Java 序列化

引言

我们经常在 java 中使用序列化，序列化成一个二进制文件，需要的时候再反序列化，但是一直只知道只要实现 Serializable 接口就可以了，一直不知道具体的原理，我们今天就来一探究竟。

• 序列化：对象 序列化成二进制文件或者二进制流
• 反序列化化：从二进制文件或二进制流中反序列化成实体

---

序列化ID

我们通常在实体类中会实现 Serializable ， 然后在下面写一个 private 属性。即

private static final long serialVersionUID = 1L;

我们都知道这个是序列化ID，那么他究竟是什么作用呢。
比如在我们的常用工具 IDEA 中，可以通过设置直接生成一个随机的 serialVersionUID， 我们也可以直接写个如上代码的 1L。
这里我们先解释这个序列化的作用。

• 声明SerialVersionUID

比如我们有2个服务 A 和 B 服务，他们的通信是 C 实体，那么如果我们A中的把C 序列化二进制文件传给 B，如果这个时候 他们的 序列化ID相同，就可以在 B中 反序列化二进制文件 到C 实体。

虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致

显示的设置serialVersionUID值就可以保证版本的兼容性，如果你在类中写上了这个值，就算类变动了，它反序列化的时候也能和文件中的原值匹配上。而新增的值则会设置成null，删除的值则不会显示。

• 不声明SerialVersionUID

所以如果没设置serialVersionUID的话，类如果发生变动，那么最新序列化的serialVersionUID该值根据最新属性值计算得来，所以跟文件中的序列化值就对应不上了，反序列化失败。
注意方法的改变不影响，因为序列化只序列化属性，跟方法无关
如果你不在类中声明SerialVersionUID的话，Java会在运行时替你生成一个，不过这个生成的过程会受到类元数据包括字段数，字段类型，字段的访问限制符，类实现的接口等因素的影响.

---

静态变量的问题

看代码

import java.io.*;

public class Demo implements Serializable {
    public static int STATIC_INT = 1;

    public static void main(String[] args) throws Exception {
        //初始时STATIC_INT为1
        ObjectOutputStream out = new ObjectOutputStream(
                new FileOutputStream("result.obj"));
        out.writeObject(new Demo());
        out.close();
        //序列化后修改为10
        Demo.STATIC_INT = 10;
        ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
                "result.obj"));
        Demo t = (Demo) oin.readObject();
        oin.close();

        //再读取，通过STATIC_INT打印新的值
        System.out.println(t.STATIC_INT);
    }
}

序列化之前的静态变量 STATIC_INT 是1，但是修改 STATIC_INT 输出变成了10。序列化保存的是对象的状态，静态变量属于类的状态，因此 序列化并不保存静态变量。也就是可以放非静态的属性

public static void main(String[] args) throws Exception {
        Demo demo = new Demo();
        demo.setName("111");
        ObjectOutputStream out = new ObjectOutputStream(
                new FileOutputStream("result1.obj"));
        out.writeObject(demo);
        out.close();

        ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
                "result1.obj"));
        Demo t = (Demo) oin.readObject();
        oin.close();

        //再读取，通过STATIC_INT打印新的值
        System.out.println(t.getName());
    }

输出如下

> 111

---

父类序列化的问题

一个子类序列化，但是父类没有序列化。那么在反序列化后，并没有父类属性，其实不难理解。要想将父类对象也序列化，就需要让父类也实现Serializable 接口。或者是显示的调用父类的构造方法。

ransient 关键字的作用是控制变量的序列化，在变量声明前加上该关键字，可以阻止该变量被序列化

---

序列化存储规则

public class Demo implements Serializable {
    public static int STATIC_INT = 1;
    private String name;



    public static void main(String[] args) throws Exception {
        Demo demo = new Demo();

        ObjectOutputStream out = new ObjectOutputStream(
                new FileOutputStream("result2.obj"));
        out.writeObject(demo);
        out.flush();
        System.out.println(new File("result2.obj").length());
        out.writeObject(demo);
        out.flush();
        System.out.println(new File("result2.obj").length());

        ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
                "result2.obj"));
        Demo t1 = (Demo) oin.readObject();
        Demo t2 = (Demo) oin.readObject();
        oin.close();
        System.out.println(t1 == t2);

    }
}

输出如下

71
76
true

Process finished with exit code 0

同一对象两次写入文件，打印出写入一次对象后的存储大小和写入两次后的存储大小，然后从文件中反序列化出两个对象，比较这两个对象是否为同一对象

Java 序列化机制为了节省磁盘空间，具有特定的存储规则，当写入文件的为同一对象时，并不会再将对象的内容进行存储，而只是再次存储一份引用，上面增加的 5 字节的存储空间就是新增引用和一些控制信息的空间。反序列化时，恢复引用关系，使得清单 3 中的 t1 和 t2 指向唯一的对象，二者相等，输出 true。该存储规则极大的节省了存储空间。

摘自 IBM