关于Java对象序列化您不知道的5件事

开发 后端
Java对象序列化是JDK1.1中引入的一组开创性特性之一,用于作为一种将Java对象的状态转换为字节数组,以便存储或传输的机制,以后,仍可以将字节数组转换回Java对象原有的状态。

Java对象序列化是JDK1.1中引入的一组开创性特性之一,之前51CTO也曾介绍过Java序列化的机制和原理,这里我们将使用Person来发现您可能不知道的关于Java对象序列化的5件事。

51CTO推荐专题:Java基础教程

实际上,序列化的思想是“冻结”对象状态,传输对象状态(写到磁盘、通过网络传输等等),然后“解冻”状态,重新获得可用的Java对象。所有这些事情的发生有点像是魔术,这要归功于ObjectInputStream/ObjectOutputStream类、完全保真的元数据以及程序员愿意用Serializable标识接口标记他们的类,从而“参与”这个过程。清单1显示一个实现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.  

将Person序列化后,很容易将对象状态写到磁盘,然后重新读出它,下面的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. }  

到现在为止,还没有看到什么新鲜的或令人兴奋的事情,但是这是一个很好的出发点。

1.序列化允许重构

序列化允许一定数量的类变种,甚至重构之后也是如此,ObjectInputStream仍可以很好地将其读出来。JavaObjectSerialization规范可以自动管理的关键任务是:

◆将新字段添加到类中。

◆将字段从static改为非static。

◆将字段从transient改为非transient。

◆取决于所需的向后兼容程度,转换字段形式(从非static转换为static或从非transient转换为transient)或者删除字段需要额外的消息传递。

重构序列化类

既然已经知道序列化允许重构,我们来看看当把新字段添加到Person类中时,会发生什么事情。如清单3所示,PersonV2在原先Person类的基础上引入一个表示性别的新字段。

  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;  

序列化使用一个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将暴露。

  1. 清单4.模糊化序列化数据  
  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;  

如果需要查看被模糊化的数据,总是可以查看序列化数据流/文件。而且,由于该格式被完全文档化,即使不能访问类本身,也仍可以读取序列化流中的内容。

3.序列化的数据可以被签名和密封

上一个技巧假设您想模糊化序列化数据,而不是对其加密或者确保它不被修改。当然,通过使用writeObject和readObject可以实现密码加密和签名管理,但其实还有更好的方式。

如果需要对整个对象进行加密和签名,最简单的是将它放在一个javax.crypto.SealedObject和/或java.security.SignedObject包装器中。两者都是可序列化的,所以将对象包装在SealedObject中可以围绕原对象创建一种“包装盒”。必须有对称密钥才能解密,而且密钥必须单独管理。同样,也可以将SignedObject用于数据验证,并且对称密钥也必须单独管理。结合使用这两种对象,便可以轻松地对序列化数据进行密封和签名,而不必强调关于数字签名验证或加密的细节。很简洁,是吧?

#p#

4.序列化允许将代理放在流中

很多情况下,类中包含一个核心数据元素,通过它可以派生或找到类中的其他字段。在此情况下,没有必要序列化整个对象。可以将字段标记为transient,但是每当有方法访问一个字段时,类仍然必须显式地产生代码来检查它是否被初始化。

如果首要问题是序列化,那么最好指定一个flyweight或代理放在流中。为原始Person提供一个writeReplace方法,可以序列化不同类型的对象来代替它。类似地,如果反序列化期间发现一个readResolve方法,那么将调用该方法,将替代对象提供给调用者。

打包和解包代理

writeReplace和readResolve方法使Person类可以将它的所有数据(或其中的核心数据)打包到一个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;  

注意,PersonProxy必须跟踪Person的所有数据。这通常意味着代理需要是Person的一个内部类,以便能访问private字段。有时候,代理还需要追踪其他对象引用并手动序列化它们,例如Person的spouse。

这种技巧是少数几种不需要读/写平衡的技巧之一。例如,一个类被重构成另一种类型后的版本可以提供一个readResolve方法,以便静默地将被序列化的对象转换成新类型。类似地,它可以采用writeReplace方法将旧类序列化成新版本。

#p#

5.信任,但要验证

认为序列化流中的数据总是与最初写到流中的数据一致,这没有问题。但是,正如一位美国前总统所说的,“信任,但要验证”。

对于序列化的对象,这意味着验证字段,以确保在反序列化之后它们仍具有正确的值,“以防万一”。为此,可以实现ObjectInputValidation接口,并覆盖validateObject()方法。如果调用该方法时发现某处有错误,则抛出一个InvalidObjectException。

结束语

Java对象序列化比大多数Java开发人员想象的更灵活,这使我们有更多的机会解决棘手的情况。幸运的是,像这样的编程妙招在JVM中随处可见。关键是要知道它们,在遇到难题的时候能用上它们。

【编辑推荐】

  1. Java序列化的机制和原理
  2. Java对象序列化使用基础
  3. Java对象的序列化和反序列化实践
  4. Java Socket通信的序列化和反序列化代码介绍
  5. Java Socket网络传输的序列化机制
责任编辑:王晓东 来源: IBM
相关推荐

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

2014-11-21 10:25:18

Java

2017-05-02 11:36:00

Java

2024-01-11 11:28:54

2013-06-18 11:05:40

Mac Pro开发工具苹果

2024-03-25 00:10:00

JSON后端开发

2011-11-30 13:34:13

2010-05-19 09:01:00

2015-08-14 14:46:47

软件开发

2010-08-24 14:08:33

乔布斯

2015-02-02 14:12:03

云桌面

2015-08-14 16:39:59

软件开发老板

2015-06-23 13:22:17

桌面云深信服

2021-07-12 23:21:52

MyISAM引擎InnoDB

2015-10-10 09:29:32

GitGithub
点赞
收藏

51CTO技术栈公众号