java序列化，看这篇就够了

一、序列化的含义、意义及使用场景二、序列化实现的方式1、Serializable1.1 普通序列化1.2 成员是引用的序列化1.3 同一对象序列化多次的机制1.4 java序列化算法潜在的问题1.5 可选的自定义序列化2、Externalizable：强制自定义序列化3、两种序列化对比三、序列化版本号serialVersionUID四、总结

• 序列化：将对象写入到IO流中

• 反序列化：从IO流中恢复对象

• 意义：序列化机制允许将实现序列化的Java对象转换位字节序列，这些字节序列可以保存在磁盘上，或通过网络传输，以达到以后恢复成原来的对象。序列化机制使得对象可以脱离程序的运行而独立存在。

• 使用场景：所有可在网络上传输的对象都必须是可序列化的，比如RMI（remote method invoke,即远程方法调用），传入的参数或返回的对象都是可序列化的，否则会出错；所有需要保存到磁盘的java对象都必须是可序列化的。通常建议：程序创建的每个JavaBean类都实现Serializeable接口。
  二、序列化实现的方式

  如果需要将某个对象保存到磁盘上或者通过网络传输，那么这个类应该实现Serializable接口或者Externalizable接口之一。

  1、Serializable

  1.1 普通序列化

  Serializable接口是一个标记接口，不用实现任何方法。一旦实现了此接口，该类的对象就是可序列化的。

  1. 序列化步骤：

  • 步骤一：创建一个ObjectOutputStream输出流；

  • 步骤二：调用ObjectOutputStream对象的writeObject输出可序列化对象。

    public class Person implements Serializable {
      private String name;
      private int age;
      //我不提供无参构造器
      public Person(String name, int age) {
          this.name = name;
          this.age = age;
      }
    
      @Override
      public String toString() {
          return "Person{" +
                  "name=" + name +  +
                  ", age=" + age +
                  };
      }
    }
    
    public class WriteObject {
      public static void main(String[] args) {
          try (//创建一个ObjectOutputStream输出流
               ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"))) {
              //将对象序列化到文件s
              Person person = new Person("9龙", 23);
              oos.writeObject(person);
          } catch (Exception e) {
              e.printStackTrace();
          }
      }
    }
    

    1. 反序列化步骤：

    • 步骤一：创建一个ObjectInputStream输入流；

    • 步骤二：调用ObjectInputStream对象的readObject()得到序列化的对象。

      我们将上面序列化到person.txt的person对象反序列化回来

      public class Person implements Serializable {
        private String name;
        private int age;
        //我不提供无参构造器
        public Person(String name, int age) {
            System.out.println("反序列化，你调用我了吗？");
            this.name = name;
            this.age = age;
        }
      
        @Override
        public String toString() {
            return "Person{" +
                    "name=" + name +  +
                    ", age=" + age +
                    };
        }
      }
      
      public class ReadObject {
        public static void main(String[] args) {
            try (//创建一个ObjectInputStream输入流
                 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"))) {
                Person brady = (Person) ois.readObject();
                System.out.println(brady);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
      }
      //输出结果
      //Person{name=9龙, age=23}
      

      waht);

      1.2 成员是引用的序列化

      如果一个可序列化的类的成员不是基本类型，也不是String类型，那这个引用类型也必须是可序列化的；否则，会导致此类不能序列化。

      看例子，我们新增一个Teacher类。将Person去掉实现Serializable接口代码。

      public class Person{
          //省略相关属性与方法
      }
      public class Teacher implements Serializable {
      
          private String name;
          private Person person;
      
          public Teacher(String name, Person person) {
              this.name = name;
              this.person = person;
          }
      
           public static void main(String[] args) throws Exception {
              try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("teacher.txt"))) {
                  Person person = new Person("路飞", 20);
                  Teacher teacher = new Teacher("雷利", person);
                  oos.writeObject(teacher);
              }
          }
      }
      

      我们看到程序直接报错，因为Person类的对象是不可序列化的，这导致了Teacher的对象不可序列化

      1.3 同一对象序列化多次的机制

      同一对象序列化多次，会将这个对象序列化多次吗？答案是否定的。

      public class WriteTeacher {
          public static void main(String[] args) throws Exception {
              try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("teacher.txt"))) {
                  Person person = new Person("路飞", 20);
                  Teacher t1 = new Teacher("雷利", person);
                  Teacher t2 = new Teacher("红发香克斯", person);
                  //依次将4个对象写入输入流
                  oos.writeObject(t1);
                  oos.writeObject(t2);
                  oos.writeObject(person);
                  oos.writeObject(t2);
              }
          }
      }
      

      依次将t1、t2、person、t2对象序列化到文件teacher.txt文件中。

      注意：反序列化的顺序与序列化时的顺序一致。

      public class ReadTeacher {
          public static void main(String[] args) {
              try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("teacher.txt"))) {
                  Teacher t1 = (Teacher) ois.readObject();
                  Teacher t2 = (Teacher) ois.readObject();
                  Person p = (Person) ois.readObject();
                  Teacher t3 = (Teacher) ois.readObject();
                  System.out.println(t1 == t2);
                  System.out.println(t1.getPerson() == p);
                  System.out.println(t2.getPerson() == p);
                  System.out.println(t2 == t3);
                  System.out.println(t1.getPerson() == t2.getPerson());
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }
      }
      //输出结果
      //false
      //true
      //true
      //true
      //true
      

      从输出结果可以看出，Java序列化同一对象，并不会将此对象序列化多次得到多个对象。

      • Java序列化算法

        1. 所有保存到磁盘的对象都有一个序列化编码号

        2. 当程序试图序列化一个对象时，会先检查此对象是否已经序列化过，只有此对象从未（在此虚拟机）被序列化过，才会将此对象序列化为字节序列输出。

        3. 如果此对象已经序列化过，则直接输出编号即可。

           图示上述序列化过程。

        1.4 java序列化算法潜在的问题

        由于java序利化算法不会重复序列化同一个对象，只会记录已序列化对象的编号。如果序列化一个可变对象（对象内的内容可更改）后，更改了对象内容，再次序列化，并不会再次将此对象转换为字节序列，而只是保存序列化编号。

        public class WriteObject {
            public static 
                         
        
                                                                                                                            
                                 云服务器
                                                     
                                 GPU云服务器
                                                                                                                                                         
                                              
                             
                            
                                                                                                       篇就够
                                                                                                                   儿就够
                                                                                                                   看这
                                                                                                                   java序列化