Java 对象的序列化、反序列化

对象的序列化（Serialize）：将内存中的Java对象转换为与平台无关的二进制流（字节序列），然后存储在磁盘文件中，或通过网络传输给另一个网络节点。

对象的反序列化（Deserialize）：获取序列化的二进制流（不管是通过网络，还是通过读取磁盘文件），将之恢复为原来的Java对象。

要实现对象的序列化，该对象所属的类必须要是可序列化的，即该类必须实现以下2个接口之一：

• Serializable     这只是一个标记接口，此接口只是表明该类是可序列化的，不用实现任何方法。Java自带的类基本都已implement  Serializable，不用我们操心，我们自定义的类                         要实现序列化，必须要手写implement  Serializable。
• Externalizable      用于实现自定义序列化

要通过网络传输的Java对象、要保存到磁盘的Java对象必须要是可序列化的，不然程序会出现异常。

JavaEE的分布式应用往往要跨平台、跨网络，通过网络传输的Java对象必须要是可序列化的，HttpSession、ServletContext等Java  Web对象都已实现序列化。如果我们要通过网络传输自定义的Java对象，该类（一般是JavaBean）要是可序列化的。通常建议：把所有的JavaBean都写成是可序列化的。

ObjectOutputStream是一个处理流，提供了void  writeObject(Object  obj)方法用于对象的序列化（对象输出流，输出到文件/网络）。

ObjectInputStream也是一个处理流，提供了Object  readObject()方法用于反序列化（对象输入流，读取文件/网络中的对象到内存）。

示例：

 //要实现Serializable接口（并不用实现任何方法）
 class Student implements Serializable{
     private int id;
     private String name;
     private int age;

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

    public int getId(){
         return this.id;
    }

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

    public String getName(){
         return this.name;
    }

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

    public int getAge(){
         return this.age;
    }

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

  //序列化
         ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("./obj.txt"));  //处理流，要建立在节点流之上
         Student zhangsan=new Student(1,"张三",20);
         oos.writeObject(zhangsan);   //writeObject(Object obj)用于序列化一个对象（输出到文件/网络节点）

         //反序列化
         ObjectInputStream ois=new ObjectInputStream(new FileInputStream("./obj.txt"));
         Student student=(Student)ois.readObject();   //返回的是Object类型，所以往往要强制类型转换

         System.out.println("学号："+student.getId());
         System.out.println("姓名："+student.getName());
         System.out.println("年龄："+student.getAge());

ObjectInputStream、ObjectOutputStream也包含了其他IO方法，可输入/输出多种类型的数据，即可以字符为单位进行操作，又可以字节为单位进行操作。

writeObject(Object  obj)一次只能写出一个对象，可多次调用，向同一文件中写入多个对象；

readObject()一次只能读一个对象，读取一个对象后，指针自动后移，指向下一个对象。读的顺序和写的顺序是一一对应的。

示例：

  //序列化，向同一文件中写入多个对象
         ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("./obj.txt"));  //处理流，要建立在节点流之上
         Student zhangsan=new Student(1,"张三",20);
         Student lisi=new Student(2,"李四",20);
         Student wangwu=new Student(3,"王五",20);
         oos.writeObject(zhangsan);  //张三
         oos.writeObject(lisi);  //李四
         oos.writeObject(wangwu);  //王五

         //反序列化，读取顺序和写入顺序是一致的
         ObjectInputStream ois=new ObjectInputStream(new FileInputStream("./obj.txt"));
         Student zhangsan1=(Student)ois.readObject();    //张三
         Student lisi1=(Student)ois.readObject();  //李四
         Student wangwu1=(Student)ois.readObject();  //王五

如果要序列化的类有父类（直接或者间接），那么这些父类必须要是可序列化的，或者具有无参的构造函数，否则会抛出 InvalidClassException  异常。

 class Student extends People implements Serializable{
     //......
 }

如果Student要序列化，则有2种方案可选：

• 其父类People也要是可序列化的（递归）。       这样Student继承自People中的成员才可以序列化输出到文件/网络。
• 其父类不是可序列化的，但是其父类有无参的构造函数。      这样不会报错，但Student继承自People中的成员不会序列化输出到文件/网络。

如果该类持有其它类的引用，则引用的类都要是可序列化的，此类才是可序列化的。

 class Student implements Serializable {
     private int id;
     private String name;  //Java自带的类基本都实现了可序列化，不用管
     private int age;
     private Teacher teacher;    //此类持有一个Teacher类的引用。Teacher类必须要是可序列化的，Student类才是可序列化的。
     //......
 }

如果要多次输出同一个对象，则第一次输出的是该对象的字节序列，以后每次输出的是该对象的编号。

   ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("./obj.txt"));
         Student zhangsan=new Student(1,"张三",20);

         oos.writeObject(zhangsan);   //第一次序列化这个对象，输出此对象的字节序列。假设此对象的编号为1，编号唯一标识此对象。
         oos.writeObject(zhangsan);  //再次输出此对象，输出的是此对象的编号，直接输出1。读取此对象时读取的仍是zhangsan这个对象。
         oos.writeObject(zhangsan);  //直接输出1。
         //类似于c++中的指针，通过编号指向某个已存在对象。减少了重新序列化对象的时间、内存开销。

如果中间修改了此对象，再次序列化此对象时，修改后的结果不会同步到文件/网络节点中。

  ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("./obj.txt"));
         Student zhangsan=new Student(1,"张三",20);

         oos.writeObject(zhangsan);   //初次序列化，输出此对象的字节序列。假设编号为1
         zhangsan.setName("李四");   //之后修改了此对象
         oos.writeObject(zhangsan);  //再次输出此对象，输出的是编号1。1代表编号为1的对象。

         /*
         在此对象第一次序列化之后，对此对象做修改，后面再次输出此对象时，都是指向第一次输出的那个对象，做的修改并不会写到文件/网络节点中。
         读取的也都是第一次输出的那个对象。

         实际上，序列化一个对象时，JVM会先检查在本次虚拟机中是否已序列化过这个对象，如果已序列化过，直接输出对应的序列化编号，未序列化过才序列化。
 　　　　　JVM是以对象名来区分序列化的是否是同一个对象。对象名相同，JVM就认为序列化的是同一个对象，直接输出该对象的编号，并不判断此对象是否修改过。

         修改此对象后，就算我们把此对象序列化到另一个文件中，输出的也是此对象第一次序列化时的编号，修改并不会同步到这个文件中。
         */

Java9新增了过滤功能，读取对象时，可以先检查该对象是否满足指定的要求，满足才允许恢复，否则拒绝恢复。

  ObjectInputStream ois=new ObjectInputStream(new FileInputStream("obj.txt"));
         /*
         参数是一个ObjectInputFilter接口的对象，函数式接口，只需实现checkInput()方法。
         参数info是FilterInfo类的对象。

         返回值要是预定义的常量：
         Status.ALLOWED  允许恢复
         Status.REJECTED  拒绝恢复
         Status.UNDECIDED  未决定，将继续执行检查
          */
         ois.setObjectInputFilter((info)->{
             ObjectInputFilter serialFilter=ObjectInputFilter.Config.getSerialFilter();   //获取默认的输入过滤器
             if(serialFilter!=null){
                 //先使用默认的过滤器进行检查
                 ObjectInputFilter.Status status=serialFilter.checkInput(info);
                 //如果已知道结果
                 if (status!= ObjectInputFilter.Status.UNDECIDED)
                     return status;
             }
             //执行到此，就说明结果是Status.UNDECIDED，还不知道结果，要继续检查
             //如果引用不唯一，说明数据被污染了，不允许恢复
             if(info.references()!=1)
                 return ObjectInputFilter.Status.REJECTED;
             //是指定的类的对象（Student)，才允许恢复（执行反序列化)
             if(info.serialClass()!=null && info.serialClass() != Student.class)
                 return ObjectInputFilter.Status.ALLOWED;
             //执行到此，说明不是指定类的对象，不允许恢复。
             return ObjectInputFilter.Status.REJECTED;
         });
         //这样恢复的对象都是唯一的Student对象
         //...........