前言：一个让你“卡壳”的面试题

先问大家一个问题：面试官问你“什么是Java序列化”，你会怎么回答？

是不是脑海里蹦出几个关键词——“把对象存到文件里”“实现Serializable接口”——然后就卡壳了？

别慌。今天咱们就花一篇文章的时间，把序列化和反序列化彻底聊透。不整那些晦涩难懂的技术黑话，咱们从最接地气的角度，一步步揭开它的面纱。

一、序列化是什么？——对象的“过安检”

想象一个场景：你要坐飞机，随身带的行李不能直接拎上飞机，得先过安检——从“三维实体”变成“X光图像”，扫描确认安全后才能放行。

在Java的世界里，对象就是你的行李，而网络传输、文件存储、Redis缓存这些“通道”就是安检机。它们不认内存里的Java对象，只认字节流。所以我们必须先把对象“过一遍安检”——转换成字节序列（byte[]） ——这个过程，就叫序列化（Serialization） 。

一句话总结：序列化 = 把内存中的Java对象 → 转成字节流（可存储、可传输）。

那反序列化呢？当这串字节流到达目的地（比如另一个服务、本地文件或者Redis），接收方需要把它还原成原来的Java对象才能继续使用。这个“从字节流变回对象”的过程，就叫反序列化（Deserialization） 。

反序列化 = 把字节流 → 还原成内存中的Java对象。

打个比方：序列化就像把对象“冷冻”起来，反序列化就是“解冻”，解冻之后还是原来那个对象，状态一点没变。

二、为什么要序列化？——存在的意义

好，概念搞清楚了。但你可能要问：我为什么要费这个劲儿把对象转来转去？直接拿对象用不香吗？

问题在于，Java对象是活在内存里的。程序一关、一断电，内存里的对象就灰飞烟灭了。序列化就是来解决这个问题的——它给了对象“永生”的能力。

具体来说，序列化的价值体现在三个场景：

1. 数据持久化：把对象保存到硬盘文件或数据库里，程序重启后还能恢复。比如游戏存档，就是把你的游戏角色序列化存下来，下次打开游戏再反序列化回去。

2. 网络传输：两个服务之间要传对象数据，必须转成二进制流才能在网上跑。RPC、微服务调用，底层都离不开序列化。

3. 缓存存储：把对象存到Redis、Memcached这类缓存里，本质也是先序列化再存储。

可以说，没有序列化，分布式系统就玩不转，数据持久化也无从谈起。

三、怎么实现序列化？——三分钟上手

理论说完了，咱们直接上代码。

第一步：实现Serializable接口

在Java中，想让一个类的对象能被序列化，只需要让这个类实现java.io.Serializable接口：

import java.io.Serializable;

public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

注意，Serializable接口里面什么方法都没有，它只是一个标记接口（Marker Interface） ——就像衣服上的标签，告诉JVM：“这个类的对象可以序列化”。

如果某个类没实现这个接口就强行序列化，JVM会毫不客气地抛出NotSerializableException。

第二步：用ObjectOutputStream序列化

有了可序列化的类，接下来用ObjectOutputStream把它写到文件里：

import java.io.*;

public class SerializationDemo {
    public static void main(String[] args) {
        Person person = new Person("张三", 25);
        
        // 序列化：对象 → 文件
        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("person.ser"))) {
            oos.writeObject(person);
            System.out.println("序列化成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

writeObject()方法就是核心，它负责把对象变成字节流并写入输出流。

第三步：用ObjectInputStream反序列化

序列化存下来的文件，怎么把它变回对象？用ObjectInputStream：

public class DeserializationDemo {
    public static void main(String[] args) {
        // 反序列化：文件 → 对象
        try (ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("person.ser"))) {
            Person person = (Person) ois.readObject();
            System.out.println("反序列化成功：" + person);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

readObject()方法从字节流中读取数据并重建对象。注意它返回的是Object类型，需要强制类型转换。

整个流程就是三步：实现Serializable → writeObject写入 → readObject读出。

四、深入原理：序列化背后发生了什么？

会用只是第一步，咱们再往底层挖一挖，看看序列化到底是怎么工作的。

当你调用writeObject()时，JVM会做以下几件事：

1. 检查对象是否实现了Serializable接口
2. 生成类的序列化描述符（包括类名、serialVersionUID、所有字段信息等）
3. 递归序列化对象的所有非transient、非static字段——如果字段里还引用了其他对象，就继续序列化那个对象
4. 把所有字节数据写入输出流

反序列化时，JVM不会调用对象的构造函数，而是直接通过反射设置字段值。这也是为什么反序列化出来的对象看起来像“凭空变出来”的——它确实没用new。

另外，序列化只保存对象的字段值和类元信息（类名、字段名、类型等），不保存静态变量、方法信息和构造函数。

五、serialVersionUID：对象的“身份证”

这是面试里的高频考点，咱们单独拎出来讲。

每个实现了Serializable的类，都可以定义一个serialVersionUID：

private static final long serialVersionUID = 1L;

这个ID是做什么用的？简单说，它是这个类的版本号。

当你序列化一个对象时，serialVersionUID会随着对象数据一起被写入字节流。反序列化时，JVM会把字节流里的ID和当前类的ID进行比对：

• 一致 → 放心反序列化
• 不一致 → 抛出InvalidClassException

那问题来了：如果不写会怎样？

如果你不显式声明，JVM会根据类的结构（字段名、类型、方法等）自动计算一个。但这就埋下了一个隐患——你哪天给类加了一个字段，JVM算出来的ID就变了，之前序列化好的数据就反序列化不回来了。

所以最佳实践是：永远显式声明serialVersionUID。这样就算类结构变了，只要ID不变，反序列化时新增的字段会被设为默认值（null或0），删除的字段会被忽略，至少不会直接崩溃。

六、transient：有些字段我不想存

不是所有的字段都值得存。比如密码这种敏感信息，或者临时计算出来的数据，序列化的时候最好跳过。

这时候就用上transient关键字了：

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String username;
    private transient String password;  // 这个字段不序列化
    private transient int tempCache;    // 临时数据也不存
}

被transient修饰的字段，序列化时会被直接忽略，反序列化时会被赋上默认值（引用类型为null，基本类型为0或false）。

七、原生序列化的优缺点

Java原生序列化（通过Serializable）好用是好用，但也有它的局限性：

优点：

• 简单，JDK自带，零依赖
• 自动处理对象图（循环引用、对象引用都能处理好）

缺点：

• 体积大：生成的字节流包含大量元信息，浪费存储和带宽
• 速度慢：性能比不上很多第三方方案
• 不跨语言：Java序列化的字节流，Python、Go这些语言读不懂

所以在实际项目中，很多人会选择JSON（Jackson、Gson）、Protocol Buffers或Kryo等替代方案。尤其是需要跨语言通信的场景，JSON或Protobuf几乎是必选项。

八、安全警告：别随便反序列化！

最后说一个严肃的问题：反序列化有安全风险。

如果你反序列化的数据来自不可信来源（比如用户上传的文件、网络请求传来的数据），攻击者可能精心构造恶意字节流，在反序列化时执行任意代码。

黄金法则：永远不要反序列化来自不可信来源的数据。

从Java 9开始，可以用ObjectInputFilter来限制允许反序列化的类集合，相当于给反序列化加了一道白名单。

结语

回顾一下今天的内容：

• 序列化 = 对象 → 字节流（过安检）
• 反序列化 = 字节流 → 对象（复活术）
• 实现方式 = 实现Serializable + ObjectOutputStream/ObjectInputStream
• 版本控制 = 显式声明serialVersionUID
• 跳过字段 = 用transient关键字
• 注意事项 = 性能一般、不跨语言、注意安全

序列化是Java里一个看似简单但内涵丰富的知识点。它让对象可以“走出”内存，在文件系统和网络之间自由穿梭——没有它，很多我们习以为常的功能（缓存、RPC、持久化）都无从谈起。

希望这篇文章能帮你彻底搞懂序列化和反序列化。下次面试官再问你，可就不只是说“把对象存到文件里”那么简单了。

---

有什么问题或者想深入探讨的点，欢迎在评论区留言！