Java笔记 IO —— 序列化和反序列化（local class incompatible异常解决）

序列化是指把一个Java对象变成二进制内容，本质上是一个byte[]数组。序列化的作用是把java对象按照byte[]数组的形式存储到文件里（也就是持久化到硬盘中，通常是保存在某一个文件中），或者通过网络传输出去（比如服务器之间的数据通信）

反序列化就是把一串二进制数据（也就是byte[]数组）再转换回java对象

1. 序列化流：把对象按照流一样的方式存到文本文件或者数据库或者网络中传输等
   对象 – 流数据 ：ObjectOutputStream

2. 反序列化：把文本文件中的流对象数据或者网络中的流数据给还原成一个对象。
   流数据 – 对象 ：ObjectInputStream

package review.IO;

import java.io.*;

public class Demo14 {
    public static void main(String[] args) throws Exception  {
        //写方法，将对象存入到文件中，也就是将对象进行持久化
        write();
        //读方法：把文本文件中的流对象数据或者网络中的流数据给还原成一个对象
        read();
    }

    public static void read() throws Exception {
        //ObjectInputStream(InputStream in)
        //创建从指定的InputStream读取的ObjectInputStream
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));

        //Object readObject()
        //从ObjectInputStream读取一个对象
        Object obj = ois.readObject();
        //向下转型，从而使用Person类中的方法
        Person p = (Person)obj;
        System.out.println(p.getName()+"---"+p.getAge());
        ois.close();
    }

    public static void write() throws IOException {
        //ObjectOutputStream(OutputStream out)
        // 创建一个写入指定的OutputStream的ObjectOutputStream
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));

        //创建一个Person类对象
        Person p = new Person("zhang",15);

        //void writeObject(Object obj)
        //将指定的对象写入ObjectOutputStream
        oos.writeObject(p);

        //关闭流
        oos.close();
    }
}

控制台结果

obj.txt文件里面的内容

这个内容看不懂属于正常情况，这是序列化后的内容结果

package review.IO;

import java.io.Serializable;

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

    public Person() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

这是被序列化的对象的类的具体内容

关于这个类需要注意的事情：
（一）被序列化的对象的类必须实现了Serializable接口，否则会报java.io.NotSerializableException未序列化异常
jdk1.8文档中的描述是：
类的序列化由实现java.io.Serializable接口的类启用，不实现此接口的类将不会使任何状态序列化或反序列化。
可序列化类的所有子类型都是可序列化的。序列化接口没有方法或字段，仅用于标识可串行化的语义。

（二）Stream流中的class类与本地文件中的class类，应该是相同的
这里的class类是Person类，
我用上面的Person类代码运行write()方法，进行序列化，写入到文件中。
然后我对这个Person类进行修改，比如将public int age改成private int age。
最后运行read()方法，读取内容，就会报错

报错内容是
java.io.InvalidClassException: review.IO.Person; local class incompatible:
stream classdesc serialVersionUID = -4369,
local class serialVersionUID = 8665（这里的UID数字太长，为了方便看我只截取四位）

造成这个异常的原因是，Person类实现了Serializable标记接口，它本身就会有一个标记值。

在修改Person类之前，假设Person.class的标记值id是1000
在没有修改Person类的之前：
Person.class —— id=1000
写数据的时候 ：obj.txt —— id=1000
读数据的时候 ：obj.txt —— id=1000
往文件里面写入类对象，和从文件里面还原类对象的时候，文件中的class类的标记值一直是1000，因为写入的时候标记值id是1000。在读文件的时候，会将这个id=1000与本地文件的Person类的id做对比，如果相同才能还原成Person类对象

进行修改后：（把public换成private，也就是对Person类进行修改）
Person.class —— id=2000
写数据的时候 ：obj.txt —— id=1000
读数据的时候 ：obj.txt —— id=1000
此时因为是修改前把对象写入文件中，所有这里的id值不会改变。但是读取的时候，会将obj.txt文件里的 id 与本地文件的Person类的 id 做对比，这里因为修改过了Person类，导致两个id是不一样的，所以会报错。

但是，修改了一个类中的某一处地方，这个类的大体构造还是没有变的，我们不希望因为一点变动就改变类的id。因此可以用serialVersionUID来固定一个class文件的id值
先选中这里的选项并应用



这样就给这个类添加了一个serialVersionUID
现在先写入文件，然后再修改Person类，再从文件中读取类对象，也不会出现异常报错

（三）如果不想在序列化的时候把某个成员变量也序列化存到文件中，应该怎么办
java中提供了一个关键字，可以让我们在序列化的时候选择哪些成员不被序列化，叫做：transient

比如这里给age属性加上transient关键字

再运行write（）和read（）方法
控制台输出的结果是

age的值为0，也就是无法获得age值