读者定位为具有 Java 和 Ant 使用经验的开发人员。

读者可以学习到如何使用 Ant 解决一些多用户开发环境中，根据不同的目标环境编译成不同部署包的问题。

工作场景

现在有一个 web 项目，是多人进行开发的，通过 CVS 来管理。另外该项目还有一些测试人员，他们测试部署在测试服务器上的应用程序，发现 bug 后通过 bug 管理系统通知开发人员，在开发人员修复 bug 并经过本地测试后，由专门的人负责检出（check out）代码，编译打包后部署到测试服务器上。

该项目的成员小A就是负责检出代码、编译打包，并部署到服务器上的人。除了这个任务之外，他还是该项目的编程人员。在项目进入测试阶段后，小A在得到组中别的成员修复了 bug 并且检入（check in）了代码的消息后（也有可能是小A自己检入了代码），小A首先更新本地的代码，先在本地做测试，确认修复了 bug 后打成 WAR 包部署到测试服务器上，并通知测试人员已经修复了 bug，让测试人员继续进行测试。

小A的烦恼

在该项目中，有一些为测试方便开发而写的代码和页面，比如跳过用户认证，但是在部署到测试机环境的时候，需要删除这些代码和页面；另外作为一个具有灵活性和扩展性的应用程序，又有一些配置文件，配置文件中的值会根据环境的改变而变动。例如，在项目中使用了 Log4j 记录日志，需要给 Log4j 指定日志文件的保存路径，本地程序员开发的时候用的是 Windows 系统，给 Log4j 指定的也是 Windows 的文件系统，在测试阶段的时候，需要部署到 Linux 系统中，那么日志的保存路径也需要做相应的改动。部署到测试服务器上的时候，除了 Log4j 需要改之外，还有很多别的配置项目也需要变动，并且分散在各个 package 中。小A的烦恼也随之而来，每次他在做完本地测之后，就根据测试机的需要逐个找配置文件，更改相应的值，并删除那些为测试方便写的代码和页面，每天可能根据需要做好几次这样的事情，最烦的是他在快做完对测试机环境更改的时候，某开发人员突然通知小A说：“我又改了一点代码，刚检入，你再重打一个包吧。”，小A又不得不从头开始做新一轮的检出代码、本地测试、更改配置文件、删除不需要的文件、打包部署的工作。另外小A在测试阶段的后期被通知要求除了每次生成一个测试环境的 WAR 包外还必须生成一个在产品环境下的 WAR 包，他做的事情就更多了。

从上面的场景可以看出，小A的工作效率低而且容易出错，甚至有可能导致整个项目的工作效率低下。其实可以通过 Ant 来帮助小A快速而且有效地完成这个工作。在 Ant 中，根据目标环境的需要，可以把所有要更改的配置文件的项目集中写到某个配置文件中。这样根据不同的目标环境得到不同的配置文件，Ant 在编译包时根据不同的目标环境切换不同的配置文件即可。比如小A现在碰到的有 3 中环境：开发环境、测试环境以及产品环境，根据这三种环境可以生成三个不同的配置文件：develop_deploy.property、test_deploy. property和product_deploy. property，当小A想生成不同的包时只需在这三个配置文件之间切换就可以了。

在正式开始编写脚本之前，我们需要下载安装相应的软件。

• Eclipse：为了使 Ant 的开发更加简单，我们选择了 Eclipse3.1 作为开发环境。当然你可以使用任何你喜欢的文本编辑工具来开发你的 Ant。Eclipse 的最新版本可以在 http://eclipse.org/ 上下载。
• Ant：Ant 是基于 Java 的编译工具，它就像 C/C++ 中的 make，但是没有 make 那样难用。Ant 的最新版本可以在 http://ant.apache.org/bindownload.cgi 上下载。如果你用 Eclipse 来开发 Ant，则不用去单独下载 Ant，因为在 Eclipse 中已经集成了 Ant。
• CVS 客户端（cvs.exe）：CVS 可以在 http://www.nongnu.org/cvs/ 上下载

回页首

用 Eclipse3.1 来创建 Ant 脚本

如果你使用 Eclipse 来编写 Ant，建议使用 Eclipse 3.1 以后的版本。除了以前 Ant 编辑器提供的语法高亮，提示语法错误等功能外，Eclipse3.1 版本增加了许多新的功能。比如：脚本代码的折叠；快速定位某属性或者目标（target）段的定义；在同一 builder 文件中重构属性名和目标名（快捷方式Alt + Shift +R）；调试 Ant 脚本等。

下面我们就来看看 Eclipse 3.1 中对 Ant 的支持

• 打开“File”－“New”－“Project”－“Simple”－“Project”，点击“Next”，输入工程名“Ant”，然后点击直到“Finish”

• 在新建的 Ant 工程中，新建 Test.xml，并且拷贝下面的脚本。该段脚本的内容就不做介绍了，我们主要看 Eclipse 提供了哪些功能。注意这时候打开的并不是 Ant 编辑器，将内容拷贝进去之后，关掉打开的“Test.xml”，然后再重新打开它，这样 Eclipse 就会用 Ant 编辑器打开它，并且也语法高亮了。

  <?xml version='1.0' encoding='UTF-8'?> <project name='Test' default='init' basedir='.'> <property name='test' value='test'/> <target name='init'> <echo>${test}</echo> </target> </project>

  
  

• 自动提示和代码折叠功能。如果是 Ant 内置的命令或者前面已经定义的变量，编辑器会自动提示；编辑器右边的加/减号可以代码折叠。如下所示：

  

• 快速定位目标（target）或者定义变量处。在上图中，将鼠标移至 default=”init” 中的 init 上之后，按下 ctrl 键，鼠标变成手状，单击就可以定位到定义该目标的地方

• 快速重构目标名或者属性名。选中目标/属性名，按下 Alt + Shift + R，然后键入你要修改后的值，所有引用到的地方都会随之改动。如下图所示，选中 init 后，按下快捷键，改成 initial：

  

• 调试 Ant 脚本。在标签“<target name=..”的左边设置一断点，然后在编辑器中右击，出现的菜单中选“Debug As”－“Ant Build”，出现后的窗口与调试 Java 程序的界面差不多。

  这是调试窗口，这里可以选择单步跟进、跳出等：

  

  下面是运行时变量窗口。可以看到 test 变量的值是“test”：

  

  运行结果窗口：

  

由此可见，如果使用好 Eclipse Ant 编辑器所提供强大的功能的话能大大提高写 Ant 脚本的效率。

回页首

Ant 中使用 property（属性）文件

刚开始写 Ant 的初学者可能会把所有的信息都放在 build.xml 中，下面就是这样的一个例子。

<project name='testBuild' default='compile' basedir='.'>
<target name='init'>
	<mkdir dir='c:/temp/dest/testProj' />
</target>
<target name='compile' depends='init'>
	<javac srcdir='c:/temp/src/testProj' destdir='c:/temp/dest/testProj '/>
<echo>Build into c:/temp/dest/testProj, successfully.</echo>
</target>
</project>

在上面的例子中，所有的路径信息都是写在 build.xml 中。但是 Ant 脚本可能在不同的机器或者不同的系统上运行，也有可能一些值需要根据环境的不同而变化，在 Ant 中可以把所有这些可能变化的地方都放到一个配置文件中，然后在 Ant 脚本中引用这个配置文件就可以了，针对上面的例子，如下所示：

<project name='testBuild' default='compile' basedir='.'>
	<property file='build.properties'/>
	<target name='init'>
		<mkdir dir='${dest.dir}' />
	</target>
	<target name='compile' depends='init'>
		<javac srcdir='${src.dir}' destdir='${dest.dir}'/>
		<echo>Build into ${dest.dir}, successfully.</echo>
	</target>
</project>
build.properties的内容：
dest.dir=c:/temp/dest/testProj
src.dir=c:/temp/src/testProj

如果想在 Ant 脚本中引用值的话，只需用$符号开头，在一对'{}'中写入要引用的键值。如上例中，需要引用编译的目标路径用'${dest.dir}'。

回页首

使用 Ant 任务从 CVS 中检出（check out）源代码，并编译打包

Ant 中提供了 cvs 任务（Task）可以从 CVS 服务器中检出资源（注意：在使用 Ant 的 cvs 任务之前，请先将 cvs.exe 下载到你的机器，并且将它添加到你本地的 PATH 环境变量中，然后重新启动 Eclipse。否则在执行下面脚本的时候就会得到 error=2 的错误）。cvs 的可选用属性很多，在这里介绍经常使用到的几个属性。从 CVS 中检出资源一般需要指定：

• CVS 所在的服务器地址：目标 CVS 服务器地址
• 用户名：登录该 CVS 服务器你指定的用户名
• 密码：登录该 CVS 服务器需要的密码
• 库路径（Repository Path）：服务器中的库路径
• 模块名：当前需要检出的模块名，一般都是以工程的名字作为模块名
• 标签名：需要从 CVS 中检出哪个标签

在介绍使用 Ant 的 cvs 之前，先说一下本地的目录结构。在 C 盘的 temp 目录下，分别有四个目录，如下所示：

• build 目录：放编译后的类以及资源文件
• dist 目录：放生成的 jar 文件或者 war 文件
• lib 目录：放在编译过程中需要用到的 jar 文件
• src 目录：放从 cvs 中检出的源文件（包括 JSP 等）
  

在 Ant 中这样写就可以从中检出资源：

  <cvs cvsRoot=':pserver:username:pwd@cvs.server:/home/testPath' 
package='TestProj' dest=' c:/temp/src/testProj ' failonerror='true' />

这段脚本片断的意思就是从叫'cvs.server'的服务器中，用用户名是 username、密码为 pwd 的用户检出在库路径是 /home/testPath 下的 TestProj 模块（项目），检出后的资源放入本地目录 c:/temp/src/testProj 中。在上面这段脚本中，可以看到有很多值可能会根据不同的环境或者用户随之改变的，比如用户名和密码等；而且从脚本的重复可利用性来说，需要把有些值抽出来放到配置文件中，如服务器的地址和库路径等。因此把这些可能需要更改的地方放到 property 文件中，效果会更好。改完后的完整 Ant 脚本如下所示：

  <?xml version='1.0'?>
<project name='testWeb' default='checkout' basedir='.'>
	<target name='checkout'>
		<property file='TestWeb.properties' />
		<cvs cvsRoot='${cvs.root}' package='${cvs.projectName}' 
tag='${cvs.tag}' dest='${src.dir}' failonerror='true' />
	</target>
</project>

对应的 TestWeb.properties 文件内容如下所示：

base.dir=c:/temp/
src.dir=${base.dir}/src

cvs.server=cvs.server
cvs.user=username
cvs.pw=pwd
cvs.repositoryPath=/home/testPath
cvs.projectName=TestProj
cvs.root=:pserver:${cvs.user}:${cvs.pw}@${cvs.server}:${cvs.repositoryPath}
cvs.tag=

在检出了资源后，需要对其进行编译打包。为了使 Ant 脚本更加具有可读性和灵活性，我们需要对上面的 Ant 脚本进行一些改动。首先将 Ant 脚本中进行分段，如下所示：

<?xml version='1.0'?>
<project name='testWeb' default='all' basedir='.'>
	<target name='all' depends='init,clean,checkout,build'>
    <!--脚本的入口点-->
	</target>
	<target name='init'>
    <!--做初始化属性文件和设置classpath等设置初始条件-->
	</target>
	<target name='clean'>
     <!--删除上一次留下的没用的目录和文件-->
	</target>
	<target name='checkout'>	
     <!--从CVS中检出资源-->
	</target>
	<target name='build'>
     <!--编译源文件并打包到指定的目录-->
	</target>
</project>

上面的脚本中，总共分成了5个目标（target），脚本的入口点是'all'，all 按顺序调用 init，clean，checkout，build。其中：

• init 是用来做初始化属性文件和设置 classpath 等设置初始条件的事情
• clean 用来删除上一次留下的没用的目录和文件
• checkout 已经介绍过了，是用来从 CVS 中检出资源
• build 用来编译源文件并打 WAR 包到指定的目录

详细的 Ant 脚本可以参见随本文所附的 TestWeb.xml 和 TestWeb.properties。

回页首

编译过程与产生不同目标环境的脚本分开执行

在前面介绍的 Ant 脚本中，根据从 CVS 服务器中检出的资源打成了一个默认的 war 包，并没有考虑根据不同的目标环境来生成不同的包，从下一节开始介绍如何根据不同的环境来生成不同的部署包。

还有一个问题是：为什么需要把从 CVS 中检出资源、编译的过程跟根据目标环境打包的过程分开？

这是因为本身 CVS 检出资源是需要花一定的时间，如果资源比较多这个过程就会花费挺长时间；另外，在多人开发的情况下必须保证在生成不同的部署包的时候是用的是同一套代码生成的，否则会出现各个服务器上运行的版本不一致，如果检出资源、编译的过程跟生成包的脚本一起执行的话就会出现这个问题（比如小A在测试服务器测试通过的时候之后，再生成一个在产品环境下的部署包，如果分两次从 CVS 服务器中检出资源的话，在此期间可能会有开发人员往 CVS 服务器中检入代码，导致生成的版本不一致），因此，必须将这两个过程分开执行。现在我们开始建立另外一个 Ant 脚本文件，叫 deploy.xml，专门用来生成包；另外与 deploy.xml 相对应的还有一个 deploy.properties 文件。在 deploy.xml 中会引用 deploy.properties 文件。另外根据在前面的场景中碰到的环境，创建三个不同的属性文件, develop_deploy.property、test_deploy. property 和 product_deploy. Property，在打包的时候，根据不同的目标环境，将相应属性文件中的内容拷贝至 deploy.properties 文件中（或者也可以直接在 deploy.xml 中直接切换不同的属性文件），然后在 Eclipse 中直接执行 deploy.xml；如果在命令行中，可以用下面的命令来执行：

  ant –f deploy.xml

回页首

解开 WAR 包

我们首先得建立一个目录（这里是 unpack）用来存放解压后的文件。Ant 中提供了 unzip 命令用来解压 ear/war/jar 包。除了这个目录外，根据不同的目标环境，在运行目录下建立一个与目标环境相对应的目录，重新打好的 war 包就放在这个目录下，比如针对场景中的情况，如果需要创建一个产品环境下的部署包，我们可以建立一个 TestWebProduct 目录，目录名写在配置文件中（${pack.base.dir}）。

  <target name='init'>
		<echo>init in deploy</echo>
		<property file='deploy.properties' />
		<delete dir='${unpack.base.dir}' failonerror='false' />
		<delete dir='${pack.base.dir}' failonerror='false' />
		<mkdir dir='${unpack.base.dir}' />
		<mkdir dir='${pack.base.dir}' />
	</target>

	<target name='unpack'>
		<echo>unpack the ${war.name}</echo>
		<copy file='${dest.dir}/${war.name}' todir='${unpack.base.dir}' />
		<unzip src='${unpack.base.dir}/${war.name}' dest='${unpack.base.dir}/${projectName}' />
		<delete file='${unpack.base.dir}/${war.name}' />
	</target>

在 init 段中首先删除掉上次解压的目录和目标打包目录，然后重新建立目录；在 unpack 中，首先将编译好的默认 war 包拷贝至 unpack 定义的目录，解压之后把 unpack 下的 war 包删除。下面是这时候对应的属性文件。

projectName=MTSWeb
war.name=MTSWeb.war

#根目录
base.dir=c:/temp
#默认的war包所在的目录
dest.dir=${base.dir}/dist
#解压后的目录
unpack.base.dir=${base.dir}/unpack
#目标环境相对应的目录
pack.base.dir=${base.dir}/TestWebProduct

回页首

利用 Ant 提供的 filter 任务替换属性值

现在根据不同环境的需要，对某些配置文件的值做一些替换。在 Ant 中，提供了 filter 任务，使得替换值很方便。当然也可以使用下面介绍的正则表达式来替换属性值。filter 主要用来在同一行内容中的替换，而正则表达式一下子可以替换多行内容。filter 的使用例子：

  <filter token=' log4j.logger' value='INFO'/>
  <copy todir='${dest.dir}' filtering='true'>
    <fileset dir='${src.dir}'/>
  </copy>

这段脚本的意思就是在 src.dir 目录下的所有文件中，如果有预先定义好的'@log4j.logger@'占位符的话，在拷贝到 dest.dir 目录后，所有的占位符都被替换成了'INFO'。

你也可以将所有被替换的值放到某个属性文件中，filter 任务将属性文件中的每一个条目读出来并且设置成一个 Filter。如下所示：

  <filter filtersfile='deploy_env.properties'/>
  <copy todir='${dest.dir}' filtering='true'>
    <fileset dir='${src.dir}'/>
  </copy>

上面的脚本表示所有在 deploy_env 中出现的条目将被作为一个 filter，在拷贝到 dest.dir 目录后，所有 src.dir 目录中存在的占位符将被替换成 deploy_env 中的值。具体的例子可以参见随本文附带的 deploy.xml， deploy_env.properties 和 Test.properties。

其中 deploy.xml 是 ant 脚本，deploy_env.properties 中包含所有要替换的值，在 Test.properties 中是包含有占位符的资源文件。

回页首

利用正则表达式替换属性值

Ant 中支持多种正则表达式，在运行 Ant 的时候用哪种正则表达式可以通过设置 ant.regexp.regexpimpl 的值来切换，Ant 支持的的正则表达式有：

• java.util.regex package of JDK 1.4
• jakarta-regexp
• installation dependencies

正则表达式的例子：

<replaceregexp byline='true'>
<regexp pattern='正则表达式'/>
<substitution expression='将要替换的值'/>
<fileset dir='${unpack.war.dir}/WEB-INF' includes='web.xml'/>
</replaceregexp>

byline 属性用来确认被替换的时候是一次替换一行还是多行；pattern 属性用来指明正则表达式；substitution expression 中是替换的值，替换的值都定义在相对应的配置文件中；fileset 属性中的 dir 用来指定被替换文件所在的目录，includes 用来指定要替换哪个文件。需要注意的是，如果在正则表达式或者替换的值中出现'<'的话，需要用转义符'<'。

在 Eclipse3.1 中已经内置了对正则表达式的支持；但是如果你在命令行中运行需要正则表达式支持的脚本的话，则需要自己将正则表达式的包下载下来加到 classpath 中。在随文章的 deploy.xml 中提供了一个简单的替换属性文件的值的例子。正则表达式的例子可以在本文所带的 deploy.xml 中找到。

回页首

Ant 使用条件表达式，根据属性值删除不需要的文件

在生成部署包的时候，还有可能会根据目标环境的不同，删除一些不同的文件。比如在产品环境中那些作为测试需要的代码往往需要删除，但是测试环境中并不需要。因此就需要条件表达式来做判断。如下所示：

<target name='checkTestEnv'>
	<condition property='isTestEnv'>
		<istrue value='${deploy.isTestEnv}' />
	</condition>
	<antcall target='trueCondition' />
	<antcall target='falseCondition' />
</target>
<target name='trueCondition' if='isTestEnv'>
	<echo message='true condition in ${projectName}' />
</target>
<target name='falseCondition' unless='isTestEnv'>
	<echo message='false condition in ${projectName}' />
</target>

在上面的例子中，先读出 ${deploy.isTestEnv} 的值（在配置文件 deloy.properties 中），根据读出的值对属性 isTestEnv 设值，如果 ${deploy.isTestEnv} 的值是 true，isTestEnv 的值也是 true；否则是 false。然后分别调用目标段 trueCondition 和 falseCondition。在这里，表达式值的判断是用'istrue'，在 Ant 中还提供了很多别的表达式，比如 not/and/or，equals 等等，具体关于条件表达式的信息可以参考：http://ant.apache.org/manual/CoreTasks/condition.html ，该页也可以在随下载下来的文档中找到。

在段 trueCondition 中，判断 isTestEnv，如果是真的话就运行，否则不运行；在段 falseCondition 中，也判断 isTestEnv，如果是假就运行，否则不运行，在段中可以根据情况做相应的事情。条件判断式的例子可以在本文的 deploy.xml 中找到。

回页首

重新打包，并拷贝到不同的目录

在上面的替换过程完成后，调用 war 将 unpack 目录下的内容重新打包。

<target name='repack'>
	<war destfile='${pack.base.dir}/${projectName}.war' 
		basedir='${unpack.base.dir}/${projectName}'
		webxml='${unpack.base.dir}/${projectName}/WEB-INF/web.xml' 
		manifest='${unpack.base.dir}/${projectName}/META-INF/MANIFEST.MF'>
	</war>
</target>

详细的例子可以参见随本文的附件 deploy.xml 和 deploy.properties。

回页首

结论

通过本文可以看出编写好有效的 Ant 脚本能很好的解决在编译部署包的时候出现的问题，将那些变化的内容放到配置文件中，在部署的时候切换不同的配置文件就可以实现生成不同的部署包。文中也介绍了如何使用 Eclipse 来提高你编写/调试 Ant 脚本的效率。

在Java程序中截获控制台输出

在Java程序中截获控制台输出

俞良松 (javaman@163.net) 软件工程师，独立顾问和自由撰稿人 2001 年 10 月 在Java开发中，控制台输出仍是一个重要的工具，但默认的控制台输出有着各种各样的局限。本文介绍如何用Java管道流截取控制台输出，分析管道流应用中应该注意的问题，提供了截取Java程序和非Java程序控制台输出的实例。 即使在图形用户界面占统治地位的今天，控制台输出仍旧在Java程序中占有重要地位。控制台不仅是Java程序默认的堆栈跟踪和错误信息输出窗口，而且还是一种实用的调试工具（特别是对习惯于使用println()的人来说）。然而，控制台窗口有着许多局限。例如在Windows 9x平台上，DOS控制台只能容纳50行输出。如果Java程序一次性向控制台输出大量内容，要查看这些内容就很困难了。 对于使用javaw这个启动程序的开发者来说，控制台窗口尤其宝贵。因为用javaw启动java程序时，根本不会有控制台窗口出现。如果程序遇到了问题并抛出异常，根本无法查看Java运行时环境写入到System.out或System.err的调用堆栈跟踪信息。为了捕获堆栈信息，一些人采取了用try/catch()块封装main()的方式，但这种方式不一定总是有效，在Java运行时的某些时刻，一些描述性错误信息会在抛出异常之前被写入System.out和System.err；除非能够监测这两个控制台流，否则这些信息就无法看到。 因此，有些时候检查Java运行时环境（或第三方程序）写入到控制台流的数据并采取合适的操作是十分必要的。本文讨论的主题之一就是创建这样一个输入流，从这个输入流中可以读入以前写入Java控制台流（或任何其他程序的输出流）的数据。我们可以想象写入到输出流的数据立即以输入的形式“回流”到了Java程序。 本文的目标是设计一个基于Swing的文本窗口显示控制台输出。在此期间，我们还将讨论一些和Java管道流（PipedInputStream和PipedOutputStream）有关的重要注意事项。图一显示了用来截取和显示控制台文本输出的Java程序，用户界面的核心是一个JTextArea。最后，我们还要创建一个能够捕获和显示其他程序（可以是非Java的程序）控制台输出的简单程序。 图一：多线程的控制台输出截取程序 一、Java管道流 要在文本框中显示控制台输出，我们必须用某种方法“截取”控制台流。换句话说，我们要有一种高效地读取写入到System.out和System.err所有内容的方法。如果你熟悉Java的管道流PipedInputStream和PipedOutputStream，就会相信我们已经拥有最有效的工具。 写入到PipedOutputStream输出流的数据可以从对应的PipedInputStream输入流读取。Java的管道流极大地方便了我们截取控制台输出。Listing 1显示了一种非常简单的截取控制台输出方案。 【Listing 1：用管道流截取控制台输出】 PipedInputStream pipedIS = new PipedInputStream(); PipedOutputStream pipedOS = new PipedOutputStream(); try { pipedOS.connect(pipedIS); } catch(IOException e) { System.err.println("连接失败"); System.exit(1); } PrintStream ps = new PrintStream(pipedOS); System.setOut(ps); System.setErr(ps); 可以看到，这里的代码极其简单。我们只是建立了一个PipedInputStream，把它设置为所有写入控制台流的数据的最终目的地。所有写入到控制台流的数据都被转到PipedOutputStream，这样，从相应的PipedInputStream读取就可以迅速地截获所有写入控制台流的数据。接下来的事情似乎只剩下在Swing JTextArea中显示从pipedIS流读取的数据，得到一个能够在文本框中显示控制台输出的程序。遗憾的是，在使用Java管道流时有一些重要的注意事项。只有认真对待所有这些注意事项才能保证Listing 1的代码稳定地运行。下面我们来看第一个注意事项。 1.1 注意事项一 PipedInputStream运用的是一个1024字节固定大小的循环缓冲区。写入PipedOutputStream的数据实际上保存到对应的PipedInputStream的内部缓冲区。从PipedInputStream执行读操作时，读取的数据实际上来自这个内部缓冲区。如果对应的PipedInputStream输入缓冲区已满，任何企图写入PipedOutputStream的线程都将被阻塞。而且这个写操作线程将一直阻塞，直至出现读取PipedInputStream的操作从缓冲区删除数据。 这意味着，向PipedOutputStream写数据的线程不应该是负责从对应PipedInputStream读取数据的唯一线程。从图二可以清楚地看出这里的问题所在：假设线程t是负责从PipedInputStream读取数据的唯一线程；另外，假定t企图在一次对PipedOutputStream的write()方法的调用中向对应的PipedOutputStream写入2000字节的数据。在t线程阻塞之前，它最多能够写入1024字节的数据（PipedInputStream内部缓冲区的大小）。然而，一旦t被阻塞，读取PipedInputStream的操作就再也不会出现，因为t是唯一读取PipedInputStream的线程。这样，t线程已经完全被阻塞，同时，所有其他试图向PipedOutputStream写入数据的线程也将遇到同样的情形。 图二：管道流工作过程 这并不意味着在一次write()调用中不能写入多于1024字节的数据。但应当保证，在写入数据的同时，有另一个线程从PipedInputStream读取数据。 Listing 2示范了这个问题。这个程序用一个线程交替地读取PipedInputStream和写入PipedOutputStream。每次调用write()向PipedInputStream的缓冲区写入20字节，每次调用read()只从缓冲区读取并删除10个字节。内部缓冲区最终会被写满，导致写操作阻塞。由于我们用同一个线程执行读、写操作，一旦写操作被阻塞，就不能再从PipedInputStream读取数据。 【Listing 2：用同一个线程执行读/写操作导致线程阻塞】 import java.io.*; public class Listing2 { static PipedInputStream pipedIS = new PipedInputStream(); static PipedOutputStream pipedOS = new PipedOutputStream(); public static void main(String[] a){ try { pipedIS.connect(pipedOS); } catch(IOException e) { System.err.println("连接失败"); System.exit(1); } byte[] inArray = new byte[10]; byte[] outArray = new byte[20]; int bytesRead = 0; try { // 向pipedOS发送20字节数据 pipedOS.write(outArray, 0, 20); System.out.println(" 已发送20字节..."); // 在每一次循环迭代中，读入10字节 // 发送20字节 bytesRead = pipedIS.read(inArray, 0, 10); int i=0; while(bytesRead != -1) { pipedOS.write(outArray, 0, 20); System.out.println(" 已发送20字节..."+i); i++; bytesRead = pipedIS.read(inArray, 0, 10); } } catch(IOException e) { System.err.println("读取pipedIS时出现错误: " + e); System.exit(1); } } // main() } 只要把读/写操作分开到不同的线程，Listing 2的问题就可以轻松地解决。Listing 3是Listing 2经过修改后的版本，它在一个单独的线程中执行写入PipedOutputStream的操作（和读取线程不同的线程）。为证明一次写入的数据可以超过1024字节，我们让写操作线程每次调用PipedOutputStream的write()方法时写入2000字节。那么，在startWriterThread()方法中创建的线程是否会阻塞呢？按照Java运行时线程调度机制，它当然会阻塞。写操作在阻塞之前实际上最多只能写入1024字节的有效载荷（即PipedInputStream缓冲区的大小）。但这并不会成为问题，因为主线程（main）很快就会从PipedInputStream的循环缓冲区读取数据，空出缓冲区空间。最终，写操作线程会从上一次中止的地方重新开始，写入2000字节有效载荷中的剩余部分。 【Listing 3：把读/写操作分开到不同的线程】 import java.io.*; public class Listing3 { static PipedInputStream pipedIS = new PipedInputStream(); static PipedOutputStream pipedOS = new PipedOutputStream(); public static void main(String[] args) { try { pipedIS.connect(pipedOS); } catch(IOException e) { System.err.println("连接失败"); System.exit(1); } byte[] inArray = new byte[10]; int bytesRead = 0; // 启动写操作线程 startWriterThread(); try { bytesRead = pipedIS.read(inArray, 0, 10); while(bytesRead != -1) { System.out.println("已经读取" + bytesRead + "字节..."); bytesRead = pipedIS.read(inArray, 0, 10); } } catch(IOException e) { System.err.println("读取输入错误."); System.exit(1); } } // main() // 创建一个独立的线程 // 执行写入PipedOutputStream的操作 private static void startWriterThread() { new Thread(new Runnable() { public void run() { byte[] outArray = new byte[2000]; while(true) { // 无终止条件的循环 try { // 在该线程阻塞之前，有最多1024字节的数据被写入 pipedOS.write(outArray, 0, 2000); } catch(IOException e) { System.err.println("写操作错误"); System.exit(1); } System.out.println(" 已经发送2000字节..."); } } }).start(); } // startWriterThread() } // Listing3 也许我们不能说这个问题是Java管道流设计上的缺陷，但在应用管道流时，它是一个必须密切注意的问题。下面我们来看看第二个更重要（更危险的）问题。 1.2 注意事项二 从PipedInputStream读取数据时，如果符合下面三个条件，就会出现IOException异常： 试图从PipedInputStream读取数据， PipedInputStream的缓冲区为“空”（即不存在可读取的数据）， 最后一个向PipedOutputStream写数据的线程不再活动（通过Thread.isAlive()检测）。 这是一个很微妙的时刻，同时也是一个极其重要的时刻。假定有一个线程w向PipedOutputStream写入数据；另一个线程r从对应的PipedInputStream读取数据。下面一系列的事件将导致r线程在试图读取PipedInputStream时遇到IOException异常： w向PipedOutputStream写入数据。 w结束（w.isAlive()返回false）。 r从PipedInputStream读取w写入的数据，清空PipedInputStream的缓冲区。 r试图再次从PipedInputStream读取数据。这时PipedInputStream的缓冲区已经为空，而且w已经结束，从而导致在读操作执行时出现IOException异常。 构造一个程序示范这个问题并不困难，只需从Listing 3的startWriterThread()方法中，删除while(true)条件。这个改动阻止了执行写操作的方法循环执行，使得执行写操作的方法在一次写入操作之后就结束运行。如前所述，此时主线程试图读取PipedInputStraem时，就会遇到一个IOException异常。 这是一种比较少见的情况，而且不存在直接修正它的方法。请不要通过从管道流派生子类的方法修正该问题——在这里使用继承是完全不合适的。而且，如果Sun以后改变了管道流的实现方法，现在所作的修改将不再有效。 最后一个问题和第二个问题很相似，不同之处在于，它在读线程（而不是写线程）结束时产生IOException异常。 1.3 注意事项三 如果一个写操作在PipedOutputStream上执行，同时最近从对应PipedInputStream读取的线程已经不再活动（通过Thread.isAlive()检测），则写操作将抛出一个IOException异常。假定有两个线程w和r，w向PipedOutputStream写入数据，而r则从对应的PipedInputStream读取。下面一系列的事件将导致w线程在试图写入PipedOutputStream时遇到IOException异常： 写操作线程w已经创建，但r线程还不存在。 w向PipedOutputStream写入数据。 读线程r被创建，并从PipedInputStream读取数据。 r线程结束。 w企图向PipedOutputStream写入数据，发现r已经结束，抛出IOException异常。 实际上，这个问题不象第二个问题那样棘手。和多个读线程/单个写线程的情况相比，也许在应用中有一个读线程（作为响应请求的服务器）和多个写线程（发出请求）的情况更为常见。 1.4 解决问题 要防止管道流前两个局限所带来的问题，方法之一是用一个ByteArrayOutputStream作为代理或替代PipedOutputStream。Listing 4显示了一个LoopedStreams类，它用一个ByteArrayOutputStream提供和Java管道流类似的功能，但不会出现死锁和IOException异常。这个类的内部仍旧使用管道流，但隔离了本文介绍的前两个问题。我们先来看看这个类的公用方法（参见图3）。构造函数很简单，它连接管道流，然后调用startByteArrayReaderThread()方法（稍后再讨论该方法）。getOutputStream()方法返回一个OutputStream（具体地说，是一个ByteArrayOutputStream）用以替代PipedOutputStream。写入该OutputStream的数据最终将在getInputStream()方法返回的流中作为输入出现。和使用PipedOutputStream的情形不同，向ByteArrayOutputStream写入数据的线程的激活、写数据、结束不会带来负面效果。 图三：ByteArrayOutputStream原理 【Listing 4：防止管道流应用中出现的常见问题】 import java.io.*; public class LoopedStreams { private PipedOutputStream pipedOS = new PipedOutputStream(); private boolean keepRunning = true; private ByteArrayOutputStream byteArrayOS = new ByteArrayOutputStream() { public void close() { keepRunning = false; try { super.close(); pipedOS.close(); } catch(IOException e) { // 记录错误或其他处理 // 为简单计，此处我们直接结束 System.exit(1); } } }; private PipedInputStream pipedIS = new PipedInputStream() { public void close() { keepRunning = false; try { super.close(); } catch(IOException e) { // 记录错误或其他处理 // 为简单计，此处我们直接结束 System.exit(1); } } }; public LoopedStreams() throws IOException { pipedOS.connect(pipedIS); startByteArrayReaderThread(); } // LoopedStreams() public InputStream getInputStream() { return pipedIS; } // getInputStream() public OutputStream getOutputStream() { return byteArrayOS; } // getOutputStream() private void startByteArrayReaderThread() { new Thread(new Runnable() { public void run() { while(keepRunning) { // 检查流里面的字节数 if(byteArrayOS.size() > 0) { byte[] buffer = null; synchronized(byteArrayOS) { buffer = byteArrayOS.toByteArray(); byteArrayOS.reset(); // 清除缓冲区 } try { // 把提取到的数据发送给PipedOutputStream pipedOS.write(buffer, 0, buffer.length); } catch(IOException e) { // 记录错误或其他处理 // 为简单计，此处我们直接结束 System.exit(1); } } else // 没有数据可用，线程进入睡眠状态 try { // 每隔1秒查看ByteArrayOutputStream检查新数据 Thread.sleep(1000); } catch(InterruptedException e) {} } } }).start(); } // startByteArrayReaderThread() } // LoopedStreams startByteArrayReaderThread()方法是整个类真正的关键所在。这个方法的目标很简单，就是创建一个定期地检查ByteArrayOutputStream缓冲区的线程。缓冲区中找到的所有数据都被提取到一个byte数组，然后写入到PipedOutputStream。由于PipedOutputStream对应的PipedInputStream由getInputStream()返回，从该输入流读取数据的线程都将读取到原先发送给ByteArrayOutputStream的数据。前面提到，LoopedStreams类解决了管道流存在的前二个问题，我们来看看这是如何实现的。 ByteArrayOutputStream具有根据需要扩展其内部缓冲区的能力。由于存在“完全缓冲”，线程向getOutputStream()返回的流写入数据时不会被阻塞。因而，第一个问题不会再给我们带来麻烦。另外还要顺便说一句，ByteArrayOutputStream的缓冲区永远不会缩减。例如，假设在能够提取数据之前，有一块500 K的数据被写入到流，缓冲区将永远保持至少500 K的容量。如果这个类有一个方法能够在数据被提取之后修正缓冲区的大小，它就会更完善。 第二个问题得以解决的原因在于，实际上任何时候只有一个线程向PipedOutputStream写入数据，这个线程就是由startByteArrayReaderThread()创建的线程。由于这个线程完全由LoopedStreams类控制，我们不必担心它会产生IOException异常。 LoopedStreams类还有一些细节值得提及。首先，我们可以看到byteArrayOS和pipedIS实际上分别是ByteArrayOutputStream和PipedInputStream的派生类的实例，也即在它们的close()方法中加入了特殊的行为。如果一个LoopedStreams对象的用户关闭了输入或输出流，在startByteArrayReaderThread()中创建的线程必须关闭。覆盖后的close()方法把keepRunning标记设置成false以关闭线程。另外，请注意startByteArrayReaderThread()中的同步块。要确保在toByteArray()调用和reset()调用之间ByteArrayOutputStream缓冲区不被写入流的线程修改，这是必不可少的。由于ByteArrayOutputStream的write()方法的所有版本都在该流上同步，我们保证了ByteArrayOutputStream的内部缓冲区不被意外地修改。 注意LoopedStreams类并不涉及管道流的第三个问题。该类的getInputStream()方法返回PipedInputStream。如果一个线程从该流读取，一段时间后终止，下次数据从ByteArrayOutputStream缓冲区传输到PipedOutputStream时就会出现IOException异常。 二、捕获Java控制台输出 Listing 5的ConsoleTextArea类扩展Swing JTextArea捕获控制台输出。不要对这个类有这么多代码感到惊讶，必须指出的是，ConsoleTextArea类有超过50%的代码用来进行测试。 【Listing 5：截获Java控制台输出】 import java.io.*; import java.util.*; import javax.swing.*; import javax.swing.text.*; public class ConsoleTextArea extends JTextArea { public ConsoleTextArea(InputStream[] inStreams) { for(int i = 0; i < inStreams.length; ++i) startConsoleReaderThread(inStreams[i]); } // ConsoleTextArea() public ConsoleTextArea() throws IOException { final LoopedStreams ls = new LoopedStreams(); // 重定向System.out和System.err PrintStream ps = new PrintStream(ls.getOutputStream()); System.setOut(ps); System.setErr(ps); startConsoleReaderThread(ls.getInputStream()); } // ConsoleTextArea() private void startConsoleReaderThread( InputStream inStream) { final BufferedReader br = new BufferedReader(new InputStreamReader(inStream)); new Thread(new Runnable() { public void run() { StringBuffer sb = new StringBuffer(); try { String s; Document doc = getDocument(); while((s = br.readLine()) != null) { boolean caretAtEnd = false; caretAtEnd = getCaretPosition() == doc.getLength() ? true : false; sb.setLength(0); append(sb.append(s).append('\n').toString()); if(caretAtEnd) setCaretPosition(doc.getLength()); } } catch(IOException e) { JOptionPane.showMessageDialog(null, "从BufferedReader读取错误：" + e); System.exit(1); } } }).start(); } // startConsoleReaderThread() // 该类剩余部分的功能是进行测试 public static void main(String[] args) { JFrame f = new JFrame("ConsoleTextArea测试"); ConsoleTextArea consoleTextArea = null; try { consoleTextArea = new ConsoleTextArea(); } catch(IOException e) { System.err.println( "不能创建LoopedStreams：" + e); System.exit(1); } consoleTextArea.setFont(java.awt.Font.decode("monospaced")); f.getContentPane().add(new JScrollPane(consoleTextArea), java.awt.BorderLayout.CENTER); f.setBounds(50, 50, 300, 300); f.setVisible(true); f.addWindowListener(new java.awt.event.WindowAdapter() { public void windowClosing( java.awt.event.WindowEvent evt) { System.exit(0); } }); // 启动几个写操作线程向 // System.out和System.err输出 startWriterTestThread( "写操作线程 #1", System.err, 920, 50); startWriterTestThread( "写操作线程 #2", System.out, 500, 50); startWriterTestThread( "写操作线程 #3", System.out, 200, 50); startWriterTestThread( "写操作线程 #4", System.out, 1000, 50); startWriterTestThread( "写操作线程 #5", System.err, 850, 50); } // main() private static void startWriterTestThread( final String name, final PrintStream ps, final int delay, final int count) { new Thread(new Runnable() { public void run() { for(int i = 1; i <= count; ++i) { ps.println("***" + name + ", hello !, i=" + i); try { Thread.sleep(delay); } catch(InterruptedException e) {} } } }).start(); } // startWriterTestThread() } // ConsoleTextArea main()方法创建了一个JFrame，JFrame包含一个ConsoleTextArea的实例。这些代码并没有什么特别之处。Frame显示出来之后，main()方法启动一系列的写操作线程，写操作线程向控制台流输出大量信息。ConsoleTextArea捕获并显示这些信息，如图一所示。 ConsoleTextArea提供了两个构造函数。没有参数的构造函数用来捕获和显示所有写入到控制台流的数据，有一个InputStream[]参数的构造函数转发所有从各个数组元素读取的数据到JTextArea。稍后将有一个例子显示这个构造函数的用处。首先我们来看看没有参数的ConsoleTextArea构造函数。这个函数首先创建一个LoopedStreams对象；然后请求Java运行时环境把控制台输出转发到LoopedStreams提供的OutputStream；最后，构造函数调用startConsoleReaderThread()，创建一个不断地把文本行追加到JTextArea的线程。注意，把文本追加到JTextArea之后，程序小心地保证了插入点的正确位置。 一般来说，Swing部件的更新不应该在AWT事件分派线程（AWT Event Dispatch Thread，AEDT）之外进行。对于本例来说，这意味着所有把文本追加到JTextArea的操作应该在AEDT中进行，而不是在startConsoleReaderThread()方法创建的线程中进行。然而，事实上在Swing中向JTextArea追加文本是一个线程安全的操作。读取一行文本之后，我们只需调用JText.append()就可以把文本追加到JTextArea的末尾。 三、捕获其他程序的控制台输出 在JTextArea中捕获Java程序自己的控制台输出是一回事，去捕获其他程序（甚至包括一些非Java程序）的控制台数据又是另一回事。ConsoleTextArea提供了捕获其他应用的输出时需要的基础功能，Listing 6的AppOutputCapture利用ConsoleTextArea，截取其他应用的输出信息然后显示在ConsoleTextArea中。 【Listing 6：截获其他程序的控制台输出】 import java.awt.*; import java.awt.event.*; import java.io.*; import javax.swing.*; public class AppOutputCapture { private static Process process; public static void main(String[] args) { if(args.length == 0) { System.err.println("用法：java AppOutputCapture " + "<程序名字> {参数1 参数2 ...}"); System.exit(0); } try { // 启动命令行指定程序的新进程 process = Runtime.getRuntime().exec(args); } catch(IOException e) { System.err.println("创建进程时出错...\n" + e); System.exit(1); } // 获得新进程所写入的流 InputStream[] inStreams = new InputStream[] { process.getInputStream(),process.getErrorStream()}; ConsoleTextArea cta = new ConsoleTextArea(inStreams); cta.setFont(java.awt.Font.decode("monospaced")); JFrame frame = new JFrame(args[0] + "控制台输出"); frame.getContentPane().add(new JScrollPane(cta), BorderLayout.CENTER); frame.setBounds(50, 50, 400, 400); frame.setVisible(true); frame.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent evt) { process.destroy(); try { process.waitFor(); // 在Win98下可能被挂起 } catch(InterruptedException e) {} System.exit(0); } }); } // main() } // AppOutputCapture AppOutputCapture的工作过程如下：首先利用Runtime.exec()方法启动指定程序的一个新进程。启动新进程之后，从结果Process对象得到它的控制台流。之后，把这些控制台流传入ConsoleTextArea(InputStream[])构造函数（这就是带参数ConsoleTextArea构造函数的用处）。使用AppOutputCapture时，在命令行上指定待截取其输出的程序名字。例如，如果在Windows 2000下执行javaw.exe AppOutputCapture ping.exe www.yahoo.com，则结果如图四所示。 图四：截取其他程序的控制台输出 使用AppOutputCapture时应该注意，被截取输出的应用程序最初输出的一些文本可能无法截取。因为在调用Runtime.exec()和ConsoleTextArea初始化完成之间存在一小段时间差。在这个时间差内，应用程序输出的文本会丢失。当AppOutputCapture窗口被关闭，process.destory()调用试图关闭Java程序开始时创建的进程。测试结果显示出，destroy()方法不一定总是有效（至少在Windows 98上是这样的）。似乎当待关闭的进程启动了额外的进程时，则那些进程不会被关闭。此外，在这种情况下AppOutputCapture程序看起来未能正常结束。但在Windows NT下，一切正常。如果用JDK v1.1.x运行AppOutputCapture，关闭窗口时会出现一个NullPointerException。这是一个JDK的Bug，JDK 1.2.x和JDK 1.3.x下就不会出现问题。

吴高峰 常德卷烟厂信息技术部

2005 年 2 月 01 日

大多数IT 组织都必须解决三个主要问题：1．帮助组织减少成本 2．增加并且保持客户 3．加快业务效率。完成这些问题一般都需要实现对多个业务系统的数据和业务逻辑的无缝访问，也就是说，要实施系统集成工程，以便联结业务流程、实现数据的访问与共享。

JpetStore 4.0是ibatis的最新示例程序，基于Struts MVC框架（注：非传统Struts开发模式），以ibatis作为持久化层。该示例程序设计优雅，层次清晰，可以学习以及作为一个高效率的编程模型参考。本文是在其基础上，采用Spring对其中间层（业务层）进行改造。使开发量进一步减少，同时又拥有了Spring的一些好处…

1. 前言

JpetStore 4.0是ibatis的最新示例程序。ibatis是开源的持久层产品，包含SQL Maps 2.0 和 Data Access Objects 2.0 框架。JpetStore示例程序很好的展示了如何利用ibatis来开发一个典型的J2EE web应用程序。JpetStore有如下特点：

• ibatis数据层
• POJO业务层
• POJO领域类
• Struts MVC
• JSP 表示层

以下是本文用到的关键技术介绍，本文假设您已经对Struts，SpringFramewok，ibatis有一定的了解，如果不是，请首先查阅附录中的参考资料。

• Struts 是目前Java Web MVC框架中不争的王者。经过长达五年的发展，Struts已经逐渐成长为一个稳定、成熟的框架，并且占有了MVC框架中最大的市场份额。但是Struts某些技术特性上已经落后于新兴的MVC框架。面对Spring MVC、Webwork2 这些设计更精密，扩展性更强的框架，Struts受到了前所未有的挑战。但站在产品开发的角度而言，Struts仍然是最稳妥的选择。本文的原型例子JpetStore 4.0就是基于Struts开发的，但是不拘泥于Struts的传统固定用法，例如只用了一个自定义Action类，并且在form bean类的定义上也是开创性的，令人耳目一新，稍后将具体剖析一下。
• Spring Framework 实际上是Expert One-on-One J2EE Design and Development 一书中所阐述的设计思想的具体实现。Spring Framework的功能非常多。包含AOP、ORM、DAO、Context、Web、MVC等几个部分组成。Web、MVC暂不用考虑，JpetStore 4.0用的是更成熟的Struts和JSP；DAO由于目前Hibernate、JDO、ibatis的流行，也不考虑，JpetStore 4.0用的就是ibatis。因此最需要用的是AOP、ORM、Context。Context中，最重要的是Beanfactory，它能将接口与实现分开，非常强大。目前AOP应用最成熟的还是在事务管理上。
• ibatis 是一个功能强大实用的SQL Map工具，不同于其他ORM工具（如hibernate），它是将SQL语句映射成Java对象，而对于ORM工具，它的SQL语句是根据映射定义生成的。ibatis 以SQL开发的工作量和数据库移植性上的让步，为系统设计提供了更大的自由空间。有ibatis代码生成的工具，可以根据DDL自动生成ibatis代码，能减少很多工作量。

回页首

2. JpetStore简述

2.1. 背景

最初是Sun公司的J2EE petstore，其最主要目的是用于学习J2EE，但是其缺点也很明显，就是过度设计了。接着Oracle用J2EE petstore来比较各应用服务器的性能。微软推出了基于.Net平台的 Pet shop，用于竞争J2EE petstore。而JpetStore则是经过改良的基于struts的轻便框架J2EE web应用程序，相比来说，JpetStore设计和架构更优良，各层定义清晰，使用了很多最佳实践和模式，避免了很多"反模式"，如使用存储过程，在java代码中嵌入SQL语句，把HTML存储在数据库中等等。最新版本是JpetStore 4.0。

2.2. JpetStore开发运行环境的建立

1、开发环境

• Java SDK 1.4.2
• Apache Tomcat 4.1.31
• Eclipse-SDK-3.0.1-win32
• HSQLDB 1.7.2

2、Eclipse插件

• EMF SDK 2.0.1：Eclipse建模框架，lomboz插件需要，可以使用runtime版本。
• lomboz 3.0：J2EE插件，用来在Eclipse中开发J2EE应用程序
• Spring IDE 1.0.3：Spring Bean配置管理插件
• xmlbuddy_2.0.10：编辑XML，用免费版功能即可
• tomcatPluginV3：tomcat管理插件
• Properties Editor：编辑java的属性文件,并可以预览以及自动存盘为Unicode格式。免去了手工或者ANT调用native2ascii的麻烦。

3、示例源程序

• ibatis示例程序JpetStore 4.0 http://www.ibatis.com/jpetstore/jpetstore.html
• 改造后的源程序（+spring）（源码链接）

2.3. 架构

图1 是JPetStore架构图，更详细的内容请参见JPetStore的白皮书。参照这个架构图，让我们稍微剖析一下源代码，得出JpetStore 4.0的具体实现图（见图2），思路一下子就豁然开朗了。前言中提到的非传统的struts开发模式，关键就在struts Action类和form bean类上。

struts Action类只有一个：BeanAction。没错，确实是一个！与传统的struts编程方式很不同。再仔细研究BeanAction类，发现它其实是一个通用类，利用反射原理，根据URL来决定调用formbean的哪个方法。BeanAction大大简化了struts的编程模式，降低了对struts的依赖（与struts以及WEB容器有关的几个类都放在com.ibatis.struts包下，其它的类都可以直接复用）。利用这种模式，我们会很容易的把它移植到新的框架如JSF，spring。

这样重心就转移到form bean上了，它已经不是普通意义上的form bean了。查看源代码，可以看到它不仅仅有数据和校验/重置方法，而且已经具有了行为，从这个意义上来说，它更像一个BO(Business Object)。这就是前文讲到的，BeanAction类利用反射原理，根据URL来决定调用form bean的哪个方法（行为）。form bean的这些方法的签名很简单，例如：

												
														 public String myActionMethod() {
   //..work
   return "success";
 }
 
												
										

方法的返回值直接就是字符串，对应的是forward的名称，而不再是ActionForward对象，创建ActionForward对象的任务已经由BeanAction类代劳了。

另外，程序还提供了ActionContext工具类，该工具类封装了request 、response、form parameters、request attributes、session attributes和 application attributes中的数据存取操作，简单而线程安全，form bean类使用该工具类可以进一步从表现层框架解耦。

在这里需要特别指出的是，BeanAction类是对struts扩展的一个有益尝试，虽然提供了非常好的应用开发模式，但是它还非常新，一直在发展中。

2.4. 代码剖析

下面就让我们开始进一步分析JpetStore4.0的源代码，为下面的改造铺路。

• BeanAction.java是唯一一个Struts action类，位于com.ibatis.struts包下。正如上文所言，它是一个通用的控制类，利用反射机制，把控制转移到form bean的某个方法来处理。详细处理过程参考其源代码，简单明晰。

• Form bean类位于com.ibatis.jpetstore.presentation包下，命名规则为***Bean。Form bean类全部继承于BaseBean类，而BaseBean类实际继承于ActionForm，因此，Form bean类就是Struts的 ActionForm，Form bean类的属性数据就由struts框架自动填充。而实际上，JpetStore4.0扩展了struts中ActionForm的应用： Form bean类还具有行为，更像一个BO,其行为（方法）由BeanAction根据配置（struts-config.xml）的URL来调用。虽然如此，我们还是把Form bean类定位于表现层。

  Struts-config.xml的配置里有3种映射方式，来告诉BeanAction把控制转到哪个form bean对象的哪个方法来处理。

  以这个请求连接为例http://localhost/jpetstore4/shop/viewOrder.do

  1. URL Pattern

  <action path="/shop/viewOrder" type="com.ibatis.struts.BeanAction" name="orderBean" scope="session" validate="false"> <forward name="success" path="/order/ViewOrder.jsp"/> </action>

  
  

  此种方式表示，控制将被转发到"orderBean"这个form bean对象 的"viewOrder"方法（行为）来处理。方法名取"path"参数的以"/"分隔的最后一部分。

  2. Method Parameter

  <action path="/shop/viewOrder" type="com.ibatis.struts.BeanAction" name="orderBean" parameter="viewOrder" scope="session" validate="false"> <forward name="success" path="/order/ViewOrder.jsp"/> </action>

  
  

  此种方式表示，控制将被转发到"orderBean"这个form bean对象的"viewOrder"方法（行为）来处理。配置中的"parameter"参数表示form bean类上的方法。"parameter"参数优先于"path"参数。

  3. No Method call

  <action path="/shop/viewOrder" type="com.ibatis.struts.BeanAction" name="orderBean" parameter="*" scope="session" validate="false"> <forward name="success" path="/order/ViewOrder.jsp"/> </action>

  
  

  此种方式表示，form bean上没有任何方法被调用。如果存在"name"属性，则struts把表单参数等数据填充到form bean对象后，把控制转发到"success"。否则，如果name为空，则直接转发控制到"success"。

  这就相当于struts内置的org.apache.struts.actions.ForwardAction的功能

  <action path="/shop/viewOrder" type="org.apache.struts.actions.ForwardAction" parameter="/order/ViewOrder.jsp " scope="session" validate="false"> </action>

  
  
• Service类位于com.ibatis.jpetstore.service包下，属于业务层。这些类封装了业务以及相应的事务控制。Service类由form bean类来调用。
• com.ibatis.jpetstore.persistence.iface包下的类是DAO接口，属于业务层，其屏蔽了底层的数据库操作，供具体的Service类来调用。DaoConfig类是工具类（DAO工厂类），Service类通过DaoConfig类来获得相应的DAO接口，而不用关心底层的具体数据库操作，实现了如图2中{耦合2}的解耦。
• com.ibatis.jpetstore.persistence.sqlmapdao包下的类是对应DAO接口的具体实现，在JpetStore4.0中采用了ibatis来实现ORM。这些实现类继承BaseSqlMapDao类，而BaseSqlMapDao类则继承ibatis DAO 框架中的SqlMapDaoTemplate类。ibatis的配置文件存放在com.ibatis.jpetstore.persistence.sqlmapdao.sql目录下。这些类和配置文件位于数据层
• Domain类位于com.ibatis.jpetstore.domain包下，是普通的javabean。在这里用作数据传输对象（DTO），贯穿视图层、业务层和数据层，用于在不同层之间传输数据。

剩下的部分就比较简单了，请看具体的源代码，非常清晰。

2.5. 需要改造的地方

JpetStore4.0的关键就在struts Action类和form bean类上，这也是其精华之一（虽然该实现方式是试验性，待扩充和验证），在此次改造中我们要保留下来，即控制层一点不变，表现层获取相应业务类的方式变了（要加载spring环境），其它保持不变。要特别关注的改动是业务层和持久层，幸运的是JpetStore4.0设计非常好，需要改动的地方非常少，而且由模式可循，如下：

1. 业务层和数据层用Spring BeanFactory机制管理。

2. 业务层的事务由spring 的aop通过声明来完成。

3. 表现层（form bean）获取业务类的方法改由自定义工厂类来实现（加载spring环境）。

回页首

3. JPetStore的改造

3.1. 改造后的架构

其中红色部分是要增加的部分，蓝色部分是要修改的部分。下面就让我们逐一剖析。

3.2. Spring Context的加载

为了在Struts中加载Spring Context，一般会在struts-config.xml的最后添加如下部分：

												
														<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation"
value="/WEB-INF/applicationContext.xml" />
</plug-in>

												
										

Spring在设计时就充分考虑到了与Struts的协同工作，通过内置的Struts Plug-in在两者之间提供了良好的结合点。但是，因为在这里我们一点也不改动JPetStore的控制层(这是JpetStore4.0的精华之一)，所以本文不准备采用此方式来加载ApplicationContext。我们利用的是spring framework 的BeanFactory机制,采用自定义的工具类（bean工厂类）来加载spring的配置文件，从中可以看出Spring有多灵活，它提供了各种不同的方式来使用其不同的部分/层次，您只需要用你想用的，不需要的部分可以不用。

具体的来说，就是在com.ibatis.spring包下创建CustomBeanFactory类，spring的配置文件applicationContext.xml也放在这个目录下。以下就是该类的全部代码，很简单：

												
														public final class CustomBeanFactory {
	static XmlBeanFactory factory = null;
	static {
		Resource is = new
InputStreamResource( CustomBeanFactory.class.getResourceAsStream("applicationContext.xml"));
		factory = new XmlBeanFactory(is);			
	}
	public static Object getBean(String beanName){
		return factory.getBean(beanName);
	}
}

												
										

实际上就是封装了Spring 的XMLBeanFactory而已，并且Spring的配置文件只需要加载一次，以后就可以直接用CustomBeanFactory.getBean("someBean")来获得需要的对象了(例如someBean)，而不需要知道具体的类。CustomBeanFactory类用于{耦合1}的解耦。

CustomBeanFactory类在本文中只用于表现层的form bean对象获得service类的对象，因为我们没有把form bean对象配置在applicationContext.xml中。但是，为什么不把表现层的form bean类也配置起来呢，这样就用不着这CustomBeanFactory个类了，Spring会帮助我们创建需要的一切？问题的答案就在于form bean类是struts的ActionForm类！如果大家熟悉struts，就会知道ActionForm类是struts自动创建的：在一次请求中，struts判断，如果ActionForm实例不存在，就创建一个ActionForm对象，把客户提交的表单数据保存到ActionForm对象中。因此formbean类的对象就不能由spring来创建，但是service类以及数据层的DAO类可以，所以只有他们在spring中配置。

所以，很自然的，我们就创建了CustomBeanFactory类，在表现层来衔接struts和spring。就这么简单，实现了另一种方式的{耦合一}的解耦。

3.3. 表现层

面分析到，struts和spring是在表现层衔接起来的，那么表现层就要做稍微的更改，即所需要的service类的对象创建上。以表现层的AccountBean类为例：

原来的源代码如下

    private static final AccountService accountService = AccountService.getInstance();
  private static final CatalogService catalogService = CatalogService.getInstance();
  

改造后的源代码如下

  private static final AccountService accountService = (AccountService)CustomBeanFactory.getBean("AccountService");
  private static final CatalogService catalogService = (CatalogService)CustomBeanFactory.getBean("CatalogService");

其他的几个presentation类以同样方式改造。这样，表现层就完成了。关于表现层的其它部分如JSP等一概不动。也许您会说，没有看出什么特别之处的好处啊？你还是额外实现了一个工厂类。别着急，帷幕刚刚开启，spring是在表现层引入，但您发没发现：

• presentation类仅仅面向service类的接口编程，具体"AccountService"是哪个实现类，presentation类不知道，是在spring的配置文件里配置。（本例中，为了最大限度的保持原来的代码不作变化，没有抽象出接口）。Spring鼓励面向接口编程，因为是如此的方便和自然，当然您也可以不这么做。
• CustomBeanFactory这个工厂类为什么会如此简单，因为其直接使用了Spring的BeanFactory。Spring从其核心而言，是一个DI容器，其设计哲学是提供一种无侵入式的高扩展性的框架。为了实现这个目标，Spring 大量引入了Java 的Reflection机制，通过动态调用的方式避免硬编码方式的约束，并在此基础上建立了其核心组件BeanFactory，以此作为其依赖注入机制的实现基础。org.springframework.beans包中包括了这些核心组件的实现类，核心中的核心为BeanWrapper和BeanFactory类。

3.4. 持久层

在讨论业务层之前，我们先看一下持久层，如下图所示：

在上文中，我们把iface包下的DAO接口归为业务层，在这里不需要做修改。ibatis的sql配置文件也不需要改。要改的是DAO实现类，并在spring的配置文件中配置起来。

1、修改基类

所有的DAO实现类都继承于BaseSqlMapDao类。修改BaseSqlMapDao类如下：

public class BaseSqlMapDao extends SqlMapClientDaoSupport {
  protected static final int PAGE_SIZE = 4;
  protected SqlMapClientTemplate smcTemplate = this.getSqlMapClientTemplate();
  public BaseSqlMapDao() { 
	}
}

使BaseSqlMapDao类改为继承于Spring提供的SqlMapClientDaoSupport类，并定义了一个保护属性smcTemplate，其类型为SqlMapClientTemplate。关于SqlMapClientTemplate类的详细说明请参照附录中的"Spring中文参考手册"

2、修改DAO实现类

所有的DAO实现类还是继承于BaseSqlMapDao类，实现相应的DAO接口，但其相应的DAO操作委托SqlMapClientTemplate来执行，以AccountSqlMapDao类为例，部分代码如下：

    public List getUsernameList() {
    return smcTemplate.queryForList("getUsernameList", null);
  }
  public Account getAccount(String username, String password) {
    Account account = new Account();
    account.setUsername(username);
    account.setPassword(password);
    return (Account) smcTemplate.queryForObject("getAccountByUsernameAndPassword", account);
  }
  public void insertAccount(Account account) {
  	smcTemplate.update("insertAccount", account);
  	smcTemplate.update("insertProfile", account);
  	smcTemplate.update("insertSignon", account);
  }
  

就这么简单，所有函数的签名都是一样的，只需要查找替换就可以了！

3、除去工厂类以及相应的配置文件

除去DaoConfig.java这个DAO工厂类和相应的配置文件dao.xml，因为DAO的获取现在要用spring来管理。

4、DAO在Spring中的配置（applicationContext.xml）

    <bean id="dataSource" 
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName">
            <value>org.hsqldb.jdbcDriver</value>
        </property>
        <property name="url">
            <value>jdbc:hsqldb:hsql://localhost/xdb</value>
        </property>
        <property name="username">
            <value>sa</value>
        </property>
        <property name="password">
            <value></value>
        </property>
    </bean>    
    <!-- ibatis sqlMapClient config -->
    <bean id="sqlMapClient" 
        class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">
        <property name="configLocation">
            <value> 
                classpath:com\ibatis\jpetstore\persistence\sqlmapdao\sql\sql-map-config.xml
            </value>
        </property>
        <property name="dataSource">
            <ref bean="dataSource"/>
        </property>    
    </bean>
    <!-- Transactions -->
    <bean id="TransactionManager" 
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource">
            <ref bean="dataSource"/>
        </property>
    </bean>
    <!-- persistence layer -->
    <bean id="AccountDao" 
        class="com.ibatis.jpetstore.persistence.sqlmapdao.AccountSqlMapDao">
        <property name="sqlMapClient">
            <ref local="sqlMapClient"/>
        </property>
    </bean>
    

具体的语法请参照附录中的"Spring中文参考手册"。在这里只简单解释一下：

1. 我们首先创建一个数据源dataSource，在这里配置的是hsqldb数据库。如果是ORACLE数据库，driverClassName的值是"oracle.jdbc.driver.OracleDriver"，URL的值类似于"jdbc:oracle:thin:@wugfMobile:1521:cdcf"。数据源现在由spring来管理，那么现在我们就可以去掉properties目录下database.properties这个配置文件了；还有不要忘记修改sql-map-config.xml，去掉<properties resource="properties/database.properties"/>对它的引用。

2. sqlMapClient节点。这个是针对ibatis SqlMap的SqlMapClientFactoryBean配置。实际上配置了一个sqlMapClient的创建工厂类。configLocation属性配置了ibatis映射文件的名称。dataSource属性指向了使用的数据源，这样所有使用sqlMapClient的DAO都默认使用了该数据源，除非在DAO的配置中另外显式指定。

3. TransactionManager节点。定义了事务，使用的是DataSourceTransactionManager。

4. 下面就可以定义DAO节点了，如AccountDao，它的实现类是com.ibatis.jpetstore.persistence.sqlmapdao.AccountSqlMapDao，使用的SQL配置从sqlMapClient中读取，数据库连接没有特别列出，那么就是默认使用sqlMapClient配置的数据源datasource。

这样，我们就把持久层改造完了，其他的DAO配置类似于AccountDao。怎么样？简单吧。这次有接口了：） AccountDao接口－>AccountSqlMapDao实现。

3.5. 业务层

业务层的位置以及相关类，如下图所示：

在这个例子中只有3个业务类，我们以OrderService类为例来改造，这个类是最复杂的，其中涉及了事务。

1、在ApplicationContext配置文件中增加bean的配置：

    <bean id="OrderService" 
        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <property name="transactionManager">
            <ref local="TransactionManager"></ref>
        </property>
        <property name="target">
            <bean class="com.ibatis.jpetstore.service.OrderService">
                <property name="itemDao">
                    <ref bean="ItemDao"/>
                </property>
                <property name="orderDao">
                    <ref bean="OrderDao"/>
                </property>
                <property name="sequenceDao">
                    <ref bean="SequenceDao"/>
                </property>
            </bean>
        </property>
        <property name="transactionAttributes">
            <props>
                <prop key="insert*">PROPAGATION_REQUIRED</prop>
            </props>
        </property>
    </bean>
    

定义了一个OrderService，还是很容易懂的。为了简单起见，使用了嵌套bean，其实现类是com.ibatis.jpetstore.service.OrderService，分别引用了ItemDao，OrderDao，SequenceDao。该bean的insert*实现了事务管理(AOP方式)。TransactionProxyFactoryBean自动创建一个事务advisor， 该advisor包括一个基于事务属性的pointcut,因此只有事务性的方法被拦截。

2、业务类的修改

以OrderService为例：

public class OrderService {

   /* Private Fields */
  private ItemDao itemDao;
  private OrderDao orderDao;
  private SequenceDao sequenceDao;

  /* Constructors */

  public OrderService() {
  }

/**
 * @param itemDao 要设置的 itemDao。
 */
public final void setItemDao(ItemDao itemDao) {
	this.itemDao = itemDao;
}
/**
 * @param orderDao 要设置的 orderDao。
 */
public final void setOrderDao(OrderDao orderDao) {
	this.orderDao = orderDao;
}
/**
 * @param sequenceDao 要设置的 sequenceDao。
 */
public final void setSequenceDao(SequenceDao sequenceDao) {
	this.sequenceDao = sequenceDao;
}
//剩下的部分
…….
}

红色部分为修改部分。Spring采用的是Type2的设置依赖注入，所以我们只需要定义属性和相应的设值函数就可以了，ItemDao，OrderDao，SequenceDao的值由spring在运行期间注入。构造函数就可以为空了，另外也不需要自己编写代码处理事务了（事务在配置中声明），daoManager.startTransaction();等与事务相关的语句也可以去掉了。和原来的代码比较一下，是不是处理精简了很多！可以更关注业务的实现。

回页首

4. 结束语

ibatis是一个功能强大实用的SQL Map工具，可以直接控制SQL,为系统设计提供了更大的自由空间。其提供的最新示例程序JpetStore 4.0,设计优雅，应用了迄今为止很多最佳实践和设计模式，非常适于学习以及在此基础上创建轻量级的J2EE WEB应用程序。JpetStore 4.0是基于struts的，本文在此基础上，最大程度保持了原有设计的精华以及最小的代码改动量，在业务层和持久化层引入了Spring。在您阅读了本文以及改造后的源代码后，会深切的感受到Spring带来的种种好处：自然的面向接口的编程，业务对象的依赖注入，一致的数据存取框架和声明式的事务处理，统一的配置文件…更重要的是Spring既是全面的又是模块化的，Spring有分层的体系结构，这意味着您能选择仅仅使用它任何一个独立的部分，就像本文，而它的架构又是内部一致。

回页首

参考资料

• jpetstore相关各种资料和源程序 http://www.ibatis.com/jpetstore/jpetstore.html
  
  
• Spring中文参考手册http://www.jactiongroup.net/reference/html/index.html
  
  
• Spring 开发指南 夏昕
  
  
• Struts http://struts.apache.org/
  

回页首

关于作者

		吴高峰，原一直在中兴通讯从事运营支撑产品的研发工作，对J2EE以及各种开源项目感兴趣。现在常德卷烟厂信息技术部从事EAI的建设。联系方式：shuwgf@21cn.com

　　javac编译工具被安装在JDK根目录的/bin目录下，负责将源代码编译成运行于JVM的字节码。事实上，我们经常使用/bin目录下的javac编译工具来编译Java源文件。如果在Java程序中动态编译任意制定的Java语句，使用这个外部的javac编译器就显得不够灵活了。虽然有时可使用Runtime类来执行一个外部命令，但如果想知道代码是否被编译通过、编译时发生了什么错误，用Runtime类的exec()方法就很难实现了。 

　　在Sun的JDK 1.2及后续版本中，JDK安装路径的/lib路径下包含了一个tools.jar文件，这个类库包含了一个完整的编译器包。com.sun.tools.javac.Main是编译器的主类入口，如果已经熟悉了javac编译器命令行的使用方法，很容易理解这个类的使用方法。方法compile(String[] p)执行编译动作，参数p是一个String数组，用来存放javac命令的参数选项，编译后的状态返回一个Int值，其对应值参考如下表所示： 

　　表 状态参数与对应值 

　　EXIT_OK 0 

　　EXIT_ERROR 1 

　　EXIT_CMDERR 2 

　　EXIT_SYSERR 3 

　　EXIT_ABNORMAL 4 

　　 

　　在程序执行时编译和执行Java语句 

　　从上面一段中，我们已经基本了解了动态编译一个Java文件的方法。那么，如何运行时动态编译指定的Java语句呢？这里需要一个技巧。 

　　假设要动态编译的Java条语句如下： 

　　编译器不支持编译单个Java语句，被编译的对象必须是一个以.java为后缀的、结构合法的类源程序文件，所以需要对这个语句进行改造，变成一个完整的类，并把这条语句置入main方法中，便于测试。 

　　这样，欲动态编译的代码已经被程序动态拼装成了上面那段代码，准备工作还没有结束，不过看起来工作在趋向稍微的复杂化。因为上述代码当前还存放在内存中，编译器似乎对一个硬盘文件更感兴趣。我们需要引用java.io.File类（JDK 1.2以上），创建一个临时的文件来存放上述代码的内容。java.io.File类的静态方法createTempFile()方法保证所创建的文件名是不重复的，这样会增大这段程序的灵活性。灵活性取决于真正应用到系统架构中的策略。 

　　System.getProperty(“user.dir”)用来获得当前路径，在这里作为临时文件的存放目录。 

　　我们约定被创建的临时文件名以“JavaRuntime”为头缀（可任意命名），后缀名以“.java”结尾。一个待编译的Java源文件已被动态生成。下一步要从com.sun.tools.javac包中创建一个Main实例，调用javac.compile()方法编译这个临时文件： 

　　假定临时文件通过了编译器文法验证等验证，编译成功（status值等于0，参看前表），在当前程序的运行目录下就会多了一个Java类文件。我们将通过执行这个Java 类文件，来模拟执行欲动态编译代码的结果。 

　　Java提供在运行时刻加载类的特性，可动态识别和调用类构造方法、类字段和类方法。java.lang.reflect.Method实现了Member接口，可以调用接口的方法来获得方法类的名称、修饰词等。方法getRuturnType()、getParameterTypes()、getExeptionTypess()等返回被表示方法的构造信息。Method另一个重要的特性是可以调用invoke()执行这个方法（详细使用方法可以查看java.lang.reflect包文档）。下面这段代码中创建一个java.lang.reflect.Method类方法，调用getMethod()方法获得被拼装的main方法的映射，这段代码如下： 

　　运行结果参如下： 

　　Hello，This runtime code！ 

　　 

　　示范程序 

　　下面给出了一个简单的Java程序，这个程序说明了如何利用Sun的javac编译器完成动态编译Java语句。运行该程序需要计算机安装JDK 1.2以上版本，并在classpath中或运行时指定tools.jar文件位置。 

　　程序结构： 

　　◆ compile() 编译Java代码，返回生成的临时文件； 

　　◆ run()运行编译的class文件； 

　　◆ debug()输出调试信息； 

　　◆ getClassName()从一个Java源文件获得类名； 

　　◆ readLine()从控制台读取用户输入的Java Code。 

　　编译运行上述代码，在please input java code提示下输入以下代码： 

　　for(int i=0;i<10;i++){System.out.println(“this is:”+i);} 

　　运行结果如下所示： 

　　Please input java code： 

　　for(int i=0;i<10;i++){System.out.println(“this is:”+i);} 

　　wait.... 

　　-------------------- 

　　this is:0 

　　this is:1 

　　this is:2 

　　this is:3 

　　this is:4 

　　this is:5 

　　this is:6 

　　this is:7 

　　this is:8 

　　this is:9 

　　 

　　总结 

　　在大中型企业应用系统平台中，使用代码动态编译技术结合OO编程模型，可在系统不菪机条件下保证系统的可扩展性和伸缩性。如果你是一个Java程序员，稍加调整以上代码，还可以帮助调试小段的Java代码． 

3.获得数据,构造树状菜单：
  无论何种方法获得数据（JDBC，HIBERNATE。。。），
    我们要构造的树状菜单需要2个必须元素: 1.显示的名称(name) 2.连接到的目标位置(location)
  TreeBuilder.java
===========================================================================

/*
 * 创建日期 2005-8-6
 */
import ....

import net.sf.navigator.menu.MenuComponent;
import net.sf.navigator.menu.MenuRepository;

/**
 * @author yutengfei
 */
public class TreeBuilder {
 protected final static Log log = LogFactory.getLog("TreeBuilder"); 
 public TreeBuilder() { }

 // 以下代码生成树结构，并以"treerepository"名储存在session 中
   public static void initialTree(HttpServletRequest request, HttpServlet servlet){
  try {
   MenuRepository repository = new MenuRepository();
   ServletContext context = servlet.getServletContext()
   // Get the repository from the application scope - and copy the
   // DisplayerMappings from it.
   MenuRepository defaultRepository = (MenuRepository) context.getAttribute(MenuRepository.MENU_REPOSITORY_KEY);

   repository.setDisplayers(defaultRepository.getDisplayers()); 

//your code begin
List tree = getTreeDataFromDataBase(); //
// 产生从数据库中获得的数据列表(一个树节点是一个NoteBean 对象) ，获得数据的方法这里没有提供
for(Iterator it = tree.iterator();it.hasNext();)
{
     MenuComponent mc = new MenuComponent();   //建立一个menu对象(树节点)，然后设置他的属性
            NoteBean row =(NoteBean) it.next()
            String name = (String) row.getName();
            mc.setName(name);  //设置显示的节点名称
            String parent = (String) row.getParentname();
            System.out.println(name + ", parent is: " + parent);
            if (parent != null) {//存在“父”节点
                MenuComponent parentMenu = repository.getMenu(parent);
                if (parentMenu == null) {
                    System.out.println("parentMenu '" + parent + "' doesn't exist!");
                    // create a temporary parentMenu
                    parentMenu = new MenuComponent();
                    parentMenu.setName(parent);
                    repository.addMenu(parentMenu);
                }

                mc.setParent(parentMenu);   //设置“父”节点
            }
            String title = (String) row.getTitle();
            mc.setTitle(title);
            String location = (String) row.getLocation();
            mc.setLocation(location);
            repository.addMenu(mc);
        }   
request.getSession().setAttribute("treerepository", repository);   //整个树结构储存在session中
  } catch (Exception ex) {
   ex.printStackTrace();
  }

 }

}

4.前台jsp显示树菜单

<%try{%>
<%
if (session.getAttribute("treerepository") == null) {
TreeBuilder .initialTree(request, (HttpServlet) pageContext.getPage());
 }%>
<%List list = new ArrayList();
MenuRepository repository = (MenuRepository) session.getAttribute("treerepository");
list = repository.getTopMenus();
String name = "";%>