1 什么是序列化

序列化是一种对象持久化的手段。普遍应用在网络传输的场景中。对于 Java 而言，序列化主要用于对对象进行持久化操作。一般情况下，Java 对象的生命周期短于 JVM 的生命周期，随着 JVM 停止运行，Java 对象也随之消亡。但是，为了能在 JVM 停止运行后对指定对象进行持久化，并在将来的某个时刻重新读取被保存的对象，或跨 JVM 传输对象，持久化能实现上述需求。
Java 在持久化对象时，会将对象的状态保存为一组字节。在反序列化时，将字节组装成对象。
值得注意的是，序列化保存的的是对象的状态，即它的成员变量，而不会保存类的静态变量和被transient修饰的变量。

2 Java序列化的相关特性

  • 只要一个类实现了 java.io.Serializable 接口，那么它就可以被序列化。
  • 通过 ObjectOutputStream 和 ObjectInputStream 实现对象的序列化及反序列化。
  • 虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致（就是 private static final long serialVersionUID）。
  • 序列化并不保存静态变量。
  • 要想将父类对象也序列化，就需要让父类也实现 Serializable 接口。
  • transient 关键字的作用是控制变量的序列化，在变量声明前加上该关键字，可以阻止该变量被序列化到文件中，在被反序列化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null。

  • 服务器端给客户端发送序列化对象数据，对象中有一些数据是敏感的，比如密码字符串等，希望对该密码字段在序列化时，进行加密，而客户端如果拥有解密的密钥，只有在客户端进行反序列化时，才可以对密码进行读取，这样可以一定程度保证序列化对象的数据安全。

    3 Java序列化的方式

  • 实现空接口 Serializable。

    • 这种方式隐式实现序列化，是最简单的序列化方式，
    • 默认情况下，会自动序列化所有非static和transient修饰的成员变量。
  • 实现 Externalizable 接口。
    • Externalizable 继承自Serializable，一旦实现了Externalizable 接口，那么基于Serializable的机制将失效。
    • 这种方式必须实现 writeExternal() 和 readExternal() 方法，这两个方法是自动调用的。
      • writeExternal()方法内可以自己选择哪些部分进行序列化。
      • writeExternal()方法内可以自定义选择序列化被transient修饰的成员变量。
  • 实现 Serializable 接口并添加 writeObject() 和 readObject() 方法。
    • 手动添加writeObject() 和 readObject() 方法，注意不是重写或覆盖。
      • 这两个方法必须被 private 修饰。
      • 第一行应该默认调用 defaultReadObject() 与 defaultWriteObject() 方法，目的是隐式序列化非static和非transient变量。
      • 最后调用 readObject() 和 writeObject() 进行显示序列化被transient修饰的成员变量。
      • writeObject()方法内可以自定义选择序列化被transient修饰的成员变量。

具体代码如下：

  1. package org.example;
  3. import java.io.*;
  5. // Serializable接口实现序列化
  6. public class SerializeTest {
  7.     public static void main(String[] args) {
  8.         // 序列化    
  9.         try (ObjectOutputStream oos = new ObjectOutputStream(
  10.                 new FileOutputStream(new File("G:\\javaCode\\demo_code\\demo\\src\\org\\example\\Serialize.txt")));
  11.         ) {
  12.             Student s1 = new Student("zhangsan", 1);
  13.             oos.writeObject(s1);
  14.             Student s2 = new Student("lisi", 2);
  15.             oos.writeObject(s2);
  16.         } catch (FileNotFoundException e) {
  17.             e.printStackTrace();
  18.         } catch (IOException e) {
  19.             e.printStackTrace();
  20.         }
  22.         // 反序列化
  23.         try (ObjectInputStream ois = new ObjectInputStream(
  24.                 new FileInputStream(new File("G:\\javaCode\\demo_code\\demo\\src\\org\\example\\Serialize.txt")))
  25.         ) {
  26.             Student o = (Student) ois.readObject();
  27.             System.out.println(o);
  28.             Student o2 = (Student) ois.readObject();
  29.             System.out.println(o2);
  30.         } catch (FileNotFoundException e) {
  31.             e.printStackTrace();
  32.         } catch (IOException e) {
  33.             e.printStackTrace();
  34.         } catch (ClassNotFoundException e) {
  35.             e.printStackTrace();
  36.         }
  38.     }
  39.     static class Student implements Serializable {
  40.         private String name;
  41.         private transient int id;
  43.         // 省略了全参、空参构造方法、get、set方法、toString方法
  44.     }
  45. }
  1. package org.example;
  3. import java.io.*;
  5. // Externalizable接口 实现自定义序列化和反序列化
  6. public class SerializeTest2 {
  7.     public static void main(String[] args) {
  8.         // 序列化    
  9.         try (ObjectOutputStream oos = new ObjectOutputStream(
  10.                 new FileOutputStream(new File("G:\\javaCode\\demo_code\\demo\\src\\org\\example\\Serialize.txt")));
  11.         ) {
  12.             Student s1 = new Student("zhangsan", 1, new School("清华", "北京"), 1);
  13.             oos.writeObject(s1);
  14.             Student s2 = new Student("lisi", 2,new School("北大", "北京"), 2);
  15.             oos.writeObject(s2);
  16.         } catch (FileNotFoundException e) {
  17.             e.printStackTrace();
  18.         } catch (IOException e) {
  19.             e.printStackTrace();
  20.         }
  22.         // 反序列化
  23.         try (ObjectInputStream ois = new ObjectInputStream(
  24.                 new FileInputStream(new File("G:\\javaCode\\demo_code\\demo\\src\\org\\example\\Serialize.txt")))
  25.         ) {
  26.             Student o = (Student) ois.readObject();
  27.             System.out.println(o);
  28.             Student o2 = (Student) ois.readObject();
  29.             System.out.println(o2);
  30.         } catch (FileNotFoundException e) {
  31.             e.printStackTrace();
  32.         } catch (IOException e) {
  33.             e.printStackTrace();
  34.         } catch (ClassNotFoundException e) {
  35.             e.printStackTrace();
  36.         }
  38.     }
  39.     // 实现Externalizable接口
  40.     static class Student implements Externalizable {
  41.         private String name;
  42.         private transient Integer age;
  43.         private School school;
  44.         private int id;
  46.         // 省略了全参、空参构造方法、get、set方法、toString方法
  47.         @Override
  48.         public void writeExternal(ObjectOutput out) throws IOException {
  49.             // 根据变量的类型不同，对需要进行序列化的变量进行writeXXX操作
  50.             // 这里没有对id变量进行序列化，其反序列化的结果为类型的默认值
  51.             out.writeObject(name);
  52.             out.writeInt(age);
  53.             out.writeObject(school);
  54.             // out.writeInt(id);
  55.         }
  57.         @Override
  58.         public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
  59.             // 获取反序列化后的结果，注意对类型进行转换
  60.             name = (String) in.readObject();
  61.             age = in.readInt();
  62.             school = (School) in.readObject();
  63.             // id = in.readInt();
  64.         }
  65.     }
  67.     private static class School implements Externalizable {
  68.         private String name;
  69.         private String address;
  71.         // 省略了全参、空参构造方法、get、set方法、toString方法
  72.         @Override
  73.         public void writeExternal(ObjectOutput out) throws IOException {
  74.             out.writeObject(name);
  75.             out.writeObject(address);
  76.         }
  78.         @Override
  79.         public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
  80.             name = (String) in.readObject();
  81.             address = (String) in.readObject();
  82.         }
  83.     }
  84. }
  1. package org.example;
  3. import java.io.*;
  4. // Serializable 接口并添加 writeObject() 和 readObject() 方法
  5. public class SerializeTest3 {
  6.     public static void main(String[] args) {
  7.         // 序列化
  8.         try (ObjectOutputStream oos = new ObjectOutputStream(
  9.                 new FileOutputStream(new File("G:\\javaCode\\demo_code\\demo\\src\\org\\example\\Serialize.txt")));
  10.         ) {
  11.             Student s1 = new Student("zhangsan", 1);
  12.             oos.writeObject(s1);
  13.             Student s2 = new Student("lisi", 2);
  14.             oos.writeObject(s2);
  15.         } catch (FileNotFoundException e) {
  16.             e.printStackTrace();
  17.         } catch (IOException e) {
  18.             e.printStackTrace();
  19.         }
  21.         // 反序列化
  22.         try (ObjectInputStream ois = new ObjectInputStream(
  23.                 new FileInputStream(new File("G:\\javaCode\\demo_code\\demo\\src\\org\\example\\Serialize.txt")))
  24.         ) {
  25.             Student o = (Student) ois.readObject();
  26.             System.out.println(o);
  27.             Student o2 = (Student) ois.readObject();
  28.             System.out.println(o2);
  29.         } catch (FileNotFoundException e) {
  30.             e.printStackTrace();
  31.         } catch (IOException e) {
  32.             e.printStackTrace();
  33.         } catch (ClassNotFoundException e) {
  34.             e.printStackTrace();
  35.         }
  36.     }
  37.     static class Student implements Serializable {
  38.         private String name;
  39.         private transient int id;
  41.         // 省略了全参、空参构造方法、get、set方法、toString方法
  43.         private  void writeObject(ObjectOutputStream oos) throws IOException {
  44.             oos.defaultWriteObject();
  45.             // 显示序列化被transient修饰的变量
  46.             oos.writeInt(id);
  47.         }
  48.         private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException {
  49.             ois.defaultReadObject();
  50.             id = ois.readInt();
  51.         }
  52.     }
  53. }

4 ArrayList中的序列化

首先，ArrayList 中实现了 Serializable 接口，意味着这个集合类可以进行序列化操作。
在ArrayList 底层，保存具体集合元素的 Object[] 类型的数组变量 elementData 被 transient 修饰，但是集合元素经过反序列化后依旧可以复原。原因如下：ArrayList 提供了两个方法：writeObject 和 readObject。

  • 在writeObject方法中：
    • 首先调用ObjectOutputStream 的 defaultWriteObject 方法，写出非transient非static的属性；以及ArrayList的size属性。
    • 然后再把 Object[] 中下标 [0, size-1] 的数据逐一写入。注意这时候长度是数组的实际长度（也就是前面写出的size），而不是ArrayList的数组容量。
  • 在readObject 方法中：
    • 首先调用ObjectInputStream 的 defaultReadObject 方法，读取非transient非static的属性；以及ArrayList的size属性。
    • 其次先读出数组长度，如果数组长度不够则调用ensureCapacityInternal 方法扩容。
    • 最后逐一读出。

      为什么要用transient修饰elementData

      既然要序列化ArrayList，为什么又要用transient修饰elementData？
      ArrayList 由于其动态性，数组容量总是大于等于数组实际数量，当序列化时可能会将大量空值序列化为 null ，造成不必要的浪费，因此用transient修饰elementData，然后在writeObjec进行手动序列化，只序列化实际存储的元素，而不是整个数组。

      5 能序列化的前提

      如果一个类想被序列化，需要实现 Serializable 接口进行自动序列化，或者实现 Externalizable 接口进行手动序列化，否则强行序列化该类的对象，就会抛出 NotSerializableException 异常，这是因为，在序列化操作过程中会对类型进行检查（代码如下），要求被序列化的类必须属于 Enum、Array 和 Serializable 类型其中的任何一种（Externalizable也继承了Serializable）。
      JVM 是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致（就是 private static final long serialVersionUID）。后面进行具体的介绍。
      transient 关键字的作用是控制变量的序列化，在变量声明前加上该关键字，可以阻止该变量被序列化到文件中，在被反序列化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null。
      FileOutputStream 类有一个带有两个参数的重载构造方法——FileOutputStream(String, boolean)。若其第二个参数为 true 且 String 代表的文件存在，那么将把新的内容写到原来文件的末尾而非重写这个文件，故不能用这个版本的构造函数来实现序列化，也就是说必须重写这个文件，否则在读取这个文件反序列化的过程中就会抛出异常，导致只有第一次写到这个文件中的对象可以被反序列化，之后程序就会出错。
      1. if (obj instanceof String) {
      2.  writeString((String) obj, unshared);
      3. } else if (cl.isArray()) {
      4.  writeArray(obj, desc, unshared);
      5. } else if (obj instanceof Enum) {
      6.  writeEnum((Enum<?>) obj, desc, unshared);
      7. } else if (obj instanceof Serializable) {
      8.  writeOrdinaryObject(obj, desc, unshared);
      9. } else {
      10.  if (extendedDebugInfo) {
      11.      throw new NotSerializableException(
      12.          cl.getName() + "\n" + debugInfoStack.toString());
      13.  } else {
      14.      throw new NotSerializableException(cl.getName());
      15.  }
      16. }
      17. }

6 Java序列化中的serialVersionUID

serialVersionUID 用于 Java 的序列化机制。简单来说，Java 的序列化机制是通过判断类的 serialVersionUID 来验证版本一致性的。
在进行反序列化时，JVM 会把传来的字节流中的 serialVersionUID 与本地相应实体类的 serialVersionUID 进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常，即是 InvalidCastException 。
序列化操作的时候系统会把当前类的 serialVersionUID 写入到序列化文件中，当反序列化时系统会去检测文件中的 serialVersionUID ，判断它是否与当前类的 serialVersionUID 一致，如果一致就说明序列化类的版本与当前类版本是一样的，可以反序列化成功，否则失败。serialVersionUID 有两种生成机制：

  • 采用默认的private static final long serialVersionUID = 1L。
  • 根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如：
    private static final long serialVersionUID = xxxxL;

当实现 java.io.Serializable 接口的类没有显式地定义一个 serialVersionUID 变量时候，Java 序列化机制会根据编译的 Class 自动生成一个 serialVersionUID 作序列化版本比较用。这种情况下，如果 Class 文件(类名，方法明等)没有发生变化(增加空格，换行，增加注释等等)，就算再编译多次，serialVersionUID 也不会变化的。

7 Java序列化中父子类相关问题

  1. 如果父类已经实现了序列化，其所有子类都自动实现序列化。
  2. 事实上，很多时候父类并没有实现序列化，这个时候其子类要想实现序列化，除了自身实现 Serializable 以外，还必须满足两个条件：
    • 父类有无参的构造方法。
      • 在父类没有实现 Serializable 接口时，虚拟机是不会序列化父对象的，而一个 Java 对象的构造必须先有父对象，才有子对象，反序列化也不例外。所以反序列化时，为了构造父对象，只能调用父类的无参构造函数作为默认的父对象。
      • 当我们在反序列后输出父对象的变量值时，它的值是调用父类无参构造函数后的值。
    • 子类要负责父类中成员变量的序列化和反序列化。
      • 还记得前面提到的 writeObject 和 readObject方法吗，就是利用这两个方法手动序列化父类的成员变量。
      • 需要注意的是，序列化前父类中定义的变量的值，和序列化后的值是不一样的。
  1. package org.example.exception;
  3. import java.io.*;
  5. // 父类实现了序列化，其所有子类自动实现了序列化
  6. public class ExceptionDemo {
  7.     public static void main(String[] args) throws Exception {
  8.         File file = new File("G:\\javaCode\\demo_code\\demo\\src\\org\\example\\exception\\test.txt");
  9.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
  10.         Student s1 = new Student("zhangsan", 1);
  11.         Student s2 = new Student2("lisi", 2);
  12.         oos.writeObject(s1);
  13.         oos.writeObject(s2);
  14.         System.out.println(s1);
  15.         System.out.println(s2);
  17.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
  18.         Student s3 = (Student) ois.readObject();
  19.         Student2 s4 = (Student2) ois.readObject();
  20.         System.out.println(s3);
  21.         System.out.println(s4);
  23.     }
  24.     static class People implements Serializable {
  25.     }
  27.     // 子类，注意没有实现Serializable接口
  28.     static class Student extends People {
  29.         public String name;
  30.         public int id;
  32.         public Student(String name, int id) {
  33.             this.name = name;
  34.             this.id = id;
  35.         }
  37.         @Override
  38.         public String toString() {
  39.             return "Student{" +
  40.                     "name='" + name + '\'' +
  41.                     ", id=" + id +
  42.                     '}';
  43.         }
  44.     }
  45.     // 孙类，注意没有实现Serializable接口
  46.     static class Student2 extends Student {
  47.         public Student2(String name, int id) {
  48.             super(name, id);
  49.         }
  51.         @Override
  52.         public String toString() {
  53.             return "Student2{" +
  54.                     "name='" + name + '\'' +
  55.                     ", id=" + id +
  56.                     '}';
  57.         }
  58.     }
  59. }
  1. package org.example.exception;
  3. import java.io.*;
  5. // 父类没有实现序列化，子类实现序列化
  6. public class ExceptionDemo2 {
  7.     public static void main(String[] args) throws Exception {
  8.         File file = new File("G:\\javaCode\\demo_code\\demo\\src\\org\\example\\exception\\test2.txt");
  9.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
  10.         Student s1 = new Student("male","zhangsan", 1);
  11.         oos.writeObject(s1);
  12.         System.out.println(s1);
  14.         System.out.println("--------------------");
  16.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
  17.         Student s3 = (Student) ois.readObject();
  18.         System.out.println(s3);
  19.     }
  20.     static class People {
  21.         public String gender;
  23.         public People(String gender) {
  24.             this.gender = gender;
  25.         }
  27.         // 父类必须有空参构造方法
  28.         // 反序列化时，为了构造父对象，只能调用父类的无参构造函数作为默认的父对象
  29.         public People() {
  30.             System.out.println("父类的无参构造方法");
  31.         }
  33.         @Override
  34.         public String toString() {
  35.             return "People{" +
  36.                     "gender='" + gender + '\'' +
  37.                     '}';
  38.         }
  39.     }
  41.     // 子类
  42.     static class Student extends People implements Serializable {
  43.         public String name;
  44.         public int id;
  46.         public Student(String gender, String name, int id) {
  47.             super(gender);
  48.             this.name = name;
  49.             this.id = id;
  50.         }
  52.         private void writeObject(ObjectOutputStream out) throws IOException {
  53.             // 先序列化子类对象
  54.             out.defaultWriteObject();
  55.             // 再手动序列化父类的成员变量
  56.             out.writeObject(gender);
  57.         }
  59.         private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
  60.             // 先反序列化子类对象
  61.             in.defaultReadObject();
  62.             // 再手动反序列化父类的成员变量
  63.             String gender = (String) in.readObject();
  64.         }
  66.         @Override
  67.         public String toString() {
  68.             return "Student{" +
  69.                     "gender='" + gender + '\'' +
  70.                     ", name='" + name + '\'' +
  71.                     ", id=" + id +
  72.                     '}';
  73.         }
  74.     }
  75. }

输出结果：

  1. Student{gender='male', name='zhangsan', id=1}
  2. --------------------
  3. 父类的无参构造方法
  4. Student{gender='null', name='zhangsan', id=1}

父类没有实现序列化，子类也没有实现序列化，孙类实现了序列化。

  1. package org.example.exception;
  3. import java.io.*;
  5. // 父类没有实现序列化，子类也没有实现序列化，孙类实现了序列化
  6. public class ExceptionDemo3 {
  7.     public static void main(String[] args) throws Exception {
  8.         File file = new File("G:\\javaCode\\demo_code\\demo\\src\\org\\example\\exception\\test3.txt");
  9.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
  11.         Student s2 = new Student2("male","lisi", 2, "清华");
  12.         oos.writeObject(s2);
  13.         System.out.println(s2);
  15.         System.out.println("--------------------");
  16.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
  17.         Student2 s3 = (Student2) ois.readObject();
  18.         System.out.println(s3);
  20.     }
  21.     static class People {
  22.         public String gender;
  24.         public People(String gender) {
  25.             this.gender = gender;
  26.         }
  28.         // 父类必须有空参构造方法
  29.         // 反序列化时，为了构造父对象，只能调用父类的无参构造函数作为默认的父对象
  30.         public People() {
  31.             System.out.println("父类的父类的无参构造方法");
  32.         }
  34.         @Override
  35.         public String toString() {
  36.             return "People{" +
  37.                     "gender='" + gender + '\'' +
  38.                     '}';
  39.         }
  40.     }
  42.     // 子类
  43.     static class Student extends People {
  44.         public String name;
  45.         public int id;
  47.         public Student() {
  48.             System.out.println("父类的无参构造方法");
  49.         }
  51.         public Student(String gender, String name, int id) {
  52.             super(gender);
  53.             this.name = name;
  54.             this.id = id;
  55.         }
  57.         @Override
  58.         public String toString() {
  59.             return "Student{" +
  60.                     "gender='" + gender + '\'' +
  61.                     ", name='" + name + '\'' +
  62.                     ", id=" + id +
  63.                     '}';
  64.         }
  65.     }
  66.     // 孙类
  67.     static class Student2 extends Student implements Serializable {
  68.         String school;
  70.         public Student2() {
  71.         }
  73.         public Student2(String gender, String name, int id, String school) {
  74.             super(gender, name, id);
  75.             this.school = school;
  76.         }
  78.         private void writeObject(ObjectOutputStream out) throws IOException {
  79.             out.defaultWriteObject();
  80.             out.writeObject(gender);
  81.             out.writeObject(name);
  82.             out.writeInt(id);
  83.         }
  85.         private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
  86.             in.defaultReadObject();
  87.             String gender = (String) in.readObject();
  88.             String name = (String) in.readObject();
  89.             id =  in.readInt();
  90.         }
  92.         @Override
  93.         public String toString() {
  94.             return "Student2{" +
  95.                     "gender='" + gender + '\'' +
  96.                     ", name='" + name + '\'' +
  97.                     ", id=" + id +
  98.                     ", school='" + school + '\'' +
  99.                     '}';
  100.         }
  101.     }
  102. }

输出结果：

  1. Student2{gender='male', name='lisi', id=2, school='清华'}
  2. --------------------
  3. 父类的父类的无参构造方法
  4. 父类的无参构造方法
  5. Student2{gender='null', name='null', id=2, school='清华'}

参考