【Java 基础篇】Java对象反序列化流详解

Bertha 。 2023-10-16 10:53 9阅读 0赞

![在这里插入图片描述][e5bac20a22bb4882a9efd38c3303380e.png]

在Java编程中，对象序列化和反序列化是常见的操作，用于将对象转换为字节流以便于存储或传输，并从字节流中重新构建对象。本文将重点介绍对象反序列化流的用法和相关概念，帮助基础小白理解这一重要的主题。

## 什么是对象反序列化？ ##

对象反序列化是将之前序列化的对象字节流还原为对象的过程。这个过程是序列化的逆过程，它可以让我们重新获得原始的Java对象，包括对象的状态和数据。反序列化是一种重要的机制，用于在Java中实现数据的持久化和跨网络通信。

对象反序列化的核心类是`ObjectInputStream`，它提供了一种方法来读取已序列化的对象数据并将其还原为Java对象。

## ObjectInputStream的基本用法 ##

要使用`ObjectInputStream`，首先需要创建一个输入流并将其连接到包含序列化对象的数据源，通常是一个文件或网络连接。接下来，您可以使用`ObjectInputStream`来读取对象。

下面是一个基本的对象反序列化示例：

import java.io.*;
    
    public class ObjectDeserializationExample {
        
        public static void main(String[] args) {
        
            try {
        
                // 创建一个输入流，连接到包含序列化对象的文件
                FileInputStream fileIn = new FileInputStream("serializedObject.ser");
                ObjectInputStream in = new ObjectInputStream(fileIn);
    
                // 使用ObjectInputStream读取对象
                MyClass deserializedObject = (MyClass) in.readObject();
    
                // 关闭流
                in.close();
                fileIn.close();
    
                // 使用反序列化后的对象
                System.out.println("Deserialized Object: " + deserializedObject);
            } catch (IOException | ClassNotFoundException e) {
        
                e.printStackTrace();
            }
        }
    }

上述示例中，我们使用`FileInputStream`将对象反序列化流连接到一个包含序列化对象的文件。然后，我们使用`ObjectInputStream`的`readObject`方法来读取对象，并将其强制转换为原始的Java对象。

## Serializable接口和版本控制 ##

在进行对象序列化和反序列化时，需要确保被操作的类实现了`Serializable`接口。这个接口是一个标记接口，没有定义任何方法，但它告诉Java运行时系统这个类可以进行序列化。

import java.io.Serializable;
    
    public class MyClass implements Serializable {
        
        // 类的成员和方法
    }

另一个重要的考虑因素是版本控制。当您对一个已序列化的类进行更改时，特别是在类的字段或结构发生变化时，可能会导致版本不兼容。为了处理版本兼容性问题，可以在类中显式定义`serialVersionUID`，如下所示：

private static final long serialVersionUID = 123456789L;

通过显式定义`serialVersionUID`，您可以确保在反序列化时可以与之前的版本兼容。如果没有提供`serialVersionUID`，Java会根据类的结构自动生成版本号，这可能会导致反序列化失败。

## 自定义序列化与`writeObject`、`readObject`方法 ##

有时，您可能需要自定义对象的序列化和反序列化过程，以满足特定需求。您可以在类中定义以下两个方法：

*  `private void writeObject(ObjectOutputStream out) throws IOException`：这个方法在对象序列化时自动被调用。您可以在其中编写自定义的序列化逻辑。
 *  `private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException`：这个方法在对象反序列化时自动被调用。您可以在其中编写自定义的反序列化逻辑。

这两个方法的签名必须与上述示例中的一致。

## 序列化的性能和安全性考虑 ##

尽管对象序列化和反序列化是强大的工具，但在性能和安全性方面需要谨慎。以下是一些性能和安全性方面的考虑：

### 性能考虑 ###

*  序列化和反序列化可能是昂贵的操作，特别是对大型对象或大量对象的处理。要谨慎使用它们，以避免性能问题。
 *  考虑使用更轻量级的序列化格式，如JSON或Protocol Buffers，以提高性能。

### 安全性考虑 ###

*  反序列化操作可能存在安全风险，因为恶意用户可以创建恶意的序列化数据。要确保只反序列化来自受信任源的数据，并对反序列化的数据进行有效验证。
 *  考虑使用安全的序列化机制，如Java的序列化过滤器或自定义的反序列化控制，以减少安全风险。

## 常用示例 ##

当涉及对象反序列化时，通常有以下几个常见的应用场景。以下是一些示例：

### 1. 从文件中加载配置数据 ###

假设您的应用程序需要读取和加载配置数据，您可以使用对象序列化来将配置对象保存到文件中。然后，在应用程序启动时，您可以使用对象反序列化从文件中加载配置数据。这可以帮助您在不更改代码的情况下轻松更改和管理配置。

// 序列化配置数据到文件
    public static void serializeConfiguration(Configuration config) {
        
        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("config.ser"))) {
        
            out.writeObject(config);
        } catch (IOException e) {
        
            e.printStackTrace();
        }
    }
    
    // 从文件中反序列化配置数据
    public static Configuration deserializeConfiguration() {
        
        try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("config.ser"))) {
        
            return (Configuration) in.readObject();
        } catch (IOException | ClassNotFoundException e) {
        
            e.printStackTrace();
            return null;
        }
    }

### 2. 缓存对象 ###

有时，您可能希望将一些对象缓存到磁盘上，以便稍后重新加载它们，而不是每次都重新生成它们。对象序列化和反序列化可用于实现此功能。

// 序列化对象到缓存文件
    public static void serializeToCache(Object object, String cacheKey) {
        
        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(cacheKey))) {
        
            out.writeObject(object);
        } catch (IOException e) {
        
            e.printStackTrace();
        }
    }
    
    // 从缓存文件中反序列化对象
    public static Object deserializeFromCache(String cacheKey) {
        
        try (ObjectInputStream in = new ObjectInputStream(new FileInputStream(cacheKey))) {
        
            return in.readObject();
        } catch (IOException | ClassNotFoundException e) {
        
            e.printStackTrace();
            return null;
        }
    }

### 3. 跨网络传输对象 ###

在分布式系统中，您可能需要将对象从一个地方传输到另一个地方。对象序列化可用于将对象转换为字节流，并在网络上传输，然后在接收端进行反序列化。

// 服务器端 - 序列化并发送对象
    try (ServerSocket serverSocket = new ServerSocket(12345)) {
        
        while (true) {
        
            Socket clientSocket = serverSocket.accept();
            ObjectOutputStream out = new ObjectOutputStream(clientSocket.getOutputStream());
            out.writeObject(myObject);
            out.close();
            clientSocket.close();
        }
    } catch (IOException e) {
        
        e.printStackTrace();
    }
    
    // 客户端 - 接收并反序列化对象
    try (Socket socket = new Socket("server-hostname", 12345)) {
        
        ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
        MyObject receivedObject = (MyObject) in.readObject();
        in.close();
    } catch (IOException | ClassNotFoundException e) {
        
        e.printStackTrace();
    }

### 4. 数据持久化 ###

对象序列化还可以用于数据持久化，特别是在应用程序需要长期存储和恢复数据时。例如，您可以使用对象序列化将用户的应用程序状态保存在文件中，以便在下一次启动应用程序时恢复该状态。

// 序列化应用程序状态到文件
    public static void serializeAppState(AppState state) {
        
        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("appstate.ser"))) {
        
            out.writeObject(state);
        } catch (IOException e) {
        
            e.printStackTrace();
        }
    }
    
    // 从文件中反序列化应用程序状态
    public static AppState deserializeAppState() {
        
        try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("appstate.ser"))) {
        
            return (AppState) in.readObject();
        } catch (IOException | ClassNotFoundException e) {
        
            e.printStackTrace();
            return null;
        }
    }

### 5. 消息传递 ###

在分布式系统中，消息传递是一种常见的通信方式。对象序列化和反序列化可用于将消息封装为对象，并在系统的不同部分之间传递消息。

// 发送方 - 序列化消息并发送
    Message message = new Message("Hello, world!");
    try (Socket socket = new Socket("server-hostname", 12345)) {
        
        ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
        out.writeObject(message);
        out.close();
    } catch (IOException e) {
        
        e.printStackTrace();
    }
    
    // 接收方 - 接收并反序列化消息
    try (ServerSocket serverSocket = new ServerSocket(12345)) {
        
        while (true) {
        
            Socket clientSocket = serverSocket.accept();
            ObjectInputStream in = new ObjectInputStream(clientSocket.getInputStream());
            Message receivedMessage = (Message) in.readObject();
            in.close();
            clientSocket.close();
            // 处理接收到的消息
        }
    } catch (IOException | ClassNotFoundException e) {
        
        e.printStackTrace();
    }

这些示例涵盖了对象反序列化的几个常见用途场景，包括配置管理、对象缓存、跨网络传输、数据持久化和消息传递。通过对象序列化，您可以在不同的上下文中轻松地传输、存储和加载对象数据。

## 总结 ##

对象反序列化是Java中重要的编程概念，用于将序列化的对象还原为原始的Java对象。通过了解`ObjectInputStream`的基本用法、`Serializable`接口、版本控制、自定义序列化和性能、安全性考虑，您可以更好地使用和理解对象反序列化流。但请谨慎使用它，特别是在面临性能和安全性问题时。

[e5bac20a22bb4882a9efd38c3303380e.png]: https://img-blog.csdnimg.cn/e5bac20a22bb4882a9efd38c3303380e.png