解析Serializable原理

前言

通常我们使用Java的序列化与反序列化时，只需要将类实现Serializable接口即可，剩下的事情就交给了jdk。今天我们就来探究一下，Java序列化是怎么实现的，然后探讨一下几个常见的集合类，他们是如何处理序列化带来的问题的。

分析过程

几个待思考的问题

1. 为什么序列化一个对象时，仅需要实现Serializable接口就可以了。
2. 通常我们序列化一个类时，为什么推荐的做法是要实现一个静态final成员变量serialVersionUID。
3. 序列化机制是怎么忽略transient关键字的, static变量也不会被序列化。

接下来我们就带着问题，在源码中找寻答案吧。

Serializable

先看Serializable接口，源码很简单，一个空的接口，没有方法也没有成员变量。但是注释非常详细，很清楚的描述了Serializable怎么用、能做什么，很值得一看，我们捡几个重点的翻译一下，

/** * Serializability of a class is enabled by the class implementing the * java.io.Serializable interface. Classes that do not implement this * interface will not have any of their state serialized or * deserialized. All subtypes of a serializable class are themselves * serializable. The serialization interface has no methods or fields * and serves only to identify the semantics of being serializable. */

类的可序列化性通过实现java.io.Serializable接口开启。未实现序列化接口的类不能序列化，所有实现了序列化的子类都可以被序列化。Serializable接口没有方法和属性，只是一个识别类可被序列化的标志。

/** * Classes that require special handling during the serialization and * deserialization process must implement special methods with these exact * signatures: * * <PRE> * private void writeObject(java.io.ObjectOutputStream out) * throws IOException * private void readObject(java.io.ObjectInputStream in) * throws IOException, ClassNotFoundException; * private void readObjectNoData() * throws ObjectStreamException; * </PRE> */ 

在序列化过程中，如果类想要做一些特殊处理，可以通过实现以下方法writeObject(), readObject(), readObjectNoData()，其中，

• writeObject方法负责为其特定类写入对象的状态，以便相应的readObject()方法可以还原它。
• readObject()方法负责从流中读取并恢复类字段。
• 如果某个超类不支持序列化，但又不希望使用默认值怎么办？writeReplace() 方法可以使对象被写入流之前，用一个对象来替换自己。
• readResolve()通常在单例模式中使用，对象从流中被读出时，可以用一个对象替换另一个对象。

ObjectOutputStream

    //我们要序列化对象的方法实现一般都是在这个函数中
    public final void writeObject(Object obj) throws IOException {
        ...
        try {
            //写入的具体实现方法
            writeObject0(obj, false);
        } catch (IOException ex) {
            ...
            throw ex;
        }
    }
    
    private void writeObject0(Object obj, boolean unshared) throws IOException {
        ...省略
        
        Object orig = obj;
            Class<?> cl = obj.getClass();
            ObjectStreamClass desc;
            for (;;) {
                // REMIND: skip this check for strings/arrays?
                Class<?> repCl;
                //获取到ObjectStreamClass，这个类很重要
                //在它的构造函数初始化时会调用获取类属性的函数
                //最终会调用getDefaultSerialFields这个方法
                //在其中通过flag过滤掉类的某一个为transient或static的属性(解释了问题3)
                desc = ObjectStreamClass.lookup(cl, true);
                if (!desc.hasWriteReplaceMethod() ||
                    (obj = desc.invokeWriteReplace(obj)) == null ||
                    (repCl = obj.getClass()) == cl)
                {
                    break;
                }
                cl = repCl;
        }
            
        //其中主要的写入逻辑如下
        //String, Array, Enum本身处理了序列化
        if (obj instanceof String) {
            writeString((String) obj, unshared);
        } else if (cl.isArray()) {
            writeArray(obj, desc, unshared);
        } else if (obj instanceof Enum) {
            writeEnum((Enum<?>) obj, desc, unshared);
            //重点在这里，通过`instanceof`判断对象是否为`Serializable`
            //这也就是普通自己定义的类如果没有实现`Serializable`
            //在序列化的时候会抛出异常的原因(解释了问题1)
        } else if (obj instanceof Serializable) {
            writeOrdinaryObject(obj, desc, unshared);
        } else {
            if (extendedDebugInfo) {
                throw new NotSerializableException(
                    cl.getName() + "\n" + debugInfoStack.toString());
            } else {
                throw new NotSerializableException(cl.getName());
            }
        }
        ...
    }

    private void writeOrdinaryObject(Object obj,
                                     ObjectStreamClass desc,
                                     boolean unshared)
        throws IOException
    {
        ...
        try {
            desc.checkSerialize();
            
            //写入二进制文件，普通对象开头的魔数0x73
            bout.writeByte(TC_OBJECT);
            //写入对应的类的描述符，见底下源码
            writeClassDesc(desc, false);
            
            handles.assign(unshared ? null : obj);
            if (desc.isExternalizable() && !desc.isProxy()) {
                writeExternalData((Externalizable) obj);
            } else {
                writeSerialData(obj, desc);
            }
        } finally {
            if (extendedDebugInfo) {
                debugInfoStack.pop();
            }
        }
    }
    
    private void writeClassDesc(ObjectStreamClass desc, boolean unshared)
        throws IOException
    {
        //句柄
        int handle;
        //null描述
        if (desc == null) {
            writeNull();
            //类对象引用句柄
            //如果流中已经存在句柄，则直接拿来用，提高序列化效率
        } else if (!unshared && (handle = handles.lookup(desc)) != -1) {
            writeHandle(handle);
            //动态代理类描述符
        } else if (desc.isProxy()) {
            writeProxyDesc(desc, unshared);
            //普通类描述符
        } else {
            //该方法会调用desc.writeNonProxy(this)如下
            writeNonProxyDesc(desc, unshared);
        }
    }
    
    void writeNonProxy(ObjectOutputStream out) throws IOException {
        out.writeUTF(name);
        //写入serialVersionUID
        out.writeLong(getSerialVersionUID());
        ...
    }
    
    public long getSerialVersionUID() {
        // 如果没有定义serialVersionUID
        // 序列化机制就会调用一个函数根据类内部的属性等计算出一个hash值
        // 这也是为什么不推荐序列化的时候不自己定义serialVersionUID的原因
        // 因为这个hash值是根据类的变化而变化的
        // 如果你新增了一个属性，那么之前那些被序列化后的二进制文件将不能反序列化回来，Java会抛出异常
        // (解释了问题2)
        if (suid == null) {
            suid = AccessController.doPrivileged(
                new PrivilegedAction<Long>() {
                    public Long run() {
                        return computeDefaultSUID(cl);
                    }
                }
            );
        }
        //已经定义了SerialVersionUID，直接获取
        return suid.longValue();
    }

    //分析到这里，要插一个我对序列化后二进制文件的一点个人见解，见下面

序列化后二进制文件的一点解读

如果我们要序列化一个List<PhoneItem>, 其中PhoneItem如下，

class PhoneItem implements Serializable {
    String phoneNumber;
}

构造List的代码省略，假设我们序列化了一个size为5的List，查看二进制文件大概如下所示，

7372 xxxx xxxx 
7371 xxxx xxxx 
7371 xxxx xxxx 
7371 xxxx xxxx 
7371 xxxx xxxx 

通过刚才的源码解读，开头的魔数0x73表示普通对象，72表示类的描述符号，71表示类描述符为引用类型。管中窥豹可知一点薄见，在解析二进制文件的时候，就是通过匹配魔数 (magic number) 开头方式，从而转换成Java对象的。当在序列化过程中，如果流中已经有同样的对象，那么之后的序列化可以直接获取该类对象句柄，变为引用类型，从而提高序列化效率。

    //通过writeSerialData调用走到真正解析类的方法中，有没有复写writeObject处理的逻辑不太一样
    //这里以默认没有复写writeObject为例，最后会调用defaultWriteFields方法
    private void defaultWriteFields(Object obj, ObjectStreamClass desc)
        throws IOException
    {
        ...
        int primDataSize = desc.getPrimDataSize();
        if (primVals == null || primVals.length < primDataSize) {
            primVals = new byte[primDataSize];
        }
        desc.getPrimFieldValues(obj, primVals);
        //写入属性大小
        bout.write(primVals, 0, primDataSize, false);

        ObjectStreamField[] fields = desc.getFields(false);
        Object[] objVals = new Object[desc.getNumObjFields()];
        int numPrimFields = fields.length - objVals.length;
        desc.getObjFieldValues(obj, objVals);
        for (int i = 0; i < objVals.length; i++) {
            ...
            try {
                //遍历写入属性类型和属性大小
                writeObject0(objVals[i],
                             fields[numPrimFields + i].isUnshared());
            } finally {
                if (extendedDebugInfo) {
                    debugInfoStack.pop();
                }
            }
        }
    }

由于反序列化过程和序列化过程类似，这里不再赘述。

常见的集合类的序列化问题

HashMap

Java要求被反序列化后的对象要与被序列化之前的对象保持一致，但因为hashmap的key是通过hash计算的。反序列化后计算得到的值可能不一致(反序列化在不同的jvm环境下执行)。所以HashMap需要重写序列化实现的过程，避免出现这种不一致的情况。

具体操作是将要自定义处理的属性定义为transient，然后复写writeObject，在其中做特殊处理

    private void writeObject(java.io.ObjectOutputStream s)
        throws IOException {
        int buckets = capacity();
        // Write out the threshold, loadfactor, and any hidden stuff
        s.defaultWriteObject();
        //写入hash桶的容量
        s.writeInt(buckets);
        //写入k-v的大小
        s.writeInt(size);
        //遍历写入不为空的k-v
        internalWriteEntries(s);
    }

ArrayList

因为在ArrayList中的数组容量基本上都会比实际的元素的数大, 为了避免序列化没有元素的数组而重写writeObject和readObject

    private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
        ...
        s.defaultWriteObject();

        // 写入arraylist当前的大小
        s.writeInt(size);

        // 按照相同顺序写入元素
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }
        ...
    }