1. 程式人生 > >java序列化,看這篇就夠了

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???? 輸出告訴我們,反序列化並不會呼叫構造方法。反序列的物件是由JVM自己生成的物件,不通過構造方法生成。

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 void main(String[] args) {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
             ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) {
            //第一次序列化person
            Person person = new Person("9龍", 23);
            oos.writeObject(person);
            System.out.println(person);

            //修改name
            person.setName("海賊王");
            System.out.println(person);
            //第二次序列化person
            oos.writeObject(person);

            //依次反序列化出p1、p2
            Person p1 = (Person) ios.readObject();
            Person p2 = (Person) ios.readObject();
            System.out.println(p1 == p2);
            System.out.println(p1.getName().equals(p2.getName()));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
//輸出結果
//Person{name='9龍', age=23}
//Person{name='海賊王', age=23}
//true
//true
1.5 可選的自定義序列化
  1. 有些時候,我們有這樣的需求,某些屬性不需要序列化。使用transient關鍵字選擇不需要序列化的欄位。

    public class Person implements Serializable {
       //不需要序列化名字與年齡
       private transient String name;
       private transient int age;
       private int height;
       private transient boolean singlehood;
       public Person(String name, int age) {
           this.name = name;
           this.age = age;
       }
       //省略get,set方法
    }

    public class TransientTest {
       public static void main(String[] args) throws Exception {
           try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
                ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) {
               Person person = new Person("9龍", 23);
               person.setHeight(185);
               System.out.println(person);
               oos.writeObject(person);
               Person p1 = (Person)ios.readObject();
               System.out.println(p1);
           }
       }
    }
    //輸出結果
    //Person{name='9龍', age=23', singlehood=true', height=185cm}
    //Person{name='null', age=0', singlehood=false', height=185cm}

    從輸出我們看到,使用transient修飾的屬性,java序列化時,會忽略掉此欄位,所以反序列化出的物件,被transient修飾的屬性是預設值。對於引用型別,值是null;基本型別,值是0;boolean型別,值是false。

  2. 使用transient雖然簡單,但將此屬性完全隔離在了序列化之外。java提供了可選的自定義序列化。可以進行控制序列化的方式,或者對序列化資料進行編碼加密等。

    private void writeObject(java.io.ObjectOutputStream out) throws IOException;
    private void readObject(java.io.ObjectIutputStream in) throws IOException,ClassNotFoundException;
    private void readObjectNoData() throws ObjectStreamException;

    通過重寫writeObject與readObject方法,可以自己選擇哪些屬性需要序列化, 哪些屬性不需要。如果writeObject使用某種規則序列化,則相應的readObject需要相反的規則反序列化,以便能正確反序列化出物件。這裡展示對名字進行反轉加密。

    public class Person implements Serializable {
       private String name;
       private int age;
       //省略構造方法,get及set方法

       private void writeObject(ObjectOutputStream out) throws IOException {
           //將名字反轉寫入二進位制流
           out.writeObject(new StringBuffer(this.name).reverse());
           out.writeInt(age);
       }

       private void readObject(ObjectInputStream ins) throws IOException,ClassNotFoundException{
           //將讀出的字串反轉恢復回來
           this.name = ((StringBuffer)ins.readObject()).reverse().toString();
           this.age = ins.readInt();
       }
    }

    當序列化流不完整時,readObjectNoData()方法可以用來正確地初始化反序列化的物件。例如,使用不同類接收反序列化物件,或者序列化流被篡改時,系統都會呼叫readObjectNoData()方法來初始化反序列化的物件。

  3. 更徹底的自定義序列化

    ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;
    ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;

    • writeReplace:在序列化時,會先呼叫此方法,再呼叫writeObject方法。此方法可將任意物件代替目標序列化物件

      public class Person implements Serializable {
        private String name;
        private int age;
        //省略構造方法,get及set方法

        private Object writeReplace() throws ObjectStreamException {
            ArrayList<Object> list = new ArrayList<>(2);
            list.add(this.name);
            list.add(this.age);
            return list;
        }

         public static void main(String[] args) throws Exception {
            try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
                 ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) {
                Person person = new Person("9龍", 23);
                oos.writeObject(person);
                ArrayList list = (ArrayList)ios.readObject();
                System.out.println(list);
            }
        }
      }
      //輸出結果
      //[9龍, 23]
    • readResolve:反序列化時替換反序列化出的物件,反序列化出來的物件被立即丟棄。此方法在readeObject後呼叫。

      public class Person implements Serializable {
          private String name;
          private int age;
          //省略構造方法,get及set方法
           private Object readResolve() throws ObjectStreamException{
              return new ("brady", 23);
          }
          public static void main(String[] args) throws Exception {
              try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
                   ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) {
                  Person person = new Person("9龍", 23);
                  oos.writeObject(person);
                  HashMap map = (HashMap)ios.readObject();
                  System.out.println(map);
              }
          }
      }
      //輸出結果
      //{brady=23}

      readResolve常用來反序列單例類,保證單例類的唯一性。

      注意:readResolve與writeReplace的訪問修飾符可以是private、protected、public,如果父類重寫了這兩個方法,子類都需要根據自身需求重寫,這顯然不是一個好的設計。通常建議對於final修飾的類重寫readResolve方法沒有問題;否則,重寫readResolve使用private修飾。

2、Externalizable:強制自定義序列化

通過實現Externalizable介面,必須實現writeExternal、readExternal方法。

public interface Externalizable extends java.io.Serializable {
     void writeExternal(ObjectOutput out) throws IOException;
     void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}
public class ExPerson implements Externalizable {

    private String name;
    private int age;
    //注意,必須加上pulic 無參構造器
    public ExPerson() {
    }

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

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        //將name反轉後寫入二進位制流
        StringBuffer reverse = new StringBuffer(name).reverse();
        System.out.println(reverse.toString());
        out.writeObject(reverse);
        out.writeInt(age);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        //將讀取的字串反轉後賦值給name例項變數
        this.name = ((StringBuffer) in.readObject()).reverse().toString();
        System.out.println(name);
        this.age = in.readInt();
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ExPerson.txt"));
             ObjectInputStream ois = new ObjectInputStream(new FileInputStream("ExPerson.txt"))) {
            oos.writeObject(new ExPerson("brady", 23));
            ExPerson ep = (ExPerson) ois.readObject();
            System.out.println(ep);
        }
    }
}
//輸出結果
//ydarb
//brady
//ExPerson{name='brady', age=23}

注意:Externalizable介面不同於Serializable介面,實現此介面必須實現介面中的兩個方法實現自定義序列化,這是強制性的;特別之處是必須提供pulic的無參構造器,因為在反序列化的時候需要反射建立物件。

3、兩種序列化對比

實現Serializable介面 實現Externalizable介面
系統自動儲存必要的資訊 程式設計師決定儲存哪些資訊
Java內建支援,易於實現,只需要實現該介面即可,無需任何程式碼支援 必須實現介面內的兩個方法
效能略差 效能略好

雖然Externalizable介面帶來了一定的效能提升,但變成複雜度也提高了,所以一般通過實現Serializable介面進行序列化。

三、序列化版本號serialVersionUID

我們知道,反序列化必須擁有class檔案,但隨著專案的升級,class檔案也會升級,序列化怎麼保證升級前後的相容性呢?

java序列化提供了一個private static final long serialVersionUID 的序列化版本號,只有版本號相同,即使更改了序列化屬性,物件也可以正確被反序列化回來。

public class Person implements Serializable {
    //序列化版本號
    private static final long serialVersionUID = 1111013L;
    private String name;
    private int age;
    //省略構造方法及get,set
}

如果反序列化使用的class的版本號與序列化時使用的不一致,反序列化會報InvalidClassException異常。

序列化版本號可自由指定,如果不指定,JVM會根據類資訊自己計算一個版本號,這樣隨著class的升級,就無法正確反序列化;不指定版本號另一個明顯隱患是,不利於jvm間的移植,可能class檔案沒有更改,但不同jvm可能計算的規則不一樣,這樣也會導致無法反序列化。

什麼情況下需要修改serialVersionUID呢?分三種情況。

  • 如果只是修改了方法,反序列化不容影響,則無需修改版本號;
  • 如果只是修改了靜態變數,瞬態變數(transient修飾的變數),反序列化不受影響,無需修改版本號;
  • 如果修改了非瞬態變數,則可能導致反序列化失敗。如果新類中例項變數的型別與序列化時類的型別不一致,則會反序列化失敗,這時候需要更改serialVersionUID。如果只是新增了例項變數,則反序列化回來新增的是預設值;如果減少了例項變數,反序列化時會忽略掉減少的例項變數。

四、總結

  1. 所有需要網路傳輸的物件都需要實現序列化介面,通過建議所有的javaBean都實現Serializable介面。
  2. 物件的類名、例項變數(包括基本型別,陣列,對其他物件的引用)都會被序列化;方法、類變數、transient例項變數都不會被序列化。
  3. 如果想讓某個變數不被序列化,使用transient修飾。
  4. 序列化物件的引用型別成員變數,也必須是可序列化的,否則,會報錯。
  5. 反序列化時必須有序列化物件的class檔案。
  6. 當通過檔案、網路來讀取序列化後的物件時,必須按照實際寫入的順序讀取。
  7. 單例類序列化,需要重寫readResolve()方法;否則會破壞單例原則。
  8. 同一物件序列化多次,只有第一次序列化為二進位制流,以後都只是儲存序列化編號,不會重複序列化。
  9. 建議所有可序列化的類加上serialVersionUID 版本號,方便專案升級。