序列化 详解

// 构造：包装底层输出流
ObjectOutputStream(OutputStream out)

// 写入对象
void writeObject(Object obj)

// 写入基本类型
void writeInt(int val)
void writeLong(long val)
void writeDouble(double val)
void writeBoolean(boolean val)
void writeUTF(String str)      // 以UTF-8修改版写入字符串
void writeBytes(String str)    // 写入字符串的低8位

// 刷新和关闭
void flush()
void close()

// 写入对象时的回调（由被序列化对象定义）
// ObjectOutputStream会调用对象的 writeObject(ObjectOutputStream oos) 方法

// 构造：包装底层输入流
ObjectInputStream(InputStream in)

// 读取对象
Object readObject()  // 返回Object，需要强转

// 读取基本类型
int readInt()
long readLong()
double readDouble()
boolean readBoolean()
String readUTF()

// 关闭
void close()

import java.io.*;
import java.util.*;

/**
 * 飞翔科技 - 员工对象持久化系统
 * 场景：HR系统需要将员工数据序列化到磁盘，系统重启后恢复
 * 讲解重点：Serializable, serialVersionUID, transient, 对象引用
 * 作者：大翔 & 白歌
 */
public class FeixiangEmployeePersistence {

    public static void main(String[] args) {
        // 1. 构建测试数据
        Department devDept = new Department("DEV-001", "研发部", "8楼A区");
        Department hrDept = new Department("HR-001", "人力资源部", "3楼B区");

        List<Employee> employees = new ArrayList<>();
        employees.add(new Employee("E1001", "大翔", devDept, 25000.0, "13800000001"));
        employees.add(new Employee("E1002", "白歌", devDept, 22000.0, "13800000002"));
        employees.add(new Employee("E1003", "小崔", devDept, 8000.0, "13800000003"));
        employees.add(new Employee("E1004", "朱璐", hrDept, 15000.0, "13800000004"));

        String dataFile = "d:/feixiang/employees.ser";

        // 2. 序列化——保存到磁盘
        serializeEmployees(employees, dataFile);

        // 3. 反序列化——从磁盘恢复
        List<Employee> restored = deserializeEmployees(dataFile);

        // 4. 对比验证
        compareResults(employees, restored);
    }

    /**
     * 序列化员工列表到文件
     */
    public static void serializeEmployees(List<Employee> employees, String filePath) {
        new File(filePath).getParentFile().mkdirs();

        try (ObjectOutputStream oos = new ObjectOutputStream(
                new BufferedOutputStream(new FileOutputStream(filePath)))) {

            oos.writeObject(employees);  // ArrayList 实现了 Serializable
            System.out.println("[大翔] 序列化成功! " + employees.size()
                    + " 个员工已存储到: " + filePath);

        } catch (NotSerializableException e) {
            System.err.println("[小崔] 序列化失败: 存在不可序列化的对象 - " + e.getMessage());
        } catch (IOException e) {
            System.err.println("[白歌] IO异常: " + e.getMessage());
        }
    }

    /**
     * 从文件反序列化员工列表
     */
    @SuppressWarnings("unchecked")
    public static List<Employee> deserializeEmployees(String filePath) {
        try (ObjectInputStream ois = new ObjectInputStream(
                new BufferedInputStream(new FileInputStream(filePath)))) {

            List<Employee> employees = (List<Employee>) ois.readObject();
            System.out.println("[大翔] 反序列化成功! " + employees.size()
                    + " 个员工已从磁盘恢复");
            return employees;

        } catch (InvalidClassException e) {
            System.err.println("[白歌] 反序列化失败: 类版本不兼容 - " + e.getMessage());
            System.err.println("[白歌] 请检查 serialVersionUID 是否一致");
        } catch (ClassNotFoundException e) {
            System.err.println("[小崔] 反序列化失败: 找不到类定义 - " + e.getMessage());
        } catch (IOException e) {
            System.err.println("[小崔] IO异常: " + e.getMessage());
        }
        return Collections.emptyList();
    }

    /**
     * 对比序列化前后的数据
     */
    public static void compareResults(List<Employee> original, List<Employee> restored) {
        System.out.println("\n========== 序列化前后数据对比 ==========");
        for (int i = 0; i < original.size(); i++) {
            Employee orig = original.get(i);
            Employee rest = restored.get(i);
            System.out.printf("[白歌] %s: 姓名=%s, 薪资(原)=%.0f, "
                    + "薪资(恢复)=%.0f, 手机号=%s%n",
                    orig.getId(), orig.getName(),
                    orig.getSalary(), rest.getSalary(),
                    rest.getPhone());
            // 注意：salary被transient修饰，反序列化后为null(包装类型)或0.0(基本类型)
        }
    }
}

// ==================== 辅助类定义 ====================

/**
 * 部门类 —— 必须实现 Serializable
 * 因为 Employee 引用了 Department，序列化时会遍历整个对象图
 */
class Department implements Serializable {
    // 显式声明 serialVersionUID，确保版本兼容性
    private static final long serialVersionUID = 20240315L;

    private String deptId;
    private String deptName;
    private String location;

    public Department(String deptId, String deptName, String location) {
        this.deptId = deptId;
        this.deptName = deptName;
        this.location = location;
    }

    @Override
    public String toString() {
        return deptName + "(" + deptId + ") - " + location;
    }

    // getters
    public String getDeptId() { return deptId; }
    public String getDeptName() { return deptName; }
    public String getLocation() { return location; }
}

/**
 * 员工类 —— 展示完整的序列化控制
 */
class Employee implements Serializable {
    private static final long serialVersionUID = 20240315L;

    private String id;          // 工号——序列化
    private String name;        // 姓名——序列化
    private Department department; // 部门引用——序列化（遍历对象图）
    private transient Double salary;  // 薪资——不序列化（敏感信息）
    private String phone;       // 手机号——序列化

    // 构造方法：反序列化时不调用
    public Employee(String id, String name, Department department,
                    Double salary, String phone) {
        this.id = id;
        this.name = name;
        this.department = department;
        this.salary = salary;
        this.phone = phone;
        System.out.println("[构造] Employee 构造方法被调用: " + name);
        // 注意：反序列化时这行不会打印——证明构造方法未被调用
    }

    /**
     * 自定义序列化逻辑（私有方法，由JVM通过反射调用）
     * 可用于加密敏感字段、添加额外数据
     */
    private void writeObject(ObjectOutputStream oos) throws IOException {
        System.out.println("[序列化回调] writeObject 被调用: " + name);
        // 先序列化非transient字段（默认行为）
        oos.defaultWriteObject();
        // 可以在此处加密salary并用writeDouble手动序列化
        // 这里为了演示，跳过salary的序列化（它本身是transient）
    }

    /**
     * 自定义反序列化逻辑
     */
    private void readObject(ObjectInputStream ois)
            throws IOException, ClassNotFoundException {
        System.out.println("[反序列化回调] readObject 被调用: (name待恢复)");
        // 先恢复非transient字段（默认行为）
        ois.defaultReadObject();
        // salary是transient的，这里保持为null
        // 实际项目中可以从其它安全渠道恢复敏感数据
    }

    // getters
    public String getId() { return id; }
    public String getName() { return name; }
    public Double getSalary() { return salary; }
    public String getPhone() { return phone; }
    public Department getDepartment() { return department; }
}

import java.io.*;

/**
 * 飞翔科技 - 项目配置序列化 (Externalizable vs Serializable)
 * 场景：配置文件只需要持久化核心参数，缓存值不应序列化
 * 作者：白歌
 */
public class FeixiangProjectConfigPersistence {

    public static void main(String[] args) {
        String configFile = "d:/feixiang/project_config.ser";

        // 1. 创建并保存配置
        ProjectConfig config = new ProjectConfig(
                "FX-2024", "飞翔ERP系统", "UTF-8",
                "/opt/feixiang/logs", 8080, 4096);
        // 修改运行时状态
        config.setUpTime("2024-03-15 10:30:00");
        config.setConnectionCount(128);

        saveConfig(config, configFile);

        // 2. 从文件恢复配置
        ProjectConfig restored = loadConfig(configFile);

        // 3. 对比
        compareConfigs(config, restored);
    }

    public static void saveConfig(ProjectConfig config, String filePath) {
        new File(filePath).getParentFile().mkdirs();
        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream(filePath))) {
            oos.writeObject(config);
            System.out.println("[白歌] 配置已保存到: " + filePath);
        } catch (IOException e) {
            System.err.println("[小崔] 保存失败: " + e.getMessage());
        }
    }

    public static ProjectConfig loadConfig(String filePath) {
        try (ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream(filePath))) {
            ProjectConfig config = (ProjectConfig) ois.readObject();
            System.out.println("[白歌] 配置已从文件恢复");
            return config;
        } catch (IOException | ClassNotFoundException e) {
            System.err.println("[小崔] 加载失败: " + e.getMessage());
        }
        return null;
    }

    public static void compareConfigs(ProjectConfig original, ProjectConfig restored) {
        System.out.println("\n========== 配置对比 ==========");
        System.out.println("[白歌] 原始配置 => " + original);
        System.out.println("[白歌] 恢复配置 => " + restored);
        System.out.println("[白歌] 运行时状态(upTime)恢复后: " + restored.getUpTime()
                + " (预期为null)");
        System.out.println("[白歌] 运行时状态(connectionCount)恢复后: "
                + restored.getConnectionCount() + " (预期为0)");
    }
}

// ==================== Externalizable 配置类 ====================

/**
 * 使用 Externalizable 实现精确控制序列化
 * 与 Serializable 的关键区别：
 * 1. 必须提供 public 无参构造方法（反序列化时需要）
 * 2. 必须实现 writeExternal 和 readExternal 方法
 * 3. 完全手动控制序列化内容
 * 4. 性能更好（跳过了反射分析字段的开销）
 */
class ProjectConfig implements Externalizable {

    private static final long serialVersionUID = 20240315L;

    // 持久化字段
    private String projectCode;
    private String projectName;
    private String encoding;
    private String logPath;
    private int port;
    private int maxThreads;

    // 运行时状态 —— 不参与序列化
    private String upTime;          // 启动时间——每次运行不同
    private int connectionCount;    // 当前连接数——运行时状态

    // ⚠️ Externalizable 必须提供 public 无参构造
    public ProjectConfig() {
        System.out.println("[Externalizable] 无参构造被调用 (反序列化)");
    }

    public ProjectConfig(String projectCode, String projectName, String encoding,
                         String logPath, int port, int maxThreads) {
        this.projectCode = projectCode;
        this.projectName = projectName;
        this.encoding = encoding;
        this.logPath = logPath;
        this.port = port;
        this.maxThreads = maxThreads;
        System.out.println("[Externalizable] 全参构造被调用 (正常创建)");
    }

    /**
     * 自定义序列化：只写需要的字段
     */
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        System.out.println("[Externalizable] writeExternal 执行");
        out.writeUTF(projectCode);
        out.writeUTF(projectName);
        out.writeUTF(encoding);
        out.writeUTF(logPath);
        out.writeInt(port);
        out.writeInt(maxThreads);
        // 运行时状态 upTime 和 connectionCount 不写入
    }

    /**
     * 自定义反序列化：按写入的顺序读取
     */
    @Override
    public void readExternal(ObjectInput in)
            throws IOException, ClassNotFoundException {
        System.out.println("[Externalizable] readExternal 执行");
        // 顺序必须与 writeExternal 完全一致!
        this.projectCode = in.readUTF();
        this.projectName = in.readUTF();
        this.encoding = in.readUTF();
        this.logPath = in.readUTF();
        this.port = in.readInt();
        this.maxThreads = in.readInt();
        // 运行时状态保持默认值
        this.upTime = null;
        this.connectionCount = 0;
    }

    // setters for runtime state
    public void setUpTime(String upTime) { this.upTime = upTime; }
    public void setConnectionCount(int connectionCount) {
        this.connectionCount = connectionCount;
    }

    // getters
    public String getUpTime() { return upTime; }
    public int getConnectionCount() { return connectionCount; }

    @Override
    public String toString() {
        return String.format(
                "ProjectConfig{code=%s, name=%s, encoding=%s, logPath=%s, "
                        + "port=%d, maxThreads=%d, upTime=%s, connections=%d}",
                projectCode, projectName, encoding, logPath,
                port, maxThreads, upTime, connectionCount);
    }
}

import java.io.*;

/**
 * 飞翔科技 - 对象图序列化：引用共享验证
 * 场景：多个员工属于同一部门，序列化后引用关系应该保持不变
 * 作者：大翔
 */
public class ObjectGraphSerialization {

    public static void main(String[] args) {
        String filePath = "d:/feixiang/graph_test.ser";
        new File(filePath).getParentFile().mkdirs();

        // 创建共享部门对象
        Department devDept = new Department("D001", "研发部", "8楼");

        // 多个员工引用同一个部门
        Employee e1 = new Employee("E01", "大翔", devDept, 25000.0, "138001");
        Employee e2 = new Employee("E02", "白歌", devDept, 22000.0, "138002");
        // e1 和 e2 的 department 字段指向同一个 Department 实例

        System.out.println("[大翔] 序列化前:");
        System.out.println("  e1.department == e2.department ? "
                + (e1.getDepartment() == e2.getDepartment()));  // true
        System.out.println("  department hashCode: " + devDept.hashCode());

        // 序列化
        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream(filePath))) {
            oos.writeObject(e1);
            oos.writeObject(e2);
            oos.writeObject(devDept);  // 再写一次部门
        } catch (IOException ex) {
            ex.printStackTrace();
        }

        // 反序列化
        try (ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream(filePath))) {
            Employee r1 = (Employee) ois.readObject();
            Employee r2 = (Employee) ois.readObject();
            Department rd = (Department) ois.readObject();

            System.out.println("\n[大翔] 反序列化后:");
            System.out.println("  r1.department == r2.department ? "
                    + (r1.getDepartment() == r2.getDepartment()));
            // JDK 8 中：同一个ObjectOutputStream内写入的共享引用
            // 会在反序列化时保持引用一致性 → true

            System.out.println("  r1.department == rd ? "
                    + (r1.getDepartment() == rd));
            // 同一个流内，三次写入同一个对象，反序列化后引用一致 → true

            System.out.println("  r1.name=" + r1.getName()
                    + " dept=" + r1.getDepartment().getDeptName());
            System.out.println("  r2.name=" + r2.getName()
                    + " dept=" + r2.getDepartment().getDeptName());

        } catch (IOException | ClassNotFoundException ex) {
            ex.printStackTrace();
        }
    }
}

// ❌ 错误：未声明 serialVersionUID
// JVM会根据类结构(方法名、字段、接口等)自动生成一个hash值
// 一旦类结构有任何改动（哪怕加一个空格再加一个方法），UID就会变
class Employee implements Serializable {
    private String name;
    // 没有 serialVersionUID!
}

// 场景：今天序列化了1000个对象到文件
// 明天：给 Employee 加了一个 getDisplayName() 方法
// 后天：反序列化 → InvalidClassException! 所有数据读取失败!

// ✅ 正确：显式声明 serialVersionUID
class Employee implements Serializable {
    private static final long serialVersionUID = 1L;  // 固定版本号
    private String name;

    // 以后添加方法、调整字段顺序都不会改变UID
    // （删除已有字段或改变字段类型仍然可能出问题，需谨慎）
}

// ❌ 错误：非静态内部类持有外部类引用，序列化时会连带外部类
class Outer {
    private String secret = "password123";

    class InnerData implements Serializable {  // 非静态内部类
        private String data;
        // 隐含持有 Outer.this 引用!
    }
}
// 序列化 InnerData 时，会尝试序列化 Outer 实例
// 如果 Outer 没有实现 Serializable → NotSerializableException!

// ✅ 方案1：使用静态内部类
class Outer {
    private String secret = "password123";

    static class InnerData implements Serializable {  // 静态内部类
        private String data;
        // 不持有外部类引用，可以独立序列化
    }
}

// ✅ 方案2：让外部类也实现 Serializable（不推荐——暴露了不该序列化的字段）
// ✅ 方案3：将内部类单独提取为顶层类

// ❌ 常见误区：以为 transient 字段反序列化后会保留原值
class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String username;           // 正常序列化
    private transient String password; // 不序列化
}

// 序列化时: username="大翔", password="123456"
// 反序列化后: username="大翔", password=null (String默认值)

// ✅ 如果需要保护password不被泄露，但恢复时需要它：
// 方案1：在 readObject 中从一个安全服务重新加载
private void readObject(ObjectInputStream ois)
        throws IOException, ClassNotFoundException {
    ois.defaultReadObject();
    this.password = SecurityService.reloadPassword(this.username);
}

// 方案2：在 writeObject 中加密后写入
private void writeObject(ObjectOutputStream oos) throws IOException {
    oos.defaultWriteObject();
    String encrypted = AESUtil.encrypt(this.password);
    oos.writeObject(encrypted);  // 额外写入加密后的值
}

// ❌ 错误：未关闭流导致数据不完整
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("data.ser"));
oos.writeObject(largeObjectList);  // 数据可能还在缓冲区!
// 没有 oos.close() → 文件可能不完整 → 反序列化时 StreamCorruptedException

// ✅ 正确：使用 try-with-resources
try (ObjectOutputStream oos = new ObjectOutputStream(
        new BufferedOutputStream(new FileOutputStream("data.ser")))) {
    oos.writeObject(largeObjectList);
    oos.flush();  // 可选但建议，确保缓冲数据写入
}

// 常见误区：以为 static 字段也会被序列化
class Config implements Serializable {
    private static final long serialVersionUID = 1L;
    private String appName;            // 实例字段 → 序列化
    private static int instanceCount;  // 静态字段 → 不序列化! 属于类，不属于实例
}

// 序列化时: appName="飞翔ERP", instanceCount=10
// 新JVM中反序列化: appName="飞翔ERP", instanceCount=0 (类加载时的初始值)
// static 字段的状态由类加载器管理，与对象序列化无关

// 查看序列化文件的前几个字节
import java.io.*;

public class SerializationMagicNumber {
    public static void main(String[] args) throws Exception {
        // 序列化一个简单字符串
        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("d:/feixiang/magic.ser"))) {
            oos.writeObject("飞翔科技");
        }

        // 以十六进制读取文件头部
        try (FileInputStream fis = new FileInputStream("d:/feixiang/magic.ser")) {
            byte[] header = new byte[16];
            int len = fis.read(header);
            System.out.println("[大翔] 序列化文件头部 (" + len + " 字节):");
            for (int i = 0; i < len; i++) {
                System.out.printf("%02X ", header[i]);
                if ((i + 1) % 4 == 0) System.out.print(" ");
            }
            // 输出: AC ED 00 05 ... (魔数 + 版本号)
        }
    }
}