对象序列化和反序列化，以及类升级后兼容原来的数据

如题：当前的Person属性有[id,name,sex] ，通过序列化之后将对象数据存储在文档中

import java.io.Serializable;

/**
 * @ClassName Person
 * @Description 人类【对象流的使用】序列化需要实现
 * @Author chenxys
 * @Date 2022/2/21 11:05
 * @Version
 */
public class Person implements Serializable {
    //序列化的版本ID是在类进行升级改造之后，可以通过ID去反序列化数据回来，解决兼容性问题
    //例如： Person[id,name,sex] 把对象数据存储在文档中
    //升级改造 Person[id,name,sex,address]
    //由于版本ID的存在，即使类修改结构之后，都会认定为同一个版本,则可以进行反序列化
    private static final long serialVersionUID = 1L;//序列化ID
    private int id;
    private String name;
    private String sex;


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

    public Person() {
    }


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
    @Override
    public String toString() {
        final StringBuffer sb = new StringBuffer("Person{");
        sb.append("id=").append(id);
        sb.append(",name='").append(name);
        sb.append(",sex='").append(sex);
        sb.append("}");
        return sb.toString();
    }
}

import java.io.*;
/**
 * @ClassName ObjectStreamTest
 * @Description 对象序列化和反序列化
 * @Author chenxys
 * @Date 2022/2/21 11:07
 * @Version
 */
public class ObjectStreamTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //对象输出流--序列化操作
        ObjectOutputStream obs = new ObjectOutputStream(new FileOutputStream("/Users/chenys/Desktop/test1/text.txt"));
        //创建一个对象
        Person p = new Person(1,"赵","女");
        //写出
        obs.writeObject(p);
        //关闭流
        obs.close();

        //对象写入流--反序列化操作
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("/Users/chenys/Desktop/test1/text.txt"));
        //读取
        Object obj = ois.readObject();
        //输出
        System.out.println(obj);
        //关闭流
        ois.close();
    }
}

当前结果：

Person{id=1,name='赵,sex='女}

对类进行升级：添加address属性并重写toString方法

package java_20220221.objectIO;

import java.io.Serializable;

/**
 * @ClassName Person
 * @Description 人类【对象流的使用】序列化需要实现
 * @Author chenxys
 * @Date 2022/2/21 11:05
 * @Version
 */
public class Person implements Serializable {
    //序列化的版本ID是在类进行升级改造之后，可以通过ID去反序列化数据回来，解决兼容性问题
    //例如： Person[id,name,sex] 把对象数据存储在文档中
    //升级改造 Person[id,name,sex,address]
    //由于版本ID的存在，即使类修改结构之后，都会认定为同一个版本,则可以进行反序列化
    private static final long serialVersionUID = 1L;//序列化ID
    private int id;
    private String name;
    private String sex;


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

    public Person() {
    }


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
//    @Override
//    public String toString() {
//        final StringBuffer sb = new StringBuffer("Person{");
//        sb.append("id=").append(id);
//        sb.append(",name='").append(name);
//        sb.append(",sex='").append(sex);
//        sb.append("}");
//        return sb.toString();
//    }

    类升级
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public Person(int id, String name, String sex, String address) {
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.address = address;
    }

    @Override
    public String toString() {
        final StringBuffer sb = new StringBuffer("Person{");
        sb.append("id=").append(id);
        sb.append(",name='").append(name);
        sb.append(",sex='").append(sex);
        sb.append(",address='").append(address);
        sb.append("}");
        return sb.toString();
    }
}

因为版本ID的存在，即使类修改结构之后，都会认定为同一个版本,则可以进行反序列化

即

import java.io.*;
/**
 * @ClassName ObjectStreamTest
 * @Description 对象序列化和反序列化
 * @Author chenxys
 * @Date 2022/2/21 11:07
 * @Version
 */
public class ObjectStreamTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //对象写入流--反序列化操作
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("/Users/chenys/Desktop/test1/text.txt"));
        //读取
        Object obj = ois.readObject();
        //输出
        System.out.println(obj);
        //关闭流
        ois.close();
    }
}

结果为：

Person{id=1,name='赵,sex='女,address='null}

综上：

序列化的版本ID是在类进行升级改造之后，可以通过ID去反序列化数据回来，解决兼容性问题
例如： Person[id,name,sex] 把对象数据存储在文档中
升级改造 Person[id,name,sex,address]
由于版本ID的存在，即使类修改结构之后，都会认定为同一个版本,则可以进行反序列化