java的工具串联

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();
    }
  }
} ///:~

#p#分页标题#e#

更有趣的是，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布局。所以在一些非凡的场所下，不得不殽杂利用两种范例的条理布局。