Java中的序列化和反序列化：让你的对象学会“变身术”

在Java中，序列化和反序列化是对象持久化或网络传输中常用的技术。通过序列化，对象可以被转换成一系列字节，这些字节可以被写入到文件或通过网络传输。反序列化则是将这些字节转换回原来的对象。

序列化与反序列化概念

什么是序列化和反序列化?

java序列化是指把java对象转化为字节序列的过程，而java反序列化是指把字节序列恢复为java对象的过程.

序列化:最主要的作用就是在传递和保存对象的时候,保证对象的完整性和可传递性.序列化是把对象转换成有序字节流,以便在网络上传输或者保存在本地文件中，序列化后的字节流保存了java对象的状态以及相关的描述信息.序列化机制的核心作用就是对象状态的保存和重建.

反序列化:客户端从文件中或者网络上获得序列化后的对象字节流后,根据字节流中所保存的对象状态及描述信息,通过反序列化重建对象.

本质上讲,序列化就是把实体对象状态按照一定的格式写入到有序字节流,反序列化就是从有序字节流重建对象,恢复对象状态.

为什么需要序列化与反序列化

我们知道，当两个进程进行远程通信时，可以相互发送各种类型的数据，包括文本、图片、音频、视频等， 而这些数据都会以二进制序列的形式在网络上传送。

那么当两个Java进程进行通信时，能否实现进程间的对象传送呢？答案是可以的！如何做到呢？这就需要Java序列化与反序列化了！

换句话说，一方面，发送方需要把这个Java对象转换为字节序列，然后在网络上传送；另一方面，接收方需要从字节序列中恢复出Java对象。

当我们明晰了为什么需要Java序列化和反序列化后，我们很自然地会想Java序列化的好处。其好处一是实现了数据的持久化，通过序列化可以把数据永久地保存到硬盘上（通常存放在文件里），二是，利用序列化实现远程通信，即在网络上传送对象的字节序列。

总的来说可以归结为以下几点：

（1）永久性保存对象，保存对象的字节序列到本地文件或者数据库中；（2）通过序列化以字节流的形式使对象在网络中进行传递和接收；（3）通过序列化在进程间传递对象；

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

先问大家一个问题：面试官问你“什么是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会做以下几件事：

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

反序列化时，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、持久化）都无从谈起。

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

到此这篇关于Java中的序列化和反序列化：让你的对象学会“变身术”的文章就介绍到这了,更多相关Java序列化和反序列化内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

最新评论