licheng700

BlogJava 首页 新随笔 联系 聚合 管理
  26 Posts :: 5 Stories :: 5 Comments :: 1 Trackbacks

2005年9月21日 #

 

jungleford如是说

    已经有一个多月没有搭理blog了,原因很多,譬如实验室的项目正在收工,巨忙;譬如找工作及其相关的事情;而且二月份大部分时间是陪老爹老妈,家里拨号的速度可想而知……但主要还是没有找到一个合适的topic,或者说这段时间懒了(临毕业前期综合症),净在看《汉武大帝》和历史方面的书,还有其它乱七八糟的闲书,就是没有认真地玩Java,哈哈!现在工作差不多落实了,好在不算太烂,小资青年jungleford的生活又开始步入正轨了!以上是新年里的一些废话。
    今天稍微聊一点关于“程序状态保存”方面的问题,我们很容易就会想到“序列化”(Serialization,有的书上又翻译为“顺序化”或者“串行化”,但“串行”一词总是让我联想到通信和硬件接口,所以我更习惯于“序列化”的叫法,何况这种叫法是有来头的,后面我会谈到这个名称的由来),当然,序列化是一种方便有效的数据存取方式,但它还有更加广泛的应用。广义上讲,就是讨论一下I/O的一些应用。

文件I/O:文件流→序列化

文件流
    文件操作是最简单最直接也是最容易想到的一种方式,我们说的文件操作不仅仅是通过FileInputStream/FileOutputStream这么“裸”的方式直接把数据写入到本地文件(像我以前写的一个扫雷的小游戏JavaMine就是这样保存一局的状态的),这样就比较“底层”了。

主要类与方法 描述
FileInputStream.read() 从本地文件读取二进制格式的数据
FileReader.read() 从本地文件读取字符(文本)数据
FileOutputStream.write() 保存二进制数据到本地文件
FileWriter.write() 保存字符数据到本地文件

XML
    和上面的单纯的I/O方式相比,XML就显得“高档”得多,以至于成为一种数据交换的标准。以DOM方式为例,它关心的是首先在内存中构造文档树,数据保存在某个结点上(可以是叶子结点,也可以是标签结点的属性),构造好了以后一次性的写入到外部文件,但我们只需要知道文件的位置,并不知道I/O是怎么操作的,XML操作方式可能多数人也实践过,所以这里也只列出相关的方法,供初学者预先了解一下。主要的包是javax.xml.parsersorg.w3c.domjavax.xml.transform

主要类与方法 描述
DocumentBuilderFactory.newDocumentBuilder().parse() 解析一个外部的XML文件,得到一个Document对象的DOM树
DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument() 初始化一棵DOM树
Document.getDocumentElement(). appendChild() 为一个标签结点添加一个子结点
Document.createTextNode() 生成一个字符串结点
Node.getChildNodes() 取得某个结点的所有下一层子结点
Node.removeChild() 删除某个结点的子结点
Document. getElementsByTagName() 查找所有指定名称的标签结点
Document.getElementById() 查找指定名称的一个标签结点,如果有多个符合,则返回某一个,通常是第一个
Element.getAttribute() 取得一个标签的某个属性的的值
Element.setAttribute() 设置一个标签的某个属性的的值
Element.removeAttribute() 删除一个标签的某个属性
TransformerFactory.newInstance().newTransformer().transform() 将一棵DOM树写入到外部XML文件

序列化
    使用基本的文件读写方式存取数据,如果我们仅仅保存相同类型的数据,则可以用同一种格式保存,譬如在我的JavaMine中保存一个盘局时,需要保存每一个方格的坐标、是否有地雷,是否被翻开等,这些信息组合成一个“复合类型”;相反,如果有多种不同类型的数据,那我们要么把它分解成若干部分,以相同类型(譬如String)保存,要么我们需要在程序中添加解析不同类型数据格式的逻辑,这就很不方便。于是我们期望用一种比较“高”的层次上处理数据,程序员应该花尽可能少的时间和代码对数据进行解析,事实上,序列化操作为我们提供了这样一条途径。
    序列化(Serialization)大家可能都有所接触,它可以把对象以某种特定的编码格式写入或从外部字节流(即ObjectInputStream/ObjectOutputStream)中读取。序列化一个对象非常之简单,仅仅实现一下Serializable接口即可,甚至都不用为它专门添加任何方法:

public class MySerial implements java.io.Serializable
{
  ...
}

但有一个条件:即你要序列化的类当中,它的每个属性都必须是是“可序列化”的。这句话说起来有点拗口,其实所有基本类型(就是int,char,boolean之类的)都是“可序列化”的,而你可以看看JDK文档,会发现很多类其实已经实现了Serializable(即已经是“可序列化”的了),于是这些类的对象以及基本数据类型都可以直接作为你需要序列化的那个类的内部属性。如果碰到了不是“可序列化”的属性怎么办?对不起,那这个属性的类还需要事先实现Serializable接口,如此递归,直到所有属性都是“可序列化”的

主要类与方法 描述
ObjectOutputStream.writeObject() 将一个对象序列化到外部字节流
ObjectInputStream.readObject() 从外部字节流读取并重新构造对象

    从实际应用上看来,“Serializable”这个接口并没有定义任何方法,仿佛它只是一个标记(或者说像是Java的关键字)而已,一旦虚拟机看到这个“标记”,就会尝试调用自身预定义的序列化机制,除非你在实现Serializable接口的同时还定义了私有的readObject()或writeObject()方法。这一点很奇怪。不过你要是不愿意让系统使用缺省的方式进行序列化,那就必须定义上面提到的两个方法:

public class MySerial implements java.io.Serializable
{
  private void writeObject(java.io.ObjectOutputStream out) throws IOException
  {
    ...
  }
  private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException
  {
    ...
  }
  ...
}

    譬如你可以在上面的writeObject()里调用默认的序列化方法ObjectOutputStream.defaultWriteObject();譬如你不愿意将某些敏感的属性和信息序列化,你也可以调用ObjectOutputStream.writeObject()方法明确指定需要序列化那些属性。关于用户可定制的序列化方法,我们将在后面提到。

Bean
    上面的序列化只是一种基本应用,你把一个对象序列化到外部文件以后,用notepad打开那个文件,只能从为数不多的一些可读字符中猜到这是有关这个类的信息文件,这需要你熟悉序列化文件的字节编码方式,那将是比较痛苦的(在《Core Java 2》第一卷里提到了相关编码方式,有兴趣的话可以查看参考资料),某些情况下我们可能需要被序列化的文件具有更好的可读性。另一方面,作为Java组件的核心概念“JavaBeans”,从JDK 1.4开始,其规范里也要求支持文本方式的“长期的持久化”(long-term persistence)。
    打开JDK文档java.beans包里的有一个名为“Encoder”的类,这就是一个可以序列化bean的实用类。和它相关的两个主要类有XMLEcoderXMLDecoder,显然,这是以XML文件的格式保存和读取bean的工具。他们的用法也很简单,和上面ObjectOutputStream/ObjectInputStream比较类似。

主要类与方法 描述
XMLEncoder.writeObject() 将一个对象序列化到外部字节流
XMLDecoder.readObject() 从外部字节流读取并重新构造对象

    如果一个bean是如下格式:

public class MyBean
{
  int i;
  char[] c;
  String s;
  ...(get和set操作省略)...
}

那么通过XMLEcoder序列化出来的XML文件具有这样的形式:

<?xml version="1.0" encoding="UTF-8"?>
<java version="1.4.0" class="java.beans.XMLDecoder">
  <object class="MyBean">
    <void property="i">
      <int>1</int>
    </void>
    <void property="c">
      <array class="char" length="3">
        <void index="0">
          <int>a</int>
        </void>
        <void index="1">
          <int>b</int>
        </void>
        <void index="2">
          <int>c</int>
        </void>
      </array>
    </void>
    <void property="s">
      <string>fox jump!</string>
    </void>
  </object>
</java>

    像AWTSwing中很多可视化组件都是bean,当然也是可以用这种方式序列化的,下面就是从JDK文档中摘录的一个JFrame序列化以后的XML文件:

<?xml version="1.0" encoding="UTF-8"?>
<java version="1.0" class="java.beans.XMLDecoder">
  <object class="javax.swing.JFrame">
    <void property="name">
      <string>frame1</string>
    </void>
    <void property="bounds">
      <object class="java.awt.Rectangle">
        <int>0</int>
        <int>0</int>
        <int>200</int>
        <int>200</int>
      </object>
    </void>
    <void property="contentPane">
      <void method="add">
        <object class="javax.swing.JButton">
          <void property="label">
            <string>Hello</string>
          </void>
        </object>
      </void>
    </void>
    <void property="visible">
      <boolean>true</boolean>
    </void>
  </object>
</java>

    因此但你想要保存的数据是一些不是太复杂的类型的话,把它做成bean再序列化也不失为一种方便的选择。

Properties
    在以前我总结的一篇关于集合框架的小文章里提到过,Properties是历史集合类的一个典型的例子,这里主要不是介绍它的集合特性。大家可能都经常接触一些配置文件,如Windows的ini文件,Apache的conf文件,还有Java里的properties文件等,这些文件当中的数据以“关键字-值”对的方式保存。“环境变量”这个概念都知道吧,它也是一种“key-value”对,以前也常常看到版上问“如何取得系统某某信息”之类的问题,其实很多都保存在环境变量里,只要用一条

System.getProperties().list(System.out);

就能获得全部环境变量的列表:

-- listing properties --
java.runtime.name=Java(TM) 2 Runtime Environment, Stand...
sun.boot.library.path=C:\Program Files\Java\j2re1.4.2_05\bin
java.vm.version=1.4.2_05-b04
java.vm.vendor=Sun Microsystems Inc.
java.vendor.url=http://java.sun.com/
path.separator=;
java.vm.name=Java HotSpot(TM) Client VM
file.encoding.pkg=sun.io
user.country=CN
sun.os.patch.level=Service Pack 1
java.vm.specification.name=Java Virtual Machine Specification
user.dir=d:\my documents\项目\eclipse\SWTDemo
java.runtime.version=1.4.2_05-b04
java.awt.graphicsenv=sun.awt.Win32GraphicsEnvironment
java.endorsed.dirs=C:\Program Files\Java\j2re1.4.2_05\li...
os.arch=x86
java.io.tmpdir=C:\DOCUME~1\cn2lx0q0\LOCALS~1\Temp\
line.separator=

java.vm.specification.vendor=Sun Microsystems Inc.
user.variant=
os.name=Windows XP
sun.java2d.fontpath=
java.library.path=C:\Program Files\Java\j2re1.4.2_05\bi...
java.specification.name=Java Platform API Specification
java.class.version=48.0
java.util.prefs.PreferencesFactory=java.util.prefs.WindowsPreferencesFac...
os.version=5.1
user.home=D:\Users\cn2lx0q0
user.timezone=
java.awt.printerjob=sun.awt.windows.WPrinterJob
file.encoding=GBK
java.specification.version=1.4
user.name=cn2lx0q0
java.class.path=d:\my documents\项目\eclipse\SWTDemo\bi...
java.vm.specification.version=1.0
sun.arch.data.model=32
java.home=C:\Program Files\Java\j2re1.4.2_05
java.specification.vendor=Sun Microsystems Inc.
user.language=zh
awt.toolkit=sun.awt.windows.WToolkit
java.vm.info=mixed mode
java.version=1.4.2_05
java.ext.dirs=C:\Program Files\Java\j2re1.4.2_05\li...
sun.boot.class.path=C:\Program Files\Java\j2re1.4.2_05\li...
java.vendor=Sun Microsystems Inc.
file.separator=\
java.vendor.url.bug=http://java.sun.com/cgi-bin/bugreport...
sun.cpu.endian=little
sun.io.unicode.encoding=UnicodeLittle
sun.cpu.isalist=pentium i486 i386


主要类与方法 描述
load() 从一个外部流读取属性
store() 将属性保存到外部流(特别是文件)
getProperty() 取得一个指定的属性
setProperty() 设置一个指定的属性
list() 列出这个Properties对象包含的全部“key-value”对
System.getProperties() 取得系统当前的环境变量

    你可以这样保存一个properties文件:

Properties prop = new Properties();
prop.setProperty("key1", "value1");
...
FileOutputStream out = new FileOutputStream("config.properties");
prop.store(out, "--这里是文件头,可以加入注释--");

Preferences
    如果我说Java里面可以不使用JNI的手段操作Windows的注册表你信不信?很多软件的菜单里都有“Setting”或“Preferences”这样的选项用来设定或修改软件的配置,这些配置信息可以保存到一个像上面所述的配置文件当中,如果是Windows平台下,也可能会保存到系统注册表中。从JDK 1.4开始,Java在java.util下加入了一个专门处理用户和系统配置信息的java.util.prefs包,其中一个类Preferences是一种比较“高级”的玩意。从本质上讲,Preferences本身是一个与平台无关的东西,但不同的OS对它的SPI(Service Provider Interface)的实现却是与平台相关的,因此,在不同的系统中你可能看到首选项保存为本地文件、LDAP目录项、数据库条目等,像在Windows平台下,它就保存到了系统注册表中。不仅如此,你还可以把首选项导出为XML文件或从XML文件导入。

主要类与方法 描述
systemNodeForPackage() 根据指定的Class对象得到一个Preferences对象,这个对象的注册表路径是从“HKEY_LOCAL_MACHINE\”开始的
systemRoot() 得到以注册表路径HKEY_LOCAL_MACHINE\SOFTWARE\Javasoft\Prefs 为根结点的Preferences对象
userNodeForPackage() 根据指定的Class对象得到一个Preferences对象,这个对象的注册表路径是从“HKEY_CURRENT_USER\”开始的
userRoot() 得到以注册表路径HKEY_CURRENT_USER\SOFTWARE\Javasoft\Prefs 为根结点的Preferences对象
putXXX() 设置一个属性的值,这里XXX可以为基本数值型类型,如int、long等,但首字母大写,表示参数为相应的类型,也可以不写而直接用put,参数则为字符串
getXXX() 得到一个属性的值
exportNode() 将全部首选项导出为一个XML文件
exportSubtree() 将部分首选项导出为一个XML文件
importPreferences() 从XML文件导入首选项

    你可以按如下步骤保存数据:

Preferences myPrefs1 = Preferences.userNodeForPackage(this);// 这种方法是在“HKEY_CURRENT_USER\”下按当前类的路径建立一个注册表项
Preferences myPrefs2 = Preferences.systemNodeForPackage(this);// 这种方法是在“HKEY_LOCAL_MACHINE\”下按当前类的路径建立一个注册表项
Preferences myPrefs3 = Preferences.userRoot().node("com.jungleford.demo");// 这种方法是在“HKEY_CURRENT_USER\SOFTWARE\Javasoft\Prefs\”下按“com\jungleford\demo”的路径建立一个注册表项
Preferences myPrefs4 = Preferences.systemRoot().node("com.jungleford.demo");// 这种方法是在“HKEY_LOCAL_MACHINE\SOFTWARE\Javasoft\Prefs\”下按“com\jungleford\demo”的路径建立一个注册表项
myPrefs1.putInt("key1", 10);
myPrefs1.putDouble("key2", -7.15);
myPrefs1.put("key3", "value3");
FileOutputStream out = new FileOutputStream("prefs.xml");
myPrefs1.exportNode(out);

网络I/O:Socket→RMI

Socket
    Socket编程可能大家都很熟,所以就不多讨论了,只是说通过socket把数据保存到远端服务器或从网络socket读取数据也不失为一种值得考虑的方式。

RMI
    RMI机制其实就是RPC(远程过程调用)的Java版本,它使用socket作为基本传输手段,同时也是序列化最重要的一个应用。现在网络传输从编程的角度来看基本上都是以流的方式操作,socket就是一个例子,将对象转换成字节流的一个重要目标就是为了方便网络传输。
    想象一下传统的单机环境下的程序设计,对于Java语言的函数(方法)调用(注意与C语言函数调用的区别)的参数传递,会有两种情况:如果是基本数据类型,这种情况下和C语言是一样的,采用值传递方式;如果是对象,则传递的是对象的引用,包括返回值也是引用,而不是一个完整的对象拷贝!试想一下在不同的虚拟机之间进行方法调用,即使是两个完全同名同类型的对象他们也很可能是不同的引用!此外对于方法调用过程,由于被调用过程的压栈,内存“现场”完全被被调用者占有,当被调用方法返回时,才将调用者的地址写回到程序计数器(PC),恢复调用者的状态,如果是两个虚拟机,根本不可能用简单压栈的方式来保存调用者的状态。因为种种原因,我们才需要建立RMI通信实体之间的“代理”对象,譬如“存根”就相当于远程服务器对象在客户机上的代理,stub就是这么来的,当然这是后话了。
    本地对象与远程对象(未必是物理位置上的不同机器,只要不是在同一个虚拟机内皆为“远程”)之间传递参数和返回值,可能有这么几种情形:

  • 值传递:这又包括两种子情形:如果是基本数据类型,那么都是“可序列化”的,统统序列化成可传输的字节流;如果是对象,而且不是“远程对象”(所谓“远程对象”是实现了java.rmi.Remote接口的对象),本来对象传递的应该是引用,但由于上述原因,引用是不足以证明对象身份的,所以传递的仍然是一个序列化的拷贝(当然这个对象也必须满足上述“可序列化”的条件)。
  • 引用传递:可以引用传递的只能是“远程对象”。这里所谓的“引用”不要理解成了真的只是一个符号,它其实是一个留在(客户机)本地stub中的,和远端服务器上那个真实的对象张得一模一样的镜像而已!只是因为它有点“特权”(不需要经过序列化),在本地内存里已经有了一个实例,真正引用的其实是这个“孪生子”。
    由此可见,序列化在RMI当中占有多么重要的地位。

数据库I/O:CMP、Hibernate

什么是“Persistence”
    用过VMWare的朋友大概都知道当一个guest OS正在运行的时候点击“Suspend”将虚拟OS挂起,它会把整个虚拟内存的内容保存到磁盘上,譬如你为虚拟OS分配了128M的运行内存,那挂起以后你会在虚拟OS所在的目录下找到一个同样是128M的文件,这就是虚拟OS内存的完整镜像!这种内存的镜像手段其实就是“Persistence”(持久化)概念的由来。

CMP和Hibernate
    因为我对J2EE的东西不是太熟悉,随便找了点材料看看,所以担心说的不到位,这次就不作具体总结了,人要学习……真是一件痛苦的事情 

序列化再探讨

    从以上技术的讨论中我们不难体会到,序列化是Java之所以能够出色地实现其鼓吹的两大卖点——分布式(distributed)和跨平台(OS independent)的一个重要基础。TIJ(即“Thinking in Java”)谈到I/O系统时,把序列化称为“lightweight persistence”——“轻量级的持久化”,这确实很有意思。

为什么叫做“序列”化?
    开场白里我说更习惯于把“Serialization”称为“序列化”而不是“串行化”,这是有原因的。介绍这个原因之前先回顾一些计算机基本的知识,我们知道现代计算机的内存空间都是线性编址的(什么是“线性”知道吧,就是一个元素只有一个唯一的“前驱”和唯一的“后继”,当然头尾元素是个例外;对于地址来说,它的下一个地址当然不可能有两个,否则就乱套了),“地址”这个概念推广到数据结构,就相当于“指针”,这个在本科低年级大概就知道了。注意了,既然是线性的,那“地址”就可以看作是内存空间的“序号”,说明它的组织是有顺序的,“序号”或者说“序列号”正是“Serialization”机制的一种体现。为什么这么说呢?譬如我们有两个对象a和b,分别是类A和B的实例,它们都是可序列化的,而A和B都有一个类型为C的属性,根据前面我们说过的原则,C当然也必须是可序列化的。

import java.io.*;
...
class A implements Serializable
{
  C c;
  ...
}

class B implements Serializable
{
  C c;
  ...
}

class C implements Serializable
{
  ...
}

A a;
B b;
C c1;
...

    注意,这里我们在实例化a和b的时候,有意让他们的c属性使用同一个C类型对象的引用,譬如c1,那么请试想一下,但我们序列化a和b的时候,它们的c属性在外部字节流(当然可以不仅仅是文件)里保存的是一份拷贝还是两份拷贝呢?序列化在这里使用的是一种类似于“指针”的方案:它为每个被序列化的对象标上一个“序列号”(serial number),但序列化一个对象的时候,如果其某个属性对象是已经被序列化的,那么这里只向输出流写入该属性的序列号;从字节流恢复被序列化的对象时,也根据序列号找到对应的流来恢复。这就是“序列化”名称的由来!这里我们看到“序列化”和“指针”是极相似的,只不过“指针”是内存空间的地址链,而序列化用的是外部流中的“序列号链”
    使用“序列号”而不是内存地址来标识一个被序列化的对象,是因为从流中恢复对象到内存,其地址可能就未必是原来的地址了——我们需要的只是这些对象之间的引用关系,而不是死板的原始位置,这在RMI中就更是必要,在两台不同的机器之间传递对象(流),根本就不可能指望它们在两台机器上都具有相同的内存地址。

更灵活的“序列化”:transient属性和Externalizable
    Serializable确实很方便,方便到你几乎不需要做任何额外的工作就可以轻松将内存中的对象保存到外部。但有两个问题使得Serializable的威力收到束缚:
    一个是效率问题,《Core Java 2》中指出,Serializable使用系统默认的序列化机制会影响软件的运行速度,因为需要为每个属性的引用编号和查号,再加上I/O操作的时间(I/O和内存读写差的可是一个数量级的大小),其代价当然是可观的。
    另一个困扰是“裸”的Serializable不可定制,傻乎乎地什么都给你序列化了,不管你是不是想这么做。其实你可以有至少三种定制序列化的选择。其中一种前面已经提到了,就是在implements Serializable的类里面添加私有的writeObject()和readObject()方法(这种Serializable就不裸了,),在这两个方法里,该序列化什么,不该序列化什么,那就由你说了算了,你当然可以在这两个方法体里面分别调用ObjectOutputStream.defaultWriteObject()和ObjectInputStream.defaultReadObject()仍然执行默认的序列化动作(那你在代码上不就做无用功了?呵呵),也可以用ObjectOutputStream.writeObject()和ObjectInputStream.readObject()方法对你中意的属性进行序列化。但虚拟机一看到你定义了这两个方法,它就不再用默认的机制了。
    如果仅仅为了跳过某些属性不让它序列化,上面的动作似乎显得麻烦,更简单的方法是对不想序列化的属性加上transient关键字,说明它是个“暂态变量”,默认序列化的时候就不会把这些属性也塞到外部流里了。当然,你如果定义writeObject()和readObject()方法的化,仍然可以把暂态变量进行序列化。题外话,像transientviolatefinallyassert这样的关键字初学者可能会不太重视,而现在有的公司招聘就偏偏喜欢问这样的问题
    再一个方案就是不实现Serializable而改成实现Externalizable接口。我们研究一下这两个接口的源代码,发现它们很类似,甚至容易混淆。我们要记住的是:Externalizable默认并不保存任何对象相关信息!任何保存和恢复对象的动作都是你自己定义的。Externalizable包含两个public的方法:

public void writeExternal(ObjectOutput out) throws IOException;
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;

    乍一看这和上面的writeObject()和readObject()几乎差不多,但Serializable和Externalizable走的是两个不同的流程:Serializable在对象不存在的情况下,就可以仅凭外部的字节序列把整个对象重建出来;但Externalizable在重建对象时,先是调用该类的默认构造函数(即不含参数的那个构造函数)使得内存中先有这么一个实例,然后再调用readExternal方法对实例中的属性进行恢复,因此,如果默认构造函数中和readExternal方法中都没有赋值的那些属性,特别他们是非基本类型的话,将会是空(null)。在这里需要注意的是,transient只能用在对Serializable而不是Externalizable的实现里面

序列化与克隆
    从“可序列化”的递归定义来看,一个序列化的对象貌似对象内存映象的外部克隆,如果没有共享引用的属性的化,那么应该是一个深度克隆。关于克隆的话题有可以谈很多,这里就不细说了,有兴趣的话可以参考IBM developerWorks上的一篇文章:JAVA中的指针,引用及对象的clone

一点启示

    作为一个实际的应用,我在写那个简易的邮件客户端JExp的时候曾经对比过好几种保存Message对象(主要是几个关键属性和邮件的内容)到本地的方法,譬如XML、Properties等,最后还是选择了用序列化的方式,因为这种方法最简单, 大约可算是“学以致用”罢。这里“存取程序状态”其实只是一个引子话题罢了,我想说的是——就如同前面我们讨论的关于logging的话题一样——在Java面前对同一个问题你可以有很多种solution:熟悉文件操作的,你可能会觉得Properties、XML或Bean比较方便,然后又发现了还有Preferences这么一个东东,大概又会感慨“天外有天”了,等到你接触了很多种新方法以后,结果又会“殊途同归”,重新反省Serialization机制本身。这不仅是Java,科学也是同样的道理。

posted @ 2005-09-28 10:09 小海船 阅读(327) | 评论 (0)编辑 收藏

1。追加文件方法
          1.java.io.FileWriter 的构造函数中:FileWriter(File file, boolean append)
          Constructs a FileWriter object given a File object.
append - if true, then bytes will be written to the end of the file rather than the beginning

         2.类java.io.RandomAccessFile extends Object implements DataOutput, DataInput 中方法
              seek(long pos)将当前操作指针移到文件末尾。
2.关于隔行写入文件java.io.BufferedWriter类中的方法newLine()



posted @ 2005-09-27 14:00 小海船 阅读(1177) | 评论 (1)编辑 收藏

Log4j 学习笔记

ccjsmile (http://ijsp.net)

 

这是我在学习Log4j时做的一点笔记,希望对各位朋友有一点帮助。我的mail:ccjsmile@sohu.com,希望能与您进行讨论^_*

 

Log4j 是一个开放源码项目,它是一个日志管理程序。

Log4j的优点:

1.       方便的调试信息;

2.       日志以各种丰富的(主要是文件)形式保留,用于以后分析;

缺点:减慢程序运行速度.


(A) 其中,level 是日志记录的优先级,分为OFFFATALERRORWARNINFODEBUGALL或者您定义的级别。Log4j建议只使用四个级别,优先级从高到低分别是ERRORWARNINFODEBUG。通过在这里定义的级别,您可以控制到应用程序中相应级别的日志信息的开关。比如在这里定义了INFO级别,则应用程序中所有DEBUG级别的日志信息将不被打印出来。

appenderName就是指定日志信息输出到哪个地方。您可以同时指定多个输出目的地。

 

(B) 其中,Log4j提供的appender有以下几种:

org.apache.log4j.ConsoleAppender(控制台),

org.apache.log4j.FileAppender(文件),

org.apache.log4j.DailyRollingFileAppender(每天产生一个日志文件),org.apache.log4j.RollingFileAppender(文件大小到达指定尺寸的时候产生一个新的文件),

org.apache.log4j.WriterAppender(将日志信息以流格式发送到任意指定的地方)

 

(C) 其中,Log4j提供的layout有以下几种:

org.apache.log4j.HTMLLayout(以HTML表格形式布局),

org.apache.log4j.PatternLayout(可以灵活地指定布局模式),

org.apache.log4j.SimpleLayout(包含日志信息的级别和信息字符串),

org.apache.log4j.TTCCLayout(包含日志产生的时间、线程、类别等等信息)

 

 

下面介绍一下log4jweb中应用的例子:

这是一个用于log4j初始化的servlet

 

package net.ijsp.log4j;

 

import org.apache.log4j.PropertyConfigurator;

import javax.servlet.http.HttpServlet;

import javax.servlet.ServletException;

 

public class InitLog4j extends HttpServlet {

 

  public  void init() throws ServletException  {

   PropertyConfigurator.configure("D:/resin/webapps/log4j/web-inf/classes/log4j.properties");

    System.out.println("ok");

  }

}

 

在上述文件中我们发现需要一个log4j.properties的文件,他的存放路径为:D:/resin/webapps/log4j/web-inf/classes/log4j.properties

这个properties的文件内容如下:

#log4j.properties

#Set root logger level to DEBUG and its only appender to A1.

log4j.rootLogger=INFO,A1

#A1 is set to be a ConsoleAppender.

#log4j.appender.A1=org.apache.log4j.ConsoleAppender

       log4j.appender.A1=org.apache.log4j.RollingFileAppender

       log4j.appender.A1.File=example11.log

#A1 uses PatternLayout

       log4j.appender.A1.layout=org.apache.log4j.PatternLayout

       log4j.appender.A1.layout.ConversionPattern=%d [%t] %-5p %c \n- %m%n\n"

 

log4j.logger.ltestlog4j=INFO,A2

log4j.appender.A2=org.apache.log4j.ConsoleAppender

       log4j.appender.A2.layout=org.apache.log4j.PatternLayout

       log4j.appender.A2.layout.ConversionPattern=%d [%t] %-5p %c \n- %m%n\n"

 

#log4j.appender.A1.MaxFileSize=1000KB

# Keep one backup file

#log4j.appender.A1.MaxBackupIndex=1

 

因为这是一个servlet文件,同时我们还要修改web.xml文件

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>

       <servlet>

              <servlet-name>log4jinit</servlet-name>

              <servlet-class>net.ijsp.log4j.InitLog4j</servlet-class>

              <load-on-startup>1</load-on-startup>

  </servlet>

</web-app>

 

下面这两个为测试文件:

package net.ijsp.log4j;

 

import org.apache.log4j.PropertyConfigurator;

import org.apache.log4j.Logger;

import javax.servlet.http.HttpServlet;

import javax.servlet.ServletException;

 

public class Test {

 

  public Test() {}

 

  static Logger logger =Logger.getRootLogger();

  static Logger logger1 = Logger.getLogger("ltestlog4j");

 

  public void t() {

    logger.error("sssssssssss");

    System.out.println(logger);

    logger1.error("kjdlfkj");

    System.out.println("ddddddddddddddd");

  }

}

 

 

<%@page import ="net.ijsp.log4j.*"%>

 

<%

Test t = new Test();

t.t();

%>

posted @ 2005-09-26 17:27 小海船 阅读(328) | 评论 (0)编辑 收藏


Last login: Fri Sep 23 14:37:23 2005 from 211.155.247.222
Sun Microsystems Inc.   SunOS 5.9       Generic May 2002
[iplanet@ec2 sunone]$ telnet 10.211.12.22
Trying 10.211.12.22...
Connected to 10.211.12.22.
Escape character is '^]'.


SunOS 5.9

login: oracle
Password:
Last login: Mon Sep 26 06:39:46 from 10.211.12.233
Sun Microsystems Inc.   SunOS 5.9       Generic May 2002
You have mail.
[oracle@db oracle]$ sqlplus cpf/cpf

SQL*Plus: Release 9.2.0.5.0 - Production on Mon Sep 26 09:24:44 2005

Copyright (c) 1982, 2002, Oracle Corporation.  All rights reserved.


Connected to:
Oracle9i Enterprise Edition Release 9.2.0.5.0 - 64bit Production
With the Partitioning, OLAP and Oracle Data Mining options
JServer Release 9.2.0.5.0 - Production

SQL> drop table bs_banksetting
  2  ;

Table dropped.

SQL> drop table bs_bankaccountinfo;

Table dropped.

SQL> drop table bs_clientsetting;

Table dropped.

SQL> drop table bs_countrysetting;

Table dropped.

SQL> drop table bs_currencysetting;

Table dropped.

SQL> exit
Disconnected from Oracle9i Enterprise Edition Release 9.2.0.5.0 - 64bit Production
With the Partitioning, OLAP and Oracle Data Mining options
JServer Release 9.2.0.5.0 - Production
[oracle@db oracle]$ ftp 211.155.247.197
Connected to 211.155.247.197.
220 fsdev FTP server ready.
Name (211.155.247.197:oracle): root
331 Password required for root.
Password:
230 User root logged in.
Remote system type is UNIX.
Using binary mode to transfer files.
ftp> cd bankportal
250 CWD command successful.
ftp> ls
200 PORT command successful.
150 Opening ASCII mode data connection for file list.
AcctDataSourceType.class
AcctDataSourceType.java
CurrencyMappingDAO_oracle.class
SettingData.dmp
account
addp.jsp
bankportal.properties
create_table.sql
datamaintain
example.xls
expbp0926.dmp
expbp1420.dmp
iTreasury-bankportal.ear
itreasury.properties
menubp.dmp
model.xls
query
v003.jsp
v005.jsp
226 Transfer complete.
316 bytes received in 0.016 seconds (19.33 Kbytes/s)
ftp> get expbp0926.dmp
200 PORT command successful.
150 Opening BINARY mode data connection for expbp0926.dmp (47104 bytes).
226 Transfer complete.
local: expbp0926.dmp remote: expbp0926.dmp
47104 bytes received in 0.16 seconds (292.70 Kbytes/s)
ftp> bye
221-You have transferred 47104 bytes in 1 files.
221-Total traffic for this session was 48051 bytes in 2 transfers.
221-Thank you for using the FTP service on fsdev.
221 Goodbye.
[oracle@db oracle]$ imp system/manager1 file=expbp0926.dmp fromuser=bp_cpf touser=cpf

Import: Release 9.2.0.5.0 - Production on Mon Sep 26 09:30:09 2005

Copyright (c) 1982, 2002, Oracle Corporation.  All rights reserved.


Connected to: Oracle9i Enterprise Edition Release 9.2.0.5.0 - 64bit Production
With the Partitioning, OLAP and Oracle Data Mining options
JServer Release 9.2.0.5.0 - Production

Export file created by EXPORT:V09.02.00 via conventional path

Warning: the objects were exported by BP_CPF, not by you

import done in ZHS16GBK character set and AL16UTF16 NCHAR character set
. importing BP_CPF's objects into CPF
. . importing table           "BS_BANKACCOUNTINFO"        150 rows imported
. . importing table               "BS_BANKSETTING"        107 rows imported
. . importing table             "BS_CLIENTSETTING"         27 rows imported
. . importing table            "BS_COUNTRYSETTING"         21 rows imported
. . importing table           "BS_CURRENCYSETTING"         53 rows imported
Import terminated successfully without warnings.
[oracle@db oracle]$

posted @ 2005-09-26 09:38 小海船 阅读(269) | 评论 (0)编辑 收藏

package property;

import java.io.*;
import java.util.*;

public class TemplateId {

 private static Properties p;

 private static final TemplateId pi = new TemplateId();

 public TemplateId() {
  // 从templateId.properties属性文件获得数据
  InputStream is = getClass()
    .getResourceAsStream("templateId.properties");
  p = new Properties();
  try {
   p.load(is);
  } catch (IOException ex) {
   ex.printStackTrace();
  }
 }

 // 此处的templateId就是templateId.properties属性文件中的templateId。
 public static String getTemplateId() {
  return pi.p.getProperty("templateId");
 }

 public static void main(String args[]) {
  System.out.println("templateId=" + getTemplateId()); // 测试调用
 }
}
templateId.properties文件内容:templateId=FFD4156506-3-2F8CAC7

posted @ 2005-09-21 17:51 小海船 阅读(348) | 评论 (0)编辑 收藏

        所谓热部署,就是在应用正在运行的时候升级软件,却不需要重新启动应用。对于Java应用程序来说,热部署就是在运行时更新Java类文件。在基于Java的应用服务器实现热部署的过程中,类装入器扮演着重要的角色。大多数基于Java的应用服务器,包括EJB服务器和Servlet容器,都支持热部署。类装入器不能重新装入一个已经装入的类,但只要使用一个新的类装入器实例,就可以将类再次装入一个正在运行的应用程序。

       由于类装入器担负着把代码装入JVM的重任,所以它的体系结构应当保证整个平台的安全性不会受到威胁。每一个类装入器要为它装入的类定义一个独立的名称空间,因此运行时,一个类由它的包名称和装入它的类装入器两者结合唯一地标识。

  在名称空间之外,类不可见,运行时不同名称空间的类之间有一种保护性的“隔离墙”,在Java 2向父类委托的类装入模式中,类装入器可以请求其父类装入器装入的类,因此类装入器需要的类不一定全部由它自己装入。

  在Java运行环境中,不同的类装入器从不同的代码库装入类,之所以要将各个类装入器代码库的位置分开,是为了便于给不同的代码库设定不同的信任级别。在JVM中,由bootstrap类装入器装入的类具有最高的信任级别,用户自定义类装入器代码库的信任级别最低。此外,类装入器可以把每一个装入的类放入一个保护域,保护域定义了代码执行时所拥有的权限。

  如果要以系统安全策略(一个java.security.Policy的实例)为基础定义代码的权限,定制类装入器必须扩展java.security.SecureClassLoad类,调用其defineClass方法,SecureClassLoad类的defineClass方法有一个java.security.CodeSource参数。defindClass方法从系统策略获得与CodeSource关联的权限,以此为基础定义一个java.security.ProtectionDomain。详细介绍该安全模型已经超出了本文的范围,请读者自行参阅有关JVM内部机制的资料。

 类装入器装入的最小执行单元是Java .class文件。Java .class文件包含Java类的二进制描述,其中有可执行的字节码以及该类用到的对其他类的引用,包括对Java标准API里面的类的引用。简单地说,类装入器首先找到要装入的Java类的字节码,读入字节码,创建一个java.lang.Class类的实例。做好这些准备之后,类就可以被JVM执行了。
 当JVM最初开始运行时,它里面不装入任何类。如果要求JVM执行一个程序,被执行的类首先装入,字节码执行期间会引用到其他类和接口,这些被引用到的类和接口随之也被装入。因此,有人把JVM的类装入方式称为“懒惰的”装入方式,即只有必须用到某个类时才会装入它(而不是预先装入各种可能用到的类),正因为如此,开始时JVM不必知道运行时要装入哪些类。在Java平台上,懒惰的装入方式是实现动态可扩展性机制的关键因素之一。在本文的后面,你将会看到通过实现一个定制的Java类装入器,我们可以为Java运行时环境加入许多有趣的功能
   一、委托模式
     Java 2运行时环境中有多个类装入器的实例,每一个类装入器的实例从不同的代码库装入Java类。例如,Java核心API类由bootstrap(或primordial)类装入器装入,应用程序的类由system(或application)类装入器装入。另外,应用程序可以自定义类装入器从指定的代码库装入类。Java 2定义了类装入器之间的父-子关系,每一个类装入器(bootstrap除外)都有一个父类装入器,形成一个由类装入器构成的树形结构,bootstrap类装入器是这个树形结构的根,因此bootstrap没有父类装入器。
 当客户程序请求类装入器装入某个类时,类装入器按照下面的算法装入一个类:
   首先执行一次检查,查看客户程序请求的类是否已经由当前的类装入器装入。如果是,则返回已装入的类,请求处理完毕。JVM缓冲了类装入器装入的所有类,已经装入的类不会被再次装入。

 如果尚未装入类,则装入类的请求被委托给父类装入器,这个操作发生在当前的类装入器尝试装入指定的类之前。委托装入类的操作一直向上传递,直至bootstrap类装入器,如前所述,bootstrap类装入器是处于树形结构的顶层,它不再有可委托的父类装入器。

 如果父类装入器未能装入指定的类,则当前的类装入器将尝试搜索该类。每一个类装入器有预定义的搜索和装入类的位置。例如,bootstrap类装入器搜索sun.boot.class.path系统属性中指定的位置(包括目录和zip、jar文件),system类装入器搜索的位置由JVM开始运行时传入的CLASSPATH命令行变量指定(相当于设置java.class.path系统属性)。如果找到了类,则类装入器将类返回给系统,请求处理完毕。
   
 ⑷ 如果找不到类,则抛出java.lang.ClassNotFoundException异常。
posted @ 2005-09-21 15:50 小海船 阅读(1467) | 评论 (0)编辑 收藏