Java序列化与反序列化

1. 序列化的时候必须实现Serializable这个接口，基本类型的数据像Integer,String这些都实现了Serializable这个接口，实现序列化的时候有两种方式

  a. 实现Serializable这个接口，如果有不需要序列化的属性使用transient修饰

 b. 实现externalizable这个接口，复习里面的方法，根据需求去 实现要序列化和反序列化的字段和属性，externalizable是Serializable的子类；实现这个接口需要重写writeExternal和readExternal方法，指定对象序列化的属性和从序列化文件中读取对象属性的行为

c. 在用Serializable这个接口在实现序列化的时候，其父类必须要有个无参数的构造函数，否则反序列化就会报错;默认如果没有父类的话，自定义的类的类的父类为Object类;如下代码，反序列化时则会报错:

package Serializable;

import net.bytebuddy.implementation.bind.annotation.Super;

import java.io.*;

class Anninal    {
    private int type;
    public Anninal(int type){
      System.out.println("I will be Seriz in Anni");
    }
}

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

    //我不提供无参构造器
    public Person(String name, int age) {
        super(10);
        System.out.println("I will be Person");
        this.name = name;
        this.age = age;
    }

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

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


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

报错如下:

java.io.InvalidClassException: Serializable.Person; no valid constructor
    at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:150)
    at java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:768)
    at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1775)
    at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)
    at java.io.ObjectInputStream.readObject(ObjectInputStream.java:371)
    at Serializable.ReadObject.main(Person.java:57)

因为父类Anninal没有默认的构造函数，修改代码如下，则正确

package Serializable;

import net.bytebuddy.implementation.bind.annotation.Super;

import java.io.*;
//implements  Serializable
class Anninal    {
    private int type;
    public Anninal(int type){
      System.out.println("I will be Seriz in Anni");
    }

    public Anninal(){
        System.out.println("I will be Seriz in Anninal, I am a Default Constructor");
    }
}

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


    //我不提供无参构造器
    public Person(String name, int age) {
        super(10);
        System.out.println("I will be Person");
        this.name = name;
        this.age = age;
    }

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

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


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

输出结果如下:

I will be Seriz in Anninal, I am a Default Constructor
Person{name='null', age=23}

如果父类实现Serializable，父类没有默认的够造函数也可以

package Serializable;

import net.bytebuddy.implementation.bind.annotation.Super;

import java.io.*;
class Anninal  implements  Serializable  {
    private int type;
    public Anninal(int type){
      System.out.println("I will be Seriz in Anni");
    }

}

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


    //我不提供无参构造器
    public Person(String name, int age) {
        super(10);
        System.out.println("I will be Person");
        this.name = name;
        this.age = age;
    }

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

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


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

这个则不会报错

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

如果反序列化使用的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 版本号，方便项目升级。