序列化和反序列化

1.概念

• 把对象转换为字节序列的过程称为对象的序列化。
• 把字节序列恢复为对象的过程称为对象的反序列化。

对象的序列化主要有两种用途：

• 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；
• 在网络上传送对象的字节序列。

在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web服务器中的Session对象，当有
10万用户并发访问，就有可能出现10万个Session对象，内存可能吃不消，于是Web容器就会把一些seesion先序列化到硬盘中，等要用了，再把保存在硬盘中的对象还原到内存中。

当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。

2. JDK类库中的序列化API

• java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
• java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。

只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自 Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为，而仅实现Serializable接口的类可以 采用默认的序列化方式 。

对象序列化包括如下步骤：

1. 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；
2. 通过对象输出流的writeObject()方法写对象。

对象反序列化的步骤如下：

1. 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；
2. 通过对象输入流的readObject()方法读取对象。

举例:

public class Person implements Serializable {

    private static final long serialVersionUID = -8716807197529864217L;
    private String name;

    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //序列化person对象
        SerializePerson();
        //反序列化文件数据到person对象中
        Person person = deSerializePerson();
        System.out.println(person);
    }

    //序列化方法
    public static void SerializePerson() throws IOException {
        Person person = new Person();
        person.setName("小明");
        person.setAge(20);

        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(new File("c://test//se.txt")));

        objectOutputStream.writeObject(person);

        System.out.println("Person对象序列化成功!");

        objectOutputStream.close();

    }

    //反序列化方法
    public static Person deSerializePerson() throws IOException, ClassNotFoundException {
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(new File("c://test//se.txt")));
        Person person = (Person)objectInputStream.readObject();
        System.out.println("Person对象反序列化成功!");
        return person;
    }
}

序列化Person成功后C盘生成了一个se.txt文件，而反序列化Person是读取E盘的se.txt后生成了一个Person对象

3. serialVersionUID的作用

serialVersionUID：字​面​意​思​上​是​序​列​化​的​版​本​号​，凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量。这种方式生成的serialVersionUID是根据类名，接口名，方法和属性等来生成的，例如：

private static final long serialVersionUID = -8716807197529864217L;

举例：

public class TestSerialversionUID {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        serializeCustomer();
        Customer customer = DeSerializeCustomer();
        System.out.println(customer);

    }

    //customer 序列化方法
    public static void serializeCustomer() throws IOException {
        Customer customer = new Customer("李明",20);
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(new File("c://test//customer.txt")));
        objectOutputStream.writeObject(customer);
        objectOutputStream.close();
        System.out.println("Customer序列化成功!");
    }

    //customer 反序列方法
    public static Customer DeSerializeCustomer() throws IOException, ClassNotFoundException {
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(new File("c://test//customer.txt")));
        Customer customer = (Customer)objectInputStream.readObject();
        System.out.println("Customer反序列化成功!");
        return customer;
    }
}

public class Customer implements Serializable {
//Customer 中没有定义serialVersionUID
    private String name;

    private int age;

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

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

以上我们第一次测试，对象可以顺利地序列化和反序列化。

Customer序列化成功!
Customer反序列化成功!
Customer{name='李明', age=20}

下面修改一下Customer类，添加一个属性 sex

public class Customer implements Serializable {
    private String name;

    private int age;

    private String sex; //新增的一个属性

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

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

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

再次运行test的程序中的反序列化方法（此时，只运行反序列化方法，用之前2个属性的文件来反序列化到内存中的3个属性）
报错：

Exception in thread "main" java.io.InvalidClassException: com.gs.test.objser.Customer; local class incompatible: stream classdesc serialVersionUID = 3632770865303553024, local class serialVersionUID = 1255731269111680396
	at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:616)
	at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1843)
	at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1713)
	at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2000)
	at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1535)
	at java.io.ObjectInputStream.readObject(ObjectInputStream.java:422)
	at com.gs.test.objser.TestSerialversionUID.DeSerializeCustomer(TestSerialversionUID.java:25)
	at com.gs.test.objser.TestSerialversionUID.main(TestSerialversionUID.java:8)

意思就是说，文件流中的class和classpath中的class，也就是修改过后的class，不兼容了，处于安全机制考虑，程序抛出了错误，并且拒绝载入。那么如果我们真的有需求要在序列化后添加一个字段或者方法呢？应该怎么办？那就是自己去指定serialVersionUID。在TestSerialversionUID例子中，没有指定Customer类的serialVersionUID的，那么java编译器会自动给这个class进行一个摘要算法，类似于指纹算法，只要这个文件
多一个空格，得到的UID就会截然不同的，可以保证在这么多类中，这个编号是唯一的。所以，添加了一个字段后，由于没有显指定
serialVersionUID，编译器又为我们生成了一个UID，当然和前面保存在文件中的那个不会一样了，于是就出现了2个序列化版本号不一致的错误。因此，只要我们自己指定了serialVersionUID，就可以在序列化后，去添加一个字段，或者方法，而不会影响到后期的还原，还原后的对象照样可以使用，而且还多了方法或者属性可以用。

下面继续修改Customer类，给Customer指定一个serialVersionUID，修改后的代码如下：

public class Customer implements Serializable {

    private static final long serialVersionUID = 1255731269111680396L; //新增
    private String name;

    private int age;

    private String sex;

    private String addr;

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

    public Customer(String name, int age, String sex,String addr) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.addr = addr;
    }

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

再次重复以上过程，发现，问题消失了，可以正确序列化和反序列化

参考文章：
https://www.cnblogs.com/xdp-gacl/p/3777987.html