深入理解Java对象序列化(Java对象序列化深度解析与实战应用)

原创

ithorizon 6个月前 (10-21) 阅读数 21 #后端开发

Java对象序列化深度解析与实战应用

一、Java对象序列化的概念与作用

Java对象序列化是指将Java对象的状态信息变成可存储或可传输的形式的过程。它允许我们将Java对象的状态保存到文件、数据库或网络中，以便在需要时恢复对象状态。对象序列化在Java中具有广泛的应用，如网络通信、数据持久化、对象复制等。

二、Java对象序列化的原理

Java对象序列化是通过实现java.io.Serializable接口来实现的。Serializable接口是一个标记接口，不包含任何方法。当一个类实现了Serializable接口时，它的对象就可以被序列化和反序列化。

三、Java对象序列化的步骤

1. 创建一个实现了Serializable接口的类。

2. 使用ObjectOutputStream对象将对象写入到输出流中。

3. 使用ObjectInputStream对象从输入流中读取对象。

四、Java对象序列化的注意事项

1. 静态成员变量不会被序列化。

2. transient关键字修饰的成员变量不会被序列化。

3. 序列化时，对象的类和版本号（serialVersionUID）必须一致，否则无法反序列化。

4. 序列化过程中，父类对象也会被序列化，除非父类也实现了Serializable接口。

五、Java对象序列化实战应用

5.1 对象序列化到文件

以下是一个将对象序列化到文件的示例：


import java.io.*;
public class ObjectOutputStreamExample {
    public static void main(String[] args) {
        // 创建对象
        Person person = new Person("张三", 30);
        try {
            // 创建文件输出流
            FileOutputStream fileOut = new FileOutputStream("person.ser");
            // 创建对象输出流
            ObjectOutputStream out = new ObjectOutputStream(fileOut);
            // 序列化对象
            out.writeObject(person);
            // 关闭流
            out.close();
            fileOut.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
class Person implements Serializable {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 省略getter和setter方法
}

5.2 对象反序列化

以下是一个从文件中反序列化对象的示例：


import java.io.*;
public class ObjectInputStreamExample {
    public static void main(String[] args) {
        Person person = null;
        try {
            // 创建文件输入流
            FileInputStream fileIn = new FileInputStream("person.ser");
            // 创建对象输入流
            ObjectInputStream in = new ObjectInputStream(fileIn);
            // 反序列化对象
            person = (Person) in.readObject();
            // 关闭流
            in.close();
            fileIn.close();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        // 输出对象信息
        System.out.println(person.getName() + " - " + person.getAge());
    }
}

六、Java对象序列化的进阶应用

6.1 自定义序列化过程

在某些情况下，我们也许需要自定义对象的序列化过程。这可以通过实现java.io.Serializable接口的writeObject和readObject方法来实现。


import java.io.*;
public class CustomSerializableExample {
    public static void main(String[] args) {
        // 创建对象
        Person person = new Person("李四", 25);
        try {
            // 创建文件输出流
            FileOutputStream fileOut = new FileOutputStream("person.ser");
            // 创建对象输出流
            ObjectOutputStream out = new ObjectOutputStream(fileOut);
            // 序列化对象
            out.writeObject(person);
            // 关闭流
            out.close();
            fileOut.close();
            // 创建文件输入流
            FileInputStream fileIn = new FileInputStream("person.ser");
            // 创建对象输入流
            ObjectInputStream in = new ObjectInputStream(fileIn);
            // 反序列化对象
            person = (Person) in.readObject();
            // 关闭流
            in.close();
            fileIn.close();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        // 输出对象信息
        System.out.println(person.getName() + " - " + person.getAge());
    }
}
class Person implements Serializable {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject();
        out.writeInt(name.length());
    }
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject();
        int length = in.readInt();
        name = name.substring(0, length);
    }
    // 省略getter和setter方法
}

6.2 使用序列化进行对象复制

序列化也可以用于对象的深拷贝，以下是一个示例：


import java.io.*;
public class DeepCopyExample {
    public static void main(String[] args) {
        // 创建对象
        Person originalPerson = new Person("王五", 28);
        // 序列化对象
        try {
            ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
            ObjectOutputStream out = new ObjectOutputStream(byteOut);
            out.writeObject(originalPerson);
            out.close();
            // 反序列化对象
            ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
            ObjectInputStream in = new ObjectInputStream(byteIn);
            Person clonedPerson = (Person) in.readObject();
            in.close();
            // 输出对象信息
            System.out.println("Original: " + originalPerson.getName() + " - " + originalPerson.getAge());
            System.out.println("Cloned: " + clonedPerson.getName() + " - " + clonedPerson.getAge());
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
class Person implements Serializable {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 省略getter和setter方法
}