跳到主要内容
约 13 分钟3 张卡

Java 序列化

Java 原生序列化把对象状态及需要保存的引用关系写成字节流,反序列化再根据流中的信息恢复对象。对象和它们之间的引用关系合起来叫对象图;默认序列化会沿参与保存的字段继续处理被引用的对象。

这种格式依赖 Java 类:读取方需要可用且兼容的类定义,恢复过程中还可能执行类中的方法。因此,除了知道哪些字段会被保存,还要理解版本变化和不可信输入怎样影响恢复结果。它适合读写双方受控、短期使用的 Java 状态;对外交换和长期保存的数据,需要更明确的格式与兼容规则。

1. 面试核心​

先记住这几条,再读正文
  • 实现 Serializable 的类可以被对象流写出,默认保存非 static、非 transient 的实例字段。卡 · Serializable
  • 普通可序列化类恢复时不执行自己的构造器,执行的是继承链上第一个不可序列化父类的可访问无参构造器,所以构造器里的校验要在 readObject 里重做。
  • 普通类的 serialVersionUID 和流中记录的不一致时抛出 InvalidClassException;一致也只说明版本标识通过,字段是否兼容要另外判断。
  • 读取对象流会执行类路径上已有类的代码,不可信的流可以借此触发危险调用或耗尽资源;ObjectInputFilter 可以限制类型和对象图规模。卡 · 不可信输入风险
  • 在同一个输出流中,未清除对象记录就再次调用 writeObject 写入同一对象,只会写出已有句柄,不会自动保存字段的新状态。卡 · 对象句柄与特殊构造规则

2. Serializable​

Serializable 是一个标记接口,不声明方法,只用于表明类具备某种能力。实现它就是声明「这个类的对象允许被序列化」,实际读写由对象流完成。下面让 UserProfile 实现这个接口:

public final class UserProfile implements Serializable {
@Serial
private static final long serialVersionUID = 1L;

private final long userId;
private final String displayName;

public UserProfile(long userId, String displayName) {
this.userId = userId;
this.displayName = displayName;
}
}

下面使用对象流写入 UserProfile,再从文件中读取:

try (ObjectOutputStream output = new ObjectOutputStream(
Files.newOutputStream(path)
)) {
output.writeObject(profile);
}

try (ObjectInputStream input = new ObjectInputStream(
Files.newInputStream(path)
)) {
UserProfile restored = (UserProfile) input.readObject();
}

writeObject 写出 profile 的类信息和参与序列化的字段。displayName 引用了字符串,对象流会继续保存该字符串;readObject 再根据流中的记录恢复字段及引用关系。

默认序列化会沿这些引用继续处理,因此参与保存的对象都必须可序列化。如果某个字段引用了不可序列化的对象,又没有被排除或另行处理,写入就会抛出 NotSerializableException。只给最外层类加上 Serializable 并不够。

2.1 默认序列化的字段范围​

默认序列化保存的是对象自己的状态,有两类字段不在其中:

  • static 字段属于类而不是某个对象,所以不会写入。
  • transient 字段是类的作者明确声明「不要默认序列化」的字段,比如可以重新算出来的缓存。
private transient String accessToken;

accessToken 不会被默认序列化写出。临时缓存、文件句柄这类恢复了也没意义的状态,以及敏感数据,都可以这样排除。但用 transient 保护敏感信息时,要确认它没有从别的路径进入流里:其他字段、嵌套对象和自定义的写入方法都可能把同样的数据写出去。

2.2 反序列化与构造方法​

恢复普通的 Serializable 类时,不会执行它自己的构造器,实例字段的初始化表达式也不会执行,例如 private int count = 10; 中的 = 10。执行的是继承链上第一个不可序列化父类的可访问无参构造器;可序列化部分的状态则根据流中的数据恢复。

这意味着两部分状态的来源不同:可序列化部分从流中读取,不可序列化父类的部分仍通过正常构造过程初始化。不能把反序列化理解成先正常调用一次子类构造器,再覆盖所有字段。

构造器里的校验也因此被跳过。对象不变量是对象必须满足的约束,例如 userId 必须大于 0。字节流可能被篡改,也可能来自旧版本,不能假定恢复出的字段仍满足约束。可以在 readObject 中恢复字段后重新检查,具体写法见自定义序列化。

3. serialVersionUID​

serialVersionUID 是普通可序列化类的版本标识。写入时它被记进流里;读取时,比较流里的值和本地类的值,不一样就抛出 InvalidClassException。record 和枚举另有规则,见对象句柄与特殊构造规则。

@Serial
private static final long serialVersionUID = 1L;

不显式声明时,默认 UID 会根据类名、字段、方法等结构计算。某些方法变化或编译器生成成员的变化,也可能改变结果,即使实际保存的字段仍然兼容,旧数据也会因 UID 不同而无法读取。需要兼容历史数据时,显式声明 UID 可以把版本标识的变化交给类的维护者控制。

3.1 UID 与语义兼容​

UID 相同只是通过了第一道检查,不代表新类能正确理解旧数据。判断时要看字段发生了哪些变化:

  • 基本类型字段改变类型属于不兼容变化,例如把 int 改为 long。
  • 读取旧流时,新增字段得到 Java 默认值。默认值是否是有效业务状态,需要读取方校验。
  • 删除字段后,旧流里对应的信息会被忽略,因此新对象会丢失这部分状态。
  • 类的继承关系和自定义读写钩子发生变化时,也要验证恢复结果是否符合预期。

维护者应在验证兼容性后,决定是否保留 UID。需要保持的不只是字段类型,还包括业务含义;例如新增字段得到 0 后,对象是否仍然有效。无法兼容时,可以改变 UID 让旧数据明确失败,并安排历史数据迁移,避免读出形式正确、含义错误的对象。

3.2 长期数据的模式版本​

数据库记录、跨服务消息和长期保存的文件,要经历很多次发布,还可能被其他语言读取。它们需要明确的字段兼容规则和版本迁移方式,而 serialVersionUID 只管「类版本对不对得上」这一件事。

JSON、Protocol Buffers 和 Avro 这类格式把数据的结构和 Java 类的实现分开了。比如 Protocol Buffers 用字段编号标识字段,改了 Java 字段名也不影响旧数据;JSON 则需要另外约定字段结构和校验规则。选格式时,一起比较体积、解析性能、兼容能力和维护成本。

4. 自定义序列化​

钩子是由框架在特定阶段调用、让类定制行为的方法。普通可序列化类可以按约定的签名声明私有 writeObject、readObject,分别介入写出和读取过程。下面沿用 UserProfile 的字段,在恢复后检查用户信息:

@Serial
private void writeObject(ObjectOutputStream output) throws IOException {
output.defaultWriteObject();
}

@Serial
private void readObject(ObjectInputStream input)
throws IOException, ClassNotFoundException {
input.defaultReadObject();

if (userId <= 0 || displayName == null || displayName.isBlank()) {
throw new InvalidObjectException("invalid user profile");
}
}

defaultWriteObject() 按默认规则写出字段,defaultReadObject() 按默认规则恢复字段。随后检查 userId 是否为正,以及 displayName 是否为 null 或空白;不满足条件就抛出 InvalidObjectException,让这次读取失败。这补上了字段约束检查,但不能阻止此前恢复其他对象时已经发生的行为。

另外还有三种扩展方式:

  • writeReplace 在写入前替换对象,让流保存替代对象的表示。
  • readResolve 在读取后替换恢复结果,常用于返回已有单例或统一复用的对象。
  • Externalizable 让类通过自己的方法控制格式和状态恢复,其构造规则见后文。

自定义读写会增加兼容测试和安全检查的工作量:以后每改一次格式,都要确认旧数据还能读。所以采用前先想清楚要恢复什么状态、要兼容哪些版本。如果只是为了少写几个字节,先测一下到底能省多少,再判断值不值得。

5. 不可信输入风险​

readObject() 会根据流里的类信息,尝试加载并恢复相应类型,不能靠外层强制转换限制它只创建 UserProfile。在 (UserProfile) input.readObject() 中,类型转换发生在 readObject() 返回之后,恢复阶段的代码此前已经执行:

  • 对象流会调用 readObject、readResolve 等自定义钩子。
  • 集合重建时会执行比较、哈希等方法,进一步调用元素所属类型的代码。
  • 大数组、深层对象图和大量引用会消耗内存与计算资源。
  • 类路径中的现有类型可能被组合成危险调用链(gadget chain),使恢复对象时的调用最终触发危险操作。

风险可能来自业务类,也可能来自依赖库。例如,某个类的 readObject 调用另一个对象的方法,而后续调用又能触发命令执行;如果这些类型和状态能够被对象流构造出来,危险行为就可能发生在业务校验之前。即使没有这样的调用链,过大的对象图也可能耗尽资源。

不要默认反序列化不可信 Java 对象流

网络请求、用户上传、消息队列,以及外部能修改的存储数据,都应该当作不可信输入。外部协议应该用结构明确的数据格式,只构造预期的 DTO(专门用来传递数据的对象,类型和字段由应用明确约定),再校验字段。

必须兼容原生对象流时,应在读取对象前配置类型与规模限制。

6. 反序列化过滤器​

反序列化过滤器(ObjectInputFilter)在对象恢复过程中检查类型和规模,可以拒绝预期之外的类、过大的数组或过深的对象图。需要读取原生对象流时,应在 readObject() 之前配置它。下面只允许明确列出的类型,并限制对象图规模:

try (ObjectInputStream input = new ObjectInputStream(source)) {
ObjectInputFilter filter = ObjectInputFilter.Config.createFilter(
"maxdepth=10;maxrefs=1000;maxarray=10000;maxbytes=1048576;"
+ "com.example.UserProfile;!*"
);
input.setObjectInputFilter(filter);

UserProfile profile = (UserProfile) input.readObject();
}

这个过滤器设置了这些限制:

  • 类名规则允许 com.example.UserProfile,末尾的 !* 拒绝其他被检查的类。
  • maxdepth=10 限制对象图的最大深度,防止引用关系过深。
  • maxrefs=1000 限制读取过程中的引用数量。
  • maxarray=10000 限制单个数组的长度。
  • maxbytes=1048576 在过滤回调时检查已经读取的字节数。

允许列表要覆盖合法对象图中需要检查的类型。例如,UserProfile 新增了一个 Address 字段,规则也需要允许 Address,并用仍需兼容的历史数据验证。直接放行整个包(例如 com.example.*)会扩大可恢复的类型范围,之后新增的类也可能被放行,审核范围随之增加。

过滤器也有管不到的地方。字符串和基本类型的值在流里是直接编码的,不会逐个触发过滤,所以 maxbytes 只在过滤回调时检查,不是整个输入流的硬性上限,外层还要限制整条消息的大小。字符串内容、字段含义和访问权限也仍然要业务代码校验。过滤器只是多了一层防护,不能替代前面说的「不读不可信的对象流」。

7. 适用范围​

原生序列化更适合双方受控、只短期保存 Java 状态的场景。采用前需要确认以下条件:

  • 写入方与读取方由同一应用和发布流程控制。
  • 数据生命周期短,不需要多年兼容。
  • 输入无法被不可信主体替换。
  • 对象图类型范围小,并配置了过滤器。
  • 现有性能和体积能满足需求,而且无需让其他语言读取。

跨越边界或长期使用的数据,优先选择其他格式:

  • 数据通过对外 HTTP、RPC 或消息协议交换。
  • 数据需要长期归档或保存在数据库字段中。
  • 数据需要由浏览器、移动端或其他语言读取。
  • 插件能够任意扩展类路径,反序列化可用的类型范围随之变化。
  • 缓存中的历史字节来源不明,无法确认是否被外部修改。

8. 对象句柄与特殊构造规则​

对象图里同一个对象可能被引用多次,恢复后它们也应该指向同一个对象,而不是变成几份副本。为此,对象流第一次写入某个对象时,会给它分配一个句柄,也就是这个对象在流里的编号。之后再遇到同一个对象,只写一个「见句柄 N」的引用。这个规则对两次 writeObject 之间也成立,所以中间对字段的修改不会被保存:

List<String> values = new ArrayList<>();
values.add("A");
output.writeObject(values);
values.add("B");
output.writeObject(values); // 引用首次写出的列表
output.reset();
output.writeObject(values); // 新快照包含 A、B

第二次 writeObject(values) 时,对象流发现 values 已经写过了,只写了一个句柄。所以接收方前两次 readObject 拿到的是同一个列表,里面只有 A。reset() 清掉了流里的对象记录,第三次写入才把 values 当作新对象完整写出,接收方第三次读到的是另一个包含 A、B 的列表。在长连接上反复发送同一个可变对象时,这个行为很容易造成「对方一直收到旧数据」。

句柄也是对象流能处理循环引用的原因:对象 A 引用 B、B 又引用 A 时,写到 B 的字段,发现 A 已经有句柄了,写一个引用就行,不会无限递归。

恢复对象时,除了普通的 Serializable 类,还有三种类型有自己的规则:

  • Externalizable 先调用公开无参构造器,再执行 readExternal 恢复状态。
  • 可序列化 record 通过规范构造器恢复,也就是接收全部记录组件的构造器。它不使用普通类的 writeObject、readObject 定制方法,并豁免 UID 匹配要求。
  • 枚举按名称恢复为已有枚举常量,其 UID 固定为 0。改名或删除常量后,旧数据中的名称就无法匹配。

所以回答「反序列化执不执行构造器」「UID 怎样匹配」这类问题时,要先说明讨论的是哪一种类。

9. 常见问题​

9.1 Serializable 为什么没有方法?​

因为它只标记类是否允许序列化,具体读写由 ObjectOutputStream 和 ObjectInputStream 完成,类如果需要定制,再提供 writeObject、readObject 等可选的私有钩子。

9.2 所有字段都可序列化,就能安全恢复对象吗?​

9.3 transient 字段反序列化后是什么值?​

9.4 什么时候应该改变 serialVersionUID?​

10. 面试题卡片​

11. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明