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

java序列化，看這篇就夠了

阿新 • • 發佈：2019-05-21

一、序列化的含義、意義及使用場景二、序列化實現的方式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 版本號，方便專案升級。

相關推薦

java序列化，看這篇就夠了

一、序列化的含義、意義及使用場景二、序列化實現的方式1、Serializable1.1 普通序列化1.2 成員是引用的序列化1.3 同一物件序列化多次的機制1.4 java序列化演算法潛在的問題1.5 可選的自定義序列化2、Externalizable：強制自定義序列化3、兩種序列化對比三、序列化版本號ser

Java 動態代理，看這篇就夠了

這篇文章需要用到 Java 的反射知識，如果對反射還不清楚的小夥伴，可以先移步到這裡 《Java進階-反射》。 程式設計思想都是來自於生活的，“代理” 在生活中很常見。比如我們買一個東西時，一般都不會是直接從工廠裡買的，而是去商店或者其他的商家買，這些商家做的事情就是代理。

學習Java JDBC，看這篇就夠了

影響 數據庫中間件 project prepare 管理系 lba 分布 為我 vax JDBC (Java DB Connection)---Java數據庫連接 JDBC是一種可用於運行SQL語句的JAVA API（ApplicationProgramming

Java執行緒池詳解，看這篇就夠了！

構造一個執行緒池為什麼需要幾個引數？如果避免執行緒池出現OOM？Runnable和Callable的區別是什麼？本文將對這些問題一一解答，同時還將給出使用執行緒池的常見場景和程式碼片段。 基礎知識 Executors建立執行緒池 Java中建立執行緒池很簡單，只需要呼叫Execu

【本人禿頂程式設計師】Java執行緒池詳解，看這篇就夠了！

←←←←←←←←←←←← 快！點關注！！！ 構造一個執行緒池為什麼需要幾個引數？如果避免執行緒池出現OOM？Runnable和Callable的區別是什麼？本文將對這些問題一一解答，同時還將給出使用執行緒池的常見場景和程式碼片段。 基礎知識 Executors建立執行緒池 J

入門Webpack，看這篇就夠了

ref ebp shu 走了 pack webp body 入門 ble 原文地址：https://www.jianshu.com/p/42e11515c10f一直以前對webpack不是很了解，通過看了原文，自己動手走了一邊，算是對webpack有了個入門。我把自己做了的

Map總結，看這篇就夠了

java map 概要 學完了Map的全部內容，我們再回頭開開Map的框架圖。 第1部分 Map概括 (01) Map 是“鍵值對”映射的抽象接口。(02) AbstractMap 實現了Map中的絕大部分函數接口。它減少了“Map的實現類”的重復編碼。(03) SortedMap 有序的“鍵值對”映

入門 Webpack，看這篇就夠了

通過 位置 post 進行 參考 sets 想要 避免 pat 轉：https://segmentfault.com/a/1190000006178770 2018年8月25日更新，目前 webpack 已經更新值 4.17.1 ，本文所用到的各種庫或多或少有些過時，跟著代

Elasticsearch Query DSL 整理總結（二）—— 要搞懂 Match Query，看這篇就夠了

目錄 引言 構建示例 match operator 引數 analyzer lenient 引數 Fuzziness fuzzniess 引數 什麼是模糊搜尋？ Levenshtein Edit Dist

Python Web怎麼學，看這篇就夠了！

Python目前應用領域實在太多，這也是他這麼火的原因吧。我認為目前Python作為應用領域來說幾個方向是值得肯定的：人工智慧、大資料分析、DevOps、Web、自動化測試、爬蟲。 在Python基礎方向，我認為必須掌握的技能有： 基本資料型別、內建資料結構 函式、高階函式、裝飾器 迭代器、

Python Web怎麽學，看這篇就夠了！

哪些 都是 這一 djang quest int 數據類型 簡單 dev Python目前應用領域實在太多，這也是他這麽火的原因吧。我認為目前Python作為應用領域來說幾個方向是值得肯定的：人工智能、大數據分析、DevOps、Web、自動化測試、爬蟲。 在Python基礎

繼萬字諫言後，Python Web 怎麼學，看這篇就夠了！

  1. 之前那篇「萬字諫言，給那些想學Python的人，建議收藏後細看！」得到很多後臺讀者的留言，表示想再來點，甚至說萬字系？你知道萬字有多少麼？不要槓我根本沒有萬字！不叫萬字你能看到這篇良心嘛！ 那憋了3天了，今天放個web好了，相信很多讀者都有關注web開發，那我們

Python 中的 or，and 運算，看這篇就夠了

問題出現： Python 中的 or，and 運算，可以寫出非常複雜的演算表示式； 看了一些大神的演算規則解釋，覺得不是很好理解，有些人甚至理解錯了規則。 這篇部落格聊一下自己的理解。 其他人是怎麼做的： 先看兩個例子熱下身： return 1 or 2 return

Python 中的 or and 運算，看這篇就夠了

可能 參考答案 大神 cto 51cto 是不是 拆分 並且 情況 問題出現： Python 中的 or，and 運算，可以寫出非常復雜的演算表達式； 看了一些大神的演算規則解釋，覺得不是很好理解，有些人甚至理解錯了規則。 這裏聊一下自己的理解。 其他人是怎麽做的：

10大經典排序演算法動圖演示，看這篇就夠了！（配相應程式碼）

排序演算法是《資料結構與演算法》中最基本的演算法之一。 排序演算法可以分為內部排序和外部排序。 內部排序是資料記錄在記憶體中進行排序。 而外部排序是因排序的資料很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。 常見的內部排序演算法有：插入排序、希爾排序、選擇排序、氣泡排序、歸併排序、快速排

mybatis 快取的使用， 看這篇就夠了

快取的重要性是不言而喻的。 使用快取， 我們可以避免頻繁的與資料庫進行互動， 尤其是在查詢越多、快取命中率越高的情況下， 使用快取對效能的提高更明顯。 mybatis 也提供了對快取的支援， 分為一級快取和二級快取。 但是在預設的情況下， 只開啟一級快取（一級快

搞定計算機網路面試，看這篇就夠了

文章目錄結構：  一 OSI與TCP/IP各層的結構與功能，都有哪些協議 運輸層主要使用以下兩種協議： UDP的主要特點： TCP的主要特點： 域名系統（Domain Name System縮寫DNS，Doma

Elasticsearch Query DSL 整理總結（二）—— 要搞懂 Match Query，看這篇就夠了

目錄 引言 昨天是感恩節，上幼兒園的女兒在老師的叮囑下，晚上為我和老婆洗了腳(形式上的^_^)，還給我們每人端了一杯水。看著孩子一天天的長大，懂事，感覺很開心，話說咱們程式設計師這麼辛苦是為了什麼？不就是為了老婆，孩子，熱炕頭，有一個溫暖幸福的家庭，再捎帶著用程式碼改變一下世界嗎？想到這裡，頓時覺得學習，創

jdk安裝與環境變數配置，看這篇就夠了

文章目錄 - 場景 - jdk 下載安裝 - 如何環境變數的配置 - 總結 場景 在做 java 開發或者 android 開發，經常會碰到 jdk 安裝與環境變數的配置，每次配置的時候，經常需要去檢視一下，而且偶爾還會

Python 3 入門，看這篇就夠了

簡介 Python 是一種高層次的結合瞭解釋性、編譯性、互動性和麵向物件的指令碼語言。Python 由 Guido van Rossum 於 1989 年底在荷蘭國家數學和電腦科學研究所發明，第一個公開發行版發行於 1991 年。 特點 易於學習：Pyt