利用Kotlin如何实现Android开发中的Parcelable详解

发布时间：2020-10-20 08:59:07 作者：Haruue Icymoon
来源：脚本之家阅读：399

坑

先来看看 Android Studio 给的自动实现。

新建一个数据类，让它实现 Parcelable

data class Worker(
  var id: Int,
  var name: String,
  var tasks: MutableList<Int>
) : Parcelable

使用 Android Studio 自带的 Add Parcelable Implementation ，然后你就得到了。。。

 data class Worker(
  var id: Int,
  var name: String,
  var tasks: MutableList<Int>
) : Parcelable {
 constructor(parcel: Parcel) : this(
   parcel.readInt(),
   parcel.readString(),
   TODO("tasks")) {
 }
 override fun writeToParcel(parcel: Parcel, flags: Int) {
  parcel.writeInt(id)
  parcel.writeString(name)
 }
 override fun describeContents(): Int {
  return 0
 }
 companion object CREATOR : Parcelable.Creator<Worker> {
  override fun createFromParcel(parcel: Parcel): Worker {
   return Worker(parcel)
  }
  override fun newArray(size: Int): Array<Worker?> {
   return arrayOfNulls(size)
  }
 }
}

有什么问题呢？

~~至少现在可以编译过了。。。~~

很明显的，自动生成的 Parcelable 实现没有包含对 MutableList 的处理，因为 Parcel 原生只支持 ArrayList ，所以这是需要你自己实现的部分。先来解决这个问题。

虽然名字是 MutableList ，但是实际上这只是 Kotlin 的一个辅助类型，可以用 Tools -> Kotlin -> Show Kotlin Bytecode 查看它编译成 JVM 字节码之后的样子。

// access flags 0x2
// signature Ljava/util/List<Ljava/lang/Integer;>;
// declaration: java.util.List<java.lang.Integer>
private Ljava/util/List; tasks
@Lorg/jetbrains/annotations/NotNull;() // invisible

点击 [Decompile] 按钮还可以直接反编译到 Java 。

编译之后 MutableList 变成了 Java 的原生类型 java.util.List 。因此我们只需要在对应的地方调用 Parcel 中对 List 和 ArrayList 的处理方法就可以了。

constructor(parcel: Parcel) : this(
  parcel.readInt(),
  parcel.readString(),
  parcel.readArrayList(Int::class.java.classLoader) as MutableList<Int>) {
}
override fun writeToParcel(parcel: Parcel, flags: Int) {
 parcel.writeInt(id)
 parcel.writeString(name)
 parcel.writeList(tasks)
}

writeList 是可以兼容 Kotlin 的 List 与 MutableList 类型的，但是 ArrayList 还需要强转一下才行，虽然能跑但是会很难看，能不能变好看一点呢？

加一个扩展方法就好了

inline fun <reified T> Parcel.readMutableList(): MutableList<T> {
 @Suppress("UNCHECKED_CAST")
 return readArrayList(T::class.java.classLoader) as MutableList<T>
}

然后就可以这样写

constructor(parcel: Parcel) : this(
  parcel.readInt(),
  parcel.readString(),
  parcel.readMutableList()) {
}
override fun writeToParcel(parcel: Parcel, flags: Int) {
 parcel.writeInt(id)
 parcel.writeString(name)
 parcel.writeList(tasks)
}

CREATOR 与 companion object 之争

Parcelable 有个特殊的要求，在 Android 官方文档里是这样写的

Parcelable interface must also have a non-null static field called CREATOR of a type that implements the Parcelable.Creator interface.

这是因为 Java 的泛型有运行时消除机制的限制， Parcel 需要一个辅助对象来协助构造你的对象以及你的对象的数组，这就是 CREATOR 。 Parcelable 要求每个实现类都有这个 CREATOR 对象，并且它必须是非空的、公有的、静态字段。在 Java 程序中，对于每个类 CREATOR 有非常稳定的实现。假如上面的例子是用 Java 写的，由于我们已经有了一个以 Parcel 为参数的构造方法，我们只需要这样实现 CREATOR 。

public static final Creator<Worker> CREATOR = new Creator<Worker>() {
 @Override
 public Worker createFromParcel(Parcel in) {
  return new Worker(in);
 }
 @Override
 public Worker[] newArray(int size) {
  return new Worker[size];
 }
};

那么在 Kotlin 中是什么样的呢，我们可以先看看 Android Studio 生成的实现：

companion object CREATOR : Parcelable.Creator<Worker> {
 override fun createFromParcel(parcel: Parcel): Worker {
  return Worker(parcel)
 }
 override fun newArray(size: Int): Array<Worker?> {
  return arrayOfNulls(size)
 }
}

在 Kotlin 中，使用命名的 companion object 确实可以生成一个对应名字的静态字段，并且它是公有的，会随着类的加载而被创建。但是一个类里只能有一个伴生对象，这个实现把伴生对象给占据了。虽然并没有什么影响的样子，但是看着总是不舒服。

通过 Kotlin 提供的 @JvmField 注解，我们可以让 Kotlin 编译器把它作为一个字段进行处理，那我们可以在 companion object 里定义一个 CREATOR ，然后给它加上 @JvmField 注解。

companion object {
 @JvmField val CREATOR = object : Parcelable.Creator<Worker> {
  override fun createFromParcel(parcel: Parcel): Worker {
   return Worker(parcel)
  }
  override fun newArray(size: Int): Array<Worker?> {
   return arrayOfNulls(size)
  }
 }
}

这样做有什么好处呢？ CREATOR 不再占据整个 companion object ，而是只是作为 companion object 中的一个字段，代码干净了很多。

此外， Kotlin 还对 inline 方法提供了 reified 泛型机制，这种泛型会被编译器直接具体化而不会像 Java 泛型一样会被运行时擦除。如果不需要太考虑效率，我们可以定义一个这样的方法。

inline fun <reified T : Parcelable> parcelableCreatorOf(): Parcelable.Creator<T> = object : Parcelable.Creator<T> {
 override fun newArray(size: Int): Array<T?> = arrayOfNulls(size)
 override fun createFromParcel(source: Parcel?): T =
   T::class.java.getDeclaredConstructor(Parcel::class.java).newInstance(source)
}

在每一个 Parcelable 实现类中就只需要一行代码了。

companion object {
 @JvmField val CREATOR = parcelableCreatorOf<Worker>()
}

End

最后，再来看看我们的 Parcelable 实现类。

data class Worker(
  var id: Int,
  var name: String,
  var tasks: MutableList<Int>
) : Parcelable {
 constructor(parcel: Parcel) : this(
   parcel.readInt(),
   parcel.readString(),
   parcel.readMutableList())
 override fun writeToParcel(parcel: Parcel, flags: Int) {
  parcel.writeInt(id)
  parcel.writeString(name)
  parcel.writeList(tasks)
 }
 override fun describeContents(): Int = 0
 companion object {
  @JvmField val CREATOR = parcelableCreatorOf<Worker>()
 }
}

本文中的关键代码，我已经封装成了一个工具类，添加依赖即可使用 -> KotlinUtils

Kotlin使用parcelable出现：BadParcelableException: Parcelable protocol requires a Parcelable.Creator...

在Kotlin编写代码过程中，需要用到parcelable来进行传值，按照以前的写法，进行序列化：

class PayTypeInfo : Parcelable{
var payMethodId: String? = null//支付方式ID
var payMethodName: String? = null//支付方式名称
override fun writeToParcel(dest: Parcel, flags: Int) {
dest.writeString(payMethodId)
dest.writeString(payMethodName)
}
override fun describeContents(): Int {
return 0
}
companion object {
val CREATOR: Parcelable.Creator<PayTypeInfo> = object : Parcelable.Creator<PayTypeInfo> {
override fun createFromParcel(source: Parcel): PayTypeInfo {
val payTypeInfo = PayTypeInfo()
payTypeInfo.payMethodId = source.readString()
payTypeInfo.payMethodName = source.readString()
return payTypeInfo
}
override fun newArray(size: Int): Array<PayTypeInfo> {
return newArray(size)
}
}
}
}

这样序列化的实体类就写完了，然后进行传值

val bundle = Bundle()
val typeList = ArrayList<PayTypeInfo>()
bundle.putParcelableArrayList("payType", typeList)

接受数据时：

val bundle = intent.extras
val payTypeList = bundle.getParcelableArrayList<PayTypeInfo>("payType")

运行程序，出现错误，错误代码为：BadParcelableException: Parcelable protocol requires a Parcelable.Creator...

经过查找资料，找到了解决办法，只需要在代码CREATOR前面添加@JvmField即可：

@JvmField val CREATOR: Parcelable.Creator<PayTypeInfo> = object : Parcelable.Creator<PayTypeInfo> {
override fun createFromParcel(source: Parcel): PayTypeInfo {
val payTypeInfo = PayTypeInfo()
payTypeInfo.payMethodId = source.readString()
payTypeInfo.payMethodName = source.readString()
return payTypeInfo
}
override fun newArray(size: Int): Array<PayTypeInfo> {
return newArray(size)
}
}

在运行程序，传值成功

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对亿速云的支持。

利用Kotlin如何实现Android开发中的Parcelable详解

相关阅读