在 java 对象序列化中，控制对象图大小的核心做法是实现 writereplace 方法将大对象替换为紧凑的代理类，或者实现 externalizable 接口手动控制写入字节。通过这种方式可以显著减少序列化后的数据体积，避免内存溢出或网络传输瓶颈。
writeReplace 如何替换大对象
当序列化引擎遇到实现了 writeReplace 方法的对象时，会先调用该方法获取一个替代对象，然后对替代对象进行序列化。这允许我们将复杂的内部状态转换为更简单的结构，从而减小对象图的大小。
import java.io.*;
public class LargeData implements Serializable {
private static final long serialVersionUID = 1L;
private byte[] hugeBuffer; // 假设这是一个巨大的缓冲区
public LargeData(int size) {
this.hugeBuffer = new byte[size];
for (int i = 0; i < size; i++) {
hugeBuffer[i] = (byte) (i % 256);
}
}
// 关键：返回一个只包含必要元数据的代理对象
private Object writeReplace() throws ObjectStreamException {
return new DataProxy(hugeBuffer.length, hugeBuffer[0]); // 仅保留长度和首字节作为示例
}
static class DataProxy implements Serializable {
private static final long serialVersionUID = 1L;
int length;
byte firstByte;
DataProxy(int length, byte firstByte) {
this.length = length;
this.firstByte = firstByte;
}
}
}
public class Main {
public static void main(String[] args) throws Exception {
LargeData original = new LargeData(1024 * 1024); // 1MB
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(original);
oos.close();
System.out.println("Serialized size: " + baos.size() + " bytes");
}
}运行上述代码，预期输出类似：
Serialized size: 38 bytes
可以看到，原本 1MB 的数据被压缩到了几十字节，因为实际序列化的是 DataProxy 而非 LargeData 本身。
立即学习“Java免费学习笔记（深入）”；
Externalizable 接口的手动控制策略
如果 writeReplace 不够灵活，可以实现 Externalizable 接口。该接口要求实现 writeExternal 和 readExternal 方法，开发者可以完全决定哪些字段被写入流中，跳过不需要序列化的部分，从而精确控制对象图大小。
import java.io.*;
public class SelectiveData implements Externalizable {
private String name;
private transient byte[] sensitiveData; // 标记为 transient 但这里我们完全控制
public SelectiveData(String name, byte[] data) {
this.name = name;
this.sensitiveData = data;
}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
// 只写入 name，不写入 sensitiveData
out.writeObject(name);
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
this.name = (String) in.readObject();
this.sensitiveData = null; // 读取时重置
}
}
public class Main {
public static void main(String[] args) throws Exception {
SelectiveData obj = new SelectiveData("Test", new byte[1024]);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(obj);
oos.close();
System.out.println("Externalizable size: " + baos.size() + " bytes");
}
}运行结果预期：
Externalizable size: 45 bytes
即使 sensitiveData 存在，由于未在 writeExternal 中写入，它不会占用序列化空间。
序列化过程中如何处理循环引用导致的无限增长
在对象图中，如果存在循环引用（例如 A 引用 B，B 又引用 A），标准的 ObjectOutputStream 会通过维护一个已序列化对象的哈希表来检测并处理这种情况，防止无限递归和对象图无限膨胀。当再次遇到已序列化过的对象时，它会写入一个引用标记而不是重新序列化整个子图。然而，如果对象图非常深且宽，即使有循环引用检测，初始序列化仍可能消耗大量内存。此时，结合前文提到的 writeReplace 或 Externalizable 是更优解，因为它们可以在进入序列化引擎之前扁平化或裁剪对象图。
