附录:对象序列化

当你创建对象时，只要你需要，它就会一直存在，但是在程序终止时，无论如何它都不会继续存在。尽管这么做肯定是有意义的，但是仍旧存在某些情况，如果对象能够在程序不运行的情况下仍能存在并保存其信息，那将非常有用。这样，在下次运行程序时，该对象将被重建并且拥有的信息与在程序上次运行时它所拥有的信息相同。当然，你可以通过将信息写入文件或数据库来达到相同的效果，但是在使万物都成为对象的精神中，如果能够将一个对象声明为是“持久性”的，并为我们处理掉所有细节，那将会显得十分方便。

Java 的对象序列化将那些实现了 Serializable 接口的对象转换成一个字节序列，并能够在以后将这个字节序列完全恢复为原来的对象。这一过程甚至可通过网络进行，这意味着序列化机制能自动弥补不同操作系统之间的差异。也就是说，可以在运行 Windows 系统的计算机上创建一个对象，将其序列化，通过网络将它发送给一台运行 Unix 系统的计算机，然后在那里准确地重新组装，而却不必担心数据在不同机器上的表示会不同，也不必关心宇节的顺序或者其他任何细节。

就其本身来说，对象序列化可以实现轻量级持久性（lightweight persistence），“持久性”意味着一个对象的生存周期并不取决于程序是否正在执行它可以生存于程序的调用之间。通过将一个序列化对象写入磁盘，然后在重新调用程序时恢复该对象，就能够实现持久性的效果。之所以称其为“轻量级”，是因为不能用某种”persistent”（持久）关键字来简单地定义一个对象，并让系统自动维护其他细节问题（尽管将来有可能实现）。相反，对象必须在程序中显式地序列化（serialize）和反序列化还原（deserialize），如果需要个更严格的持久性机制，可以考虑像 Hibernate 之类的工具。

对象序列化的概念加入到语言中是为了支持两种主要特性。一是 Java 的远程方法调用（Remote Method Invocation，RMI），它使存活于其他计算机上的对象使用起来就像是存活于本机上一样。当向远程对象发送消息时，需要通过对象序列化来传输参数和返回值。

再者，对 Java Beans 来说，对象的序列化也是必需的（在撰写本文时被视为失败的技术），使用一个 Bean 时，一般情况下是在设计阶段对它的状态信息进行配置。这种状态信息必须保存下来，并在程序启动时进行后期恢复，这种具体工作就是由对象序列化完成的。

只要对象实现了 Serializable 接口（该接口仅是一个标记接口，不包括任何方法），对象的序列化处理就会非常简单。当序列化的概念被加入到语言中时，许多标准库类都发生了改变，以便具备序列化特性-其中包括所有基本数据类型的封装器、所有容器类以及许多其他的东西。甚至 Class 对象也可以被序列化。

要序列化一个对象，首先要创建某些 OutputStream 对象，然后将其封装在一个 ObjectOutputStream 对象内。这时，只需调用 writeObject() 即可将对象序列化，并将其发送给 OutputStream（对象化序列是基于字节的，因要使用 InputStream 和 OutputStream 继承层次结构）。要反向进行该过程（即将一个序列还原为一个对象），需要将一个 InputStream 封装在 ObjectInputStream 内，然后调用 readObject()。和往常一样，我们最后获得的是一个引用，它指向一个向上转型的 Object，所以必须向下转型才能直接设置它们。

对象序列化特别“聪明”的一个地方是它不仅保存了对象的“全景图”，而且能追踪对象内所包含的所有引用，并保存那些对象；接着又能对对象内包含的每个这样的引用进行追踪，依此类推。这种情况有时被称为“对象网”，单个对象可与之建立连接，而且它还包含了对象的引用数组以及成员对象。如果必须保持一套自己的对象序列化机制，那么维护那些可追踪到所有链接的代码可能会显得非常麻烦。然而，由于 Java 的对象序列化似乎找不出什么缺点，所以请尽量不要自己动手，让它用优化的算法自动维护整个对象网。下面这个例子通过对链接的对象生成一个 worm（蠕虫）对序列化机制进行了测试。每个对象都与 worm 中的下一段链接，同时又与属于不同类（Data）的对象引用数组链接：

  1. // serialization/Worm.java
  2. // Demonstrates object serialization
  3. import java.io.*;
  4. import java.util.*;
  5. class Data implements Serializable {
  6.     private int n;
  7.     Data(int n) { this.n = n; }
  8.     @Override
  9.     public String toString() {
  10.         return Integer.toString(n);
  11.     }
  12. }
  13. public class Worm implements Serializable {
  14.     private static Random rand = new Random(47);
  15.     private Data[] d = {
  16.             new Data(rand.nextInt(10)),
  17.             new Data(rand.nextInt(10)),
  18.             new Data(rand.nextInt(10))
  19.     };
  20.     private Worm next;
  21.     private char c;
  22.     // Value of i == number of segments
  23.     public Worm(int i, char x) {
  24.         System.out.println("Worm constructor: " + i);
  25.         c = x;
  26.         if(--i > 0)
  27.             next = new Worm(i, (char)(x + 1));
  28.     }
  29.     public Worm() {
  30.         System.out.println("No-arg constructor");
  31.     }
  32.     @Override
  33.     public String toString() {
  34.         StringBuilder result = new StringBuilder(":");
  35.         result.append(c);
  36.         result.append("(");
  37.         for(Data dat : d)
  38.             result.append(dat);
  39.         result.append(")");
  40.         if(next != null)
  41.             result.append(next);
  42.         return result.toString();
  43.     }
  44.     public static void
  45.     main(String[] args) throws ClassNotFoundException,
  46.             IOException {
  47.         Worm w = new Worm(6, 'a');
  48.         System.out.println("w = " + w);
  49.         try(
  50.                 ObjectOutputStream out = new ObjectOutputStream(
  51.                         new FileOutputStream("worm.dat"))
  52.         ) {
  53.             out.writeObject("Worm storage\n");
  54.             out.writeObject(w);
  55.         }
  56.         try(
  57.                 ObjectInputStream in = new ObjectInputStream(
  58.                         new FileInputStream("worm.dat"))
  59.         ) {
  60.             String s = (String)in.readObject();
  61.             Worm w2 = (Worm)in.readObject();
  62.             System.out.println(s + "w2 = " + w2);
  63.         }
  64.         try(
  65.                 ByteArrayOutputStream bout =
  66.                         new ByteArrayOutputStream();
  67.                 ObjectOutputStream out2 =
  68.                         new ObjectOutputStream(bout)
  69.         ) {
  70.             out2.writeObject("Worm storage\n");
  71.             out2.writeObject(w);
  72.             out2.flush();
  73.             try(
  74.                     ObjectInputStream in2 = new ObjectInputStream(
  75.                             new ByteArrayInputStream(
  76.                                     bout.toByteArray()))
  77.             ) {
  78.                 String s = (String)in2.readObject();
  79.                 Worm w3 = (Worm)in2.readObject();
  80.                 System.out.println(s + "w3 = " + w3);
  81.             }
  82.         }
  83.     }
  84. }

输出为：

  1. Worm constructor: 6
  2. Worm constructor: 5
  3. Worm constructor: 4
  4. Worm constructor: 3
  5. Worm constructor: 2
  6. Worm constructor: 1
  7. w = :a(853):b(119):c(802):d(788):e(199):f(881)
  8. Worm storage
  9. w2 = :a(853):b(119):c(802):d(788):e(199):f(881)
  10. Worm storage
  11. w3 = :a(853):b(119):c(802):d(788):e(199):f(881)

更有趣的是，Worm 内的 Data 对象数组是用随机数初始化的（这样就不用怀疑编译器保留了某种原始信息），每个 Worm 段都用一个 char 加以标记。该 char 是在递归生成链接的 Worm 列表时自动产生的。要创建一个 Worm，必须告诉构造器你所希望的它的长度。在产生下一个引用时，要调用 Worm 构造器，并将长度减 1，以此类推。最后一个 next 引用则为 null（空），表示已到达 Worm 的尾部

以上这些操作都使得事情变得更加复杂，从而加大了对象序列化的难度。然而，真正的序列化过程却是非常简单的。一旦从另外某个流创建了 ObjectOutputstream，writeObject() 就会将对象序列化。注意也可以为一个 String 调用 writeObject() 也可以用与 DataOutputStream 相同的方法写人所有基本数据类型（它们具有同样的接口）。

有两段看起来相似的独立的代码。一个读写的是文件，而另一个读写的是字节数组（ByteArray），可利用序列化将对象读写到任何 DatalnputStream 或者 DataOutputStream。

从输出中可以看出，被还原后的对象确实包含了原对象中的所有链接。

注意在对一个 Serializable 对象进行还原的过程中，没有调用任何构造器，包括默认的构造器。整个对象都是通过从 InputStream 中取得数据恢复而来的。

查找类

你或许会奇怪，将一个对象从它的序列化状态中恢复出来，有哪些工作是必须的呢？举个例子来说，假如我们将一个对象序列化，并通过网络将其作为文件传送给另一台计算机，那么，另一台计算机上的程序可以只利用该文件内容来还原这个对象吗？

回答这个问题的最好方法就是做一个实验。下面这个文件位于本章的子目录下：

  1. // serialization/Alien.java
  2. // A serializable class
  3. import java.io.*;
  4. public class Alien implements Serializable {}

而用于创建和序列化一个 Alien 对象的文件也位于相同的目录下：

  1. // serialization/FreezeAlien.java
  2. // Create a serialized output file
  3. import java.io.*;
  4. public class FreezeAlien {
  5.     public static void main(String[] args) throws Exception {
  6.         try(
  7.                 ObjectOutputStream out = new ObjectOutputStream(
  8.                         new FileOutputStream("X.file"));
  9.         ) {
  10.             Alien quellek = new Alien();
  11.             out.writeObject(quellek);
  12.         }
  13.     }
  14. }

一旦该程序被编译和运行，它就会在 c12 目录下产生一个名为 X.file 的文件。以下代码位于一个名为 xiles 的子目录下：

  1. // serialization/xfiles/ThawAlien.java
  2. // Recover a serialized file
  3. // {java serialization.xfiles.ThawAlien}
  4. // {RunFirst: FreezeAlien}
  5. package serialization.xfiles;
  6. import java.io.*;
  7. public class ThawAlien {
  8.     public static void main(String[] args) throws Exception {
  9.         ObjectInputStream in = new ObjectInputStream(
  10.                 new FileInputStream(new File("X.file")));
  11.         Object mystery = in.readObject();
  12.         System.out.println(mystery.getClass());
  13.     }
  14. }

输出为：

  1. class Alien

为了正常运行，必须保证 Java 虚拟机能找到相关的.class 文件。

控制序列化

正如大家所看到的，默认的序列化机制并不难操纵。然而，如果有特殊的需要那又该怎么办呢？例如，也许要考虑特殊的安全问题，而且你不希望对象的某一部分被序列化；或者一个对象被还原以后，某子对象需要重新创建，从而不必将该子对象序列化。

在这些特殊情况下，可通过实现 Externalizable 接口——代替实现 Serializable 接口-来对序列化过程进行控制。这个 Externalizable 接口继承了 Serializable 接口，同时增添了两个方法：writeExternal() 和 readExternal()。这两个方法会在序列化和反序列化还原的过程中被自动调用，以便执行一些特殊操作。

下面这个例子展示了 Externalizable 接口方法的简单实现。注意 Blip1 和 Blip2 除了细微的差别之外，几乎完全一致（研究一下代码，看看你能否发现）：

  1. // serialization/Blips.java
  2. // Simple use of Externalizable & a pitfall
  3. import java.io.*;
  4. class Blip1 implements Externalizable {
  5.     public Blip1() {
  6.         System.out.println("Blip1 Constructor");
  7.     }
  8.     @Override
  9.     public void writeExternal(ObjectOutput out)
  10.             throws IOException {
  11.         System.out.println("Blip1.writeExternal");
  12.     }
  13.     @Override
  14.     public void readExternal(ObjectInput in)
  15.             throws IOException, ClassNotFoundException {
  16.         System.out.println("Blip1.readExternal");
  17.     }
  18. }
  19. class Blip2 implements Externalizable {
  20.     Blip2() {
  21.         System.out.println("Blip2 Constructor");
  22.     }
  23.     @Override
  24.     public void writeExternal(ObjectOutput out)
  25.             throws IOException {
  26.         System.out.println("Blip2.writeExternal");
  27.     }
  28.     @Override
  29.     public void readExternal(ObjectInput in)
  30.             throws IOException, ClassNotFoundException {
  31.         System.out.println("Blip2.readExternal");
  32.     }
  33. }
  34. public class Blips {
  35.     public static void main(String[] args) {
  36.         System.out.println("Constructing objects:");
  37.         Blip1 b1 = new Blip1();
  38.         Blip2 b2 = new Blip2();
  39.         try(
  40.                 ObjectOutputStream o = new ObjectOutputStream(
  41.                         new FileOutputStream("Blips.serialized"))
  42.         ) {
  43.             System.out.println("Saving objects:");
  44.             o.writeObject(b1);
  45.             o.writeObject(b2);
  46.         } catch(IOException e) {
  47.             throw new RuntimeException(e);
  48.         }
  49.         // Now get them back:
  50.         System.out.println("Recovering b1:");
  51.         try(
  52.                 ObjectInputStream in = new ObjectInputStream(
  53.                         new FileInputStream("Blips.serialized"))
  54.         ) {
  55.             b1 = (Blip1)in.readObject();
  56.         } catch(IOException | ClassNotFoundException e) {
  57.             throw new RuntimeException(e);
  58.         }
  59.         // OOPS! Throws an exception:
  60.         //- System.out.println("Recovering b2:");
  61.         //- b2 = (Blip2)in.readObject();
  62.     }
  63. }

输出为：

  1. Constructing objects:
  2. Blip1 Constructor
  3. Blip2 Constructor
  4. Saving objects:
  5. Blip1.writeExternal
  6. Blip2.writeExternal
  7. Recovering b1:
  8. Blip1 Constructor
  9. Blip1.readExternal

没有恢复 Blip2 对象的原因是那样做会导致一个异常。你找出 Blip1 和 Blip2 之间的区别了吗？Blipl 的构造器是“公共的”（public），Blip2 的构造器却不是，这样就会在恢复时造成异常。试试将 Blip2 的构造器变成 public 的，然后删除//注释标记，看看是否能得到正确的结果。

恢复 b1 后，会调用 Blip1 默认构造器。这与恢复一个 Serializable 对象不同。对于 Serializable 对象，对象完全以它存储的二进制位为基础来构造，而不调用构造器。而对于一个 Externalizable 对象，所有普通的默认构造器都会被调用（包括在字段定义时的初始化），然后调用 readExternal() 必须注意这一点—所有默认的构造器都会被调用，才能使 Externalizable 对象产生正确的行为。

下面这个例子示范了如何完整保存和恢复一个 Externalizable 对象：

  1. // serialization/Blip3.java
  2. // Reconstructing an externalizable object
  3. import java.io.*;
  4. public class Blip3 implements Externalizable {
  5.     private int i;
  6.     private String s; // No initialization
  7.     public Blip3() {
  8.         System.out.println("Blip3 Constructor");
  9. // s, i not initialized
  10.     }
  11.     public Blip3(String x, int a) {
  12.         System.out.println("Blip3(String x, int a)");
  13.         s = x;
  14.         i = a;
  15. // s & i initialized only in non-no-arg constructor.
  16.     }
  17.     @Override
  18.     public String toString() { return s + i; }
  19.     @Override
  20.     public void writeExternal(ObjectOutput out)
  21.             throws IOException {
  22.         System.out.println("Blip3.writeExternal");
  23. // You must do this:
  24.         out.writeObject(s);
  25.         out.writeInt(i);
  26.     }
  27.     @Override
  28.     public void readExternal(ObjectInput in)
  29.             throws IOException, ClassNotFoundException {
  30.         System.out.println("Blip3.readExternal");
  31. // You must do this:
  32.         s = (String)in.readObject();
  33.         i = in.readInt();
  34.     }
  35.     public static void main(String[] args) {
  36.         System.out.println("Constructing objects:");
  37.         Blip3 b3 = new Blip3("A String ", 47);
  38.         System.out.println(b3);
  39.         try(
  40.                 ObjectOutputStream o = new ObjectOutputStream(
  41.                         new FileOutputStream("Blip3.serialized"))
  42.         ) {
  43.             System.out.println("Saving object:");
  44.             o.writeObject(b3);
  45.         } catch(IOException e) {
  46.             throw new RuntimeException(e);
  47.         }
  48. // Now get it back:
  49.         System.out.println("Recovering b3:");
  50.         try(
  51.                 ObjectInputStream in = new ObjectInputStream(
  52.                         new FileInputStream("Blip3.serialized"))
  53.         ) {
  54.             b3 = (Blip3)in.readObject();
  55.         } catch(IOException | ClassNotFoundException e) {
  56.             throw new RuntimeException(e);
  57.         }
  58.         System.out.println(b3);
  59.     }
  60. }

输出为：

  1. Constructing objects:
  2. Blip3(String x, int a)
  3. A String 47
  4. Saving object:
  5. Blip3.writeExternal
  6. Recovering b3:
  7. Blip3 Constructor
  8. Blip3.readExternal
  9. A String 47

其中，字段 s 和 i 只在第二个构造器中初始化，而不是在默认的构造器中初始化。这意味着假如不在 readExternal() 中初始化 s 和 i，s 就会为 null，而 i 就会为零（因为在创建对象的第一步中将对象的存储空间清理为 0）。如果注释掉跟随于”You must do this”后面的两行代码，然后运行程序，就会发现当对象被还原后，s 是 null，而 i 是零。

我们如果从一个 Externalizable 对象继承，通常需要调用基类版本的 writeExternal() 和 readExternal() 来为基类组件提供恰当的存储和恢复功能。

因此，为了正常运行，我们不仅需要在 writeExternal() 方法（没有任何默认行为来为 Externalizable 对象写入任何成员对象）中将来自对象的重要信息写入，还必须在 readExternal() 方法中恢复数据。起先，可能会有一点迷惑，因为 Externalizable 对象的默认构造行为使其看起来似乎像某种自动发生的存储与恢复操作。但实际上并非如此。

transient 关键字

当我们对序列化进行控制时，可能某个特定子对象不想让 Java 的序列化机制自动保存与恢复。如果子对象表示的是我们不希望将其序列化的敏感信息（如密码），通常就会面临这种情况。即使对象中的这些信息是 private（私有）属性，一经序列化处理，人们就可以通过读取文件或者拦截网络传输的方式来访问到它。

有一种办法可防止对象的敏感部分被序列化，就是将类实现为 Externalizable，如前面所示。这样一来，没有任何东西可以自动序列化，并且可以在 writeExternal() 内部只对所需部分进行显式的序列化。

然而，如果我们正在操作的是一个 Seralizable 对象，那么所有序列化操作都会自动进行。为了能够予以控制，可以用 transient（瞬时）关键字逐个字段地关闭序列化，它的意思是“不用麻烦你保存或恢复数据——我自己会处理的”。

例如，假设某个 Logon 对象保存某个特定的登录会话信息，登录的合法性通过校验之后，我们想把数据保存下来，但不包括密码。为做到这一点，最简单的办法是实现 Serializable，并将 password 字段标志为 transient，下面是具体的代码：

  1. // serialization/Logon.java
  2. // Demonstrates the "transient" keyword
  3. import java.util.concurrent.*;
  4. import java.io.*;
  5. import java.util.*;
  6. import onjava.Nap;
  7. public class Logon implements Serializable {
  8.     private Date date = new Date();
  9.     private String username;
  10.     private transient String password;
  11.     public Logon(String name, String pwd) {
  12.         username = name;
  13.         password = pwd;
  14.     }
  15.     @Override
  16.     public String toString() {
  17.         return "logon info: \n username: " +
  18.                 username + "\n date: " + date +
  19.                 "\n password: " + password;
  20.     }
  21.     public static void main(String[] args) {
  22.         Logon a = new Logon("Hulk", "myLittlePony");
  23.         System.out.println("logon a = " + a);
  24.         try(
  25.                 ObjectOutputStream o =
  26.                         new ObjectOutputStream(
  27.                                 new FileOutputStream("Logon.dat"))
  28.         ) {
  29.             o.writeObject(a);
  30.         } catch(IOException e) {
  31.             throw new RuntimeException(e);
  32.         }
  33.         new Nap(1);
  34. // Now get them back:
  35.         try(
  36.                 ObjectInputStream in = new ObjectInputStream(
  37.                         new FileInputStream("Logon.dat"))
  38.         ) {
  39.             System.out.println(
  40.                     "Recovering object at " + new Date());
  41.             a = (Logon)in.readObject();
  42.         } catch(IOException | ClassNotFoundException e) {
  43.             throw new RuntimeException(e);
  44.         }
  45.         System.out.println("logon a = " + a);
  46.     }
  47. }

输出为：

  1. logon a = logon info:
  2. username: Hulk
  3. date: Tue May 09 06:07:47 MDT 2017
  4. password: myLittlePony
  5. Recovering object at Tue May 09 06:07:49 MDT 2017
  6. logon a = logon info:
  7. username: Hulk
  8. date: Tue May 09 06:07:47 MDT 2017
  9. password: null

可以看到，其中的 date 和 username 是一般的（不是 transient 的），所以它们会被自动序列化。而 password 是 transient 的，所以不会被自动保存到磁盘；另外，自动序列化机制也不会尝试去恢复它。当对象被恢复时，password 就会变成 null。注意，虽然 toString() 是用重载后的+运算符来连接 String 对象，但是 null 引用会被自动转换成字符串 null。

我们还可以发现：date 字段被存储了到磁盘并从磁盘上被恢复了出来，而且没有再重新生成。由于 Externalizable 对象在默认情况下不保存它们的任何字段，所以 transient 关键字只能和 Serializable 对象一起使用。

Externalizable 的替代方法

如果不是特别坚持实现 Externalizable 接口，那么还有另一种方法。我们可以实现 Serializable 接口，并添加（注意我说的是“添加”，而非“覆盖”或者“实现”）名为 writeObject() 和 readObject() 的方法。这样一旦对象被序列化或者被反序列化还原，就会自动地分别调用这两个方法。也就是说，只要我们提供了这两个方法，就会使用它们而不是默认的序列化机制。

这些方法必须具有准确的方法特征签名：

  1. private void writeObject(ObjectOutputStream stream) throws IOException
  3. private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException

从设计的观点来看，现在事情变得真是不可思议。首先，我们可能会认为由于这些方法不是基类或者 Serializable 接口的一部分，所以应该在它们自己的接口中进行定义。但是注意它们被定义成了 private，这意味着它们仅能被这个类的其他成员调用。然而，实际上我们并没有从这个类的其他方法中调用它们，而是 ObjectOutputStream 和 ObjectInputStream 对象的 writeObject() 和 readobject() 方法调用你的对象的 writeObject() 和 readObject() 方法（注意关于这里用到的相同方法名，我尽量抑制住不去谩骂。一句话：混乱）。读者可能想知道 ObjectOutputStream 和 ObjectInputStream 对象是怎样访问你的类中的 private 方法的。我们只能假设这正是序列化神奇的一部分。

在接口中定义的所有东西都自动是 public 的，因此如果 writeObject() 和 readObject() 必须是 private 的，那么它们不会是接口的一部分。因为我们必须要完全遵循其方法特征签名，所以其效果就和实现了接口一样。

在调用 ObjectOutputStream.writeObject() 时，会检查所传递的 Serializable 对象，看看是否实现了它自己的 writeObject()。如果是这样，就跳过正常的序列化过程并调用它的 writeObiect()。readObject() 的情形与此相同。

还有另外一个技巧。在你的 writeObject() 内部，可以调用 defaultWriteObject() 来选择执行默认的 writeObject()。类似地，在 readObject() 内部，我们可以调用 defaultReadObject()，下面这个简单的例子演示了如何对一个 Serializable 对象的存储与恢复进行控制：

  1. // serialization/SerialCtl.java
  2. // Controlling serialization by adding your own
  3. // writeObject() and readObject() methods
  4. import java.io.*;
  5. public class SerialCtl implements Serializable {
  6.     private String a;
  7.     private transient String b;
  8.     public SerialCtl(String aa, String bb) {
  9.         a = "Not Transient: " + aa;
  10.         b = "Transient: " + bb;
  11.     }
  12.     @Override
  13.     public String toString() { return a + "\n" + b; }
  14.     private void writeObject(ObjectOutputStream stream)
  15.             throws IOException {
  16.         stream.defaultWriteObject();
  17.         stream.writeObject(b);
  18.     }
  19.     private void readObject(ObjectInputStream stream)
  20.             throws IOException, ClassNotFoundException {
  21.         stream.defaultReadObject();
  22.         b = (String)stream.readObject();
  23.     }
  24.     public static void main(String[] args) {
  25.         SerialCtl sc = new SerialCtl("Test1", "Test2");
  26.         System.out.println("Before:\n" + sc);
  27.         try (
  28.                 ByteArrayOutputStream buf =
  29.                         new ByteArrayOutputStream();
  30.                 ObjectOutputStream o =
  31.                         new ObjectOutputStream(buf);
  32.         ) {
  33.             o.writeObject(sc);
  34. // Now get it back:
  35.             try (
  36.                     ObjectInputStream in =
  37.                             new ObjectInputStream(
  38.                                     new ByteArrayInputStream(
  39.                                             buf.toByteArray()));
  40.             ) {
  41.                 SerialCtl sc2 = (SerialCtl)in.readObject();
  42.                 System.out.println("After:\n" + sc2);
  43.             }
  44.         } catch(IOException | ClassNotFoundException e) {
  45.             throw new RuntimeException(e);
  46.         }
  47.     }
  48. }

输出为：

  1. Before:
  2. Not Transient: Test1
  3. Transient: Test2
  4. After:
  5. Not Transient: Test1
  6. Transient: Test2

在这个例子中，有一个 String 字段是普通字段，而另一个是 transient 字段，用来证明非 transient 字段由 defaultWriteObject() 方法保存，而 transient 字段必须在程序中明确保存和恢复。字段是在构造器内部而不是在定义处进行初始化的，以此可以证实它们在反序列化还原期间没有被一些自动化机制初始化。

如果我们打算使用默认机制写入对象的非 transient 部分，那么必须调用 defaultwriteObject() 作为 writeObject() 中的第一个操作，并让 defaultReadObject() 作为 readObject() 中的第一个操作。这些都是奇怪的方法调用。例如，如果我们正在为 ObjectOutputStream 调用 defaultWriteObject() 且没有传递任何参数，然而不知何故它却可以运行，并且知道对象的引用以及如何写入非 transient 部分。真是奇怪之极。

对 transient 对象的存储和恢复使用了我们比较熟悉的代码。请再考虑一下在这里所发生的事情。在 main0）中，创建 SerialCtl 对象，然后将其序列化到 ObjectOutputStream（注意在这种情况下，使用的是缓冲区而不是文件-这对于 ObjectOutputStream 来说是完全一样的）。序列化发生在下面这行代码当中

  1. o.writeObject(sc);

writeObject() 方法必须检查 sc，判断它是否拥有自己的 writeObject() 方法（不是检查接口——这里根本就没有接口，也不是检查类的类型，而是利用反射来真正地搜索方法）。如果有，那么就会使用它。对 readObject() 也采用了类似的方法。或许这是解决这个问题的唯一切实可行的方法，但它确实有点古怪。

版本控制

有时可能想要改变可序列化类的版本（比如源类的对象可能保存在数据库中）。虽然 Java 支持这种做法，但是你可能只在特殊的情况下才这样做，此外，还需要对它有相当深程度的了解（在这里我们就不再试图达到这一点）。从 http://java.oracle.com 下的 JDK 文档中对这一主题进行了非常彻底的论述。

使用持久化

一个比较诱人的使用序列化技术的想法是：存储程序的一些状态，以便我们随后可以很容易地将程序恢复到当前状态。但是在我们能够这样做之前，必须回答几个问题。如果我们将两个对象-它们都具有指向第三个对象的引用-进行序列化，会发生什么情况？当我们从它们的序列化状态恢复这两个对象时，第三个对象会只出现一次吗？如果将这两个对象序列化成独立的文件，然后在代码的不同部分对它们进行反序列化还原，又会怎样呢？

下面这个例子说明了上述问题：

  1. // serialization/MyWorld.java
  2. import java.io.*;
  3. import java.util.*;
  4. class House implements Serializable {}
  5. class Animal implements Serializable {
  6.     private String name;
  7.     private House preferredHouse;
  8.     Animal(String nm, House h) {
  9.         name = nm;
  10.         preferredHouse = h;
  11.     }
  12.     @Override
  13.     public String toString() {
  14.         return name + "[" + super.toString() +
  15.                 "], " + preferredHouse + "\n";
  16.     }
  17. }
  18. public class MyWorld {
  19.     public static void main(String[] args) {
  20.         House house = new House();
  21.         List<Animal> animals = new ArrayList<>();
  22.         animals.add(
  23.                 new Animal("Bosco the dog", house));
  24.         animals.add(
  25.                 new Animal("Ralph the hamster", house));
  26.         animals.add(
  27.                 new Animal("Molly the cat", house));
  28.         System.out.println("animals: " + animals);
  29.         try(
  30.                 ByteArrayOutputStream buf1 =
  31.                         new ByteArrayOutputStream();
  32.                 ObjectOutputStream o1 =
  33.                         new ObjectOutputStream(buf1)
  34.         ) {
  35.             o1.writeObject(animals);
  36.             o1.writeObject(animals); // Write a 2nd set
  37. // Write to a different stream:
  38.             try(
  39.                     ByteArrayOutputStream buf2 = new ByteArrayOutputStream();
  40.                     ObjectOutputStream o2 = new ObjectOutputStream(buf2)
  41.             ) {
  42.                 o2.writeObject(animals);
  43. // Now get them back:
  44.                 try(
  45.                         ObjectInputStream in1 =
  46.                                 new ObjectInputStream(
  47.                                         new ByteArrayInputStream(
  48.                                                 buf1.toByteArray()));
  49.                         ObjectInputStream in2 =
  50.                                 new ObjectInputStream(
  51.                                         new ByteArrayInputStream(
  52.                                                 buf2.toByteArray()))
  53.                 ) {
  54.                     List
  55.                             animals1 = (List)in1.readObject(),
  56.                             animals2 = (List)in1.readObject(),
  57.                             animals3 = (List)in2.readObject();
  58.                     System.out.println(
  59.                             "animals1: " + animals1);
  60.                     System.out.println(
  61.                             "animals2: " + animals2);
  62.                     System.out.println(
  63.                             "animals3: " + animals3);
  64.                 }
  65.             }
  66.         } catch(IOException | ClassNotFoundException e) {
  67.             throw new RuntimeException(e);
  68.         }
  69.     }
  70. }

输出为：

  1. animals: [Bosco the dog[Animal@15db9742],
  2. House@6d06d69c
  3. , Ralph the hamster[Animal@7852e922], House@6d06d69c
  4. , Molly the cat[Animal@4e25154f], House@6d06d69c
  5. ]
  6. animals1: [Bosco the dog[Animal@7ba4f24f],
  7. House@3b9a45b3
  8. , Ralph the hamster[Animal@7699a589], House@3b9a45b3
  9. , Molly the cat[Animal@58372a00], House@3b9a45b3
  10. ]
  11. animals2: [Bosco the dog[Animal@7ba4f24f],
  12. House@3b9a45b3
  13. , Ralph the hamster[Animal@7699a589], House@3b9a45b3
  14. , Molly the cat[Animal@58372a00], House@3b9a45b3
  15. ]
  16. animals3: [Bosco the dog[Animal@4dd8dc3],
  17. House@6d03e736
  18. , Ralph the hamster[Animal@568db2f2], House@6d03e736
  19. , Molly the cat[Animal@378bf509], House@6d03e736
  20. ]

这里有一件有趣的事：我们可以通过一个字节数组来使用对象序列化，从而实现对任何可 Serializable 对象的“深度复制”（deep copy）—— 深度复制意味着我们复制的是整个对象网，而不仅仅是基本对象及其引用。复制对象将在本书的 附录：传递和返回对象 一章中进行深入地探讨。

在这个例子中，Animal 对象包含有 House 类型的字段。在 main() 方法中，创建了一个 Animal 列表并将其两次序列化，分别送至不同的流。当其被反序列化还原并被打印时，我们可以看到所示的执行某次运行后的结果（每次运行时，对象将会处在不同的内存地址）。

当然，我们期望这些反序列化还原后的对象地址与原来的地址不同。但请注意，在 animals1 和 animals2 中却出现了相同的地址，包括二者共享的那个指向 House 对象的引用。另一方面，当恢复 animals3 时，系统无法知道另一个流内的对象是第一个流内的对象的别名，因此它会产生出完全不同的对象网。

只要将任何对象序列化到单一流中，就可以恢复出与我们写出时一样的对象网，并且没有任何意外重复复制出的对象。当然，我们可以在写出第一个对象和写出最后一个对象期间改变这些对象的状态，但是这是我们自己的事，无论对象在被序列化时处于什么状态（无论它们和其他对象有什么样的连接关系），它们都可以被写出。

最安全的做法是将其作为“原子”操作进行序列化。如果我们序列化了某些东西，再去做其他一些工作，再来序列化更多的东西，如此等等，那么将无法安全地保存系统状态。取而代之的是，将构成系统状态的所有对象都置入单一容器内，并在一个操作中将该容器直接写出。然后同样只需一次方法调用，即可以将其恢复。

下面这个例子是一个想象的计算机辅助设计（CAD）系统，该例演示了这一方法。此外，它还引入了 static 字段的问题：如果我们查看 JDK 文档，就会发现 Class 是 Serializable 的，因此只需直接对 Class 对象序列化，就可以很容易地保存 static 字段。在任何情况下，这都是一种明智的做法。

  1. // serialization/AStoreCADState.java
  2. // Saving the state of a fictitious CAD system
  3. import java.io.*;
  4. import java.util.*;
  5. import java.util.stream.*;
  6. enum Color { RED, BLUE, GREEN }
  7. abstract class Shape implements Serializable {
  8.     private int xPos, yPos, dimension;
  9.     private static Random rand = new Random(47);
  10.     private static int counter = 0;
  11.     public abstract void setColor(Color newColor);
  12.     public abstract Color getColor();
  13.     Shape(int xVal, int yVal, int dim) {
  14.         xPos = xVal;
  15.         yPos = yVal;
  16.         dimension = dim;
  17.     }
  18.     public String toString() {
  19.         return getClass() + "color[" + getColor() +
  20.                 "] xPos[" + xPos + "] yPos[" + yPos +
  21.                 "] dim[" + dimension + "]\n";
  22.     }
  23.     public static Shape randomFactory() {
  24.         int xVal = rand.nextInt(100);
  25.         int yVal = rand.nextInt(100);
  26.         int dim = rand.nextInt(100);
  27.         switch(counter++ % 3) {
  28.             default:
  29.             case 0: return new Circle(xVal, yVal, dim);
  30.             case 1: return new Square(xVal, yVal, dim);
  31.             case 2: return new Line(xVal, yVal, dim);
  32.         }
  33.     }
  34. }
  35. class Circle extends Shape {
  36.     private static Color color = Color.RED;
  37.     Circle(int xVal, int yVal, int dim) {
  38.         super(xVal, yVal, dim);
  39.     }
  40.     public void setColor(Color newColor) {
  41.         color = newColor;
  42.     }
  43.     public Color getColor() { return color; }
  44. }
  45. class Square extends Shape {
  46.     private static Color color = Color.RED;
  47.     Square(int xVal, int yVal, int dim) {
  48.         super(xVal, yVal, dim);
  49.     }
  50.     public void setColor(Color newColor) {
  51.         color = newColor;
  52.     }
  53.     public Color getColor() { return color; }
  54. }
  55. class Line extends Shape {
  56.     private static Color color = Color.RED;
  57.     public static void
  58.     serializeStaticState(ObjectOutputStream os)
  59.             throws IOException { os.writeObject(color); }
  60.     public static void
  61.     deserializeStaticState(ObjectInputStream os)
  62.             throws IOException, ClassNotFoundException {
  63.         color = (Color)os.readObject();
  64.     }
  65.     Line(int xVal, int yVal, int dim) {
  66.         super(xVal, yVal, dim);
  67.     }
  68.     public void setColor(Color newColor) {
  69.         color = newColor;
  70.     }
  71.     public Color getColor() { return color; }
  72. }
  73. public class AStoreCADState {
  74.     public static void main(String[] args) {
  75.         List<Class<? extends Shape>> shapeTypes =
  76.                 Arrays.asList(
  77.                         Circle.class, Square.class, Line.class);
  78.         List<Shape> shapes = IntStream.range(0, 10)
  79.                 .mapToObj(i -> Shape.randomFactory())
  80.                 .collect(Collectors.toList());
  81.         // Set all the static colors to GREEN:
  82.         shapes.forEach(s -> s.setColor(Color.GREEN));
  83.         // Save the state vector:
  84.         try(
  85.                 ObjectOutputStream out =
  86.                         new ObjectOutputStream(
  87.                                 new FileOutputStream("CADState.dat"))
  88.         ) {
  89.             out.writeObject(shapeTypes);
  90.             Line.serializeStaticState(out);
  91.             out.writeObject(shapes);
  92.         } catch(IOException e) {
  93.             throw new RuntimeException(e);
  94.         }
  95.         // Display the shapes:
  96.         System.out.println(shapes);
  97.     }
  98. }

输出为：

  1. [class Circlecolor[GREEN] xPos[58] yPos[55] dim[93]
  2. , class Squarecolor[GREEN] xPos[61] yPos[61] dim[29]
  3. , class Linecolor[GREEN] xPos[68] yPos[0] dim[22]
  4. , class Circlecolor[GREEN] xPos[7] yPos[88] dim[28]
  5. , class Squarecolor[GREEN] xPos[51] yPos[89] dim[9]
  6. , class Linecolor[GREEN] xPos[78] yPos[98] dim[61]
  7. , class Circlecolor[GREEN] xPos[20] yPos[58] dim[16]
  8. , class Squarecolor[GREEN] xPos[40] yPos[11] dim[22]
  9. , class Linecolor[GREEN] xPos[4] yPos[83] dim[6]
  10. , class Circlecolor[GREEN] xPos[75] yPos[10] dim[42]
  11. ]

Shape 类实现了 Serializable，所以任何自 Shape 继承的类也都会自动是 Serializable 的。每个 Shape 都含有数据，而且每个派生自 Shape 的类都包含一个 static 字段，用来确定各种 Shape 类型的颜色（如果将 static 字段置入基类，只会产生一个 static 字段，因为 static 字段不能在派生类中复制）。可对基类中的方法进行重载，以便为不同的类型设置颜色（static 方法不会动态绑定，所以这些都是普通的方法）。每次调用 randomFactory() 方法时，它都会使用不同的随机数作为 Shape 的数据，从而创建不同的 Shape。

在 main() 中，一个 ArrayList 用于保存 Class 对象，而另一个用于保存几何形状。

恢复对象相当直观：

  1. // serialization/RecoverCADState.java
  2. // Restoring the state of the fictitious CAD system
  3. // {RunFirst: AStoreCADState}
  4. import java.io.*;
  5. import java.util.*;
  6. public class RecoverCADState {
  7.     @SuppressWarnings("unchecked")
  8.     public static void main(String[] args) {
  9.         try(
  10.                 ObjectInputStream in =
  11.                         new ObjectInputStream(
  12.                                 new FileInputStream("CADState.dat"))
  13.         ) {
  14. // Read in the same order they were written:
  15.             List<Class<? extends Shape>> shapeTypes =
  16.                     (List<Class<? extends Shape>>)in.readObject();
  17.             Line.deserializeStaticState(in);
  18.             List<Shape> shapes =
  19.                     (List<Shape>)in.readObject();
  20.             System.out.println(shapes);
  21.         } catch(IOException | ClassNotFoundException e) {
  22.             throw new RuntimeException(e);
  23.         }
  24.     }
  25. }

输出为：

  1. [class Circlecolor[RED] xPos[58] yPos[55] dim[93]
  2. , class Squarecolor[RED] xPos[61] yPos[61] dim[29]
  3. , class Linecolor[GREEN] xPos[68] yPos[0] dim[22]
  4. , class Circlecolor[RED] xPos[7] yPos[88] dim[28]
  5. , class Squarecolor[RED] xPos[51] yPos[89] dim[9]
  6. , class Linecolor[GREEN] xPos[78] yPos[98] dim[61]
  7. , class Circlecolor[RED] xPos[20] yPos[58] dim[16]
  8. , class Squarecolor[RED] xPos[40] yPos[11] dim[22]
  9. , class Linecolor[GREEN] xPos[4] yPos[83] dim[6]
  10. , class Circlecolor[RED] xPos[75] yPos[10] dim[42]
  11. ]

可以看到，xPos，yPos 以及 dim 的值都被成功地保存和恢复了，但是对 static 信息的读取却出现了问题。所有读回的颜色应该都是“3”，但是真实情况却并非如此。Circle 的值为 1（定义为 RED），而 Square 的值为 0（记住，它们是在构造器中被初始化的）。看上去似乎 static 数据根本没有被序列化！确实如此——尽管 Class 类是 Serializable 的，但它却不能按我们所期望的方式运行。所以假如想序列化 static 值，必须自己动手去实现。

这正是 Line 中的 serializeStaticState() 和 deserializeStaticState() 两个 static 方法的用途。可以看到，它们是作为存储和读取过程的一部分被显式地调用的。（注意必须维护写入序列化文件和从该文件中读回的顺序。）因此，为了使 CADStatejava 正确运转起来，你必须：

  1. 为几何形状添加 serializeStaticState() 和 deserializeStaticState()
  2. 移除 ArrayList shapeTypes 以及与之有关的所有代码。
  3. 在几何形状内添加对新的序列化和反序列化还原静态方法的调用。

另一个要注意的问题是安全，因为序列化也会将 private 数据保存下来。如果你关心安全问题，那么应将其标记成 transient，但是这之后，还必须设计一种安全的保存信息的方法，以便在执行恢复时可以复位那些 private 变量。

XML

对象序列化的一个重要限制是它只是 Java 的解决方案：只有 Java 程序才能反序列化这种对象。一种更具互操作性的解决方案是将数据转换为 XML 格式，这可以使其被各种各样的平台和语言使用。

因为 XML 十分流行，所以用它来编程时的各种选择不胜枚举，包括随 JDK 发布的 javax.xml.*类库。我选择使用 Elliotte Rusty Harold 的开源 XOM 类库（可从 www.xom.nu 下载并获得文档），因为它看起来最简单，同时也是最直观的用 Java 产生和修改 XML 的方式。另外，XOM 还强调了 XML 的正确性。

作为一个示例，假设有一个 APerson 对象，它包含姓和名，你想将它们序列化到 XML 中。下面的 APerson 类有一个 getXML() 方法，它使用 XOM 来产生被转换为 XML 的 Element 对象的 APerson 数据；还有一个构造器，接受 Element 并从中抽取恰当的 APerson 数据（注意，XML 示例都在它们自己的子目录中）：

  1. // serialization/APerson.java
  2. // Use the XOM library to write and read XML
  3. // nu.xom.Node comes from http://www.xom.nu
  4. import nu.xom.*;
  5. import java.io.*;
  6. import java.util.*;
  7. public class APerson {
  8.     private String first, last;
  9.     public APerson(String first, String last) {
  10.         this.first = first;
  11.         this.last = last;
  12.     }
  13.     // Produce an XML Element from this APerson object:
  14.     public Element getXML() {
  15.         Element person = new Element("person");
  16.         Element firstName = new Element("first");
  17.         firstName.appendChild(first);
  18.         Element lastName = new Element("last");
  19.         lastName.appendChild(last);
  20.         person.appendChild(firstName);
  21.         person.appendChild(lastName);
  22.         return person;
  23.     }
  24.     // Constructor restores a APerson from XML:
  25.     public APerson(Element person) {
  26.         first = person
  27.                 .getFirstChildElement("first").getValue();
  28.         last = person
  29.                 .getFirstChildElement("last").getValue();
  30.     }
  31.     @Override
  32.     public String toString() {
  33.         return first + " " + last;
  34.     }
  35.     // Make it human-readable:
  36.     public static void
  37.     format(OutputStream os, Document doc)
  38.             throws Exception {
  39.         Serializer serializer =
  40.                 new Serializer(os,"ISO-8859-1");
  41.         serializer.setIndent(4);
  42.         serializer.setMaxLength(60);
  43.         serializer.write(doc);
  44.         serializer.flush();
  45.     }
  46.     public static void main(String[] args) throws Exception {
  47.         List<APerson> people = Arrays.asList(
  48.                 new APerson("Dr. Bunsen", "Honeydew"),
  49.                 new APerson("Gonzo", "The Great"),
  50.                 new APerson("Phillip J.", "Fry"));
  51.         System.out.println(people);
  52.         Element root = new Element("people");
  53.         for(APerson p : people)
  54.             root.appendChild(p.getXML());
  55.         Document doc = new Document(root);
  56.         format(System.out, doc);
  57.         format(new BufferedOutputStream(
  58.                 new FileOutputStream("People.xml")), doc);
  59.     }
  60. }

输出为：

  1. [Dr. Bunsen Honeydew, Gonzo The Great, Phillip J. Fry]
  2. <?xml version="1.0" encoding="ISO-8859-1"?>
  3. <people>
  4.     <person>
  5.         <first>Dr. Bunsen</first>
  6.         <last>Honeydew</last>
  7.     </person>
  8.     <person>
  9.         <first>Gonzo</first>
  10.         <last>The Great</last>
  11.     </person>
  12.     <person>
  13.         <first>Phillip J.</first>
  14.         <last>Fry</last>
  15.     </person>
  16. </people>

XOM 的方法都具有相当的自解释性，可以在 XOM 文档中找到它们。XOM 还包含一个 Serializer 类，你可以在 format() 方法中看到它被用来将 XML 转换为更具可读性的格式。如果只调用 toXML()，那么所有东西都会混在一起，因此 Serializer 是一种便利工具。

从 XML 文件中反序列化 Person 对象也很简单：

  1. // serialization/People.java
  2. // nu.xom.Node comes from http://www.xom.nu
  3. // {RunFirst: APerson}
  4. import nu.xom.*;
  5. import java.io.File;
  6. import java.util.*;
  7. public class People extends ArrayList<APerson> {
  8.     public People(String fileName) throws Exception {
  9.         Document doc =
  10.                 new Builder().build(new File(fileName));
  11.         Elements elements =
  12.                 doc.getRootElement().getChildElements();
  13.         for(int i = 0; i < elements.size(); i++)
  14.             add(new APerson(elements.get(i)));
  15.     }
  16.     public static void main(String[] args) throws Exception {
  17.         People p = new People("People.xml");
  18.         System.out.println(p);
  19.     }
  20. }
  21. /* Output:
  22. [Dr. Bunsen Honeydew, Gonzo The Great, Phillip J. Fry]
  23. */

People 构造器使用 XOM 的 Builder.build() 方法打开并读取一个文件，而 getChildElements() 方法产生了一个 Elements 列表（不是标准的 Java List，只是一个拥有 size() 和 get() 方法的对象，因为 Harold 不想强制人们使用特定版本的 Java，但是仍旧希望使用类型安全的容器）。在这个列表中的每个 Element 都表示一个 Person 对象，因此它可以传递给第二个 Person 构造器。注意，这要求你提前知道 XML 文件的确切结构，但是这经常会有些问题。如果文件结构与你预期的结构不匹配，那么 XOM 将抛出异常。对你来说，如果你缺乏有关将来的 XML 结构的信息，那么就有可能会编写更复杂的代码去探测 XML 文档，而不是只对其做出假设。

为了获取这些示例去编译它们，你必须将 XOM 发布包中的 JAR 文件放置到你的类路径中。

这里只给出了用 Java 和 XOM 类库进行 XML 编程的简介，更详细的信息可以浏览 www.xom.nu 。