Java序列化和反序列化介绍

一,序列化和反序列化介绍

Spark是基于JVM运行的进行，其序列化必然遵守Java的序列化规则

序列化就是指将一个对象转化为二进制的byte流（注意，不是bit流），然后以文件的方式进行保存或通过网络传输，等待被反序列化读取出来。序列化常被用于数据存取和通信过程中。

序列化：指堆内存中的java对象数据，通过某种方式把对存储到磁盘文件中，或者传递给其他网络节点（网络传输）。这个过程称为序列化，通常是指将数据结构或对象转化成二进制的过程。

即将对象转化为二进制，用于保存，或者网络传输。

反序列化：把磁盘文件中的对象数据或者把网络节点上的对象数据，恢复成Java对象模型的过程。也就是将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程

与序列化相反，将二进制转化成对象。

意义：

1. 序列化机制允许将实现序列化的对象转换为字节序列，这些字节序列可以保存在磁盘上，还可以通过网络传输，以达到以后可以恢复为原始对象的目的。序列化机制使得对象可以脱离程序的允许而独立存在
2. 在分布式系统中，此时需要把对象在网络上传输，就得把对象数据转换为二进制形式，需要共享的数据的 JavaBean 对象，都得做序列化。
3. 服务器钝化：如果服务器发现某些对象好久没活动了，那么服务器就会把这些内存中的对象持久化在本地磁盘文件中（Java对象转换为二进制文件）；如果服务器发现某些对象需要活动时，先去内存中寻找，找不到再去磁盘文件中反序列化我们的对象数据，恢复成 Java 对象。这样能节省服务器内存。

使用场景：

• 所有在网络上传输的对象都必须是可序列化的。比如RMI(Remote Method Invoke)远程方法调用，传入的参数或返回的对象都必须要是可序列化的。
• 所有需要保存在磁盘上的Java对象都必须要是可序列化的

对于java应用实现序列化一般方法：

• class实现序列化操作是让class 实现Serializable接口，但实现该接口不保证该class一定可以序列化，因为序列化必须保证该class引用的所有属性可以序列化。
• 这里需要明白，static和transient修饰的变量不会被序列化，这也是解决序列化问题的方法之一，让不能序列化的引用用static和transient来修饰。（static修饰的是类的状态，而不是对象状态，所以不存在序列化问题。transient修饰的变量，是不会被序列化到文件中，在被反序列化后，transient变量的值被设为初始值，如int是0，对象是null）
• 此外还可以实现readObject()方法和writeObject()方法来自定义实现序列化。

序列化的一些结论

1. 静态变量不会被序列化（ static,transient）
2. 当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口。
3. 当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化。

子类序列化时：
如果父类没有实现Serializable接口，没有提供默认构造函数，那么子类的序列化会出错；
如果父类没有实现Serializable接口，提供了默认的构造函数，那么子类可以序列化，父类的成员变量不会被序列化。如果父类实现了Serializable接口，则父类和子类都可以序列化。

问题1：如果某些数据不需要做序列化，比如密码，年龄？

解决办法：在字段面前加上 transient

private String name;//需要序列化
transient private int age;//不需要序列化

那么我们在反序列化的时候，打印出来的就是Person [name=vae, age=0]，整型数据默认值为 0

问题2：序列化版本问题，在完成序列化操作后，由于项目的升级或修改，可能我们会对序列化对象进行修改，比如增加某个字段，那么我们在进行反序列化就会报错


解决办法：在 JavaBean 对象中增加一个 serialVersionUID 字段，用来固定这个版本，无论我们怎么修改，版本都是一致的，就能进行反序列化了

private static final long serialVersionUID = 8656128222714547171L;

二,序列化实现的方式

如果需要将某个对象保存到磁盘上或者通过网络传输，那么这个类应该实现Serializable接口或者Externalizable接口之一。

2.1 实现Serializable接口

2.1.1 普通序列化

Serializable接口是一个标记接口，不用实现任何方法。一旦实现了此接口，该类的对象就是可序列化的。

1.序列化步骤

步骤一：创建一个ObjectOutputStream输出流；

步骤二：调用ObjectOutputStream对象的writeObject输出可序列化对象。

public class Person implements Serializable {
    private String name;
    private int age;

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

    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}


public class WriteObject {
    public static void main(String[] args) {
        try (//创建一个ObjectOutputStream输出流
             ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"))) {
            //将对象序列化到文件s
            Person person = new Person("龙傲天", 23);
            oos.writeObject(person);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在磁盘上生成一个序列化文件person.txt

2.反序列化步骤

步骤一：创建一个ObjectInputStream输入流；

步骤二：调用ObjectInputStream对象的readObject()得到序列化的对象。

我们将上面序列化到person.txt的person对象反序列化回来

public class Person implements Serializable {
    private String name;
    private int age;

    public Person(String name, int age) {
        System.out.println("反序列化，你调用我了吗？");
        this.name = name;
        this.age = age;
    }

    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}


public class ReadObject {
    public static void main(String[] args) {
        try (//创建一个ObjectInputStream输入流
             ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"))) {
            Person person = (Person) ois.readObject();
            System.out.println(person);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果为

输出告诉我们，反序列化并不会调用构造方法。反序列的对象是由JVM自己生成的对象，不通过构造方法生成。

2.1.2 成员是引用的序列化

如果一个可序列化的类的成员不是基本类型，也不是String类型，那这个引用类型也必须是可序列化的；否则，会导致此类不能序列化。

看例子，我们新增一个Teacher类。将Person去掉实现Serializable接口代码。

public class Person{
    //省略相关属性与方法
}
public class Teacher implements Serializable {

    private String name;
    private Person person;

    public Teacher(String name, Person person) {
        this.name = name;
        this.person = person;
    }

     public static void main(String[] args) throws Exception {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("teacher.txt"))) {
            Person person = new Person("路飞", 20);
            Teacher teacher = new Teacher("雷利", person);
            oos.writeObject(teacher);
        }
    }
}

运行报错如下

Exception in thread "main" java.io.NotSerializableException: com.cw.spark.core.Person
	at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
	at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1548)
	at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1509)
	at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1432)
	at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1178)
	at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
	at com.cw.spark.core.Teacher.main(Teacher.java:62)

我们看到程序直接报错，因为Person类的对象是不可序列化的，这导致了Teacher的对象不可序列化

2.1.3 同一对象序列化多次的机制

同一对象序列化多次，会将这个对象序列化多次吗？答案是否定的。

public class WriteTeacher {
    public static void main(String[] args) throws Exception {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("teacher.txt"))) {
            Person person = new Person("路飞", 20);
            Teacher t1 = new Teacher("雷利", person);
            Teacher t2 = new Teacher("红发香克斯", person);
            //依次将4个对象写入输入流
            oos.writeObject(t1);
            oos.writeObject(t2);
            oos.writeObject(person);
            oos.writeObject(t2);
        }
    }
}

依次将t1、t2、person、t2对象序列化到文件teacher.txt文件中。

注意：反序列化的顺序与序列化时的顺序一致。

import java.io.FileInputStream;
import java.io.ObjectInputStream;

/**
 * @author 陈小哥cw
 * @date 2021/3/12 10:05
 */
public class ReadTeacher {
    public static void main(String[] args) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("teacher.txt"))) {
            Teacher t1 = (Teacher) ois.readObject();
            Teacher t2 = (Teacher) ois.readObject();
            Person p = (Person) ois.readObject();
            Teacher t3 = (Teacher) ois.readObject();
            System.out.println(t1 == t2);
            System.out.println(t1.getPerson() == p);
            System.out.println(t2.getPerson() == p);
            System.out.println(t2 == t3);
            System.out.println(t1.getPerson() == t2.getPerson());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出结果

false
true
true
true
true

从输出结果可以看出，Java序列化同一对象，并不会将此对象序列化多次得到多个对象。

这和Java序列化算法有关

1. 所有保存到磁盘的对象都有一个序列化编码号
2. 当程序试图序列化一个对象时，会先检查此对象是否已经序列化过，只有此对象从未（在此虚拟机）被序列化过，才会将此对象序列化为字节序列输出。
3. 如果此对象已经序列化过，则直接输出编号即可。

图示上述序列化过程。

2.1.4 java序列化算法潜在的问题

由于java序利化算法不会重复序列化同一个对象，只会记录已序列化对象的编号。如果序列化一个可变对象（对象内的内容可更改）后，更改了对象内容，再次序列化，并不会再次将此对象转换为字节序列，而只是保存序列化编号。

public class WriteObject {
    public static void main(String[] args) {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
             ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) {
            //第一次序列化person
            Person person = new Person("龙傲天", 23);
            oos.writeObject(person);
            System.out.println(person);

            //修改name
            person.setName("海贼王");
            System.out.println(person);
            //第二次序列化person
            oos.writeObject(person);

            //依次反序列化出p1、p2
            Person p1 = (Person) ios.readObject();
            Person p2 = (Person) ios.readObject();
            System.out.println(p1 == p2);
            System.out.println(p1.getName().equals(p2.getName()));
            System.out.println(p1.getName());
            System.out.println(p2.getName());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果如下，可以看到序列化前对象发生改变，但是序列化内容并未发生改变

Person{name='龙傲天', age=23}
Person{name='海贼王', age=23}
true
true
龙傲天
龙傲天

2.1.5 可选的自定义序列化

1.使用transient

有些时候，我们有这样的需求，某些属性不需要序列化。使用transient关键字选择不需要序列化的字段。

public class Person implements Serializable {
   //不需要序列化名字与年龄
   private transient String name;
   private transient int age;
   private int height;
   private transient boolean singlehood;
   public Person(String name, int age) {
       this.name = name;
       this.age = age;
   }
   //省略get,set方法
}


public class TransientTest {
    public static void main(String[] args) {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
             ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) {
            Person person = new Person("龙傲天", 23);
            person.setHeight(185);
            person.setSinglehood(true);
            System.out.println(person);

            oos.writeObject(person);
            Person p1 = (Person) ios.readObject();
            System.out.println(p1);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

运行结果如下

Person{name='龙傲天', age=23, height=185, singlehood=true}
Person{name='null', age=0, height=185, singlehood=false}

从输出我们看到，使用transient修饰的属性，java序列化时，会忽略掉此字段，所以反序列化出的对象，被transient修饰的属性是默认值。对于引用类型，值是null；基本类型，值是0；boolean类型，值是false。

2.可选的自定义序列化

使用transient虽然简单，但将此属性完全隔离在了序列化之外。java提供了可选的自定义序列化。可以进行控制序列化的方式，或者对序列化数据进行编码加密等。

private void writeObject(java.io.ObjectOutputStream out) throws IOException；
private void readObject(java.io.ObjectIutputStream in) throws IOException,ClassNotFoundException;
private void readObjectNoData() throws ObjectStreamException;

通过重写writeObject与readObject方法，可以自己选择哪些属性需要序列化， 哪些属性不需要。如果writeObject使用某种规则序列化，则相应的readObject需要相反的规则反序列化，以便能正确反序列化出对象。这里展示对名字进行反转加密。

public class Person implements Serializable {
    private String name;
    private int age;

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

    // 省略get set方法

    private void writeObject(ObjectOutputStream out) throws IOException {
        //将名字反转写入二进制流
        out.writeObject(new StringBuffer(this.name).reverse());
        out.writeInt(age);
    }

    private void readObject(ObjectInputStream ins) throws IOException, ClassNotFoundException {
        StringBuffer sbname = (StringBuffer) ins.readObject();
        System.out.println("sbname = " + sbname);
        //将读出的字符串反转恢复回来
        this.name = sbname.reverse().toString();
        this.age = ins.readInt();
    }
}





public class Test {
    public static void main(String[] args) {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
             ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) {
            Person person = new Person("龙傲天", 23);
            System.out.println(person);

            oos.writeObject(person);
            Person p1 = (Person) ios.readObject();
            System.out.println(p1);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

运行结果如下

Person{name='龙傲天', age=23}
sbname = 天傲龙
Person{name='龙傲天', age=23}

当序列化流不完整时，readObjectNoData()方法可以用来正确地初始化反序列化的对象。例如，使用不同类接收反序列化对象，或者序列化流被篡改时，系统都会调用readObjectNoData()方法来初始化反序列化的对象。

3.更彻底的自定义序列化

ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;
ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;

writeReplace：在序列化时，会先调用此方法，再调用writeObject方法。此方法可将任意对象代替目标序列化对象

package com.cw.spark.core.serial;

import java.io.*;
import java.util.ArrayList;

/**
 * @author 陈小哥cw
 * @date 2021/3/12 10:30
 */
public class Person implements Serializable {
    private String name;
    private int age;

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

    // 省略get set方法

    private Object writeReplace() throws ObjectStreamException {
        ArrayList<Object> list = new ArrayList<>(2);
        list.add(this.name);
        list.add(this.age);
        return list;
    }

    public static void main(String[] args) throws Exception {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
             ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) {
            Person person = new Person("龙傲天", 23);
            oos.writeObject(person);

            ArrayList list = (ArrayList) ios.readObject();
            System.out.println(list);
        }
    }
}

运行结果

[龙傲天, 23]

readResolve：反序列化时替换反序列化出的对象，反序列化出来的对象被立即丢弃。此方法在readeObject后调用。

private Object readResolve() throws ObjectStreamException {
        HashMap hashMap = new HashMap<String, Integer>();
        hashMap.put("萧辰", 23);
        return hashMap;
    }

public static void main(String[] args) throws Exception {
     try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
          ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) {
         Person person = new Person("龙傲天", 23);
         oos.writeObject(person);
         HashMap map = (HashMap) ios.readObject();
         System.out.println(map);
     }
 }

运行结果如下

{萧辰=23}

查看序列化文件，可以看到存的是龙傲天

但是使用了readResolve方法替换了反序列化出来的对象，原对象被丢弃

readResolve常用来反序列单例类，保证单例类的唯一性。

注意：readResolve与writeReplace的访问修饰符可以是private、protected、public，如果父类重写了这两个方法，子类都需要根据自身需求重写，这显然不是一个好的设计。通常建议对于final修饰的类重写readResolve方法没有问题；否则，重写readResolve使用private修饰。

2.1.6 案例

Student类

public class Student implements Serializable {
    private String name;
    private Integer age;
    private Clazz clazz;

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

   // 省略get set方法
}

Clazz类

public class Clazz implements Serializable {
    private String dept;
    private String num;

    public Clazz() {
    }

    public Clazz(String dept, String num) {
        this.dept = dept;
        this.num = num;
    }

    // 省略get set方法
}

Test类

package com.cw.spark.core.serial;

import java.io.*;
import java.util.ArrayList;
import java.util.Date;

/**
 * @author 陈小哥cw
 * @date 2021/3/12 14:02
 */
public class Test {
    public static void main(String[] args) throws Exception {
        write();
        read();
    }

    public static void write() throws Exception {
        ArrayList list;
        //创建输出流
        OutputStream fos = new FileOutputStream("test.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        //使用输出流
        oos.writeInt(123);
        oos.writeDouble(3.14);
        oos.writeChar('A');
        oos.writeBoolean(true);
        oos.writeUTF("hello world");
        oos.writeObject(new Date());

        Student stu = new Student("陈小哥cw", 24);
        Clazz clz = new Clazz("计算机系", "01");
        stu.setClazz(clz);
        oos.writeObject(stu);
        //关闭输出流
        oos.close();
    }

    public static void read() throws Exception {
        //创建输入流
        ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream(new File("test.txt"))));
        //使用输入流
        System.out.println(ois.readInt());
        double d = ois.readDouble();
        System.out.println(d);
        System.out.println(ois.readChar());
        System.out.println(ois.readBoolean());
        System.out.println(ois.readUTF());
        Date date = (Date) ois.readObject();
        System.out.println(date);
        System.out.println(ois.readObject());
        //关闭输入流
        ois.close();
    }
}

运行结果如下

123
3.14
A
true
hello world
Fri Mar 12 14:12:04 CST 2021
Student{name='陈小哥cw', age=24, clazz=Clazz{dept='计算机系', num='01'}}

总结

1. 反序列化的顺序与序列化时的顺序一致
2. 当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化。

2.2 Externalizable：强制自定义序列化

通过实现Externalizable接口，必须实现writeExternal、readExternal方法。

package com.cw.spark.core.serial;

import java.io.*;

/**
 * Externalizable：强制自定义序列化
 *
 * @author 陈小哥cw
 * @date 2021/3/12 13:47
 */
public class ExPerson implements Externalizable {

    private String name;
    private int age;

    //注意，必须加上pulic 无参构造器
    public ExPerson() {
    }

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

    @Override
    public String toString() {
        return "ExPerson{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        //将name反转后写入二进制流
        StringBuffer reverse = new StringBuffer(name).reverse();
        System.out.println(reverse.toString());
        out.writeObject(reverse);
        out.writeInt(age);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        //将读取的字符串反转后赋值给name实例变量
        this.name = ((StringBuffer) in.readObject()).reverse().toString();
        System.out.println(name);
        this.age = in.readInt();
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ExPerson.txt"));
             ObjectInputStream ois = new ObjectInputStream(new FileInputStream("ExPerson.txt"))) {
            oos.writeObject(new ExPerson("陈小哥cw", 23));
            ExPerson ep = (ExPerson) ois.readObject();
            System.out.println(ep);
        }
    }
}

输出结果

wc哥小陈
陈小哥cw
ExPerson{name='陈小哥cw', age=23}

注意：Externalizable接口不同于Serializable接口，实现此接口必须实现接口中的两个方法实现自定义序列化，这是强制性的；特别之处是必须提供public的无参构造器，因为在反序列化的时候需要反射创建对象。

2.3 两种序列化对比

实现Serializable接口	实现Externalizable接口
系统自动存储必要的信息	程序员决定存储哪些信息
Java内建支持，易于实现，只需要实现该接口即可，无需任何代码支持	必须实现接口内的两个方法
性能略差	性能略好

虽然Externalizable接口带来了一定的性能提升，但变成复杂度也提高了，所以一般通过实现Serializable接口进行序列化。

三,序列化版本号serialVersionUID

我们知道，反序列化必须拥有class文件，但随着项目的升级，class文件也会升级，序列化怎么保证升级前后的兼容性呢？

java序列化提供了一个private static final long serialVersionUID的序列化版本号，只有版本号相同，即使更改了序列化属性，对象也可以正确被反序列化回来。

public class Person implements Serializable {
    //序列化版本号
    private static final long serialVersionUID = 12345678L;
    private String name;
    private int age;
    //省略构造方法及get,set
}

如果反序列化使用的class的版本号与序列化时使用的不一致，反序列化会报InvalidClassException异常。

序列化版本号可自由指定，如果不指定，JVM会根据类信息自己计算一个版本号，这样随着class的升级，就无法正确反序列化；不指定版本号另一个明显隐患是，不利于jvm间的移植，可能class文件没有更改，但不同jvm可能计算的规则不一样，这样也会导致无法反序列化。

什么情况下需要修改serialVersionUID呢？分三种情况。

• 如果只是修改了方法，反序列化不容影响，则无需修改版本号；

• 如果只是修改了静态变量，瞬态变量（transient修饰的变量），反序列化不受影响，无需修改版本号；
• 如果修改了非瞬态变量，则可能导致反序列化失败。如果新类中实例变量的类型与序列化时类的类型不一致，则会反序列化失败，这时候需要更改serialVersionUID。如果只是新增了实例变量，则反序列化回来新增的是默认值；如果减少了实例变量，反序列化时会忽略掉减少的实例变量。

四,总结

1. 所有需要网络传输的对象都需要实现序列化接口，通过建议所有的javaBean都实现Serializable接口。
2. 对象的类名、实例变量（包括基本类型，数组，对其他对象的引用）都会被序列化；方法、类变量、transient实例变量都不会被序列化。
3. 如果想让某个变量不被序列化，使用transient修饰。
4. 序列化对象的引用类型成员变量，也必须是可序列化的，否则，会报错。
5. 反序列化时必须有序列化对象的class文件。
6. 当通过文件、网络来读取序列化后的对象时，必须按照实际写入的顺序读取。
7. 单例类序列化，需要重写readResolve()方法；否则会破坏单例原则。
8. 同一对象序列化多次，只有第一次序列化为二进制流，以后都只是保存序列化编号，不会重复序列化。
9. 建议所有可序列化的类加上serialVersionUID版本号，方便项目升级。

参考链接

https://www.cnblogs.com/9dragon/p/10901448.html#h14java