序列化机制：Serializable、transient 与 serialVersionUID

public class User implements Serializable {
    private String name;
    private int age;
    private transient String password;  // ★ transient 字段不参与序列化
}

// 序列化：对象 → 字节流
User user = new User("张三", 28, "secret");
try (ObjectOutputStream oos = new ObjectOutputStream(
        new FileOutputStream("user.dat"))) {
    oos.writeObject(user);
}

// 反序列化：字节流 → 对象
try (ObjectInputStream ois = new ObjectInputStream(
        new FileInputStream("user.dat"))) {
    User restored = (User) ois.readObject();
    System.out.println(restored.name);      // 张三
    System.out.println(restored.age);       // 28
    System.out.println(restored.password);  // null ★ transient 字段丢失
}

/*
 * 为什么 Serializable 是空接口？
 * 它只是一个"标记"，告诉 JVM：这个类允许被序列化。
 * 实际的序列化逻辑在 ObjectOutputStream 内部实现。
 * 如果一个类没有 implements Serializable，序列化时会抛出 NotSerializableException。
 */

// ═══ 版本 1：原始类 ═══
public class Order implements Serializable {
    // 没有显式声明 serialVersionUID
    private String orderId;
    private double amount;
}

// 序列化一个 Order 对象，保存到文件/Redis/数据库

// ═══ 版本 2：新增字段 ═══
public class Order implements Serializable {
    // JVM 自动生成的 UID 变了！（因为类结构变了）
    private String orderId;
    private double amount;
    private String status;  // 新增字段
}

// 反序列化之前保存的 Order 对象：
// ❌ InvalidClassException: Order;
//    local class incompatible:
//    stream classdesc serialVersionUID = -3287764903...
//    local class serialVersionUID   =  4829105732...

/*
 * 正确做法：显式声明 serialVersionUID
 */
public class Order implements Serializable {
    private static final long serialVersionUID = 1L;  // ★ 显式声明！
    private String orderId;
    private double amount;
    private String status;  // 新增字段，反序列化时为 null（默认值）
}

public class UserSession implements Serializable {
    private static final long serialVersionUID = 1L;

    private String userId;
    private String username;

    // ★ 场景 1：敏感数据不应序列化（安全）
    private transient String password;
    private transient String token;

    // ★ 场景 2：可以重新计算的派生字段
    private transient int age;  // 可以从 birthday 重新算

    // ★ 场景 3：非序列化类型的字段（Thread、Socket 等）
    private transient Thread worker;
    private transient Socket connection;

    // ★ 场景 4：static 字段天然不参与序列化
    // （static 属于类，不属于对象实例，不需要 transient）
    private static String appName = "MyApp";
}

public class SensitiveData implements Serializable {
    private static final long serialVersionUID = 1L;

    private String name;
    private transient String secret;  // 不直接序列化

    // ★ 自定义序列化：加密后写入
    private void writeObject(ObjectOutputStream oos) throws Exception {
        oos.defaultWriteObject();  // 先序列化非 transient 字段
        oos.writeUTF(encrypt(secret));  // 再手动序列化 transient 字段（加密后）
    }

    // ★ 自定义反序列化：读取后解密
    private void readObject(ObjectInputStream ois) throws Exception {
        ois.defaultReadObject();  // 先反序列化非 transient 字段
        this.secret = decrypt(ois.readUTF());  // 再手动恢复 transient 字段
    }

    // ★ 另一个钩子：readResolve()——控制反序列化返回的对象
    // 常用于实现序列化安全的单例
    private Object readResolve() {
        return Singleton.INSTANCE;  // 反序列化时返回已有单例，而非新建对象
    }
}

public class Config implements Externalizable {
    // ★ Externalizable 反序列化时会调用无参构造函数！
    // 所以必须提供 public 无参构造（Serializable 不需要）
    public Config() { }

    public Config(String key, String value) {
        this.key = key;
        this.value = value;
    }

    private String key;
    private String value;

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        // ★ 完全由你控制写什么、怎么写
        out.writeUTF(key);
        out.writeUTF(encrypt(value));  // 可以加密
        out.writeInt(1);              // 可以写版本号
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException {
        // ★ 读取顺序必须和写入顺序完全一致
        this.key = in.readUTF();
        this.value = decrypt(in.readUTF());
        int version = in.readInt();
        // 可以根据 version 做兼容性处理
    }
}

/*
 * 攻击原理（以 Apache Commons Collections 为例）：
 *
 * 1. 攻击者构造一个特殊的 HashMap：
 *    HashMap → TiedMapEntry → LazyMap → ChainedTransformer
 *      → InvokerTransformer → Runtime.exec("rm -rf /")
 *
 * 2. HashMap 的 readObject() 会调用 hash() → hashCode()
 *    触发 TiedMapEntry.hashCode() → LazyMap.get()
 *    → ChainedTransformer.transform() → Runtime.exec()
 *
 * 3. 只要服务端对输入的字节流执行 readObject()，就会触发命令执行
 *
 * 这是 2015 年 Gabriel Lawrence 发现的经典攻击链
 * 影响了大量使用 Commons Collections 3.x 的系统
 */

// 防御措施：
// ① 使用 ObjectInputFilter（JDK 9+）限制可反序列化的类
ObjectInputStream ois = new ObjectInputStream(in);
ois.setObjectInputFilter(filterInfo -> {
    if (filterInfo.serialClass() != null) {
        String name = filterInfo.serialClass().getName();
        // 只允许特定类被反序列化
        if (name.startsWith("com.myapp.model."))
            return ObjectInputFilter.Status.ALLOWED;
        return ObjectInputFilter.Status.REJECTED;
    }
    return ObjectInputFilter.Status.UNDECIDED;
});

/* ═══ Protobuf（需要定义 .proto 文件）═══ */
// user.proto:
// message User { string name = 1; int32 age = 2; }
//
// protoc --java_out=. user.proto  生成 Java 类
User user = User.newBuilder().setName("张三").setAge(28).build();
byte[] data = user.toByteArray();           // 序列化（极小体积）
User restored = User.parseFrom(data);       // 反序列化

/* ═══ Hessian（Dubbo 默认序列化）═══ */
Hessian2Output ho = new Hessian2Output(outputStream);
ho.writeObject(user);  // 不需要 implements Serializable！
ho.flush();

Hessian2Input hi = new Hessian2Input(inputStream);
User u = (User) hi.readObject();

/* ═══ Jackson JSON ═══ */
ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(user);    // {"name":"张三","age":28}
User u2 = mapper.readValue(json, User.class);

/* ═══ Kryo（高性能，但不跨语言）═══ */
Kryo kryo = new Kryo();
kryo.register(User.class);
kryo.writeObject(output, user);    // 序列化（速度极快）
User u3 = kryo.readObject(input, User.class);