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

文章出处： http://java.chinaitlab.com/base/807715.html

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

　　实际上，序列化的思想是“冻结”对象状态，传输对象状态（写到磁盘、通过网络传输等等），然后“解冻”状态，重新获得可用的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.

　　36.}

　　将Person序列化后，很容易将对象状态写到磁盘，然后重新读出它，下面的JUnit4单元测试对此做了演示。

　　37.清单2.对Person进行反序列化

　　38.publicclassSerTest

　　39.{

　　40.@TestpublicvoidserializeToDisk()

　　41.{

　　42.try

　　43.{

　　44.com.tedneward.Personted=newcom.tedneward.Person("Ted","Neward",39);

　　45.com.tedneward.Personcharl=newcom.tedneward.Person("Charlotte",

　　46."Neward",38);

　　47.

　　48.ted.setSpouse(charl);charl.setSpouse(ted);

　　49.

　　50.FileOutputStreamfos=newFileOutputStream("tempdata.ser");

　　51.ObjectOutputStreamoos=newObjectOutputStream(fos);

　　52.oos.writeObject(ted);

　　53.oos.close();

　　54.}

　　55.catch(Exceptionex)

　　56.{

　　57.fail("Exceptionthrownduringtest:"+ex.toString());

　　58.}

　　59.

　　60.try

　　61.{

　　62.FileInputStreamfis=newFileInputStream("tempdata.ser");

　　63.ObjectInputStreamois=newObjectInputStream(fis);

　　64.com.tedneward.Personted=(com.tedneward.Person)ois.readObject();

　　65.ois.close();

　　66.

　　67.assertEquals(ted.getFirstName(），"Ted");

　　68.assertEquals(ted.getSpouse().getFirstName(），"Charlotte");

　　69.

　　70.//Cleanupthefile

　　71.newFile("tempdata.ser").delete();

　　72.}

　　73.catch(Exceptionex)

　　74.{

　　75.fail("Exceptionthrownduringtest:"+ex.toString());

　　76.}

　　77.}

　　78.}

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

1.序列化允许重构

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

　　◆将新字段添加到类中。

　　◆将字段从static改为非static。

　　◆将字段从transient改为非transient。

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

　　重构序列化类

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

　　79.清单3.将新字段添加到序列化的Person中

　　80.enumGender

　　81.{

　　82.MALE,FEMALE

　　83.}

　　84.

　　85.publicclassPerson

　　86.implementsjava.io.Serializable

　　87.{

　　88.publicPerson(Stringfn,Stringln,inta,Genderg)

　　89.{

　　90.this.firstName=fn;this.lastName=ln;this.age=a;this.gender=g;

　　91.}

　　92.

　　93.publicStringgetFirstName(){returnfirstName;}

　　94.publicStringgetLastName(){returnlastName;}

　　95.publicGendergetGender(){returngender;}

　　96.publicintgetAge(){returnage;}

　　97.publicPersongetSpouse(){returnspouse;}

　　98.

　　99.publicvoidsetFirstName(Stringvalue){firstName=value;}

　　100.publicvoidsetLastName(Stringvalue){lastName=value;}

　　101.publicvoidsetGender(Gendervalue){gender=value;}

　　102.publicvoidsetAge(intvalue){age=value;}

　　103.publicvoidsetSpouse(Personvalue){spouse=value;}

　　104.

　　105.publicStringtoString()

　　106.{

　　107.return"[Person:firstName="+firstName+

　　108."lastName="+lastName+

　　109."gender="+gender+

　　110."age="+age+

　　111."spouse="+spouse.getFirstName()+

　　112."]";

　　113.}

　　114.

　　115.privateStringfirstName;

　　116.privateStringlastName;

　　117.privateintage;

　　118.privatePersonspouse;

　　119.privateGendergender;

　　120.}

　　序列化使用一个hash，该hash是根据给定源文件中几乎所有东西-方法名称、字段名称、字段类型、访问修改方法等-计算出来的，序列化将该hash值与序列化流中的hash值相比较。

　　为了使Java运行时相信两种类型实际上是一样的，第二版和随后版本的Person必须与第一版有相同的序列化版本hash（存储为privatestaticfinalserialVersionUID字段）。因此，我们需要serialVersionUID字段，它是通过对原始（或V1）版本的Person类运行JDKserialver命令计算出的。

　　一旦有了Person的serialVersionUID，不仅可以从原始对象Person的序列化数据创建PersonV2对象（当出现新字段时，新字段被设为缺省值，最常见的是“null”），还可以反过来做：即从PersonV2的数据通过反序列化得到Person，这毫不奇怪。

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;

　　50.}

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

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

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

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

　　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;

　　69.}

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

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

　　5.信任，但要验证

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

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

　　结束语

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