一篇文章带你了解Java 中序列化与反序列化

引言

在Java编程中，可能需要将对象存储在文件中或通过网络传输。使用序列化来处理这些任务是很常见的方法。本篇文章将介绍Java中的序列化和反序列化的概念和用法，给你提供一个完整的攻略。

Serializable 接口

Java 中的序列化和反序列化要求被序列化的类必须实现 Serializable 接口。实现 Serializable 接口只需要在序列化类的定义中添加一个串行化 ID 和继承 java.io.Serializable 接口。

// Foo.java
import java.io.Serializable;

public class Foo implements Serializable {
    private static final long serialVersionUID = 1L;
    // class definition
}

在上面的代码中，Foo 类实现了 Serializable 接口，在类定义中添加了 serialVersionUID 常量。这将使 Foo 变为“可串行化”。

序列化

当需要将一个 Java 对象转化为字节时，就发生了序列化。序列化使用 ObjectOutputStream 完成。

// SerializeDemo.java
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class SerializeDemo {
    public static void main(String[] args) {
        Employee e = new Employee();
        e.name = "Alice";
        e.address = "1 Main St, Seattle, WA";
        e.SSN = 123456789;
        e.number = 1001;
        try (FileOutputStream fileOut = new FileOutputStream("employee.ser");
             ObjectOutputStream out = new ObjectOutputStream(fileOut)) {
            out.writeObject(e);
            System.out.println("Serialized data is saved in employee.ser");
        } catch (IOException i) {
            i.printStackTrace();
        }
    }
}

在上面这个例子中，我们将一个 Employee 对象序列化并写入文件 employee.ser 中。示例中的 Employee 类需要实现 Serializable 接口。

反序列化

当需要从字节中重新构建一个 Java 对象时，就需要反序列化该字节。反序列化使用 ObjectInputStream 完成。

// DeserializeDemo.java
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class DeserializeDemo {
    public static void main(String[] args) {
        Employee e = null;
        try (FileInputStream fileIn = new FileInputStream("employee.ser");
             ObjectInputStream in = new ObjectInputStream(fileIn)) {
            e = (Employee) in.readObject();
        } catch (IOException i) {
            i.printStackTrace();
            return;
        } catch (ClassNotFoundException c) {
            System.out.println("Employee class not found.");
            c.printStackTrace();
            return;
        }
        System.out.println("Deserialized Employee...");
        System.out.println("Name: " + e.name);
        System.out.println("Address: " + e.address);
        System.out.println("SSN: " + e.SSN);
        System.out.println("Number: " + e.number);
    }
}

在上面的代码中，我们从文件 employee.ser 中反序列化 Employee 对象并打印它们的一些属性。注意，反序列化需要抛出 ClassNotFoundException 异常。当程序无法找到要反序列化的类时，这个异常就会被抛出。

示例一

这里是一个使用序列化的示例，我们将会序列化一个 Employee 对象并写入文件中：

// SerializeDemo.java
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class SerializeDemo {
    public static void main(String[] args) {
        Employee e = new Employee();
        e.name = "Alice";
        e.address = "1 Main St, Seattle, WA";
        e.SSN = 123456789;
        e.number = 1001;
        try (FileOutputStream fileOut = new FileOutputStream("employee.ser");
             ObjectOutputStream out = new ObjectOutputStream(fileOut)) {
            out.writeObject(e);
            System.out.println("Serialized data is saved in employee.ser");
        } catch (IOException i) {
            i.printStackTrace();
        }
    }
}

示例二

下面是一个使用反序列化的示例，我们将从文件 employee.ser 中读取 Employee 对象并打印它们的属性：

// DeserializeDemo.java
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class DeserializeDemo {
    public static void main(String[] args) {
        Employee e = null;
        try (FileInputStream fileIn = new FileInputStream("employee.ser");
             ObjectInputStream in = new ObjectInputStream(fileIn)) {
            e = (Employee) in.readObject();
        } catch (IOException i) {
            i.printStackTrace();
            return;
        } catch (ClassNotFoundException c) {
            System.out.println("Employee class not found.");
            c.printStackTrace();
            return;
        }
        System.out.println("Deserialized Employee...");
        System.out.println("Name: " + e.name);
        System.out.println("Address: " + e.address);
        System.out.println("SSN: " + e.SSN);
        System.out.println("Number: " + e.number);
    }
}

在这两个示例中，我们使用了 SerializeDemo 和 DeserializeDemo 两个 Java 类，它们分别完成了序列化和反序列化的功能。同时，为了序列化我们创建了 Employee 类并注册了 Serializable 接口。

结论

Java 中的序列化和反序列化是将 Java 对象转化为字节并反转以获取原始对象的一种方式。在实现 Serializable 接口、序列化以及反序列化方面，我们应该时刻注意细节。

本文介绍了如何通过 Java 中实现 Serializable 接口的对象使用序列化和反序列化来存储和加载 Java 对象。同时，也演示了如何在 Java 程序中使用这两个技术。