Java之标准序列化机制详解

1、基本用法

Ja va的序列化机制，可以说是Ja va语言里把“化繁为简”做到极致的设计之一。开发者只需要一个简单的标记接口，就能让对象在持久化或网络传输时自动完成转换，省去了手动处理字段、拼接字节等繁琐工作。接下来我们具体看看，这一切是如何发生的。

想要让一个类支持序列化？其实很简单——只要让这个类实现ja va.io.Serializable接口就行。注意，Serializable里面没有定义任何方法，它纯粹是一个标记接口，起到“身份标识”的作用。

举个例子。前面章节我们讨论过Student类，如果要让它支持序列化，代码只需要这样改动：

public class Student implements Serializable {
    // 主体代码保持不变
}

声明实现Serializable接口之后，保存或读取Student对象就可以直接借助ObjectOutputStream和ObjectInputStream这两个流来完成了。

ObjectOutputStream是OutputStream的子类，同时实现了ObjectOutput接口。而ObjectOutput又是DataOutput的子接口，它比DataOutput多了一个核心方法：

public void writeObject(Object obj) throws IOException

这个方法的作用，就是把一个对象转换为字节，然后写入底层流中。

与之对应的是ObjectInputStream，它是InputStream的子类，实现了ObjectInput接口。ObjectInput继承自DataInput，增加的方法也很直观：

public Object readObject() throws ClassNotFoundException, IOException

这个方法会从流中读取字节，并还原成一个Ja va对象。

有了这两个流，保存学生列表的操作就变得非常简洁了：

public static void writeStudents(List students) throws IOException {
    ObjectOutputStream out = new ObjectOutputStream(
            new BufferedOutputStream(new FileOutputStream("students.dat")));
    try {
        out.writeInt(students.size());
        for (Student s : students) {
            out.writeObject(s);
        }
    } finally {
        out.close();
    }
}

从文件读回学生列表也同样直接：

public static List readStudents() throws IOException, ClassNotFoundException {
    ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(
            new FileInputStream("students.dat")));
    try {
        int size = in.readInt();
        List list = new ArrayList<>(size);
        for (int i = 0; i < size; i++) {
            list.add((Student) in.readObject());
        }
        return list;
    } finally {
        in.close();
    }
}

如果仔细想想，其实上面这段代码还可以进一步简化——因为ArrayList和LinkedList都实现了Serializable，所以整个List对象可以一次性写入或读取。这样一来，真正关键的代码就只剩下一行了：

public static void writeStudents(List students) throws IOException {
    ObjectOutputStream out = new ObjectOutputStream(
            new BufferedOutputStream(new FileOutputStream("students.dat")));
    try {
        out.writeObject(students);
    } finally {
        out.close();
    }
}

public static List readStudents() throws IOException, ClassNotFoundException {
    ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(
            new FileInputStream("students.dat")));
    try {
        return (List) in.readObject();
    } finally {
        in.close();
    }
}

是不是有点意外的感觉？只要给类加上Serializable接口，之后就可以直接用ObjectOutputStream/ObjectInputStream读写对象了。像String、Date、Double、ArrayList、LinkedList、HashMap、TreeMap这些我们日常频繁使用的类，其实都已经实现了Serializable。

2、复杂对象

上面Student的例子还比较简单，但如果对象关系复杂起来呢？这里有两个常见提问：

1. 假如a和b两个对象都引用同一个对象c，序列化之后c是保存一份还是两份？反序列化之后，a和b还能指向同一个c吗？答案是：c只会保存一份，反序列化后a和b仍然指向同一个对象。
2. 如果a和b出现循环引用呢？比如a引用了b，而b又引用了a。这种情况Ja va同样能处理，引用关系会被完整保留。

这就是Ja va序列化机制真正神奇的地方——它自动处理了“引用同一对象”和“循环引用”这些让人头疼的问题。具体实现细节这里不展开了，记住结论就好。

3、定制序列化

默认的序列化机制虽然强大，但有些场景下它并不合适。

比如，有些字段的值与内存位置有关。最典型的就是hashCode()的默认实现，它基于对象的内存地址计算；一旦对象被恢复，内存地址已经变了，之前的值自然也就失效了。还有一些字段可能与时间相关，比如记录对象创建的时刻，这种情况下保存和恢复它也没有意义。

更常见的情况是，类中的某些字段描述的是“实现细节”，而不是逻辑信息。序列化格式本质上是一种“契约”，它应该反映类的逻辑结构，而不是与内部实现绑定。一旦绑定，将来想修改实现细节就会非常困难，封装也被破坏了。

以LinkedList为例，它的默认序列化就不合适。为什么？因为LinkedList的核心逻辑是“一个列表”，它由长度和每个元素组成；但它的字段却暴露了链表的实现细节：头尾节点指针、每个节点的前驱后继指针等。如果用默认机制序列化这些字段，格式就会被具体实现“焊死”。

那么如何解决？Ja va提供了两种主要的定制手段：

• 使用transient关键字；
• 实现writeObject和readObject方法。

将字段声明为transient，默认序列化机制就会忽略它，既不保存也不恢复。LinkedList正是这么做的，它的所有字段都声明成了transient：

transient int size = 0;
transient Node first;
transient Node last;

但声明为transient不等于“不保存”——而是告诉Ja va“别管这个字段了，我用自己的方法来处理”。具体做法就是实现writeObject和readObject方法。

writeObject的方法签名必须是：

private void writeObject(ja va.io.ObjectOutputStream s) throws ja va.io.IOException

在这个方法里，可以调用ObjectOutputStream的方法，按照自己的意愿写入对象数据。LinkedList的做法是：

private void writeObject(ja va.io.ObjectOutputStream s) throws ja va.io.IOException {
    s.defaultWriteObject();      // 必需，写入非transient字段及元数据
    s.writeInt(size);            // 写入元素个数
    for (Node x = first; x != null; x = x.next)
        s.writeObject(x.item);   // 逐个写入每个元素
}

注意那一行s.defaultWriteObject()，它是必需的。即使类中所有字段都是transient，也必须调用它——Ja va序列化框架不仅保存纯粹的数据，还会写入一些隐藏的元数据描述信息，这些信息是序列化之所以能自动处理复杂引用的关键。

对应的readObject方法签名必须是：

private void readObject(ja va.io.ObjectInputStream s) throws ja va.io.IOException, ClassNotFoundException

在这里，我们从流中读取数据并还原类的内部状态。LinkedList的做法是：

private void readObject(ja va.io.ObjectInputStream s) throws ja va.io.IOException, ClassNotFoundException {
    s.defaultReadObject();       // 必需
    int size = s.readInt();      // 读入元素个数
    for (int i = 0; i < size; i++)
        linkLast((E) s.readObject());  // 逐个还原元素并链接
}

同样，s.defaultReadObject()也是必需的。

除了writeObject和readObject，Ja va还提供了Externalizable接口、readResolve方法和writeReplace方法等更高级的定制机制。不过它们的使用频率相对较低，这里就不再展开了。

4、序列化的基本原理

梳理一下核心思路：

1. 如果类的字段本身就反映“逻辑信息”（比如Student类），那么直接实现Serializable接口、用默认机制就行。
2. 如果类的字段与实现细节绑定（比如LinkedList），则使用transient配合自定义的writeObject/readObject。
3. Ja va序列化可以自动处理引用同一对象、循环引用等问题。

那么，这些神奇的功能底层到底是怎么实现的？关键就在ObjectOutputStream的writeObject和ObjectInputStream的readObject这两个方法里。它们的实现逻辑非常复杂，这里只做简要介绍：

writeObject的基本逻辑：

• 如果对象没有实现Serializable，直接抛出NotSerializableException。
• 每个对象都有一个内部编号。如果之前已经写过该对象，这一次就只写一个引用编号（而不是重复写入对象本身），从而解决引用共享和循环引用问题。
• 如果对象实现了自定义writeObject方法，就调用它。
• 默认情况下，利用反射遍历对象的结构图，对每个非transient字段，根据其类型写入流中。信息包括：字段所属的完整类名、字段名、字段值等。

readObject的基本逻辑：

• 不调用任何构造方法。
• 它自己就相当于一个独立的“构造器”，根据字节流来初始化对象——同样依赖反射机制。
• 解析字节流时，遇到引用的类型会动态加载类。如果找不到对应的类，抛出ClassNotFoundException。

5、版本问题

代码是在不断演化的。如果序列化后的对象被持久化保存在文件中，而类的定义后来发生了变化，那旧数据还能反序列化吗？

默认情况下，Ja va会为每个类自动生成一个版本号，这个版本号基于类的各种信息（字段、方法等）计算得出。当类的定义发生变化时，版本号也随之改变。反序列化时，Ja va会比对类当前的版本号和流中的版本号，如果不一致，就会抛出InvalidClassException。

在实际开发中，我们通常希望自行定义这个版本号，而不是依赖Ja va自动生成。一方面是为了更好的可控性，另一方面也是因为自动生成版本号的开销较大。做法是在类中声明：

private static final long serialVersionUID = 1L;

在Eclipse等IDE中，如果声明了实现Serializable却没有定义serialVersionUID，IDE会主动提示自动生成。这个值可以任意指定，它代表类的版本号。序列化时会写入流，反序列化时进行比较，不一致则抛出异常。

如果版本号一致，但实际的字段发生了变化呢？Ja va会尽可能保持兼容：

• 字段被删除了：流中有该字段，但类定义中没有——该字段被忽略。
• 增加了新字段：类定义中有，但流中没有——该字段被初始化为默认值（null、0、false等）。
• 字段类型变了：同名字段，但类型不同——抛出InvalidClassException。

6、序列化特点分析

Ja va的序列化机制，主要服务于两个目标：对象持久化和跨网络的数据交换（如RPC）。它的优点很明显：使用简单，自动处理对象引用和循环引用，容易定制，也能处理版本兼容问题。但它也有几个不容忽视的局限性：

1. 序列化格式是Ja va私有的，无法被其他语言识别，不能用于跨语言的数据交换。
2. 序列化后的字节流中包含了大量描述性信息（类名、字段名等），导致数据体积偏大。
3. 默认序列化依赖反射来遍历对象结构，性能较低。
4. 格式是二进制的，不方便查看、调试和手工修改。

正是这些局限性，使得在实际项目中往往会采用替代方案。如果是跨语言场景，XML和JSON是广泛使用的文本格式，清晰易读，各种原生支持齐全。而在对性能和体积要求较高的领域，ProtoBuf、Thrift、MessagePack等高效的二进制格式则更受青睐。

总结

到这里，Ja va的标准序列化机制就介绍完了。从最基础的Serializable接口用法，到复杂对象的引用处理，再到transient和自定义writeObject/readObject进行精细控制，最后分析了它的原理和优缺点。可以说，它是一套“用起来简单、底层却极为复杂”的机制，设计的初衷是让开发者能轻松搞定对象持久化和传输，但在跨语言和性能敏感场景中，需要谨慎选择更合适的替代方案。