副标题#e#
数年前，当和一个软件团队一起用 Java 语言编写一个应用措施时，我体会 到比一般措施员多知道一点关于 Java 工具序列化的常识所带来的长处。
约莫一年前，一个认真打点应用措施所有用户配置的开拓人员，抉择将用户 配置存储在一个 Hashtable 中，然后将这个 Hashtable 序列化到磁盘，以便持 久化。当用户变动配置时，便从头将 Hashtable 写到磁盘。
这是一个优雅的、开放式的配置系统，可是，当团队抉择从 Hashtable 迁移 到 Java Collections 库中的 HashMap 时，这个系统便面对瓦解。
Hashtable 和 HashMap 在磁盘上的名目是不沟通、不兼容的。除非对每个持 久化的用户配置运行某种范例的数据转换实用措施（极其复杂的任务），不然以 后好像只能一直用 Hashtable 作为应用措施的存储名目。
团队感想陷入僵局，但这只是因为他们不知道关于 Java 序列化的一个重要 事实：Java 序列化答允跟着时间的推移而改变范例。当我向他们展示如何自动 举办序列化替换后，他们终于按打算完成了向 HashMap 的转变。
本文是本系列的第一篇文章，这个系列专门展现关于 Java 平台的一些有用 的小常识 — 这些小常识不易领略，但对付办理 Java 编程挑战早晚有用。
将 Java 工具序列化 API 作为初步是一个不错的选择，因为它从一开始就存 在于 JDK 1.1 中。本文先容的关于序列化的 5 件工作将说服您从头审视那些标 准 Java API。
Java 序列化简介
Java 工具序列化是 JDK 1.1 中引入的一组开创性特性之一，用于作为一种 将 Java 工具的状态转换为字节数组，以便存储或传输的机制，今后，仍可以将 字节数组转换回 Java 工具原有的状态。
实际上，序列化的思想是 “冻结” 工具状态，传输工具状态（写到磁盘、 通过网络传输等等），然后 “解冻” 状态，从头得到可用的 Java 工具。所有 这些工作的产生有点像是把戏，这要归功于 ObjectInputStream/ObjectOutputStream 类、完全保真的元数据以及措施员愿 意用 Serializable 标识接口标志他们的类，从而 “参加” 这个进程。
清单 1 显示一个实现 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;
}
#p#副标题#e#
将 Person 序列化后，很容易将工具状态写到磁盘，然后从头读出它，下面 的 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());
}
}
}
#p#分页标题#e#
到此刻为止，还没有看到什么新鲜的或令人欢快的工作，可是这是一个很好 的出发点。我们将利用 Person 来发明您大概不 知道的关于 Java 工具序列化 的 5 件事。
1. 序列化答允重构
序列化答允必然数量的类变种，甚至重构之后也是如此，ObjectInputStream 仍可以很好地将其读出来。
Java Object Serialization 类型可以自动打点的要害任务是：
将新字段添加到类中
将字段从 static 改为非 static
将字段从 transient 改为非 transient
取决于所需的向后兼容水平，转换字段形式（从非 static 转换为 static 或从非 transient 转换为 transient）可能删除字段需要特另外动静通报。
重构序列化类
既然已经知道序列化答允重构，我们来看看当把新字段添加到 Person 类中 时，会产生什么工作。
如清单 3 所示，PersonV2 在原先 Person 类的基本上引入一个暗示性此外 新字段。
清单 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 是按照给定源文件中险些所有对象 — 要领 名称、字段名称、字段范例、会见修改要领等 — 计较出来的，序列化将该 hash 值与序列化流中的 hash 值对较量。
为了使 Java 运行时相信两种范例实际上是一样的，第二版和随后版本的 Person 必需与第一版有沟通的序列化版本 hash（存储为 private static final serialVersionUID 字段）。因此，我们需要 serialVersionUID 字段， 它是通过对原始（或 V1）版本的 Person 类运行 JDK serialver 呼吁计较出的 。
一旦有了 Person 的 serialVersionUID，不只可以从原始工具 Person 的序 列化数据建设 PersonV2 工具（当呈现新字段时，新字段被设为缺省值，最常见 的是“null”），还可以反过来做：即从 PersonV2 的数据通过反序列化获得 Person，这绝不奇怪。
2. 序列化并不安详
#p#分页标题#e#
让 Java 开拓人员惊讶并感想不快的是，序列化二进制名目完全编写在文档 中，而且完全可逆。实际上，只需将二进制序列化流的内容转储到节制台，就足 以看清类是什么样子，以及它包括什么内容。
这对付安详性有着不良影响。譬喻，当通过 RMI 举办长途要领挪用时，通过 毗连发送的工具中的任何 private 字段险些都是以明文的方法呈此刻套接字流 中，这显然容易招致哪怕最简朴的安详问题。
幸运的是，序列化答允 “hook” 序列化进程，并在序列化之前和反序列化 之后掩护（或恍惚化）字段数据。可以通过在 Serializable 工具上提供一个 writeObject 要领来做到这一点。
恍惚化序列化数据
假设 Person 类中的敏感数据是 age 字段。究竟，密斯忌谈年数。我们可以 在序列化之前恍惚化该数据，将数位轮回左移一位，然后在反序列化之后复位。（您可以开拓更安详的算法，当前这个算法只是作为一个例子。）
为了 “hook” 序列化进程，我们将在 Person 上实现一个 writeObject 方 法；为了 “hook” 反序列化进程，我们将在同一个类上实现一个 readObject 要领。重要的是这两个要领的细节要正确 — 假如会见修改要领、参数或名称不 同于清单 4 中的内容，那么代码将不被察觉地失败，Person 的 age 将袒露。
清单 4. 恍惚化序列化数据
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;
}
假如需要查察被恍惚化的数据，老是可以查察序列化数据流/文件。并且，由 于该名目被完全文档化，纵然不能会见类自己，也仍可以读取序列化流中的内容 。
3. 序列化的数据可以被签名和密封
上一个能力假设您想恍惚化序列化数据，而不是对其加密可能确保它不被修 改。虽然，通过利用 writeObject 和 readObject 可以实现暗码加密和签名管 理，但其实尚有更好的方法。
假如需要对整个工具举办加密和签名，最简朴的是将它放在一个 javax.crypto.SealedObject 和/或 java.security.SignedObject 包装器中。 两者都是可序列化的，所以将工具包装在 SealedObject 中可以环绕原工具建设 一种 “包装盒”。必需有对称密钥才气解密，并且密钥必需单独打点。同样， 也可以将 SignedObject 用于数据验证，而且对称密钥也必需单独打点。
团结利用这两种工具，便可以轻松地对序列化数据举办密封和签名，而不必 强调关于数字签名验证或加密的细节。很简捷，是吧？
4. 序列化答允将署理放在流中
#p#分页标题#e#
许多环境下，类中包括一个焦点数据元素，通过它可以派生或找到类中的其 他字段。在此环境下，没有须要序列化整个工具。可以将字段标志为 transient ，可是每当有要了解见一个字段时，类仍然必需显式地发生代码来查抄它是否被 初始化。
假如首要问题是序列化，那么最好指定一个 flyweight 或署理放在流中。为 原始 Person 提供一个 writeReplace 要领，可以序列化差异范例的工具来取代 它。雷同地，假如反序列化期间发明一个 readResolve 要领，那么将挪用该方 法，将替代工具提供应挪用者。
打包息争包署理
writeReplace 和 readResolve 要领使 Person 类可以将它的所有数据（或 个中的焦点数据）打包到一个 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 的所有数据。这凡是意味着署理需要 是 Person 的一个内部类，以便能会见 private 字段。有时候，署理还需要追 踪其他工具引用并手动序列化它们，譬喻 Person 的 spouse。
这种能力是少数几种不需要读/写均衡的能力之一。譬喻，一个类被重组成另 一种范例后的版本可以提供一个 readResolve 要领，以便静默地将被序列化的 工具转换成新范例。雷同地，它可以回收 writeReplace 要领将旧类序列化成新 版本。
5. 信任，但要验证
认为序列化流中的数据老是与最初写到流中的数据一致，这没有问题。可是 ，正如一位美国前总统所说的，“信任，但要验证”。
对付序列化的工具，这意味着验证字段，以确保在反序列化之后它们仍具有 正确的值，“以防万一”。为此，可以实现 ObjectInputValidation 接口，并 包围 validateObject() 要领。假如挪用该要领时发明某处有错误，则抛出一个 InvalidObjectException。
竣事语
Java 工具序列化比大大都 Java 开拓人员想象的更机动，这使我们有更多的 时机办理棘手的环境。
幸运的是，像这样的编程妙招在 JVM 中到处可见。要害是要知道它们，在遇 到困难的时候能用上它们。
5 件事 系列下期预告：Java Collections。在此之前，好好享受按本身的想 法调解序列化吧！
原文地点：http://www.ibm.com/developerworks/cn/java/j- 5things1/index.html
