（原文链接：http://www.ibm.com/developerworks/cn/java/j-5things1/ 感谢原作者的分享）
Java 对象序列化（Java Object Serialization）在 Java 编程中是如此基本，以致很容易让人想当然。但是，和 Java 平台的很多方面一样，只要肯深入挖掘，序列化总能给予回报。在这个新系列的第一篇文章中，Ted Neward 给出 5 个需重新审视 Java 对象序列化的理由，并提供重构、加密和验证序列化数据的技巧（和代码）。
数年前，当和一个软件团队一起用 Java 语言编写一个应用程序时，我体会到比一般程序员多知道一点关于 Java 对象序列化的知识所带来的好处。关于本系列
您觉得自己懂 Java 编程？事实上，大多数程序员对于 Java 平台都是浅尝则止，只学习了足以完成手头上任务的知识而已。在本 系列 中，Ted Neward 深入挖掘 Java 平台的核心功能，揭示一些鲜为人知的事实，帮助您解决最棘手的编程挑战。
大约一年前，一个负责管理应用程序所有用户设置的开发人员，决定将用户设置存储在一个 Hashtable 中，然后将这个 Hashtable 序列化到磁盘，以便持久化。当用户更改设置时，便重新将 Hashtable 写到磁盘。
这是一个优雅的、开放式的设置系统，但是，当团队决定从 Hashtable 迁移到 Java Collections 库中的 HashMap 时，这个系统便面临崩溃。
Hashtable 和 HashMap 在磁盘上的格式是不相同、不兼容的。除非对每个持久化的用户设置运行某种类型的数据转换实用程序（极其庞大的任务），否则以后似乎只能一直用 Hashtable 作为应用程序的存储格式。
团队感到陷入僵局，但这只是因为他们不知道关于 Java 序列化的一个重要事实：Java 序列化允许随着时间的推移而改变类型。当我向他们展示如何自动进行序列化替换后，他们终于按计划完成了向 HashMap 的转变。
本文是本系列的第一篇文章，这个系列专门揭示关于 Java 平台的一些有用的小知识 — 这些小知识不易理解，但对于解决 Java 编程挑战迟早有用。
将 Java 对象序列化 API 作为开端是一个不错的选择，因为它从一开始就存在于 JDK 1.1 中。本文介绍的关于序列化的 5 件事情将说服您重新审视那些标准 Java API。
0.Java 序列化简介
Java 对象序列化是 JDK 1.1 中引入的一组开创性特性之一，用于作为一种将 Java 对象的状态转换为字节数组，以便存储或传输的机制，以后，仍可以将字节数组转换回 Java 对象原有的状态。实际上，序列化的思想是 “冻结” 对象状态，传输对象状态（写到磁盘、通过网络传输等等），然后 “解冻” 状态，重新获得可用的 Java 对象。所有这些事情的发生有点像是魔术，这要归功于 ObjectInputStream/ObjectOutputStream 类、完全保真的元数据以及程序员愿意用 Serializable 标识接口标记他们的类，从而 “参与” 这个过程。
清单 1 显示一个实现 Serializable 的 Person 类。
import java.io.Serializable;
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
private String firstName;
private String lastName;
private int age;
private Person spouse;
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person getSpouse() {
return spouse;
}
public void setSpouse(Person spouse) {
this.spouse = spouse;
}
@Override
public String toString() {
return "Person [firstName=" + firstName + ", lastName=" + lastName
+ ", age=" + age + ", spouse=" + spouse + "]";
}
public Person() {
}
public Person(String firstName, String lastName, int age) {
this.firstName = firstName;
this.lastName = lastName;
this.age = age;
}
}
清单 2. 对 Person 进行反序列化
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import org.junit.Test;
public class SerTest {
@Test
public void serializedToDisk() {
Person ted = new Person("ted", "Neward", 39);
Person charl = new Person("Charlotte", "Neward", 38);
ted.setSpouse(charl);
charl.setSpouse(ted);
try {
//附：该tempdata.ser文件会在项目根目录下生成
FileOutputStream fos = new FileOutputStream("tempdata.ser");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(ted);
oos.close();
} catch (Exception e) {
System.out.println("Exception thrown during test:");
e.printStackTrace();
}
try {
FileInputStream fis=new FileInputStream("tempdata.ser");
ObjectInputStream ois=new ObjectInputStream(fis);
Person ted1=(Person) ois.readObject();
ois.close();
System.out.println(ted1.getFirstName());
System.out.println(ted1.getSpouse().getFirstName());
//clean up the file
new File("tempdata.ser").delete();
} catch (Exception e) {
System.out.println("Exception thrown during test:");
e.printStackTrace();
}
}
}1. 序列化允许重构
序列化允许一定数量的类变种，甚至重构之后也是如此，ObjectInputStream 仍可以很好地将其读出来。
Java Object Serialization 规范可以自动管理的关键任务是：
* 将新字段添加到类中
* 将字段从 static 改为非 static
* 将字段从 transient 改为非 transient (当一个对象被序列化的时候，transient型变量的值不包括在序列化的表示中，可避免对象被序列化)
取决于所需的向后兼容程度，转换字段形式（从非 static 转换为 static 或从非 transient 转换为 transient）或者删除字段需要额外的消息传递。
重构序列化类
既然已经知道序列化允许重构，我们来看看当把新字段添加到 Person 类中时，会发生什么事情。如清单 3 所示，PersonV2 在原先 Person 类的基础上引入一个表示性别的新字段。
清单 3. 将新字段添加到序列化的 Person 中
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
enum Gender {
MALE, FEMALE
}
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
private String firstName;
private String lastName;
private int age;
private Person spouse;
private Gender gender;
private void writeObject(ObjectOutputStream stream) throws IOException {
age = age << 2;
stream.defaultWriteObject();
}
private void readObject(ObjectInputStream stream) throws IOException,
ClassNotFoundException {
stream.defaultReadObject();
age = age << 2;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person getSpouse() {
return spouse;
}
public void setSpouse(Person spouse) {
this.spouse = spouse;
}
public Gender getGender() {
return gender;
}
public void setGender(Gender gender) {
this.gender = gender;
}
public Person() {
}
@Override
public String toString() {
return "Person [firstName=" + firstName + ", lastName=" + lastName
+ ", age=" + age + ", gender=" + gender + " spouse="
+ (spouse!=null ? spouse.getFirstName() : "[null]")+ "]";
}
public Person(String firstName, String lastName, int age) {
this.firstName = firstName;
this.lastName = lastName;
this.age = age;
}
}3. 序列化的数据可以被签名和密封
上一个技巧假设您想模糊化序列化数据，而不是对其加密或者确保它不被修改。当然，通过使用 writeObject 和 readObject 可以实现密码加密和签名管理，但其实还有更好的方式。如果需要对整个对象进行加密和签名，最简单的是将它放在一个 javax.crypto.SealedObject 和/或 java.security.SignedObject 包装器中。两者都是可序列化的，所以将对象包装在 SealedObject 中可以围绕原对象创建一种 “包装盒”。必须有对称密钥才能解密，而且密钥必须单独管理。同样，也可以将 SignedObject 用于数据验证，并且对称密钥也必须单独管理。
结合使用这两种对象，便可以轻松地对序列化数据进行密封和签名，而不必强调关于数字签名验证或加密的细节。很简洁，是吧？
(原文没有该演示,该类需要 bouncycastle.jar包:http://www.bouncycastle.org/latest_releases.html )
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.security.Security;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SealedObject;
import javax.crypto.SecretKey;
public class MainClass {
public static void main(String args[]) throws Exception {
Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
SecretKey secretKey;
Cipher encrypter, decrypter;
secretKey = KeyGenerator.getInstance("DES").generateKey();// des加密
// 加密
encrypter = Cipher.getInstance("DES");
encrypter.init(Cipher.ENCRYPT_MODE, secretKey);
// 解密
decrypter = Cipher.getInstance("DES");
decrypter.init(Cipher.DECRYPT_MODE, secretKey);
User user1, unsealed;
SealedObject sealed;
user1 = new User();
user1.username = "jerry";
user1.password = "password";
// Seal it, storing it in a SealedObject 密封，将其存储在一个SealedObject当中
sealed = (new SealedObject(user1, encrypter));
FileOutputStream fos = new FileOutputStream("test.ser");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(sealed);
oos.close();
// Try unsealing it 解密
String algorithmName = sealed.getAlgorithm();
System.out.println(algorithmName);
unsealed = (User) sealed.getObject(decrypter);
System.out.println("NAME: " + unsealed.username);
System.out.println("PASSWORD: " + unsealed.password);
}
}
class User implements Serializable {
private static final long serialVersionUID = 1L;
public String username;
public String password;
}4. 序列化允许将代理放在流中
很多情况下，类中包含一个核心数据元素，通过它可以派生或找到类中的其他字段。在此情况下，没有必要序列化整个对象。可以将字段标记为 transient，但是每当有方法访问一个字段时，类仍然必须显式地产生代码来检查它是否被初始化。如果首要问题是序列化，那么最好指定一个 flyweight 或代理放在流中。为原始 Person 提供一个 writeReplace 方法，可以序列化不同类型的对象来代替它。类似地，如果反序列化期间发现一个 readResolve 方法，那么将调用该方法，将替代对象提供给调用者。
打包和解包代理
writeReplace 和 readResolve 方法使 Person 类可以将它的所有数据（或其中的核心数据）打包到一个 PersonProxy 中，将它放入到一个流中，然后在反序列化时再进行解包。
清单 5. 你完整了我，我代替了你
import java.io.Serializable;
public class PersonProxy implements Serializable{
private static final long serialVersionUID = 1L;
public String data;
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();
}
}
private Object readResolve(){
String[] pieces=data.split(",");
Person result=new Person(pieces[0],pieces[1],Integer.parseInt(pieces[5]));
if(pieces.length>3){
result.setSpouse(new Person(pieces[3],pieces[4],Integer.parseInt(pieces[5])));
result.getSpouse().setSpouse(result);
}
return result;
}
}
import java.io.Serializable;
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
private String firstName;
private String lastName;
private int age;
private Person spouse;
private Object writeReplace() {
return new PersonProxy(this);
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person getSpouse() {
return spouse;
}
public void setSpouse(Person spouse) {
this.spouse = spouse;
}
@Override
public String toString() {
return "Person [firstName=" + firstName + ", lastName=" + lastName
+ ", age=" + age + " spouse="
+ (spouse != null ? spouse.getFirstName() : "[null]") + "]";
}
public Person() {}
public Person(String firstName, String lastName, int age) {
this.firstName = firstName;
this.lastName = lastName;
this.age = age;
}
}
这种技巧是少数几种不需要读/写平衡的技巧之一。例如，一个类被重构成另一种类型后的版本可以提供一个 readResolve 方法，以便静默地将被序列化的对象转换成新类型。类似地，它可以采用 writeReplace 方法将旧类序列化成新版本。
5. 信任，但要验证
认为序列化流中的数据总是与最初写到流中的数据一致，这没有问题。但是，正如一位美国前总统所说的，“信任，但要验证”。对于序列化的对象，这意味着验证字段，以确保在反序列化之后它们仍具有正确的值，“以防万一”。为此，可以实现 ObjectInputValidation 接口，并覆盖 validateObject() 方法。如果调用该方法时发现某处有错误，则抛出一个 InvalidObjectException。结束语
Java 对象序列化比大多数 Java 开发人员想象的更灵活，这使我们有更多的机会解决棘手的情况。幸运的是，像这样的编程妙招在 JVM 中随处可见。关键是要知道它们，在遇到难题的时候能用上它们。5 件事 系列下期预告：Java Collections。在此之前，好好享受按自己的想法调整序列化吧！
扫一扫
150
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
