【Java基础】序列化、反序列化和不可变类

Hi~！这里是奋斗的明志，很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~~
🌱🌱个人主页：奋斗的明志
🌱🌱所属专栏：Java基础面经

📚本系列文章为个人学习笔记，在这里撰写成文一为巩固知识，二为展示我的学习过程及理解。文笔、排版拙劣，望见谅。

一、Java中的序列化和反序列化是什么？

应用场景：
网络传输、远程调用、持久化存储（比如：保存数据到文件或者数据库）、以及分布式系统中数据交换。

1、序列化

在Java中 序列化就是把 对象转换为字节流
这样对象可以通过网络传输、持久化存储或者缓存
Java 提供了 java.io.Serializable 接口来支持序列化，只要类实现了这个接口，就可以将该类的对象进行序列化.

1.1 Java序列化关键类和接口

• 通过实现 Serializable 接口，然后用 ObjectOutputStream 和 ObjectInputStream
• ObjectOutputStream 用于序列化，ObjectInputStream 用于反序列化
• 类必须 实现 Serializable 接口 才能被序列化

2、反序列化

是将字节流重新转换为对象的过程，即从存储中读取数据，并重新创建对象

3、注意点

3.1 transient 关键字

• 在序列化过程中，有些字段不需要被序列化，例如：敏感数据，可以使用 transient 关键字 标记不需要序列化的字段。

3.2 serialVersionUID

• 每一个 Serializable 类都应该定义一个 serialVersionUID，用于在反序列化时验证版本的一致性。如果没有明确指定 serialVersionUID，Java会根据类的定义自动生成一个 UID ，版本不匹配可能导致反序列化失败。

3.3 序列化性能问题

• Java默认的序列化机制可能比较慢，尤其是对于大规模分布式系统，可能会选择更加高效的序列化框架
• 比如：Protobuf、Kryo 等

3.4 安全性

• 反序列化是一个潜在的安全风险，因为通过恶意构造的字节流，可能会加载不安全的类 或者 执行不是期望的代码。因此，反序列化过程需要进行输入验证，避免反序列化漏洞。

4、序列化和反序列化理解

序列化其实就是将对象转化为可传输的字节序列格式，以便于存储和传输。

• 因为对象在 JVM 中可以认为是“立体的”，会有各种引用。
• 比如在内存地址中 Ox666 引用了某某某对象，呢此时这个对象要传输到网络的另一端的时候，就需要把这些引用“压扁”。
• 因为网络另一端的内存地址 Ox666 可以没有某某某对象，所以传输的对象需要包含这些信息，然后接收端将这些扁平的信息再反序列化得到对象。
• 所以，反序列化就是将字节序列格式转换为对象的过程

4.1 Java 序列化 Serializable 的意义

Serializable 接口没有什么实际的含义，就是起到一个标记的作用

• 观看一下源码就会非常清楚，除了String，数组，枚举之外，如果实现了 serializable 这个接口就走 writeOrdinaryObject，否则序列化就会抛出异常。

4.2 serialVersionUID 又有什么用？

private static final long serialVersionUID = 1L;

想必经常会看到这样的代码，这个 ID 其实就是用来验证序列化的对象和反序列化对应的对象的 ID 是否是一致的。所以这个 ID 的数字其实不重要，无论是 1L 还是 idea 自动生成的，只要序列化的时候对象 serialVersionUID和反序列化的时候对象的 serialVersionUlD 一致的话就行。如果没有显式指定 serialVersionUlD 则编译器会根据类的相关信息自动生成一个，可以认为是一个指纹。所以如果你没有定义一个 serialVersionUID 然后序列化个对象之后，在反序列化之前把对象的类的结构改了，比如增加了一个成员变量，则此时的反序列化会失败。因为类的结构变了，生成的指纹就变了，所以 serialVersionUID 就不一致了.

4.2 Java 序列化不包含静态变量

简单地说就是序列化之后存储的内容不包含静态变量的值，看一下下面的代码就很清晰了。

import java.io.*;

public class Test implements Serializable {
    //指纹
    private static final long serialVersionUID = 1L;

    public static int n = 1;

    public static void main(String[] args) {
        try {
            ObjectOutputStream outputStream = new ObjectOutputStream(
                    new FileOutputStream("明志学编程！"));
            outputStream.writeObject(new Test());
            outputStream.close();

            //序列化后修改值
            Test.n = 2;

            ObjectInputStream objectInputStream = new ObjectInputStream(
                    new FileInputStream("明志学编程！"));
            Test t = (Test) objectInputStream.readObject();
            objectInputStream.close();
            System.out.println(t.n);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

二、什么是 Java 中的不可变类？

不可变类 是指在创建后其状态（对象的字段）无法被修改的类。一旦对系被创建，它的所有属性都不能被修改。也就是说，对象的所有成员变量在初始化后就不能被修改，无论是通过外部方法还是内部方法。这种类的实例整个生命周期内保持不变。

1、特征

• 字段声明为 final，防止子类继承
• 该类的所有字段都是 private 和 final，确保只能在构造函数中初始化，之后不能修改。另外，不要提供 serter 方法，因为 setter 会改变变量的值。
• 如果类中有可变对象的引用，比如一个 Date 对象，那么在获取该对象的时候应该返回其副本而不是原对象，防止外部修改影响内部状态。
• 通过构造函数初始化所有字段
• 如果有一个可变对象，比如一个Date类型的birthDate，那么在getter中应该返回birthDate的克隆或者新的Date对象，而不是直接返回引用，这样可以避免外部的修改影响到Person类内部的状态。
• 可能还需要注意深拷贝的问题，特别是在构造函数中传入可变对象时，应该进行拷贝，而不是直接引用。比如，如果构造函数的参数是Date，应该创建一个新的Date对象保存其值，这样外部的Date对象后续变化不会影响Person内部的birthDate。
• 另外，确保类不会被扩展，所以类本身要声明为final，这样不会有子类覆盖方法导致状态变化的风险。

Java中经典不可变类有 ： String，Integer，BigDecimal，LocalDate 等

1.1 不可变类 Person 实现

public final class Person {
    // 1. 成员变量声明为 private final
    private final String name;
    private final int age;
    private final List<String> hobbies;

    // 2. 通过构造函数初始化所有成员变量
    public Person(String name, int age, List<String> hobbies) {
        this.name = name;
        this.age = age;
        // 3. 对可变对象进行深拷贝（防御性拷贝）
        this.hobbies = new ArrayList<>(hobbies);
    }

    // 4. 不提供 setter 方法
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    // 5. 返回可变对象的不可变视图或深拷贝
    public List<String> getHobbies() {
        return Collections.unmodifiableList(hobbies);
        // 或者返回深拷贝：return new ArrayList<>(hobbies);
    }
}

1.2 验证不可变性

public class Main {
    public static void main(String[] args) {
        List<String> hobbies = new ArrayList<>();
        hobbies.add("Reading");
        Person person = new Person("Alice", 30, hobbies);

        // 尝试修改原始 hobbies
        hobbies.add("Cooking");
        System.out.println("Original Hobbies: " + hobbies); // [Reading, Cooking]

        // 不可变类的 hobbies 未被修改
        System.out.println("Person's Hobbies: " + person.getHobbies()); // [Reading]

        // 尝试通过 getHobbies() 修改（会抛出 UnsupportedOperationException）
        person.getHobbies().add("Gaming");
    }
}

2、不可变类的优缺点

2.1 优点

• 线程安全：由于不可变对象的状态不能被修改，他们天生就是线程安全的，在并发环境中无需同步。
• 缓存友好：不可变对象可以安全的被缓存和共享，如 string 的字符常量池。
• 防止状态不一致：不可变类可以有效避免因意外修改对象状态而导致的不一致问题。

2.2 缺点

• 性能问题：不可变对象需要在每次状态变化时创建新的对象，这可能会导致性能开销，尤其是对于大规模对象或频繁修改的场景（例如String频繁拼接）

3、举例 String

String就是典型的不可变类，当你创建一个String对象之后，这个对象就无法被修改。
因为无法被修改，所以像执行S += “a” ,这样的方法，其实返回的是一个新建的String对象，老的 S 指向的对象不会发生变化，只是 S 的引用指向了新的对象而已。
所以不要在字符串拼接频繁的场景使用+来拼接，因为这样会频繁的创建对象。
不可变类的好处就是安全，因为知晓这个对象不可能会被修改，因此可以放心大胆的用，在多线程环境下也是线程安全的。

查看 String 的源码，发现 String 类是 final 修饰的，表示无法被继承。

String本质是一个char数组，然后用final修饰，不过 final 限制不了数组内部的数据，所以这还不够。所以value是用private修饰的，并且没有暴露出set方法，这样外部其实就接触不到vlue所以无法修改。

当然还是有修改的需求，比如replace方法，所以这时候就需要返回一个新对象来作为结果。

就是私有化变量，然后不要暴露St方法，即使有修改的需求也是返回一个新对象。