建站
咨詢
售后
建站咨詢
新聞中心
數(shù)年前，當和一個軟件團隊一起用 Java 語言編寫一個應用程序時，我體會到比一般程序員多知道一點關(guān)于 Java 對象序列化的知識所帶來的好處。
關(guān)于本系列
您覺得自己懂 Java 編程？事實上，大多數(shù)程序員對于 Java 平臺都是淺嘗則止，只學習了足以完成手頭上任務的知識而已。在本 系列 中，Ted Neward 深入挖掘 Java 平臺的核心功能，揭示一些鮮為人知的事實，幫助您解決最棘手的編程挑戰(zhàn)。
大約一年前，一個負責管理應用程序所有用戶設置的開發(fā)人員，決定將用戶設置存儲在一個 Hashtable中，然后將這個 Hashtable 序列化到磁盤，以便持久化。當用戶更改設置時，便重新將 Hashtable 寫到磁盤。
這是一個優(yōu)雅的、開放式的設置系統(tǒng)，但是，當團隊決定從 Hashtable 遷移到 Java Collections 庫中的HashMap 時，這個系統(tǒng)便面臨崩潰。
Hashtable 和 HashMap 在磁盤上的格式是不相同、不兼容的。除非對每個持久化的用戶設置運行某種類型的數(shù)據(jù)轉(zhuǎn)換實用程序（極其龐大的任務），否則以后似乎只能一直用Hashtable 作為應用程序的存儲格式。
團隊感到陷入僵局，但這只是因為他們不知道關(guān)于 Java 序列化的一個重要事實：Java 序列化允許隨著時間的推移而改變類型。當我向他們展示如何自動進行序列化替換后，他們終于按計劃完成了向 HashMap 的轉(zhuǎn)變。
本文是本系列的第一篇文章，這個系列專門揭示關(guān)于 Java 平臺的一些有用的小知識 — 這些小知識不易理解，但對于解決 Java 編程挑戰(zhàn)遲早有用。
將 Java 對象序列化 API 作為開端是一個不錯的選擇，因為它從一開始就存在于 JDK 1.1 中。本文介紹的關(guān)于序列化的 5 件事情將說服您重新審視那些標準 Java API。
關(guān)于本系列
Java 對象序列化是 JDK 1.1 中引入的一組開創(chuàng)性特性之一，用于作為一種將 Java 對象的狀態(tài)轉(zhuǎn)換為字節(jié)數(shù)組，以便存儲或傳輸?shù)臋C制，以后，仍可以將字節(jié)數(shù)組轉(zhuǎn)換回 Java 對象原有的狀態(tài)。
實際上，序列化的思想是 “凍結(jié)” 對象狀態(tài)，傳輸對象狀態(tài)（寫到磁盤、通過網(wǎng)絡傳輸?shù)鹊龋?，然?“解凍” 狀態(tài)，重新獲得可用的 Java 對象。所有這些事情的發(fā)生有點像是魔術(shù)，這要歸功于 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());
}
}
}到現(xiàn)在為止，還沒有看到什么新鮮的或令人興奮的事情，但是這是一個很好的出發(fā)點。我們將使用 Person 來發(fā)現(xiàn)您可能不 知道的關(guān)于 Java 對象序列化 的 5 件事。
1. 序列化允許重構(gòu)
序列化允許一定數(shù)量的類變種，甚至重構(gòu)之后也是如此，ObjectInputStream 仍可以很好地將其讀出來。
Java Object Serialization 規(guī)范可以自動管理的關(guān)鍵任務是：
- 將新字段添加到類中
- 將字段從 static 改為非 static
- 將字段從 transient 改為非 transient
取決于所需的向后兼容程度，轉(zhuǎn)換字段形式（從非 static 轉(zhuǎn)換為 static 或從非 transient 轉(zhuǎn)換為 transient）或者刪除字段需要額外的消息傳遞。
重構(gòu)序列化類
既然已經(jīng)知道序列化允許重構(gòu)，我們來看看當把新字段添加到 Person 類中時，會發(fā)生什么事情。
如清單 3 所示，PersonV2 在原先 Person 類的基礎(chǔ)上引入一個表示性別的新字段。
清單 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，這毫不奇怪。
#p#
2. 序列化并不安全
讓 Java 開發(fā)人員詫異并感到不快的是，序列化二進制格式完全編寫在文檔中，并且完全可逆。實際上，只需將二進制序列化流的內(nèi)容轉(zhuǎn)儲到控制臺，就足以看清類是什么樣子，以及它包含什么內(nèi)容。
這對于安全性有著不良影響。例如，當通過 RMI 進行遠程方法調(diào)用時，通過連接發(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 中的內(nèi)容，那么代碼將不被察覺地失敗，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ù)流/文件。而且，由于該格式被完全文檔化，即使不能訪問類本身，也仍可以讀取序列化流中的內(nèi)容。
#p#
3. 序列化的數(shù)據(jù)可以被簽名和密封
上一個技巧假設您想模糊化序列化數(shù)據(jù)，而不是對其加密或者確保它不被修改。當然，通過使用 writeObject 和 readObject 可以實現(xiàn)密碼加密和簽名管理，但其實還有更好的方式。
如果需要對整個對象進行加密和簽名，最簡單的是將它放在一個 javax.crypto.SealedObject 和/或 java.security.SignedObject 包裝器中。兩者都是可序列化的，所以將對象包裝在 SealedObject 中可以圍繞原對象創(chuàng)建一種 “包裝盒”。必須有對稱密鑰才能解密，而且密鑰必須單獨管理。同樣，也可以將 SignedObject 用于數(shù)據(jù)驗證，并且對稱密鑰也必須單獨管理。
結(jié)合使用這兩種對象，便可以輕松地對序列化數(shù)據(jù)進行密封和簽名，而不必強調(diào)關(guān)于數(shù)字簽名驗證或加密的細節(jié)。很簡潔，是吧？
4. 序列化允許將代理放在流中
很多情況下，類中包含一個核心數(shù)據(jù)元素，通過它可以派生或找到類中的其他字段。在此情況下，沒有必要序列化整個對象?？梢詫⒆侄螛擞洖?nbsp;transient，但是每當有方法訪問一個字段時，類仍然必須顯式地產(chǎn)生代碼來檢查它是否被初始化。
如果首要問題是序列化，那么最好指定一個 flyweight 或代理放在流中。為原始 Person 提供一個 writeReplace 方法，可以序列化不同類型的對象來代替它。類似地，如果反序列化期間發(fā)現(xiàn)一個 readResolve 方法，那么將調(diào)用該方法，將替代對象提供給調(diào)用者。
打包和解包代理
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;
}注意，PersonProxy 必須跟蹤 Person 的所有數(shù)據(jù)。這通常意味著代理需要是 Person 的一個內(nèi)部類，以便能訪問 private 字段。有時候，代理還需要追蹤其他對象引用并手動序列化它們，例如 Person 的 spouse。
這種技巧是少數(shù)幾種不需要讀/寫平衡的技巧之一。例如，一個類被重構(gòu)成另一種類型后的版本可以提供一個 readResolve 方法，以便靜默地將被序列化的對象轉(zhuǎn)換成新類型。類似地，它可以采用 writeReplace 方法將舊類序列化成新版本。
5. 信任，但要驗證
認為序列化流中的數(shù)據(jù)總是與最初寫到流中的數(shù)據(jù)一致，這沒有問題。但是，正如一位美國前總統(tǒng)所說的，“信任，但要驗證”。
對于序列化的對象，這意味著驗證字段，以確保在反序列化之后它們?nèi)跃哂姓_的值，“以防萬一”。為此，可以實現(xiàn) ObjectInputValidation接口，并覆蓋 validateObject() 方法。如果調(diào)用該方法時發(fā)現(xiàn)某處有錯誤，則拋出一個 InvalidObjectException。
結(jié)束語
Java 對象序列化比大多數(shù) Java 開發(fā)人員想象的更靈活，這使我們有更多的機會解決棘手的情況。
幸運的是，像這樣的編程妙招在 JVM 中隨處可見。關(guān)鍵是要知道它們，在遇到難題的時候能用上它們。
5 件事 系列下期預告：Java Collections。在此之前，好好享受按自己的想法調(diào)整序列化吧！
網(wǎng)站名稱：關(guān)于 Java 對象序列化您不知道的 5 件事
文章地址：http://www.dlmjj.cn/article/cciddis.html
