JAVA进阶技术之八：探索 Java 序列化与反序列化的原理及应用
小标题：Java 开发者必知：序列化与反序列化的深度探索全解析！
一、引言
在 Java 编程的世界里，序列化与反序列化是两个极为重要的概念。当我们需要将对象的状态保存下来，以便在程序下次运行时恢复，或者将对象在网络中传输，又或者实现进程间通信时，序列化与反序列化就如同桥梁一般，连接着不同的运行时环境与存储介质。比如，在一个电商系统中，我们可能需要将用户的购物车信息序列化后存储在本地，以便用户下次登录时能够快速恢复购物车状态；在分布式系统中，不同节点之间传输数据对象也离不开序列化与反序列化。接下来，就让我们深入探究 Java 中序列化与反序列化的奥秘。
###二、序列化与反序列化的概念
序列化，简单来说，就是将 Java 对象转换为字节序列的过程。就好比把一个复杂的物体（Java 对象）拆解成一个个零件（字节），并按照特定的顺序排列好，以便于存储或传输。例如，我们有一个 User 对象，它包含了用户名、密码、年龄等信息，序列化后就变成了一串字节流，这些字节流可以被保存到文件中或者通过网络发送出去。
反序列化则是序列化的逆过程，即将字节序列恢复为原来的 Java 对象。就像是把之前拆解并排列好的零件（字节序列）重新组装成原来的物体（Java 对象），使得我们可以在程序中继续使用这个对象及其包含的信息。 以下是一个简单的示例代码，帮助大家更好地理解这两个概念：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
class User implements Serializable {
private String username;
private String password;
private int age;
public User(String username, String password, int age) {
this.username = username;
this.password = password;
this.age = age;
}
@Override
public String toString() {
return "User{" +
"username='" + username + '\'' +
", password='" + password + '\'' +
", age=" + age +
'}';
}
}
public class SerializationExample {
public static void main(String[] args) {
// 创建一个 User 对象
User user = new User("John", "123456", 25);
// 序列化对象到文件
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.ser"))) {
oos.writeObject(user);
System.out.println("对象已序列化并保存到 user.ser 文件中。");
} catch (IOException e) {
e.printStackTrace();
}
// 从文件中反序列化对象
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.ser"))) {
User deserializedUser = (User) ois.readObject();
System.out.println("从文件中反序列化出的对象：" + deserializedUser);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
在上述代码中，User 类实现了 Serializable 接口，表示该类的对象可以被序列化。main 方法中首先创建了一个 User 对象，然后通过 ObjectOutputStream 将其序列化并保存到名为 "user.ser" 的文件中。接着，使用 ObjectInputStream 从文件中读取字节序列并反序列化为 User 对象，最后打印出反序列化后的对象信息。 通过这个例子，我们可以清晰地看到序列化将对象转换为字节流并保存到文件，反序列化则从文件中读取字节流并还原为对象的过程。这一过程在很多场景中都非常有用，比如将用户的登录信息序列化后存储在本地，下次登录时再反序列化出来，避免用户重复输入；或者在分布式系统中，将对象在不同节点之间进行传输时，就需要先将对象序列化，接收方再进行反序列化操作，从而实现数据的共享和交互。
三、如何在 Java 中实现序列化与反序列化
（一）实现 Serializable 接口 在 Java 中，要使一个类的对象能够被序列化，首先需要让该类实现 Serializable 接口。Serializable 接口是一个标记接口，它没有任何方法，仅用于标识该类的对象可以被序列化。例如：
import java.io.Serializable;
class User implements Serializable {
private String username;
private String password;
private int age;
// 构造方法、getter和setter方法等
@Override
public String toString() {
return "User{" +
"username='" + username + '\'' +
", password='" + password + '\'' +
", age=" + age +
'}';
}
}
在上述代码中，User 类实现了 Serializable 接口，这就表明 User 类的对象可以被序列化。需要注意的是，如果一个类的父类没有实现 Serializable 接口，那么子类在实现 Serializable 接口时，父类的非 transient 成员变量不会被序列化，除非父类有无参构造器。
另外，还有一个重要的概念是 serialVersionUID。每个实现了 Serializable 接口的类都有一个与之关联的 serialVersionUID，它是一个用于标识类的序列化版本的静态常量。如果在反序列化时，读取到的字节流中的 serialVersionUID 与当前类的 serialVersionUID 不匹配，就会抛出 InvalidClassException 异常。serialVersionUID 的默认值是由 Java 编译器根据类的结构自动生成的，但为了确保在类的结构发生变化时序列化的兼容性，最好显式地定义 serialVersionUID。例如：
private static final long serialVersionUID = 1L;
可以使用 JDK 自带的 serialver 工具来生成 serialVersionUID 的值，也可以根据类的包名、类名、继承关系、非私有方法和属性等信息计算得出一个唯一的哈希值作为 serialVersionUID。
（二）使用 ObjectOutputStream 进行序列化
ObjectOutputStream 类是用于将对象序列化为字节流的关键类。它提供了 writeObject 方法，可以将一个对象转换为字节序列并输出到指定的目标，如文件或网络流。
以下是使用 ObjectOutputStream 进行序列化的基本步骤： 1.创建一个 FileOutputStream 对象，用于指定序列化后数据的输出位置（这里以文件为例）。 2.创建一个 ObjectOutputStream 对象，将 FileOutputStream 对象作为参数传递给它的构造函数。 3.使用 ObjectOutputStream 的 writeObject 方法将需要序列化的对象写入到输出流中。 4.关闭 ObjectOutputStream 流，释放相关资源。
示例代码如下：
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class SerializationExample {
public static void main(String[] args) {
User user = new User("John", "123456", 25);
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.ser"))) {
oos.writeObject(user);
System.out.println("对象已序列化并保存到 user.ser 文件中。");
} catch (IOException e) {
e.printStackTrace();
}
}
}
在上述代码中，首先创建了一个 User 对象，然后通过 ObjectOutputStream 将其序列化并保存到名为 "user.ser" 的文件中。writeObject 方法会递归地将对象的各个非 transient 字段以及其引用的其他对象（如果这些对象也实现了 Serializable 接口）一起序列化为字节流。
（三）使用 ObjectInputStream 进行反序列化
ObjectInputStream 类则用于从字节流中读取数据并反序列化为对象。它的 readObject 方法可以从输入流中读取字节序列，并将其转换为对应的对象。 使用 ObjectInputStream 进行反序列化的步骤如下：
1.创建一个 FileInputStream 对象，用于指定从哪里读取序列化数据（这里以文件为例）。 2.创建一个 ObjectInputStream 对象，将 FileInputStream 对象作为参数传递给它的构造函数。 3.使用 ObjectInputStream 的 readObject 方法从输入流中读取字节序列并反序列化为对象，需要注意的是，读取的顺序要与序列化时写入的顺序一致。 4.关闭 ObjectInputStream 流，释放相关资源。
示例代码如下：
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class DeserializationExample {
public static void main(String[] args) {
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.ser"))) {
User deserializedUser = (User) ois.readObject();
System.out.println("从文件中反序列化出的对象：" + deserializedUser);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
在上述代码中，通过 ObjectInputStream 从 "user.ser" 文件中读取字节序列，并将其反序列化为 User 对象，然后打印出反序列化后的对象信息。如果在反序列化过程中找不到对应的类定义，或者字节流中的数据格式不正确，就会抛出相应的异常，如 ClassNotFoundException 或 InvalidClassException 等。
四、代码示例解析
（一）定义可序列化类
以下是一个简单的 Person 类，它包含了基本数据类型的属性 name 和 age，并实现了 Serializable 接口。同时，我们显式地定义了 serialVersionUID，以确保在类的结构发生变化时序列化的兼容性。
import java.io.Serializable;
class Person implements Serializable {
private static final long serialVersionUID = 1234567890L;
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
（二）序列化操作示例
在 main 方法中，我们创建了一个 Person 对象，并使用 ObjectOutputStream 将其序列化到文件 person.ser 中。在这个过程中，我们需要处理可能出现的 IOException。
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class SerializationExample {
public static void main(String[] args) {
Person person = new Person("John", 25);
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
oos.writeObject(person);
System.out.println("对象已序列化并保存到 person.ser 文件中。");
} catch (IOException e) {
e.printStackTrace();
}
}
}
（三）反序列化操作示例
接着，我们使用 ObjectInputStream 从文件 person.ser 中读取字节流，并反序列化出 Person 对象。同样，我们需要处理可能出现的 IOException 和 ClassNotFoundException。最后，我们通过打印对象的属性来验证反序列化的结果。
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class DeserializationExample {
public static void main(String[] args) {
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
Person deserializedPerson = (Person) ois.readObject();
System.out.println("从文件中反序列化出的对象：" + deserializedPerson);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
在上述代码中，Person 类实现了 Serializable 接口，这使得它的对象可以被序列化和反序列化。SerializationExample 类中的 main 方法演示了如何将 Person 对象序列化到文件中，而 DeserializationExample 类中的 main 方法则展示了如何从文件中反序列化出 Person 对象。 在实际应用中，序列化和反序列化的操作可能会更加复杂，例如涉及到对象的嵌套、继承关系，以及对序列化过程的自定义控制等。但无论如何，理解和掌握这些基本的序列化和反序列化操作是非常重要的，它为我们在处理对象的持久化存储、网络传输等方面提供了有力的工具。
五、序列化与反序列化的应用场景
（一）数据持久化
在很多应用程序中，我们需要将对象的状态持久化保存，以便在程序下次运行时能够恢复。序列化就为我们提供了一种便捷的方式来实现数据持久化。例如，在一个游戏中，玩家的游戏进度、角色属性、装备信息等都可以封装成对象，通过序列化将这些对象保存到文件中。当玩家下次启动游戏时，游戏程序从文件中读取序列化数据并进行反序列化，恢复玩家的游戏状态，这样玩家就可以继续之前的游戏进程。
以下是一个简单的示例，展示如何将一个游戏角色对象序列化后保存到文件中，并在下次运行时读取恢复：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
class GameCharacter implements Serializable {
private String name;
private int level;
private int health;
public GameCharacter(String name, int level, int health) {
this.name = name;
this.level = level;
this.health = health;
}
@Override
public String toString() {
return "GameCharacter{" +
"name='" + name + '\'' +
", level=" + level +
", health=" + health +
'}';
}
}
public class GameSaveExample {
public static void main(String[] args) {
// 创建游戏角色对象
GameCharacter character = new GameCharacter("Warrior", 10, 80);
// 序列化角色对象到文件
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("gameSave.ser"))) {
oos.writeObject(character);
System.out.println("游戏角色已序列化并保存到 gameSave.ser 文件中。");
} catch (IOException e) {
e.printStackTrace();
}
// 模拟程序关闭后再次启动
// 从文件中反序列化角色对象
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("gameSave.ser"))) {
GameCharacter loadedCharacter = (GameCharacter) ois.readObject();
System.out.println("从文件中反序列化出的游戏角色：" + loadedCharacter);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
在上述代码中，GameCharacter 类实现了 Serializable 接口，其对象可以被序列化。main 方法中先创建了一个游戏角色对象，然后将其序列化保存到名为 "gameSave.ser" 的文件中。之后，模拟程序再次启动，从文件中读取序列化数据并反序列化出游戏角色对象，最后打印出角色信息。 除了游戏中的应用，序列化在其他需要数据持久化的场景中也非常常见。比如，应用程序的配置信息可以封装成对象进行序列化保存。当应用程序启动时，读取配置文件并反序列化出配置对象，根据配置信息进行初始化设置。这样，用户可以方便地修改配置文件来调整应用程序的行为，而无需重新编译代码。
（二）远程通信
在分布式系统中，不同的组件可能运行在不同的 Java 虚拟机（JVM）甚至不同的物理机器上。这些组件之间需要进行通信和数据交互，而序列化与反序列化就成为了实现这种远程通信的关键技术。
例如，在一个基于 RPC（远程过程调用）的分布式系统中，一个服务提供者（Server）提供了某些方法供远程客户端（Client）调用。当客户端调用远程方法时，需要将方法的参数对象序列化为字节流，然后通过网络传输到服务端。服务端接收到字节流后，进行反序列化操作，将字节流还原为参数对象，然后执行相应的方法，并将结果对象序列化为字节流返回给客户端。客户端再对返回的字节流进行反序列化，得到最终的结果。
以下是一个简单的 RPC 示例代码，展示了序列化与反序列化在远程通信中的应用：
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.io.Serializable;
// 定义可序列化的请求对象
class RpcRequest implements Serializable {
private String methodName;
private Object[] parameters;
public RpcRequest(String methodName, Object[] parameters) {
this.methodName = methodName;
this.parameters = parameters;
}
public String getMethodName() {
return methodName;
}
public Object[] getParameters() {
return parameters;
}
}
// 定义可序列化的响应对象
class RpcResponse implements Serializable {
private Object result;
public RpcResponse(Object result) {
this.result = result;
}
public Object getResult() {
return result;
}
}
// 服务端实现
class RpcServer {
public void start(int port) {
try (ServerSocket serverSocket = new ServerSocket(port)) {
System.out.println("RPC 服务端已启动，监听端口：" + port);
while (true) {
// 接受客户端连接
Socket socket = serverSocket.accept();
// 处理客户端请求
handleRequest(socket);
}
} catch (IOException e) {
e.printStackTrace();
}
}
private void handleRequest(Socket socket) {
try (ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream())) {
// 读取客户端发送的请求对象
RpcRequest request = (RpcRequest) ois.readObject();
// 根据请求调用相应的方法并获取结果
Object result = invokeMethod(request.getMethodName(), request.getParameters());
// 创建响应对象并写入输出流
RpcResponse response = new RpcResponse(result);
oos.writeObject(response);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
private Object invokeMethod(String methodName, Object[] parameters) {
// 这里简单模拟根据方法名调用相应方法并返回固定结果
if ("add".equals(methodName)) {
int sum = 0;
for (Object param : parameters) {
if (param instanceof Integer) {
sum += (Integer) param;
}
}
return sum;
}
return null;
}
}
// 客户端实现
class RpcClient {
public Object sendRequest(String host, int port, RpcRequest request) {
try (Socket socket = new Socket(host, port);
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream())) {
// 发送请求对象到服务端
oos.writeObject(request);
// 读取服务端返回的响应对象
RpcResponse response = (RpcResponse) ois.readObject();
return response.getResult();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
}
public class RpcExample {
public static void main(String[] args) {
// 启动服务端
RpcServer server = new RpcServer();
server.start(8080);
// 客户端发送请求
RpcClient client = new RpcClient();
RpcRequest request = new RpcRequest("add", new Object[]{1, 2, 3});
Object result = client.sendRequest("localhost", 8080, request);
System.out.println("RPC 调用结果：" + result);
}
}
在上述代码中，RpcRequest 和 RpcResponse 分别作为远程调用的请求和响应对象，都实现了 Serializable 接口。RpcServer 类表示服务端，它监听指定端口，接受客户端连接后，读取请求对象，根据请求调用相应方法并将结果封装成响应对象返回给客户端。RpcClient 类则用于客户端发送请求并接收响应。在 main 方法中，首先启动服务端，然后客户端创建请求对象并发送到服务端，最后接收并打印服务端返回的结果。
除了 RPC，在 Web 服务中，序列化与反序列化也起着重要作用。例如，当客户端通过 HTTP 协议向服务器发送 JSON 或 XML 格式的数据时，服务器端需要将接收到的数据反序列化为相应的对象进行处理。处理完成后，又将结果对象序列化为 JSON 或 XML 格式返回给客户端。这种数据的序列化与反序列化操作在前后端分离的架构中尤为常见，它使得不同语言和平台之间能够方便地进行数据交互。
六、注意事项与最佳实践
（一）serialVersionUID 的管理
在 Java 序列化中，serialVersionUID是一个关键元素，它用于标识类的序列化版本。如果在反序列化时，读取到的字节流中的serialVersionUID与当前类的serialVersionUID不匹配，就会抛出InvalidClassException异常。因此，显式定义serialVersionUID至关重要。
当类的结构发生变化时，如何合理更新serialVersionUID值以确保序列化兼容性或控制版本不兼容情况，是开发者需要重点考虑的问题。例如，如果只是对类进行了一些不影响序列化兼容性的修改，如添加新的方法、修改非序列化字段等，可以保持serialVersionUID不变。但如果对序列化字段进行了修改、删除或增加，就需要根据具体情况判断是否更新serialVersionUID。
以一个简单的Employee类为例，初始时它包含name和age两个字段：
import java.io.Serializable;
class Employee implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int age;
// 构造方法、getter和setter方法等
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
如果后续为Employee类添加了一个新的字段salary，但希望保持与之前序列化数据的兼容性，可以不更新serialVersionUID。在反序列化时，新添加的salary字段将被赋予默认值（如基本数据类型的默认值）。
class Employee implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int age;
private double salary;
// 构造方法、getter和setter方法等
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", age=" + age +
", salary=" + salary +
'}';
}
}
然而，如果修改了name字段的类型，从String改为StringBuilder，这将导致序列化不兼容，此时就应该更新serialVersionUID，以避免反序列化错误：
class Employee implements Serializable {
private static final long serialVersionUID = 2L;
private StringBuilder name;
private int age;
private double salary;
// 构造方法、getter和setter方法等
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", age=" + age +
", salary=" + salary +
'}';
}
}
（二）敏感信息处理
序列化可能带来安全风险，因为当对象被序列化时，其所有字段（包括私有字段）都会被转换为字节流。如果这些字段包含敏感信息，如密码、个人身份信息等，一旦序列化数据被未授权访问，敏感信息就可能被泄露。
为了避免这种情况，对于包含敏感信息的类，应避免实现Serializable接口。如果必须序列化，确保敏感数据字段被标记为transient，这样它们就不会被包含在序列化数据中。例如：
import java.io.Serializable;
class User implements Serializable {
private String username;
private transient String password;
private int age;
// 构造方法、getter和setter方法等
@Override
public String toString() {
return "User{" +
"username='" + username + '\'' +
", password='" + password + '\'' +
", age=" + age +
'}';
}
}
在上述User类中，password字段被标记为transient，在序列化时将不会被保存到字节流中。
此外，还可以考虑使用加密技术来保护序列化数据。例如，在序列化之前对敏感数据进行加密，在反序列化之后再进行解密。这样即使序列化数据被泄露，攻击者也难以获取到原始的敏感信息。
（三）性能考虑
序列化和反序列化操作可能会对性能产生影响，特别是在大量数据处理或频繁网络传输时。为了提高性能，可以考虑采用更高效的序列化框架。
例如，Google 的 Protocol Buffers 和 Apache 的 Avro 等序列化库通常提供更严格的类型检查和更小的攻击面，从而减少安全风险，并且在性能上往往优于 Java 原生的序列化机制。在一些性能要求较高的场景中，使用这些序列化库可以显著提升应用的性能。
另外，优化对象结构也可以提高序列化和反序列化的效率。例如，减少不必要的字段、避免使用复杂的对象层次结构等。同时，合理使用transient关键字标记不需要序列化的字段，可以减少序列化的数据量，从而提高性能。
七、总结
序列化与反序列化在 Java 编程中扮演着不可或缺的角色。通过本文的详细阐述，我们了解到序列化是将 Java 对象转换为字节序列的过程，反序列化则是其逆过程，将字节序列恢复为 Java 对象。在实现方面，让类实现Serializable 接口是基础，同时要合理管理 serialVersionUID 以确保版本兼容性。在应用场景上，数据持久化和远程通信是其两大重要应用领域，无论是保存游戏进度还是分布式系统中的数据交互，都离不开序列化与反序列化。然而，我们也不能忽视其注意事项，如对敏感信息的处理以保障安全性，以及采用高效的序列化框架和优化对象结构来提升性能等。掌握好序列化与反序列化技术，能够让我们在 Java 开发中更加游刃有余地处理对象的存储与传输，构建出更加稳定、高效的应用程序。
最近一直在研究AI公众号爆文的运维逻辑，也在学习各种前沿的AI技术，加入了不会笑青年和纯洁的微笑两位大佬组织起来的知识星球，也开通了自己的星球：
怡格网友圈，地址是：https://wx.zsxq.com/group/51111855584224
这是一个付费的星球，暂时我还没想好里面放什么，现阶段不建议大家付费和进入我自己的星球，即使有不小心付费的，我也会直接退费，无功不受禄。如果你也对AI特别感兴趣，推荐你付费加入他们的星球：
AI俱乐部，地址是：https://t.zsxq.com/mRfPc 。
建议大家先加
微信号:yeegee2024
或者关注微信公众号:yeegeexb2014
咱们产品成型了之后，咱们再一起进入星球，一起探索更美好的未来！