Java序列化和反序列化_java中哪个类可以用于字节数组反序列化对象-CSDN博客

本文链接：https://blog.csdn.net/ProgrammingWay/article/details/113091590

本文详细介绍了Java序列化的过程，包括对象的序列化和反序列化，以及如何通过ObjectOutputStream和ObjectInputStream实现。同时，强调了序列化时的注意事项，如实现Serializable接口、静态属性和transient关键字的使用。还讨论了Java序列化存在的不足，如跨语言限制和安全问题，并提到了常用的序列化替代方案如JSON和protobuf。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

1、是什么？

序列化：就是把 Java 对象转换成字节序列的过程；
反序列化：就是把字节序列恢复为 Java 对象的过程；

2、为什么？

Java 序列化机制的作用：
（1）可以把对象以字节序列的方式持久化保存到到文件中；
（2）可以将对象以字节序列的方式在网络上进行传输；

3、怎么用？

对于基本数据类型：都是可序列化的；
对于引用数据类型：一个Java对象要想实现序列化，必须实现 java.io.Serializable 接口，该接口是一个标记接口，内部没有定义任何方法；

/**
 * ...
 * @author  unascribed
 * @see java.io.ObjectOutputStream
 * @see java.io.ObjectInputStream
 * @see java.io.ObjectOutput
 * @see java.io.ObjectInput
 * @see java.io.Externalizable
 * @since   JDK1.1
 */
public interface Serializable {
}

Java 中通过对象输入输出流来实现序列化和反序列化：

java.io.ObjectOutputStream 类实现对象的序列化；
java.io.ObjectInputStream 类实现反序列化回对象；

示例：
下面是实现了序列化接口的 Person 类和一个实现序列化接口的 Car 类：

@Getter
@Setter
@ToString
public class Person implements Serializable {

    private static final long serialVersionUID = 1L;

    String name;
    int age;
    private Float height;
    //另一个对象
    List<Car> cars;
    //静态属性
    static String color = "unknown";
    //被 transient 修饰的属性
    transient Double salary;
}

@Getter
@Setter
@ToString
public class Car implements Serializable {

    private static final long serialVersionUID = 111L;

    private String brand;
    private Double price;
}

下面通过 ObjectOutputStream 将 Person 类的对象序列化后保存到 person.ser 文件中；

    @Test
    public void testSerialize() {
        //1、定义一个 Person 对象，并设置属性值
        Person person = new Person();
        person.setName("小明");
        person.setAge(25);
        person.setHeight(175.50f);
        person.setSalary(6700.00);
        Car car = new Car();
        car.setBrand("BMW");
        car.setPrice(200000.23);
        Car car2 = new Car();
        car2.setBrand("BYD");
        car2.setPrice(150000.5);
        List<Car> cars = new ArrayList<>();
        cars.add(car);
        cars.add(car2);
        person.setCars(cars);
        System.out.println("序列化对象: " + person);
        System.out.println("color: " + Person.color);

        //2、使用 ObjectOutputStream 将对象序列化后保存到文件中
        FileOutputStream os = null;
        ObjectOutputStream oos = null;
        try {
            os = new FileOutputStream("person.ser");
            oos = new ObjectOutputStream(os);
            oos.writeObject(person);
            oos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (oos != null) {
                    oos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (os != null) {
                    os.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

//打印结果：
序列化对象: Person(name=小明, age=25, height=175.5, cars=[Car(brand=BMW, price=200000.23), Car(brand=BYD, price=150000.5)], salary=6700.0)
color: unknown

接着，通过 ObjectInputStream 将 person.ser 文件反序列化成 Person 对象读取到内存中：

    @Test
    public void testDeserialize() {
        //1、使用 ObjectInputStream 将文件中的内容反序列化成 Person 对象
        InputStream is = null;
        ObjectInputStream ois = null;
        try {
            is = new FileInputStream("person.ser");
            ois = new ObjectInputStream(is);
            Person p = (Person) ois.readObject();
            System.out.println("反序列化对象: " + p);
            System.out.println("color: " + Person.color);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null) {
                    ois.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (is != null) {
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    
// 打印结果：
反序列化对象: Person(name=小明, age=25, height=175.5, cars=[Car(brand=BMW, price=200000.23), Car(brand=BYD, price=150000.5)], salary=null)
color: unknown

4、注意点：

（1）一个对象想要实现序列化，必须实现 Serializable 接口，并且其内部所有属性也必须都是可序列化的类型；
例如：如果 Person 类没有实现序列化，或者其内部的属性 Car 类没有实现序列化接口，在对 Person 对象进行序列化时，就会抛出 java.io.NotSerializableException 异常；
（2）对实现 Serializable 接口的类，通常情况下，最好需要显式的定义 serialVersionUID 字段，该字段的作用是为每个序列化类定义一个版本标识，用来保证反序列化时，遇到类的版本不兼容抛出异常；
例如：在使用 ObjectOutputStream 序列化 Person 对象时，其定义的 serialVersionUID = 1L; 但是，如果在反序列化时，其 serialVersionUID 修改为 2L; 就会抛出 java.io.InvalidClassException 异常；
（3）如果对于类中的某些属性不想被序列化，可以使用 transient 关键字修饰；
例如：对于 Person 对象中的 salary 属性，在序列化设置值为 6700.00，但是，在反序列化成的 Person 对象后，其值是默认的 null；
（4）如果父类实现序列化接口，子类继承父类，子类也是可序列化的；
（5）如果子类实现序列化接口，父类没有实现序列化，在进行序列化时，父类的属性不会被序列化，只会序列化子类自己的属性；
（6）静态属性不会被序列化；
（7）反序列化时，由JVM直接构造出Java对象，不会调用构造方法，构造方法内部的代码，在反序列化时不会执行。

5、Java 序列化的不足

不能跨语言：Java 序列化仅适用于 Java 语言，不能够跨语言使用；
存在安全性问题：反序列化是不用经过构造方法，可以将类路径上几乎所有实现了 Serializable 接口的对象都实例化。这意味着，在反序列化字节流的过程中，该方法可以执行任意类型的代码，这是非常危险的。
性能太差：Java 的序列化耗时比较大。