關于Java對象序列化您不知道的5件事
Java對象序列化是JDK1.1中引入的一組開創性特性之一，之前51CTO也曾介紹過Java序列化的機制和原理，這里我們將使用Person來發現您可能不知道的關于Java對象序列化的5件事。
51CTO推薦專題：Java基礎教程
實際上，序列化的思想是“凍結”對象狀態，傳輸對象狀態（寫到磁盤、通過網絡傳輸等等），然后“解凍”狀態，重新獲得可用的Java對象。所有這些事情的發生有點像是魔術，這要歸功于ObjectInputStream/ObjectOutputStream類、完全保真的元數據以及程序員愿意用Serializable標識接口標記他們的類，從而“參與”這個過程。清單1顯示一個實現Serializable的Person類。
- 清單1.SerializablePerson
- packagecom.tedneward;
- publicclassPerson
- implementsjava.io.Serializable
- {
- publicPerson(Stringfn,Stringln,inta)
- {
- this.firstName=fn;this.lastName=ln;this.age=a;
- }
- publicStringgetFirstName(){returnfirstName;}
- publicStringgetLastName(){returnlastName;}
- publicintgetAge(){returnage;}
- publicPersongetSpouse(){returnspouse;}
- publicvoidsetFirstName(Stringvalue){firstName=value;}
- publicvoidsetLastName(Stringvalue){lastName=value;}
- publicvoidsetAge(intvalue){age=value;}
- publicvoidsetSpouse(Personvalue){spouse=value;}
- publicStringtoString()
- {
- return"[Person:firstName="+firstName+
- "lastName="+lastName+
- "age="+age+
- "spouse="+spouse.getFirstName()+
- "]";
- }
- privateStringfirstName;
- privateStringlastName;
- privateintage;
- privatePersonspouse;
- }
將Person序列化后，很容易將對象狀態寫到磁盤，然后重新讀出它，下面的JUnit4單元測試對此做了演示。
- 清單2.對Person進行反序列化
- publicclassSerTest
- {
- @TestpublicvoidserializeToDisk()
- {
- try
- {
- com.tedneward.Personted=newcom.tedneward.Person("Ted","Neward",39);
- com.tedneward.Personcharl=newcom.tedneward.Person("Charlotte",
- "Neward",38);
- ted.setSpouse(charl);charl.setSpouse(ted);
- FileOutputStreamfos=newFileOutputStream("tempdata.ser");
- ObjectOutputStreamoos=newObjectOutputStream(fos);
- oos.writeObject(ted);
- oos.close();
- }
- catch(Exceptionex)
- {
- fail("Exceptionthrownduringtest:"+ex.toString());
- }
- try
- {
- FileInputStreamfis=newFileInputStream("tempdata.ser");
- ObjectInputStreamois=newObjectInputStream(fis);
- com.tedneward.Personted=(com.tedneward.Person)ois.readObject();
- ois.close();
- assertEquals(ted.getFirstName(），"Ted");
- assertEquals(ted.getSpouse().getFirstName(），"Charlotte");
- //Cleanupthefile
- newFile("tempdata.ser").delete();
- }
- catch(Exceptionex)
- {
- fail("Exceptionthrownduringtest:"+ex.toString());
- }
- }
- }
到現在為止，還沒有看到什么新鮮的或令人興奮的事情，但是這是一個很好的出發點。
1.序列化允許重構
序列化允許一定數量的類變種，甚至重構之后也是如此，ObjectInputStream仍可以很好地將其讀出來。JavaObjectSerialization規范可以自動管理的關鍵任務是：
◆將新字段添加到類中。
◆將字段從static改為非static。
◆將字段從transient改為非transient。
◆取決于所需的向后兼容程度，轉換字段形式（從非static轉換為static或從非transient轉換為transient）或者刪除字段需要額外的消息傳遞。
重構序列化類
既然已經知道序列化允許重構，我們來看看當把新字段添加到Person類中時，會發生什么事情。如清單3所示，PersonV2在原先Person類的基礎上引入一個表示性別的新字段。
- 清單3.將新字段添加到序列化的Person中
- enumGender
- {
- MALE,FEMALE
- }
- publicclassPerson
- implementsjava.io.Serializable
- {
- publicPerson(Stringfn,Stringln,inta,Genderg)
- {
- this.firstName=fn;this.lastName=ln;this.age=a;this.gender=g;
- }
- publicStringgetFirstName(){returnfirstName;}
- publicStringgetLastName(){returnlastName;}
- publicGendergetGender(){returngender;}
- publicintgetAge(){returnage;}
- publicPersongetSpouse(){returnspouse;}
- publicvoidsetFirstName(Stringvalue){firstName=value;}
- publicvoidsetLastName(Stringvalue){lastName=value;}
- publicvoidsetGender(Gendervalue){gender=value;}
- publicvoidsetAge(intvalue){age=value;}
- publicvoidsetSpouse(Personvalue){spouse=value;}
- publicStringtoString()
- {
- return"[Person:firstName="+firstName+
- "lastName="+lastName+
- "gender="+gender+
- "age="+age+
- "spouse="+spouse.getFirstName()+
- "]";
- }
- privateStringfirstName;
- privateStringlastName;
- privateintage;
- privatePersonspouse;
- privateGendergender;
- }
序列化使用一個hash，該hash是根據給定源文件中幾乎所有東西—方法名稱、字段名稱、字段類型、訪問修改方法等—計算出來的，序列化將該hash值與序列化流中的hash值相比較。
為了使Java運行時相信兩種類型實際上是一樣的，第二版和隨后版本的Person必須與第一版有相同的序列化版本hash（存儲為privatestaticfinalserialVersionUID字段）。因此，我們需要serialVersionUID字段，它是通過對原始（或V1）版本的Person類運行JDKserialver命令計算出的。
一旦有了Person的serialVersionUID，不僅可以從原始對象Person的序列化數據創建PersonV2對象（當出現新字段時，新字段被設為缺省值，最常見的是“null”），還可以反過來做：即從PersonV2的數據通過反序列化得到Person，這毫不奇怪。
#p#
2.序列化并不安全
讓Java開發人員詫異并感到不快的是，序列化二進制格式完全編寫在文檔中，并且完全可逆。實際上，只需將二進制序列化流的內容轉儲到控制臺，就足以看清類是什么樣子，以及它包含什么內容。
這對于安全性有著不良影響。例如，當通過RMI進行遠程方法調用時，通過連接發送的對象中的任何private字段幾乎都是以明文的方式出現在套接字流中，這顯然容易招致哪怕最簡單的安全問題。
幸運的是，序列化允許“hook”序列化過程，并在序列化之前和反序列化之后保護（或模糊化）字段數據。可以通過在Serializable對象上提供一個writeObject方法來做到這一點。
模糊化序列化數據
假設Person類中的敏感數據是age字段。畢竟，女士忌談年齡。我們可以在序列化之前模糊化該數據，將數位循環左移一位，然后在反序列化之后復位。（您可以開發更安全的算法，當前這個算法只是作為一個例子。）
為了“hook”序列化過程，我們將在Person上實現一個writeObject方法；為了“hook”反序列化過程，我們將在同一個類上實現一個readObject方法。重要的是這兩個方法的細節要正確—如果訪問修改方法、參數或名稱不同于清單4中的內容，那么代碼將不被察覺地失敗，Person的age將暴露。
- 清單4.模糊化序列化數據
- publicclassPerson
- implementsjava.io.Serializable
- {
- publicPerson(Stringfn,Stringln,inta)
- {
- this.firstName=fn;this.lastName=ln;this.age=a;
- }
- publicStringgetFirstName(){returnfirstName;}
- publicStringgetLastName(){returnlastName;}
- publicintgetAge(){returnage;}
- publicPersongetSpouse(){returnspouse;}
- publicvoidsetFirstName(Stringvalue){firstName=value;}
- publicvoidsetLastName(Stringvalue){lastName=value;}
- publicvoidsetAge(intvalue){age=value;}
- publicvoidsetSpouse(Personvalue){spouse=value;}
- privatevoidwriteObject(java.io.ObjectOutputStreamstream)
- throwsjava.io.IOException
- {
- //"Encrypt"/obscurethesensitivedata
- ageage=age<<2;
- stream.defaultWriteObject();
- }
- privatevoidreadObject(java.io.ObjectInputStreamstream)
- throwsjava.io.IOException,ClassNotFoundException
- {
- stream.defaultReadObject();
- //"Decrypt"/de-obscurethesensitivedata
- ageage=age<<2;
- }
- publicStringtoString()
- {
- return"[Person:firstName="+firstName+
- "lastName="+lastName+
- "age="+age+
- "spouse="+(spouse!=null?spouse.getFirstName():"[null]")+
- "]";
- }
- privateStringfirstName;
- privateStringlastName;
- privateintage;
- privatePersonspouse;
- }
如果需要查看被模糊化的數據，總是可以查看序列化數據流/文件。而且，由于該格式被完全文檔化，即使不能訪問類本身，也仍可以讀取序列化流中的內容。
3.序列化的數據可以被簽名和密封
上一個技巧假設您想模糊化序列化數據，而不是對其加密或者確保它不被修改。當然，通過使用writeObject和readObject可以實現密碼加密和簽名管理，但其實還有更好的方式。
如果需要對整個對象進行加密和簽名，最簡單的是將它放在一個javax.crypto.SealedObject和/或java.security.SignedObject包裝器中。兩者都是可序列化的，所以將對象包裝在SealedObject中可以圍繞原對象創建一種“包裝盒”。必須有對稱密鑰才能解密，而且密鑰必須單獨管理。同樣，也可以將SignedObject用于數據驗證，并且對稱密鑰也必須單獨管理。結合使用這兩種對象，便可以輕松地對序列化數據進行密封和簽名，而不必強調關于數字簽名驗證或加密的細節。很簡潔，是吧？
#p#
4.序列化允許將代理放在流中
很多情況下，類中包含一個核心數據元素，通過它可以派生或找到類中的其他字段。在此情況下，沒有必要序列化整個對象。可以將字段標記為transient，但是每當有方法訪問一個字段時，類仍然必須顯式地產生代碼來檢查它是否被初始化。
如果首要問題是序列化，那么最好指定一個flyweight或代理放在流中。為原始Person提供一個writeReplace方法，可以序列化不同類型的對象來代替它。類似地，如果反序列化期間發現一個readResolve方法，那么將調用該方法，將替代對象提供給調用者。
打包和解包代理
writeReplace和readResolve方法使Person類可以將它的所有數據（或其中的核心數據）打包到一個PersonProxy中，將它放入到一個流中，然后在反序列化時再進行解包。
- 清單5.你完整了我，我代替了你
- classPersonProxy
- implementsjava.io.Serializable
- {
- publicPersonProxy(Personorig)
- {
- data=orig.getFirstName()+","+orig.getLastName()+","+orig.getAge();
- if(orig.getSpouse()!=null)
- {
- Personspouse=orig.getSpouse();
- datadata=data+","+spouse.getFirstName()+","+spouse.getLastName()+","
- +spouse.getAge();
- }
- }
- publicStringdata;
- privateObjectreadResolve()
- throwsjava.io.ObjectStreamException
- {
- String[]pieces=data.split(",");
- Personresult=newPerson(pieces[0],pieces[1],Integer.parseInt(pieces[2]));
- if(pieces.length>3)
- {
- result.setSpouse(newPerson(pieces[3],pieces[4],Integer.parseInt
- (pieces[5])));
- result.getSpouse().setSpouse(result);
- }
- returnresult;
- }
- }
- publicclassPerson
- implementsjava.io.Serializable
- {
- publicPerson(Stringfn,Stringln,inta)
- {
- this.firstName=fn;this.lastName=ln;this.age=a;
- }
- publicStringgetFirstName(){returnfirstName;}
- publicStringgetLastName(){returnlastName;}
- publicintgetAge(){returnage;}
- publicPersongetSpouse(){returnspouse;}
- privateObjectwriteReplace()
- throwsjava.io.ObjectStreamException
- {
- returnnewPersonProxy(this);
- }
- publicvoidsetFirstName(Stringvalue){firstName=value;}
- publicvoidsetLastName(Stringvalue){lastName=value;}
- publicvoidsetAge(intvalue){age=value;}
- publicvoidsetSpouse(Personvalue){spouse=value;}
- publicStringtoString()
- {
- return"[Person:firstName="+firstName+
- "lastName="+lastName+
- "age="+age+
- "spouse="+spouse.getFirstName()+
- "]";
- }
- privateStringfirstName;
- privateStringlastName;
- privateintage;
- privatePersonspouse;
- }
注意，PersonProxy必須跟蹤Person的所有數據。這通常意味著代理需要是Person的一個內部類，以便能訪問private字段。有時候，代理還需要追蹤其他對象引用并手動序列化它們，例如Person的spouse。
這種技巧是少數幾種不需要讀/寫平衡的技巧之一。例如，一個類被重構成另一種類型后的版本可以提供一個readResolve方法，以便靜默地將被序列化的對象轉換成新類型。類似地，它可以采用writeReplace方法將舊類序列化成新版本。
#p#
5.信任，但要驗證
認為序列化流中的數據總是與最初寫到流中的數據一致，這沒有問題。但是，正如一位美國前總統所說的，“信任，但要驗證”。
對于序列化的對象，這意味著驗證字段，以確保在反序列化之后它們仍具有正確的值，“以防萬一”。為此，可以實現ObjectInputValidation接口，并覆蓋validateObject()方法。如果調用該方法時發現某處有錯誤，則拋出一個InvalidObjectException。
結束語
Java對象序列化比大多數Java開發人員想象的更靈活，這使我們有更多的機會解決棘手的情況。幸運的是，像這樣的編程妙招在JVM中隨處可見。關鍵是要知道它們，在遇到難題的時候能用上它們。
【編輯推薦】
