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

Hi~！这里是奋斗的明志，很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~~

🌱🌱个人主页：奋斗的明志

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

Java基础

一、Java中的序列化和反序列化是什么？
- 1、序列化
- - [1.1 Java序列化关键类和接口](#1.1 Java序列化关键类和接口)
- 2、反序列化
- 3、注意点
- - [3.1 transient 关键字](#3.1 transient 关键字)
  - [3.2 serialVersionUID](#3.2 serialVersionUID)
  - [3.3 序列化性能问题](#3.3 序列化性能问题)
  - [3.4 安全性](#3.4 安全性)
- 4、序列化和反序列化理解
- - [4.1 Java 序列化 Serializable 的意义](#4.1 Java 序列化 Serializable 的意义)
  - [4.2 serialVersionUID 又有什么用？](#4.2 serialVersionUID 又有什么用？)
  - [4.2 Java 序列化不包含静态变量](#4.2 Java 序列化不包含静态变量)
[二、什么是 Java 中的不可变类？](#二、什么是 Java 中的不可变类？)
- 1、特征
- - [1.1 不可变类 Person 实现](#1.1 不可变类 Person 实现)
  - [1.2 验证不可变性](#1.2 验证不可变性)
- 2、不可变类的优缺点
- - [2.1 优点](#2.1 优点)
  - [2.2 缺点](#2.2 缺点)
- [3、举例 String](#3、举例 String)

一、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 又有什么用？

java 复制代码

private static final long serialVersionUID = 1L;

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

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

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

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 实现

java 复制代码

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 验证不可变性

java 复制代码

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方法，即使有修改的需求也是返回一个新对象。