一、介绍

注解序列化篇：Android kotlin序列化之@Parcelize详解与使用_蜗牛、Z的博客-CSDN博客

通过上一篇注解序列化，我们已了解的kotlin的序列化比Java复杂了很多。而且有好多问题，注解虽好，但是存在一些问题。

一般在大型商业项目开发过程中，我们不仅追求极致的开发技术，更重视软件质量。过于风骚的技术同样有潜在的风险，这个时候我们还是回到本质。

二、手写Parcelable序列化

这边直接上代码：

class Car(var logo:String?="") :Parcelable{
    var name:String?=""
    var numbe:Int=0

    constructor(parcel: Parcel) : this(parcel.readString()) {
        name = parcel.readString()
        numbe = parcel.readInt()
    }

    override fun writeToParcel(parcel: Parcel, flags: Int) {
        parcel.writeString(logo)
        parcel.writeString(name)
        parcel.writeInt(numbe)
    }

    override fun describeContents(): Int {
        return 0
    }

    companion object CREATOR : Parcelable.Creator<Car> {
        override fun createFromParcel(parcel: Parcel): Car {
            return Car(parcel)
        }

        override fun newArray(size: Int): Array<Car?> {
            return arrayOfNulls(size)
        }
    }


}

只要继承Parcelable，IDE可以自动完成，接下来就是测试。

关于CREATOR 写法有两种

1、第一种


    companion object CREATOR : Parcelable.Creator<Car> {
        override fun createFromParcel(parcel: Parcel): Car {
            return Car(parcel)
        }

        override fun newArray(size: Int): Array<Car?> {
            return arrayOfNulls(size)
        }
    }

2、第二种

    companion object {
        @JvmField
        val CREATOR = object : Parcelable.Creator<Car> {
            override fun createFromParcel(parcel: Parcel): Car {
                return Car(parcel)
            }

            override fun newArray(size: Int): Array<Car?> {
                return arrayOfNulls(size)
            }
        }
    }

如果你的类中需要有其他方法加入伴生对象中，当前采用第一种无法扩展，因为一个类中只能有一个伴生对象，所以建议第二种写法。

三、复杂类序列化

简单类很好处理，即使使用注解也能完成，但是复杂对象的封装，注解存在问题。这就是我们为什么用原生继承写法。

Demo：

class TestCar() :Parcelable{
    var car:Car?=null
    var list= mutableListOf<Car>()

    constructor(parcel: Parcel) : this() {
        car = parcel.readParcelable(Car::class.java.classLoader)
        parcel.readTypedList(list,Car.CREATOR)
    }

    @RequiresApi(Build.VERSION_CODES.Q)
    override fun writeToParcel(parcel: Parcel, flags: Int) {
        parcel.writeParcelable(car, flags)
        parcel.writeTypedList(list)
    }

    override fun describeContents(): Int {
        return 0
    }

    companion object CREATOR : Parcelable.Creator<TestCar> {
        override fun createFromParcel(parcel: Parcel): TestCar {
            return TestCar(parcel)
        }

        override fun newArray(size: Int): Array<TestCar?> {
            return arrayOfNulls(size)
        }
    }


}

这样我们就完成了复杂的对象封装。