序列化之Serializable与Parcelable

序列化定义

在java中，序列化就是让对象变成字节序列，来进行传输或储存；相反地，把字节序列变对象，叫反序列化。

Serializable实现序列化

1. 一个类实现了Serializable接口，并写了serialVersionUID，就可正常进行序列化。如下：

public class Source implements Serializable {

    private static final long serialVersionUID = 6067841943119850745L;
    
    private String name;
    private String type;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

2. 调用ObjectOutputStream的writeObject方法进行序列化

//要序列化的对象
Source source = new Source();
source.setName("gallery");
source.setType("png");

//保存本地文件路径
File file = new File(getFilesDir().getPath() + File.separator + "source");
if (!file.exists()) {
    file.mkdir();
}
//创建ObjectOutputStream
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
//调用writeObject (writexxx)
oos.writeObject(source);
//关闭
oos.close();

3. 调用ObjectInputStream的readObject方法接口来反序列化

//创建ObjectInputStream
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
//调用readObject
Source source1 = (Source) ois.readObject();
//关闭
ois.close();

序列化和反序列化的过程比较简单，Serializable的作用只是一个标记，writeObject方法中会判断是否是是 instanceof Serializable

这是流程图，可以先大概看下，后面源码分析完后再回头看

源码分析

writeObject(Object obj) -> writeObject0(Object obj, boolean unshared)

    private void writeObject0(Object obj, boolean unshared)
        throws IOException
    {
        ……
            } else if (obj instanceof Serializable) {
                writeOrdinaryObject(obj, desc, unshared);
            } else {
                 ……
            }
        } f
    }

writeOrdinaryObject 开始写入

private void writeOrdinaryObject(Object obj,
                                 ObjectStreamClass desc,
                                 boolean unshared)
    throws IOException
{
   ……
        desc.checkSerialize();
        //开始写入的标记TC_OBJECT
        bout.writeByte(TC_OBJECT);
        //写入类的描述符
        writeClassDesc(desc, false);
        ……
       //写入需要序列化的数据
        writeSerialData(obj, desc);
 ……
    }
}

writeClassDesc 正常调用到（非动态代理） writeNonProxyDesc

    private void writeClassDesc(ObjectStreamClass desc, boolean unshared)
        throws IOException
    {
        int handle;
        if (desc == null) {
            writeNull();
        }     ……
        else {
            writeNonProxyDesc(desc, unshared);
        }
    }

    private void writeNonProxyDesc(ObjectStreamClass desc, boolean unshared)
        throws IOException
    {
        //标记开始写入类描述
        bout.writeByte(TC_CLASSDESC);
        ……
        //真正写入类描述
        desc.writeNonProxy(this);
        ……
        //标记结束写入类描述
        bout.writeByte(TC_ENDBLOCKDATA);
        ……
        //循环写入父类的描述，知道父类为null
        writeClassDesc(desc.getSuperDesc(), false);
    }

writeNonProxy中写入了类名，serialVersionUID，标记，字段类型、字段名等信息 serialVersionUID 是唯一识别码，序列化前后发送变化，则反序列化会失败，如果用户赋值，则会调用computeDefaultSUID方法计算，计算过程比较复杂，会被字段方法等影响，如当序列化前后，类的字段方式变化，则自动计算的suid会不一样，导致序列化失败，因此serialVersionUID 需要写上。

    void writeNonProxy(ObjectOutputStream out) throws IOException {
        out.writeUTF(name);
        out.writeLong(getSerialVersionUID());

        byte flags = 0;
         ……
            flags |= ObjectStreamConstants.SC_SERIALIZABLE;
         ……
        out.writeByte(flags);

        out.writeShort(fields.length);
        for (int i = 0; i < fields.length; i++) {
            ObjectStreamField f = fields[i];
            out.writeByte(f.getTypeCode());
            out.writeUTF(f.getName());
            if (!f.isPrimitive()) {
                out.writeTypeString(f.getTypeString());
            }
        }
    }

writeClassDesc类描述完成后接着 writeSerialData

    private void writeSerialData(Object obj, ObjectStreamClass desc)
        throws IOException
    {
        //类描述符相关数组，父类排在前面
        ObjectStreamClass.ClassDataSlot[] slots = desc.getClassDataLayout();
        for (int i = 0; i < slots.length; i++) {
            ObjectStreamClass slotDesc = slots[i].desc;
            if (slotDesc.hasWriteObjectMethod()) {
              //如果这个类自己写了writeObject 方法，就走这里
              ……
            } else {
                //这个类没写writeObject 方法，调用默认
                defaultWriteFields(obj, slotDesc);
            }
        }
    }

defaultWriteFields 里面区分了基本数据类型和非基本数据类型，基本数据类型直接写，非基本类型会调用writeObject0，重复上面的步骤。

另外static和transient(瞬时状态)修饰的字段不可序列化

private void defaultWriteFields(Object obj, ObjectStreamClass desc)
        throws IOException
    {
        ……
        //获取对象obj的可序列化的基本类型(byte、short、int、long、float、double...)字段值，并将其编组为从偏移量0开始的字节数组buf。
        desc.getPrimFieldValues(obj, primVals);
        bout.write(primVals, 0, primDataSize, false);
        //获取所有可序列化的字段，其中调到getDefaultSerialFields，里面过滤了static和transient修饰的字段(Modifier.STATIC | Modifier.TRANSIENT)，也就是static和transient修饰的字段不可序列化
        ObjectStreamField[] fields = desc.getFields(false);
        //返回所表示类的非基本数据类型可序列化字段数组。非基本类型的字段需要再次走writeObject0方法，进一步序列化
        //这个非基本数据类型的字段也必须是可序列化的，也即继承serializable，否则，会导致此类不能序列化
        Object[] objVals = new Object[desc.getNumObjFields()];
        //获取对象obj的可序列化的对象字段值，并将它们存储在从偏移量0开始的数组vals中。
        desc.getObjFieldValues(obj, objVals);
        for (int i = 0; i < objVals.length; i++) {
            ……
            try {
                writeObject0(objVals[i],
                             fields[numPrimFields + i].isUnshared());
            } finally {
                ……
            }
        }
    }

自定义序列化过程

上面分析的过程都是使用了默认的序列化，其实在实现了接口的序列化时，可以有一些自定义的方法

查看ObjectStreamClass中的字段，发现有五个可以自动定义的方法

    /** class-defined writeObject method, or null if none */
    private Method writeObjectMethod;
    /** class-defined readObject method, or null if none */
    private Method readObjectMethod;
    /** class-defined readObjectNoData method, or null if none */
    private Method readObjectNoDataMethod;
    /** class-defined writeReplace method, or null if none */
    private Method writeReplaceMethod;
    /** class-defined readResolve method, or null if none */
    private Method readResolveMethod;

通过查看其反射获取，可以定义出

//getPrivateMethod 是获取私有非静态方法
writeObjectMethod = getPrivateMethod(cl, "writeObject", new Class<?>[] { ObjectOutputStream.class },Void.TYPE);
readObjectMethod = getPrivateMethod(cl, "readObject", new Class<?>[] { ObjectInputStream.class },Void.TYPE);
readObjectNoDataMethod = getPrivateMethod( cl, "readObjectNoData", null, Void.TYPE);

//getInheritableMethod 获取非静态，非抽象，共有和保护类方法可以从父类中查找，私有只能从本类中查找
writeReplaceMethod = getInheritableMethod(cl, "writeReplace", null, Object.class);
readResolveMethod = getInheritableMethod(cl, "readResolve", null, Object.class);

结合源码： 序列化时：先调用writeReplace，再调用writeObject 反序列化时：先调用readObject，为空时调用readObjectNoData，最后调用readResolve

• 如果一个序列化类中含有writeReplace()方法，那么实际序列化的对象将是作为writeReplace方法返回值的对象
• 如果一个序列化类中含有writeObject()方法，那么具体序列化的过程就使用writeObject()里的。
• 如果一个序列化类中含有readObject()方法，那么具体反序列化的过程就使用readObject()里的。
• 如果一个序列化类中含有readResolve()方法，那么实际反序列化的最终结果就是readResolve返回值的值。
• 如果一个序列化类中含有readObjectNoData()方法，那么当字段获取到的序列化结果为空时，就使用该方法返回的值，一般是类进行了修改。

readObjectNoData的触发时机说明： 如果开始序列化时，Source继承Source2，Source2里有name和type字段。 要反序列化时，Source发生改变，由继承Source2变为继承Source3，Source3里有name和type和age字段。 Source3写了readObjectNoData方法，那么在进行反序列化时，就会被触发，一般的做法是给age设置个默认值。

    private Object writeReplace() {

    }

   private void writeObject(ObjectOutputStream oos) throws IOException {
        oos.writeObject(getName());
        oos.writeObject(getType());
    }

    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
        setName((String) ois.readObject());
        setType((String) ois.readObject());
    }

    private void readObjectNoData() {

    }

    private Object readResolve() {

    }

HashMap中的自定义序列化

HashMap是写了writeObject和readObject方法来自定义序列化，并且使用了transient来修饰table，我们知道HashMap是“数组”+“链表/红黑树”的形式，这个table就是存放数据的数组;HashMap计算出hash值，再计算出一个索引值，来从table中存、取数据，

HashMap计算 hash 时最终调用 Object 中的 hashCode 方法。但 Object 中的 hashCode 方法是 native 型的，不同的 JVM 下，可能会有不同的实现，产生的 hash 可能也是不一样的。

因此，在不同的虚拟机中进行反序列化，在用get方法，因为索引值可能不同，所以可能获取不到数据。

另外，table 多数情况下是无法被存满的，序列化未使用的部分，浪费空间。

可外化接口 Externalizable

public interface Externalizable extends java.io.Serializable {
   // 序列化
    void writeExternal(ObjectOutput out) throws IOException;
    //反序列化
    void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}

Externalizable是继承了Serializable的，采用Externalizable无需产生序列化ID，但需要复写上面两个序列化和反序列化接口和一个无参的构造函数。Externalizable是一种自定义序列化，writeExternal的功能类似Serializable的writeObject，readExternal与readObject类似。

查看writeObject0的方法，在创建desc的过程中，调用过了

ObjectStreamClass.lookup —> new ObjectStreamClass -> getExternalizableConstructor;

private static Constructor<?> getExternalizableConstructor(Class<?> cl) {
    try {
        Constructor<?> cons = cl.getDeclaredConstructor((Class<?>[]) null);
        cons.setAccessible(true);
        return ((cons.getModifiers() & Modifier.PUBLIC) != 0) ?
            cons : null;
    } catch (NoSuchMethodException ex) {
        return null;
    }
}

代码中，调用writeClassDesc后，接下去做了一个判断，如果是isExternalizable，且不是代理，则调用writeExternalData

if (desc.isExternalizable() && !desc.isProxy()) {
    writeExternalData((Externalizable) obj);
} else {
    writeSerialData(obj, desc);
}

writeExternalData中就调用过了Externalizable的writeExternal方法

    private void writeExternalData(Externalizable obj) throws IOException {
        ……
                obj.writeExternal(this);
       ……
    }

Parcelable实现序列化

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

Parcelable与Serializable比较

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

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

对比总结：

• 在使用内存的时候，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<Source> CREATOR = new Creator<Source>() {
        @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的工作原理，mmap内存映射（待续）

参考:

• www.cnblogs.com/dgwblog/p/1…
• www.cnblogs.com/wytiger/p/1…