Android-序列化-Serializable/Parcelable

学习自

《Android开发艺术探索》

序列化漫谈

IPC的首要目的是传输数据，当然不能仅仅是传输一些基础数据了，毕竟基础数据承载的信息非常少，传输复杂的自定义对象时肯定的，而传输对象的话，必须遵守特定的约定对对象进行序列化才行。通过将对象序列化不接可以在IPC中使用，在Intent之间也也可以传递，或者在网络上传递，或将复杂的数据持久化。

Serializable接口

Serializable 是Java提供的一个对对象进行序列化的接口，该接口是一个空接口，只需要实现它就可以完成默认的序列化。

class Person(var name: String, var age: Int, var gender: Char) : Serializable {
    companion object {
        private val serialVersionUID = 1L
    }
}/**
 * 将Person对象序列化
 * */
fun serializeObject(view: View) {
    val person = Person("LittleDavid", 20, 'M')
    val objectOutputStream = ObjectOutputStream(
        this.openFileOutput("tempPerson.txt",Context.MODE_PRIVATE))
    objectOutputStream.writeObject(person)
    objectOutputStream.flush()
}/**
 * 将对象反序列化
 * */
fun deserializeObject(view: View) {
    val objectInputStream = ObjectInputStream(this.openFileInput("tempPerson.txt"))
    val person = objectInputStream.readObject() as Person
    "Name=${person.name}; Age=${person.age}; Gender = ${person.gender}".logE()
}

上面就是序列化和反序列化的过程，在序列化的时候，我们通过ObjectOnputStream将对象写入的文件(数据持久化),在反序列化的时候，通过ObjectInputStream将对象读取出来并向下转型获取到我们序列化的对象。

你可能会感觉到奇怪，刚才还在上面说，只要实现 Serializable 接口就可以完成序列化操作，现在有多了个劳什子静态的只读变量(在Java中式静态的只读变量而在Kotlin中并没有静态这个概念，只有伴生对象这个概念)。其实不加这个字段序列化仍然可以完成，不过添加这个字段当然是有特殊的含义了。请按照下面的步骤操作:

serialVersionUID 现在是1，进行序列化
将serialVersionUID 改为2
再次运行程序，进行反序列化

在上面的步骤中，当你执行反序列化操作的时候，就会抛出下面的错误:

Caused by: java.io.InvalidClassException:
top.littledavid.studyipc.Person; local class incompatible:
stream classdesc serialVersionUID = 1, local class serialVersionUID = 2

通过上面的实验我们可以了解到，只有在 serialVersionUID 字段的值与序列化对象的该字段的值(会将该字段的值存储到序列化的内容中)与现有的类的的值进行比较如果相同才能够反序列化成功，否则抛出异常。

serialVersionUID 字段的作用是提供一个标识，表示当前类的结构并没有发生改变(比如改变数据类型，删除了某些字段，增加了某些字段等)可以放心的序列化，如果当前类的结构发生了改变，那么久应该修改该字段的值来通知类的结构已经发生了改变。

可能你记不住该字段的名称，没关系，按照 Control+Q 查看 Serializable 接口的文档即可找到该字段的说明。

Parcelable接口

Parcelable接口是Android提供的，比较适合Android平台，接下来我们来看一看。

class Person(var name: String, var age: Int, var gender: Char) : Parcelable {
    //在这里创建对象的时候，要按照写入的顺序读取值
    constructor(parcel: Parcel) : this(
            parcel.readString(),
            parcel.readInt(),
            parcel.readInt().toChar()) {
    }
    //在此方法中完成序列化
    //将值写入到parcel中
    //并不需要将所有的字段都序列化，只需要将自己所需要的序列化就行
    override fun writeToParcel(parcel: Parcel, flags: Int) {
        parcel.writeString(name)
        parcel.writeInt(age)
        parcel.writeInt(gender.toInt())
    }    override fun describeContents(): Int {
        return 0
    }    companion object CREATOR : Parcelable.Creator<Person> {
        //从序列化的对象中创建原始的对象
        override fun createFromParcel(parcel: Parcel): Person {
            return Person(parcel)
        }        override fun newArray(size: Int): Array<Person?> {
            return arrayOfNulls(size)
        }
    }
}

可见上面的代码的序列化的方式要比 Serializable 序列化的时候要复杂多了