數年前，當和一個軟件團隊一起用 Java 語言編寫一個應用程序時，我體會 到比一般程序員多知道一點關於 Java 對象序列化的知識所帶來的好處。
大約一年前，一個負責管理應用程序所有用戶設置的開發人員，決定將用戶 設置存儲在一個 Hashtable 中，然後將這個 Hashtable 序列化到磁盤，以便持 久化。當用戶更改設置時，便重新將 Hashtable 寫到磁盤。
這是一個優雅的、開放式的設置系統，但是，當團隊決定從 Hashtable 遷移 到 Java Collections 庫中的 HashMap 時，這個系統便面臨崩潰。
Hashtable 和 HashMap 在磁盤上的格式是不相同、不兼容的。除非對每個持 久化的用戶設置運行某種類型的數據轉換實用程序（極其龐大的任務），否則以 後似乎只能一直用 Hashtable 作為應用程序的存儲格式。
團隊感到陷入僵局，但這只是因為他們不知道關於 Java 序列化的一個重要 事實：Java 序列化允許隨著時間的推移而改變類型。當我向他們展示如何自動 進行序列化替換後，他們終於按計劃完成了向 HashMap 的轉變。
本文是本系列的第一篇文章，這個系列專門揭示關於 Java 平台的一些有用 的小知識 — 這些小知識不易理解，但對於解決 Java 編程挑戰遲早有用。
將 Java 對象序列化 API 作為開端是一個不錯的選擇，因為它從一開始就存 在於 JDK 1.1 中。本文介紹的關於序列化的 5 件事情將說服您重新審視那些標 准 Java API。
Java 序列化簡介
Java 對象序列化是 JDK 1.1 中引入的一組開創性特性之一，用於作為一種 將 Java 對象的狀態轉換為字節數組，以便存儲或傳輸的機制，以後，仍可以將 字節數組轉換回 Java 對象原有的狀態。
實際上，序列化的思想是 “凍結” 對象狀態，傳輸對象狀態（寫到磁盤、 通過網絡傳輸等等），然後 “解凍” 狀態，重新獲得可用的 Java 對象。所有 這些事情的發生有點像是魔術，這要歸功於 ObjectInputStream/ObjectOutputStream 類、完全保真的元數據以及程序員願 意用 Serializable 標識接口標記他們的類，從而 “參與” 這個過程。
清單 1 顯示一個實現 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 序列化後，很容易將對象狀態寫到磁盤，然後重新讀出它，下面 的 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());
}
}
}
到現在為止，還沒有看到什麼新鮮的或令人興奮的事情，但是這是一個很好 的出發點。我們將使用 Person 來發現您可能不 知道的關於 Java 對象序列化 的 5 件事。
1. 序列化允許重構
序列化允許一定數量的類變種，甚至重構之後也是如此，ObjectInputStream 仍可以很好地將其讀出來。
Java Object Serialization 規范可以自動管理的關鍵任務是：
將新字段添加到類中
將字段從 static 改為非 static
將字段從 transient 改為非 transient
取決於所需的向後兼容程度，轉換字段形式（從非 static 轉換為 static 或從非 transient 轉換為 transient）或者刪除字段需要額外的消息傳遞。
重構序列化類
既然已經知道序列化允許重構，我們來看看當把新字段添加到 Person 類中 時，會發生什麼事情。
如清單 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 是根據給定源文件中幾乎所有東西 — 方法 名稱、字段名稱、字段類型、訪問修改方法等 — 計算出來的，序列化將該 hash 值與序列化流中的 hash 值相比較。
為了使 Java 運行時相信兩種類型實際上是一樣的，第二版和隨後版本的 Person 必須與第一版有相同的序列化版本 hash（存儲為 private static final serialVersionUID 字段）。因此，我們需要 serialVersionUID 字段， 它是通過對原始（或 V1）版本的 Person 類運行 JDK serialver 命令計算出的 。
一旦有了 Person 的 serialVersionUID，不僅可以從原始對象 Person 的序 列化數據創建 PersonV2 對象（當出現新字段時，新字段被設為缺省值，最常見 的是“null”），還可以反過來做：即從 PersonV2 的數據通過反序列化得到 Person，這毫不奇怪。
2. 序列化並不安全
讓 Java 開發人員詫異並感到不快的是，序列化二進制格式完全編寫在文檔 中，並且完全可逆。實際上，只需將二進制序列化流的內容轉儲到控制台，就足 以看清類是什麼樣子，以及它包含什麼內容。
這對於安全性有著不良影響。例如，當通過 RMI 進行遠程方法調用時，通過 連接發送的對象中的任何 private 字段幾乎都是以明文的方式出現在套接字流 中，這顯然容易招致哪怕最簡單的安全問題。
幸運的是，序列化允許 “hook” 序列化過程，並在序列化之前和反序列化 之後保護（或模糊化）字段數據。可以通過在 Serializable 對象上提供一個 writeObject 方法來做到這一點。
模糊化序列化數據
假設 Person 類中的敏感數據是 age 字段。畢竟，女士忌談年齡。我們可以 在序列化之前模糊化該數據，將數位循環左移一位，然後在反序列化之後復位。（您可以開發更安全的算法，當前這個算法只是作為一個例子。）
為了 “hook” 序列化過程，我們將在 Person 上實現一個 writeObject 方 法；為了 “hook” 反序列化過程，我們將在同一個類上實現一個 readObject 方法。重要的是這兩個方法的細節要正確 — 如果訪問修改方法、參數或名稱不 同於清單 4 中的內容，那麼代碼將不被察覺地失敗，Person 的 age 將暴露。
清單 4. 模糊化序列化數據
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;
}
如果需要查看被模糊化的數據，總是可以查看序列化數據流/文件。而且，由 於該格式被完全文檔化，即使不能訪問類本身，也仍可以讀取序列化流中的內容 。
3. 序列化的數據可以被簽名和密封
上一個技巧假設您想模糊化序列化數據，而不是對其加密或者確保它不被修 改。當然，通過使用 writeObject 和 readObject 可以實現密碼加密和簽名管 理，但其實還有更好的方式。
如果需要對整個對象進行加密和簽名，最簡單的是將它放在一個 javax.crypto.SealedObject 和/或 java.security.SignedObject 包裝器中。 兩者都是可序列化的，所以將對象包裝在 SealedObject 中可以圍繞原對象創建 一種 “包裝盒”。必須有對稱密鑰才能解密，而且密鑰必須單獨管理。同樣， 也可以將 SignedObject 用於數據驗證，並且對稱密鑰也必須單獨管理。
結合使用這兩種對象，便可以輕松地對序列化數據進行密封和簽名，而不必 強調關於數字簽名驗證或加密的細節。很簡潔，是吧？
4. 序列化允許將代理放在流中
很多情況下，類中包含一個核心數據元素，通過它可以派生或找到類中的其 他字段。在此情況下，沒有必要序列化整個對象。可以將字段標記為 transient ，但是每當有方法訪問一個字段時，類仍然必須顯式地產生代碼來檢查它是否被 初始化。
如果首要問題是序列化，那麼最好指定一個 flyweight 或代理放在流中。為 原始 Person 提供一個 writeReplace 方法，可以序列化不同類型的對象來代替 它。類似地，如果反序列化期間發現一個 readResolve 方法，那麼將調用該方 法，將替代對象提供給調用者。
打包和解包代理
writeReplace 和 readResolve 方法使 Person 類可以將它的所有數據（或 其中的核心數據）打包到一個 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;
}
注意，PersonProxy 必須跟蹤 Person 的所有數據。這通常意味著代理需要 是 Person 的一個內部類，以便能訪問 private 字段。有時候，代理還需要追 蹤其他對象引用並手動序列化它們，例如 Person 的 spouse。
這種技巧是少數幾種不需要讀/寫平衡的技巧之一。例如，一個類被重構成另 一種類型後的版本可以提供一個 readResolve 方法，以便靜默地將被序列化的 對象轉換成新類型。類似地，它可以采用 writeReplace 方法將舊類序列化成新 版本。
5. 信任，但要驗證
認為序列化流中的數據總是與最初寫到流中的數據一致，這沒有問題。但是 ，正如一位美國前總統所說的，“信任，但要驗證”。
對於序列化的對象，這意味著驗證字段，以確保在反序列化之後它們仍具有 正確的值，“以防萬一”。為此，可以實現 ObjectInputValidation 接口，並 覆蓋 validateObject() 方法。如果調用該方法時發現某處有錯誤，則拋出一個 InvalidObjectException。
結束語
Java 對象序列化比大多數 Java 開發人員想象的更靈活，這使我們有更多的 機會解決棘手的情況。
幸運的是，像這樣的編程妙招在 JVM 中隨處可見。關鍵是要知道它們，在遇 到難題的時候能用上它們。
5 件事 系列下期預告：Java Collections。在此之前，好好享受按自己的想 法調整序列化吧！
原文地址：http://www.ibm.com/developerworks/cn/java/j- 5things1/index.html
