序列化之Parcelable

序列化之Serializable
上篇文章写了Serializable，本篇则介绍Parcelable

Serializable是java的序列化方式，Parcelable是Android中推荐使用的方式，采用共享内存的方式实现用户空间和内核空间的交换，性能很好，但是实现方式比较复杂。

Parcelable与Serializable比较

Parcelable	Serizlizable
Parcelable	Serizlizable
实现Parcelable接口	实现Serizlizable接口
android 专用	Java 自带
内存消耗：低	内存消耗：一般
内存中直接进行读写	通过使用IO流的形式将数据读写入在硬盘上
不支持持久化	支持持久化
速度快	速度一般

速度上，Parcelable 比 Serializable快了10多倍

parcelable vs serializable

对比总结：

• 在使用内存的时候，Parcelable 类比Serializable性能高，推荐使用Parcelable类。
• Serializable在序列化的时候采用了大量的反射，并且会产生大量的临时变量，从而产生过高的负载，而Parcelable没有这种情况。
• Parcelable不能使用在要将数据存储在磁盘上的情况，因为Parcelable不能很好的保证数据的持续性在外界有变化的情况下。尽管Serializable效率低点， 但在这种情况下，还是要用Serializable 。

Parcelable实现类介绍

在该篇文章中，介绍了Parcelable对象的快速生成，这里就不再赘述，下面Source 类是一个标准的实现了Parcelable的类：

public class Source implements Parcelable {

    private String name;
    private String type;

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(this.name);
        dest.writeString(this.type);
    }

    public Source() {
    }

    protected Source(Parcel in) {
        this.name = in.readString();
        this.type = in.readString();
    }

    public static final Creator CREATOR = new Creator() {
        @Override
        public Source createFromParcel(Parcel source) {
            return new Source(source);
        }

        @Override
        public Source[] newArray(int size) {
            return new Source[size];
        }
    };
}

describeContents

实现Parcelable的类都需要实现这个方法，返回值一般都是0，但特殊情况下（包含 file descriptor时）需要返回1。

就是Parcelable中定义的变量。
/**
* 表示 Parcelable 对象的扁平化表示包括文件描述符。
*/
public static final int CONTENTS_FILE_DESCRIPTOR = 0x0001;

writeToParcel

writeToParcel是正在序列化的方法，内部会通过Parcel中的writeXXX方法，最终调用nativeWritexxx方法，将数据写入。

参数为Parcel的构造函数

通过Parcel的readxxx的方法，进行反序列化，顺序要和写入保持一致

CREATOR

提供方法，创建列化对象和创建对象数组

Parcel

Parcelable使用了Parcel的read和write方法，来进行序列化和反序列化。Parcel调用jni方法，将数据写入和读出。

Parce提供了基本数据类型、String的写入和读出，及其数组，和java标准集合类等。
writeValue涵盖了所有支持的类型。

    public final void writeValue(@Nullable Object v) {
        if (v == null) {
            writeInt(VAL_NULL);
        } else if (v instanceof String) {
            writeInt(VAL_STRING);
            writeString((String) v);
        } else if (v instanceof Integer) {
            writeInt(VAL_INTEGER);
            writeInt((Integer) v);
        } else if (v instanceof Map) {
            writeInt(VAL_MAP);
            writeMap((Map) v);
        } else if (v instanceof Bundle) {
            // Must be before Parcelable
            writeInt(VAL_BUNDLE);
            writeBundle((Bundle) v);
        } else if (v instanceof PersistableBundle) {
            writeInt(VAL_PERSISTABLEBUNDLE);
            writePersistableBundle((PersistableBundle) v);
        } else if (v instanceof Parcelable) {
            // IMPOTANT: cases for classes that implement Parcelable must
            // come before the Parcelable case, so that their specific VAL_*
            // types will be written.
            writeInt(VAL_PARCELABLE);
            writeParcelable((Parcelable) v, 0);
        } else if (v instanceof Short) {
            writeInt(VAL_SHORT);
            writeInt(((Short) v).intValue());
        } else if (v instanceof Long) {
            writeInt(VAL_LONG);
            writeLong((Long) v);
        } else if (v instanceof Float) {
            writeInt(VAL_FLOAT);
            writeFloat((Float) v);
        } else if (v instanceof Double) {
            writeInt(VAL_DOUBLE);
            writeDouble((Double) v);
        } else if (v instanceof Boolean) {
            writeInt(VAL_BOOLEAN);
            writeInt((Boolean) v ? 1 : 0);
        } else if (v instanceof CharSequence) {
            // Must be after String
            writeInt(VAL_CHARSEQUENCE);
            writeCharSequence((CharSequence) v);
        } else if (v instanceof List) {
            writeInt(VAL_LIST);
            writeList((List) v);
        } else if (v instanceof SparseArray) {
            writeInt(VAL_SPARSEARRAY);
            writeSparseArray((SparseArray) v);
        } else if (v instanceof boolean[]) {
            writeInt(VAL_BOOLEANARRAY);
            writeBooleanArray((boolean[]) v);
        } else if (v instanceof byte[]) {
            writeInt(VAL_BYTEARRAY);
            writeByteArray((byte[]) v);
        } else if (v instanceof String[]) {
            writeInt(VAL_STRINGARRAY);
            writeStringArray((String[]) v);
        } else if (v instanceof CharSequence[]) {
            // Must be after String[] and before Object[]
            writeInt(VAL_CHARSEQUENCEARRAY);
            writeCharSequenceArray((CharSequence[]) v);
        } else if (v instanceof IBinder) {
            writeInt(VAL_IBINDER);
            writeStrongBinder((IBinder) v);
        } else if (v instanceof Parcelable[]) {
            writeInt(VAL_PARCELABLEARRAY);
            writeParcelableArray((Parcelable[]) v, 0);
        } else if (v instanceof int[]) {
            writeInt(VAL_INTARRAY);
            writeIntArray((int[]) v);
        } else if (v instanceof long[]) {
            writeInt(VAL_LONGARRAY);
            writeLongArray((long[]) v);
        } else if (v instanceof Byte) {
            writeInt(VAL_BYTE);
            writeInt((Byte) v);
        } else if (v instanceof Size) {
            writeInt(VAL_SIZE);
            writeSize((Size) v);
        } else if (v instanceof SizeF) {
            writeInt(VAL_SIZEF);
            writeSizeF((SizeF) v);
        } else if (v instanceof double[]) {
            writeInt(VAL_DOUBLEARRAY);
            writeDoubleArray((double[]) v);
        } else {
            Class clazz = v.getClass();
            if (clazz.isArray() && clazz.getComponentType() == Object.class) {
                // Only pure Object[] are written here, Other arrays of non-primitive types are
                // handled by serialization as this does not record the component type.
                writeInt(VAL_OBJECTARRAY);
                writeArray((Object[]) v);
            } else if (v instanceof Serializable) {
                // Must be last
                writeInt(VAL_SERIALIZABLE);
                writeSerializable((Serializable) v);
            } else {
                throw new RuntimeException("Parcel: unable to marshal value " + v);
            }
        }
    }

Parcel内部维持了一个缓存，因此建议使用Parcel.obtain()来获取Parcel

Parce包含大量write、read、native方法，native通过一个指针对数据进行读和写，通过不同的

要进一步分析Parcels的工作原理，涉及到binder机制

参考：
https://www.cnblogs.com/wytiger/p/12875640.html