java 原生序列化通过维护对象引用表来处理循环引用,在写入对象时记录其唯一标识(id),当遇到已写入的对象时直接输出该 id 而非重复序列化内容。具体做法是调用 objectoutputstream 的构造函数并传入字节流,随后调用 writeobject() 方法,该方法会自动处理图结构中的环,确保不会陷入无限递归或产生数据损坏。

如何验证两个对象之间的双向引用被正确解析
要验证循环引用是否被正确处理,可以构建一个包含双向引用的简单类,实例化后将其序列化到文件,再反序列化回来。关键在于检查反序列化后的对象引用关系是否与原始对象一致,即修改其中一个对象的属性,另一个对象应能感知到变化,证明它们指向的是内存中的同一个实例。

import java.io.*;
public class CycleTest {
static class Node implements Serializable {
String name;
Node next;
public Node(String name) { this.name = name; }
}
public static void main(String[] args) throws Exception {
Node a = new Node("A");
Node b = new Node("B");
a.next = b;
b.next = a; // 形成循环引用
// 序列化
FileOutputStream fos = new FileOutputStream("cycle.ser");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(a);
oos.close();
// 反序列化
FileInputStream fis = new FileInputStream("cycle.ser");
ObjectInputStream ois = new ObjectInputStream(fis);
Node restoredA = (Node) ois.readObject();
// 验证:恢复后的 A 的 next 应该还是 B,且 B 的 next 应该回到 A
System.out.println(restoredA.next == restoredA); // false
System.out.println(restoredA.next.next == restoredA); // true
}
}
为什么自定义 writeReplace 可能破坏循环引用处理
如果在类中定义了 writeReplace 方法用于替换序列化代理,必须确保返回的新对象也能被正确追踪。如果 writeReplace 创建了一个全新的、未注册到当前序列化上下文的对象,或者破坏了原有的引用结构,可能会导致反序列化时出现 ClassCastException 或引用断裂。正确的做法是让代理对象保持与原始对象相同的引用拓扑结构,或者在代理类中也实现相应的循环逻辑。
立即学习“Java免费学习笔记(深入)”;

import java.io.*;
public class ProxyCycleTest {
static class RealObj implements Serializable {
RealObj ref;
public RealObj() {}
private Object writeReplace() throws ObjectStreamException {
// 错误示范:创建一个完全独立的新对象,不保留引用关系
return new ProxyObj();
}
}
static class ProxyObj implements Serializable {
ProxyObj ref;
}
public static void main(String[] args) throws Exception {
RealObj a = new RealObj();
RealObj b = new RealObj();
a.ref = b;
b.ref = a;
FileOutputStream fos = new FileOutputStream("proxy.ser");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(a);
oos.close();
FileInputStream fis = new FileInputStream("proxy.ser");
ObjectInputStream ois = new ObjectInputStream(fis);
ProxyObj restored = (ProxyObj) ois.readObject();
// 此时 restored.ref 为 null,因为 writeReplace 切断了引用链
System.out.println(restored.ref); // null
}
}
循环引用导致栈溢出时的替代方案是什么
虽然 Java 原生序列化能处理循环引用,但在极端深层嵌套或复杂图结构中,默认的递归机制可能导致栈溢出。此时可以使用第三方库如 Jackson 或 Gson,它们通常提供更灵活的引用处理策略。例如,Jackson 可以通过配置 MapperFeature.USE_ANNOTATIONS 或使用 @JsonBackReference 和 @JsonManagedReference 注解来显式控制循环引用的序列化方向,避免无限递归。此外,也可以手动实现 writeObject 和 readObject 方法,使用 HashMap 缓存已序列化的对象 ID,从而绕过默认机制的限制。


















