# 10.9 对象序列化
Java 1.1增添了一种有趣的特性，名为“对象序列化”（Object Serialization）。它面向那些实现了`Serializable`接口的对象，可将它们转换成一系列字节，并可在以后完全恢复回原来的样子。这一过程亦可通过网络进行。这意味着序列化机制能自动补偿操作系统间的差异。换句话说，可以先在Windows机器上创建一个对象，对其序列化，然后通过网络发给一台Unix机器，然后在那里准确无误地重新“装配”。不必关心数据在不同机器上如何表示，也不必关心字节的顺序或者其他任何细节。
就其本身来说，对象的序列化是非常有趣的，因为利用它可以实现“有限持久化”。请记住“持久化”意味着对象的“生存时间”并不取决于程序是否正在执行——它存在或“生存”于程序的每一次调用之间。通过序列化一个对象，将其写入磁盘，以后在程序重新调用时重新恢复那个对象，就能圆满实现一种“持久”效果。之所以称其为“有限”，是因为不能用某种`persistent`（持久）关键字简单地地定义一个对象，并让系统自动照看其他所有细节问题（尽管将来可能成为现实）。相反，必须在自己的程序中明确地序列化和组装对象。
语言里增加了对象序列化的概念后，可提供对两种主要特性的支持。Java 1.1的“远程方法调用”（RMI）使本来存在于其他机器的对象可以表现出好象就在本地机器上的行为。将消息发给远程对象时，需要通过对象序列化来传输参数和返回值。RMI将在第15章作具体讨论。
对象的序列化也是Java Beans必需的，后者由Java 1.1引入。使用一个Bean时，它的状态信息通常在设计期间配置好。程序启动以后，这种状态信息必须保存下来，以便程序启动以后恢复；具体工作由对象序列化完成。
对象的序列化处理非常简单，只需对象实现了`Serializable`接口即可（该接口仅是一个标记，没有方法）。在Java 1.1中，许多标准库类都发生了改变，以便能够序列化——其中包括用于基本数据类型的全部包装器、所有集合类以及其他许多东西。甚至`Class`对象也可以序列化（第11章讲述了具体实现过程）。
为序列化一个对象，首先要创建某些`OutputStream`对象，然后将其封装到`ObjectOutputStream`对象内。此时，只需调用`writeObject()`即可完成对象的序列化，并将其发送给`OutputStream`。相反的过程是将一个`InputStream`封装到`ObjectInputStream`内，然后调用`readObject()`。和往常一样，我们最后获得的是指向一个向上转换`Object`的引用，所以必须向下转换，以便能够直接设置。
对象序列化特别“聪明”的一个地方是它不仅保存了对象的“全景图”，而且能追踪对象内包含的所有引用并保存那些对象；接着又能对每个对象内包含的引用进行追踪；以此类推。我们有时将这种情况称为“对象网”，单个对象可与之建立连接。而且它还包含了对象的引用数组以及成员对象。若必须自行操纵一套对象序列化机制，那么在代码里追踪所有这些链接时可能会显得非常麻烦。在另一方面，由于Java对象的序列化似乎找不出什么缺点，所以请尽量不要自己动手，让它用优化的算法自动维护整个对象网。下面这个例子对序列化机制进行了测试。它建立了许多链接对象的一个`Worm`（蠕虫），每个对象都与`Worm`中的下一段链接，同时又与属于不同类（`Data`）的对象引用数组链接：
```
//: Worm.java
// Demonstrates object serialization in Java 1.1
import java.io.*;
class Data implements Serializable {
private int i;
Data(int x) { i = x; }
public String toString() {
return Integer.toString(i);
}
}
public class Worm implements Serializable {
// Generate a random int value:
private static int r() {
return (int)(Math.random() * 10);
}
private Data[] d = {
new Data(r()), new Data(r()), new Data(r())
};
private Worm next;
private char c;
// Value of i == number of segments
Worm(int i, char x) {
System.out.println(" Worm constructor: " + i);
c = x;
if(--i > 0)
next = new Worm(i, (char)(x + 1));
}
Worm() {
System.out.println("Default constructor");
}
public String toString() {
String s = ":" + c + "(";
for(int i = 0; i < d.length; i++)
s += d[i].toString();
s += ")";
if(next != null)
s += next.toString();
return s;
}
public static void main(String[] args) {
Worm w = new Worm(6, 'a');
System.out.println("w = " + w);
try {
ObjectOutputStream out =
new ObjectOutputStream(
new FileOutputStream("worm.out"));
out.writeObject("Worm storage");
out.writeObject(w);
out.close(); // Also flushes output
ObjectInputStream in =
new ObjectInputStream(
new FileInputStream("worm.out"));
String s = (String)in.readObject();
Worm w2 = (Worm)in.readObject();
System.out.println(s + ", w2 = " + w2);
} catch(Exception e) {
e.printStackTrace();
}
try {
ByteArrayOutputStream bout =
new ByteArrayOutputStream();
ObjectOutputStream out =
new ObjectOutputStream(bout);
out.writeObject("Worm storage");
out.writeObject(w);
out.flush();
ObjectInputStream in =
new ObjectInputStream(
new ByteArrayInputStream(
bout.toByteArray()));
String s = (String)in.readObject();
Worm w3 = (Worm)in.readObject();
System.out.println(s + ", w3 = " + w3);
} catch(Exception e) {
e.printStackTrace();
}
}
} ///:~
```
更有趣的是，`Worm`内的`Data`对象数组是用随机数字初始化的（这样便不用怀疑编译器保留了某种原始信息）。每个`Worm`段都用一个`Char`标记。这个`Char`是在重复生成链接的`Worm`列表时自动产生的。创建一个`Worm`时，需告诉构造器希望它有多长。为产生下一个引用（`next`），它总是用减去1的长度来调用`Worm`构造器。最后一个`next`引用则保持为`null`（空），表示已抵达`Worm`的尾部。
上面的所有操作都是为了加深事情的复杂程度，加大对象序列化的难度。然而，真正的序列化过程却是非常简单的。一旦从另外某个流里创建了`ObjectOutputStream`，`writeObject()`就会序列化对象。注意也可以为一个`String`调用`writeObject()`。亦可使用与`DataOutputStream`相同的方法写入所有基本数据类型（它们有相同的接口）。
有两个单独的`try`块看起来是类似的。第一个读写的是文件，而另一个读写的是一个`ByteArray`（字节数组）。可利用对任何`DataInputStream`或者`DataOutputStream`的序列化来读写特定的对象；正如在关于连网的那一章会讲到的那样，这些对象甚至包括网络。一次循环后的输出结果如下：
```
Worm constructor: 6
Worm constructor: 5
Worm constructor: 4
Worm constructor: 3
Worm constructor: 2
Worm constructor: 1
w = :a(262):b(100):c(396):d(480):e(316):f(398)
Worm storage, w2 = :a(262):b(100):c(396):d(480):e(316):f(398)
Worm storage, w3 = :a(262):b(100):c(396):d(480):e(316):f(398)
```
可以看出，装配回原状的对象确实包含了原来那个对象里包含的所有链接。
注意在对一个`Serializable`（可序列化）对象进行重新装配的过程中，不会调用任何构造器（甚至默认构造器）。整个对象都是通过从`InputStream`中取得数据恢复的。
作为Java 1.1特性的一种，我们注意到对象的序列化并不属于新的`Reader`和`Writer`层次结构的一部分，而是沿用老式的`InputStream`和`OutputStream`结构。所以在一些特殊的场合下，不得不混合使用两种类型的层次结构。
## 10.9.1 寻找类
读者或许会奇怪为什么需要一个对象从它的序列化状态中恢复。举个例子来说，假定我们序列化一个对象，并通过网络将其作为文件传送给另一台机器。此时，位于另一台机器的程序可以只用文件目录来重新构造这个对象吗？
回答这个问题的最好方法就是做一个实验。下面这个文件位于本章的子目录下：
```
//: Alien.java
// A serializable class
import java.io.*;
public class Alien implements Serializable {
} ///:~
```
用于创建和序列化一个`Alien`对象的文件位于相同的目录下：
```
//: FreezeAlien.java
// Create a serialized output file
import java.io.*;
public class FreezeAlien {
public static void main(String[] args)
throws Exception {
ObjectOutput out =
new ObjectOutputStream(
new FileOutputStream("file.x"));
Alien zorcon = new Alien();
out.writeObject(zorcon);
}
} ///:~
```
该程序并不是捕获和控制异常，而是将异常简单、直接地传递到`main()`外部，这样便能在命令行报告它们。
程序编译并运行后，将结果产生的`file.x`复制到名为`xfiles`的子目录，代码如下：
```
//: ThawAlien.java
// Try to recover a serialized file without the
// class of object that's stored in that file.
package c10.xfiles;
import java.io.*;
public class ThawAlien {
public static void main(String[] args)
throws Exception {
ObjectInputStream in =
new ObjectInputStream(
new FileInputStream("file.x"));
Object mystery = in.readObject();
System.out.println(
mystery.getClass().toString());
}
} ///:~
```
该程序能打开文件，并成功读取`mystery`对象中的内容。然而，一旦尝试查找与对象有关的任何资料——这要求`Alien`的`Class`对象——Java虚拟机（JVM）便找不到`Alien.class`（除非它正好在类路径内，而本例理应相反）。这样就会得到一个名叫`ClassNotFoundException`的异常（同样地，若非能够校验`Alien`存在的证据，否则它等于消失）。
恢复了一个序列化的对象后，如果想对其做更多的事情，必须保证JVM能在本地类路径或者因特网的其他什么地方找到相关的`.class`文件。
## 10.9.2 序列化的控制
正如大家看到的那样，默认的序列化机制并不难操纵。然而，假若有特殊要求又该怎么办呢？我们可能有特殊的安全问题，不希望对象的某一部分序列化；或者某一个子对象完全不必序列化，因为对象恢复以后，那一部分需要重新创建。
此时，通过实现`Externalizable`接口，用它代替`Serializable`接口，便可控制序列化的具体过程。这个`Externalizable`接口扩展了`Serializable`，并增添了两个方法：`writeExternal()`和`readExternal()`。在序列化和重新装配的过程中，会自动调用这两个方法，以便我们执行一些特殊操作。
下面这个例子展示了`Externalizable`接口方法的简单应用。注意`Blip1`和`Blip2`几乎完全一致，除了极微小的差别（自己研究一下代码，看看是否能发现）：
```
//: Blips.java
// Simple use of Externalizable & a pitfall
import java.io.*;
import java.util.*;
class Blip1 implements Externalizable {
public Blip1() {
System.out.println("Blip1 Constructor");
}
public void writeExternal(ObjectOutput out)
throws IOException {
System.out.println("Blip1.writeExternal");
}
public void readExternal(ObjectInput in)
throws IOException, ClassNotFoundException {
System.out.println("Blip1.readExternal");
}
}
class Blip2 implements Externalizable {
Blip2() {
System.out.println("Blip2 Constructor");
}
public void writeExternal(ObjectOutput out)
throws IOException {
System.out.println("Blip2.writeExternal");
}
public void readExternal(ObjectInput in)
throws IOException, ClassNotFoundException {
System.out.println("Blip2.readExternal");
}
}
public class Blips {
public static void main(String[] args) {
System.out.println("Constructing objects:");
Blip1 b1 = new Blip1();
Blip2 b2 = new Blip2();
try {
ObjectOutputStream o =
new ObjectOutputStream(
new FileOutputStream("Blips.out"));
System.out.println("Saving objects:");
o.writeObject(b1);
o.writeObject(b2);
o.close();
// Now get them back:
ObjectInputStream in =
new ObjectInputStream(
new FileInputStream("Blips.out"));
System.out.println("Recovering b1:");
b1 = (Blip1)in.readObject();
// OOPS! Throws an exception:
//! System.out.println("Recovering b2:");
//! b2 = (Blip2)in.readObject();
} catch(Exception e) {
e.printStackTrace();
}
}
} ///:~
```
该程序输出如下：
```
Constructing objects:
Blip1 Constructor
Blip2 Constructor
Saving objects:
Blip1.writeExternal
Blip2.writeExternal
Recovering b1:
Blip1 Constructor
Blip1.readExternal
```
未恢复`Blip2`对象的原因是那样做会导致一个异常。你找出了`Blip1`和`Blip2`之间的区别吗？`Blip1`的构造器是“公共的”（`public`），`Blip2`的构造器则不然，这样便会在恢复时造成异常。试试将`Blip2`的构造器属性变成`public`，然后删除`//!`注释标记，看看是否能得到正确的结果。
恢复`b1`后，会调用`Blip1`默认构造器。这与恢复一个`Serializable`（可序列化）对象不同。在后者的情况下，对象完全以它保存下来的二进制位为基础恢复，不存在构造器调用。而对一个`Externalizable`对象，所有普通的默认构建行为都会发生（包括在字段定义时的初始化），而且会调用`readExternal()`。必须注意这一事实——特别注意所有默认的构建行为都会进行——否则很难在自己的`Externalizable`对象中产生正确的行为。
下面这个例子揭示了保存和恢复一个`Externalizable`对象必须做的全部事情：
```
//: Blip3.java
// Reconstructing an externalizable object
import java.io.*;
import java.util.*;
class Blip3 implements Externalizable {
int i;
String s; // No initialization
public Blip3() {
System.out.println("Blip3 Constructor");
// s, i not initialized
}
public Blip3(String x, int a) {
System.out.println("Blip3(String x, int a)");
s = x;
i = a;
// s & i initialized only in non-default
// constructor.
}
public String toString() { return s + i; }
public void writeExternal(ObjectOutput out)
throws IOException {
System.out.println("Blip3.writeExternal");
// You must do this:
out.writeObject(s); out.writeInt(i);
}
public void readExternal(ObjectInput in)
throws IOException, ClassNotFoundException {
System.out.println("Blip3.readExternal");
// You must do this:
s = (String)in.readObject();
i =in.readInt();
}
public static void main(String[] args) {
System.out.println("Constructing objects:");
Blip3 b3 = new Blip3("A String ", 47);
System.out.println(b3.toString());
try {
ObjectOutputStream o =
new ObjectOutputStream(
new FileOutputStream("Blip3.out"));
System.out.println("Saving object:");
o.writeObject(b3);
o.close();
// Now get it back:
ObjectInputStream in =
new ObjectInputStream(
new FileInputStream("Blip3.out"));
System.out.println("Recovering b3:");
b3 = (Blip3)in.readObject();
System.out.println(b3.toString());
} catch(Exception e) {
e.printStackTrace();
}
}
} ///:~
```
其中，字段`s`和`i`只在第二个构造器中初始化，不关默认构造器的事。这意味着假如不在`readExternal`中初始化`s`和`i`，它们就会成为`null`（因为在对象创建的第一步中已将对象的存储空间清除为1）。若注释掉跟随于`"You must do this"`后面的两行代码，并运行程序，就会发现当对象恢复以后，`s`是`null`，而`i`是零。
若从一个`Externalizable`对象继承，通常需要调用`writeExternal()`和`readExternal()`的基类版本，以便正确地保存和恢复基类组件。
所以为了让一切正常运作起来，千万不可仅在writeExternal()方法执行期间写入对象的重要数据（没有默认的行为可用来为一个`Externalizable`对象写入所有成员对象）的，而是必须在`readExternal()`方法中也恢复那些数据。初次操作时可能会有些不习惯，因为`Externalizable`对象的默认构建行为使其看起来似乎正在进行某种存储与恢复操作。但实情并非如此。
(1) `transient`（临时）关键字
控制序列化过程时，可能有一个特定的子对象不愿让Java的序列化机制自动保存与恢复。一般地，若那个子对象包含了不想序列化的敏感信息（如密码），就会面临这种情况。即使那种信息在对象中具有`private`（私有）属性，但一旦经序列化处理，人们就可以通过读取一个文件，或者拦截网络传输得到它。
为防止对象的敏感部分被序列化，一个办法是将自己的类实现为`Externalizable`，就象前面展示的那样。这样一来，没有任何东西可以自动序列化，只能在`writeExternal()`明确序列化那些需要的部分。
然而，若操作的是一个`Serializable`对象，所有序列化操作都会自动进行。为解决这个问题，可以用`transient`（临时）逐个字段地关闭序列化，它的意思是“不要麻烦你（指自动机制）保存或恢复它了——我会自己处理的”。
例如，假设一个`Login`对象包含了与一个特定的登录会话有关的信息。校验登录的合法性时，一般都想将数据保存下来，但不包括密码。为做到这一点，最简单的办法是实现`Serializable`，并将`password`字段设为`transient`。下面是具体的代码：
```
//: Logon.java
// Demonstrates the "transient" keyword
import java.io.*;
import java.util.*;
class Logon implements Serializable {
private Date date = new Date();
private String username;
private transient String password;
Logon(String name, String pwd) {
username = name;
password = pwd;
}
public String toString() {
String pwd =
(password == null) ? "(n/a)" : password;
return "logon info: \n " +
"username: " + username +
"\n date: " + date.toString() +
"\n password: " + pwd;
}
public static void main(String[] args) {
Logon a = new Logon("Hulk", "myLittlePony");
System.out.println( "logon a = " + a);
try {
ObjectOutputStream o =
new ObjectOutputStream(
new FileOutputStream("Logon.out"));
o.writeObject(a);
o.close();
// Delay:
int seconds = 5;
long t = System.currentTimeMillis()
+ seconds * 1000;
while(System.currentTimeMillis() < t)
;
// Now get them back:
ObjectInputStream in =
new ObjectInputStream(
new FileInputStream("Logon.out"));
System.out.println(
"Recovering object at " + new Date());
a = (Logon)in.readObject();
System.out.println( "logon a = " + a);
} catch(Exception e) {
e.printStackTrace();
}
}
} ///:~
```
可以看到，其中的`date`和`username`字段保持原始状态（未设成`transient`），所以会自动序列化。然而，`password`被设为`transient`，所以不会自动保存到磁盘；另外，自动序列化机制也不会作恢复它的尝试。输出如下：
```
logon a = logon info:
username: Hulk
date: Sun Mar 23 18:25:53 PST 1997
password: myLittlePony
Recovering object at Sun Mar 23 18:25:59 PST 1997
logon a = logon info:
username: Hulk
date: Sun Mar 23 18:25:53 PST 1997
password: (n/a)
```
一旦对象恢复成原来的样子，`password`字段就会变成`null`。注意必须用`toString()`检查`password`是否为`null`，因为若用重载的`+`运算符来装配一个`String`对象，而且那个运算符遇到一个`null`引用，就会造成一个名为`NullPointerException`的异常（新版Java可能会提供避免这个问题的代码）。
我们也发现`date`字段被保存到磁盘，并从磁盘恢复，没有重新生成。
由于`Externalizable`对象默认时不保存它的任何字段，所以`transient`关键字只能伴随`Serializable`使用。
(2) `Externalizable`的替代方法
若不是特别在意要实现`Externalizable`接口，还有另一种方法可供选用。我们可以实现`Serializable`接口，并添加（注意是“添加”，而非“覆盖”或者“实现”）名为`writeObject()`和`readObject()`的方法。一旦对象被序列化或者重新装配，就会分别调用那两个方法。也就是说，只要提供了这两个方法，就会优先使用它们，而不考虑默认的序列化机制。
这些方法必须含有下列准确的签名：
```
private void
writeObject(ObjectOutputStream stream)
throws IOException;
private void
readObject(ObjectInputStream stream)
throws IOException, ClassNotFoundException
```
从设计的角度出发，情况变得有些扑朔迷离。首先，大家可能认为这些方法不属于基类或者`Serializable`接口的一部分，它们应该在自己的接口中得到定义。但请注意它们被定义成`private`，这意味着它们只能由这个类的其他成员调用。然而，我们实际并不从这个类的其他成员中调用它们，而是由`ObjectOutputStream`和`ObjectInputStream`的`writeObject()`及`readObject()`方法来调用我们对象的`writeObject()`和`readObject()`方法（注意我在这里用了很大的抑制力来避免使用相同的方法名——因为怕混淆）。大家可能奇怪`ObjectOutputStream`和`ObjectInputStream`如何有权访问我们的类的`private`方法——只能认为这是序列化机制玩的一个把戏。
在任何情况下，接口中的定义的任何东西都会自动具有`public`属性，所以假若`writeObject()`和`readObject()`必须为`private`，那么它们不能成为接口（`interface`）的一部分。但由于我们准确地加上了签名，所以最终的效果实际与实现一个接口是相同的。
看起来似乎我们调用`ObjectOutputStream.writeObject()`的时候，我们传递给它的`Serializable`对象似乎会被检查是否实现了自己的`writeObject()`。若答案是肯定的是，便会跳过常规的序列化过程，并调用`writeObject()`。`readObject()`也会遇到同样的情况。
还存在另一个问题。在我们的`writeObject()`内部，可以调用`defaultWriteObject()`，从而决定采取默认的`writeObject()`行动。类似地，在`readObject()`内部，可以调用`defaultReadObject()`。下面这个简单的例子演示了如何对一个`Serializable`对象的存储与恢复进行控制：
```
//: SerialCtl.java
// Controlling serialization by adding your own
// writeObject() and readObject() methods.
import java.io.*;
public class SerialCtl implements Serializable {
String a;
transient String b;
public SerialCtl(String aa, String bb) {
a = "Not Transient: " + aa;
b = "Transient: " + bb;
}
public String toString() {
return a + "\n" + b;
}
private void
writeObject(ObjectOutputStream stream)
throws IOException {
stream.defaultWriteObject();
stream.writeObject(b);
}
private void
readObject(ObjectInputStream stream)
throws IOException, ClassNotFoundException {
stream.defaultReadObject();
b = (String)stream.readObject();
}
public static void main(String[] args) {
SerialCtl sc =
new SerialCtl("Test1", "Test2");
System.out.println("Before:\n" + sc);
ByteArrayOutputStream buf =
new ByteArrayOutputStream();
try {
ObjectOutputStream o =
new ObjectOutputStream(buf);
o.writeObject(sc);
// Now get it back:
ObjectInputStream in =
new ObjectInputStream(
new ByteArrayInputStream(
buf.toByteArray()));
SerialCtl sc2 = (SerialCtl)in.readObject();
System.out.println("After:\n" + sc2);
} catch(Exception e) {
e.printStackTrace();
}
}
} ///:~
```
在这个例子中，一个`String`保持原始状态，其他设为`transient`（临时），以便证明非临时字段会被`defaultWriteObject()`方法自动保存，而`transient`字段必须在程序中明确保存和恢复。字段是在构造器内部初始化的，而不是在定义的时候，这证明了它们不会在重新装配的时候被某些自动化机制初始化。
若准备通过默认机制写入对象的非`transient`部分，那么必须调用`defaultWriteObject()`，令其作为`writeObject()`中的第一个操作；并调用`defaultReadObject()`，令其作为`readObject()`的第一个操作。这些都是不常见的调用方法。举个例子来说，当我们为一个`ObjectOutputStream`调用`defaultWriteObject()`的时候，而且没有为其传递参数，就需要采取这种操作，使其知道对象的引用以及如何写入所有非`transient`的部分。这种做法非常不便。
`transient`对象的存储与恢复采用了我们更熟悉的代码。现在考虑一下会发生一些什么事情。在`main()`中会创建一个`SerialCtl`对象，随后会序列化到一个`ObjectOutputStream`里（注意这种情况下使用的是一个缓冲区，而非文件——与`ObjectOutputStream`完全一致）。正式的序列化操作是在下面这行代码里发生的：
```
o.writeObject(sc);
```
其中，`writeObject()`方法必须核查`sc`，判断它是否有自己的`writeObject()`方法（不是检查它的接口——它根本就没有，也不是检查类的类型，而是利用反射方法实际搜索方法）。若答案是肯定的，就使用那个方法。类似的情况也会在`readObject()`上发生。或许这是解决问题唯一实际的方法，但确实显得有些古怪。
(3) 版本问题
有时候可能想改变一个可序列化的类的版本（比如原始类的对象可能保存在数据库中）。尽管这种做法得到了支持，但一般只应在非常特殊的情况下才用它。此外，它要求操作者对背后的原理有一个比较深的认识，而我们在这里还不想达到这种深度。JDK 1.1的HTML文档对这一主题进行了非常全面的论述（可从Sun公司下载，但可能也成了Java开发包联机文档的一部分）。
## 10.9.3 利用“持久性”
一个比较诱人的想法是用序列化技术保存程序的一些状态信息，从而将程序方便地恢复到以前的状态。但在具体实现以前，有些问题是必须解决的。如果两个对象都有指向第三个对象的引用，该如何对这两个对象序列化呢？如果从两个对象序列化后的状态恢复它们，第三个对象的引用只会出现在一个对象身上吗？如果将这两个对象序列化成独立的文件，然后在代码的不同部分重新装配它们，又会得到什么结果呢？
下面这个例子对上述问题进行了很好的说明：
```
//: MyWorld.java
import java.io.*;
import java.util.*;
class House implements Serializable {}
class Animal implements Serializable {
String name;
House preferredHouse;
Animal(String nm, House h) {
name = nm;
preferredHouse = h;
}
public String toString() {
return name + "[" + super.toString() +
"], " + preferredHouse + "\n";
}
}
public class MyWorld {
public static void main(String[] args) {
House house = new House();
Vector animals = new Vector();
animals.addElement(
new Animal("Bosco the dog", house));
animals.addElement(
new Animal("Ralph the hamster", house));
animals.addElement(
new Animal("Fronk the cat", house));
System.out.println("animals: " + animals);
try {
ByteArrayOutputStream buf1 =
new ByteArrayOutputStream();
ObjectOutputStream o1 =
new ObjectOutputStream(buf1);
o1.writeObject(animals);
o1.writeObject(animals); // Write a 2nd set
// Write to a different stream:
ByteArrayOutputStream buf2 =
new ByteArrayOutputStream();
ObjectOutputStream o2 =
new ObjectOutputStream(buf2);
o2.writeObject(animals);
// Now get them back:
ObjectInputStream in1 =
new ObjectInputStream(
new ByteArrayInputStream(
buf1.toByteArray()));
ObjectInputStream in2 =
new ObjectInputStream(
new ByteArrayInputStream(
buf2.toByteArray()));
Vector animals1 = (Vector)in1.readObject();
Vector animals2 = (Vector)in1.readObject();
Vector animals3 = (Vector)in2.readObject();
System.out.println("animals1: " + animals1);
System.out.println("animals2: " + animals2);
System.out.println("animals3: " + animals3);
} catch(Exception e) {
e.printStackTrace();
}
}
} ///:~
```
这里一件有趣的事情是也许是能针对一个字节数组应用对象的序列化，从而实现对任何`Serializable`（可序列化）对象的一个“全面复制”（全面复制意味着复制的是整个对象网，而不仅是基本对象和它的引用）。复制问题将在第12章进行全面讲述。
`Animal`对象包含了类型为`House`的字段。在`main()`中，会创建这些`Animal`的一个`Vector`，并对其序列化两次，分别送入两个不同的数据流内。这些数据重新装配并打印出来后，可看到下面这样的结果（对象在每次运行时都会处在不同的内存位置，所以每次运行的结果有区别）：
```
animals: [Bosco the dog[Animal@1cc76c], House@1cc769
, Ralph the hamster[Animal@1cc76d], House@1cc769
, Fronk the cat[Animal@1cc76e], House@1cc769
]
animals1: [Bosco the dog[Animal@1cca0c], House@1cca16
, Ralph the hamster[Animal@1cca17], House@1cca16
, Fronk the cat[Animal@1cca1b], House@1cca16
]
animals2: [Bosco the dog[Animal@1cca0c], House@1cca16
, Ralph the hamster[Animal@1cca17], House@1cca16
, Fronk the cat[Animal@1cca1b], House@1cca16
]
animals3: [Bosco the dog[Animal@1cca52], House@1cca5c
, Ralph the hamster[Animal@1cca5d], House@1cca5c
, Fronk the cat[Animal@1cca61], House@1cca5c
]
```
当然，我们希望装配好的对象有与原来不同的地址。但注意在`animals1`和`animals2`中出现了相同的地址，其中包括共享的、对`House`对象的引用。在另一方面，当`animals3`恢复以后，系统没有办法知道另一个流内的对象是第一个流内对象的化身，所以会产生一个完全不同的对象网。
只要将所有东西都序列化到单独一个数据流里，就能恢复获得与以前写入时完全一样的对象网，不会不慎造成对象的重复。当然，在写第一个和最后一个对象的时间之间，可改变对象的状态，但那必须由我们明确采取操作——序列化时，对象会采用它们当时的任何状态（包括它们与其他对象的连接关系）写入。
若想保存系统状态，最安全的做法是当作一种“微观”操作序列化。如果序列化了某些东西，再去做其他一些工作，再来序列化更多的东西，以此类推，那么最终将无法安全地保存系统状态。相反，应将构成系统状态的所有对象都置入单个集合内，并在一次操作里完成那个集合的写入。这样一来，同样只需一次方法调用，即可成功恢复之。
下面这个例子是一套假想的计算机辅助设计（CAD）系统，对这一方法进行了很好的演示。此外，它还为我们引入了`static`字段的问题——如留意联机文档，就会发现`Class`是`Serializable`（可序列化）的，所以只需简单地序列化`Class`对象，就能实现`static`字段的保存。这无论如何都是一种明智的做法。
```
//: CADState.java
// Saving and restoring the state of a
// pretend CAD system.
import java.io.*;
import java.util.*;
abstract class Shape implements Serializable {
public static final int
RED = 1, BLUE = 2, GREEN = 3;
private int xPos, yPos, dimension;
private static Random r = new Random();
private static int counter = 0;
abstract public void setColor(int newColor);
abstract public int getColor();
public Shape(int xVal, int yVal, int dim) {
xPos = xVal;
yPos = yVal;
dimension = dim;
}
public String toString() {
return getClass().toString() +
" color[" + getColor() +
"] xPos[" + xPos +
"] yPos[" + yPos +
"] dim[" + dimension + "]\n";
}
public static Shape randomFactory() {
int xVal = r.nextInt() % 100;
int yVal = r.nextInt() % 100;
int dim = r.nextInt() % 100;
switch(counter++ % 3) {
default:
case 0: return new Circle(xVal, yVal, dim);
case 1: return new Square(xVal, yVal, dim);
case 2: return new Line(xVal, yVal, dim);
}
}
}
class Circle extends Shape {
private static int color = RED;
public Circle(int xVal, int yVal, int dim) {
super(xVal, yVal, dim);
}
public void setColor(int newColor) {
color = newColor;
}
public int getColor() {
return color;
}
}
class Square extends Shape {
private static int color;
public Square(int xVal, int yVal, int dim) {
super(xVal, yVal, dim);
color = RED;
}
public void setColor(int newColor) {
color = newColor;
}
public int getColor() {
return color;
}
}
class Line extends Shape {
private static int color = RED;
public static void
serializeStaticState(ObjectOutputStream os)
throws IOException {
os.writeInt(color);
}
public static void
deserializeStaticState(ObjectInputStream os)
throws IOException {
color = os.readInt();
}
public Line(int xVal, int yVal, int dim) {
super(xVal, yVal, dim);
}
public void setColor(int newColor) {
color = newColor;
}
public int getColor() {
return color;
}
}
public class CADState {
public static void main(String[] args)
throws Exception {
Vector shapeTypes, shapes;
if(args.length == 0) {
shapeTypes = new Vector();
shapes = new Vector();
// Add handles to the class objects:
shapeTypes.addElement(Circle.class);
shapeTypes.addElement(Square.class);
shapeTypes.addElement(Line.class);
// Make some shapes:
for(int i = 0; i < 10; i++)
shapes.addElement(Shape.randomFactory());
// Set all the static colors to GREEN:
for(int i = 0; i < 10; i++)
((Shape)shapes.elementAt(i))
.setColor(Shape.GREEN);
// Save the state vector:
ObjectOutputStream out =
new ObjectOutputStream(
new FileOutputStream("CADState.out"));
out.writeObject(shapeTypes);
Line.serializeStaticState(out);
out.writeObject(shapes);
} else { // There's a command-line argument
ObjectInputStream in =
new ObjectInputStream(
new FileInputStream(args[0]));
// Read in the same order they were written:
shapeTypes = (Vector)in.readObject();
Line.deserializeStaticState(in);
shapes = (Vector)in.readObject();
}
// Display the shapes:
System.out.println(shapes);
}
} ///:~
```
`Shape`（几何形状）类“实现了可序列化”（`implements Serializable`），所以从`Shape`继承的任何东西也都会自动“可序列化”。每个`Shape`都包含了数据，而且每个派生的`Shape`类都包含了一个特殊的`static`字段，用于决定所有那些类型的`Shape`的颜色（如将一个`static`字段置入基类，结果只会产生一个字段，因为`static`字段未在派生类中复制）。可对基类中的方法进行覆盖处理，以便为不同的类型设置颜色（`static`方法不会动态绑定，所以这些都是普通的方法）。每次调用`randomFactory()`方法时，它都会创建一个不同的`Shape`（`Shape`值采用随机值）。
`Circle`（圆）和`Square`（矩形）属于对`Shape`的直接扩展；唯一的差别是`Circle`在定义时会初始化颜色，而`Square`在构造器中初始化。`Line`（直线）的问题将留到以后讨论。
在`main()`中，一个`Vector`用于容纳`Class`对象，而另一个用于容纳形状。若不提供相应的命令行参数，就会创建`shapeTypes Vector`，并添加`Class`对象。然后创建`shapes Vector`，并添加`Shape`对象。接下来，所有`static color`值都会设成`GREEN`，而且所有东西都会序列化到文件`CADState.out`。
若提供了一个命令行参数（假设`CADState.out`），便会打开那个文件，并用它恢复程序的状态。无论在哪种情况下，结果产生的`Shape`的`Vector`都会打印出来。下面列出它某一次运行的结果：
```
>java CADState
[class Circle color[3] xPos[-51] yPos[-99] dim[38]
, class Square color[3] xPos[2] yPos[61] dim[-46]
, class Line color[3] xPos[51] yPos[73] dim[64]
, class Circle color[3] xPos[-70] yPos[1] dim[16]
, class Square color[3] xPos[3] yPos[94] dim[-36]
, class Line color[3] xPos[-84] yPos[-21] dim[-35]
, class Circle color[3] xPos[-75] yPos[-43] dim[22]
, class Square color[3] xPos[81] yPos[30] dim[-45]
, class Line color[3] xPos[-29] yPos[92] dim[17]
, class Circle color[3] xPos[17] yPos[90] dim[-76]
]
>java CADState CADState.out
[class Circle color[1] xPos[-51] yPos[-99] dim[38]
, class Square color[0] xPos[2] yPos[61] dim[-46]
, class Line color[3] xPos[51] yPos[73] dim[64]
, class Circle color[1] xPos[-70] yPos[1] dim[16]
, class Square color[0] xPos[3] yPos[94] dim[-36]
, class Line color[3] xPos[-84] yPos[-21] dim[-35]
, class Circle color[1] xPos[-75] yPos[-43] dim[22]
, class Square color[0] xPos[81] yPos[30] dim[-45]
, class Line color[3] xPos[-29] yPos[92] dim[17]
, class Circle color[1] xPos[17] yPos[90] dim[-76]
]
```
从中可以看出，`xPos`，`yPos`以及`dim`的值都已成功保存和恢复出来。但在获取`static`信息时却出现了问题。所有“3”都已进入，但没有正常地出来。`Circle`有一个1值（定义为`RED`），而`Square`有一个0值（记住，它们是在构造器里初始化的）。看上去似乎`static`根本没有得到初始化！实情正是如此——尽管类`Class`是“可以序列化的”，但却不能按我们希望的工作。所以假如想序列化`static`值，必须亲自动手。
这正是`Line`中的`serializeStaticState()`和`deserializeStaticState()`两个`static`方法的用途。可以看到，这两个方法都是作为存储和恢复进程的一部分明确调用的（注意写入序列化文件和从中读回的顺序不能改变）。所以为了使`CADState.java`正确运行起来，必须采用下述三种方法之一：
(1) 为几何形状添加一个`serializeStaticState()`和`deserializeStaticState()`。
(2) 删除`Vector shapeTypes`以及与之有关的所有代码
(3) 在几何形状内添加对新序列化和撤消序列化静态方法的调用
要注意的另一个问题是安全，因为序列化处理也会将`private`数据保存下来。若有需要保密的字段，应将其标记成`transient`。但在这之后，必须设计一种安全的信息保存方法。这样一来，一旦需要恢复，就可以重设那些`private`变量。
- Java 编程思想
- 写在前面的话
- 引言
- 第1章 对象入门
- 1.1 抽象的进步
- 1.2 对象的接口
- 1.3 实现方案的隐藏
- 1.4 方案的重复使用
- 1.5 继承：重新使用接口
- 1.6 多态对象的互换使用
- 1.7 对象的创建和存在时间
- 1.8 异常控制：解决错误
- 1.9 多线程
- 1.10 永久性
- 1.11 Java和因特网
- 1.12 分析和设计
- 1.13 Java还是C++
- 第2章 一切都是对象
- 2.1 用引用操纵对象
- 2.2 所有对象都必须创建
- 2.3 绝对不要清除对象
- 2.4 新建数据类型：类
- 2.5 方法、参数和返回值
- 2.6 构建Java程序
- 2.7 我们的第一个Java程序
- 2.8 注释和嵌入文档
- 2.9 编码样式
- 2.10 总结
- 2.11 练习
- 第3章 控制程序流程
- 3.1 使用Java运算符
- 3.2 执行控制
- 3.3 总结
- 3.4 练习
- 第4章 初始化和清除
- 4.1 用构造器自动初始化
- 4.2 方法重载
- 4.3 清除：收尾和垃圾收集
- 4.4 成员初始化
- 4.5 数组初始化
- 4.6 总结
- 4.7 练习
- 第5章 隐藏实现过程
- 5.1 包：库单元
- 5.2 Java访问指示符
- 5.3 接口与实现
- 5.4 类访问
- 5.5 总结
- 5.6 练习
- 第6章 类复用
- 6.1 组合的语法
- 6.2 继承的语法
- 6.3 组合与继承的结合
- 6.4 到底选择组合还是继承
- 6.5 protected
- 6.6 累积开发
- 6.7 向上转换
- 6.8 final关键字
- 6.9 初始化和类装载
- 6.10 总结
- 6.11 练习
- 第7章 多态性
- 7.1 向上转换
- 7.2 深入理解
- 7.3 覆盖与重载
- 7.4 抽象类和方法
- 7.5 接口
- 7.6 内部类
- 7.7 构造器和多态性
- 7.8 通过继承进行设计
- 7.9 总结
- 7.10 练习
- 第8章 对象的容纳
- 8.1 数组
- 8.2 集合
- 8.3 枚举器（迭代器）
- 8.4 集合的类型
- 8.5 排序
- 8.6 通用集合库
- 8.7 新集合
- 8.8 总结
- 8.9 练习
- 第9章 异常差错控制
- 9.1 基本异常
- 9.2 异常的捕获
- 9.3 标准Java异常
- 9.4 创建自己的异常
- 9.5 异常的限制
- 9.6 用finally清除
- 9.7 构造器
- 9.8 异常匹配
- 9.9 总结
- 9.10 练习
- 第10章 Java IO系统
- 10.1 输入和输出
- 10.2 增添属性和有用的接口
- 10.3 本身的缺陷：RandomAccessFile
- 10.4 File类
- 10.5 IO流的典型应用
- 10.6 StreamTokenizer
- 10.7 Java 1.1的IO流
- 10.8 压缩
- 10.9 对象序列化
- 10.10 总结
- 10.11 练习
- 第11章 运行期类型识别
- 11.1 对RTTI的需要
- 11.2 RTTI语法
- 11.3 反射：运行期类信息
- 11.4 总结
- 11.5 练习
- 第12章 传递和返回对象
- 12.1 传递引用
- 12.2 制作本地副本
- 12.3 克隆的控制
- 12.4 只读类
- 12.5 总结
- 12.6 练习
- 第13章 创建窗口和程序片
- 13.1 为何要用AWT？
- 13.2 基本程序片
- 13.3 制作按钮
- 13.4 捕获事件
- 13.5 文本字段
- 13.6 文本区域
- 13.7 标签
- 13.8 复选框
- 13.9 单选钮
- 13.10 下拉列表
- 13.11 列表框
- 13.12 布局的控制
- 13.13 action的替代品
- 13.14 程序片的局限
- 13.15 视窗化应用
- 13.16 新型AWT
- 13.17 Java 1.1用户接口API
- 13.18 可视编程和Beans
- 13.19 Swing入门
- 13.20 总结
- 13.21 练习
- 第14章 多线程
- 14.1 反应灵敏的用户界面
- 14.2 共享有限的资源
- 14.3 堵塞
- 14.4 优先级
- 14.5 回顾runnable
- 14.6 总结
- 14.7 练习
- 第15章 网络编程
- 15.1 机器的标识
- 15.2 套接字
- 15.3 服务多个客户
- 15.4 数据报
- 15.5 一个Web应用
- 15.6 Java与CGI的沟通
- 15.7 用JDBC连接数据库
- 15.8 远程方法
- 15.9 总结
- 15.10 练习
- 第16章 设计模式
- 16.1 模式的概念
- 16.2 观察器模式
- 16.3 模拟垃圾回收站
- 16.4 改进设计
- 16.5 抽象的应用
- 16.6 多重分发
- 16.7 访问器模式
- 16.8 RTTI真的有害吗
- 16.9 总结
- 16.10 练习
- 第17章 项目
- 17.1 文字处理
- 17.2 方法查找工具
- 17.3 复杂性理论
- 17.4 总结
- 17.5 练习
- 附录A 使用非JAVA代码
- 附录B 对比C++和Java
- 附录C Java编程规则
- 附录D 性能
- 附录E 关于垃圾收集的一些话
- 附录F 推荐读物