關于Java對象序列化您不知道的5件事
數(shù)年前，當和一個軟件團隊一起用 Java 語言編寫一個應用程序時，我體會到比一般程序員多知道一點關于 Java 對象序列化的知識所帶來的好處。
大約一年前，一個負責管理應用程序所有用戶設置的開發(fā)人員，決定將用戶設置存儲在一個 Hashtable 中，然后將這個 Hashtable 序列化到磁盤，以便持久化。當用戶更改設置時，便重新將 Hashtable 寫到磁盤。
這是一個優(yōu)雅的、開放式的設置系統(tǒng)，但是，當團隊決定從 Hashtable 遷移到 Java Collections 庫中的 HashMap 時，這個系統(tǒng)便面臨崩潰。
Hashtable 和 HashMap 在磁盤上的格式是不相同、不兼容的。除非對每個持久化的用戶設置運行某種類型的數(shù)據(jù)轉換實用程序(極其龐大的任務)，否則以后似乎只能一直用 Hashtable 作為應用程序的存儲格式。
團隊感到陷入僵局，但這只是因為他們不知道關于 Java 序列化的一個重要事實：Java 序列化允許隨著時間的推移而改變類型。當我向他們展示如何自動進行序列化替換后，他們終于按計劃完成了向 HashMap 的轉變。
本文是本系列的第一篇文章，這個系列專門揭示關于 Java 平臺的一些有用的小知識 — 這些小知識不易理解，但對于解決 Java 編程挑戰(zhàn)遲早有用。
將 Java 對象序列化 API 作為開端是一個不錯的選擇，因為它從一開始就存在于 JDK 1.1 中。本文介紹的關于序列化的 5 件事情將說服您重新審視那些標準 Java API。
Java 序列化簡介
Java 對象序列化是 JDK 1.1 中引入的一組開創(chuàng)性特性之一，用于作為一種將 Java 對象的狀態(tài)轉換為字節(jié)數(shù)組，以便存儲或傳輸?shù)臋C制，以后，仍可以將字節(jié)數(shù)組轉換回 Java 對象原有的狀態(tài)。
實際上，序列化的思想是 “凍結” 對象狀態(tài)，傳輸對象狀態(tài)(寫到磁盤、通過網絡傳輸?shù)鹊?，然后 “解凍” 狀態(tài)，重新獲得可用的 Java 對象。所有這些事情的發(fā)生有點像是魔術，這要歸功于 ObjectInputStream/ObjectOutputStream 類、完全保真的元數(shù)據(jù)以及程序員愿意用 Serializable 標識接口標記他們的類，從而 “參與” 這個過程。
清單 1 顯示一個實現(xiàn) Serializable 的 Person 類。
清單 1. Serializable Person
- package com.tedneward;
- public class Person
- implements java.io.Serializable
- {
- public Person(String fn, String ln, int a)
- {
- this.firstName = fn; this.lastName = ln; this.age = a;
- }
- public String getFirstName() { return firstName; }
- public String getLastName() { return lastName; }
- public int getAge() { return age; }
- public Person getSpouse() { return spouse; }
- public void setFirstName(String value) { firstName = value; }
- public void setLastName(String value) { lastName = value; }
- public void setAge(int value) { age = value; }
- public void setSpouse(Person value) { spouse = value; }
- public String toString()
- {
- return "[Person: firstName=" + firstName +
- " lastName=" + lastName +
- " age=" + age +
- " spouse=" + spouse.getFirstName() +
- "]";
- }
- private String firstName;
- private String lastName;
- private int age;
- private Person spouse;
- ｝
將 Person 序列化后，很容易將對象狀態(tài)寫到磁盤，然后重新讀出它，下面的 JUnit 4 單元測試對此做了演示。
清單 2. 對 Person 進行反序列化
- public class SerTest
- {
- @Test public void serializeToDisk()
- {
- try
- {
- com.tedneward.Person ted = new com.tedneward.Person("Ted", "Neward", 39);
- com.tedneward.Person charl = new com.tedneward.Person("Charlotte",
- "Neward", 38);
- ted.setSpouse(charl); charl.setSpouse(ted);
- FileOutputStream fos = new FileOutputStream("tempdata.ser");
- ObjectOutputStream oos = new ObjectOutputStream(fos);
- oos.writeObject(ted);
- oos.close();
- }
- catch (Exception ex)
- {
- fail("Exception thrown during test: " + ex.toString());
- }
- try
- {
- FileInputStream fis = new FileInputStream("tempdata.ser");
- ObjectInputStream ois = new ObjectInputStream(fis);
- com.tedneward.Person ted = (com.tedneward.Person) ois.readObject();
- ois.close();
- assertEquals(ted.getFirstName(）， "Ted");
- assertEquals(ted.getSpouse().getFirstName(）， "Charlotte");
- // Clean up the file
- new File("tempdata.ser").delete();
- }
- catch (Exception ex)
- {
- fail("Exception thrown during test: " + ex.toString());
- }
- }
- }
#p#
到現(xiàn)在為止，還沒有看到什么新鮮的或令人興奮的事情，但是這是一個很好的出發(fā)點。我們將使用 Person 來發(fā)現(xiàn)您可能不 知道的關于 Java 對象序列化 的 5 件事。
1. 序列化允許重構
序列化允許一定數(shù)量的類變種，甚至重構之后也是如此，ObjectInputStream 仍可以很好地將其讀出來。Java Object Serialization 規(guī)范可以自動管理的關鍵任務是：
- 將新字段添加到類中
- 將字段從 static 改為非 static
- 將字段從 transient 改為非 transient
取決于所需的向后兼容程度，轉換字段形式(從非 static 轉換為 static 或從非 transient 轉換為 transient)或者刪除字段需要額外的消息傳遞。
重構序列化類
既然已經知道序列化允許重構，我們來看看當把新字段添加到 Person 類中時，會發(fā)生什么事情。
如清單 3 所示，PersonV2 在原先 Person 類的基礎上引入一個表示性別的新字段。
清單 3. 將新字段添加到序列化的 Person 中
- enum Gender
- {
- MALE, FEMALE
- }
- public class Person
- implements java.io.Serializable
- {
- public Person(String fn, String ln, int a, Gender g)
- {
- this.firstName = fn; this.lastName = ln; this.age = a; this.gender = g;
- }
- public String getFirstName() { return firstName; }
- public String getLastName() { return lastName; }
- public Gender getGender() { return gender; }
- public int getAge() { return age; }
- public Person getSpouse() { return spouse; }
- public void setFirstName(String value) { firstName = value; }
- public void setLastName(String value) { lastName = value; }
- public void setGender(Gender value) { gender = value; }
- public void setAge(int value) { age = value; }
- public void setSpouse(Person value) { spouse = value; }
- public String toString()
- {
- return "[Person: firstName=" + firstName +
- " lastName=" + lastName +
- " gender=" + gender +
- " age=" + age +
- " spouse=" + spouse.getFirstName() +
- "]";
- }
- private String firstName;
- private String lastName;
- private int age;
- private Person spouse;
- private Gender gender;
- }
序列化使用一個 hash，該 hash 是根據(jù)給定源文件中幾乎所有東西 — 方法名稱、字段名稱、字段類型、訪問修改方法等 — 計算出來的，序列化將該 hash 值與序列化流中的 hash 值相比較。
為了使 Java 運行時相信兩種類型實際上是一樣的，第二版和隨后版本的 Person 必須與第一版有相同的序列化版本 hash(存儲為 private static final serialVersionUID 字段)。因此，我們需要 serialVersionUID 字段，它是通過對原始(或 V1)版本的 Person 類運行 JDK serialver 命令計算出的。
一旦有了 Person 的 serialVersionUID，不僅可以從原始對象 Person 的序列化數(shù)據(jù)創(chuàng)建 PersonV2 對象(當出現(xiàn)新字段時，新字段被設為缺省值，最常見的是“null”)，還可以反過來做：即從 PersonV2 的數(shù)據(jù)通過反序列化得到 Person，這毫不奇怪。
2. 序列化并不安全
讓 Java 開發(fā)人員詫異并感到不快的是，序列化二進制格式完全編寫在文檔中，并且完全可逆。實際上，只需將二進制序列化流的內容轉儲到控制臺，就足以看清類是什么樣子，以及它包含什么內容。
這對于安全性有著不良影響。例如，當通過 RMI 進行遠程方法調用時，通過連接發(fā)送的對象中的任何 private 字段幾乎都是以明文的方式出現(xiàn)在套接字流中，這顯然容易招致哪怕最簡單的安全問題。
幸運的是，序列化允許 “hook” 序列化過程，并在序列化之前和反序列化之后保護(或模糊化)字段數(shù)據(jù)。可以通過在 Serializable 對象上提供一個 writeObject 方法來做到這一點。
模糊化序列化數(shù)據(jù)
假設 Person 類中的敏感數(shù)據(jù)是 age 字段。畢竟，女士忌談年齡。我們可以在序列化之前模糊化該數(shù)據(jù)，將數(shù)位循環(huán)左移一位，然后在反序列化之后復位。(您可以開發(fā)更安全的算法，當前這個算法只是作為一個例子。)
為了 “hook” 序列化過程，我們將在 Person 上實現(xiàn)一個 writeObject 方法;為了 “hook” 反序列化過程，我們將在同一個類上實現(xiàn)一個 readObject 方法。重要的是這兩個方法的細節(jié)要正確 — 如果訪問修改方法、參數(shù)或名稱不同于清單 4 中的內容，那么代碼將不被察覺地失敗，Person 的 age 將暴露。
清單 4. 模糊化序列化數(shù)據(jù)
- public class Person
- implements java.io.Serializable
- {
- public Person(String fn, String ln, int a)
- {
- this.firstName = fn; this.lastName = ln; this.age = a;
- }
- public String getFirstName() { return firstName; }
- public String getLastName() { return lastName; }
- public int getAge() { return age; }
- public Person getSpouse() { return spouse; }
- public void setFirstName(String value) { firstName = value; }
- public void setLastName(String value) { lastName = value; }
- public void setAge(int value) { age = value; }
- public void setSpouse(Person value) { spouse = value; }
- private void writeObject(java.io.ObjectOutputStream stream)
- throws java.io.IOException
- {
- // "Encrypt"/obscure the sensitive data
- age = age << 2;
- stream.defaultWriteObject();
- }
- private void readObject(java.io.ObjectInputStream stream)
- throws java.io.IOException, ClassNotFoundException
- {
- stream.defaultReadObject();
- // "Decrypt"/de-obscure the sensitive data
- age = age << 2;
- }
- public String toString()
- {
- return "[Person: firstName=" + firstName +
- " lastName=" + lastName +
- " age=" + age +
- " spouse=" + (spouse!=null ? spouse.getFirstName() : "[null]") +
- "]";
- }
- private String firstName;
- private String lastName;
- private int age;
- private Person spouse;
- }
如果需要查看被模糊化的數(shù)據(jù)，總是可以查看序列化數(shù)據(jù)流/文件。而且，由于該格式被完全文檔化，即使不能訪問類本身，也仍可以讀取序列化流中的內容。
#p#
3、序列化的數(shù)據(jù)可以被簽名和密封上一個技巧假設您想模糊化序列化數(shù)據(jù)，而不是對其加密或者確保它不被修改。當然，通過使用 writeObject 和 readObject 可以實現(xiàn)密碼加密和簽名管理，但其實還有更好的方式。
如果需要對整個對象進行加密和簽名，最簡單的是將它放在一個 javax.crypto.SealedObject 和/或 java.security.SignedObject 包裝器中。兩者都是可序列化的，所以將對象包裝在 SealedObject 中可以圍繞原對象創(chuàng)建一種 “包裝盒”。必須有對稱密鑰才能解密，而且密鑰必須單獨管理。同樣，也可以將 SignedObject 用于數(shù)據(jù)驗證，并且對稱密鑰也必須單獨管理。
結合使用這兩種對象，便可以輕松地對序列化數(shù)據(jù)進行密封和簽名，而不必強調關于數(shù)字簽名驗證或加密的細節(jié)。很簡潔，是吧?
4. 序列化允許將代理放在流中
很多情況下，類中包含一個核心數(shù)據(jù)元素，通過它可以派生或找到類中的其他字段。在此情況下，沒有必要序列化整個對象。可以將字段標記為 transient，但是每當有方法訪問一個字段時，類仍然必須顯式地產生代碼來檢查它是否被初始化。
如果首要問題是序列化，那么最好指定一個 flyweight 或代理放在流中。為原始 Person 提供一個 writeReplace 方法，可以序列化不同類型的對象來代替它。類似地，如果反序列化期間發(fā)現(xiàn)一個 readResolve 方法，那么將調用該方法，將替代對象提供給調用者。
打包和解包代理
writeReplace 和 readResolve 方法使 Person 類可以將它的所有數(shù)據(jù)(或其中的核心數(shù)據(jù))打包到一個 PersonProxy 中，將它放入到一個流中，然后在反序列化時再進行解包。
清單 5. 你完整了我，我代替了你
- class PersonProxy
- implements java.io.Serializable
- {
- public PersonProxy(Person orig)
- {
- data = orig.getFirstName() + "," + orig.getLastName()+ "," + orig.getAge();
- if (orig.getSpouse() != null)
- {
- Person spouse = orig.getSpouse();
- data = data + "," + spouse.getFirstName() + "," + spouse.getLastName() + ","+ spouse.getAge();
- }
- }
- public String data;
- private Object readResolve()
- throws java.io.ObjectStreamException
- {
- String[] pieces = data.split(",");
- Person result = new Person(pieces[0], pieces[1], Integer.parseInt(pieces[2]));
- if (pieces.length > 3)
- {
- result.setSpouse(new Person(pieces[3], pieces[4], Integer.parseInt
- (pieces[5])));
- result.getSpouse().setSpouse(result);
- }
- return result;
- }
- }
- public class Person
- implements java.io.Serializable
- {
- public Person(String fn, String ln, int a){
- this.firstName = fn; this.lastName = ln; this.age = a;
- }
- public String getFirstName() { return firstName; }
- public String getLastName() { return lastName; }
- public int getAge() { return age; }
- public Person getSpouse() { return spouse; }
- private Object writeReplace()
- throws java.io.ObjectStreamException
- {
- return new PersonProxy(this);
- }
- public void setFirstName(String value) { firstName = value; }
- public void setLastName(String value) { lastName = value; }
- public void setAge(int value) { age = value; }
- public void setSpouse(Person value) { spouse = value; }
- public String toString()
- {
- return "[Person: firstName=" + firstName +
- " lastName=" + lastName +
- " age=" + age +
- " spouse=" + spouse.getFirstName() +
- "]";
- }
- private String firstName;
- private String lastName;
- private int age;
- private Person spouse;
- }
5. 信任，但要驗證
認為序列化流中的數(shù)據(jù)總是與最初寫到流中的數(shù)據(jù)一致，這沒有問題。但是，正如一位美國前總統(tǒng)所說的，“信任，但要驗證”。
對于序列化的對象，這意味著驗證字段，以確保在反序列化之后它們仍具有正確的值，“以防萬一”。為此，可以實現(xiàn) ObjectInputValidation 接口，并覆蓋 validateObject() 方法。如果調用該方法時發(fā)現(xiàn)某處有錯誤，則拋出一個 InvalidObjectException。
【編輯推薦】
