java序列化，从底层到序列化所隐藏的问题以及解决方案

什么是序列化？

序列化：将对象写入到IO流中，对象序列化的最主要的用处就是在传递和保存对象的时候，保证对象的完整性和可传递性。序列化是把对象转换成有序字节流，以便在网络上传输或者保存在本地文件中。核心作用是对象状态的保存与重建。

反序列化：将IO流中恢复对象，客户端从文件中或网络上获得序列化后的对象字节流，根据字节流中所保存的对象状态及描述信息，通过反序列化重建对象。

---

序列化的意义

序列化机制允许将实现序列化的Java对象转换位字节序列，这些字节序列可以保存在磁盘上，或通过网络传输，以达到以后恢复成原来的对象。序列化机制使得对象可以脱离程序的运行而独立存在。**所有可在网络上传输的对象都必须是可序列化的，**比如RMI（remote method invoke,即远程方法调用），传入的参数或返回的对象都是可序列化的，否则会出错；所有需要保存到磁盘的java对象都必须是可序列化的。通常建议：程序创建的每个JavaBean类都实现Serializeable接口。

---

序列化的方法

实现 Serializable 接口

• 使用默认的序列化机制，即实现 Serializable 接口即可，不需要实现任何方法。

• Serializable 接口没有任何方法，只是一个标记而已，告诉Java虚拟机该类可以被序列化了。利用 ObjectOutputStream 的writeObject(object) 方法进行序列化，用 ObjectInputStream 的 readObject() 方法进行反序列化。

• 该方式下序列化机制会自动保存该对象的成员变量，static 成员变量和 transient 关键字修饰的成员变量不会被序列化保存

---

序列化步骤：

• 步骤一：创建一个ObjectOutputStream输出流；
• 步骤二：调用ObjectOutputStream对象的writeObject输出可序列化对象。

反序列化步骤：

• 步骤一：创建一个ObjectInputStream输入流；
• 步骤二：调用ObjectInputStream对象的readObject()得到序列化的对象。

//省略get、set方法
public class Person implements Serializable {
    private Integer id;
    private String name;
    private Integer age;
    public Person(Integer id, String name, Integer age) {
        System.out.println("调用构造方法了！");
        this.id = id;
        this.name = name;
        this.age = age;
    }
}

public static void main(String[] args) throws Exception {
    ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("D:\\idea_maven\\algorithm\\test.txt"));
    ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("D:\\idea_maven\\algorithm\\test.txt"));

    Person person = new Person(1, "AAA", 1008611);
    outputStream.writeObject(person);
    Person object = (Person) inputStream.readObject();
    System.out.println(object);
}
//Person{id=1, name='AAA', age=1008611}

我们可以从输出看出在序列化和反序列化中并没有调用到构造方法。反序列化并不会调用构造方法。反序列的对象是由JVM自己生成的对象，不通过构造方法生成。

---

属性中有成员变量的引用的序列化

• 如果属性中有成员变量的话，则该成员变量的类也得实现 Serializable，否则会报无法序列化异常

public class PersonInfo {
    private Integer id;

    public PersonInfo(Integer id) {
        this.id = id;
    }
}
public class Person implements Serializable {
    private Integer id;
    private String name;
    private Integer age;
    private PersonInfo personInfo;
    public Person(Integer id, String name, Integer age, PersonInfo personInfo) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.personInfo = personInfo;
    }
}
Exception in thread "main" java.io.NotSerializableException: com.base.october.three_zero.PersonInfo
	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.base.october.three_zero.Test02.main(Test02.java:19)

---

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

在这里提一个问题：同一对象序列化多次系统会创建多个对象吗？ 答案是否，Jvm只会反序列化一次对象，我们先看一下下面的例子

public static void main(String[] args) throws Exception {
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("D:\\idea_maven\\algorithm\\test.txt"));
        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("D:\\idea_maven\\algorithm\\test.txt"));
        PersonInfo piObject = new PersonInfo(110);
        Person pObject1 = new Person(1, "AAA", 1008611,piObject);
        outputStream.writeObject(pObject1);
        outputStream.writeObject(pObject1);
        outputStream.writeObject(piObject);

        Person person1 = (Person) inputStream.readObject();//依次读出两次 Person 对象
        Person person2 = (Person) inputStream.readObject();
        PersonInfo personInfo = (PersonInfo)inputStream.readObject();//读出 personInfo 对象

        System.out.println(person1==person2); //读出的两次 Person 对象是相等的
        System.out.println(pObject1==person2); //读出的 Person 对象和原 Person 对象是不相等的
        System.out.println(person1.getPersonInfo()==personInfo); //读出来的 Person 对象中的 PersonInfo 引用和读出来的 PersonInfo 一致
        System.out.println(person1.getPersonInfo()==person2.getPersonInfo()); //读出来的 Person 对象中的 PersonInfo 引用都是同一个
}
/**
true
false
true
true
*/

从输出结果可以看出，**Java序列化同一对象，并不会将此对象序列化多次得到多个对象。**那它到底是通过什么来防止多次反序列化一个对象的呢？

它其实是通过java序列化算法来防止多次实例化一个对象的

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

我们从上图可以看到，每个对象只会被反序列化一次，而如果继续反序列化它的话只会给到相对应的序列化编号而已

---

java序列化算法潜在的问题

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

    public static void main(String[] args) throws Exception {
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("D:\\idea_maven\\algorithm\\test.txt"));
        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("D:\\idea_maven\\algorithm\\test.txt"));

        Person person = new Person(1, "BBB", 100, new PersonInfo(123456789));
        outputStream.writeObject(person);
        person.setAge(110);
        outputStream.writeObject(person);
        Person p1 = (Person) inputStream.readObject();
        Person p2 = (Person) inputStream.readObject();
        System.out.println(p1 == p2);
        System.out.println(p1);
        System.out.println(person);
    }
/**
true
Person{id=1, name='BBB', age=100}
Person{id=1, name='BBB', age=110}
*/

面对这个问题，我们要怎么解决呢？我们看到下面

---

可选的自定义序列化

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

Person person = new Person(1, "BBB", 100, new PersonInfo(123456789));
outputStream.writeObject(person);
Person p1 = (Person) inputStream.readObject();
System.out.println(p1);
//Person{id=null, name='BBB', age=100}

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

• 使用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;   //省略构造方法，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{
        //将读出的字符串恢复回来      
        this.name = ins.readObject().toString();
        this.age = ins.readInt();
    }
 }

        Person person = new Person(1, "BBB", 100, new PersonInfo(123456789));
        outputStream.writeObject(person);
        Person p1 = (Person) inputStream.readObject();
        System.out.println(p1);
//Person{id=null, name='new StringBuffer(this.name).reverse()', age=100}

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

---

更彻底的自定义序列化

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

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

public class Person implements Serializable {  
    private String name;  
    private int age;  //省略构造方法，get及set方法  
  	private Object writeReplace() throws ObjectStreamException { 
        ArrayList<Object> list = new ArrayList<>(2);
        list.add(this.name);
        list.add(this.age);
        return list;
    }
}

		Person person = new Person(1, "BBB", 100, new PersonInfo(123456789));
        outputStream.writeObject(person);
        ArrayList list = (ArrayList)inputStream.readObject();
        System.out.println(list);
//[BBB, 100]

public class Person implements Serializable {  
    private String name;  
    private int age;  //省略构造方法，get及set方法  
    private Object readResolve() throws ObjectStreamException{
        HashMap<Object, Object> objectObjectHashMap = new HashMap<>();
        objectObjectHashMap.put(123456,1321321);
        return objectObjectHashMap;
    }
}
        Person person = new Person(1, "BBB", 100, new PersonInfo(123456789));
        outputStream.writeObject(person);
        HashMap map = (HashMap)inputStream.readObject();
        System.out.println(map);  
//{123456=1321321}

我们可以看到输出的是一个list集合。writeReplace 方法或者 readResolve 方法如果存在就会去调用它去序列化，而不会去调用 writeObject 和 readObject 两个方法，也就是权限比他们高，其中 writeReplace 的调用顺序又比 readResolve 高

writeReplace > readResolve > writeObject > readObject

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

---

Externalizable：强制自定义序列化

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

public class Person implements Externalizable {
    transient private Integer id;
    private String name;
    private Integer age;

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

	//必须要，它会调用这个构造器
    public Person() {
        System.out.println("调用了空参构造器！！！");
    }

    @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();
    }
}
        Person person = new Person(1, "AAABBB", 100);
        outputStream.writeObject(person);
        Person p1 = (Person) inputStream.readObject();;
        System.out.println(p1);
/**
BBBAAA
调用了空参构造器！！！
AAABBB
Person{id=null, name='AAABBB', age=100}
*/

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

---

两种实现方法的比较

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

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

---

序列化版本号serialVersionUID

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

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

如果不加序列号，当我们去序列化一个对象后，这个对象的属性修改了，然后在我们反序列化时就会抛出异常

而当我们在实体类中添加 serialVersionUID 属性时就可以正常的反序列化了(名称只能是serialVersionUID ，不能是其他名称，否则也会报错，idea有配置可以自动添加这个 serialVersionUID )

public class Person implements Serializable {
    private Integer id;
    private String name;
    private Integer age;
    private Integer score;
    private static final long serialVersionUID = 1111013L;
    }

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

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

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

---

总结

• 所有需要网络传输的对象都需要实现序列化接口，通过建议所有的javaBean都实现Serializable接口。

• 对象的类名、实例变量（包括基本类型，数组，对其他对象的引用）都会被序列化；方法、类变量、transient实例变量都不会被序列化。

• 如果想让某个变量不被序列化，使用transient修饰。

• 序列化对象的引用类型成员变量，也必须是可序列化的，否则，会报错。

• 反序列化时必须有序列化对象的class文件。

• 当通过文件、网络来读取序列化后的对象时，必须按照实际写入的顺序读取。

• 单例类序列化，需要重写readResolve()方法；否则会破坏单例原则。

• 同一对象序列化多次，只有第一次序列化为二进制流，以后都只是保存序列化编号，不会重复序列化。

• 建议所有可序列化的类加上serialVersionUID 版本号，方便项目升级。