一、序列化的含義、意義及使用場景二、序列化實現的方式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序列化