Java 序列化方案对比与性能

四大阵营：
  JDK 原生     —— 方便但慢、大、有漏洞
  JSON         —— 可读、跨语言、中等性能（Jackson/Gson）
  二进制通用   —— 快、小（Kryo/FST），但需注册类
  结构化协议   —— 跨语言、强类型（Protobuf/Thrift/Avro）

// 必须实现 Serializable
@Serial
private static final long serialVersionUID = 1L;  // 建议显式声明

// 序列化
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.ser"))) {
    oos.writeObject(user);
}
// 反序列化
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.ser"))) {
    User u = (User) ois.readObject();
}

安全结论（Oracle 官方立场）：
  不建议在 Java 9+ 继续使用 Java 序列化
  可用 ObjectInputFilter 做类白名单，但仅是缓解
  新系统一律选用 JSON / Kryo / Protobuf

// Jackson：性能领先、功能全
ObjectMapper mapper = new ObjectMapper();

// 序列化
String json = mapper.writeValueAsString(user);

// 反序列化
User user = mapper.readValue(json, User.class);

// 泛型反序列化：用 TypeReference 保留泛型信息
List<User> users = mapper.readValue(json,
        new TypeReference<List<User>>() {});

// Gson 泛型反序列化
Gson gson = new Gson();
List<User> users = gson.fromJson(json, new TypeToken<List<User>>() {}.getType());

// 1. 复用 ObjectMapper（线程安全，可共享）
// 2. 用流式 API 避免中间字符串
// 3. 关闭不必要的特性
ObjectMapper mapper = new ObjectMapper()
        .disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);

JSON 适用场景：
  需要人类可读、跨语言（JS/Go 等）互操作
  HTTP API、配置文件、日志
  RPC/缓存需要极致性能时，JSON 通常不够快

// 关键：注册类，减少体积
Kryo kryo = new Kryo();
kryo.register(User.class, 101);      // 用整数 ID 代替全类名
kryo.setReferences(true);            // 对象引用跟踪，省重复

// 序列化
Output out = new Output(1024);
kryo.writeObject(out, user);
byte[] bytes = out.toBytes();

// 反序列化
Input in = new Input(bytes);
User u = kryo.readObject(in, User.class);

// ThreadLocal 复用 Kryo，避免并发问题
static final ThreadLocal<Kryo> KRYO = ThreadLocal.withInitial(() -> {
    Kryo k = new Kryo();
    k.register(User.class, 101);
    return k;
});

// user.proto
syntax = "proto3";
package demo;

message User {
  int64 id = 1;
  string name = 2;
  string email = 3;
}

# 生成 Java 代码
protoc --java_out=./src user.proto

// 序列化
UserOuter.User user = UserOuter.User.newBuilder()
        .setId(1L).setName("alice").setEmail("a@b.com").build();
byte[] bytes = user.toByteArray();

// 反序列化
UserOuter.User parsed = UserOuter.User.parseFrom(bytes);

适用场景：
  跨语言 RPC（gRPC 默认）
  大数据平台、消息协议
  长期演进的内部协议

一个中等结构（约 20 字段）的对比（相对比例，环境不同有差异）：

方案         序列化速度   反序列化速度   体积
JDK 原生      1x          1x            100（基准）
Gson          2x          1.5x          55
Jackson       3x          2.5x          50
Kryo          8x          6x            20
Protobuf      10x         8x            15

结论：二进制方案在速度与体积上全面占优，JSON 居中，JDK 最差。

// 正确的基准姿势：JMH，预热 + 多次迭代
@Benchmark
public void kryoWrite(Blackhole bh) {
    Kryo k = kryoTl.get();
    Output out = new Output(1024);
    k.writeObject(out, user);
    bh.consume(out.toBytes());
}

基准注意：
  1. 必须预热（JIT 生效）
  2. 复用对象，测稳态吞吐
  3. 相同数据、相同机器对比
  4. 关注反序列化（通常更慢）而非只测序列化

反序列化安全规范：
  1. 不反序列化不可信来源的 JDK 序列化流
  2. 如必须用，配置 ObjectInputFilter 类白名单
  3. JSON 反序列化注意多态类型（Jackson 默认关闭）
  4. 校验输入长度，防超大 payload 攻击

// Jackson 安全实践：显式配置，禁用默认多态
mapper.activateDefaultTyping(
        LaissezFaireSubTypeValidator.instance,
        ObjectMapper.DefaultTyping.NON_FINAL,
        JsonTypeInfo.As.PROPERTY);
// 或直接禁用多态，用 DTO 做输入校验