Serializable是怎么一回事

前言

在Java中，Serializable作为一种序列化手段最为方便不过，其使用成本之低，使在完全不了解它原理的情况下，均可正常使用。

需要序列化的场景很多，当涉及如果将数据从一个地方，有效地传输到另一个地方，就可涉及到序列化的使用。侧重于目标不同，实现的序列化方式也就不同，Serializable作为出镜率超高的序列化手段，自然有不同于其他序列化方式的地方。本文也主要讲出自己对于Serializable的理解，通过本文，可以得知：

• 什么是对象序列化
• Serializable如何实现
• Serializable如何存储
• Serializable有什么使用技巧

如果以上问题你不知道答案，本文或许有些帮助。

什么是对象序列化

简单来说，对象序列化，就是把运行时的对象信息，按照一定的规则，翻译成一串有迹可循的二进制流，然后将此二进制流，传输到从一方传输到另一方。而在接收方，在接受到此二进制流之后，可以按照约定好的解析规则，进行反序列化，将对象信息解析出来，得到有用的数据信息。

对象信息，包括Class信息、继承关系、访问权限、变量类型以及数值信息等。因此，序列化后得到的二进制流，不仅仅包含了描述一个对象的Class的关键信息，也存储了具有实际意义的数值信息。因此，序列化可以描述为——转述对象信息，存储对象数据。

Serializable如何实现

既然如此，那么Serializable是如何实现序列化的呢？

对于使用来说，我们仅需要通过声明实现Serializable接口，即可使用。如果再顺嘴问一下，Serializable怎么实现，绝大多数人都能脱口而出，使用反射使用。如果再深入地问下去，为什么要使用反射实现，不少人会哑火。

在进入真正的源码讲解之前，不妨假设，如果让你来写Serializable，你会如何实现？

开发者写出的对象千差万别，并且对于Serializable的使用说来，也不会提供更多的信息。但是可以知道，每一个对象的类信息可以用一个对应的Class类型来进行描述，其中Class类型包含了一个类所的方法，成员属性，作用域，访问权限，继承关系等。每一种类型都是Object的子类，并且在运行时，可以通过对象，访问到存储于heep中的对象数据。

既然如此，当得拿到一个将要进行序列化的对象时，可以通过反射的手段提取信息。如果将一个对象视为根节点，那么一个对象的所有信息，可以粗略地用下面一课树来表示：

对象信息树.png

上图中，Class节点可以继续往下分解，直到为Object类型。

那么剩下的问题，就是如何通过反射，遍历这棵树，提取并存储关键信息了。

ObjectStreamClass

Serializable中，使用ObjectStreamClass来描述一种对象的存在。在ObjectStreamClass中，除了Serializable提供的此对象类型可以实现以达到其他目的的几个方法外，并不关心所包含的其他方法。因为对于将要序列化传输的对象来说，关心他的数据结构，以及各属性的基础属性值。

ObjectStreamClass接受Class类型作为参数进行实例话，并提取各层信息

    private ObjectStreamClass(final Class cl) {
        // 代表的类类型
        this.cl = cl;
        // 类名
        name = cl.getName();
        // 是否是动态代理产生的类
        isProxy = Proxy.isProxyClass(cl);
        // 是否是Enum
        isEnum = Enum.class.isAssignableFrom(cl);
        // 是否实现了 serializable
        serializable = Serializable.class.isAssignableFrom(cl);
        // 是否实现了 externalizable
        externalizable = Externalizable.class.isAssignableFrom(cl);

        // 父类类型
        Class superCl = cl.getSuperclass();
        // superDesc是一个ObjectStreamClass，代表父类的描述
        superDesc = (superCl != null) ? lookup(superCl, false) : null;
        // 指向自己的ObjectStreamClass
        localDesc = this;

        if (serializable) {
            AccessController.doPrivileged(new PrivilegedAction() {
                public Void run() {
                    if (isEnum) {
                        // serialVersionUID
                        suid = Long.valueOf(0);
                        // Enum没有属性
                        fields = NO_FIELDS;
                        return null;
                    }
                    if (cl.isArray()) {
                        // 为集合的话，没有属性
                        fields = NO_FIELDS;
                        return null;
                    }
                    
                    // 获取serialVersionUID
                    suid = getDeclaredSUID(cl);
                    try {
                        // 获取此类所有需要被序列化的属性，即Filed
                        fields = getSerialFields(cl);
                        computeFieldOffsets();
                    } catch (InvalidClassException e) {
                        serializeEx = deserializeEx =
                            new ExceptionInfo(e.classname, e.getMessage());
                        fields = NO_FIELDS;
                    }
                    
                    if (externalizable) {
                        // 实现了Enternalizable则反射获取构造方法
                        cons = getExternalizableConstructor(cl);
                    } else {
                        // 反射获取构造方法
                        cons = getSerializableConstructor(cl);
                        // 反射获取writeObject方法，实现了则有
                        writeObjectMethod = getPrivateMethod(cl, "writeObject",
                            new Class[] { ObjectOutputStream.class },
                            Void.TYPE);
                        // 反射获取readObject方法，实现了则有
                        readObjectMethod = getPrivateMethod(cl, "readObject",
                            new Class[] { ObjectInputStream.class },
                            Void.TYPE);
                        // 反射获取readObjectNoData方法，实现了则有
                        readObjectNoDataMethod = getPrivateMethod(
                            cl, "readObjectNoData", null, Void.TYPE);
                        hasWriteObjectData = (writeObjectMethod != null);
                    }
                    
                    // 反射获取是否实现了 writeReplace，实现了则有
                    writeReplaceMethod = getInheritableMethod(
                        cl, "writeReplace", null, Object.class);
                    // 反射获取是否实现了 writeReplace，实现了则有
                    readResolveMethod = getInheritableMethod(
                        cl, "readResolve", null, Object.class);
                    return null;
                }
            });
        } else {
            suid = Long.valueOf(0);
            fields = NO_FIELDS;
        }
        ......
    }

ObjectStreamClass的实例化过程可看到的关键点为：

• Enum和集合类型是不会收集FIELDS的
• 会获取自定义的serialVersionUID，没有则生成
• 成员属性以ObjectStreamField来表示，通过getSerialFields()来获取，在此方法中，先通过getDeclaredSerialFields()先尝试获取通过变量serialPersistentFields声明的要进行序列化的成员属性，如果获取不到则通过getDefaultSerialFields()反射获取类型中声明的成员属性

看一眼getDefaultSerialFields()

    private static ObjectStreamField[] getDefaultSerialFields(Class cl) {
        // 获取所有 Field
        Field[] clFields = cl.getDeclaredFields();
        ArrayList list = new ArrayList<>();
        // static 和 transient 的掩码
        int mask = Modifier.STATIC | Modifier.TRANSIENT;

        for (int i = 0; i < clFields.length; i++) {
            if ((clFields[i].getModifiers() & mask) == 0) {
                // 添加所有不被声明为 STATIC或 TRANSIENT 的 FIELD，以ObjectStreamField来描述
                list.add(new ObjectStreamField(clFields[i], false, true));
            }
        }
        int size = list.size();
        return (size == 0) ? NO_FIELDS :
            list.toArray(new ObjectStreamField[size]);
    }

获取其他各种信息也主要通过反射来获取。上文源码中看到的一些方法：

• writeObject()
• readObject()
• readObjectNoData()
• writeReplace()
• readResolve()

即是Serializable提供的一些可自定义操作的方法入口，在下文中会提到。

ObjectStreamField

ObjectStreamClass用来描述一个对象，对象有属性。ObjectStreamField则描述了属性信息。

ObjectStreamField的结构相对简单不少，它只需要描述一个对象的属性信息

    ObjectStreamField(Field field, boolean unshared, boolean showType) {
        // 反射中代表属性的类，Field
        this.field = field;
        this.unshared = unshared;
        // 属性名
        name = field.getName();
        // 属性的类类型，因为类的类型信息由ObjectStreamClass保存，因此只要知道类型即可
        Class ftype = field.getType();
        // 此属性的类型，是基本类型，或者是对象类型
        type = (showType || ftype.isPrimitive()) ? ftype : Object.class;
        // 获取类标识符
        signature = getClassSignature(ftype).intern();
    }

signature记录类标识符，类标识符是指用一串字符串来表示一种类型，在当前上下文中为：

• I: Integer
• B: Byte
• J: Long
• F: Float
• D: Double
• S: Short
• C: Character
• Z: Boolean
• V: Void
• L...: 引用类型

L...用来表示引用类型，假如有类为com.qinx.Example，则类标识符为: L/com/qinx/Example .

HandleTable

HandleTable是Serializable中的缓存池，在序列化或者反序列化是，当遇到同一种信息时，如果缓存池中有缓存信息，则可以减少很多不必要的解析，引用到缓存池的那个信息即可。以序列化时为列，会缓存下来的信息有：

• Class
• ObjectStreamClass
• String
• Array
• Enum

HandleTable源码可不深究，仅了解作用也可。

实际上，有了上面提到ObjectStreamClass、ObjectStreamField、HandleTable以及前面提到的从一个对象中提取信息的思路，Serializable的实现能猜出个雏型。因为，知道了获取信息的思路，对象和属性的表示方式，以及过程中减少解析的手段。下一小节则是源码过程。

ObjectOutputStream

序列化的入口类为ObjectOutputStream

    public ObjectOutputStream(OutputStream out) throws IOException {
        // 校验继承权限
        verifySubclass();
        // 构造类型为BlockDataOutputStream的OutputStream，解析过程中的数据会先写入bout，经过一些处理后，写入out
        bout = new BlockDataOutputStream(out);
        // 缓存
        handles = new HandleTable(10, (float) 3.00);
        // 替换表，在解析过程中，可以通过ObjectOutputStream提供的一些入口，来替换一些对象
        subs = new ReplaceTable(10, (float) 3.00);
        // 如果这个变量为true时，意味着需要重写writeObjectOverride()
        enableOverride = false;
        // 向bout先写入魔数以及版本号
        writeStreamHeader();
        // 设置BlockDataOutputStream的模式，为true则数据显写入bout
        bout.setBlockDataMode(true);
        ......
    }

序列化的入口方法为writeObject()

    public final void writeObject(Object obj) throws IOException {
        if (enableOverride) {
        //  enableOverride为前面所说，也就是当自定义ObjectOutputStream并使用无参构造时，需要重写writeObjectOverride()来做序列化工作。
            writeObjectOverride(obj);
            return;
        }
        try {
            writeObject0(obj, false);
        } catch (IOException ex) {
            if (depth == 0) {
            // 说明遍历信息的方式有错误
                writeFatalException(ex);
            }
            throw ex;
        }
    }

一般来说，使用ObjectOutputStream()有参构造，走writeObject0()来实现序列化。还记得前面说过的提取对象信息的思路吗， 这里看到的变量depth，也就是当前遍历这颗树的节点所处的深度。

下面的源码有点长，耐心看

       boolean oldMode = bout.setBlockDataMode(false);
        depth++;
        try {
            // handle previously written and non-replaceable objects
            int h;
            if ((obj = subs.lookup(obj)) == null) {
                // 处理需要被替换的对象，如果obj不需要被替换，subs.lookup()会返回obj本身，而如果当obj需要被替换，会出现被替换为null的情况
                // 这里是写入null
                writeNull();
                return;
            } else if (!unshared && (h = handles.lookup(obj)) != -1) {
                // 如果obj已经被解析过， 写入索引信息就好，不需要重复解析
                writeHandle(h);
                return;
            } else if (obj instanceof Class) {
                // Class类型的处理方式，不深入
                writeClass((Class) obj, unshared);
                return;
            } else if (obj instanceof ObjectStreamClass) {
                // ObjectStreamClass类型的处理方式，不深入
                writeClassDesc((ObjectStreamClass) obj, unshared);
                return;
            }

            // check for replacement object
            Object orig = obj;
            Class cl = obj.getClass();
            ObjectStreamClass desc;
            for (;;) {
                // REMIND: skip this check for strings/arrays?
                Class repCl;
                // 拿到当前obj的类型的描述ObjectStreamClass
                desc = ObjectStreamClass.lookup(cl, true);
                if (!desc.hasWriteReplaceMethod() ||
                    (obj = desc.invokeWriteReplace(obj)) == null ||
                    (repCl = obj.getClass()) == cl)
                {
                    // 三个条件满足一个即可
                    // 1. 此类型没有实现writeReplace()
                    // 2. 此类型实现了writeReplace()替换对象，但返回了空对象
                    // 3. 此类型实现了writeReplace()并返回了空对象，获取被替换对象的类型
                    break;
                }
                cl = repCl;
            }
            if (enableReplace) {
                // 如果允许替换对象的话，进到这里
                // 默认情况下replaceObject()返回本是，也就是说，ObjectOutputStream的子类可以重写replaceObject()来对一些对象进行操作
                Object rep = replaceObject(obj);
                if (rep != obj && rep != null) {
                    // 如果obj被替换成不同类型的对象，通过ObjectOutputStream解析出此类型的信息
                    cl = rep.getClass();
                    desc = ObjectStreamClass.lookup(cl, true);
                }
                // obj赋值为更换后的对象
                obj = rep;
            }

            // 如果发生替换时，要再此做前面的检查
            if (obj != orig) {
                // 记录替换关系
                subs.assign(orig, obj);
                if (obj == null) {
                // null的情况
                    writeNull();
                    return;
                } else if (!unshared && (h = handles.lookup(obj)) != -1) {          // 类型已被解析过的情况
                    writeHandle(h);
                    return;
                } else if (obj instanceof Class) {
                // Class类型的情况
                    writeClass((Class) obj, unshared);
                    return;
                } else if (obj instanceof ObjectStreamClass) {
                // ObjectStreamClass类型的情况
                    writeClassDesc((ObjectStreamClass) obj, unshared);
                    return;
                }
            }

            // 下面分别是obj为String、集合、枚举、对象类型时的处理情况
            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);
            } 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());
                }
            }
        } finally {
            // 遍历完了，恢复遍历深度信息
            depth--;
            bout.setBlockDataMode(oldMode);
        }

概括地说，做了以下事情：

1. 首先会检查并处理obj被替换、被解析过、是Class类型、和ObjectStreamClass类型时的情况，此时会通过各自的处理方法，向bout想入信息。Class和ObjectStreamClass的处理情况不是本文的重点，因此不拓展。obj被替换以及被解析过的处理情况写入代码较简单，也不多贴例行代码
2. obj没有被处理过，通过ObjectStreamClass.lookup()拿到它的类型描述。如果ObjectOutputStream重写了替换方法，则要将obj进行替换，并拿到替换的对象以及它的描述，因为后面的操作是基于真正要被写入的obj来操作的
3. 当发生了替换，重写执行1
4. 分别处理obj为String、集合、枚举、以及对象类型时的情况，其中前三者不难，不拓展。重点是对象类型时的处理方式。按照之前说的思路，最终当一个种类型的成员变量不再包含对象类型时，也就不再继续往下解析（处理父类的情况当作处理对象类型的情况来处理）
5. 恢复遍历深度

因此，关注的点为ObjectStreamClass.lookup()如果拿到对象描述，以及writeOrdinaryObject()如何处理对象类型的解析。

获取对象描述ObjectStreamClass

    static ObjectStreamClass lookup(Class cl, boolean all) {
        if (!(all || Serializable.class.isAssignableFrom(cl))) {
            // 如果all为true，所有类型都能拿到对象描述
            // 否则，只有实现了Serializable的类型能拿到对象描述
            return null;
        }
        // 因为对象描述ObjectStreamClass是与Class关联的，并且在JVM类可以被卸载，
        // 因此当类被卸载时，与Class相关的对象描述也也就无效了
        // 所要移除这层关系并重新建立关系
        processQueue(Caches.localDescsQueue, Caches.localDescs);
        // WeakClassKey是WeakReference，弱引用Class
        WeakClassKey key = new WeakClassKey(cl, Caches.localDescsQueue);
        // 获取EntryFutrue或ObjectStreamClass
        // key实际为Class的hashCode
        Reference ref = Caches.localDescs.get(key);
        Object entry = null;
        if (ref != null) {
            // 获取实际的引用类型
            entry = ref.get();
        }
        EntryFuture future = null;
        if (entry == null) {
            // entry被回收了
            // 创建EntryFuture，使用软引用关联
            EntryFuture newEntry = new EntryFuture();
            Reference newRef = new SoftReference<>(newEntry);
            do {
                if (ref != null) {
                    Caches.localDescs.remove(key, ref);
                }
                // 当第一次解析这个类型时，或者entry被回收时，必定拿不到entry，
                // 因此先将key与EntryFuture相关联占位
                ref = Caches.localDescs.putIfAbsent(key, newRef);
                if (ref != null) {
                    entry = ref.get();
                }
            // 下面的判断条件，是要保证ref弱引用到的对象没有被卸载
            } while (ref != null && entry == null);
            if (entry == null) {
                future = newEntry;
            }
        }

        if (entry instanceof ObjectStreamClass) {
        // 如果拿到ObjectStreamClass，直接返回
            return (ObjectStreamClass) entry;
        }
        if (entry instanceof EntryFuture) {
        // 如果走这里，说明是第一次获取次类型的描述，或者描述已经被卸载
            future = (EntryFuture) entry;
            if (future.getOwner() == Thread.currentThread()) {
              // 如果是当前线程创建的，置空
              entry = null;
            } else {
             // 如果是其他线程创建的，获取到其他线程创建的结果
                entry = future.get();
            }
        }
        if (entry == null) {
            try {
            // 说明类其他线程并未创建，创建对象描述
                entry = new ObjectStreamClass(cl);
            } catch (Throwable th) {
                entry = th;
            }
            if (future.set(entry)) {
                // 说明由当前线程创建的对象描述可用
                // 与Class建立关联
                Caches.localDescs.put(key, new SoftReference