From：http://blog.csdn.net/mervyn/articles/928589.aspx

※简述※

Subversion是近期在开源社区中非常流行的一款版本控制软件，它是CVS的替代产物。

它的主要特征有：

CVS大部分的功能。
支持“目录”级别的版本管理，并且解决了CVS中迟迟未能解决的文件重命名和移动等问题。甚至对文件或文件夹的属性都提供了版本管理。
“提交（commit）”实现了真正意义上的原子操作。也就是类似数据库中的事务的功能。
版本号依据每次提交而改变，不再针对每个文件。日志信息也是针对每次提交而设置。所以看到版本号是几百或者几千也不用太惊讶，表示方式不一样罢了。
通过WebDAV/DeltaV协议，可以与Apache的网络服务无缝衔接（通过Apache来运行）。这样就能提供一些额外的功能，例如：认证，压缩传输，以及数据仓库（Repository，见下）的浏览等。
也可以作为独立服务器运行，但这样的话提供的功能较为简单薄弱。
两种运行模式都支持SSH（当然需要各自的支持和配置）
降低了分支（Branch）和标签（tag）上的时间消耗。底层设计理念和实现上的不同，不细说了。
时间消耗依据的是文件改变部分的大小，而不是数据总量。
创建数据仓库时，用户可以指定是使用内嵌的 BerkeleyDB 数据库，还是特定格式的文件系统。
其他还有些零星的小功能，具体可以参阅： http://subversion.tigris.org/roadmap.html

这里解释一下数据仓库的概念：
一个数据仓库对应的可以是一个项目，也可以是多个项目。SVN是基于数据仓库进行管理的。
按照用户习惯，可以只在每个数据仓库内仅放置一个项目的内容。

※下载※

Subversion 1.2.3:
http://subversion.tigris.org/project_packages.html
（SVN的Server端，分不同操作系统的版本，这里我下载的是for windows及for linux的）

TortoiseSVN:
http://tortoisesvn.tigris.org/download.html
（windows下的SVN客户端，以shell方式集成在系统右键菜单中）

Apache 2.0.55:
http://httpd.apache.org/download.cgi
（视操作系统而下）

※安装使用※

下面说一下安装，分两种平台（windows，linux）及两种模式（与Apache绑定 vs. Stand-alone）
具体在Apache上的配置倒是大同小异。

另外，SVN是支持SSL的，但是这个配置牵涉到其他太多东西，本文就不过多涉及了。真的有需要可以参考SVN的手册（英文）。

方便起见，用几个变量代表具体的值，请自行加以调整：

%SystemRoot% — windows的系统所在目录，一般类似这样：C:"WINNT
%SVN_HOME% — SVN的安装目录
%SVN_REPO_PARENT% — SVN所有数据仓库的根目录（就是存放全部版本文件的总目录）
%PROJECT_NAME% — 项目名，严格的来说它对应的是一个数据仓库，但是这里遵从用户习惯，以项目名称方式来命名。
%SERVER_NAME_OR_IP% — 服务器名或IP地址
%APACHE_HOME% — Apache2的安装路径

另外，安装过程默认使用文件系统做后台数据库，文中不再加以说明。如需使用BerkeleyDB，请自行参考SVN文档。

Windows上的服务器端安装
____________________________________________

1.双击下载得来的”svn-1.2.3-setup.exe”并安装到”%SVN_HOME%”

2.安装完毕后，”%SVN_HOME%"bin”应该已经自动加入到系统路径（%PATH%）中。如果没有，请手工添加。

3.用命令行来测试安装结果是否正确：

1.        cmd

2.        svnadmin

如果返回这样的错误信息：”svnadmin.exe - Unable To Locate DLL”，那就需要尝试一下步骤的中的一种或几种：
安装VC++ 6.0（主要是安装VC的运行库）
或者直接从别的机器上拷贝一个”msvcp60.dll”文件到本机的”%SystemRoot%"system32″下

4.使用以下命令创建一个数据仓库，用来存放项目的源代码和其他文件：

1.        cmd

2.        svnadmin create%SVN_REPO_PARENT%"%PROJECT_NAME%

5.其中%SVN_REPO_PARENT%是包含所有数据仓库的目录，%PROJECT_NAME%是所创建的数据仓库对应的项目名。

*************************
* 以 Stand-alone 模式运行 *
*************************

6.从命令行启动SVN Server：

1.        cmd

2.        svnserve -d -r %SVN_REPO_PARENT%

注意里面的参数 r 限定了浏览全部数据仓库的根目录

当然如果觉得每次这样启动太麻烦的话，也有SVN Serveice的包装程序（http://dark.clansoft.dk/~mbn/svnservice/）。通过它能够以windows service的方式运行SVN Server（其本质还是Stand-alone），运行起来相对比较方便。

7.创建用户数据库（其实就是一个txt文本，就叫它”users.conf”吧，你也可以改名），保存到
%SVN_REPO_PARENT%"%PROJECT_NAME%"conf
目录（那个conf子文件夹在创建数据仓库时已被自动创建好），然后在这个文件内添加需要的用户名和密码。基本的样例如下：

1.        [users]

2.        your_username = your_password

注意这里密码是明文存放的，所以也是这种方式的不足之处。

8.在”%SVN_REPO_PARENT%"%PROJECT_NAME%"conf”目录下找到这个”svnserve.conf”文件，用任何文本编辑器打开，为刚才创建的那些用户添加读写权限：

1.        [general]

2.        anon-access = none              # 匿名访问权限

3.        auth-access = write             # 认证用户的权限

4.        password-db = users.conf        # 认证用户数据库

5.        realm = Anything youwant, butgenerallyweuse "%PROJECT_NAME%"   # 在用户认证界面上出现的提示语句

里面的”users.conf”就是刚才在第7步创建的用户文件。

9.最后，重启SVN Server（什么？你不知道怎么重启？关掉窗口再重新用命令行启动啦；包装成Service的话么就更加简单了）

现在已经可以使用客户端来连接SVN Server，进行import等操作了。
连接Server的URL应该是类似这样的：

1.        svn://%SERVER_NAME_OR_IP%/%PROJECT_NAME%

具体步骤，请参阅第20步。

************************
* 以Apache的模块方式运行 *
************************

10.首先要了解的是SVN设计的时候只考虑了兼容Apache2.x，所以在Apache1.x下是不能正常工作的。

11.安装Apache2
如果事先启动了IIS之类的其他webserver，请先停止那些服务（端口被占用会导致Apache安装失败）。
其他问题可以参考Apache的安装手册。
这里假设安装目录为：%APACHE_HOME%

12.检查Apache2的安装是否成功
打开浏览器，访问： http://localhost/
如果出现的是默认的欢迎页面，那就没有问题了。否则请仔细检查，重新安装。

13.打开Apache的配置文件： “%APACHE_HOME%"conf"httpd.conf”
查找”LoadModule”这个关键字，找到导入模块的区块（section）
反注释掉下面这样，从而加载Subversion所需要的DAV模块：

1.        # LoadModule dav_module modules/mod_dav.so

完成之后看起来应该是这样：

1.        LoadModuledav_modulemodules/mod_dav.so

另外在这行下面再添加两行（请注意把路径中的”"”替换成”/”）：

1.        LoadModuledav_svn_module%SVN_HOME%/bin/mod_dav_svn.so

2.        LoadModule authz_svn_module%SVN_HOME%/bin/mod_authz_svn.so

特别需要注意的是：由于模块依赖关系，这三行的出现顺序千万不能颠倒。

14.再来配置一下”httpd.conf”的其他部分，告诉Apache2 SVN的数据仓库所在。
（为避免不必要的麻烦，所有路径中的”"”都请替换成”/”）
注意：

按照下述配置，所有数据仓库将共享密码文件及权限文件
如果需要为每个数据仓库创建独立的设置，请查阅SVN的文档（”Authorization Option”章节）
添加下述内容：

1.        <Location /svn>

2.        

3.          DAV svn

4.          SVNParentPath %SVN_REPO_PARENT%

5.        

6.          #设置通过浏览器访问Repository时的XML格式文件，可以省略

7.          SVNIndexXSLT "/svnindex.xsl"

8.        

9.          # 存取权限控制文件所在地

10.        AuthzSVNAccessFile %SVN_REPO_PARENT%/AccessFile

11.         

12.        # 先尝试匿名操作，如有必要再转向用户认证

13.        Satisfy Any

14.        Require valid-user

15.         

16.        # 如何验证用户

17.        AuthType Basic

18.        AuthName "Anything youwant, butgenerallyweuse %PROJECT_NAME%"

19.        AuthUserFile %SVN_REPO_PARENT%/passwd

20.      

21.        #输出时调用Apache的Deflate模块，必须有启用此模块才能这样配，否则删除此行

22.        SetOutputFilter DEFLATE

23.      

24.      </Location>

这里涉及到两个文件: “%SVN_REPO_PARENT%/AccessFile” 及 “%SVN_REPO_PARENT%/passwd”.
并不一定非要放到”%SVN_REPO_PARENT%”目录下，我图方便而已。觉得不安全可以移到另外地方。
这两个文件里面具体内容的设置请参考第16和17步。

15.保存”httpd.conf”并退出，这里Apache2的配置告一段落。

16.”%SVN_REPO_PARENT%/AccessFile”文件的内容

1.        [/]

2.        * = r

3.        user1 = rw

4.        user2 = r

5.        admin = rw

6.        

7.        [%PROJECT_NAME%:/src/test]

8.        user2 = rw

其中：

[/] 指代所有数据仓库的根目录，匿名用户默认的权限为只读。
对于”user1″和”admin”，他们对所有数据仓库都有读写权限。
对于”user2″，它对所有数据仓库仅有只读权限。但是下方又额外指定了他对”%PROJECT_NAME%:/src/test”目录具有读写权限。
综上，他对’test’目录及其子目录（自动继承，除非特别指定）具有读写权限，其他则均为只读权限。
你可以根据需要来设定不同的权限，更详细的说明还需要参考SVN文档中的权限设置章节。

17.”%SVN_REPO_PARENT%/passwd”文件的内容
这个文件是通过”%APACHE_HOME%"bin"htpasswd.exe”自动生成的：

1.        cmd

2.        cd /D %APACHE_HOME%"bin

3.        # 参数c仅在第一次运行时使用，用来创建一个新文件

4.        htpasswd –cm %SVN_REPO_PARENT%"passwd user1

5.        # 以后添加用户可用此命令，参数m表明需要加密

6.        htpasswd –m %SVN_REPO_PARENT%"passwd user2

此时用文本编辑器打开”%SVN_REPO_PARENT%/passwd”，可以看到里面内容是类似这样的：

1.        admin:$apr1$HLWV7/..$upZwVGvge0sc28fEp7mGM0

2.        user1:$apr1$8sbRo...$hNMdkTvO4t8POVmOkV3Vg.

3.        user2:$apr1$ZXzcE/..$5Ir0V8VQQtNYTNnnOp.EU1

18.把SVN自带的XSLT文件拷贝到网站根目录，
然后设置合理权限（windows平台则不必考虑）

1.        #这里假设你的网站根目录是  /var/www/html

2.        mv /tmp/subversion-1.2.3/tools/xslt/svnindex* /var/www/html

3.        chown apache:apache /var/www/html/svnindex*

4.        chmod 644 /var/www/html/svnindex*

5.        

6.        #设置所有者和权限(将权限赋给apache运行的用户身份)

7.        chown -R apache:apache%SVN_REPO_PARENT%

8.        chmod -R 766%SVN_REPO_PARENT%

19. 重启Apache2服务：

1.        cmd

2.        net stopApache2

3.        net startApache2

20.打开浏览器，访问：http://%SERVER_NAME_OR_IP%/svn/
如果返回的页面是”403 Forbidden”，可能是由于Apache2默认没有打开目录的浏览权限（Option Indexes，参阅Apache2文档），但这并不影响使用。
现在已经可以用客户端导入项目并开始使用了。
具体步骤，请参阅第20步。

***********************************************
* 注意：以下步骤/命令需要在装有SVN客户端的机器上执行 *
* Windows下安装服务器端的时候已经同时安装了客户端 *
* Linux下尚待查证。 *
***********************************************

21.和CVS一样，SVN在最初的时候需要将已有项目导入到数据库中。
从命令行执行以下命令（Stand-alone）：

1.        svnimportc:"temp"myprojectsvn://%SERVER_NAME_OR_IP%/%PROJECT_NAME% -m"initial import" --usernameyour_username --passwordyour_password

或者（Apache2 module）：

1.        svnimportc:"temp"myprojecthttp://%SERVER_NAME_OR_IP%/svn/%PROJECT_NAME% -m"initial import" --usernameyour_username --passwordyour_password

其中：
A) c:"temp"myproject里面包含了你所要导入的项目文件的内容
B) %SERVER_NAME_OR_IP%是SVN Server的名字或者IP地址，上面存有第5步中创建的数据仓库
C) %PROJECT_NAME%是要导入到的数据仓库名称，这里选择跟项目名一致
D) 参数 m 表明此次导入操作的注释，SVN的注释是按每次提交来定义的，导入也是提交的一种。
E) your_username和your_password是第7和17步创建的用户及密码，注意该用户必须对上面的%PROJECT_NAME%数据仓库有写权限才能成功。

22.然后，需要从Server端再次checkout到本地：
（这点感觉不是太方便，为啥不做成import的时候有个选项，本地目录可以自动生成版本信息呢？）

1.        cmd

2.        cd /D anywhere_you_want_to_put_your_versioned_project_files

3.        svn co svn://myserver/myproject/trunk . --username your_username --passwordyour_password

注意：
“co”是”checkout”的一个别名
那个点[.]代表当前目录，checkout出来的文件会自动放到这个目录下。也可以改为某个绝对路径。

23.对于向SVN Serer增加，移动，删除，或者修改后提交某些文件，参考使用以下命令：

1.        Add:    svnaddsrc/myfile.java -m"adding a file"

2.        Move:    svn movesrc/myfile.javasrc/mynewfile.java -m"moved myfile.java to mynewfile.java"

3.        Delete:    svn deletesrc/myfile.java -m"removing a file"

4.        Commit:    svn commitsrc/myfile.java -m"the message"

对于上面的客户端操作，如果安装了TortoiseSVN，一切就变得简单多了。
不过这个就要抓图来说明了。等有空的时候再放上来。

※总结※

使用Eclipse的朋友还可以参考这里： http://subclipse.tigris.org/
它以插件的形式向Eclipse提供了SVN的支持。

另外，具体的设置，参数说明等还是需要自己去查阅SVN的文档（在安装server端的时候已经附带）

参考文献及资料：
_________________________________________

http://subversion.tigris.org/
http://www-128.ibm.com/developerworks/cn/opensource/os-subversion/
http://www.javayou.com/showlog.jspe?log_id=972

如果是Java进程不知道什么原因退出或被杀死，想要分析具体原因，一般来说分下面几步：

1 拿到Java应用程序的日志文件。
一般来说日志文件中会有很应用相关的错误信息。Java进程异常退出的原因最有可能就是应用程序本身的问题。因此检查Java应用程序的日志文件可能是最快定位到错误的方法。

2 查找JVM的致命错误日志
如果应用程序日志文件中没有发现什么线索。那么还可以查看 JVM的致命错误日志。有些致命的错误，比如JNI或虚拟机本身产生的错误，可能使得Java应用程序来不及写日志就退出了。这时候可以查一个以 "hs_err_pid" 开头的日志名，例如hs_err_pid1125.log，其中1125是进程号。这个文件中也记录了一些宝贵的信息来提供一些线索，特别是Java自身的一些Bug。这个文件一般为于当前的工作目录中。用户可以用find命令自己搜索到。

3 查找操作系统的core dump文件
作为被操作系统所调度的进程，Java进程也会在不同的信号下产生Core Dump文件，例如Sig_ill和Seg_segv。这些非常严重的错误的确会使得Java虚拟机根本来不及产生任何日志就宕了。拿到core dump文件就可以使用很多工具来分析具体原因了，例如jmap, jstack等等都可以友好的进行Java进程的Core文件的分析。一般来说，Core文件也放到进程的当前工作目录，用户可以用find命令搜索 “core”。另外可以用coreadm来预先指定core文件存放的地方以及文件名的格式，例如：coreadm -g /var/core/core.%f.%p.%t

4使用Dtrace查找“是谁杀死了Java进程”
但是，有很多情况，进程被杀死的原因很复杂。有可能被别的进程以外杀掉，或被一些脚本不小心kill掉，或者被管理员（或入侵者kill -9）处理掉。这些情况都不会产生日志文件和core dump文件。这些情况很难跟踪。但如果是Solaris10下，可以使用下面的Dtrace脚本来确定“是谁杀死了Java进程”

#!/usr/sbin/dtrace -qs

proc:::signal-send
/args[1]->pr_pid == $1/
{
        printf("%s(pid:%d) is sending signal %d to %s"n", execname, pid, args[2],args[1]->pr_fname);
}

如何运行（1125）是进程号
$ ./sig1.d 1125
sched(pid:0) is sending signal 24 to bc
sched(pid:0) is sending signal 24 to bc
bash(pid:3987) is sending signal 15 to bc
bash(pid:3987) is sending signal 15 to bc
bash(pid:3987) is sendg signal 9 to bc

Java的应用有时候会因为各种原因Crash，这时候会产生一个类似java_errorpid.log的错误日志。可以拿到了这个日志，怎样分析Crash的原因呢？下面我们来详细讨论如何分析java_errorpid.log的错误日志。
一. 如何得到这个日志文件如果有一个严重的错误引起Java进程非正常退出，我们叫Crash，这时候会产生一个日志文件。缺省情况下，这个文件会产生在工作目录下。但是，可以在Java启动参数通过下面的设置，来改变这个文件的位置和命名规则。例如：
java -XX:ErrorFile=/var/log/java/java_error_%p.log
就将这个错误文件放在/var/log/java下，并且以java_error_pid.log的形式出现。

二.产生错误的原因造成严重错误的原因有多种可能性。Java虚拟机自身的Bug是原因之一，但是这种可能不是很大。在绝大多数情况下，是由于系统的库文件、API或第三方的库文件造成的；系统资源的短缺也有可能造成这种严重的错误。在发生了Crash之后，如果无法定位根本原因，也应该迅速找到Work Around的方法。

三.对日志文件的分析首先要检查日志的文件头：例如，下面是从一个客户发过来的错误日志的文件头
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
#
# An unexpected error has been detected by HotSpot Virtual Machine:
#
# EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x0815e87e, pid=7268, tid=4360
#
# Java VM: Java HotSpot(TM) Server VM (1.4.2_13-b06 mixed mode)
# Problematic frame:
# V [jvm.dll+0x15e87e]
#
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－


文件头中有很多有用的信息，“EXCEPTION_ACCESS_VIOLATION ”意味着Java应用Crash的时候，正在运行JVM自己的代码，而不是外部的Java代码或其他类库代码。这种情况很可能是JVM的Bug，但是也不一定。除了“EXCEPTION_ACCESS_VIOLATION ”，还有可能是别的信息，例如“SIGSEGV(0xb)”，意味着JVM正在执行本地或JNI的代码;[font=Thorndale, serif]“EXCEPTION_STACK_OVERFLOW”[/font]意味着这是个栈溢出的错误。


另外一个有用的信息就是：
# Problematic frame:
# V [jvm.dll+0x15e87e]

它说明Crash的时候，JVM正在从哪个库文件执行代码。除了“V”以外，还有可能是“C”、“j”、“v”、“J”。具体的表示意思如下：
FrameType Description：
C: Native C frame
j: Interpreted Java frame
V: VMframe
v: VMgenerated stub frame
J: Other frame types, including compiled Java frames

文件头之后，是当前线程的DUMP信息，线程之后是JVM进程的DUMP信息，包括所有线程的状态、地址和ID。最后还有JVM状态，Heap状态，动态连接库等等的信息。这些烦乱的信息中，包含有非常有用的信息。下面我们根据几个具体的实例来分析Java虚拟机Crash的典型例子。

四.内存回收引起的Crash内存回收引起的Crash有以下的特点：在日志文件头一般有“ EXCEPTION_ACCESS _VIOLATION”和“# Problematic frame: # V [jvm.dll+....”的信息，意味着这是在JVM内部处理，而且多半是JVM的Bug。对于这类问题，最快的方法就是绕过它。
另外，在Thread的DUMP信息最后，还能看到有关内存回收的行为例如：
--------------- T H R E A D ---------------
Current thread (0x00a56668): VMThread [id=4360]
siginfo: ExceptionCode=0xc0000005, reading address 0x00000057
Registers:
........

Stack: [0x03cf0000,0x03d30000), sp=0x03d2fc18, free space=255k
Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)
V [jvm.dll+0x15e87e]

VM_Operation (0x063efbac): full generation collection, mode: safepoint, requested by thread 0x040f83f8
------------------------------------------------------------

可以清楚的看到JVM正在做 “full generation collection”。另外还有可能看到，其他的回收行为：

• generation collection for allocation
• full generation collection
• parallel gc failed allocation
• parallel gc failed permanent allocation
• parallel gc system gc

对于内存回收的错误，一般采取改变回收的算法和参数的方法来绕过去。例如，来自客户的日志除了上面的日志信息，在日志中Heap信息中还能发现一些其他信息：
--------------------------------------------------------------
Heap
def new generation total 22592K, used 19530K [0x10010000, 0x11890000, 0x138f0000)
eden space 20096K, 97% used [0x10010000, 0x11322bd8, 0x113b0000)
from space 2496K, 0% used [0x113b0000, 0x113b0000, 0x11620000)
to space 2496K, 0% used [0x11620000, 0x11620000, 0x11890000)
tenured generation total 190696K, used 100019K [0x138f0000, 0x1f32a000, 0x30010000)
the space 190696K, 52% used [0x138f0000, 0x19a9cf38, 0x19a9d000, 0x1f32a000)
compacting perm gen total 38656K, used 38588K [0x30010000, 0x325d0000, 0x34010000)
the space 38656K, 99% used [0x30010000, 0x325bf038, 0x325bf200, 0x325d0000)
----------------------------------------------------------------

上面的信息能看出在Crash的时候，JVM的PermSize空间几乎已经消耗完了，并且回收算法在压缩Perm空间的时候出了错。因此，建议改变内存回收的算法，或扩大PermSize和MaxPermSize的数值。

五.栈溢出引起的CrashJava代码引起的栈溢出，通常不会引起JVM的Crash，而是抛出一个[font=Thorndale, serif]Java[/font]异常：[font=Thorndale, serif]java.lang.StackOverflowError[/font]。但是在[font=Thorndale, serif]Java[/font]虚拟机中，[font=Thorndale, serif]Java[/font]的代码和本地[font=Thorndale, serif]C[/font]或[font=Thorndale, serif]C++[/font]代码公用相同的[font=Thorndale, serif]Stack[/font]。这样，在执行本地代码所造成的栈溢出，就有可能引起[font=Thorndale, serif]JVM[/font]的[font=Thorndale, serif]Crash[/font]了。
栈溢出引起的Crash会在日志的文件头中看到“EXCEPTION_STACK_OVERFLOW”字样。另外，在当前线程的Stack信息中也能发现一些信息。例如下面的例子：
-----------------------------------------------------------------------------------

在上面的信息中，可以发现这是个栈溢出的错误。并且当前栈剩余的空间已经很小了(free space =4k)。因此建议将JVM的Stack的尺寸调大，主要设计两个参数：“-Xss” 和“[font=Thorndale, serif]-XX:StackShadowPages=n”[/font]。但是，将栈的尺寸调大，也意味着在有限的内存资源中，能打开的最大线程数会减少。

六.动态编译引起的Crash未完，待续

现在 Java 编程语言已经广泛应用于互联网世界，早在 Sun 公司开发 Java 语言的时候，就已经考虑到对非英文字符的支持了。Sun 公司公布的 Java 运行环境（JRE）本身就分英文版和国际版，但只有国际版才支持非英文字符。不过在 Java 编程语言的应用中，对中文字符的支持并非如同 Java Soft 的标准规范中所宣称的那样完美，因为中文字符集不只一个，而且不同的操作系统对中文字符的支持也不尽相同，所以会有许多和汉字编码处理有关的问题在我们进行应用开发中困扰着我们。有很多关于这些问题的解答，但都比较琐碎，并不能够满足大家迫切解决问题的愿望，关于 Java 中文问题的系统研究并不多，本文从汉字编码常识出发，分析 Java 中文问题，希望对大家解决这个问题有所帮助。

汉字编码的常识

我们知道，英文字符一般是以一个字节来表示的，最常用的编码方法是 ASCII 。但一个字节最多只能区分256个字符，而汉字成千上万，所以现在都以双字节来表示汉字，为了能够与英文字符分开，每个字节的最高位一定为1，这样双字节最多可以表示64K格字符。我们经常碰到的编码方式有 GB2312、BIG5、UNICODE 等。关于具体编码方式的详细资料，有兴趣的读者可以查阅相关资料。我肤浅谈一下和我们关系密切的 GB2312 和 UNICODE。GB2312 码，中华人民共和国国家标准汉字信息交换用编码，是一个由中华人民共和国国家标准总局发布的关于简化汉字的编码，通行于中国大陆地区及新加坡，简称国标码。两个字节中，第一个字节（高字节）的值为区号值加32（20H），第二个字节（低字节）的值为位号值加32（20H），用这两个值来表示一个汉字的编码。UNICODE 码是微软提出的解决多国字符问题的多字节等长编码，它对英文字符采取前面加“0”字节的策略实现等长兼容。如 “A” 的 ASCII 码为0x41，UNICODE 就为0x00，0x41。利用特殊的工具各种编码之间可以互相转换。

Java 中文问题的初步认识

我们基于 Java 编程语言进行应用开发时，不可避免地要处理中文。Java 编程语言默认的编码方式是 UNICODE，而我们通常使用的数据库及文件都是基于 GB2312 编码的，我们经常碰到这样的情况：浏览基于 JSP 技术的网站看到的是乱码，文件打开后看到的也是乱码，被 Java 修改过的数据库的内容在别的场合应用时无法继续正确地提供信息。

String sEnglish = “apple”;

String sChinese = “苹果”;

String s = “苹果 apple ”;

sEnglish 的长度是5，sChinese的长度是4，而 s 默认的长度是14。对于 sEnglish来说， Java 中的各个类都支持得非常好，肯定能够正确显示。但对于 sChinese 和 s 来说，虽然 Java Soft 声明 Java 的基本类已经考虑到对多国字符的支持（默认 UNICODE 编码），但是如果操作系统的默认编码不是 UNICODE ，而是国标码等。从 Java 源代码到得到正确的结果，要经过 “Java 源代码-> Java 字节码-> ;虚拟机->操作系统->显示设备”的过程。在上述过程中的每一步骤，我们都必须正确地处理汉字的编码，才能够使最终的显示结果正确。

“ Java 源代码-> Java 字节码”，标准的 Java 编译器 javac 使用的字符集是系统默认的字符集，比如在中文 Windows 操作系统上就是 GBK ,而在 Linux 操作系统上就是ISO-8859-1，所以大家会发现在 Linux 操作系统上编译的类中源文件中的中文字符都出了问题，解决的办法就是在编译的时候添加 encoding 参数，这样才能够与平台无关。用法是

javac ?Cencoding GBK。

“ Java 字节码->虚拟机->操作系统”， Java 运行环境 （JRE） 分英文版和国际版，但只有国际版才支持非英文字符。 Java 开发工具包 （JDK） 肯定支持多国字符，但并非所有的计算机用户都安装了 JDK 。很多操作系统及应用软件为了能够更好的支持 Java ，都内嵌了 JRE 的国际版本，为自己支持多国字符提供了方便。

“操作系统->显示设备”，对于汉字来说，操作系统必须支持并能够显示它。英文操作系统如果不搭配特殊的应用软件的话，是肯定不能够显示中文的。

还有一个问题，就是在 Java 编程过程中，对中文字符进行正确的编码转换。例如，向网页输出中文字符串的时候，不论你是用

out.println(string);还是用

<%=string%>，都必须作 UNICODE 到 GBK 的转换，或者手动，或者自动。在 JSP 1.0中，可以定义输出字符集，从而实现内码的自动转换。用法是

<%@page contentType=”text/html;charset=gb2312” %>

但是在一些 JSP 版本中并没有提供对输出字符集的支持，（例如 JSP 0.92），这就需要手动编码输出了，方法非常多。最常用的方法是

String s1 = request.getParameter(“keyword”);

String s2 = new String(s1.getBytes(“ISO-8859-1”),”GBK”);

getBytes 方法用于将中文字符以“ISO-8859-1”编码方式转化成字节数组，而“GBK” 是目标编码方式。我们从以ISO-8859-1方式编码的数据库中读出中文字符串 s1 ，经过上述转换过程，在支持 GBK 字符集的操作系统和应用软件中就能够正确显示中文字符串 s2 。

Java 中文问题的表层分析及处理

背景 

开发环境 JDK1.15 Vcafe2.0 JPadPro 

服务器端 NT IIS Sybase System Jconnect（JDBC） 

客户端 IE5.0 Pwin98 ?span > 

.CLASS 文件存放在服务器端，由客户端的浏览器运行 APPLET ， APPLET 只起调入 FRAME 类等主程序的作用。界面包括 Textfield ，TextArea，List，Choice 等。

I.用 JDBC 执行 SELECT 语句从服务器端读取数据（中文）后，将数据用 APPEND 方法加到 TextArea（TA） ，不能正确显示。但加到 List 中时，大部分汉字却可正确显示。

将数据按“ISO-8859-1” 编码方式转化为字节数组，再按系统缺省编码方式 （Default Character Encoding） 转化为 STRING ，即可在 TA 和 List 中正确显示。

程序段如下：

dbstr2 = results.getString(1);

//After reading the result from DB server，converting it to string.

dbbyte1 = dbstr2.getBytes(“iso-8859-1”);

dbstr1 = new String(dbbyte1);

在转换字符串时不采用系统默认编码方式，而直接采用“ GBK” 或者 “GB2312” ,在 A 和 B 两种情况下，从数据库取数据都没有问题。

II.处理方式与“取中文”相逆，先将 SQL 语句按系统缺省编码方式转化为字节数组，再按“ISO-8859-1”编码方式转化为 STRING ，最后送去执行，则中文信息可正确写入数据库。

程序段如下：

sqlstmt = tf_input.getText();

//Before sending statement to DB server，converting it to sql statement.

dbbyte1 = sqlstmt.getBytes();

sqlstmt = newString(dbbyte1,”iso-8859-1”);

_stmt = _con.createStatement();

_stmt.executeUpdate(sqlstmt);

……

问题：如果客户机上存在 CLASSPATH 指向 JDK 的 CLASSES.ZIP 时（称为 A 情况），上述程序代码可正确执行。但是如果客户机只有浏览器，而没有 JDK 和 CLASSPATH 时（称为 B 情况），则汉字无法正确转换。

我们的分析：

1.经过测试，在 A 情况下，程序运行时系统的缺省编码方式为 GBK 或者 GB2312 。在 B 情况下，程序启动时浏览器的 JAVA 控制台中出现如下错误信息：

Can't find resource for sun.awt.windows.awtLocalization_zh_CN

然后系统的缺省编码方式为“8859-1”。

2.如果在转换字符串时不采用系统缺省编码方式，而是直接采用 “GBK” 或“GB2312”，则在 A 情况下程序仍然可正常运行，在 B 情况下，系统出现错误：

UnsupportedEncodingException。

3.在客户机上，把 JDK 的 CLASSES.ZIP 解压后，放在另一个目录中， CLASSPATH 只包含该目录。然后一边逐步删除该目录中的 .CLASS 文件，另一边运行测试程序，最后发现在一千多个 CLASS 文件中，只有一个是必不可少的，该文件是：

sun.io.CharToByteDoubleByte.class。

将该文件拷到服务器端和其它的类放在一起，并在程序的开头 IMPORT 它，在 B 情况下程序仍然无法正常运行。

4.在 A 情况下，如果在 CLASSPTH 中去掉 sun.io.CharToByteDoubleByte.class ，则程序运行时测得默认编码方式为“8859-1”，否则为 “GBK” 或 “GB2312” 。

如果 JDK 的版本为1.2以上的话，在 B 情况下遇到的问题得到了很好的解决，测试的步骤同上，有兴趣的读者可以尝试一下。

Java 中文问题的根源分析及解决

在简体中文 MS Windows 98 + JDK 1.3 下，可以用 System.getProperties() 得到 Java 运行环境的一些基本属性，类 PoorChinese 可以帮助我们得到这些属性。

类 PoorChinese 的源代码：

public class PoorChinese {

}

执行 java PoorChinese 后，我们会得到:

系统变量 file.encoding 的值为 GBK ，user.language 的值为 zh ， user.region 的值为 CN ，这些系统变量的值决定了系统默认的编码方式是 GBK 。

在上述系统中，下面的代码将 GB2312 文件转换成 Big5 文件，它们能够帮助我们理解 Java 中汉字编码的转化:

?

import java.io.*;

import java.util.*;

?

public class gb2big5 {

?

static int iCharNum=0;

?

public static void main(String[] args) {

System.out.println("Input GB2312 file, output Big5 file.");

if (args.length!=2) {

System.err.println("Usage: jview gb2big5 gbfile big5file");

System.exit(1);

String inputString = readInput(args[0]);

writeOutput(inputString,args[1]);

System.out.println("Number of Characters in file: "+iCharNum+".");

}

?

static void writeOutput(String str, String strOutFile) {

try {

FileOutputStream fos = new FileOutputStream(strOutFile);

Writer out = new OutputStreamWriter(fos, "Big5");

out.write(str);

out.close();

}

catch (IOException e) {

e.printStackTrace();

e.printStackTrace();

}

}

?

static String readInput(String strInFile) {

StringBuffer buffer = new StringBuffer();

try {

FileInputStream fis = new FileInputStream(strInFile);

InputStreamReader isr = new InputStreamReader(fis, "GB2312");

Reader in = new BufferedReader(isr);

int ch;

while ((ch = in.read()) > -1) {

iCharNum += 1;

buffer.append((char)ch);

}

in.close();

return buffer.toString();

}

catch (IOException e) {

e.printStackTrace();

return null;

}

}

}

?

编码转化的过程如下：

GB2312------------------>Unicode------------->Big5

执行 java gb2big5 gb.txt big5.txt ，如果 gb.txt 的内容是“今天星期三”，则得到的文件 big5.txt 中的字符能够正确显示；而如果 gb.txt 的内容是“情人节快乐”，则得到的文件 big5.txt 中对应于“节”和“乐”的字符都是符号“？”（0x3F），可见 sun.io.ByteToCharGB2312 和 sun.io.CharToByteBig5 这两个基本类并没有编好。

正如上例一样， Java 的基本类也可能存在问题。由于国际化的工作并不是在国内完成的，所以在这些基本类发布之前，没有经过严格的测试，所以对中文字符的支持并不像 Java Soft 所声称的那样完美。前不久，我的一位技术上的朋友发信给我说，他终于找到了 Java Servlet 中文问题的根源。两周以来，他一直为 Java Servlet 的中文问题所困扰，因为每面对一个含有中文字符的字符串都必须进行强制转换才能够得到正确的结果（这好象是大家公认的唯一的解决办法）。后来，他确实不想如此继续安分下去了，因为这样的事情确实不应该是高级程序员所要做的工作，他就找出 Servlet 解码的源代码进行分析，因为他怀疑问题就出在解码这部分。经过四个小时的奋斗，他终于找到了问题的根源所在。原来他的怀疑是正确的， Servlet 的解码部分完全没有考虑双字节，直接把 %XX 当作一个字符。（原来 Java Soft 也会犯这幺低级的错误！）

如果你对这个问题有兴趣或者遇到了同样的烦恼的话，你可以按照他的步骤 对Servlet.jar 进行修改：

找到源代码 HttpUtils 中的 static private String parseName ，在返回前将 sb（StringBuffer） 复制成 byte bs[] ，然后 return new String(bs,”GB2312”)。作上述修改后就需要自己解码了：

HashTable form=HttpUtils .parseQueryString(request.getQueryString())或者

form=HttpUtils.parsePostData(……)

千万别忘了编译后放到 Servlet.jar 里面。

关于 Java 中文问题的总结

Java 编程语言成长于网络世界，这就要求 Java 对多国字符有很好的支持。 Java 编程语言适应了计算的网络化的需求，为它能够在网络世界迅速成长奠定了坚实的基础。 Java 的缔造者 （Java Soft） 已经考虑到 Java 编程语言对多国字符的支持，只是现在的解决方案有很多缺陷在里面，需要我们付诸一些补偿性的措施。而世界标准化组织也在努力把人类所有的文字统一在一种编码之中，其中一种方案是 ISO10646 ，它用四个字节来表示一个字符。当然，在这种方案未被采用之前，还是希望 Java Soft 能够严格地测试它的产品，为用户带来更多的方便。

附一个用于从数据库和网络中取出 中文乱码的处理函数，入参是有问题的字符串，出参是问题已经解决了的字符串。

技术应用者提供解决方案

关于作者

 段明辉 has co-authored this article

编译代码文件,要用

         javac -encoding GBK   xxxxxx.java

   如果是用ant工具,

       <target name="compile" depends="prepare" description="complie All Java source">
          <copy todir="${build.dir}">
            <fileset dir="${src.dir}" includes="**/*.properties" />
         </copy>
         <javac srcdir="${src.dir}" destdir="${build.dir}" encoding="GBK">
            <classpath refid="project.classpath" />
         </javac>

      </target>

http://zeroliu.blogdriver.com/zeroliu/1183916.html

这个工具利用 ANT 来制作在 Windows, MacOS X, Unix 平台上可执行的文件，比如 exe，zip，jar。ROXES ANT Tasks 基于 GPL 发布。 

 http://www.roxes.com/produkte/rat.html

 企业开源参考架构

Java Web应用产品安装程序制作方案

目录：

一．背景

二．开源工具

三．环境准备

四．技术准备

4.1. Jsmooth

4.1.1. Jsmooth简介

4.1.2.工作原理

4.2. IzPack

4.2.1.IzPack简介

4.2.2.工作原理

五．方案实例

六．结束

一． 背景：

随着Java在应用产品开发中的广泛应用，基于Java的应用产品也就越来越多，那么如何为基于Java的应用产品制作安装程序的需求就产生了。以前人们一般都是使用InstallShield与InstallAnyWhere进行产品安装程序的制作，这是两个功能非常强大、易用的安装盘制作工具，尤其是InstallAnyWhere，它还支持Java应用产品安装制作，例如：大名鼎鼎的Jbuilder安装程序就是由它制作的。

本文并不准备对这些商业的安装制作工具进行讨论，本文将就如何利用开源的安装制作工具来进行Java Web应用产品程序制作进行一些探讨。

二． 开源工具：

目前用于支持Java应用安装程序制作的开源工具非常丰富，本人将要本人在研究过程中所遇到的罗列一二以供参考：

Packlet

Packlet是一个简单的Java安装制作工具。它将Java Application打包成一个可以发布的类似于zip或tgz的压缩文件中。这个压缩文件被简为packlet，它可以在安装有Java 2 Runtime Environment的操作系统上执行. 通过执行packlet将会给用户提供一个图形化的安装配置界面并解压应用。

Go To Packlet

IzPack

IzPack是一个用于Java平台的安装程序生成器。它用于产生一个轻量级、能运行于所有安装了JVM的任何的操作系统的安装程序。生成的安装程序可以通过双击或在Command Line通过java –jar install.jar命令进行启动，安装程序运行的方式具体将看操作系统的支持方式。IzPack的主要好处就是能够生成运行于任意操作系统的安装程序。

Go To IzPack

JSmooth

Jsmooth可以将Java可执行应用Wrapper成window可执行Exe程序。通过Jsmooth生成的Exe程序会自动按制作时定义的顺序寻找合适的JVM，如果能不查找到JVM，安装程序会提示用户并能根据定义好的URL启动Web Browser让用户下载JVM. 注意：Jsmooth并不是纯Java应用。

Go To JSmooth

VAInstall

VAInsall是一个用Java写的多平台安装程序工具。它是基于GNU GPL2.0许可。通过一个简单的配置文件，它允许安装程序打包工具由不同的目录下收集程序包，这与一般情况下安装程序制作工具只能由一个根目录开始相比更为灵活。由VAInstall生成的安装程序允许先择不同的安装模式(graphic,text或ansi)。

Go To VAInstall

Java Service Wrapper

用于将Java Application安装成为Window NT Service.同时与之附带的scripts能够很容易将Java Application安装成为UNIX的后台进程。

Go To Java Service Wrapper

Lift Off Java Installer

Lift Off Java Installer的最大特色就是：自解压class 文件，对目标系统要求低以及跨平台性。

Go To Lift Off Java Installer

Toolshed

一个小巧、简单、纯Java实现的安装程序制作工作。

Go To Toolshed

Launch4J

Lauch4J也是一个Java应用Window Exe封装工具。通过Lauch4J，可以提供splash screen, 图标，自动查询JRE或内置JRE等功能，同时还支持启动失败反馈以及命令行参数。

Go To Launch4J

AntInstaller

AntInstaller是一个安装程序框架，它利用一个简单的XML定义安装界面，并以Ant执行安装过程。基于AntInstaller的安装程序可以打包成自解压jar通过command line执行可Swing GUI来执行。

Go To AntInstaller

Antigen

Antigen----即Ant Installer Generator。它主要的目的就是根据Ant脚本创建图形化安装程序。

Go To Antigen

FreeInstaller

FreeInstaller是一个开源项目，完全用Java编写。它将应用程序打包成一个自解压的Java应用。通过FreeInstaller可以将Java或非Java的应用安装到UNIX,LINUX以及window NT系统中。

Go To FreeInstaller

Mini Installer

一个简单的Java安装程序制作工具。整个制作过程是通过脚本完成的，最终生成一个可以通过双击方式执行的jar文件。

Go To Mini Installer

通过对如上各产品的初步探索，本人最终选择了利用izpack + jsmooth作为Java Web应用产品的安装程序制作方案。选择这两种工具并不代表其它开源工具不好，只是本人自已结合自已项目的需求(本人负责公司一企业应用开发平台的研发工作)及本人的偏好作出的选择。

由于本人所在公司为商业公司，所以本文描述的方案并不是企业应用开发系统平台的实现模式，本文只是提供一个解决办法，关于如何与自已的框架或平台进行有效的整合，请读者自行考虑。

三． 环境准备：

你需要安装J2SDK1.4.1+版本；关于J2SDK请由Sun公司下载；

你需要安装Ant1.6.2版本，理论上其它版本也行，只是本人用的是1.6.2；

请下载并安装izpack；设定定装到IZPACK_HOME

请下载并安装jsmooth；设定安装到JSMOOTH_HOME

四． 技术准备：

为了便于理解，你需要对Java进行应用的开发有一定的基础，本例将以Web应用的安装程序制作为背景进行相关介绍，所以需要你对Web 应用开发以及其发布方式有一定的基础；另外，本方案将会以Ant作为应用build的工具，所以你需要有一定的Ant技术；对于如上相关知识本部分不准备介绍。下面本部分将主要对izpack及jsmooth进行简单的介绍。

4.1. jsmooth：

4.1.1 Jsmooth 简介：

Jsmooth，一个Java可执行应用封装器(Wrapper)，即将Java可执行应用程序(即可执行jar)封装为Window可执行文件------exe文件的工具。

通过Jsmooth将可执行jar封装为Exe文件，使得用户执行Java应用就如同执行一般的Window应用程序一样，重用用户经验。

Jsmooth对jar进行封装时可以设定classpath，JVM参数，命令行参数，JVM版本及位置，这样用户在执行exe时不用关心JVM,Classpath等问题，这样就简化了Java应用执行。

4.1.2 工作原理：

通过Jsmooth生成的Window Exe文件通常定义为“Jsmooth Application”；

要想生成Jsmooth Application，我们需要一个JsmoothGen 项目文件-----.jsmooth文件，后面我们将其称为“.jsmooth文件”；.jsmooth文件实际上是一个xml文件，用于描述/定义Jsmooth Application的相关属性，例如：classpath, JVM，Java main方法类，以及其它与Java应用运行相关的各种设定等；通常你可以通过Jsmooth提供的JsmoothGen.exe--------Windows Project Editor来创建和编辑这个文件，这个Editor如下图所示：

(图-1)Widnow Project Editor

(图-2)Widnow Project Editor

(图-3)Widnow Project Editor

在.jsmooth文件生成之后，就可以通过如下方式生成目标Jsmooth Application，即Exe文件：

(1)。Window Project Editor：

你可以直接在如上图所示的编辑器通过工具条来生成：ProjectàCreate Exe。

(2)。Command Line：

你也可以进入。jsmooth文件所以目录，通过如下命令来生成目标Exe文件：

………> %jsmooth_home%"jsmoothcmd.exe yourproject.jsmooth

(3)。通过Ant任务调用生成目标Exe：

首先你需要在你的build文件中加入jsmooth Ant 任务定义：

<> 

classname="net.charabia.jsmoothgen.ant.JSmoothGen"

classpath="${jsmooth_home}/lib/jsmoothgen-ant.jar"/>

然后，通过jsmoothgen任务来执行生成Exe的工作：

skeletonroot=”${jsmooth_home}/skeletons”/>

所以通过Jsmooth我们可以很容易将Java Application制作Windows Exe应用。

关于Jsmooth的详细介绍请参考http://jsmooth.sourceforge.net

4.2. izpack：

4.2.1. izpack简介：

izpack是基于Apache Software License 2.0许可的开源项目；

izpack是纯Java，对部分特性有针对不同平台版本的Library。例如：快捷键的创建。

izpack是一个用于解决安装程序制作的Builder工具；

通过izpack制作的安装程序可以运行于不同的操作系统，Windows, Linux, Unix等，只要安装了JDK1.4以及其后版本即可；

izpack优秀的模块化设计可以允许你定制安装程序外观、安装过程等；同时允许你通过其提供API调整izpack安装过程。

izpack的主要功能包括(但不限于)：

· XML based installation files

· easy internationalization using XML files (10 translations are already available)

· Ant integration, command-line compiler

· easy customization with the panels and a rich API (even an XML parser is included !)

· powerful variable substitution system that you can use to customize scripts and more generally any text-based file

· different kinds of installers (standard, web-based, ...)

· launching of external executables during the installation process and Unix executable flag support (useful for the scripts for instance)

· layout of the installation files in packs (some can be optional)

· native code integration facilities

· jar files nesting support

· ... more things to discover and create !.

(图-4)IzPack制作的安装界面示例－选择安装的Pack.

4.2.2. 原理及过程

利用izpack制作安装程序的主要有两步：

第一步：创建并描述安装定义文件；

第二步：通过izpack提供CommandLine工具或Ant Task对安装定义文件进行编译，编译的结果即是生成一个可执行的jar文件，其中包括了整个安装过程的实现以及安装数据；

安装定义文件：

安装过程定义文件是一个XML文件，installation是根元素，表示定义的开始。定义主要由如下几部分组成：

1．….

用于定义安装程序的基本信息；

产品中文名称

产品版本号，例如：1.0-062312

公司网址

JDK版本号：1.4.2

2．……

用于定义安装程序界面信息，例如：

3.……..

定义变量或配置信息，变量在整个安装制作的过程中非常重要，变量两种用途：其一：作为配置用，例如可以通过按照一定的命名称规则为某个变量设定一个值，izpack在执行安装过程中将会读取某个变量的值来决定某个安装向导窗口是否可见等；例如：我们可以通过定义compareToVariable.、compareToOperator.与compareToValue.的组合决定第个用户自定义的向导窗口在安装时是否可见，这样就可以通过上个窗口用户选择来决定下个窗口是否可见；其二：作为替换变量用，通常安装过程中收集的信息存放在变量中，然后，在安装程序进行到最后，利用变量的值来替换安装目标文件中的内容。

4. ….

决定，安装程序界面所支持的语言。

5. ……..

用于为安装界面指定图片或图标

用于指定用户自定义安装向导窗口定义XML文件的位置

用于指定安装向导窗口中国际化资源XML文件的位置

等等，例如：

<resources>

<res src="langsel.jpg" id="installer.langsel.img" />

<res src="readme.html" id="HTMLInfoPanel.info" parse="yes" type="plain" encoding="GB2312" />

<res src="readme_chn.html" id="HTMLInfoPanel.info_chn" parse="yes" type="plain" encoding="GB2312" />

<res src="license.html" id="HTMLLicencePanel.licence" parse="yes" type="plain" encoding="GB2312" />

<res src="license_chn.html" id="HTMLLicencePanel.licence_chn" parse="yes" type="plain" encoding="GB2312" />

<res src="shortcutSpec.xml" id="shortcutSpec.xml" parse="yes" type="xml" encoding="GB2312" />

<res src="Unix_shortcutSpec.xml" id="Unix_shortcutSpec.xml" parse="yes" type="xml" encoding="GB2312" />

<res src="packsLang.xml" id="packsLang.xml" />

<res src="packsLang_chn.xml" id="packsLang.xml_chn" />

<res src="UserInputSpec.xml" id="userInputSpec.xml" />

<res src="UserInputLang.xml" id="userInputLang.xml" />

<res src="UserInputLang_chn.xml" id="userInputLang.xml_chn" />

resources>

6. …….

本部分用于定义整个安装过程，每个panel即是一个安装向导窗口，panel是按顺序由IzPack调用的。IzPack内置了很多的Panel，另外它还支持用户自定义的功能，主要是通过UserInputPanel来实现的，你可以通过在……中定义的ID为UserInputSpec.xml的资源(XML)中定义UserInputPanel窗口中用户录入项目及相关存放的变量。另外，Izpack支持条件用户自定义Panel,即ConditionalUserInputPanel，你可以在….中通过变量来控制这样的向导窗口的可见性。当安装过程执行到InstallPanel时IzPack开始解压安装包到硬盘中，所以，一般来说所有的配置信息(例如，安装目录，安装包的选择等)都应在InstallPanel之前完成。在InstallPanel之后可以通过ShortcutPanel来显示快捷方式创建窗口，另外还可以通过ProcessPanel来执行一些后续操作。

<panels>

<panel classname="HTMLLicencePanel" />

<panel classname="HTMLInfoPanel" />

<panel classname="TargetPanel" />

<panel classname="PacksPanel" />

<panel classname="UserInputPanel" />

<panel classname="SummaryPanel" />

<panel classname="InstallPanel" />

<panel classname="ShortcutPanel" />

<panel classname="SimpleFinishPanel" />

panels>

7. …….

本部分主要用于定义安装包，即将哪些文件进行打包，以及将来安装时如何进行安装。通过可以将应用程序文件分解成不同的安装包，可以指定哪些pack是必须安装的，哪些是可选的。

前边我们讲过，我们可以在中加入自定义向导窗口来允许用户指定一些配置，这些配置信息被存放到变量中，我们可以利用用户指定的值来替换应用程序中部分文件中的内容。那么在定义pack时，就可以指定哪些文件在安装时需要进行解析(parseable)。需要注意的，你需要指定需要解析的方式(xml, javaprop, plain,shell)，如查将javaprop类型的文件解析类型设定为plain的话，可以就有问题，例如：如果变量的值为路径，那么在可能就会有问题。

另，对于每一个Pack在它安装(copy文件)之后，可以定义它执行一个程序，例如脚本程序。你可以利用这种功能来做一些工作，例如：你可执行脚本程序来导入数据库数据等。

下面是一个示例：

<packs>

<pack id="ToolKit" name="ToolKit" required="yes">

…………

pack>

<pack id="Core" name="Core" required="yes">

<description>在packsLang.xml和packsLang.xml_chn中描述了.description>

<fileset dir="app" targetdir="$INSTALL_PATH"app">

<include name="*" />

<include name="**" />

fileset>

<fileset dir="native" targetdir="$INSTALL_PATH"native">

<include name="*" />

<include name="**" />

fileset>

<file src="clear.db.splash.gif" targetdir="$INSTALL_PATH" />

<file src="init.db.splash.gif" targetdir="$INSTALL_PATH" />

<file src="installer.properties" targetdir="$INSTALL_PATH" />

<file src="installer.xml" targetdir="$INSTALL_PATH" />

<file src="installer.bat" targetdir="$INSTALL_PATH" />

<file src="uninstaller.bat" targetdir="$INSTALL_PATH" />

<parsable targetfile="$INSTALL_PATH/installer.properties"

type="javaprop" />

&

1、运行外部程序：

      Runtime.getRuntime().exec("notepad");

2、运行系统内部命令：

      Runtime.getRuntime().exec("command.com /c dir");

Runtime.getRuntime().exec("cmd xxx");

SVN版本问题解决方案：

1、svn: Expected version '3' of repository; found version '5' / svn: Expected format '3' of repository; found format '5'

把home/svnroot/repository/test/format文件中的5改成3就可以了.

2、svn: Expected FS format '1'; found format '2'

把home/svnroot/repository/test/db/format文件中的2改成1就可以了.

Linux环境下Subversion,apache2,ssl配置安装（FC4系统）

///////////////////////////////////////////////////////////

工具包

httpd-2.2.4

下载地址

[url=http://apache.justdn.org/httpd/]http://apache.justdn.org/httpd/[/url]

apr-1.2.8

apr-util-1.2.8

下载地址

[url=http://apache.justdn.org/apr/]http://apache.justdn.org/apr/[/url]

openssl

openssl-0.9.7d.tar.gz

下载地址

http://www.openssl.org/source/

证书软件

ssl.ca-0.1.tar.gz

下载地址

http://www.openssl.org/contrib/ssl.ca-0.1.tar.gz

SVN

下载地址

[url=http://www.iusesvn.com/bbs/download/subversion-1.4.0.tar.gz]http://www.iusesvn.com/bbs/download/subversion-1.4.0.tar.gz[/url]

//////////////////////////////////////////////////////////////////////

开始安装

安装apr,apr-util

tar zxvf apr-1.2.8.tar.gz

cd apr-1.2.8

./configure --prefix=/usr/local/apr

make

make install

tar zxvf apr-util-1.2.8.tar.gz

cd apr-util-1.2.8

./configure --prefix=/usr/local/apr-util --with-apr=/usr/local/apr make

make install

# tar zxvf openssl-0.9.8d.tar.gz

# cd openssl-0.9.8d

# ./config --prefix=/usr/local/openssl

# make

# make install

安装apache

tar zxvf httpd-2.2.3.tar.gz

cd httpd-2.2.3

./configure --prefix=/usr/local/apache2 --enable-so --enable-rewrite=share --enable-proxy=share --enable-proxy-ajp=share --enable-dav=share --enable-dav-fs --with-apr=/usr/local/apr/ --with-apr-util=/usr/local/apr-util/ --enable-ssl=static --with-ssl=/usr/local/ssl --enable-mods-shared=all //此语句意思是把所有模块都添加上，在这里可以不写

make

make install

其中/usr/local/ssl目录自己建

安装SVN

tar zxvf subversion-1.4.2.tar.gz

cd subversion-1.4.2

./configure --with-apxs=/usr/local/apache2/bin/apxs --prefix=/usr/local/subversion --with-apr=/usr/local/apr --with-apr-util=/usr/local/apr-util --with-ssl --with-zlib --enable-maintainer-mode

make

make install

///////////////////////////////////////////////////////////

配置

1.//创建库文件

# mkdir /home/svnroot/repository //进入subversion的bin目录

# cd /usr/local/subversion/bin

# ./svnadmin create /home/svnroot/repository/test //创建仓库"test"

# ls –l /home/svnroot/repository/test //看看是不是多了些文件，如果是则说明Subversion安装成功了

# cd /usr/local/subverion/bin

# ./svn import /home/user/import file:///home/svnroot/repository/test –m "init" //这条语句将把路径/home/user/import下找到的文件导入到你创建的Subversion 仓库中去，其中/user/import/下有自己的项目.提交后的修订版为1。

apache进程的权限：因为所有跟仓库传输的操作都是通过apache进程进行的，所以即使你给svn用户设置了很大的权限，但是apache进程没有访问仓库或者相关文件的权限也没有用，apache进程的权限设置在 /usr/local/apache2/conf/httpd.conf 文件中配置，找到文件中的这两行：

User daemon # 将daemon改为svnroot，

Group daemon

2.修改Apache配置文件

# cd /usr/local/apache2/bin

# ./apachect1 start //启动Apache

# vi /opt/apache2/conf/httpd.conf //在最下面添加

#LoadModule dav_svn_module modules/mod_dav_svn.so

#LoadModule authz_svn_module modules/mod_authz_svn.so //如果有可不写

<Location /svn>

DAV svn

SVNParentPath /home/svnroot/repository/ //svn父目录

AuthzSVNAccessFile /home/svnroot/repository/authz.conf //权限配置文件

AuthType Basic //连接类型设置

AuthName "Subversion.zoneyump" //连接框提示

AuthUserFile /home/svnroot/repository/authfile //用户配置文件

Require valid-user //采用何种认证

</Location>

#"Require valid-user"告诉apache在authfile中所有的用户都可以访问。如果没有它，则只能第一个用户可以访问新建库

3.创建用户配置文件

#cd /usr/local/apache2/bin

#htpasswd -c /home/svnroot/repository/authfile wooin //其中authfile是通过来创建的

4.配置用户访问权限:

vi /home/svnroot/repository/authz.conf //示例

[groups]

admin = mangosoft

[/]

@admin = rw

[test:/]

@admin = rw

wooin = rw

为了简化配置，3个版本库共用1个权限配置文件/home/svnroot/repository/pwd.conf。如有必要，也可以分开。文件中定义用户组和版本库目录权限。

注意：

* 权限配置文件中出现的用户名必须已在用户配置文件中定义。

* 对权限配置文件的修改立即生效，不必重启svn。

用户组格式：

[groups]

<用户组名> = <用户1>,<用户2>

其中，1个用户组可以包含1个或多个用户，用户间以逗号分隔。

版本库目录格式：

[<版本库>:/项目/目录]

@<用户组名> = <权限>

<用户名> = <权限>

其中，方框号内部分可以有多种写法:

/,表示根目录及以下。根目录是svnserve启动时指定的，我们指定为/home/svnroot/repository。这样，/就是表示对全部版本库设置权限。

test:/,表示对版本库test设置权限

权限主体可以是用户组、用户或*，用户组在前面加@，*表示全部用户。权限可以是w、r、wr和空，空表示没有任何权限。

5. 不让其他人有该目录的权限

# chown -R svnroot:daemon /home/svnroot/repository //，这里的用户名可以自己定

6.检验是否成功

重启apache

cd /usr/local/apache2/bin/

./apachectl restart

//打开浏览器访问[url=http://localhost/svn/test/]

http://localhost/svn/test/ //如果有东西显示就说明成功。

注意：如果没成功在/usr/local/apache2/htdocs/下建一个favicon.ico文件.

////////////////////////////////////////////////////////

基本应用

1. 权限管理

1)增加用户

# htpasswd [-c] /home/svnroot/repository/authfile wooin //第一次设置用户时使用-c表示新建一个用户文件。回车后输入用户密码，

# htpasswd authfile 用户名(加入新的用户) //完成对用户 的增加

2)权限分配

# vi /home/svnroot/repository/authz.conf

[test:/] //这表示，仓库test的根目录下的访问权限

wooin = rw //test仓库wooin用户具有读和写权限

bao = r //test仓库bao用户具有读权限

[test2:/] //test2仓库根目录下的访问权限

wooin = r //wooin用户在test2仓库根目录下只有读权限

bao = //bao用户在 test2仓库根目录下无任何权限

[/] //这个表示在所有仓库的根目录下

* = r //这个表示对所有的用户都具有读权限

#[groups] //这个表示群组设置

#svn1-developers = wooin, bao //这个表示某群 组里的成员

#svn2-developers = wooin

#[svn1:/]

#@svn1-developers = rw //如果在前面加上@符号，则表 示这是个群组权限设置

将这个设置完成后。重启Apache，就可以通过

http://localhost/svn/test

这个URL来访问仓库了，当然，受权限的限制，必须是合法用户才能访问且具有相应的权限

2. 在/etc/profile的结尾设置一些svn启动时要做的工作

# start apache server for svn

/usr/sbin/apachectl start

export SVN_EDITOR=vi

3. 如果linux的登录用户名密码都和svn的其中一个用户名密码相同时，在checkout的时候不会要求输入用户名密码直接就可以checkout出来。比如：linux有个用户wooin，svn也有一个用户wooin，并且密码都是一样的，当用wooin登录linux后，执行checkout，可以直接提取出源码文件，不用输入现ば畔ⅰ?

4. 在svn使用过程中牵扯到几种权限：文件系统的权限，linux系统权限，svn用户的权限，apache进程的权限。

文件系统的权限，linux系统权限：这里相同的意思，就是平时大家使用linux时文件夹和文件的访问权限。在 svn建立仓库，文件夹，配置文件的时候用svnroot用户，并将仓库权限设置为700，不允许其他用户直接通过文件系统查看，只能由svnroot进行管理。

apache进程的权限：因为所有跟仓库传输的操作都是通过apache进程进行的，所以即使你给svn用户设置了很大的权限，但是apache进程没有访问仓库或者相关文件的权限也没有用，apache进程的权限设置在 /usr/local/apache2/conf/httpd.conf 文件中配置，找到文件中的这两行：

User daemon # 将daemon改为svnroot，让apache进程以svnroot的身份运行

Group daemon

svn用户的权限：就是在authz.conf文件中设置的权限信息，是svn用来管理仓库访问权限的。

5. 重新部署SVN仓库

需要将目前的某个仓库导出，并导入到另一个仓库（可以导入到该仓库的指定目录下），

要用到以下的命令：

# svnadmin dump /home/svnroot/sonatina/ > stn.dump // 导出所有版本到stn.dump文件中

# svnadmin dump /home/svnroot/sonatina/ --revision 10 > stn.r10.dump // 或者也可以只导出其中一个版本

# svnadmin dump /home/svnroot/sonatina/ --revision 0:10 > stn.r0-10.dump // 或者也可以导出多个版本，比如0-10版本

# svnadmin load /home/svnroot/sonatinab/ --parent-dir trunk < stn.r0-10.dump // 导入到sonatinab/trunk目录下，如果不指定--parent-dir，则会导入到根目录sonatinab/下

//////////////////////////////////////////////////////////

使用ssh方式验证:

cd /home/usr/local/subversion/bin

./svn list svn+ssh://ip地址/home/svnroot/repository/test

如果出现这个问题:

subversion/libsvn_repos/repos.c:1004: (apr_err=165005)

svn: Expected version '3' of repository; found version '5'

把home/svnroot/repository/test/format文件中的5改成3就可以了.

///////////////////////////////////////////////////////

使用https方式验证

vi /usr/local/apache/conf/http.conf

# Secure (SSL/TLS) connections

Include conf/extra/httpd-ssl.conf //把此处的#去掉

#

# Note: The following must must be present to support

# starting without SSL on platforms with no /dev/random equivalent

# but a statically compiled-in mod_ssl.

#

# cd /usr/local/apache2

# ./bin/apachectl start

Syntax error on line 108 of /usr/local/apache2/conf/ssl.conf:

SSLCertificateFile: file '/usr/local/apache2/conf/server.key' does not exist or is empty

这又是什么原因呢？因为我们没有配置ssl，需要生成ssl需要的证书。

以前使用apache1+mod_ssl的时候，make之后有一个这样的步骤

$ make certificate

可以用来生成ssl所用到的证书。

现在没有这个工具了，只能自己动手生成了，对证书不熟悉的人，有一个工具可以使用：http://www.openssl.org/contrib/ssl.ca-0.1.tar.gz

# cd /usr/local/apache2/conf

# tar zxvf ssl.ca-0.1.tar.gz

# cd ssl.ca-0.1

# ./new-root-ca.sh (生成根证书)

No Root CA key round. Generating one

Generating RSA private key, 1024 bit long modulus

...........................++++++

....++++++

e is 65537 (0x10001)

Enter pass phrase for ca.key: (输入一个密码)

Verifying - Enter pass phrase for ca.key: (再输入一次密码)

......

Self-sign the root CA... (签署根证书)

Enter pass phrase for ca.key: (输入刚刚设置的密码)

........

........ (下面开始签署)

Country Name (2 letter code) [MY]: CN

State or Province Name (full name) [Perak]: liaoning

Locality Name (eg, city) [Sitiawan]: dalian

Organization Name (eg, company) [My Directory Sdn Bhd]: jishikeyan

Organizational Unit Name (eg, section) [Certification Services Division]: ACSTAR

Common Name (eg, MD Root CA) []: yong

Email Address []: yong@yong.com.cn

这样就生成了ca.key和ca.crt两个文件，下面还要为我们的服务器生成一个证书：

# ./new-server-cert.sh server (这个证书的名字是server)

......

......

Country Name (2 letter code) [MY]: CN

State or Province Name (full name) [Perak]: liaoning

Locality Name (eg, city) [Sitiawan]: dalian

Organization Name (eg, company) [My Directory Sdn Bhd]: jishikeyan

Organizational Unit Name (eg, section) [Secure Web Server]: ACSTAR

Common Name (eg, www.domain.com) []: localhost

Email Address []: yong@yong.com.cn

这样就生成了server.csr和server.key这两个文件。

还需要签署一下才能使用的：

# ./sign-server-cert.sh server

CA signing: server.csr -> server.crt:

Using configuration from ca.config

Enter pass phrase for ./ca.key: (输入上面设置的根证书密码)

Check that the request matches the signature

Signature ok

The Subject's Distinguished Name is as follows

countryName :PRINTABLE:'CN'

stateOrProvinceName :PRINTABLE:'liaoning'

localityName :PRINTABLE:'liaoning'

organizationName :PRINTABLE:'jishikeyan'

organizationalUnitName:PRINTABLE:'ACSTAR'

commonName :PRINTABLE:'localhost'

emailAddress :IA5STRING:'yongl@yong.com.cn'

Certificate is to be certified until Jul 16 12:55:34 2005 GMT (365 days)

Sign the certificate? [y/n]: y

1 out of 1 certificate requests certified, commit? [y/n] y

Write out database with 1 new entries

Data Base Updated

CA verifying: server.crt <-> CA cert

server.crt: OK

下面要按照ssl.conf里面的设置，将证书放在适当的位置。

# chmod 400 server.key

# cd ..

# mv ssl.ca-0.1/server.key server.key

# mv ssl.ca-0.1/server.crt server.crt

然后就可以启动啦！

# cd /usr/local/apache2

# ./bin/apachectl start

在浏览器中https://127.0.0.1/svn/test就可以进行https用户验证啦!

subversion验证

./svn list https://localhost/svn/test

验证“https://localhost:443”的服务器凭证时发生错误：

- 本凭证并不是由受信任的权威机权所核发。请手动利用指纹以验证

凭证的有效性！

- 本凭证的主机名称不符。

凭证信息：

- 主机名称：www.yong.com

- 有效期间：自 Jan 25 07:55:48 2007 GMT 至 Jan 25 07:55:48 2008 GMT - 发行者：yong, jishi, dalian, liaoning, CN

- 指纹：49:c4:12:38:5e:03:df:52:64:eb:f4:02:b8:a4:f3:b0:2c:f7:8d:2a(R)拒绝，(t)暂时接受 或 (p)永远接受？t

填写证书密码

用户名

密码

登录成功!!!!!

//////////////////////////////////////////////////////

subversion基本操作

1.从服务器中拷贝库文件

#cd /usr/local/subversion/bin

#./svn checkout http://ip地址/svn/test

[root@localhost bin]# ./svn checkout http://192.168.9.5/svn/test

认证领域：<http://192.168.9.5:80> Subversion.zoneyump

“root”的密码：

认证领域：<http://192.168.9.5:80> Subversion.zoneyump

用户登录名：gy

“gy”的密码：

A test/index.html

A test/dianhuaben

A test/dianhuaben/chaxun.jsp

A test/dianhuaben/modify.jsp

A test/dianhuaben/work

A test/dianhuaben/work/tldCache.ser

A test/dianhuaben/work/org

A test/dianhuaben/work/org/apache

A test/dianhuaben/work/org/apache/jsp

A test/dianhuaben/work/org/apache/jsp/addtel_jsp.java

A test/dianhuaben/work/org/apache/jsp/selectAllTel_jsp.java

A test/dianhuaben/work/org/apache/jsp/addtel_jsp.class

A test/dianhuaben/work/org/apache/jsp/selectAllTel_jsp.class

A test/dianhuaben/work/SESSIONS.ser

A test/dianhuaben/.tomcatplugin

A test/dianhuaben/.project

A test/dianhuaben/modifytel.jsp

A test/dianhuaben/WEB-INF

A test/dianhuaben/WEB-INF/_desktop.ini

A test/dianhuaben/WEB-INF/lib

A test/dianhuaben/WEB-INF/src

A test/dianhuaben/WEB-INF/web.xml

A test/dianhuaben/WEB-INF/.cvsignore

A test/dianhuaben/WEB-INF/classes

A test/dianhuaben/WEB-INF/classes/com

A test/dianhuaben/WEB-INF/classes/com/Telbook.java

A test/dianhuaben/WEB-INF/classes/com/Telbook.class

A test/dianhuaben/WEB-INF/classes/com/DataBaseConnection.java

A test/dianhuaben/WEB-INF/classes/com/DataBaseConnection.class

A test/dianhuaben/WEB-INF/classes/com/TelBean.java

A test/dianhuaben/WEB-INF/classes/com/TelBean.class

A test/dianhuaben/modifydel1.jsp

A test/dianhuaben/addtel.jsp

A test/dianhuaben/modify.html

A test/dianhuaben/chanxun.jsp

A test/dianhuaben/addtel.html

A test/dianhuaben/.classpath

A test/dianhuaben/deletetel.jsp

A test/dianhuaben/deltel.jsp

A test/dianhuaben/selectAllTel.jsp

A test/dianhuaben/index.html

A test/dianhuaben/.cvsignore

取出修订版 1。

2. 发布你的修改给别人，你可以使用Subversion的提交（commit）命令

#./svn commit 项目名或文件名

[root@localhost bin]# ./svn commit test/index.html

日志信息未改变，或是未指定

a)中断，c)继续，e)编辑

c

正在发送 test/index.html

传输文件数据.

提交后的修订版为 3。

3.状态查询（status）

#./svn status 路径/项目名

L some_dir # svn已经在.svn目录锁定了some_dir

M bar.c # bar.c的内容已经在本地修改过了

M baz.c # baz.c属性有修改，但没有内容修改

X 3rd_party # 这个目录是外部定义的一部分

? foo.o # svn并没有管理foo.o

! some_dir # svn管理这个，但它可能丢失或者不完

~ qux # 作为file/dir/link进行了版本控制，但类型已经改变

I .screenrc # svn不管理这个，配置确定要忽略它

A + moved_dir # 包含历史的添加，历史记录了它的来历

M + moved_dir/README # 包含历史的添加，并有了本地修改

D stuff/fish.c # 这个文件预定要删除

A stuff/loot/bloo.h # 这个文件预定要添加

C stuff/loot/lump.c # 这个文件在更新时发生冲突

C stuff/loot/glub.c # 文件在更新时发生属性冲突

R xyz.c # 这个文件预定要被替换

S stuff/squawk # 这个文件已经跳转到了分支

K dog.jpg # 文件在本地锁定；有锁定令牌

O cat.jpg # 文件在版本库被其他用户锁定

B bird.jpg # 文件本地锁定，但锁定发生错误

T fish.jpg # 文件本地锁定，但锁定丢失

4.检查修改的方式是svn diff命令，你可以通过不带参数的svn diff精确的找出你所做的修改

#./svn diff 项目名

root@localhost bin]# ./svn diff test

Index: test/index.html

===================================================================

--- test/index.html （修订版 2）

+++ test/index.html （工作拷贝）

@@ -1,6 +1,6 @@

<html>

<head>

- <title>人才库</html>

+ <title>人才库资料</html>

<meta context="text/html;charset=UTF-8">

</head>

<body>

输出的格式为统一区别格式（unified diff format），删除的行前面加一个-，添加的行前面有一个+

svn diff命令也打印文件名和打补丁需要的信息，所以你可以通过重定向一个区别文件来生成“补丁”

#./svn diff 项目名 > 文件名

[root@localhost bin]# ./svn diff test > haha

[root@localhost bin]# ls

haha svn svndumpfilter svnserve svnversion

stn.dump svnadmin svnlook svnsync test

生成一个haha文件

5.添加文件或目录（add）

#./svn add 项目名/新建文件或目录

6.删除文件或目录（delete）

#./svn delete 项目名/删除的文件或目录

svn delete http://ip地址/svn_dir/repository/project_dir 这条命令刚好可以用来删除

7.列出仓库中的项目（list）

svn list --verbose

#./svn list --verbose file:///home/svnroot/repository/test/

[root@localhost bin]# ./svn list --verbose file:///home/svnroot/repository/test/

1 root 529 1月 25 14:16 .classpath

1 root 4 1月 25 14:16 .cvsignore

1 root 12288 1月 25 14:16 .genggai1.jsp.swp

1 root 425 1月 25 14:16 .project

1 root 358 1月 25 14:16 .tomcatplugin

1 root 1月 25 14:16 WEB-INF/

1 root 10 1月 25 14:16 _desktop.ini

1 root 29269 1月 25 14:16 a.gif

1 root 1172 1月 25 14:16 chaxun.jsp

1 root 1245 1月 25 14:16 genggai.jsp

1 root 1787 1月 25 14:16 genggai1.jsp

1 root 707 1月 25 14:16 genggai2.jsp

6 wooin 1月 26 12:10 hehe/

4 wooin 1047 1月 26 11:48 index.html

1 root 3719546 1月 25 14:16 love.mp3

1 root 3073 1月 25 14:16 rencaiku.txt

1 root 1243 1月 25 14:16 shanchu.jsp

1 root 409 1月 25 14:16 shanchu1.jsp

1 root 1073 1月 25 14:16 tianjia.html

1 root 813 1月 25 14:16 tianjia.jsp

1 root 1月 25 14:16 work/

////////////////////////////////////////////////////////////////////////

subversion的分支与合并

1.建立分支

#cd /usr/local/subversion/bin

#./svn copy http://192.168.9.53/svn/test http://192.168.9.53/svn/test/mycopy -m "copy a branch"

2.在分支上工作(导出分支到本地)

#./svn checkout http://192.168.9.53/svn/test/mycopy mycopy1

3.合并

#./svn merge -r 15:16 http://192.168.9.53/svn/test/mycopy test

http://blog.doesite.net/read.php?save_215

1.安装 subversion

# apt-get install subversion subversion-tools

创建一个新的储存库：

#svnadmin create /svn/repository

在/svn目录创建一个新的空储存库，数据储存方式默认采用Berkeley DB。

导入你的源码：

# svn import /svn/repository file:///data/svn/ldap

把/data/ldap整个目录导入到储存库中的repository目录中，储存库的repository目录会自动创建。

显示储存库内容：

mt@mtmt:~$ svn list file:///svn/repository

.cache/

.project

.projectOptions

.settings/

bbscnmo/

newcnmo/

显示目录内容，成功导入。

上面使用了file:///形式的URL来访问Subversion库，这表示在本地通过文件系统访问。但我们的Subversion库可能需要通过网络被其它用户访问，这就需要用到其它的协议，下表是Subversion支持的各种访问协议：

访问协议

协议 访问方法

file:/// 通过本地磁盘访问。

http:// 与Apache组合，通过WebDAV协议访问。

https:// 同上，但支持SSL协议加密连接。

svn:// 通过svnserve服务自定义的协议访问。

svn+ssh:// 同上，但通过SSH协议加密连接。

2.配置 subversion 与Apache组合通过WebDAV方式访问Subversion库

# apt-get install apache2 libapache2-svn

配置文件位于/etc/apache2/mods-enabled/目录下，配置文件共有两个，分别是dav_svn.conf和dav_svn.load，dav_svn.load文件负责装载必要的模块，内容如下：

# Load mod_dav_svn when apache starts

LoadModule dav_svn_module /usr/lib/apache2/modules/mod_dav_svn.so

LoadModule authz_svn_module /usr/lib/apache2/modules/mod_authz_svn.so

在装载mod_dav_svn.so前，必须先装载mod_dav.so模块。它由dav.load文件控制，内容如下：

LoadModule dav_module /usr/lib/apache2/modules/mod_dav.so

dav_svn.conf是mod_dav_svn.so模块的配置文件，内容如下：

# dav_svn.conf - Example Subversion/Apache configuration

#

# For details and further options see the Apache user manual and

# the Subversion book.

# …

# URL controls how the repository appears to the outside world.

# In this example clients access the repository as http://hostname/svn/

#设置访问路径

# Uncomment this to enable the repository,

DAV svn #启用by siko

# Set this to the path to your repository

SVNPath /data/subversion #设置储存库路径，仅支持单个储存库，该路径要可被Apache进程访问。

#SVNParentPath /data/subversion #如果subversion下有多个储存库，则用SVNParentPath

# The following allows for basic http authentication. Basic authentication

# should not be considered secure for any particularly rigorous definition of

# secure.

# to create a passwd file #按下面的步骤创建Apache用户验证文件

# # rm -f /etc/apache2/dav_svn.passwd

# # htpasswd2 -c /etc/apache2/dav_svn.passwd dwhedon

# New password:

# Re-type new password:

# Adding password for user dwhedon

# #

# Uncomment the following 3 lines to enable Basic Authentication

AuthType Basic #启用Apache基础验证

AuthName “Subversion Repository” #设置验证框标题

AuthUserFile /etc/apache2/dav_svn.passwd #指定验证用户文件名

# Uncomment the following line to enable Authz Authentication

AuthzSVNAccessFile /etc/apache2/dav_svn.authz #启用目录级别授权，dav_svn.authz是授权配置文档

# The following three lines allow anonymous read, but make

# committers authenticate themselves.

#

#允许匿名访问，不允许Commit，不能与AuthzSVNAccessFile同时使用

Require valid-user

#

修改/data/subversion目录访问权限使它可被Apache进程访问，我的Apache是用www-data启动的，所以设置方法如下：

# chown -R www-data.www-data /data/subversion

通 过Apache的用户验证功能可以区别匿名用户和验证用户，从而赋予匿名用户读权限和验证用户读/写的权限。这些权限只能在全局范围内设置，不能设置具体 的某个目录是否能被某个用户操作。要实现目录级别的授权，就要使用mod_authz_svn.so模块提供的 AuthzSVNAccessFile指令。它会指定一个授权文档，该授权文档设置具体的目录权限。根据上面的配置，授权文档名叫 dav_svn.authz，它的内容如下：

[groups] #定义组

admin=jims,ringkee

tests=tester1,tester2

[erp:/] #定义erp储存库根目录的访问权限

@admin=rw #admin组有读写权限

tests=r #test用户只有读权限

[oa:/test] #定义oa储存库下test目录的访问权限

*= #禁止所有用户访问，星号代表所有用户，权限为空代表没有任何权限

ringkee=rw #打开ringkee用户的读写权限

在该文件中使用的用户需在apache2的用户文件/etc/apache2/dav_svn.passwd中预先设置好。

3.安装trac #sudo apt-get install trac 配置TRAC

#cd /trac/

#trac-admin repository initenv

在运行trac-admin时有一步设置需要注意，就是”Path to repository”，要指向上面的/svn/repository

chown -R www-data.www-data /trac/repository

以CGI方式运行TRAC,有一些设置要做

建立密码文件:

htpasswd -c /somewhere/trac.htpasswd username

编辑apache的apache2.conf

#edit by siko@ 2006.11.24

ScriptAlias /trac /usr/share/trac/cgi-bin/trac.cgi

SetEnv TRAC_ENV “/trac/repository”

Alias /tracdoc “/usr/share/trac/htdocs/”

Options -Indexes -MultiViews

AllowOverride None

Order allow,deny

Allow from all

AuthType Basic

AuthName “Trac”

AuthUserFile /home/mt/trac.htpasswd

Require valid-user

重启apache使其生效

4. svn的eclipse插件 安装配置：

1.更新安装http://subclipse.tigris.org/update的subclipse插件

2.安装完成后eclipse会自动重启后，在svn的透视图中可以看到svn的相关菜单

3.将新的 SVN 资源库添加至“SVN 资源库。url为http://your_ip/svn

4.引用项目成功后，便可以用前面的用户名和密码来更新和提交工程内文件了。

5.subclipse的较新版本都是中文的，详细操作略。svn有很多的客户端，在此只通过命令行来操作，结合eclipse的插件来控制版本并不涉及任何客户端程序。

java -Xms256m -Xmx512m Diff /hbbi/bossjf/A0500220040628WH005.avl /hbbi/bossjf/A0500220040628WH005.avl

许多工具可以将JDK5的代码，编译成JDK1.4可以运行的代码，其中最好的有两个:

1.        http://retrotranslator.sourceforge.net/

2.        http://retroweaver.sourceforge.net/

The Reactor pattern has been introduced in  [Schmidt95] as a general architecture for event-driven systems. It explains how to register handlers for particular event types, and how to activate handlers when events occur, even when events come from multiple sources, in a single-threaded environment. In other words, the reactor allows for the combination of multiple event-loops, without introducing additional threads.

The Reactor pattern

• activate handlers when events occur
• allow events from multiple sources
• in single threaded process

See D.C. Schmidt, Using Design Patterns to Develop Reusable Object-oriented Communication Software, CACM October '95, 38(10): 65-74

slide: The Reactor pattern

The abstract layout of the software architecture needed to realize the pattern is depicted in slide reactor-structure. The reactor environment must allow for binding handlers to particular types of events. In addition, it must be able to receive events, and select a handler to which the event can be dispatched.

slide: The Reactor pattern -- structure

Events may be organized in a hierarchy. There are two possible choices here. Either the topmost event class has a fat interface, containing all the methods that an event may ever need to support, or the topmost event class can be lean, so that additional methods need to be added by the subclasses of event. The first solution is chosen for hush, because in C++ it is not possible to load new classes dynamically. The latter solution is the way Java does it. In Java new event types can be added at the reactor level without recompiling the system. In the Java AWT and Swing libraries, handlers are called Listeners.

Concrete handlers, derived from an abstract handler, must provide a method, such as operate(Event) that can be called by the reactor when the handler is selected after receiving an event.

slide: The Reactor Pattern - interaction

The interaction between the application, its handlers, the reactor and the environment from which the events originate is depicted in slide reactor-interaction. First, the reactor must be initialized, then one or more handlers can be registered, providing a binding for particular types of events. The reactor must then start to execute its eventloop. When it receives an event from the environment, it selects a handler and dispatches the event to that handler, by calling operate(Event).

Consequences

Modularity is one of the advantages of an event-driven software architecture. Handlers can be composed easily, since their invocation is controlled by the reactor. Another advantage is the decoupling of application-independent mechanisms from application-specific policies. In other words, handler objects need not be aware of how events are dispatched. This is the responsibility of the system or framework.

The fact that control is handed over to the environment has, however, also some disadvantages. First of all, as experience with student assignments shows, it is difficult to learn in the beginning. But even when mastered, applications may be hard to debug, since it is not always clear why a particular handler was invoked, and because it may be difficult to repeat the computation preceding the fault.

Applicability

Some variant of the reactor pattern is used in Unix (X) Windows, (MS) Windows, and also GUI libraries such as Interviews, ET++ and hush. Another example is the Orbacus object request broker, that supports a reactor mode for server objects, which allows for receiving messages from multiple sources in a single thread. The Orbacus broker, however, also allows for multi-threaded servers.

http://www.levilee.cn/Jeans/304/Play_9426_1/

1.     使用观察者(Observer)实现对象监听

观察者(Observer)是一种模式，也是Java中的一个API，它让一个值对象(Value Object)具备自省的功能，当他发现自己的状态改变了，就向相关的对象发送消息，这样的监听方式当然比轮询好。我感冒了自己会去医院，用不着医生每个月来问一次。

Java的Observer API是对观察者模式的一个实现。假设我们有一个对象容器，其中存放用户消息，我希望这个容器自省，当有新的消息进来就自动触发观察者作出响应。首先定义消息对象，是个很简单的值对象：

package com.gwnet.smsMessenger.mm.bromon;

public class Message

{

private int id;

private String sender;

private String receiver;

private String content;

private String time;

//请自己实现set/get方法，比如:

public int getId()

{

return id;

}

public void setId(int id)

{

this.id=id;

}

}

然后写一个存放Message的容器，容器使用ArrayList来存放对象是个很好的选择，也很简单：

package com.gwnet.smsMessenger.mm.bromon;

import java.util.*;

public class MessageList extends Observable

{

    private List m=new ArrayList();

    private static MessageList ml=null;

    public MessageList()

    {

    }

    public static MessageList getInstance()

    {

        if(ml==null)

       {

           ml=new MessageList();

       }

        return ml;

    }

    public void add(Message msg)

    {

        m.add(msg);

        super.setChanged();

        super.notifyObservers(m);

    }

    public void del(Message msg)

    {

        m.remove(msg);

    }

}

这个类继承了Observable类，并且对其中的add方法做了手脚，很明显，add方法的作用是向ArrayList容器中放入一个对象，这正是我们想监听的操作，所以有了:

uper.setChanged();

super.notifyObservers(m);

这意思是一旦调用add方法，这个类自己就会向所有注册过的观察者发送消息，消息内容是什么呢？内容就是m，是存放消息的容器，观察者可以收到这个改变了状态的容器，然后对它进行操作，从而实现了对容器的监听，当然，我们只实现了对add方法的监听，你也可以试试其他的。

需要特别注意的是这是一个不完整的单例类，写成单例是为了要保证整个jvm中只有这一个存放消息的容器，而不写成完整的单例，原因是将来可能要提供另外的实例化方法。所以理解起来可能稍微难一点，大家可以参考一下设计模式中的单例模式。

下面就是编写观察者并且注册它：

package com.gwnet.smsMessenger.bromon;

import java.util.*;

public class MessageObserver implements Observer

{

    public void update(Observable arg0, Object arg1)

    {

       List l=(List)arg1;

        Message m=(Message)l.get(l.size()-1);

        String receiver=m.getReceiver();

        System.out.println("给"+m.getReceiver()+”的新消息:”+m.getContent());

    }

}

这个类继承Oberver接口，update(Observable,Object)是必须提供的方法，在这个方法中我们接收被观察类传过来的数据（含有消息的容器），然后取出其中最后一个，读取它的内容。

Java里的观察者使用起来是非常简单的。我们的例子好处是所有的操作都在内存中进行，而且不需要轮询，效率非常高，缺点是一旦当机内存中的数据就丢失了，所以如果有一套比较完善的对象缓冲机制，就可以应付复杂的应用，写出高效简洁的多线程服务器。

http://www.cnblogs.com/goodcandle/archive/2006/04/05/observerext.html

2.        Observer模式为何要区分推拉模式

       先来比较两张UML图：

推模式

拉模式

       两者的区别我再罗嗦一下，推模式是当通知消息来之时，把所有相关信息都通过参数的形式“推给”观察者。而拉模式是当通知消息来之时，通知的函数不带任何相关的信息，而是要观察者主动去“拉”信息。

       推模式的优点：

是当消息来临时，观察者很直接地都到信息，然后进行相关地处理，与被观察者没有一点联系，两者几乎没有耦合。

       推模式的缺点：

是当消息来临时，所有的信息都强迫观察者，不管有用与否。还有一个致命的缺点是，如果想在通知消息中添加一个参数，那么所有的观察者都需要修改了，这一点往往被忽视。

       看来事物都有其两面性一点都不假，信息太全也不是一件好事。

       “存在即有理由”，为了弥补推模式的不足，拉模式就诞生了。

       就接着上面的例子，如果CPerson2想要都到秒的信息，按推模式来说，CPerson1也就需要修改了，然而用拉模式，各个观测者之间就没有什么联系了，因为具体的信息还要观测者主动去“拉”，而一旦有了主动权，各个观察者想拉什么信息就取决于具体的观察者了，这样CPerson1就无需修改了，只要在CNotifyBase中再添加一个接口函数就行了（GetSecond）。

       Q：那CClockDevice不是还要修改吗？

       A：修改是难免的，使用设计模式的目的不是不允许修改，而是让软件更易扩展，更易扩展体现在哪里呢？那就是让修改处尽可能的减少。看到UML图中那1和*了吗？你现在应该明白了吧？被观察者只要一个，而且不太会更改，而观察者确有很多。让你选择，你会选择修改什么呢？

       当然拉模式的缺点也是存在的，那就是：

和被观察者有一定的耦合，但我们可以通过接口，把耦合降到最低。

下面是观察者模式其它一些优缺点:

1 ) 目标和观察者间的抽象耦合一个目标所知道的仅仅是它有一系列观察者, 每个都符合抽象的O b s e r v e r类的简单接口。目标不知道任何一个观察者属于哪一个具体的类。这样目标和观察者之间的耦合是抽象的和最小的。

因为目标和观察者不是紧密耦合的, 它们可以属于一个系统中的不同抽象层次。一个处于较低层次的目标对象可与一个处于较高层次的观察者通信并通知它, 这样就保持了系统层次的完整。如果目标和观察者混在一块, 那么得到的对象要么横贯两个层次(违反了层次性), 要么必须放在这两层的某一层中(这可能会损害层次抽象)。

2) 支持广播通信不像通常的请求, 目标发送的通知不需指定它的接收者。通知被自动广播给所有已向该目标对象登记的有关对象。目标对象并不关心到底有多少对象对自己感兴趣;它唯一的责任就是通知它的各观察者。这给了你在任何时刻增加和删除观察者的自由。处理还是忽略一个通知取决于观察者。

3) 意外的更新因为一个观察者并不知道其它观察者的存在, 它可能对改变目标的最终代价一无所知。在目标上一个看似无害的操作可能会引起一系列对观察者以及依赖于这些观察者的那些对象的更新。此外, 如果依赖准则的定义或维护不当，常常会引起错误的更新, 这种错误通常很难捕捉。

简单的更新协议不提供具体细节说明目标中什么被改变了, 这就使得上述问题更加严重。

如果没有其他协议帮助观察者发现什么发生了改变，它们可能会被迫尽力减少改变。

这一节讨论一些与实现依赖机制相关的问题。

1) 创建目标到其观察者之间的映射一个目标对象跟踪它应通知的观察者的最简单的方法是显式地在目标中保存对它们的引用。然而, 当目标很多而观察者较少时, 这样存储可能代价太高。一个解决办法是用时间换空间, 用一个关联查找机制(例如一个h a s h表)来维护目标到观察者的映射。这样一个没有观察者的目标就不产生存储开销。但另一方面, 这一方法增加了访问观察者的开销。

2) 观察多个目标在某些情况下, 一个观察者依赖于多个目标可能是有意义的。例如, 一个表格对象可能依赖于多个数据源。在这种情况下, 必须扩展U p d a t e接口以使观察者知道是哪一个目标送来的通知。目标对象可以简单地将自己作为U p d a t e操作的一个参数, 让观察者知道应去检查哪一个目标。

3) 谁触发更新目标和它的观察者依赖于通知机制来保持一致。但到底哪一个对象调用N o t i f y来触发更新? 此时有两个选择:

a) 由目标对象的状态设定操作在改变目标对象的状态后自动调用N o t i f y。这种方法的优点是客户不需要记住要在目标对象上调用N o t i f y，缺点是多个连续的操作会产生多次连续的更新, 可能效率较低。

b) 让客户负责在适当的时候调用N o t i f y。这样做的优点是客户可以在一系列的状态改变完成后再一次性地触发更新,避免了不必要的中间更新。缺点是给客户增加了触发更新的责任。由于客户可能会忘记调用N o t i f y，这种方式较易出错。

4) 对已删除目标的悬挂引用删除一个目标时应注意不要在其观察者中遗留对该目标的悬挂引用。一种避免悬挂引用的方法是, 当一个目标被删除时，让它通知它的观察者将对该目标的引用复位。一般来说, 不能简单地删除观察者, 因为其他的对象可能会引用它们, 或者也可能它们还在观察其他的目标。

5) 在发出通知前确保目标的状态自身是一致的在发出通知前确保状态自身一致这一点很重要, 因为观察者在更新其状态的过程中需要查询目标的当前状态。当S u b j e c t的子类调用继承的该项操作时, 很容易无意中违反这条自身一致的准则。你可以用抽象的S u b j e c t类中的模板方法( Template Method(5.10))发送通知来避免这种错误。定义那些子类可以重定义的原语操作, 并将N o t i f y作为模板方法中的最后一个操作, 这样当子类重定义了S u b j e c t的操作时，还可以保证该对象的状态是自身一致的。

6) 避免特定于观察者的更新协议-推/拉模型观察者模式的实现经常需要让目标广播关于其改变的其他一些信息。目标将这些信息作为U p d a t e操作一个参数传递出去。这些信息的量可能很小，也可能很大。一个极端情况是，目标向观察者发送关于改变的详细信息, 而不管它们需要与否。我们称之为推模型(push model)。另一个极端是拉模型(pull model); 目标除最小通知外什么也不送出,而在此之后由观察者显式地向目标询问细节。

拉模型强调的是目标不知道它的观察者, 而推模型假定目标知道一些观察者的需要的信息。

推模型可能使得观察者相对难以复用，因为目标对观察者的假定可能并不总是正确的。

另一方面。拉模型可能效率较差, 因为观察者对象需在没有目标对象帮助的情况下确定什么改变了。

7) 显式地指定感兴趣的改变你可以扩展目标的注册接口,让各观察者注册为仅对特定事件感兴趣，以提高更新的效率。当一个事件发生时, 目标仅通知那些已注册为对该事件感兴趣的观察者。支持这种做法一种途径是，对使用目标对象的方面（a s p e c t s）的概念。可用如下代码将观察者对象注册为对目标对象的某特定事件感兴趣：

void Subject::Attach(Observer*, Aspect& interest);

此处i n t e r e s t指定感兴趣的事件。在通知的时刻, 目标将这方面的改变作为U p d a t e操作的一个参数提供给它的观察者，例如:

void Observer::Update(Subject*, Aspect& interest);

8) 封装复杂的更新语义当目标和观察者间的依赖关系特别复杂时, 可能需要一个维护这些关系的对象。我们称这样的对象为更改管理器（C h a n g e M a n a g e r）。它的目的是尽量减少观察者反映其目标的状态变化所需的工作量。例如, 如果一个操作涉及到对几个相互依赖的目标进行改动, 就必须保证仅在所有的目标都已更改完毕后，才一次性地通知它们的观察者,而不是每个目标都通知观察者。

C h a n g e M a n a g e r有三个责任:

a) 它将一个目标映射到它的观察者并提供一个接口来维护这个映射。这就不需要由目标来维护对其观察者的引用, 反之亦然。

b) 它定义一个特定的更新策略。

c) 根据一个目标的请求, 它更新所有依赖于这个目标的观察者。

有两种特殊的C h a n g e M a n a g e r。S i m p l e C h a n g e M a n a g e r总是更新每一个目标的所有观察者, 比较简单。相反,D A G C h a n g e M a n a g e r处理目标及其观察者之间依赖关系构成的无环有向图。当一个观察者观察多个目标时, DAGChangeManager要比S i m p l e C h a n g e M a n a g e r更好一些。在这种情况下, 两个或更多个目标中产生的改变可能会产生冗余的更新。D A G C h a n g e M a n a g e r保证观察者仅接收一个更新。当然，当不存在多重更新的问题时, SimpleChangeManager更好一些。

C h a n g e M a n a g e r是一个M e d i a t o r ( 5 . 5 )模式的实例。通常只有一个C h a n g e M a n a g e r, 并且它是全局可见的。这里S i n g l e t o n ( 3 . 5 )模式可能有用。

9) 结合目标类和观察者类用不支持多重继承的语言(如S m a l l t a l k )书写的类库通常不单独定义S u b j e c t和O b s e r v e r类, 而是将它们的接口结合到一个类中。这就允许你定义一个既是一个目标又是一个观察者的对象，而不需要多重继承。例如在S m a l l t a l k中, Subject和O b s e r v e r接口

http://www.javaeye.com/topic/37302

1.泛化(Generalization)
[泛化]
表示类与类之间的继承关系，接口与接口之间的继承关系，或类对接口的实现关系。一般化的关系是从子类指向父类的，与继承或实现的方法相反。
[具体表现]
父类 父类实例＝new 子类()
[UML图](图1.1)

图1.1 Animal类与Tiger类,Dog类的泛化关系

[代码表现]

1. class Animal{}   
2. class Tiger extends Animal{}   
3. public class Test   
4. {   
5.     public void test()   
6.     {   
7.         Animal a=new Tiger();   
8.     }   
9. }  

2.依赖(Dependency)
[依赖]
对于两个相对独立的对象，当一个对象负责构造另一个对象的实例，或者依赖另一个对象的服务时，这两个对象之间主要体现为依赖关系。
[具体表现]
依赖关系表现在局部变量，方法的参数，以及对静态方法的调用
[现实例子]
比如说你要去拧螺丝，你是不是要借助(也就是依赖)螺丝刀(Screwdriver)来帮助你完成拧螺丝(screw)的工作
[UML表现](图1.2)

图1.2 Person类与Screwdriver类的依赖关系

[代码表现]

1. public class Person{   
2.     /** 拧螺丝 */  
3.     public void screw(Screwdriver screwdriver){   
4.         screwdriver.screw();   
5.     }   
6. }  

3.关联(Association)
[关联]
对于两个相对独立的对象，当一个对象的实例与另一个对象的一些特定实例存在固定的对应关系时，这两个对象之间为关联关系。
[具体表现]
关联关系是使用实例变量来实现
[现实例子]
比如客户和订单，每个订单对应特定的客户，每个客户对应一些特定的订单；再例如公司和员工，每个公司对应一些特定的员工，每个员工对应一特定的公司
[UML图] (图1.3)

图1.3 公司和员工的关联关系

[代码表现]

1. public class Company{   
2.     private Employee employee;   
3.     public Employee getEmployee(){   
4.         return employee;   
5.     }   
6.     public void setEmployee(Employee employee){   
7.         this.employee=employee;   
8.     }   
9.     //公司运作   
10.     public void run(){   
11.         employee.startWorking();   
12.     }   
13. }  

(4)聚合（Aggregation）
[聚合]
当对象A被加入到对象B中，成为对象B的组成部分时，对象B和对象A之间为聚集关系。聚合是关联关系的一种，是较强的关联关系，强调的是整体与部分之间的关系。
[具体表现]
与关联关系一样，聚合关系也是通过实例变量来实现这样关系的。关联关系和聚合关系来语法上是没办法区分的，从语义上才能更好的区分两者的区别。
[关联与聚合的区别]
(1)关联关系所涉及的两个对象是处在同一个层次上的。比如人和自行车就是一种关联关系，而不是聚合关系，因为人不是由自行车组成的。
聚合关系涉及的两个对象处于不平等的层次上，一个代表整体，一个代表部分。比如电脑和它的显示器、键盘、主板以及内存就是聚集关系，因为主板是电脑的组成部分。
(2)对于具有聚集关系（尤其是强聚集关系）的两个对象，整体对象会制约它的组成对象的生命周期。部分类的对象不能单独存在，它的生命周期依赖于整体类的对象的生命周期，当整体消失，部分也就随之消失。比如张三的电脑被偷了，那么电脑的所有组件也不存在了，除非张三事先把一些电脑的组件（比如硬盘和内存）拆了下来。
[UML图](图1.4)

图1.3 电脑和组件的聚合关系

[代码表现]

1. public class Computer{   
2.     private CPU cpu;   
3.     public CPU getCPU(){   
4.         return cpu;   
5.     }   
6.     public void setCPU(CPU cpu){   
7.         this.cpu=cpu;   
8.     }   
9.     //开启电脑   
10.     public void start(){   
11.         //cpu运作   
12.         cpu.run();   
13.     }   
14. }  

JProfiler 是一个著名的用于 java 系统监控分析的软件，功能很强大，可以监控普通的 java application, applet, java web start, application server 等等。除了可以监控本地的程序，还可以对远程服务器上跑的应用进行监控。

http://resources.ej-technologies.com/jprofiler/help/doc/indexRedirect.html?http&&&resources.ej-technologies.com/jprofiler/help/doc/ide/eclipse3.html

一、        JProfiler as an Eclipse 3.x Plugin

  When JProfiler is integrated into the eclipse 3.x IDE, JProfiler can be invoked from within the IDE without any further need for session configuration.

Requirements: The eclipse 3.x plugins work with the full SDKs for eclipse 3.0 and eclipse 3.1. The JProfiler integration does not work with partial installations of the eclipse framework. For eclipse 2.x, a different plugin is available.

  The installation of the eclipse plugin is started by selecting "eclipse 3.0" or "eclipse 3.1" on the

• IDE integration tab of JProfiler's setup wizard
• miscellaneous options tab of JProfiler's general settings (use Session->IDE integrations in JProfiler's main menu as a shortcut).

and clicking on [Integrate]

Reminder: Please close eclipse while performing the plugin installation. If you are performing the installation from JProfiler's setup wizard, please complete the entire setup first before starting eclipse.

A file selector will then prompt you to locate the installation directory of eclipse.

After acknowledging the completion message, you can start eclipse and check whether the installation was successful. If the menu item Run->Profile ... does not exist in the Java perspective, please enable the "Profile" actions for this perspective under Window->Customize perspective by bringing the Command tab to front and selecting the "Profile" checkbox.

eclipse provides shared infrastructure for profiling plugins that allows only one active profiler at a time. If another profiler has registered itself in eclipse, JProfiler will show a collision message dialog at startup. Please go to the plugin directory in your eclipse installation and delete the plugins that are specified in the warning message in order to guarantee that JProfiler will be used when you click on one of the profiling actions.

If you are upgrading the integration from JProfiler <=3.2, please delete your Eclipse "configuration" directory except the config.ini file before restarting Eclipse. This is to avoid a common Eclipse 3.x plugin cache bug.

  To profile your application from eclipse, choose one of the profiling commands in the Run menu or click on the corresponding toolbar button. The profile commands are equivalent to the debug and run commands in eclipse and are part of eclipse's infrastructure.

Main eclipse toolbar with "Profile" button
 

eclipse "Run" menu with "Profile" actions
 

The profiled application is then started just as with the usual "Run" commands. If no instance of JProfiler is currently running, JProfiler is also started, otherwise the running instance of JProfiler will be used for presenting profiling data.

Every time a run configuration is profiled, a dialog box is brought up that asks you whether a new window should be opened in JProfiler. To get rid of this dialog, you can select the "Don't ask me again" checkbox. The window policy can subsequently be configured in the JProfiler settings in eclipse (see below).

All profiling settings and view settings changes are persistent across session restarts.

When JProfiler is used with the eclipse integration, the "Show source" action for a class or a method in one of JProfiler's view will show the source element in eclipse and not in JProfiler's integrated source code viewer.

  Several JProfiler-related settings can be adjusted in eclipse under Window->Preferences->JProfiler:

• The used JProfiler installation can be changed by repeating the integration from JProfiler or by adjusting the JProfiler executable in the corresponding text field. When you upgrade to a newer version of JProfiler, make sure to repeat the integration, since the plugin has to be updated, too.
• The window policy can be configured as
• Ask each time
  Every time you profile a run configuration, a dialog box will ask you whether a new window should be opened in JProfiler. This is the default setting.
• Always new window
  Every time you profile a run configuration, a new window will be opened in JProfiler.
• Reuse last window
  Every time you profile a run configuration, the last window will be reused in JProfiler.
• You can manually repeat the collision detection that is performed at startup. With the corresponding checkbox, you can also switch off collision detection at startup.

·         You can ask JProfiler to always use interpreted mode for profiling. A separate checkbox tells JProfiler to use the deprecated JVMPI interface when profiling with a 1.5 JRE. Both these settings are trouble-shooting options and should normally not be selected.

  For eclipse 3.2 and higher, profiling WTP run configurations is supported.

二、        Overview of Features

  JProfiler's features are ordered into view sections. A view section can be made visible by selecting in JProfiler's sidebar. JProfiler offers the following view sections:

• Memory profiling
  Keep track of your objects and find out where the problem spots are.
• The heap walker
  Use the drill down capabilities of JProfiler's unique heap walker to find memory leaks.
• CPU profiling
  Find out where your CPU time is going and zero in on performance bottlenecks.
• Thread profiling
  Check the activity of your threads, resolve deadlocks and get detailed information on your application's monitor usage.

·         VM telemetry information
Unfold the statistical history of your application with JProfiler's virtual machine telemetry monitors.

  In order to help you find JProfiler's features which are most important to you, we present a situational overview. There are two types of uses for a profiler which arise from different motivations:

• Problem solving
  If you turn to a profiler with a problem in your application, it most likely falls into one of the following three categories:
• Performance problem
  To find performance related problem spots in your application, turn to JProfiler's CPU section. Often, performance problems are caused by excessive creation of temporary objects. For that case, the recorded objects views with its view mode set to "garbage collected objects" will show you where efforts to reduce allocations make sense.
• Excessive memory consumption
  If your application consumes too much memory, the memory views will show you where the memory consumption comes from. With the reference views in the heap walker you can find out which objects are unnecessarily kept alive in the heap.
• Memory leak
  If your application's memory consumption goes up linearly with time, you likely have a memory leak which is show stopper especially for application servers. The "mark current values and show differences" feature in the memory section and the heap walker will help you to find the cause.
• Deadlock
  If you experience a deadlock, JProfiler's deadlock detection graph will help you to find the cause even for complex locking situations.
• Hard to find bug
  A often overlooked but highly profitable use of a profiler is that of debugging. Many kinds of bugs are exceptionally hard to find by hand or by using a traditional debugger. Some bugs revolve around complex call stack scenarios (have a look at the CPU section), others around entangled object reference graphs (have a look at the heap walker section), both of which are not easy to keep track of.
  Particularly JProfiler's thread views are of great help in multi-threaded situations, where race-conditions and deadlocks are hard to track down.

·         Quality assurance
During a development process, it's a good idea to regularly run a profiler on your application to assess potential problem spots. Even though an application may prove to be "good enough" in test cases, an awareness for performance and memory bottlenecks enables you adapt your design decisions as the project evolves. In this way you avoid costly re-engineering when real-world needs are not met. Use the information presented in JProfiler's telemetry section to keep an eye on the evolution of your application. The ability to save profiling snapshots enables you to keep track of your project's evolution. The offline profiling capability allows you to perform automated profiling runs on your application.

三、        Finding a Memory Leak

1. Introduction

Unlike C/C++, Java has a garbage collector that eventually frees all unreferenced instances. This means that there are no classic memory leaks in Java where you forget to delete an object or a memory region. However, in Java you can forget something else: to remove all references to an instance so that the object can be garbage collected. If an object is only ever held in a single location, this may seem simple, but in many complex systems objects are passed around through many layers, each of which can add a permanent reference to the object.

Sometimes it appears to be clear that an object should be garbage collected when looking at the local environment of where the object is created and discarded. However, any call to a different part of a system that passes the object as a parameter can cause the object to "escape" if the receiver intentionally or by mistake continues to hold a reference to the object after the call has completed. Often, over-eager caching with the intention to improve performance or design mistakes where parallel access structures are built are the reason for memory leaks.

2. Recognizing a memory leak

The first step when suspecting a memory leak is to look at the heap and object telemetry views. When you have a memory leak in your application, these graphs must show a linear positive trend with possible oscillations on top.

If there's no such linear trend, your application probably simply consumes a lot of memory. This is not a memory leak and the strategy for that case is straightforward: Find out which classes or arrays use a lot of memory and try to reduce their size or number or instances.

3. Using differencing to narrow down a memory leak

The first stop when looking for the origin of a memory leak is the differencing action of the all objects view and the recorded objects view. Simple memory leaks can sometimes be tracked down with the differencing function alone.

First, you observe the differences in the all objects view or the recorded objects view and find out which class is causing the problems. Then you switch to the allocation hotspots view, select the problematic class and observe in the difference column in which method the problematic instances are allocated. Now you know the method in which these instances were created.

An analysis of the code for this method and the methods to which these instances are passed may already yield the solution to the memory leak. If not, you have to continue with the heap walker.

Another tool to observe instance counts that also presents a history of values is the class tracker. The class tracker shows graphs of instance counts versus time for selected classes and packages. When the difference columns in the "all objects" or "recorded objects" views identify suspicious classes, the class tracker can often generate further insight into the evolution of these instance counts since you can correlate jumps or increases in the allocation rate with other telemetry views or bookmarks.

4. The heap walker and memory leaks

When you take a heap snapshot, you first have to create an object set with those object instances or arrays that should be freed by the garbage collector but are still referenced somewhere. If you've already narrowed down the origin of the memory leak in the dynamic memory views, you can use the "Take heap snapshot for selection" action to save you some work and to start in the heap walker right at the point where you left off in the dynamic memory views.

By default, the heap walker cleans a heap snapshot from objects that are unreferenced but are still not collected by the garbage collector. This behavior can be controlled by the "Remove unreferenced and weakly referenced objects" option in the heap walker options dialog. When searching for a memory leak, this "full garbage collection" is desirable, since unreferenced objects are a temporary phenomenon without any connection to a memory leak.

If necessary, you can now further narrow down the memory leak by adding additional selection steps. For example, you can go to the data view and look at the instance data to find out a number of instances that definitely should have been freed. By flagging these instances and creating a new set of objects you can reduce the number of objects that are in your focus.

5. Using the reference graph to find the reason for a memory leak

The core instrument for finding memory leaks is the reference graph in the heap walker. Here you can find out how single objects are referenced and why they're not garbage collected. By successively opening incoming references you may spot a "wrong" reference immediately. In complex systems this is often not possible. In that case you have to find one or multiple "garbage collector roots". Garbage collector roots are points in the JVM that are not subject to garbage collection. These roots emanate strong references, any object that is linked by a chain of references to such a root cannot be garbage collected.

When you right-click on an object in the reference view, the context menu offers the option to search for paths to the garbage collector roots:

Potentially there are very many garbage collector roots and displaying them all can lead to the situation that a sizable fraction of the entire heap has to be shown in the reference graph. Also, looking for garbage collector roots is computationally quite expensive, and if thousands of roots can be found, the computation can take very long and use a lot of memory. In order to prevent this, it is recommend to start with a single garbage collector root and search for more roots if required. An option dialog is displayed after you trigger the search:

As you can see in this example, the chain to a garbage collector root can be quite long:

The reason for a memory leak can be anywhere along this chain. It is of a semantic nature and cannot be found out by JProfiler, but only by the programmer. Once you have found the faulty reference, you can work on your code to remove it. Unless there are other references, the memory leak will be gone.

6. Using the cumulated references views to find the reason for a memory leak

In some cases, you might not succeed in narrowing down the object set to a reasonable size. You object set might still contain a large number of instances that are OK and using the reference graph might not provide any insight in this situation.

If such a situation arises, the cumulated reference tables available in the reference view of the heap walker can be of help. The cumulated incoming reference table shows all possible reference types into the current object set:

From the reference type, you may be able to narrow down the object set. For example, you may know that one type of reference is OK, but another is not. As a hypothetical example, the reference from HashMap$Entry in the table above might be OK, but the reference from java.util.jar.Manifest might be suspicious. By selecting the 8 objects who are referenced in this way, you can discard the other 224 instances and use the reference graph to show the path to a garbage collector root.

四、        JProfiler's Menu

JProfiler's toolbar and menu contain actions applicable to all views as well as actions which are view-sensitive or appear for certain views only. The common menu and toolbar entries fall into six categories:

  The session menu contains actions to create, open and close sessions and snapshots.

• Start center
  (CTRL-O) Brings up JProfiler's start center. If there already is an open session in the current window, it will be discarded once a new session is opened. This action is also available from JProfiler's toolbar.
• New window
  (CTRL-ALT-O) Open in a new instance of JProfiler's main window and brings up JProfiler's start center.
• New session
  (CTRL-N) Creates a new session and brings up the application settings dialog. The new session will be started after leaving the dialog with [OK]. If there is already an open session in the current window, it will be discarded.
• Integration wizards
  This submenu contains the starting points for the application server integration wizards, just like the "New session" tab on the start center.
• Conversion wizards
  This submenu contains the starting points for the conversion wizards, just like the "Convert" tab on the start center.
• Open session
  Brings up the open session dialog. If there already is an open session in the current window, it will be discarded once a new session is opened.
• Save snapshot
  (CTRL-S) Brings up a file chooser to select a snapshot file to be written. A dialog box informs about the successful completion of the operation. This action is also available from JProfiler's toolbar.
• Open snapshot
  Brings up a file chooser to select a snapshot file to be opened. If there already is an open session in the current window, it will be discarded.
• Session settings
  Brings up the session settings dialog. Note that any changes here become effective only when the session is restarted.
• General settings
  Brings up the general settings dialog.
• IDE integrations
  Short cut to the IDE integrations tab of the general settings dialog where you can integrate all supported IDEs.
• Close window
  (CTRL-W) Closes the current window. If there is an open session in the current window, you will be asked for confirmation.

·         Exit JProfiler
(CTRL-ALT-X) After confirmation, closes all open main windows and exits JProfiler.

  The view menu contains view-specific actions and gives access to the view settings dialog. View specific actions are described in the help page of the corresponding view.

·         View settings
(CTRL-T) Brings up the view settings dialog for the corresponding view. If disabled, the currently active view has no particular settings. This action is also available from JProfiler's toolbar.

  The profiling menu contains actions which change the window or session as a whole.

• Stop/Detach/Start/Attach session
  (F11) This action is also available from JProfiler's toolbar.
•  Stops the session (all session types except remote session), i.e. the process is destroyed. In a stopped session, the profiling views are not fully functional (visible if currently started and not remote session).
•  Detaches the current remote session. The profiled JVM will be detached from JProfiler's front end and continues to run undisturbed. In a detached session, the profiling views are not fully functional (visible if currently attached and remote session).
• Starts the application configured in the current session if it is a local session, applet session or Web Start session (visible if currently detached and not remote session).
• Attaches the current remote session to a remote application or reconnects to it. (visible if currently detached and remote session).
• Freeze/Unfreeze session
  (F12) This action is also available from JProfiler's toolbar.
• Freeze all views for the current session (visible if currently not frozen).
• Unfreeze all views for the current session (visible if currently frozen).
• Get current data
  (F5) Update all views with the current data. If the current session is frozen, this action reloads all views and is also available from JProfiler's toolbar. If the session is not frozen, only the current view is updated. This action only has an effect on dynamic views that get auto-updated, views where data is calculated on demand are not re-calculated with this action.
• Record allocation data
  This action is also available from JProfiler's toolbar. The memory views and some telemetry views rely on allocation data.
• Start recording allocation data. (visible if allocations are currently not recorded). Adds a bookmark with a solid line to all graph views with a time axis.
• Stop recording allocation data. (visible if allocations are currently recorded). Adds a bookmark with a dashed line to all graph views with a time axis.
• Record CPU data
  This action is also available from JProfiler's toolbar. The CPU views rely on CPU data.
• Start recording CPU data. (visible if CPU data is currently not recorded). Adds a bookmark with a solid line to all graph views with a time axis.
• Stop recording CPU data. (visible if CPU data is currently recorded). Adds a bookmark with a dashed line to all graph views with a time axis.
• Save HPROF snapshot
  Brings up a dialog to select a path for an HPROF snapshot file to be saved. A dialog box informs about the successful completion of the operation.
• Run garbage collector
  Run the garbage collector in the profiled JVM. This action is also available from JProfiler's toolbar.
• Add bookmark
  Add a bookmark in all graph views with a time axis. Bookmarks can be renamed or deleted by right-clicking them and choosing the appropriate action from the context menu. Bookmarks can also be set programmatically from the profiling API.

·         Show global filters for method call recording
Show a dialog with a tree view of all exclusive or inclusive filters that JProfiler uses when recording the method call tree. This action is also available at the bottom of several views that show call trees.

  The go to menu provides one-click access to all of JProfiler's profiling views, grouped into the four         view sections.

  The window menu allows you to keep track of all tops level windows created by JProfiler.

• Undock/Dock view
  (CTRL-E) This action is also available from the context menu when right clicking the view in the tab selector at the bottom of the window.
•  Undocks the view and shows it in a separate top level window. (visible if the currently active view is docked into the main window)
•  Docks the view and returns it to the main window. (visible if the currently active view is undocked)
• Dock all floating views
  Docks all currently undocked views into their main windows.
• Cycle to previous window
  (CTRL-F2) Activate the previous window in the window list and bring it to the front.
• Cycle to next window
  (CTRL-F3) Activate the next window in the window list and bring it to the front.
• Tile all undocked views
  Tile the desktop with all undocked views.
• Stack all undocked views
  Resize all undocked views to a standard size and stack them regularly on the desktop.
• Close unused console windows
  Close all console windows that do not have an active process associated with them.

At the bottom of the window menu you can directly navigate to a window by selecting it from the list.

  The help menu gives access to help, web sites, and useful e-mail addresses for JProfiler.

• Help contents
  (F1) Brings up context sensitive help. This action is also available from JProfiler's toolbar.
• JProfiler on the web
  Connects to JProfiler's web site in the web browser configured under general settings.
• Contact sales
  Brings up a sales contact form in the web browser configured under general settings.
• Contact support
  Brings up a support contact form in the web browser configured under general settings.
• Enter license key
  Allows you to enter your license key.

·         About JProfiler
Shows general information about your copy of JProfiler and its license status.

1.         下载软件JProfile4.2.2(for windows版本)

2.         安装JProfile，License使用如下信息

Name: License for You

Lincese Code: A-G667#42616F-10kg1r134fq9m#2217

http://blog.csdn.net/samlei/archive/2007/03/16/1531510.aspx

摘要：不当的O/R-Mapping框架使用，导致垃圾对象的生成。

最近用JProfile测试一个比较大的工程，希望能找到一些程序运行的瓶颈。过去使用Hibernate，很多人反映效率低。特别是懒加载关闭的时候，对象的持续生成最后会导致JVM直接OutOfMemory错误。目前使用iBatis，发现临时对象还是特别多，一开始百思不解。通过使用JProfile以后，终于找到了原因所在。

对象引用关系：baseView ->InstanceModel -> City

其中，baseView 引用了InstanceMode，而InstanceMode 引用了City对象，City对象是一个比较简单的对象，只有id、name、中文名称等属性。在工程实际使用环境中，InstanceModel 是比较多的，可能会有数万经常被使用。通过对JVM堆的观察，发现每次InstanceModel对象生成的时候，都会附带出大量的City对象。由于一般应用中City的个数都有限，所以程序中专门对City对象作了缓存。为什么会产生大量City的临时对象呢？

通过在JProfile中查看堆的情况，可以很清楚的看到上述引用关系。这很正常啊？纳闷中，反复查看堆、对象、引用关系等信息，终于发现了线索。那就是，被引用的City对象中只有ID值，没有中文名称等其他信息。这就让我们找到了突破口，通过与开发工程师的交谈，被告知只使用了ID值，没有使用其他的属性。于是我们找到iBatis加载baseView对象的映射文件：

    <resultMap id="baseView" class="View">

               …

        <result column="CITYCODE"

            property="InstanceModel.city.id" jdbcType="NUMERIC"         />

    </resultMap>

注意，在上面这个定义文件中，加载View对象的时候，从同一张数据库表中，加载了View所属的City的代码（id）。但是iBatis框架在达到这个目的的同时，生成了一个临时City对象，并把ID赋了值。这就是原因！！

好了，原因找到了，优化的方案自然就出来了。只需要去掉InstanceModel对City对象的引用，直接取City的ID就行了！再次运行JProfile，发现不再生成大量的City临时对象，优化的目的达到了。

结论：使用Hibernate、iBatis等框架的时候，我们过于热衷于对象引用的方便，忽视了这种方便的代价。有时候，我们只为了使用一个简单类型的数据，却大量加载肥胖对象而不自知。然后抱怨框架效率低，有问题。其实回头看看，良好的数据库设计、良好的对象设计这些基本的东西，是任何框架都不能帮我们做的。同时感叹JProfile这种强大工具给我们带来的好处，让我感觉又回到了DOS Debug 的时代。

参考：http://www.tusc.com.au/tutorial/html/index.html

一、Enterprise Beans

在EJB（Enterprise Java Beans）中定义了两种不同类别的Enterprise Bean ：

l         会话 Bean (Session Bean)

l         实体Bean (Entity Bean)

1.       会话 Bean (Session Bean)

请把Session Beans看作任务而非持久数据，只有这样，你才能清晰地理解使用它的场合和原因。比如说，Session Bean可能会对数据库内的用户进行检索操作，但并不把用户表示为持久的业务对象。Session Beans可以同其他类型的Java beans通信，这种能力已经超出了数据库事务概念之外。在这种方式下工作的分布式应用程序特别适合于采用Session Beans。

所有的Session Beans都派生于javax.ejb.SessionBean类。就像其名称那样， Session Beans只存在于单一客户会话中。这里的客户可能是Java Servlet、桌面应用程序、别的EJB乃至采用Java Bean的其他事务信息方式。Session Bean的生存期从客户程序发起接触开始，在客户通过调用EJB宿主接口的remove()方法显式破坏bean时终止。会话还会在预先设置的时间终止，而这种时间设置则由EJB容器内确定。考虑到服务器的资源，开发者往往会设法避免处理“超时”设置而在编写客户程序时做相应的延期处理。此外，开发者还应该在EJB容器重新启动的时候小心Session Bean的短暂寿命；客户程序可以重新获得同类bean的引用，但很有可能却不是同一bean。

Session Beans可以是无状态也可以是有状态的，因而两者会显示出不同的行为。Session Bean的状态概念类似于HTTP设置：客户程序和服务器之间的交互（在这种情况下就是bean自身）发生在定义的环境之内。有状态的Session Bean会在多个方法调用的情况下保存客户和bean的有关信息。有状态的Session Bean只能同一个客户程序通讯，而无状态Session bean的实例却可以同时和若干个客户程序通讯。

会话 Bean 是调用它的客户端代码要完成的工作。当客户端与服务器建立联系，那么一个会话 Bean 就建立起来了。根据会话 Bean 的状态不同有分为:

A. 状态会话 Bean (Stateful Session Bean)

B. 无状态会话 Bean (Stateless Session Bean)

1.1 状态会话 Bean (Stateful Session Bean)

当客户机和服务器建立连接之后，状态会话 Bean (Stateful Session Bean) 将一直在客户机和服务器之间保持着用户的某个状态。例如：用户使用银行的ATM时，经过验证之后，用户可以连续执行多次操作，在这个过程当中，用户的合法状态将一直被保留，直到她将信用卡取出，结束这次操作。这时，状态会话 Bean (Stateful Session Bean) 也就被销毁。

1.2无状态会话 Bean (Stateless Session Bean)

当客户机和服务器建立连接之后，无状态会话 Bean (Stateless Session Bean)处理单一的用户请求或商务过程。无状态会话 Bean (Stateless Session Bean)不需要从以前的请求中提取任何状态。例如，用户的用户密码确认。用户输入密码后，发送请求。组件返回真或假来确认用户，一旦过程完成，无状态会话 Bean (Stateless Session Bean) 也宣告结束。

2. 实体Bean (Entity Bean)

实体Bean (Entity Bean)只是数据模型，它不包括商务逻辑。实体Bean (Entity Bean)可以将关系/对象数据库的数据映射到内存中供其它组件使用。实体Bean (Entity Bean)是一直存在的，而且具有很高的容错性能。实体Bean (Entity Bean)能供允许多用户同时访问。

二、会话 Bean (Session Bean)

Ejb的执行过程是被放在一个EJB容器中进行的，所以客户端不会直接调用我们写好的Enterprise Bean ，而是调用EJB容器生成的一个EJBObject (EJB对象)来实现。那么，我们在编写服务器端的Enterprise Bean 时，就要考虑这点。既然客户端不能直接访问，就由EJBObject来代劳，所以在编写服务器端时，就要编写服务器端的一个接口（Remote）用来与客户机联系，实力化EJBObject。要生成EJBObject 就要调有Home 接口，来建立这个实力。

以下是会话 Bean 的代码分析：

A.Enterprise Bean 类：sailorsy.class

1.setSessionContext(SessionContext ctx)方法

它是EJB容器和Enterprise Bean互相作用的关口。

import java.rmi.*;

import javax.ejb.*;

public class sailorsy implements SessionBean{

private SessionContext ctx=null;

public voic setSessionContext(SessionContext ctx){

this.ctx=ctx;

}//setSessionContext

}//class sailorsy

2.ejbCreate(…)方法

它可以初始化Enterprise Bean ,可以定义不同的ejbCreate(…)方法，每个方法所带的参数不同。但是，必许要存在至少一种。

import java.rmi.*;

import javax.ejb.*;

public class sailorsy implements SessionBean{

private SessionContext ctx=null;

public voic setSessionContext(SessionContext ctx){

this.ctx=ctx;

}//setSessionContext

public void ejbCreate() {

}//ejbCreate

}//class sailorsy

3.ejbPassivate()方法

如果初始化的Enterprise Bean 过多，EJB容器将其中的一些挂起（passivate）,释放他们所占用的空间。

import java.rmi.*;

import javax.ejb.*;

public class sailorsy implements SessionBean{

private SessionContext ctx=null;

public voic setSessionContext(SessionContext ctx){

this.ctx=ctx;

}//setSessionContext

public void ejbCreate() {

}//ejbCreate

public void ejbPassivate() {

}//ejbPassivate

}//class sailorsy

4.ejbActivate()方法

和ejbPassivate正好相反，它将被挂起的Bean从新调回。

import java.rmi.*;

import javax.ejb.*;

public class sailorsy implements SessionBean{

private SessionContext ctx=null;

public voic setSessionContext(SessionContext ctx){

this.ctx=ctx;

}//setSessionContext

Creating a Stateless Session Bean

This chapter covers how to create a stateless session EJB component. This bean will be responsible for authenticating the user by communicating with the database using Data Access Object (DAO) which encapsulates Java Database Connectivity (JDBC) code. A DAO has all attributes (fields) and behavior (methods) corresponding to the bean it is being used for.

All customers, supplier and manager of MyStore have been assigned a unique username and userid to access services of MyStore, but in order to access these services all these entities have to first login into the system (MyStore). The method for authentication is named loginUser, which takes two String parameters, username and password and returns the userID if authentication is successful.

Note : This method loginUser is a business method, normally business methods carry out operations or processing on values EJB components. From clients perspective, clients can see only business methods and invoke them on bean.

Tasks :

1. Create a J2EE project named MyStore.
2. Create a Stateless Session Bean named StoreAccess.
3. Add a business method in bean named loginUser with the following signature

public String loginUser (String username, String password)

4. Create a DAO named StoreAccessDAOImpl under package au.com.tusc.dao. Generate the DAO interface.
5. Implement the method named loginUser, generated in DAO interface, in StoreAccessDAOImpl. Method signature is

public String loginUser (String username, String password)

6. Add callback methods and implement them.
7. Deploy StoreAccess bean.
8. Create your test client named SessionClient under package au.com.tusc.client.
9. Run your client and test the bean.

Create J2EE Project :

Now, lets start to write our first component of this tutorial.

Go to File > New > LombozJ2EE Project, project creation wizard will pop up.

Insert Project Name MyStore > Next .

Under Java Settings Check source, should be MyStore/src , libraries pointing to $JAVA_HOME > Go Next as shown in fig below.

Note: This step is shown in chapter1, as there is a bug in eclipse 2.1, so its important that you check your library settings are right.

Under Create J2EE Module, select Web Modules tab > Add.., enter Module name as OnlineStore > OK as shown in figure below.

Under Create J2EE Module, select EJB Modules tab > Add.., enter Module name as MyStoreMgr > OK .

Under Create J2EE Module, select Targeted Servers tab > Select JBOSS 3.2.1 ALL > Add.. > Finish.

Create Stateless Bean :

Go To Package Explorer > Expand Mystore (project) node > select src, right click and menu will pop up.

On pop up menu > New > Lomboz EJB Creation Wizard.

Enter package name au.com.tusc.session, bean name StoreAccess and select bean type as stateless > Finish.

This will create a package named au.com.tusc.session under src and StoreAccessBean under that package as shown in the figure below.

As we can see from the figure below it has created a class level tag @ejb.bean, which has assigned the bean type, name and its JNDI name which will be generated in Home interface. This tag will also generate deployment descriptors in ejb-jar.xml and jboss.xml file as well once you generate your EJB classes, which is covered later on in this chapter.

Note: It will generate the bean name, jndi-name and type of bean in the file. Also, the name of file is appended with word 'Bean' as you gave the name of the bean as StoreAccess only. Again, be careful with naming conventions, specifying the bean name only in the wizard without adding the word 'Bean' to the name as the wizard appends that for you.

Expand MyStoreMgr/META-INF node under Package Explorer. You will find there are seven files which are generated by Lomboz using Xdoclet as shown in the figure below.

Now we are going to generate all the interfaces including Home, Remote, DAO and other helper classes. We will explain why later on, but for the time being just follow the steps.

But before we get too excited, there are a few concepts to cover here.

Go to MyStoreMgr/META-INF > select and open ejbGenerate.xml.

Note: Lomboz uses this file to generate required interfaces and helper classes, so in the event that you have special needs then you will have to customize this file. See ejbdoclet under the Xdoclet documentation.

'ejbGenerate.xml' file is generated only once when you create your EJB module. So any changes made in this file will be reflected even if you modify your bean class and generate your classes again and again.

The other two files which are of importance to us are ejb-jar.xml and jboss.xml. The file ejb-jar.xml has all the deployment descriptors for beans and jboss.xml has the JBOSS specific deployment descriptors required by JBOSS.

Note : ejb-jar.xml file is generated every time you generate interface and helper classes for your bean. For the first time, it is empty, and jboss.xml will be generated every time when you will generate your classes for your bean.

Setup DAO :

Now, let's customize ejbGenerate.xml for setting up a DAO.

We have included a <dao> tag specifying the destination directory for the generated DAO interface and what pattern to be used.

Note : For details, please refer ejbdoclet under Xdoclet documentation.

Note : The way Xdoclet works is bit different from some conventional styles of programming, as the Xdoclet tags will generate these (home and remote) interfaces along with necessary helper classes, which then will used in Bean and DAO Implementation class. However, until these are generated, we cannot write any business methods in Bean and JDBC wrappers in the DAO Implementation class. If this seems confusing then just follow the steps, and hopefully it will become more clear.

Create DAO Interface :

Since we are going to use a DAO to access the database for this Stateless Bean, we have to create a DAOImpl class which will implement that generated DAO interface.

Go to src > add package named au.com.tusc.dao > Add a class StoreAccessDAOImpl in that package.

Now go to your Bean class and declare this tag at the class level (that is at the top) as shown below to generate the DAO interface.

   @ejb.dao class="au.com.tusc.session.StoreAccessDAO"

    impl-class="au.com.tusc.dao.StoreAccessDAOImpl"

Expand StoreAccessBean node under Package Explorer. Right click and a pop up menu will appear.

On that menu go to Lomboz J2EE > Add EJB to module. Select EJB '[MyStoreMgr]' > OK.

Expand MyStoreMgr node under MyStore Project in Package Explorer. Right click and a menu will pop up.

Go to Lomboz J2EE > Generate EJB Classes as shown in the figure below.

This tag also generates the following descriptors in jboss.xml as shown in the code snippet below.

So now we know which tags are responsible for generating classes, interfaces and descriptors.

Add Business Method :

Next step is to add a business method in the bean.

Go to StoreAccesBean > Right click > Select New on pop up menu > Select Lomboz Ejb Method Wizard.

Add a business method with the following signature: public String loginUser (String username, String password).

Select Method Type as Business and Interface as Remote as shown in the figure below..

This wizard generates a loginUser method in our bean class, with the method level tag '@ejb.interface' shown below.

This tag is responsible for generating this method in the Remote Interface (in this case it is StoreAccess which will be created once you generate your classes). This tag is covered later on in this chapter.

After generating the classes, we look at first the generated DAO interface and then the generated Session Class.

In StoreAcessDAO two methods are generated.

1. init() by default.

2. loginUser(), generated by tag shown below.

@dao.call name="loginUser"

Note: Please do not edit any class generated by Xdoclect.

In StoreAcessSession two methods of our interest are

1. getDAO() creates instance of DAOImpl calss.

2. loginUser(), calls loginUser method in DAOImpl class, which we have to implement.

Code snippet from 'StoreAccessSession'.

Implement DAO Interface :

Now, we will implement methods in the StoreAccessDAOImpl class.

In StoreAcessBean class under the loginUser method just add some debug statements, as shown below in this code snippet.

Note : We don't have to call the loginUser method in StoreAccessDAOImpl, as it being invoked by the loginUser method in StoreAccessSession class which inherits StoreAccessBean class, that is the StoreAccessSession class has overridden this method.

Code snippet from StoreAccessSession shown below.

Add Callback Methods :

Now, add callback methods to complete this bean as shown below.

1. setSessionContext.
2. UnsetSessionContext.

Note : These callback methods are invoked by the EJB container.

Add a field to store sessionContext.

protected SessionContext ctx;

Add method setSessionContext with sessionContext as parameter and assign that to the sessionContext variable as shown below in the code snippet.

Similarly add method unsetSessionContext, assign context variable to null as shown above.

Note : StoreAccessSession class inherits the StoreAccessBean abstract class and implements SessionBean, which will override all methods of interface SessionBean. So after finishing the methods in the bean class, generate your EJB classes again. SessionContext methods will be overridden as shown in figure below. Code snippet from StoreAccessSession shown below.

Now let's look at the generated Home and Remote interfaces.

In the case of the Remote interface all business methods declared in the bean are also generated with the same signature. This is due to the class level tag declared in the StoreAccess Bean as discussed above after adding business methods. Code snippet for tag is shown below.

So, loginUser is generated in a Remote Interface called StoreAccess as shown below because of this tag.

In the case of the Home Interface only one method is created named 'create', which is generated by default because of the <homeinterface/> tag in ejbGenerate.xml as shown below.

Also, other then that, it has JNDI_NAME and COMP_NAME (which is the logical name to lookup the component) is also generated, these are generated because of this tag declared at class level in 'StoreAccessBean' class shown below in figure.

Note : For further options associated with these tags please refer to the 'ejbdoclet' documentation in Xdoclet.

Now, all the aspects are pretty much covered, and our bean's functionality is complete. Now for the deployment descriptors..

Deploy Bean :

In order to deploy our bean we have to declare a few tags in the StoreAccessBean class as shown below in the code snippet.

Add the tag shown below in at the class level (at the top).

@ejb.resource-ref res-ref-name="jdbc/DefaultDS"

res-type="javax.sql.Datasource"

res-auth="Container"

This tag will generate deployment descriptors in ejb-jar.xml, as the bean has to know which datasource you are going to connect to, what is its type, etc. This will generate these descriptors as shown in code snippet below.

Add the tag shown below in StoreAccessBean at the class level (at the top).

@jboss.resource-ref res-ref-name="jdbc/DefaultDS" jndi-name="java:/DefaultDS"

This tag will generate deployment descriptors in jboss.xml, as the application server has to know with what jndi-name datasource it has been registered with. This will generate these descriptors as shown in the code snippet below.

Now, everything is complete, and it's time to deploy the bean.

First, regenerate your EJB classes as shown in the steps above for the final time.

Note : We have regenerated the classes again and again, in order to explain every step and its result. Once you are familiar with these steps you will need much fewer of these iterations. Either way, it doesn't matter, as your implementation always remains untouched by this process.

Go to Lomboz J2EE View > expand node MyStore > expand MyStoreMgr > select 'Jboss 3.2.1 ALL' .

Right click > select Debug Sever on the pop up menu as shown in figure below.

Go to MyStoreMgr node in LombozJ2EE view > right click > select Deploy on the pop up menu as shown in the figure below.

And now wait for your deployment result.

If everything goes fine, you will have this message under your console as shown in the figure below.

So, now our bean is deployed successfully, let's create our test client, which will invoke the loginUser method on 'StoreAccessBean'.

Create your Test Client :

Go to Project MytStore node > select src node > right click.

Select New on pop up menu > select Lomboz EJB Test Client Wizard as shown in the figure below.

Select package name au.com.tusc.client, name as SessionClient and select Ejb Home as au.com.tusc.session.StoreAccessHome and Ejb Interface as au.com.tusc.session.StoreAccess as shown in the figure below.

This will generate the required methods for you in your SessionClient class and you have to just invoke the loginUser method on the bean as shown below.

Now the last step is to write code in your client.

So add these lines under the testBean method as shown in figure below.

System.out.println("Request from client : ");

System.out.println("Reply from Server: Your userid is " +

myBean.loginUser("ANDY","PASSWD"));

Test your Client :

Now, in order to test your client, Select SessionClient node > Go at top level menu and select the icon with the 'Running Man'.

On that select 'Run as' > select 'Java Application', as shown below.

Now under your console, if you get your reply for 'ANDY' as 'U2', then your call is successful as shown below.

Note : So our Stateless Session Bean is deployed and tested successfully and from now onwards you should be comfortable using Lomboz. In future we will not go into the detail of the steps for using Lomboz and will concentrate more on other aspects of beans.

小结

通过表示J2EE应用程序中的任务或者行动。Session Beans可以因此而处理大量的状态。尤其是在同其他EJB合用的情况下。理解Session Beans的瞬时现象对开发者的工作会带来莫大的帮助。有状态和无状态Beans的细微差别就如同充分利用其行为一样重要。在掌握以上的概念之后，正确的设计和实现Session Beans必然会显著改进EJB应用程序的功能和效率。

一、 Servlet简介

　　1．Servlet 是什么？

　　Servlet是使用Java Servlet 应用程序设计接口（API）及相关类和方法的 Java 程序。除了 Java Servlet API，Servlet 还可以使用用以扩展和添加到 API 的 Java 类软件包。Servlet 在启用 Java 的 Web 服务器上或应用服务器上运行并扩展了该服务器的能力。Java servlet对于Web服务器就好象Java applet对于Web浏览器。Servlet装入Web服务器并在Web服务器内执行，而applet装入Web浏览器并在Web浏览器内执行。Java Servlet API 定义了一个servlet 和Java使能的服务器之间的一个标准接口，这使得Servlets具有跨服务器平台的特性。

　　Servlet 通过创建一个框架来扩展服务器的能力，以提供在 Web 上进行请求和响应服务。当客户机发送请求至服务器时，服务器可以将请求信息发送给 Servlet，并让 Servlet 建立起服务器返回给客户机的响应。 当启动 Web 服务器或客户机第一次请求服务时，可以自动装入 Servlet。装入后， Servlet 继续运行直到其它客户机发出请求。Servlet 的功能涉及范围很广。例如，Servlet 可完成如下功能：

　　(1) 创建并返回一个包含基于客户请求性质的动态内容的完整的 HTML页面。

　　(2) 创建可嵌入到现有 HTML 页面中的一部分 HTML 页面（HTML 片段）。

　　(3) 与其它服务器资源（包括数据库和基于 Java 的应用程序）进行通信。

　　(4) 用多个客户机处理连接，接收多个客户机的输入，并将结果广播到多个客户机上。例如，Servlet 可以是多参与者的游戏服务器。

　　(5) 当允许在单连接方式下传送数据的情况下，在浏览器上打开服务器至applet的新连接，并将该连接保持在打开状态。当允许客户机和服务器简单、高效地执行会话的情况下，applet也可以启动客户浏览器和服务器之间的连接。可以通过定制协议或标准（如 IIOP）进行通信。

　　(6) 对特殊的处理采用 MIME 类型过滤数据，例如图像转换和服务器端包括（SSI）。

　　(7) 将定制的处理提供给所有服务器的标准例行程序。例如，Servlet 可以修改如何认证用户。

　　2．Servlet 的生命周期

　　Servlet 的生命周期始于将它装入 Web 服务器的内存时，并在终止或重新装入 Servlet 时结束。

　　(1) 初始化

　在下列时刻装入 Servlet：

l         如果已配置自动装入选项，则在启动服务器时自动装入

l         在服务器启动后，客户机首次向 Servlet 发出请求时

l         重新装入 Servlet 时装入 Servlet 后，服务器创建一个 Servlet 实例并且调用 Servlet 的 init() 方法。在初始化阶段，Servlet 初始化参数被传递给 Servlet 配置对象。

　　(2) 请求处理

　　对于到达服务器的客户机请求，服务器创建特定于请求的一个“请求”对象和一个“响应”对象。服务器调用 Servlet 的 service() 方法，该方法用于传递“请求”和“响应”对象。service() 方法从“请求”对象获得请求信息、处理该请求并用“响应”对象的方法以将响应传回客户机。service() 方法可以调用其它方法来处理请求，例如 doGet()、doPost() 或其它的方法。

　　(3) 终止

　　当服务器不再需要 Servlet, 或重新装入 Servlet 的新实例时，服务器会调用 Servlet 的 destroy() 方法。

　　3. Java Servlet API

　　Java Servlet 开发工具（JSDK）提供了多个软件包，在编写 Servlet 时需要用到这些软件包。其中包括两个用于所有 Servlet 的基本软件包：javax.servlet 和 javax.servlet.http。可从sun公司的Web站点下载 Java Servlet 开发工具。 下面主要介绍javax.servlet.http提供的HTTP Servlet应用编程接口。

　　HTTP Servlet 使用一个 HTML 表格来发送和接收数据。要创建一个 HTTP Servlet，请扩展 HttpServlet 类， 该类是用专门的方法来处理 HTML 表格的 GenericServlet 的一个子类。 HTML 表单是由 <FORM> 和 </FORM> 标记定义的。表单中典型地包含输入字段（如文本输入字段、复选框、单选按钮和选择列表）和用于提交数据的按钮。当提交信息时，它们还指定服务器应执行哪一个Servlet（或其它的程序）。 HttpServlet 类包含 init()、destroy()、service() 等方法。其中 init() 和 destroy() 方法是继承的。

　　(1) init() 方法

　　在 Servlet 的生命期中，仅执行一次 init() 方法。它是在服务器装入 Servlet 时执行的。 可以配置服务器，以在启动服务器或客户机首次访问 Servlet 时装入 Servlet。 无论有多少客户机访问 Servlet，都不会重复执行 init() 。

　　缺省的 init() 方法通常是符合要求的，但也可以用定制 init() 方法来覆盖它，典型的是管理服务器端资源。 例如，可能编写一个定制 init() 来只用于一次装入 GIF 图像，改进 Servlet 返回 GIF 图像和含有多个客户机请求的性能。另一个示例是初始化数据库连接。缺省的 init() 方法设置了 Servlet 的初始化参数，并用它的 ServletConfig 对象参数来启动配置， 因此所有覆盖 init() 方法的 Servlet 应调用 super.init() 以确保仍然执行这些任务。在调用 service() 方法之前，应确保已完成了 init() 方法。

　　(2) service() 方法

　　service() 方法是 Servlet 的核心。每当一个客户请求一个HttpServlet 对象，该对象的service() 方法就要被调用，而且传递给这个方法一个“请求”（ServletRequest）对象和一个“响应”（ServletResponse）对象作为参数。 在 HttpServlet 中已存在 service() 方法。缺省的服务功能是调用与 HTTP 请求的方法相应的 do 功能。例如， 如果 HTTP 请求方法为 GET，则缺省情况下就调用 doGet() 。Servlet 应该为 Servlet 支持的 HTTP 方法覆盖 do 功能。因为 HttpServlet.service() 方法会检查请求方法是否调用了适当的处理方法，不必要覆盖 service() 方法。只需覆盖相应的 do 方法就可以了。

　当一个客户通过HTML 表单发出一个HTTP POST请求时，doPost（）方法被调用。与POST请求相关的参数作为一个单独的HTTP 请求从浏览器发送到服务器。当需要修改服务器端的数据时，应该使用doPost()方法。

　当一个客户通过HTML 表单发出一个HTTP GET请求或直接请求一个URL时，doGet()方法被调用。与GET请求相关的参数添加到URL的后面，并与这个请求一起发送。当不会修改服务器端的数据时，应该使用doGet()方法。

　　Servlet的响应可以是下列几种类型：

　　一个输出流，浏览器根据它的内容类型（如text/HTML）进行解释。

　　一个HTTP错误响应, 重定向到另一个URL、servlet、JSP。

　　(3) destroy() 方法

　　destroy() 方法仅执行一次，即在服务器停止且卸装Servlet 时执行该方法。典型的，将 Servlet 作为服务器进程的一部分来关闭。缺省的 destroy() 方法通常是符合要求的，但也可以覆盖它，典型的是管理服务器端资源。例如，如果 Servlet 在运行时会累计统计数据，则可以编写一个 destroy() 方法，该方法用于在未装入 Servlet 时将统计数字保存在文件中。另一个示例是关闭数据库连接。

当服务器卸装 Servlet 时，将在所有 service() 方法调用完成后，或在指定的时间间隔过后调用 destroy() 方法。一个Servlet 在运行service() 方法时可能会产生其它的线程，因此请确认在调用 destroy() 方法时，这些线程已终止或完成。

　　(4) GetServletConfig（）方法

　　GetServletConfig（）方法返回一个 ServletConfig 对象，该对象用来返回初始化参数和　　ServletContext。ServletContext 接口提供有关servlet 的环境信息。

　　(5) GetServletInfo（）方法

　　GetServletInfo（）方法是一个可选的方法，它提供有关servlet 的信息，如作者、版本、版权。

　　当服务器调用sevlet 的Service（）、doGet（）和doPost（）这三个方法时，均需要 “请求”和“响应”对象作为参数。“请求”对象提供有关请求的信息，而“响应”对象提供了一个将响应信息返回给浏览器的一个通信途径。javax.servlet 软件包中的相关类为ServletResponse和ServletRequest，而javax.servlet.http 软件包中的相关类为HttpServletRequest 和 HttpServletResponse。Servlet 通过这些对象与服务器通信并最终与客户机通信。Servlet 能通过调用“请求”对象的方法获知客户机环境，服务器环境的信息和所有由客户机提供的信息。Servlet 可以调用“响应”对象的方法发送响应，该响应是准备发回客户机的。

　　1.2 创建HTTP Servlet

　　创建一个 HTTP Servlet，通常涉及下列四个步骤：

　　1. 扩展 HttpServlet 抽象类。

　　2. 重载适当的方法。]如覆盖（或称为重写）doGet() 或doPost()方法。

　　3. 如果有 HTTP 请求信息的话，获取该信息。用 HttpServletRequest 对象来检索 HTML 表格所

　　提交的数据或 URL 上的查询字符串。“请求”对象含有特定的方法以检索客户机提供的信息，有3个可用的方法：

　getParameterNames()，

　getParameter()，

　getParameterValues()。

　　4. 生成 HTTP 响应。HttpServletResponse 对象生成响应，并将它返回到发出请求的客户机上。它

的方法允许设置“请求” 标题和“响应”主体。“响应”对象还含有 getWriter() 方法以返回一个 PrintWriter 对象。使用 PrintWriter 的 print() 和 println() 方法以编写 Servlet 响应来返回给客户机。或者，直接使用out对象输出有关HTML文档内容。

　　一个servlet样例(ServletSample.java)如下：

　　import java.io.*;

　　import java.util.*;

　　import javax.servlet.*;

　　import javax.servlet.http.*;

　　public class ServletSample extends HttpServlet { // 第一步： 扩展 HttpServlet 抽象类。

　　public void doGet (HttpServletRequest request, HttpServletResponse response)

　　throws ServletException, IOException { // 第二步：重写doGet()方法

　　String myName = ""; // 第三步：获取HTTP 请求信息

　　java.util.Enumeration keys = request.getParameterNames();

　　while (keys.hasMoreElements());

　　{

　　key = (String) keys.nextElement();

　　if (key.equalsIgnoreCase("myName"))

　　myName = request.getParameter(key);

　　}

　　if (myName == "")

　　myName = "Hello";

　　// 第四步：生成 HTTP 响应。

　　response.setContentType("text/html");

　　response.setHeader("Pragma", "No-cache");

　　response.setDateHeader("Expires", 0);

　　response.setHeader("Cache-Control", "no-cache");

　　out.println("<head><title>Just a basic servlet</title></head>");

　　out.println("<body>");

　　out.println("<h1>Just a basic servlet</h1>");

　　out.println ("<p>" + myName + ", this is a very basic servlet that writes an HTML

　　 page.");

　　out.println ("<p>For instructions on running those samples on your WebSphere应用服务器, 　　"+

　　"open the page:");

　　out.println("<pre>http://<em>your.server.name</em>/IBMWebAs/samples/index.aspl</pre>");

　　out.println("where <em>your.server.name</em> is the hostname of your WebSphere应用服

　　务器.");

　　out.println("</body></html>");

　　out.flush();

　　}

　　}

上述ServletSample类扩展 HttpServlet 抽象类、重写doGet()方法。在重写的doGet()方法中，获取HTTP 请求中的一个任选的参数（myName），该参数可作为调用的 URL 上的查询参数传递到 Servlet。使用示例如下：

http://your.server.name/servlet/ServletSample?myname=Michael。

　　1.3 调用 Servlet

　　要调用 Servlet 或 Web 应用程序，请使用下列任一种方法：由 URL 调用、在 <FORM> 标记中调用、在 <SERVLET>标记中调用、在 JSP 文件中调用、在 ASP 文件中调用。

　　1. 由 URL 调用 Servlet

　　这里有两种用 Servlet 的 URL 从浏览器中调用该 Servlet 的方法：

　　(1) 指定 Servlet 名称：当用 WebSphere应用服务器 管理器来将一个 Servlet 实例添加（注册）到服务器配置中时，必须指定“Servlet 名称”参数的值。例如，可以指定将hi作为HelloWorldServlet 的 Servlet 名称。要调用该 Servlet，需打开 http://your.server.name/servlet/hi。也可以指定 Servlet 和类使用同一名称（HelloWorldServlet）。在这种情况下，将由 http://your.server.name/servlet/HelloWorldServlet 来调用 Servlet 的实例。

　　(2) 指定 Servlet 别名：用 WebSphere应用服务器 管理器来配置 Servlet 别名，该别名是用于调用 Servlet 的快捷 URL。快捷 URL 中不包括 Servlet 名称。

　　2. 在 <FORM> 标记中指定 Servlet

　　可以在 <FORM> 标记中调用 Servlet。HTML 格式使用户能在 Web 页面（即从浏览器）上输入数据，并向 Servlet 提交数据。例如：

　　<FORM METHOD="GET" ACTION="/servlet/myservlet">

　　<OL>

　　<INPUT TYPE="radio" NAME="broadcast" VALUE="am">AM<BR>

　　<INPUT TYPE="radio" NAME="broadcast" VALUE="fm">FM<BR>

　　</OL>

　　（用于放置文本输入区域的标记、按钮和其它的提示符。）

　　</FORM>

　　ACTION 特性表明了用于调用 Servlet 的 URL。关于METHOD 的特性，如果用户输入的信息是通过 GET 方法向 Servlet 提交的，则 Servlet 必须优先使用 doGet() 方法。反之，如果用户输入的信息是通过 POST 方法向 Servlet 提交的，则 Servlet 必须优先使用 doPost() 方法。使用 GET 方法时，用户提供的信息是查询字符串表示的 URL 编码。无需对 URL 进行编码，因为这是由表单完成的。然后 URL 编码的查询字符串被附加到 Servlet URL 中，则整个 URL 提交完成。URL 编码的查询字符串将根据用户同可视部件之间的交互操作，将用户所选的值同可视部件的名称进行配对。例如，考虑前面的 HTML 代码段将用于显示按钮(标记为 AM 和 FM)，如果用户选择 FM 按钮，则查询字符串将包含 name=value 的配对操作为broadcast=fm。因为在这种情况下，Servlet 将响应 HTTP 请求，因此 Servlet 应基于 HttpServlet 类。Servlet 应根据提交给它的查询字符串中的用户信息使用的 GET 或 POST 方法，而相应地使用 doGet() 或 doPost() 方法。

　　3．在 <SERVLET> 标记中指定 Servlet

　　当使用 <SERVLET> 标记来调用 Servlet 时，如同使用 <FORM> 标记一样，无需创建一个完整的 HTML 页面。作为替代，Servlet 的输出仅是 HTML 页面的一部分，且被动态嵌入到原始 HTML 页面中的其它静态文本中。所有这些都发生在服务器上，且发送给用户的仅是结果 HTML 页面。建议在 Java 服务器页面（JSP）文件中使用 <SERVLET> 标记。请参阅有关 JSP 技术

　　原始 HTML 页面中包含 <SERVLET> 和 </SERVLET> 标记。 Servlet 将在这两个标记中被调用，且 Servlet 的响应将覆盖这两个标记间的所有东西和标记本身。如果用户的浏览器可以看到 HTML 源文件，则用户将看不到 <SERVLET> 和 </SERVLET> 标记。要在 Domino Go Webserver 上使用该方法，请启用服务器上的服务器端包括功能。部分启用过程将会涉及到添加特殊文件类型 SHTML。当 Web 服务器接收到一个扩展名为 SHTML 的 Web 页面请求时，它将搜索 <SERVLET> 和 </SERVLET> 标记。对于所有支持的 Web 服务器，WebSphere应用服务器 将处理 SERVLET 标记间的所有信息。下列 HTML 代码段显示了如何使用该技术。

　　<SERVLET NAME="myservlet" CODE="myservlet.class" CODEBASE="url" initparm1="value">

　　<PARAM NAME="parm1" VALUE="value">

　　</SERVLET>

　　使用 NAME 和 CODE 属性带来了使用上的灵活性。可以只使用其中一个属性，也可以同时使用两个属性。 NAME 属性指定了 Servlet 的名称（使用 WebSphere应用服务器 管理器配置的），或不带 .class 扩展名的 Servlet 类名。CODE 属性指定了 Servlet 类名。使用 WebSphere应用服务器 时，建议指定 NAME 和 CODE，或当 NAME 指定了 Servlet 名称时，仅指定 NAME。如果仅指定了 CODE，则会创建一个 NAME=CODE 的 Servlet 实例。装入的 Servlet 将假设 Servlet 名称与 NAME 属性中指定的名称匹配。然后，其它 SHTML 文件可以成功地使用 NAME 属性来指定 Servlet 的名称，并调用已装入的 Servlet。NAME 的值可以直接在要调用 Servlet 的 URL 中使用。如果 NAME 和 CODE 都存在，且 NAME 指定了一个现有 Servlet，则通常使用 NAME 中指定的 Servlet。由于 Servlet 创建了部分 HTML 文件，所以当创建 Servlet 时，将可能会使用 HttpServlet 的一个子类，并优先使用 doGet() 方法（因为 GET 方法是提供信息给 Servlet 的缺省方法）。另一个选项是优先使用 service() 方法。另外， CODEBASE 是可选的，它指定了装入 Servlet 的远程系统的 URL。请使用 WebSphere应用服务器 管理器来从 JAR 文件配置远程 Servlet 装入系统。

　　在上述的标记示例中，initparm1 是初始化参数名，value 是该参数的值。可以指定多个“名称-值”对的集合。利用 ServletConfig 对象（被传递到 Servlet 的 init() 方法中）的 getInitParameterNames() 和 getInitParameter() 方法来查找参数名和参数值的字符串数组。在示例中，parm1 是参数名，并在初始化 Servlet 后被才被设置某个值。因为只能通过使用“请求”对象的方法来使用以 <PARAM> 标记设置的参数，所以服务器必须调用 Servlet service() 方法，以从用户处传递请求。要获得有关用户的请求信息，请使用 getParameterNames()、getParameter() 和 getParameterValues() 方法。

　　初始化参数是持续的。假设一台客户机通过调用一个包含某些初始化参数的 SHTML 文件来调用 Servlet。并假设第二台客户机通过调用第二个 SHTML 文件来调用同一个 Servlet，且该 SHTML 中未指定任何初始化参数。那么第一次调用 Servlet 时所设置的初始化参数将一直可用，并且通过所有其它 SHTML 文件而调用的所有后继 Servlet 都不会更改该参数。直到 Servlet 调用了 destroy() 方法后，才能重新设置初始化参数。例如，如果另一个 SHTML 文件指定了另一个不同的初始化参数值，虽然已此时已装入了 Servlet，但该值仍将被忽略。

　　4．在 JSP 文件中调用 Servlet

　　可以从 JavaServer 页面（JSP）文件中调用 Servlet。请参阅JSP技术部分。

　　5．在 ASP 文件中调用 Servlet

　　如果在 Microsoft Internet Information Server（IIS）上有遗留的 ASP 文件，并且无法将 ASP 文件移植成 JSP 文件时，可用 ASP 文件来调用 Servlet。在 WebSphere应用服务器 中的 ASP 支持包括一个用于嵌入 Servlet 的 ActiveX 控制，下面介绍ActiveX 控制AspToServlet 的方法和属性。

该方法说明如下：

　　(1) String ExecServletToString(String servletName)；执行 ServletName，并将其输出返回到一个字符串中。

　　(2) ExecServlet(String servletName)；执行 ServletName，并将其输出直接发送至 HTML 页面。

　　(3) String VarValue(String varName)；获得一预置变量值（其它格式）。

　　(4) VarValue(String varName, String newVal)；设置变量值。变量占据的总大小应小于 0.5 个千字节（Kbyte）。且仅对配置文件使用这些变量。

　　其属性如下：

　Boolean WriteHeaders；若该属性为真，则 Servlet 提供的标题被写入用户处。缺省值为假。

　Boolean OnTest；若该属性为真，服务器会将消息记录到生成的 HTML 页面中。缺省值为假。

　　下列ASP 脚本示例是以 Microsoft Visual Basic Scripting（VBScript）书写的。

　　<%

　　' Small sample asp file to show the capabilities of the servlets and the ASP GateWay ...

　　%>

　　<H1> Starting the ASP->Java Servlet demo</H1>

　　<%

　　' Create a Servlet gateway object and initialize it ...

　　Set javaasp = Server.CreateObject("AspToServlet.AspToServlet")

　　' Setting these properties is only for the sake of demo.

　　' These are the default values ...

　　javaasp.OnTest = False

　　javaasp.WriteHeaders = False

　　' Add several variables ...

　　javaasp.VarValue("gal") = "lag"

　　javaasp.VarValue("pico")= "ocip"

　　javaasp.VarValue("tal") = "lat"

　　javaasp.VarValue("paz") = "zap"

　　javaasp.VarValue("variable name with spaces") = "variable value with spaces"

　　%>

　　<BR>

　　Lets check the variables

　　<%

　　Response.Write("variable gal = ")

　　Response.Write(javaasp.VarValue("gal"))

　　%>

　　<BR>

　　<%

　　Response.Write("variable pico = " & javaasp.VarValue("pico"))

　　%>

　　<BR>

　　<HR>

　　<%

　　galout = javaasp.ExecServletToString("SnoopServlet")

　　If javaasp.WriteHeaders = True Then

　　%>

　　Headers were written <%

　　Else

　　%>

　　Headers were not written <%

　　End If

　　Response.Write(galout)

　　%>

<H1> The End ...</H1>

public void ejbCreate() {

}//ejbCreate

public void ejbPassivate() {

}//ejbPassivate

public void ejbActivate() {

}//ejbActivate

}//class sailorsy

5.ejbRemove()方法

它可以清除EJB容器中的Bean。

import java.rmi.*;

import javax.ejb.*;

public class sailorsy implements SessionBean{

private SessionContext ctx=null;

public voic setSessionContext(SessionContext ctx){

this.ctx=ctx;

}//setSessionContext

public void ejbCreate() {

}//ejbCreate

public void ejbPassivate() {

}//ejbPassivate

public void ejbActivate() {

}//ejbActivate

public void ejbRemove() {

}//ejbRemove

public String showname(){

return "Hello,my name is sailorsy";

}//自己的商务方法

}//class sailorsy

以上这些是EJB必需的回调方法，我们可以在里面加入自己的方法，加入自己的商务逻辑。

B.Home 接口: sailorsyHome

import java.rmi.*;

import javax.ejb.*;

public interface sailorsyHome extends EJBHome {

public sailorsyRemote create() throws RemoteException, CreateException;

}

C. Remote接口：sailorsyRemote

import java.rmi.*;

import javax.ejb.*;

public interface sailorsyRemote extends EJBObject {

public java.lang.String showname() throws RemoteException;

}

三.调用会话 Bean：sailorsyTestClient1

import javax.naming.*;

import javax.ejb.*;

import javax.rmi.PortableRemoteObject;

import java.rmi.*;

public class sailorsyTestClient1 {

private sailorsyHome sailorsyHomeObject = null;

//Construct the EJB test client

public sailorsyTestClient1() {

try {