当前位置:七道奇文章资讯编程技术Java编程
日期:2011-03-22 16:17:00  来源:本站整理

java的对象串通[Java编程]

赞助商链接



  本文“java的对象串通[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();
    }
  }
} ///:~
更风趣的是,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构造.所以在一些特别的场所下,不得不混合利用两种范例的层次构造.
  以上是“java的对象串通[Java编程]”的内容,如果你对以上该文章内容感兴趣,你可以看看七道奇为您推荐以下文章:
  • 利用Javascript实现网页水印(非图片水印)
  • Java开辟环境的搭建
  • Ubuntu java安装与配置
  • 办理Ubuntu 10.04 Firefox3.6 Java浏览器插件不工作的问
  • Ubuntu重装后Java环境的设置
  • Sun Java进入Ubuntu 10.10软件中央
  • Ubuntu 10.10配置Java开辟环境
  • 在Ubuntu 10.10中配置Java环境变量的办法
  • Ubuntu下Java环境的搭建
  • Ubuntu 10.04 下安装 Java, JRE
  • Ubuntu 10.04下的搭建SUN JAVA开辟环境
  • Ubuntu 12.04安装java7
  • 本文地址: 与您的QQ/BBS好友分享!
    • 好的评价 如果您觉得此文章好,就请您
        0%(0)
    • 差的评价 如果您觉得此文章差,就请您
        0%(0)

    文章评论评论内容只代表网友观点,与本站立场无关!

       评论摘要(共 0 条,得分 0 分,平均 0 分) 查看完整评论
    Copyright © 2020-2022 www.xiamiku.com. All Rights Reserved .