Java中对象序列化和反序列化方法_技术教程

Java通过实现Serializable接口实现对象序列化与反序列化，使用ObjectOutputStream和ObjectInputStream进行读写操作，推荐显式声明serialVersionUID以确保版本兼容性；transient关键字可标记不参与序列化的字段，用于保护敏感数据；通过自定义writeObject和readObject方法能控制序列化过程，实现加密等逻辑；但反序列化存在安全风险，如任意代码执行漏洞，需通过过滤类、避免序列化敏感信息等方式防范。

Java中对象序列化和反序列化，简单来说，就是把Java对象转换成字节流，以及把字节流恢复成Java对象的过程。这对于持久化对象状态，或者在网络上传输对象非常有用。

序列化：将Java对象转换为字节流。反序列化：将字节流转换回Java对象。

序列化和反序列化在Java中是如何实现的？

要让一个Java对象能够被序列化，需要实现

java.io.Serializable

接口。这个接口是一个标记接口，没有任何方法需要实现，它的作用就是告诉JVM，这个类的对象是可以被序列化的。

import java.io.*;

public class MyObject implements Serializable {
    private static final long serialVersionUID = 1L; // 推荐显式声明
    private String name;
    private int age;

    public MyObject(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public static void main(String[] args) {
        MyObject obj = new MyObject("Alice", 30);

        // 序列化
        try (FileOutputStream fileOut = new FileOutputStream("myobject.ser");
             ObjectOutputStream out = new ObjectOutputStream(fileOut)) {
            out.writeObject(obj);
            System.out.println("Serialized data is saved in myobject.ser");
        } catch (IOException i) {
            i.printStackTrace();
        }

        // 反序列化
        try (FileInputStream fileIn = new FileInputStream("myobject.ser");
             ObjectInputStream in = new ObjectInputStream(fileIn)) {
            MyObject obj2 = (MyObject) in.readObject();
            System.out.println("Deserialized Object: Name = " + obj2.getName() + ", Age = " + obj2.getAge());
        } catch (IOException i) {
            i.printStackTrace();
        } catch (ClassNotFoundException c) {
            System.out.println("MyObject class not found");
            c.printStackTrace();
        }
    }
}

这段代码展示了如何将一个

MyObject

对象序列化到文件

myobject.ser

，然后再从该文件中反序列化出来。需要注意的是，

serialVersionUID

的作用。它是用来在反序列化时验证类的版本一致性的。如果类的结构发生了改变（比如增加了字段），而

serialVersionUID

没有改变，反序列化可能会失败。所以，推荐显式地声明

serialVersionUID

。

transient 关键字有什么用？

有时候，我们不希望某个字段被序列化。例如，一个密码字段，或者一个缓存对象。可以使用

transient

关键字来标记这些字段。

import java.io.*;

public class MyObject implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private transient String password; // 不会被序列化

    public MyObject(String name, String password) {
        this.name = name;
        this.password = password;
    }

    // ...
}

当对象被序列化时，

password

字段的值会被忽略。在反序列化后，

password

字段的值会是

null

(对于对象引用) 或默认值 (对于基本类型)。这是一个保护敏感数据的好方法。

自定义序列化和反序列化

Java 提供了自定义序列化和反序列化的机制，通过实现

writeObject

和

readObject

方法。这允许你控制序列化和反序列化的过程，例如，加密敏感数据，或者处理复杂的对象关系。

import java.io.*;

public class MyObject implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private transient String password;

    public MyObject(String name, String password) {
        this.name = name;
        this.password = password;
    }

    private void writeObject(ObjectOutputStream out) throws IOException {
        // 自定义序列化逻辑
        out.defaultWriteObject(); // 先序列化非 transient 字段
        // 加密 password
        String encryptedPassword = encrypt(password);
        out.writeObject(encryptedPassword);
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        // 自定义反序列化逻辑
        in.defaultReadObject(); // 先反序列化非 transient 字段
        // 解密 password
        String encryptedPassword = (String) in.readObject();
        this.password = decrypt(encryptedPassword);
    }

    private String encrypt(String password) {
        // 简单的加密示例，实际应用中需要更强的加密算法
        return new StringBuilder(password).reverse().toString();
    }

    private String decrypt(String encryptedPassword) {
        // 简单的解密示例
        return new StringBuilder(encryptedPassword).reverse().toString();
    }

    // ...
}