深入理解 Java 序列化

靜默虛空發表於2019-03-22

:notebook: 本文已歸檔到:「blog

:keyboard: 本文中的示例程式碼已歸檔到:「javacore

簡介


深入理解 Java 序列化

  • 序列化(serialize) - 序列化是將物件轉換為位元組流。
  • 反序列化(deserialize) - 反序列化是將位元組流轉換為物件。
  • 序列化用途
    • 序列化可以將物件的位元組序列持久化——儲存在記憶體、檔案、資料庫中。
    • 在網路上傳送物件的位元組序列。
    • RMI(遠端方法呼叫)

:bell: 注意:使用 Java 物件序列化,在儲存物件時,會把其狀態儲存為一組位元組,在未來,再將這些位元組組裝成物件。必須注意地是,物件序列化儲存的是物件的”狀態”,即它的成員變數。由此可知,物件序列化不會關注類中的靜態變數

序列化和反序列化

Java 通過物件輸入輸出流來實現序列化和反序列化:

  • java.io.ObjectOutputStream 類的 writeObject() 方法可以實現序列化;
  • java.io.ObjectInputStream 類的 readObject() 方法用於實現反序列化。

序列化和反序列化示例:

public class SerializeDemo01 {
    enum Sex {
        MALE,
        FEMALE
    }


    static class Person implements Serializable {
        private static final long serialVersionUID = 1L;
        private String name = null;
        private Integer age = null;
        private Sex sex;

        public Person() { }

        public Person(String name, Integer age, Sex sex) {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }

        @Override
        public String toString() {
            return "Person{" + "name='" + name + '\'' + ", age=" + age + ", sex=" + sex + '}';
        }
    }

    /**
     * 序列化
     */
    private static void serialize(String filename) throws IOException {
        File f = new File(filename); // 定義儲存路徑
        OutputStream out = new FileOutputStream(f); // 檔案輸出流
        ObjectOutputStream oos = new ObjectOutputStream(out); // 物件輸出流
        oos.writeObject(new Person("Jack", 30, Sex.MALE)); // 儲存物件
        oos.close();
        out.close();
    }

    /**
     * 反序列化
     */
    private static void deserialize(String filename) throws IOException, ClassNotFoundException {
        File f = new File(filename); // 定義儲存路徑
        InputStream in = new FileInputStream(f); // 檔案輸入流
        ObjectInputStream ois = new ObjectInputStream(in); // 物件輸入流
        Object obj = ois.readObject(); // 讀取物件
        ois.close();
        in.close();
        System.out.println(obj);
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        final String filename = "d:/text.dat";
        serialize(filename);
        deserialize(filename);
    }
}
// Output:
// Person{name='Jack', age=30, sex=MALE}
複製程式碼

Serializable 介面

被序列化的類必須屬於 Enum、Array 和 Serializable 型別其中的任何一種

如果不是 Enum、Array 的類,如果需要序列化,必須實現 java.io.Serializable 介面,否則將丟擲 NotSerializableException 異常。這是因為:在序列化操作過程中會對型別進行檢查,如果不滿足序列化型別要求,就會丟擲異常。

我們不妨做一個小嚐試:將 SerializeDemo01 示例中 Person 類改為如下實現,然後看看執行結果。

public class UnSerializeDemo {
    static class Person { // 其他內容略 }
    // 其他內容略
}
複製程式碼

輸出:結果就是出現如下異常資訊。

Exception in thread "main" java.io.NotSerializableException:
...
複製程式碼

serialVersionUID

請注意 serialVersionUID 欄位,你可以在 Java 世界的無數類中看到這個欄位。

serialVersionUID 有什麼作用,如何使用 serialVersionUID

serialVersionUID 是 Java 為每個序列化類產生的版本標識。它可以用來保證在反序列時,傳送方傳送的和接受方接收的是可相容的物件。如果接收方接收的類的 serialVersionUID 與傳送方傳送的 serialVersionUID 不一致,會丟擲 InvalidClassException

如果可序列化類沒有顯式宣告 serialVersionUID,則序列化執行時將基於該類的各個方面計算該類的預設 serialVersionUID 值。儘管這樣,還是建議在每一個序列化的類中顯式指定 serialVersionUID 的值。因為不同的 jdk 編譯很可能會生成不同的 serialVersionUID 預設值,從而導致在反序列化時丟擲 InvalidClassExceptions 異常。

serialVersionUID 欄位必須是 static final long 型別

我們來舉個例子:

(1)有一個可序列化類 Person

public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private Integer age;
    private String address;
    // 構造方法、get、set 方法略
}
複製程式碼

(2)開發過程中,對 Person 做了修改,增加了一個欄位 email,如下:

public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private Integer age;
    private String address;
    private String email;
    // 構造方法、get、set 方法略
}
複製程式碼

由於這個類和老版本不相容,我們需要修改版本號:

private static final long serialVersionUID = 2L;
複製程式碼

再次進行反序列化,則會丟擲 InvalidClassException 異常。

綜上所述,我們大概可以清楚:serialVersionUID 用於控制序列化版本是否相容。若我們認為修改的可序列化類是向後相容的,則不修改 serialVersionUID

預設序列化機制

如果僅僅只是讓某個類實現 Serializable 介面,而沒有其它任何處理的話,那麼就會使用預設序列化機制。

使用預設機制,在序列化物件時,不僅會序列化當前物件本身,還會對其父類的欄位以及該物件引用的其它物件也進行序列化。同樣地,這些其它物件引用的另外物件也將被序列化,以此類推。所以,如果一個物件包含的成員變數是容器類物件,而這些容器所含有的元素也是容器類物件,那麼這個序列化的過程就會較複雜,開銷也較大。

注意:這裡的父類和引用物件既然要進行序列化,那麼它們當然也要滿足序列化要求:被序列化的類必須屬於 Enum、Array 和 Serializable 型別其中的任何一種

非預設序列化機制

在現實應用中,有些時候不能使用預設序列化機制。比如,希望在序列化過程中忽略掉敏感資料,或者簡化序列化過程。下面將介紹若干影響序列化的方法。

transient 關鍵字

當某個欄位被宣告為 transient 後,預設序列化機制就會忽略該欄位

我們將 SerializeDemo01 示例中的內部類 Person 的 age 欄位宣告為 transient,如下所示:

public class SerializeDemo02 {
    static class Person implements Serializable {
        transient private Integer age = null;
        // 其他內容略
    }
    // 其他內容略
}
// Output:
// name: Jack, age: null, sex: MALE
複製程式碼

從輸出結果可以看出,age 欄位沒有被序列化。

Externalizable 介面

無論是使用 transient 關鍵字,還是使用 writeObject()readObject() 方法,其實都是基於 Serializable 介面的序列化。

JDK 中提供了另一個序列化介面--Externalizable

可序列化類實現 Externalizable 介面之後,基於 Serializable 介面的預設序列化機制就會失效

我們來基於 SerializeDemo02 再次做一些改動,程式碼如下:

public class ExternalizeDemo01 {
    static class Person implements Externalizable {
        transient private Integer age = null;
        // 其他內容略

        private void writeObject(ObjectOutputStream out) throws IOException {
            out.defaultWriteObject();
            out.writeInt(age);
        }

        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            in.defaultReadObject();
            age = in.readInt();
        }

        @Override
        public void writeExternal(ObjectOutput out) throws IOException { }

        @Override
        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { }
    }
     // 其他內容略
}
// Output:
// call Person()
// name: null, age: null, sex: null
複製程式碼

從該結果,一方面可以看出 Person 物件中任何一個欄位都沒有被序列化。另一方面,如果細心的話,還可以發現這此次序列化過程呼叫了 Person 類的無參構造方法。

  • Externalizable 繼承於 Serializable,它增添了兩個方法:writeExternal()readExternal()。這兩個方法在序列化和反序列化過程中會被自動呼叫,以便執行一些特殊操作。當使用該介面時,序列化的細節需要由程式設計師去完成。如上所示的程式碼,由於 writeExternal()readExternal() 方法未作任何處理,那麼該序列化行為將不會儲存/讀取任何一個欄位。這也就是為什麼輸出結果中所有欄位的值均為空。
  • 另外,若使用 Externalizable 進行序列化,當讀取物件時,會呼叫被序列化類的無參構造方法去建立一個新的物件;然後再將被儲存物件的欄位的值分別填充到新物件中。這就是為什麼在此次序列化過程中 Person 類的無參構造方法會被呼叫。由於這個原因,實現 Externalizable 介面的類必須要提供一個無參的構造方法,且它的訪問許可權為 public

對上述 Person 類作進一步的修改,使其能夠對 name 與 age 欄位進行序列化,但要忽略掉 gender 欄位,如下程式碼所示:

public class ExternalizeDemo02 {
    static class Person implements Externalizable {
        transient private Integer age = null;
        // 其他內容略

        private void writeObject(ObjectOutputStream out) throws IOException {
            out.defaultWriteObject();
            out.writeInt(age);
        }

        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            in.defaultReadObject();
            age = in.readInt();
        }

        @Override
        public void writeExternal(ObjectOutput out) throws IOException {
            out.writeObject(name);
            out.writeInt(age);
        }

        @Override
        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
            name = (String) in.readObject();
            age = in.readInt();
        }
    }
     // 其他內容略
}
// Output:
// call Person()
// name: Jack, age: 30, sex: null
複製程式碼

Externalizable 介面的替代方法

實現 Externalizable 介面可以控制序列化和反序列化的細節。它有一個替代方法:實現 Serializable 介面,並新增 writeObject(ObjectOutputStream out)readObject(ObjectInputStream in) 方法。序列化和反序列化過程中會自動回撥這兩個方法。

示例如下所示:

public class SerializeDemo03 {
    static class Person implements Serializable {
        transient private Integer age = null;
        // 其他內容略

        private void writeObject(ObjectOutputStream out) throws IOException {
            out.defaultWriteObject();
            out.writeInt(age);
        }

        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            in.defaultReadObject();
            age = in.readInt();
        }
        // 其他內容略
    }
    // 其他內容略
}
// Output:
// name: Jack, age: 30, sex: MALE
複製程式碼

writeObject() 方法中會先呼叫 ObjectOutputStream 中的 defaultWriteObject() 方法,該方法會執行預設的序列化機制,如上節所述,此時會忽略掉 age 欄位。然後再呼叫 writeInt() 方法顯示地將 age 欄位寫入到 ObjectOutputStream 中。readObject() 的作用則是針對物件的讀取,其原理與 writeObject() 方法相同。

注意:writeObject()readObject() 都是 private 方法,那麼它們是如何被呼叫的呢?毫無疑問,是使用反射。詳情可見 ObjectOutputStream 中的 writeSerialData 方法,以及 ObjectInputStream 中的 readSerialData 方法。

readResolve() 方法

當我們使用 Singleton 模式時,應該是期望某個類的例項應該是唯一的,但如果該類是可序列化的,那麼情況可能會略有不同。此時對第 2 節使用的 Person 類進行修改,使其實現 Singleton 模式,如下所示:

public class SerializeDemo04 {

    enum Sex {
        MALE, FEMALE
    }

    static class Person implements Serializable {
        private static final long serialVersionUID = 1L;
        private String name = null;
        transient private Integer age = null;
        private Sex sex;
        static final Person instatnce = new Person("Tom", 31, Sex.MALE);

        private Person() {
            System.out.println("call Person()");
        }

        private Person(String name, Integer age, Sex sex) {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }

        public static Person getInstance() {
            return instatnce;
        }

        private void writeObject(ObjectOutputStream out) throws IOException {
            out.defaultWriteObject();
            out.writeInt(age);
        }

        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            in.defaultReadObject();
            age = in.readInt();
        }

        public String toString() {
            return "name: " + this.name + ", age: " + this.age + ", sex: " + this.sex;
        }
    }

    /**
     * 序列化
     */
    private static void serialize(String filename) throws IOException {
        File f = new File(filename); // 定義儲存路徑
        OutputStream out = new FileOutputStream(f); // 檔案輸出流
        ObjectOutputStream oos = new ObjectOutputStream(out); // 物件輸出流
        oos.writeObject(new Person("Jack", 30, Sex.MALE)); // 儲存物件
        oos.close();
        out.close();
    }

    /**
     * 反序列化
     */
    private static void deserialize(String filename) throws IOException, ClassNotFoundException {
        File f = new File(filename); // 定義儲存路徑
        InputStream in = new FileInputStream(f); // 檔案輸入流
        ObjectInputStream ois = new ObjectInputStream(in); // 物件輸入流
        Object obj = ois.readObject(); // 讀取物件
        ois.close();
        in.close();
        System.out.println(obj);
        System.out.println(obj == Person.getInstance());
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        final String filename = "d:/text.dat";
        serialize(filename);
        deserialize(filename);
    }
}
// Output:
// name: Jack, age: null, sex: MALE
// false
複製程式碼

值得注意的是,從檔案中獲取的 Person 物件與 Person 類中的單例物件並不相等。為了能在單例類中仍然保持序列的特性,可以使用 readResolve() 方法。在該方法中直接返回 Person 的單例物件。我們在 SerializeDemo04 示例的基礎上新增一個 readObject 方法, 如下所示:

public class SerializeDemo05 {
    // 其他內容略

    static class Person implements Serializable {

        // 新增此方法
        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            in.defaultReadObject();
            age = in.readInt();
        }
        // 其他內容略
    }

    // 其他內容略
}
// Output:
// name: Tom, age: 31, sex: MALE
// true
複製程式碼

序列化工具

Java 官方的序列化存在許多問題,因此,很多人更願意使用優秀的第三方序列化工具來替代 Java 自身的序列化機制。

Java 官方的序列化主要體現在以下方面:

  • Java 官方的序列化效能不高,序列化後的資料相對於一些優秀的序列化的工具,還是要大不少,這大大影響儲存和傳輸的效率。
  • Java 官方的序列化一定需要實現 Serializable 介面。
  • Java 官方的序列化需要關注 serialVersionUID。
  • Java 官方的序列無法跨語言使用。

當然我們還有更加優秀的一些序列化和反序列化的工具,根據不同的使用場景可以自行選擇!

  • thriftprotobuf - 適用於對效能敏感,對開發體驗要求不高的內部系統。
  • hessian - 適用於對開發體驗敏感,效能有要求的內外部系統。
  • jacksongsonfastjson - 適用於對序列化後的資料要求有良好的可讀性(轉為 json 、xml 形式)。

小結


深入理解 Java 序列化

參考資料

相關文章