自拍偷在线精品自拍偷,亚洲欧美中文日韩v在线观看不卡

關(guān)于Java對象序列化您不知道的5件事

作者：Ted Neward
開發(fā) 后端
Java對象序列化是JDK1.1中引入的一組開創(chuàng)性特性之一，用于作為一種將Java對象的狀態(tài)轉(zhuǎn)換為字節(jié)數(shù)組，以便存儲或傳輸?shù)臋C制，以后，仍可以將字節(jié)數(shù)組轉(zhuǎn)換回Java對象原有的狀態(tài)。

Java對象序列化是JDK1.1中引入的一組開創(chuàng)性特性之一，之前51CTO也曾介紹過Java序列化的機制和原理，這里我們將使用Person來發(fā)現(xiàn)您可能不知道的關(guān)于Java對象序列化的5件事。

51CTO推薦專題：Java基礎(chǔ)教程

實際上，序列化的思想是“凍結(jié)”對象狀態(tài)，傳輸對象狀態(tài)（寫到磁盤、通過網(wǎng)絡(luò)傳輸?shù)鹊龋?，然?ldquo;解凍”狀態(tài)，重新獲得可用的Java對象。所有這些事情的發(fā)生有點像是魔術(shù)，這要歸功于ObjectInputStream/ObjectOutputStream類、完全保真的元數(shù)據(jù)以及程序員愿意用Serializable標識接口標記他們的類，從而“參與”這個過程。清單1顯示一個實現(xiàn)Serializable的Person類。

  1. 清單1.SerializablePerson  
  2. packagecom.tedneward;  
  3.  
  4. publicclassPerson  
  5. implementsjava.io.Serializable  
  6. {  
  7. publicPerson(Stringfn,Stringln,inta)  
  8. {  
  9. this.firstName=fn;this.lastName=ln;this.age=a;  
  10. }  
  11.  
  12. publicStringgetFirstName(){returnfirstName;}  
  13. publicStringgetLastName(){returnlastName;}  
  14. publicintgetAge(){returnage;}  
  15. publicPersongetSpouse(){returnspouse;}  
  16.  
  17. publicvoidsetFirstName(Stringvalue){firstName=value;}  
  18. publicvoidsetLastName(Stringvalue){lastName=value;}  
  19. publicvoidsetAge(intvalue){age=value;}  
  20. publicvoidsetSpouse(Personvalue){spouse=value;}  
  21.  
  22. publicStringtoString()  
  23. {  
  24. return"[Person:firstName="+firstName+  
  25. "lastName="+lastName+  
  26. "age="+age+  
  27. "spouse="+spouse.getFirstName()+  
  28. "]";  
  29. }  
  30.  
  31. privateStringfirstName;  
  32. privateStringlastName;  
  33. privateintage;  
  34. privatePersonspouse;  
  35.  
  36. } 

將Person序列化后，很容易將對象狀態(tài)寫到磁盤，然后重新讀出它，下面的JUnit4單元測試對此做了演示。

  1. 清單2.對Person進行反序列化  
  2. publicclassSerTest  
  3. {  
  4. @TestpublicvoidserializeToDisk()  
  5. {  
  6. try  
  7. {  
  8. com.tedneward.Personted=newcom.tedneward.Person("Ted","Neward",39);  
  9. com.tedneward.Personcharl=newcom.tedneward.Person("Charlotte",  
  10. "Neward",38);  
  11.  
  12. ted.setSpouse(charl);charl.setSpouse(ted);  
  13.  
  14. FileOutputStreamfos=newFileOutputStream("tempdata.ser");  
  15. ObjectOutputStreamoos=newObjectOutputStream(fos);  
  16. oos.writeObject(ted);  
  17. oos.close();  
  18. }  
  19. catch(Exceptionex)  
  20. {  
  21. fail("Exceptionthrownduringtest:"+ex.toString());  
  22. }  
  23.  
  24. try  
  25. {  
  26. FileInputStreamfis=newFileInputStream("tempdata.ser");  
  27. ObjectInputStreamois=newObjectInputStream(fis);  
  28. com.tedneward.Personted=(com.tedneward.Person)ois.readObject();  
  29. ois.close();  
  30.  
  31. assertEquals(ted.getFirstName(），"Ted");  
  32. assertEquals(ted.getSpouse().getFirstName(），"Charlotte");  
  33.  
  34. //Cleanupthefile  
  35. newFile("tempdata.ser").delete();  
  36. }  
  37. catch(Exceptionex)  
  38. {  
  39. fail("Exceptionthrownduringtest:"+ex.toString());  
  40. }  
  41. }  
  42. } 

到現(xiàn)在為止，還沒有看到什么新鮮的或令人興奮的事情，但是這是一個很好的出發(fā)點。

1.序列化允許重構(gòu)

序列化允許一定數(shù)量的類變種，甚至重構(gòu)之后也是如此，ObjectInputStream仍可以很好地將其讀出來。JavaObjectSerialization規(guī)范可以自動管理的關(guān)鍵任務(wù)是：

◆將新字段添加到類中。

◆將字段從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ǔ)上引入一個表示性別的新字段。

  1. 清單3.將新字段添加到序列化的Person中  
  2. enumGender  
  3. {  
  4. MALE,FEMALE  
  5. }  
  6.  
  7. publicclassPerson  
  8. implementsjava.io.Serializable  
  9. {  
  10. publicPerson(Stringfn,Stringln,inta,Genderg)  
  11. {  
  12. this.firstName=fn;this.lastName=ln;this.age=a;this.gender=g;  
  13. }  
  14.  
  15. publicStringgetFirstName(){returnfirstName;}  
  16. publicStringgetLastName(){returnlastName;}  
  17. publicGendergetGender(){returngender;}  
  18. publicintgetAge(){returnage;}  
  19. publicPersongetSpouse(){returnspouse;}  
  20.  
  21. publicvoidsetFirstName(Stringvalue){firstName=value;}  
  22. publicvoidsetLastName(Stringvalue){lastName=value;}  
  23. publicvoidsetGender(Gendervalue){gender=value;}  
  24. publicvoidsetAge(intvalue){age=value;}  
  25. publicvoidsetSpouse(Personvalue){spouse=value;}  
  26.  
  27. publicStringtoString()  
  28. {  
  29. return"[Person:firstName="+firstName+  
  30. "lastName="+lastName+  
  31. "gender="+gender+  
  32. "age="+age+  
  33. "spouse="+spouse.getFirstName()+  
  34. "]";  
  35. }  
  36.  
  37. privateStringfirstName;  
  38. privateStringlastName;  
  39. privateintage;  
  40. privatePersonspouse;  
  41. privateGendergender;  
  42. } 

序列化使用一個hash，該hash是根據(jù)給定源文件中幾乎所有東西—方法名稱、字段名稱、字段類型、訪問修改方法等—計算出來的，序列化將該hash值與序列化流中的hash值相比較。

為了使Java運行時相信兩種類型實際上是一樣的，第二版和隨后版本的Person必須與第一版有相同的序列化版本hash（存儲為privatestaticfinalserialVersionUID字段）。因此，我們需要serialVersionUID字段，它是通過對原始（或V1）版本的Person類運行JDKserialver命令計算出的。

一旦有了Person的serialVersionUID，不僅可以從原始對象Person的序列化數(shù)據(jù)創(chuàng)建PersonV2對象（當出現(xiàn)新字段時，新字段被設(shè)為缺省值，最常見的是“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ù)

假設(shè)Person類中的敏感數(shù)據(jù)是age字段。畢竟，女士忌談年齡。我們可以在序列化之前模糊化該數(shù)據(jù)，將數(shù)位循環(huán)左移一位，然后在反序列化之后復(fù)位。（您可以開發(fā)更安全的算法，當前這個算法只是作為一個例子。）

為了“hook”序列化過程，我們將在Person上實現(xiàn)一個writeObject方法；為了“hook”反序列化過程，我們將在同一個類上實現(xiàn)一個readObject方法。重要的是這兩個方法的細節(jié)要正確—如果訪問修改方法、參數(shù)或名稱不同于清單4中的內(nèi)容，那么代碼將不被察覺地失敗，Person的age將暴露。

  1. 清單4.模糊化序列化數(shù)據(jù)  
  2. publicclassPerson  
  3. implementsjava.io.Serializable  
  4. {  
  5. publicPerson(Stringfn,Stringln,inta)  
  6. {  
  7. this.firstName=fn;this.lastName=ln;this.age=a;  
  8. }  
  9.  
  10. publicStringgetFirstName(){returnfirstName;}  
  11. publicStringgetLastName(){returnlastName;}  
  12. publicintgetAge(){returnage;}  
  13. publicPersongetSpouse(){returnspouse;}  
  14.  
  15. publicvoidsetFirstName(Stringvalue){firstName=value;}  
  16. publicvoidsetLastName(Stringvalue){lastName=value;}  
  17. publicvoidsetAge(intvalue){age=value;}  
  18. publicvoidsetSpouse(Personvalue){spouse=value;}  
  19.  
  20. privatevoidwriteObject(java.io.ObjectOutputStreamstream)  
  21. throwsjava.io.IOException  
  22. {  
  23. //"Encrypt"/obscurethesensitivedata  
  24. ageage=age<<2;  
  25. stream.defaultWriteObject();  
  26. }  
  27.  
  28. privatevoidreadObject(java.io.ObjectInputStreamstream)  
  29. throwsjava.io.IOException,ClassNotFoundException  
  30. {  
  31. stream.defaultReadObject();  
  32.  
  33. //"Decrypt"/de-obscurethesensitivedata  
  34. ageage=age<<2;  
  35. }  
  36.  
  37. publicStringtoString()  
  38. {  
  39. return"[Person:firstName="+firstName+  
  40. "lastName="+lastName+  
  41. "age="+age+  
  42. "spouse="+(spouse!=null?spouse.getFirstName():"[null]")+  
  43. "]";  
  44. }  
  45.  
  46. privateStringfirstName;  
  47. privateStringlastName;  
  48. privateintage;  
  49. privatePersonspouse;  
  50. } 

如果需要查看被模糊化的數(shù)據(jù)，總是可以查看序列化數(shù)據(jù)流/文件。而且，由于該格式被完全文檔化，即使不能訪問類本身，也仍可以讀取序列化流中的內(nèi)容。

3.序列化的數(shù)據(jù)可以被簽名和密封

上一個技巧假設(shè)您想模糊化序列化數(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é)。很簡潔，是吧？

#p#

4.序列化允許將代理放在流中

很多情況下，類中包含一個核心數(shù)據(jù)元素，通過它可以派生或找到類中的其他字段。在此情況下，沒有必要序列化整個對象?？梢詫⒆侄螛擞洖閠ransient，但是每當有方法訪問一個字段時，類仍然必須顯式地產(chǎn)生代碼來檢查它是否被初始化。

如果首要問題是序列化，那么最好指定一個flyweight或代理放在流中。為原始Person提供一個writeReplace方法，可以序列化不同類型的對象來代替它。類似地，如果反序列化期間發(fā)現(xiàn)一個readResolve方法，那么將調(diào)用該方法，將替代對象提供給調(diào)用者。

打包和解包代理

writeReplace和readResolve方法使Person類可以將它的所有數(shù)據(jù)（或其中的核心數(shù)據(jù)）打包到一個PersonProxy中，將它放入到一個流中，然后在反序列化時再進行解包。

  1. 清單5.你完整了我，我代替了你  
  2. classPersonProxy  
  3. implementsjava.io.Serializable  
  4. {  
  5. publicPersonProxy(Personorig)  
  6. {  
  7. data=orig.getFirstName()+","+orig.getLastName()+","+orig.getAge();  
  8. if(orig.getSpouse()!=null)  
  9. {  
  10. Personspouse=orig.getSpouse();  
  11. datadata=data+","+spouse.getFirstName()+","+spouse.getLastName()+","  
  12. +spouse.getAge();  
  13. }  
  14. }  
  15.  
  16. publicStringdata;  
  17. privateObjectreadResolve()  
  18. throwsjava.io.ObjectStreamException  
  19. {  
  20. String[]pieces=data.split(",");  
  21. Personresult=newPerson(pieces[0],pieces[1],Integer.parseInt(pieces[2]));  
  22. if(pieces.length>3)  
  23. {  
  24. result.setSpouse(newPerson(pieces[3],pieces[4],Integer.parseInt  
  25. (pieces[5])));  
  26. result.getSpouse().setSpouse(result);  
  27. }  
  28. returnresult;  
  29. }  
  30. }  
  31.  
  32. publicclassPerson  
  33. implementsjava.io.Serializable  
  34. {  
  35. publicPerson(Stringfn,Stringln,inta)  
  36. {  
  37. this.firstName=fn;this.lastName=ln;this.age=a;  
  38. }  
  39.  
  40. publicStringgetFirstName(){returnfirstName;}  
  41. publicStringgetLastName(){returnlastName;}  
  42. publicintgetAge(){returnage;}  
  43. publicPersongetSpouse(){returnspouse;}  
  44.  
  45. privateObjectwriteReplace()  
  46. throwsjava.io.ObjectStreamException  
  47. {  
  48. returnnewPersonProxy(this);  
  49. }  
  50.  
  51. publicvoidsetFirstName(Stringvalue){firstName=value;}  
  52. publicvoidsetLastName(Stringvalue){lastName=value;}  
  53. publicvoidsetAge(intvalue){age=value;}  
  54. publicvoidsetSpouse(Personvalue){spouse=value;}  
  55.  
  56. publicStringtoString()  
  57. {  
  58. return"[Person:firstName="+firstName+  
  59. "lastName="+lastName+  
  60. "age="+age+  
  61. "spouse="+spouse.getFirstName()+  
  62. "]";  
  63. }  
  64.  
  65. privateStringfirstName;  
  66. privateStringlastName;  
  67. privateintage;  
  68. privatePersonspouse;  
  69. } 

注意，PersonProxy必須跟蹤Person的所有數(shù)據(jù)。這通常意味著代理需要是Person的一個內(nèi)部類，以便能訪問private字段。有時候，代理還需要追蹤其他對象引用并手動序列化它們，例如Person的spouse。

這種技巧是少數(shù)幾種不需要讀/寫平衡的技巧之一。例如，一個類被重構(gòu)成另一種類型后的版本可以提供一個readResolve方法，以便靜默地將被序列化的對象轉(zhuǎn)換成新類型。類似地，它可以采用writeReplace方法將舊類序列化成新版本。

#p#

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)鍵是要知道它們，在遇到難題的時候能用上它們。

【編輯推薦】

  1. Java序列化的機制和原理
  2. Java對象序列化使用基礎(chǔ)
  3. Java對象的序列化和反序列化實踐
  4. Java Socket通信的序列化和反序列化代碼介紹
  5. Java Socket網(wǎng)絡(luò)傳輸?shù)男蛄谢瘷C制
責任編輯：王曉東 來源： IBM
JavaJava對象序列化
相關(guān)推薦

2011-06-01 15:34:23

2015-06-16 10:25:22

2011-04-02 13:11:35

JARJava

2011-04-02 13:35:21

多線程編程多線程java

2011-04-02 14:00:45

命令行JVMJava

2010-07-12 10:03:50

ibmdwjava

2017-05-02 11:36:00

Java

2014-11-21 10:25:18

Java

2024-01-11 11:28:54

2013-06-18 11:05:40

Mac Pro開發(fā)工具蘋果

2024-03-25 00:10:00

JSON后端開發(fā)

2011-11-30 13:34:13

2010-05-19 09:01:00

2015-02-02 14:12:03

云桌面

2015-08-14 14:46:47

軟件開發(fā)

2010-08-24 14:08:33

喬布斯

2015-08-14 16:39:59

軟件開發(fā)老板

2024-10-14 12:42:06

2021-07-12 23:21:52

MyISAM引擎InnoDB

2015-06-23 13:22:17

桌面云深信服
點贊
收藏

51CTO技術(shù)棧公眾號