肖菁 , 软件工程师

2004 年 2 月 13 日

JMeter 是 Apache 组织的开放源代码项目，它是功能和性能测试的工具，100%的用java实现，最新的版本是1.9.1。本文中作者将向大家介绍如何使用 JMeter 进行测试。

JMeter是Apache组织的开放源代码项目，它是功能和性能测试的工具，100%的用java实现，最新的版本是1.9.1，大家可以到 http://jakarta.apache.org/jmeter/index.html下载源代码和查看相关文档。

JMeter作用领域

JMeter可以用于测试静态或者动态资源的性能（文件、Servlets、Perl脚本、java对象、数据库和查询、ftp服务器或者其他的资源）。JMeter用于模拟在服务器、网络或者其他对象上附加高负载以测试他们提供服务的受压能力，或者分析他们提供的服务在不同负载条件下的总性能情况。你可以用JMeter提供的图形化界面分析性能指标或者在高负载情况下测试服务器/脚本/对象的行为。

回页首

使用JMeter测试Web应用

接下来的章节里，作者将详细的演示如何使用JMeter来测试Web应用的完整过程。

2.1 测试环境

作者使用了Tomcat作为Web服务器进行测试，被测试的内容是一个jsp文件和一个servlet，jsp文件调用JavaBean、打印相关信息，servlet接受用户参数、调用javabean、输出相关信息。详细的内容请参考作者提供的JMeter.war的内容。

2.2 安装启动JMeter

大家可以到通过http://apache.linuxforum.net/dist/jakarta/jmeter/binaries/jakarta-jmeter-1.9.1.zip下载JMeter的release版本，然后将下载的.zip文件解压缩到C:/JMeter（后面的文章中将使用%JMeter%来引用这个目录）目录下。

现在，请使用%JMeter%/bin下面的jmeter.bat批处理文件来启动JMeter的可视化界面，下面的工作都将在这个可视化界面界面上进行操作。下面的图片是JMeter的可视化界面的屏幕截图。

2.3 建立测试计划（Test Plan）

测试计划描述了执行测试过程中JMeter的执行过程和步骤，一个完整的测试计划包括一个或者多个线程组(Thread Groups)、逻辑控制（Logic Controller）、实例产生控制器（Sample Generating Controllers）、侦听器(Listener)、定时器（Timer）、比较（Assertions）、配置元素（Config Elements）。打开JMeter时，它已经建立一个默认的测试计划,一个JMeter应用的实例只能建立或者打开一个测试计划。

现在我们开始填充一个测试计划的内容，这个测试计划向一个jsp文件和一个servlet发出请求，我们需要JMeter模拟五个请求者（也就是五个线程），每个请求者连续请求两次，下面的章节介绍了详细的操作步骤。

2.4 增加负载信息设置

这一步，我们将向测试计划中增加相关负载设置,是Jmeter知道我们需要模拟五个请求者，每个请求者在测试过程中连续请求两次。详细步骤如下：

1. 选中可视化界面中左边树的Test Plan节点，单击右键，选择Add'Thread Group，界面右边将会出现他的设置信息框。

2. Thread Group有三个和负载信息相关的参数：
Number of Threads： 设置发送请求的用户数目
Ramp-up period： 每个请求发生的总时间间隔，单位是秒。比如你的请求数目是5，而这个参数是10，那么每个请求之间的间隔就是10／5，也就是2秒
Loop Count： 请求发生的重复次数，如果选择后面的forever（默认），那么 请求将一直继续，如果不选择forever，而在输入框中输入数字，那么请求将重复 指定的次数，如果输入0，那么请求将执行一次。

根据我们演示例子的设计，我们应该将Number of Threads设置为5，Ramp-up period设置为0（也就是同时并发请求），不选中forever，在Loop Count后面的输入框中输入2，设置后的屏幕截图如下：

2.5 增加默认Http属性（可选）

实际的测试工作往往是针对同一个服务器上Web应用展开的,所以Jmeter提供了这样一种设置, 在默认Http属性设置需要被测试服务器的相关属性，以后的http请求设置中就可以忽略这些相同参数的设置,减少设置参数录入的时间。

我们这里将采用这种属性。你可以通过下面的步骤来设置默认http属性：

1. 选中可视化界面中左边树的Test Plan节点，单击右键，选择Add'config element'http request defaults，界面右边将会出现他的设置信息框。

2. 默认http属性的主要参数说明如下：
protocal：发送测试请求时使用的协议
server name or ip：被测试服务器的ip地址或者名字
path： 默认的起始位置。比如将path设置为／jmeter，那么所有的http请求的url中都将增加／jmeter路径。
port number： 服务器提供服务的端口号

我们的测试计划将针对本机的Web服务器上的Web应用进行测试，所以protocal应该是http，ip使用localhost，因为这个web应用发布的context路径是／jmeter，所以这里的path设置为／jmeter，因为使用Tomcat服务器，所以port number是8080。设置后的屏幕截图如下：

2.6 增加Http请求

现在我们需要增加http请求了，他也是我们测试的内容主体部分。你可以通过下面的步骤来增加性的http请求：

1. 选中可视化界面中左边树的Thread Group节点，单击右键，选择Add'sampler'http request，界面右边将会出现他的设置信息框。

2. 他的参数和2.5中介绍的http属性差不多，增加的属性中有发送http时方法的选择，你可以选择为get或者post。

我们现在增加两个http 请求，因为我们设置了默认的http属性，所以和默认http属性中相同的属性不再重复设置。设置后的屏幕截图如下：

2.7 增加Listener

增加listener是为了记录测试信息并且可以使用Jmeter提供的可视化界面查看测试结果，里面有好几种结果分析方式可供选择，你可以根据自己习惯的分析方式选择不同的结果显示方式，我们这里使用表格的形式来查看和分析测试结果。你可以通过下面的步骤来增加listener：

1. 选中可视化界面中左边树的Test Plan节点，单击右键，选择Add'listener'view result in table，界面右边将会出现他的设置信息和结果显示框。

2. 你可以设置界面上面的filename属性设置将测试结果保存到某个文件中界面下面将使用表格显示测试结果，表格的第一列sampleno显示请求执行的顺序和编号，url显示请求发送的目标，sample－ms列显示这个请求完成耗费的时间，最后的success列显示改请求是否成功执行。

界面的最下面你还可以看到一些统计信息，最关心的应该是Average吧，也就是相应的平均时间。

2.8 开始执行测试计划

现在你可以通过单击菜单栏run -> Start开始执行测试计划了。下面这两个图是作者第一次、第二次执行该测试计划的结果图:

大家可以看到第一次执行时的几个大时间值均来自于jsp request，这可以通过下面的理由进行解释：jsp执行前都需要被编译成.class文件。所以第二次的结果才是正常的结果。

回页首

总结

JMeter用于进行供能或者性能测试，通过使用JMeter提供的供能，我们可以可视化的制定测试计划：包括规定使用什么样的负载、测试什么内容、传入的参数，同时，他提供了好多种图形化的测试结果显示方式，使我们能够简单的开始测试工作和分析测试结果。

本文中，作者根据自己的使用经验，详细演示了如何使用JMeter来进行Web测试的全部过程，简单的介绍了JMeter提供测试结果的图形化显示界面中相关参数的含义。希望能够帮助大家学会使用JMeter的基本知识，同时，大家可以参考这个过程和JMeter的帮助文档来实现对java对象、数据库等的测试过程。

工具下载：

1. tomcat http://jakarta.apache.org/tomcat/index.html

2. JMeter http://jakarta.apache.org/jmeter/index.html

参考资料

JMeter 的用户指南 ： http://jakarta.apache.org/jmeter/usermanual/index.html

关于作者

		姓名: 肖菁， jing.xiao@chinacreator.com，作者目前是湖南省长沙铁道学院科创计算机系统集成有限公司软件中心软件工程师，IBM developerworks／BEA dev2dev撰稿人，主要研究J2EE编程技术、Web Service技术以及他们在websphere、weblogic、apache平台上的实现，拥有IBM 的 Developing With Websphere Studio证书。个人网站： vivianj.go.nease.net

<serverDefinition 
     name="JBOSS 4.0.0"
     ejbModules="true"
     webModules="true"
     earModules="true">
<property id="serverRootDirectory"
    label="Application Server Directory:"
    type="directory"
    default="C:/jboss4" />
<property id="serverAddress"
    label="Address:"
    type="string"
    default="127.0.0.1" />
<property id="serverPort"
    label="Port:"
    type="string"
    default="8080" />
<property id="serverConfig"
    label="Server Configuration (minimal/default/all):"
    type="string"
    default="default" />
<property id="classPathVariableName"
    label="Classpath Variable Name:"
    type="string"
    default="JBOSS400" />
<property id="classPath"
    label="Classpath Variable:"
    type="directory"
    default="C:/jboss4" />
<serverHome>${serverRootDirectory}</serverHome>
<webModulesDeployDirectory>${serverRootDirectory}/server/${serverConfig}/deploy</webModulesDeployDirectory>
<ejbModulesDeployDirectory>${serverRootDirectory}/server/${serverConfig}/deploy</ejbModulesDeployDirectory>
<earModulesDeployDirectory>${serverRootDirectory}/server/${serverConfig}/deploy</earModulesDeployDirectory>
<jndiInitialContextFactory>org.jnp.interfaces.NamingContextFactory</jndiInitialContextFactory>
<jndiProviderUrl>jnp://${serverAddress}:1099</jndiProviderUrl>
<startClass>org.jboss.Main</startClass>
<startWorkingDirectory>${serverRootDirectory}/bin</startWorkingDirectory>
<startVmParameters>-Djava.endorsed.dirs=${serverRootDirectory}/lib/endorsed</startVmParameters>
<startProgramArguments>-c ${serverConfig}</startProgramArguments>
<stopClass>org.jboss.Shutdown</stopClass>
<stopWorkingDirectory>${serverRootDirectory}/bin</stopWorkingDirectory>
<stopVmParameters>-cp {classPathVariableName}/bin/shutdown.jar -Djboss.boot.loader.name=shutdown.bat</stopVmParameters>
<stopProgramArguments>-S</stopProgramArguments>
<serverClassPath>
    <jar type="variable">JDK_TOOLS</jar>
    <jar type="variable">${classPathVariableName}/bin/run.jar</jar>
    <jar type="variable">${classPathVariableName}/bin/shutdown.jar</jar>
    <jar type="variable">${classPathVariableName}/lib/concurrent.jar</jar>
    <jar type="variable">${classPathVariableName}/lib/dom4j.jar</jar>
    <jar type="variable">${classPathVariableName}/lib/gnu-regexp.jar</jar>
    <jar type="variable">${classPathVariableName}/lib/jboss-jmx.jar</jar>
    <jar type="variable">${classPathVariableName}/lib/jboss-common.jar</jar>
    <jar type="variable">${classPathVariableName}/lib/jboss-system.jar</jar>
    <jar type="variable">${classPathVariableName}/lib/endorsed/xercesImpl.jar</jar>
    <jar type="variable">${classPathVariableName}/lib/endorsed/xml-apis.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/activation.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/avalon-framework.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/bcel.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/bsh-commands-1.3.0.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/bsh-core-1.3.0.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/bsh-deployer.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/castor-0.9.3.9-xml.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/cglib-full-2.0.1.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/hibernate2.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/hsqldb.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/hsqldb-plugin.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jacorb.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/javax.servlet.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/javax.servlet.jsp.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jaxr-client.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jboss.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jboss-common-jdbc-wrapper.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jboss-hibernate.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jboss-iiop.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jboss-j2ee.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jboss-jaxrpc.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jboss-jca.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jboss-jsr77.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jboss-management.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jboss-monitoring.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jboss-saaj.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jbossmq.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jbosssx.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jnpserver.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jpl-pattern.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jpl-util.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jboss-transaction.jar</jar>
</serverClassPath>
<clientClassPath>
    <jar type="variable">${classPathVariableName}/client/jboss-j2ee.jar</jar>
    <jar type="variable">${classPathVariableName}/client/jnp-client.jar</jar>
    <jar type="variable">${classPathVariableName}/client/jboss-client.jar</jar>
    <jar type="variable">${classPathVariableName}/client/jboss-common-client.jar</jar>
    <jar type="variable">${classPathVariableName}/client/jbosssx-client.jar</jar>
    <jar type="variable">${classPathVariableName}/client/log4j.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jnpserver.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/javax.servlet.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/javax.servlet.jsp.jar</jar>
</clientClassPath>
<projectClassPath>
    <jar type="variable">JDK_TOOLS</jar>
    <jar type="variable">${classPathVariableName}/bin/run.jar</jar>
    <jar type="variable">${classPathVariableName}/bin/shutdown.jar</jar>
    <jar type="variable">${classPathVariableName}/client/jboss-j2ee.jar</jar>
    <jar type="variable">${classPathVariableName}/lib/jboss-system.jar</jar>
    <jar type="variable">${classPathVariableName}/lib/concurrent.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jboss.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jnpserver.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jpl-pattern.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jpl-util.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/jboss-transaction.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/bcel.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/javax.servlet.jar</jar>
    <jar type="variable">${classPathVariableName}/server/${serverConfig}/lib/javax.servlet.jsp.jar</jar>
</projectClassPath>
</serverDefinition>

然后重新启动Eclipse,在Server Definitions 里面就可以选择JBoss4.0做web Server了

    public Company addCompany(Company company) throws HibernateException {
        getHibernateTemplate().save(company);
        return company;
    }

    public void removeCompany(Company company) throws HibernateException {
        getHibernateTemplate().delete(company);
    }

    public Company updateCompany(Company company) throws HibernateException {
        getHibernateTemplate().saveOrUpdate(company);          
        return company;
    }
}
<bean id="companyDAO" class="net.zdsoft.swh.dao.hibernate.CompanyDAOHibernate">
         <property name="sessionFactory"><ref local="sessionFactory"/></property> 
</bean>
其他基本不变

1 面临的问题

1.1 需要处理的特殊动态内容

在信息系统建设过程中我们通常会遇到这样的问题：

1. 基础数据的变更问题

信息系统中需要处理的基础数据的内容短时间内是不会发生变化的，但是在一个相对长一些的时间里，它却可能是动态增加或者减少的。

举个例子：电子商务中关于送货区域的定义，可能短时间内不会发生变化，但是随着电子商务企业业务的扩大，系统中需要处理的送货区域就可能增加。所以我们的系统中不得不在每次向客户展示送货区域信息的时候都和数据库（假设送货区域信息保存在数据库中，这也是通常采用的处理方法）进行交互。

2. 统计报表（不仅限于统计报表）的问题

一般来说，统计报表是一个周期性的工作，可能是半个月、一个月或者更长的时间才会需要更新一次，然而统计报表通常是图形显示或者是生成pdf、word、excel等格式的文件，这些图形内容、文件的生成通常需要消耗很多的系统资源，给系统运行造成很大的负担。

1.2 问题的共同点

通过比较分析，不难发现这两类问题有一些共同点：

1、被处理的内容短时间不变，所以短时间内可以作为静态内容进行处理

2、在一个不太长的时间内，被处理的内容可能或者必定产生变化，所以必须将他们作为动态内容进行处理

3、在合理的时间区段内可以忽略被处理内容变化后带来的影响

4、对这些内容的处理动作比较消耗系统性能，影响系统响应时间

1.3 解决方法

缓存技术可以帮助我们很好的解决这个问题：

1、缓存信息

当上述的基础数据或者统计报表第一次被访问时，被处理的内容被当作动态信息，基础数库从数据库中获得，统计报表也会被生成符合要求的图形、文件，然后这些信息都会被放入缓存信息中。

2、响应信息由缓存提供

当上述的基础数据或者统计报表继续被访问时，系统将会首先检查缓存信息中是否有对应的内容和我们设定的缓存规则，如果符合缓存信息存在而且符合缓存规则，给出的响应将来自于缓存信息，如果没有或者缓存信息已经不符合设定的要求，系统将重复上一步的动作。

很显然，上面的步骤2中，多数情况下，当用户请求到达时，被处理的内容将来自于缓存，所以大大的减少了与数据库的交互，或者不再需要为每个请求都生成一次报表图形或者文件，这部分工作的减少对于降低系统性能消耗、提高系统稳定性和并发处理能力是非常有益的。

2 OSCache简介

OSCache是OpenSymphony组织提供的一个J2EE架构中Web应用层的缓存技术实现组件，它的出现解决了我们面临的问题。 OSCache目前最新的稳定版本是2.0，本文中的例子都是基于这个版本的，如果大家运行例子的过程中发生问题，请首先确认是否采用了正确的软件版本。

2.1 主要特征

1. 兼容多种支持JSP的web服务器

已经通过兼容测试的web服务器包括OrionServer (1.4.0或者以上版本) 、Macromedia JRun (3.0或者以上版本) 、BEA Weblogic (7.x或者以上版本) 、IBM Websphere (5.0版本)、Silverstream (3.7.4版本)、Caucho Resin (1.2.3或者以上版本)、Tomcat (4.0或者以上版本) ，其他支持servlet2.3、jsp1.2的web服务器应该都是完全兼容OSCache的。

2. 可选的缓存区

你可以使用内存、硬盘空间、同时使用内存和硬盘或者提供自己的其他资源（需要自己提供适配器）作为缓存区。

• 使用内存作为缓存区将可以提供更好的性能
• 使用硬盘作为缓存区可以在服务器重起后迅速恢复缓存内容
• 同时使用内存和硬盘作为缓存区则可以减少对内存的占用

3. 灵活的缓存系统

OSCache支持对部分页面内容或者对页面级的响应内容进行缓存，编程者可以根据不同的需求、不同的环境选择不同的缓存级别。

4. 容错

在一般的web应用中，如果某个页面需要和数据库打交道，而当客户请求到达时，web应用和数据库之间无法进行交互，那么将返回给用户"系统出错"或者类似的提示信息，如果使用了OSCache的话，你可以使用缓存提供给用户，给自己赢得维护系统或者采取其他补救的时间。

其它特性还包括对集群的支持、缓存主动刷新等特性，大家可以参考OpenSymphony网站上的其他资源获取更多的信息。

3 OSCache组件的安装

OSCache是一个基于web应用的组件，他的安装工作主要是对web应用进行配置，大概的步骤如下：

1. 下载、解压缩OSCache

请到OSCache的主页http://www.opensymphony.com/oscache/download.html下载Oscache的最新版本，作者下载的是OSCache的最新稳定版本2.0。

将下载后的。Zip文件解压缩到c:\oscache（后面的章节中将使用%OSCache_Home%来表示这个目录）目录下

2. 新建立一个web应用

3. 将主要组件%OSCache_Home%\oscache.jar放入WEB-INF\lib目录

4. commons-logging.jar、commons-collections.jar的处理

• OSCache组件用Jakarta Commons Logging来处理日志信息，所以需要commons-logging.jar的支持，请将%OSCache_Home%\lib\core\commons-logging.jar放入classpath（通常意味着将这个文件放入WEB-INF\lib目录）
• 如果使用JDK1.3,请将%OSCache_Home%\lib\core\commons-collections.jar放入classpath，如果使用JDK1.4或者以上版本，则不需要了

5. 将oscache.properties、oscache.tld放入WEB-INF\class目录

• %OSCache_Home%\oscache.properties包含了对OSCache运行特征值的设置信息
• %OSCache_Home%\oscache.tld包含了OSCache提供的标签库的定义内容

6. 修改web.xml文件

在web.xml文件中增加下面的内容，增加对OSCache提供的taglib的支持：

<taglib>
<taglib-uri>oscache</taglib-uri>
<taglib-location>/WEB-INF/classes/ oscache.tld</taglib-location>
</taglib> 

4 开始使用OSCache中的缓存组件

OSCache中按照缓存范围的不同分为两种不同的方式：一种是缓存JSP页面中部分或者全部内容，一种是基于整个页面文件的缓存。

4.1 JSP部分内容缓存

4.1.1 Cache-OSCache提供的缓存标签

这是OSCache提供的标签库中最重要的一个标签，包括在标签中的内容将应用缓存机制进行处理，处理的方式将取决于编程者对cache标签属性的设置。

第一次请求到达时，标签中的内容被处理并且缓存起来，当下一个请求到达时，缓存系统会检查这部分内容的缓存是否已经失效，主要是以下几项：

• 1. 缓存时间超过了cache标签设置的time或者duration属性规定的超时时间
• 2. cron属性规定的时间比缓存信息的开始时间更晚
• 3. 标签中缓存的内容在缓存后又被重新刷新过
• 4. 其他缓存超期设定

如果符合上面四项中的任何一项，被缓存的内容视为已经失效，这时被缓存的内容将被重新处理并且返回处理过后的信息，如果被缓存的内容没有失效，那么返回给用户的将是缓存中的信息。

cache标签的属性说明:

key - 标识缓存内容的关键词。在指定的作用范围内必须是唯一的。默认的key是被访问页面的URI和后面的请求字符串。

你可以在同一个页面中使用很多cache标签而不指定他的key属性，这种情况下系统使用该页面的URI和后面的请求字符串，另外再自动给这些key增加一个索引值来区分这些缓存内容。但是不推荐采用这样的方式。

scope - 缓存发生作用的范围，可以是application或者session

time - 缓存内容的时间段，单位是秒，默认是3600秒，也就是一个小时，如果设定一个负值，那么这部分被缓存的内容将永远不过期。

duration - 指定缓存内容失效的时间，是相对time的另一个选择，可以使用简单日期格式或者符合USO-8601的日期格式。如：duration='PT5M' duration='5s'等

refresh - false 或者true。

如果refresh属性设置为true，不管其他的属性是否符合条件，这部分被缓存的内容都将被更新，这给编程者一种选择，决定什么时候必须刷新。

mode - 如果编程者不希望被缓存的内容增加到给用户的响应中，可以设置mode属性为"silent"

其它可用的属性还包括：cron 、groups、language、refreshpolicyclass、refreshpolicyparam。

上面的这些属性可以单独使用，也可以根据需要组合使用，下面的例子将讲解这些常用属性的使用方式。

4.1.2 Cache标签实例分析:

1. 最简单的cache标签用法

使用默认的关键字来标识cache内容，超时时间是默认的3600秒

<cache:cache>
<%
//自己的JSP代码内容
%>
</cache:cache> 

2. 用自己指定的字符串标识缓存内容，并且设定作用范围为session。

<cache:cache key="foobar" scope="session">
<%
//自己的JSP代码内容
%>
</cache:cache> 

3.动态设定key值，使用自己指定的time属性设定缓存内容的超时时间，使用动态refresh值决定是否强制内容刷新。

因为OSCache使用key值来标识缓存内容，使用相同的key值将会被认为使用相同的的缓存内容，所以使用动态的key值可以自由的根据不同的角色、不同的要求决定使用不同的缓存内容。

<cache:cache key="<%= product.getId() %>" time="1800" refresh="<%= needRefresh %>">
<%
//自己的JSP代码内容
%>
</cache:cache> 

4. 设置time属性为负数使缓存内容永不过期

<cache:cache time="-1">
<%
//自己的JSP代码内容
%>

5. 使用duration属性设置超期时间

<cache:cache  duration='PT5M'>
<%
//自己的JSP代码内容
%>

6. 使用mode属性使被缓存的内容不加入给客户的响应中

<cache:cache  mode='silent'>
<%
//自己的JSP代码内容
%>

4.2 用CashFilter实现页面级缓存

在OSCache组件中提供了一个CacheFilter用于实现页面级的缓存，主要用于对web应用中的某些动态页面进行缓存，尤其是那些需要生成pdf格式文件/报表、图片文件等的页面，不仅减少了数据库的交互、减少数据库服务器的压力，而且对于减少web服务器的性能消耗有很显著的效果。

这种功能的实现是通过在web.xml中进行配置来决定缓存哪一个或者一组页面，而且还可以设置缓存的相关属性，这种基于配置文件的实现方式对于J2EE来说应该是一种标准的实现方式了。

[注] 只有客户访问时返回http头信息中代码为200（也就是访问已经成功）的页面信息才能够被缓存

1. 缓存单个文件

修改web.xml，增加如下内容，确定对/testContent.jsp页面进行缓存。

<filter>
      <filter-name>CacheFilter</filter-name>
<filter-class>com.opensymphony.oscache.web.filter.CacheFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>CacheFilter</filter-name>
<!-对/testContent.jsp页面内容进行缓存-->
      <url-pattern>/testContent.jsp</url-pattern>
</filter-mapping>

2. 缓存URL pattern

修改web.xml，增加如下内容，确定对*.jsp页面进行缓存。

<filter>
      <filter-name>CacheFilter</filter-name>
<filter-class>com.opensymphony.oscache.web.filter.CacheFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>CacheFilter</filter-name>
<!-对所有jsp页面内容进行缓存-->
      <url-pattern>*.jsp</url-pattern>
</filter-mapping>

3. 自己设定缓存属性

在页面级缓存的情况下，可以通过设置CacheFilter的初始属性来决定缓存的一些特性：time属性设置缓存的时间段，默认为3600秒，可以根据自己的需要只有的设置，而scope属性设置，默认为application，可选项包括application、session

<filter>
      <filter-name>CacheFilter</filter-name>
<filter-class>com.opensymphony.oscache.web.filter.CacheFilter</filter-class>
	<init-param>
         <param-name>time</param-name>
         <param-value>600</param-value>
      </init-param>
      <init-param>
         <param-name>scope</param-name>
         <param-value>session</param-value>
      </init-param>
</filter>
<filter-mapping>
<filter-name>CacheFilter</filter-name>
<!-对所有jsp页面内容进行缓存-->
<url-pattern>*.jsp</url-pattern>
</filter-mapping>

5 性能测试结果

5.1 测试环境

系统平台：windows 2000 高级服务器/ P3 800 /512M内存

web服务器：websphere 5.0

数据库服务器：mysql 4.0.18-nt

性能测试用工具：apache Jmeter

5.2 测试计划

这次性能测试对比方为使用缓存和不使用缓存两种，他们的访问代码都是一样的：通过数据源从本地mysql数据库中获取person表的所有记录，然后显示在页面上。

测试中将模仿10个用户，每个用户发起5次请求，然后统计所有访问花费的时间。

5.3 测试结果

使用缓存后的测试结果 不使用缓存时的测试结果

所有请求花费的总时间(毫秒) 20569 22870

性能测试的详细结果请大家查看下载内容中的《不使用cache时的系统性能测试结果.txt》和《使用cache后系统性能测试结果.txt》

6 总结

在J2EE系统中，我们经常需要处理一些特殊的动态内容，这些内容在一个时间段内的变更非常有限，但是又不得不将他们确定为动态内容进行输出，而且非常消耗数据库系统资源或者web服务器的资源，这时我们就可以采用Cache----一种用于提高系统响应速度、改善系统运行性能的技术----来优化我们的系统。尤其是在Web应用中，这种处理可以很显著的改善系统运行性能。

本文中作者给大家介绍一个实现J2EE框架中Web应用层缓存功能的开放源代码项目----OSCache。它提供了在J2EE系统中实现缓存需要的丰富的功能。通过应用OSCache，我们不但可以实现通常的Cache功能、自由的设定cache的相关特性比如缓存时间段/缓存内容等，提升系统性能，而且还能有效的改善系统的稳定性。除此之外，OSCache组件还提供了更多的特性比如集群、容错、灵活的缓存区选择等。

作者根据自己的使用经验给大家提供了一些简单的例子，他们部分演示了如何使用OSCache组件提供的丰富特性，OSCache提供的特性远不止这些，需要大家在今后的时间里深入的研究，同时也希望大家通过E-mail和作者贡献研究成果。

参考资料

OpenSymphony网站中关于OSCache的部分 http://www.opensymphony.com/oscache/

OSCache下载地址 http://www.opensymphony.com/oscache/download.html

The following document illustrates several basic JCS configurations. As you'll see, using JCS can be as simple as creating a single memory cache for you application. However, with a few configuration changes, you can quickly enable some distributed caching features that can scale your application even further.

# DEFAULT CACHE REGION   

jcs.default=
jcs.default.cacheattributes=
    org.apache.jcs.engine.CompositeCacheAttributes
jcs.default.cacheattributes.MaxObjects=1000
jcs.default.cacheattributes.MemoryCacheName=
    org.apache.jcs.engine.memory.lru.LRUMemoryCache
        
If you want to add memory shrinking then you can add these lines: 

jcs.default.cacheattributes.cacheattributes.UseMemoryShrinker=true
jcs.default.cacheattributes.cacheattributes.MaxMemoryIdleTimeSeconds=3600
jcs.default.cacheattributes.cacheattributes.ShrinkerIntervalSeconds=60
        

jcs.auxiliary.DC=
    org.apache.jcs.auxiliary.disk.indexed.IndexedDiskCacheFactory
jcs.auxiliary.DC.attributes=
    org.apache.jcs.auxiliary.disk.indexed.IndexedDiskCacheAttributes
jcs.auxiliary.DC.attributes.DiskPath=g:/dev/jakarta-turbine-stratum/raf
        

jcs.default=DC
        

jcs.system.groupIdCache=DC
jcs.system.groupIdCache.cacheattributes=
    org.apache.jcs.engine.CompositeCacheAttributes
jcs.system.groupIdCache.cacheattributes.MaxObjects=10000
jcs.system.groupIdCache.cacheattributes.MemoryCacheName=
    org.apache.jcs.engine.memory.lru.LRUMemoryCache
        

jcs.region.testCache1=DC
jcs.region.testCache1.cacheattributes=
    org.apache.jcs.engine.CompositeCacheAttributes
jcs.region.testCache1.cacheattributes.MaxObjects=1000
jcs.region.testCache1.cacheattributes.MemoryCacheName=
    org.apache.jcs.engine.memory.lru.LRUMemoryCache
jcs.region.testCache1.cacheattributes.UseMemoryShrinker=true
jcs.region.testCache1.cacheattributes.MaxMemoryIdleTimeSeconds=3600
jcs.region.testCache1.cacheattributes.ShrinkerIntervalSeconds=60
        

jcs.auxiliary.LTCP=
    org.apache.jcs.auxiliary.lateral.LateralCacheFactory
jcs.auxiliary.LTCP.attributes=
    org.apache.jcs.auxiliary.lateral.LateralCacheAttributes
jcs.auxiliary.LTCP.attributes.TransmissionTypeName=TCP
jcs.auxiliary.LTCP.attributes.TcpServers=localhost:1111
jcs.auxiliary.LTCP.attributes.TcpListenerPort=1110
jcs.auxiliary.LTCP.attributes.PutOnlyMode=false
        

jcs.region.testCache1=DC,LTCP

# DEFAULT CACHE REGION   

jcs.default=DC,LTCP
jcs.default.cacheattributes=
    org.apache.jcs.engine.CompositeCacheAttributes
jcs.default.cacheattributes.MaxObjects=1000
jcs.default.cacheattributes.MemoryCacheName=
    org.apache.jcs.engine.memory.lru.LRUMemoryCache

# System CACHE REGION   
jcs.system.groupIdCache=DC,LTCP
jcs.system.groupIdCache.cacheattributes=
    org.apache.jcs.engine.CompositeCacheAttributes
jcs.system.groupIdCache.cacheattributes.MaxObjects=10000
jcs.system.groupIdCache.cacheattributes.MemoryCacheName=
    org.apache.jcs.engine.memory.lru.LRUMemoryCache

# PRE-DEFINED CACHE REGIONS   

jcs.region.testCache1=DC,LTCP
jcs.region.testCache1.cacheattributes=
    org.apache.jcs.engine.CompositeCacheAttributes
jcs.region.testCache1.cacheattributes.MaxObjects=1000
jcs.region.testCache1.cacheattributes.MemoryCacheName=
    org.apache.jcs.engine.memory.lru.LRUMemoryCache
jcs.region.testCache1.cacheattributes.UseMemoryShrinker=true
jcs.region.testCache1.cacheattributes.MaxMemoryIdleTimeSeconds=3600
jcs.region.testCache1.cacheattributes.ShrinkerIntervalSeconds=60

# AVAILABLE AUXILIARY CACHES   
jcs.auxiliary.DC=
    org.apache.jcs.auxiliary.disk.indexed.IndexedDiskCacheFactory
jcs.auxiliary.DC.attributes=
    org.apache.jcs.auxiliary.disk.indexed.IndexedDiskCacheAttributes
jcs.auxiliary.DC.attributes.DiskPath=g:/dev/jakarta-turbine-stratum/raf
jcs.auxiliary.DC.attributes.maxKeySize=100000

jcs.auxiliary.LTCP=
    org.apache.jcs.auxiliary.lateral.LateralCacheFactory
jcs.auxiliary.LTCP.attributes=
    org.apache.jcs.auxiliary.lateral.LateralCacheAttributes
jcs.auxiliary.LTCP.attributes.TransmissionTypeName=TCP
jcs.auxiliary.LTCP.attributes.TcpServers=localhost:1111
jcs.auxiliary.LTCP.attributes.TcpListenerPort=1110
jcs.auxiliary.LTCP.attributes.PutOnlyMode=false

Spring对JDBC进行了非常优雅的封装，通过一系列的模板方法，只需简单的几行代码就可实现数据库的访问。通过Spring的JdbcTemplate访问数据库从而实现用户验证。Access数据库，建立表Account，包含两个字段：

    username：VARCHAR(20)，主键；
    password：VARCHAR(20)。

然后输入一些测试数据，注册到系统DSN，名字为Blog。接下来我们在Tomcat中配置一个名为“jdbc/blog”的DataSource如下：

如果你使用其他数据库，只需要保证表的逻辑结构和JDNI名“jdbc/blog”。在AccountManager中，使用JdbcTemplate访问数据库来验证用户：

    Account getAccount(String username, String password) throws Exception {
        // validate the password:
        InitialContext ctx = new InitialContext();
        DataSource dataSource = (DataSource)ctx.lookup("java:comp/env/jdbc/blog");
        JdbcTemplate jt = new JdbcTemplate(dataSource);
        String pass = (String) jt.queryForObject(
            "select password from Account where username=?",
            new Object[] {username}, String.class);
        if(password.equals(pass))
        {
            Account account = new Account();
            account.setUsername(username);
            account.setPassword(password);
            return account;
        }
        throw new Exception("authorization failed.");
    }

编译运行，输入hello.c?username=xxx&password=xxx来测试用户登录，如果匹配数据库中的记录，会显示出用户名，否则可以看到authorization failed异常。要更友好的显示登陆失败，可以在Controller中导向一个login_failed.jsp并给出登陆失败的原因。

下面来看这个AccountManager，很显然在验证逻辑中写入了JNDI查找DataSource的代码，这将导致比较“生硬”的编码。“依赖注入”此刻显示出了威力：让容器注入DataSource：

public class AccountManager implements java.io.Serializable {
    private DataSource dataSource;
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    Account getAccount(String username, String password) throws Exception {
        JdbcTemplate jt = new JdbcTemplate(dataSource);
        
    }
}

OK，现在这个AccountManager变得优雅多了，现在如何配置DataSource的注入呢？Spring提供了一个DataSourceUtils类，通过静态方法getDataSourceFromJndi来获得容器中配置的DataSource。我们添加以下配置：

    <bean id="dataSource"
          class="org.springframework.jdbc.datasource.DataSourceUtils"
          factory-method="getDataSourceFromJndi">
        <constructor-arg><value>jdbc/blogvalue>constructor-arg>
    bean>
    <bean id="accountManager" class="AccountManager">
        <property name="dataSource">
            <ref bean="dataSource" />
        property>
    bean>

You may have heard the buzz this summer around the Spring Framework. In this article, I’ll try to explain what Spring sets out to achieve, and how I believe it can help you to develop J2EE applications.
在这个夏天，你可以听到许许多多围绕着Spring Framework的声音. 这篇文章,我将说明Spring 的作用和如何帮助你开发J2EE应用.

Yet another framework?
哦,又一个框架?

You may be thinking \\\\\\\"not another framework.\\\\\\\" Why should you bother to read this article, or download the Spring Framework, when there are already many open source (and proprietary) J2EE frameworks?
你也许正在想\\\\\\\"不，又一个框架\\\\\\\". 在众多的开源J2EE框架横行的时代,为什么你还会去读这篇文章或者下载Spring Framework?

I believe that Spring is unique, for several reasons:
我相信Sping 的独特，有下列原因:

* It addresses areas that many other popular frameworks don’t. Spring focuses around providing a way to manage your business objects.
* Spring 的地址区域? 是其他框架所不具备的. Spring 只围绕一点，那就是管理业务对象.

* Spring is both comprehensive and modular. Spring has a layered architecture, meaning that you can choose to use just about any part of it in isolation, yet its architecture is internally consistent. So you get maximum value from your learning curve. You might choose to use Spring only to simplify use of JDBC, for example, or you might choose to use Spring to manage all your business objects.
* Spring 非常的全面和标准. Spring是一个分层构架,意思是你可以选择只用它的一部分,而不影响其他.它的构架体系是内部相容的.所以，你将会在你的学习曲线中获得最大价值.
例如，你可以选择只用Spring 的JDBC 单一应用 或者 用Spring 管理你的业务对象.

* It’s designed from the ground up to help you write code that’s easy to test. Spring is an ideal framework for test driven projects.
* Spring的设计可以帮助你从表层到简单地写出测试代码.Spring是一个理想的测试驱动项目的框架.

Spring is not necessarily one more framework dependency for your project. Spring is potentially a one-stop shop, addressing most infrastructure concerns of typical applications. It also goes places other frameworks don’t.
在你的项目中,Spring 不必依靠更多的框架. Spring 相当于一个一站式商店,从事更多的涉及典型应用的基础框架.它也不必替换任何框架.

Although it has been an open source project only since February 2003, Spring has a long heritage. The open source project started from infrastructure code published with my book, Expert One-on-One J2EE Design and Development, in late 2002. Expert One-on-One J2EE also laid out the basic architectural thinking behind Spring. However, the architectural concepts go back to early 2000, and reflect my experience in developing infrastructure for a series of successful commercial projects.
虽然Spring 是一个起始于2003年2月的一个开源项目,但是它有很长时间的传统. 这个开源项目开始于(2002年出版)
发布的基础编码, 这本书同样也展示了在Spring之后的基础构架. 然而，这个构架的观念在2000年就诞生了, 而且源自我长时间从事一连串的商业项目的成功开发经验.

Since January 2003, Spring has been hosted on SourceForge. There are now ten developers, of whom six are highly active.
自从2003年一月份,Spring 在SourceForge上被建立起来. 现在有10名开发人员，6名高手.

Architectural benefits of Spring
Spring 构架优势

Before we get down to specifics, let’s look at some of the benefits Spring can bring to a project:
在我们详细说明之前，让我们先看一下Spring 可以给一个项目带来的好处:

* Spring can effectively organize your middle tier objects, whether or not you choose to use EJB. Spring takes care of plumbing that would be left up to you if you use only Struts or other frameworks geared to particular J2EE APIs.
*Spring 可以有效的组织你的中间层对象,无论你是否选择了EJB. 如果你只用了Struts 或者其他框架来连接特定的J2EE APIs,Spring 更关心的是委托到你的管道?

* Spring can eliminate the proliferation of Singletons seen on many projects. In my experience, this is a major problem, reducing testability and object orientation.
* Spring 可以消除一个单独项目看起来像多个项目的扩散. 以我的经验, 主要的问题是, 减弱了测试能力和对象方位.

* Spring can eliminate the need to use a variety of custom properties file formats, by handling configuration in a consistent way throughout applications and projects. Ever wondered what magic property keys or system properties a particular class looks for, and had to read the Javadoc or even source code? With Spring you simply look at the class’s JavaBean properties. The use of Inversion of Control (discussed below) helps achieve this simplification.
* Spring 可以消除规定多样的定制属性文件的需要, 用一致的配置操作贯穿这个应用和项目.多样的属性健或者系统属性寻找使你不得不去读Javadoc 或者甚至是源代码?然而, Sping可以使你非常简单地看到这些class 的 JavaBean的属性. 控制的倒置用法(下面介绍)可以帮助你完成简化.

* Spring can facilitate good programming practice by reducing the cost of programming to interfaces, rather than classes, almost to zero.
* Spring 可以使良好的编程习惯更容易培养,利用接口代替classes 减弱编程成本，降至最小.

* Spring is designed so that applications built with it depend on as few of its APIs as possible. Most business objects in Spring applications have no dependency on Spring.
* Spring 的设计使依靠很少的APIs 建立应用成为可能. 在Spring 应用中的许多业务对象根本不要依靠Spring.

* Applications built using Spring are very easy to unit test.
* 利用Sping 建立的应用使单元测试变得非常简单.

* Spring can make the use of EJB an implementation choice, rather than the determinant of application architecture. You can choose to implement business interfaces as POJOs or local EJBs without affecting calling code.
* Spring 是使用EJB成为一个选择,优于成为决定性的应用构架 .你可以选择作为POJOs 或者 local EJBs 扩展业务借口,而不影响调用代码.

* Spring helps you solve many problems without using EJB. Spring can provide an alternative to EJB that’s appropriate for many web applications. For example, Spring can use AOP to deliver declarative transaction management without using an EJB container; even without a JTA implementation, if you only need to work with a single database.
* Spring 可以帮助你解决没有EJB的许多的问题.Spring 提供了为多个web 应用选择性适当的JEB.例如, Spring 可以用 AOP 去传递声明事务管理，在不用EJB容器的情况下.
如果你只需要工作在单个的数据库上面, 甚至不用JTA 的支持.

* Spring provides a consistent framework for data access, whether using JDBC or an O/R mapping product such as Hibernate.
* Spring 提供了坚固的数据存储框架, 无论用JDBC 或者 像Hibernate 一样的 O/R mapping 产品.

Spring really can enable you to implement the simplest possible solution to your problems. And that’s worth a lot.
Spring 确实是你程序扩展简单的方案.并且具有相当大的价值.

What does Spring do?
Spring 做什么呢？

Spring provides a lot of functionality, so I’ll quickly review each major area in turn.
Spring 具有很多的功能, 我们可以快速浏览每个主要的范围.

Mission statement
任务描述

Firstly, let’s be clear on Spring’s scope. Although Spring covers a lot of ground, we do have clear vision as to what it should and shouldn’t address.
首先, 让我们跳出Spring. 虽然Spring 覆盖了很多的层面, 我们必须清楚了解他做什么不做什么.

Spring’s main aim is to make J2EE easier to use and promote good programming practice.
Spring 的主要目标是使J2EE更简单易用, 促进良好的编程习惯.

Spring does not reinvent the wheel. Thus you’ll find no logging packages in Spring, no connection pools, no distributed transaction coordinator. All these things are provided by open source projects (such as Commons Logging, which we use for all our log output, or Commons DBCP), or by your application server. For the same reason, we don’t provide an O/R mapping layer. There are good solutions to this problem such as Hibernate and JDO.
Spring 遵守不重新发明轮子的原则. 因此,你在Spring 找不到 日志管理, 连接池，分布事务调节的程序包. 所有这些功能可以由开源项目(如,Commons Logging ,Common DBCP)提供,
或者是你的应用服务器. 同样的原因, 我们不提供O/R mapping 层, 因为已经有很好地解决方案, 如,Hibernate 和 JDO.

Spring does aim to make existing technologies easier to use. For example, although we are not in the business of low-level transaction coordination, we do provide an abstraction layer over JTA or any other transaction strategy.
Spring 主要目标是让已经存在的技术更简单易用. 例如,虽然我们没有低级的事务调节业务,但是我们提供了在JTA 或者其他事物级别处理之上的提取层.

Spring doesn’t directly compete with other open source projects unless we feel we can provide something new. For example, like many developers, we have never been happy with Struts, and feel that there’s room for improvement in MVC web frameworks. In some areas, such as its lightweight IoC container and AOP framework, Spring does have direct competition, but these are areas in which no solution has become popular. (Spring was a pioneer in these areas.)
Spring
Spring 没有直接和其他的开源项目进行竞争除非我们认为我们提供了新的功能. 例如, 像很多开发者一样,我们一直对strus感觉不好,是因为它把我们框在了它提供了MVC框架之中.
在某些地方,像轻巧的IoC 容器和AOP 框架,Spring 将和他们有着直接的竞争, 但是在这些区域还没有形成普遍成型的方案(Spring 是这个区域的先驱)

Spring also benefits from internal consistency. All the developers are singing from the same hymn sheet, the fundamental ideas remaining faithful to those of Expert One-on-One J2EE Design and Development. And we’ve been able to use some central concepts, such as Inversion of Control, across multiple areas.
Spring 同样获益于区域一致性. 就像所有的开发者唱着同样的赞美诗一样,大家都支持Expert One-on-One J2EE Design and Development . 并且我们都用一些主要的概念,
倒置控制，穿越多个区域.

Spring is portable between application servers. Of course ensuring portability is always a challenge, but we avoid anything platform-specific or non-standard, and support users on WebLogic, Tomcat, Resin, JBoss, WebSphere and other application servers.

Spring 可以轻巧的用于应用服务器. 当然, 保证轻巧的能力一直是一个挑战,但是, 我们避免任何平台详细或者不标准, 并且支持于Weblogic ,Tomcat ,Resin, JBoss, WebSphere 和其他的应用服务器.

Inversion of control container
控制容器的倒置

The core of Spring’s design is the org.springframework.beans package, designed for working with JavaBeans. This package typically isn’t used directly by users, but serves as the underpinning of much of the other functionality.
Spring的设计核心是 org.springframework.beans 包, 设计协调JavaBeans的工作. 这个包代表可以直接被用户使用, 但是可以作为其他很多功能的基础服务.

The next higher layer of abstraction is the \\\\\\\"Bean Factory.\\\\\\\" A Spring bean factory is a generic factory that enables objects to be retrieved by name, and which can manage relationships between objects.
下一个较高的层面是\\\\\\\"Bean Factory\\\\\\\", 一个Spring bean factory 是一个通常可以管理连接多个对象且可以根据name重新获得对象的factory。

Bean factories support two modes of objects:
Bean factories 支持两种对象模式:

* \\\\\\\"Singleton\\\\\\\": in this case, there’s one shared instance of the object with a particular name, which will be retrieved on lookup. This is the default, and most often used, mode. It’s ideal for stateless service objects.
* 单粒模式: 在这里,有一个共享具有特使名称的对象实例,它将可以被找回. 这是一个缺省模式, 而且是应用最为广泛德模式.这种模式是理想的无状态服务对象.

* \\\\\\\"Prototype\\\\\\\": in this case, each retrieval will result in the creation of an independent object. For example, this could be used to allow each user to have their own object.
* \\\\\\\"原型模式\\\\\\\": 在这里,每一个获得导致一个独立的对象创立, 例如,这可以用于允许用户使用他们自己的对象.

As org.springframework.beans.factory.BeanFactory is a simple interface, it can be implemented for a range of underlying storage methods. You could easily implement your own, although few users find they need to. The most commonly used BeanFactory definitions are:
因为 org.springframwork.beans.factory.BeanFactory是一个简单的接口, 它可以被潜在的存储方法行列执行?. 虽然,很少用户需要,但是这可以使你可以简单的拓展你自己 . 一些通常用于BeanFactory 定义是:

* The XmlBeanFactory. This parses a simple, intuitive XML structure defining the classes and properties of named objects. We provide a DTD to make authoring easier.
* XmlBeanFactory. 这是一个简单的解析器.根据XML 结构定义classes和命名对象的属性. 我们提供了一个DTD来使命名更加得简单.

* ListableBeanFactoryImpl: This provides the ability to parse bean definitions in properties files, and create BeanFactories programmatically.
* ListableBeanFactoryImpl: 这提供了在属性文件里面解析bean定义的能力,和编写创建BeanFactories.

Each bean definition can be a POJO (defined by class name and JavaBean initialisation properties), or a FactoryBean. The FactoryBean interface adds a level of indirection. Typically this is used to create proxied objects using AOP or other approaches: for example, proxies that add declarative transaction management. (This is similar to EJB interception in concept, but works out much simpler in practice.)
每个bean的定义可以是一个POJO(定义class和JavaBean初始化属性), 或者一个FactoryBean. FactoryBean 接口添加了一个间接层.代表了这将用于创建用于AOP或者其他途径的
代理对象:例如, 加入声明事务管理的代理.(这是一个类似于EJB侦听的概念,但是在实践中实现十分的简单)

BeanFactories can optionally participate in a hierarchy, \\\\\\\"inheriting\\\\\\\" definitions from their ancestors. This enables the sharing of common configuration across a whole application, while individual resources such as controller servlets also have their own independent set of objects.
BeanFactories 可以在一个层面上进行随意的添加,根据他们的原先的定义. 这能够通过基础配置的共享穿过整个应用,当个别资源如controller servlets也设置自己为单个的对象.

This motivation for the use of JavaBeans is described in Chapter 4 of Expert One-on-One J2EE Design and Development, which is available on the ServerSide as a free PDF (http://www.theserverside.com/res ... dJohnsonInterview).
这是为了声明JavaBeans的用法,在第四章,用法在ServerSide的免费PDF(http://www.theserverside.com/res ... dJohnsonInterview).

Through its BeanFactory concept, Spring is an Inversion of Control container. (I don’t much like the term container, as it conjures up visions of heavyweight containers such as EJB containers. A Spring BeanFactory is a container that can be created in a single line of code, and requires no special deployment steps.)
通过它的BeanFactory 概念,Spring 作为一个控制容器的倒置.(我非常不喜欢期限容器,因为它依靠重量级的容器，如EJB容器).Spring BeanFactory是一个可以在一行代码中创建的容器,而且不需要特殊的部署)

The concept behind Inversion of Control is often expressed in the Hollywood Principle: \\\\\\\"Don’t call me, I’ll call you.\\\\\\\" IoC moves the responsibility for making things happen into the framework, and away from application code. Where configuration is concerned this means that while in traditional container architectures such as EJB, a component might call the container to say \\\\\\\"where’s object X, which I need to do my work\\\\\\\", with IoC the container figures out that the component needs an X object, and provides it to it at runtime. The container does this figuring out based on method signatures (such as JavaBean properties) and, possibly, configuration data such as XML.
控制倒置(IoC)这个感念是经常在好莱坞原则上使用:\\\\\\\"不要打电话给我,我打给你\\\\\\\".IoC的责任是记录进入framework 发生的事件,并且远离应用代码. 涉及到配置的地方，也就是说,
像EJB一样传统的容器构架,一个组建可以调用容器,并且说\\\\\\\"哪儿有可以让我工作的Object X\\\\\\\"，对于IoC容器判断出这个组建需要 X 对象,并且在运行的时候提供它执行.容器在方法
签名(就像JavaBean属性)上作出这个基础的判断,并且,尽可能的,配置数据,如XML一样.

IoC has several important benefits. For example:
控制倒置的几个优势,例如:

* Because components don’t need to look up collaborators at runtime, they’re much simpler to write and maintain. In Spring’s version of IoC, components express their dependency on other components via exposing JavaBean setter methods. The EJB equivalent would be a JNDI lookup, which requires the developer to write code.
* 因为组件不需要在运行时间寻找合作,所以他们可以很容易的编写和维护. 在Spring的IoC版本里面, 组件表述了他们通过JavaBean的setter方法来被其他组件支持. 这等于EJB中
通过JNDI lookup,开发人员写的请求代码.

* For the same reasons, application code is much easier to test. JavaBean properties are simple, core Java and easy to test: just write a self-contained JUnit test method that creates the object and sets the relevant properties.
* 为了同样的原因,应用代码变得非常容易测试.JavaBean属性简单,主要的程序测试也变得容易: 刚刚写了一个包含自己的创建对象和设置关联属性的JUnit测试方法.

* A good IoC implementation preserves strong typing. If you need to use a generic factory to look up collaborators, you have to cast the results to the desired type. This isn’t a major problem, but it is inelegant. With IoC you express strongly typed dependencies in your code and the framework is responsible for type casts. This means that type mismatches will be raised as errors when the framework configures the application; you don’t have to worry about class cast exceptions in your code.
* 一个良好的IoC执行保持健壮的输入. 如果你需要用一般的factory寻找合作者,你不得不造型结果成你需要的类型.这不是一个主要的程序,但是这是不好的.对于IoC 你需要在你的
代码 和框架响应里为输入造型传递健壮的信任类型. 这意味着在配置应用的时候输入机制将可能存在错误;但是不必担心造型异常.

* Most business objects don’t depend on IoC container APIs. This makes it easy to use legacy code, and easy to use objects either inside or outside the IoC container. For example, Spring users often configure the Jakarta Commons DBCP DataSource as a Spring bean: there’s no need to write any custom code to do this. We say that an IoC container isn’t invasive: using it won’t invade your code with dependency on its APIs. Any JavaBean can become a component in a Spring bean factory.
* 许多业务对象不依靠IoC. 这使简化为使用继承代码,并且简单用于IoC容器的内部和外部.例如,Spring 用户通常配置Commons DBCP 数据源作为Spring bean:这不需要写任何
代码就可以完成. 我们说IoC容器不会影响:利用APIs用它将不会影响你的代码. 任何JavaBean可以成为Spring bean factory 的一个组件.

This last point deserves emphasis. IoC is unlike traditional container architectures, such as EJB, in this minimization of dependency of application code on container. This means that your business objects can potentially be run in different IoC frameworks - or outside any framework - without code changes.
最后要强调的是,IoC 不同于传统的容器构架,如:EJB, 应用最小限度的依靠容器. 这意味着你的业务对象可以潜在的运行在不同的IoC 框架上-或者没有框架-而不需要改动任何代码.

In my experience and that of Spring users, it’s hard to overemphasize the benefits that IoC brings to application code.
最为Spring用户的经验,这里强调了IoC给你的代码带来的好处.

IoC is not a new concept, although it’s only just made prime time in the J2EE community. There are alternative IoC containers: notably, Apache Avalon, PicoContainer and HiveMind. Avalon has never become particularly popular, although it is powerful and has a long history. Avalon is fairly heavyweight and complex, and seems more invasive than newer IoC solutions. PicoContainer is lightweight and emphasizes the expression of dependencies through constructors rather than JavaBean properties. Unlike Spring, its design allows the definition of only one object of each type (possibly a limitation resulting from its rejection of any metadata outside Java code). For a comparison between Spring and PicoContainer and other IoC frameworks, see the article \\\\\\\"The Spring Framework - A Lightweight Container\\\\\\\" on the Spring website at http://www.springframework.org/docs/lightweight_container.html. This page includes a link to the PicoContainer website.
IoC不是一个新的概念,但是它在J2EE团体里面刚刚成为精华. 有那些IoC 容器可选呢: notably, Apache Avalon, PicoContainer 和 HiveMind.Avalon 不会成为通用,虽然它很强大
而且有很长的历史.Avalon 相当的重量级和复杂,并且看起来比新的IoC解决方案更内聚. PicoContainer是一个轻量级而且强调通过构造器传递优于JavaBean 属性. 不像Spring,
它涉及允许定义一个对象多种输入(可能局限于外部的java code收集结果), 作为比较http://www.springframework.org/docs/lightweight_container.html. 这个业面包含了
PicoContainer站点.

Spring BeanFactories are very lightweight. Users have successfully used them inside applets, as well as standalone Swing applications. (They also work fine within an EJB container.) There are no special deployment steps and no detectable startup time. This ability to instantiate a container almost instantly in any tier of an application can be very valuable.
Spring BeanFactories 是非常轻型的.用户可以成功地在applets里面使用,作为独立的Swing应用.(它们也在EJB容器工作的很好) 没有制定的部署步骤和省去了重起的时间.这个能力
表明一个容器在应用的任何层面差不多立即可以发挥重大的价值.

The Spring BeanFactory concept is used throughout Spring, and is a key reason that Spring is so internally consistent. Spring is also unique among IoC containers in that it uses IoC as a basic concept throughout a full-featured framework.
Spring BeanFactory 概念应用于Spring, 而且是Spring中心协调的关键原因. Spring 也是在IoC容器中唯一利用基础概念完成全部特点的框架.

Most importantly for application developers, one or more BeanFactories provide a well-defined layer of business objects. This is analogous to, but much simpler than, a layer of local session beans. Unlike EJBs, the objects in this layer can be interrelated, and their relationships managed by the owning factory. Having a well-defined layer of business objects is very important to a successful architecture.
许多应用开发者关心的,一个或者多个BeanFactories可以提供了一个定义好的业务对象层. 这类似,且非常简单,一个本地session beans的一个层. 不同于EJBs, 在这个层里面的对象
是相关的,并且他们的关系被自己的factory 管理.提供一个定义完好的业务对象层是成功构架非常重要的一点.

A Spring ApplicationContext is a subinterface of BeanFactory, which provides support for:
Spring ApplicationContext 是BeanFactory的子接口,为下列提供支持:

* Message lookup, supporting internationalization
* 消息寻找,支持国际化

* An eventing mechanism, allowing application objects to publish and optionally register to be notified of events
* 事件机制,允许应用对象发布和操作注册成为事件

* Portable file and resource access
* 轻巧的文件和资源存储

In the following example, we use a BasicDataSource from the Jakarta Commons DBCP project. This class (like many other existing classes) can easily be used in a Spring bean factory, as it offers JavaBean-style configuration. The close method that needs to be called on shutdown can be registered via Spring\\\\\\\'s \\\\\\\"destroy-method\\\\\\\" attribute, to avoid the need for BasicDataSource to implement any Spring interface.
在下面的例子里，我们用一个DBCP项目中的BasicDataSource 。这个class(和其他存在的class一样)可以简单的在Spring bean factory使用，并且提供了JavaBean配置。这种需要在shutdown的时候被调用的精密方法可以通过Spring的\\\\\\\"destroy-method\\\\\\\"属性被注册，而且提供了需要为BasicDataSource执行的许多Spring 接口。

代码:

destroy-method=\\\\\\\"close\\\\\\\">

com.mysql.jdbc.Driver

jdbc:mysql://localhost:3306/mydb

root

All the properties of BasicDataSource we e interested in are Strings, so we specify their values with the element. Spring uses the standard JavaBean PropertyEditor mechanism to convert String representations to other types if necessary.
我们感兴趣的是Strings ,BasicDataSource的所有属性,所以我们用标签指定了他们的值。如果必要的话,Spring 用标准的JavaBean属性编辑机制来转换String 表示其他的类型.
Now we define the DAO, which has a bean reference to the DataSource. Relationships between beans are specified using the element:
现在，我们定义这个用一个bean 表示为DataSource的 DAO. 用标签来表示beans之间的关系:

代码:
class=\\\\\\\"example.ExampleDataAccessObject\\\\\\\">

The business object has a reference to the DAO, and an int property (exampleParam):
这个业务对象涉及到DAO，并且有一个int属性(exampleParam)：

代码:
class=\\\\\\\"example.ExampleBusinessObject\\\\\\\">

10

Relationships between objects are normally set explicitly in configuration, as in this example. We consider this to be a Good Thing. However, Spring also provides what we call \\\\\\\"autowire\\\\\\\" support, a la PicoContainer, where it figures out the dependencies between beans. The limitation with this - as with PicoContainer - is that if there are multiple beans of a particular type it impossible to work out which instance a dependency of that type should be resolved to. On the positive side, unsatisfied dependencies can be caught when the factory is initialized. (Spring also offers an optional dependency check for explicit configuration, which can achieve this goal.)
这两个对象的关系可以在配置中非常清楚,有如例子一样。我们认为这样做很好.无论如何,Spring也提供了我们叫做\\\\\\\"autowire\\\\\\\"的支持, 一个la PicoContainer,它可以判断这两个beans只见的依赖关系.PicoContainer的局限性是如果有多个的Beans有特殊的类型,这种类型不可能完全解决实例的类型可以判断之间的依赖关系.值得一提的是，不能班组的依赖关系可以在factory初始化的时候被捕获.(Spring 也提供一种可以完成这个目标的的外部配置)
We could use the autowire feature as follows in the above example, if we didn\\\\\\\'t want to code these relationships explicitly:
在以上的例子里，我们可以用autowire 用来理解，如果我们不想编码这些外部关系：
代码:
class=\\\\\\\"example.ExampleBusinessObject\\\\\\\"
autowire=\\\\\\\"byType\\\\\\\">

10

With this usage, Spring will work out that the dataSource property of exampleBusinessObject should be set to the implementation of DataSource it finds in the present BeanFactory. It‘s an error if there is none, or more than one, bean of the required type in the present BeanFactory. We still need to set the exampleParam property, as it\\\\\\\'s not a reference.
对于这个用法,Spring 将可以理解为exampleBusinessObject的dataSource 属性在父BeanFactory里找到DataSource,将其设置执行.如果在beanFactory没找到或者多于一个请求类型的bean产生一个error。我们还需要设置exampleParam属性，因为它没有参数.

Autowire support and dependency checking is presently in CVS and will be available in Spring 1.0 M2 (due October 20, 2003). All other features discussed in this article are in the current 1.0 M1 release.
Autowire支持和依赖关系检查是刚刚加入CVS和将发布在Spring 1.0 M2(10/20,2003).所有其他的特点讨论当前1.0 M1发布版本.

Externalizing relationships from Java code has an enormous benefit over hard coding it, as it possible to change the XML file without changing a line of Java code. For example, we could simply change the myDataSource bean definition to refer to a different bean class to use an alternative connection pool, or a test data source. We could use Spring JNDI location FactoryBean to get a datasource from an application server in a single alternative XML stanza.
具体的说,这样描述关系比硬编码有很大的好处，因为只改变XML文件而不用改变java 代码.例如，我们可以简单的改变myDataSource bean 定义提供不同的bean class 用选择性的连接池，或者一个测试数据源. 我们用Spring JNDI本地FactoryBean从application server两个单独的选择性节点得到一个数据源.
Now let\\\\\\\'s look at the Java code for the example business object. Note that there are no Spring dependencies in the code listing below. Unlike an EJB container, a Spring BeanFactory is not invasive: you don\\\\\\\'s normally need to code awareness of it into application objects.
现在让我们来看一段业务对象的java 代码的例子.注意下面没有Spring的依赖。不像EJB容器，Spring BeanFactory不用嵌入：在应用对象里面你通常不需要编码.
代码:
public class ExampleBusinessObject implements MyBusinessObject {

private ExampleDataAccessObject dao;
private int exampleParam;

public void setDataAccessObject(ExampleDataAccessObject dao) {
this.dao = dao;
}

public void setExampleParam(int exampleParam) {
this.exampleParam = exampleParam;
}

public void myBusinessMethod() {
// do stuff using dao
}
}

Note the property setters, which correspond to the XML references in the bean definition document. These are invoked by Spring before the object is used.
注意属性设置,在bean定义文档里面对应XML定义.这将在对象使用之前被Spring调用.

Such application beans do not need to depend on Spring: They don\\\\\\\'t need to implement any Spring interfaces or extend Spring classes: they just need to observe JavaBeans naming convention. Reusing one outside of a Spring application context is easy, for example in a test environment. Just instantiate it with its default constructor, and set its properties manually, via setDataSource() and setExampleParam() calls. So long as you have a no-args constructor, you are free to define other constructors taking multiple properties if you want to support programmatic construction in a single line of code.
这种应用bean不需要依靠Spring.他们不需要执行任何Spring接口或者继承Spring classes:他们只需要遵守JavaBeans名称转换.在Spring 应用内容之外重用非常简单，例如一个测试环境.不过示例定义了一个缺省的构造器，并且通过setDataSource()和setExampleParam()调用配置了属性。只要你有一个没有参数的构造器，如果你想在单行代码支持程序的构件器，你可以自由定义其他的构建器设置其他的属性.

Note that the JavaBean properties are not declared on the business interface callers will work with. They are an implementation detail. We could \\\\\\\"plug in\\\\\\\" different implementing classes that have different bean properties without affecting connected objects or calling code.
注意，在业务借口没有声明的JavaBean属性一起工作. 他们是一个详细地执行.我们可以插入不同的bean属性执行classes，而不硬性连接对象或者调用代码.

Of course Spring XML bean factories have many more capabilities than described here, but this should give you a feel for the basic approach. As well as simple properties, and properties for which you have a JavaBeans PropertyEditor, Spring can automatically handle lists, maps and java.util.Properties.
当然，Spring XML bean factories 有更多的能力没有在这里描述，但是，这将给你在基础步骤上一个基本的认识.还有简单属性，和用于javabean属性编辑器的属性，Spring可以自动操作lists,maps和java.util.Properties.
Bean factories and application contexts are usually associated with a scope defined by the J2EE server, such as:
Bean factories 和application contexts 通常通过被J2EE server定义一个范围,例如:

*The Servlet context. In the Spring MVC framework, an application context is defined for each web application containing common objects. Spring provides the ability to instantiate such a context through a listener or servlet without dependence on the Spring MVC framework, so it can also be used in Struts, WebWork or other web frameworks.
Servlet context. 在spring MVC 框架里, 一个应用context 可以为每一个饱含基础对象的web 应用 定义.Spring提供了如示例一样一个context通过监听器或者servlet不需要依靠Spring MVC 框架的能力，所以它也可以用于Struts,WebWork 或者其他的web框架.

*A Servlet: Each controller servlet in the Spring MVC framework has its own application context, derived from the root (application-wide) application context. It also easy to accomplish this with Struts or another MVC framework.
A Servlet:在Spring MVC 框架里每一个servlet控制器由它特有的应用context,根源于应用context.这同样可以简单应用于Struts或者其他的MVC框架.

*EJB: Spring provides convenience superclasses for EJB that simplify EJB authoring and provide a BeanFactory loaded from an XML document in the EJB Jar file.
EJB:Spring 提供为EJB创建者方便的超类和在EJB jar 文件里从XML 文档提供的BeanFactory载入.

These hooks provided by the J2EE specification generally avoid the need to use a Singleton to bootstrap a bean factory.
这样符合J2EE规范通常避免使用Singleton 到 bean factory.
However, it\\\\\\\'s trivial to instantiate a BeanFactory programmatically if we wish. For example, we could create the bean factory and get a reference to the business object defined above in the following three lines of code:
不管怎样，我们将详细示例一个BeanFactory,下面3行代码，我们创建一个bean factory 并且作为定义业务对象的参考。

代码:
InputStream is = getClass().getResourceAsStream(\\\\\\\"myFile.xml\\\\\\\");
XmlBeanFactory bf = new XmlBeanFactory(is);
MyBusinessObject mbo = (MyBusinessObject) bf.getBean(\\\\\\\"exampleBusinessObject\\\\\\\");

This code will work outside an application server: it doesn\\\\\\\'s even depend on J2EE, as the Spring IoC container is pure Java.
这段代码工作在一个应用server之外：甚至不依靠J2EE，因为Spring IoC容器是纯java的.

JDBC abstraction and data access exception hierarchy
JDBC 抽象和数据存储异常层次

Data access is another area in which Spring shines.
数据存储是Spring 的另一个闪光点.

JDBC offers fairly good abstraction from the underlying database, but is a painful API to use. Some of the problems include:
JDBC 提供还算不错的数据库抽象，但是需要用痛苦的API. 这些问题包含:

The need for verbose error handling to ensure that ResultSets, Statements and (most importantly) Connections are closed after use. This means that correct use of JDBC can quickly result in a lot of code. It’s also a common source of errors. Connection leaks can quickly bring applications down under load.
麻烦的是需要在用完ResultSets,Statements 和(最重要的)Connections必须关闭. 这意味着正确的使用JDBC得到结果需要一大堆的代码. 同样是一个错误的根源。Connection泄漏可以马上让应用down掉.

The relatively uninformative SQLException. JDBC does not offer an exception hierarchy, but throws SQLException in response to all errors. Finding out what actually went wrong - for example, was the problem a deadlock or invalid SQL? - involves examining the SQLState and error code. The meaning of these values varies between databases.
没有相关的SQLException. JDBC 不能提供异常层次,而是在响应里抛出SQLException.找不出实际是错误 – 例如,程序死锁或者错误的SQL? - 包括可检查的SQLState 和错误码.这可能在数据库之间出错.

Spring addresses these problems in two ways:
Spring 解决这些问题有两个方法:

By providing APIs that move tedious and error-prone exception handling out of application code into the framework. The framework takes care of all exception handling; application code can concentrate on issuing the appropriate SQL and extracting results.
通过提供APIs 使 不易移植和错误倾向的异常排除在应用代码之外而到框架层面.这个框架可以照顾到所有的异常操作；应用代码可以集中发布的适当的SQL和提取结果.

By providing a meaningful exception hierarchy for your application code to work with in place of SQLException. When Spring first obtains a connection from a DataSource it examines the metadata to ascertain the database. It uses this knowledge to map SQLExceptions to the correct exception in its own hierarchy descended from org.springframework.dao.DataAccessException. Thus your code can work with meaningful exceptions, and need not worry about proprietary SQLState or error codes. Spring’s data access exceptions are not JDBC-specific, so your DAOs are not necessarily tied to JDBC because of the exceptions they may throw.
为你的应用代码通过提供一组对SQLException起作用的异常级别.当Spring 第一次在DataSource获得一个连接,它将核对数据库的元数据. 在自己的层面利用绘制SQLException 到当前的异常org.springframework.dao.DataAccessException.因而，你的代码可以和有意义的exceptions一起运行,并且, 不用担心任何SQLState 或错误码.Spring 的数据存储异常不是JDBC规范,所以你的DAOs不必依赖JDBC,因为他们可以抛出异常.

Spring provides two levels of JDBC API. The first, in the org.springframework.jdbc.core package, uses callbacks to move control - and hence error handling and connection acquisition and release - from application code inside the framework. This is a different type of Inversion of Control, but equally valuable to that used for configuration management.
Spring 提供了2个JDBC API的级别. 第一个,在org.springframework.jdbc.core package里面,用callbacks来移动控制- 因此错误操作和连接获得释放 – 从framework里的应用代码.这是一种倒置控制的一种不同类型, 然而,这和用配置管理一样有价值.

Spring uses a similar callback approach to address several other APIs that involve special steps to acquire and cleanup resources, such as JDO (acquiring and relinquishing a PersistenceManager), transaction management (using JTA) and JNDI. Spring classes that perform such callbacks are called templates.
Spring 用一个类似的回调方法通过几个其他的APIs ,这包括特特殊的步骤获得和清除资源,例如,JDO(获得和释放一个PersistenceManager),事务管理(用JTA)和JNDI.Spring classes提供了几个callbacks 调用模式.

For example, the Spring JdbcTemplate object can be used to perform a SQL query and save the results in a list as follows:
例如,Spring JdbcTemplate对象可以用于提供一个SQL query 和保存list结果:

代码:

JdbcTemplate template = new JdbcTemplate(dataSource);
final List names = new LinkedList();
template.query(\\\\\\\"SELECT USER.NAME FROM USER\\\\\\\",
new RowCallbackHandler() {
public void processRow(ResultSet rs) throws SQLException {
names.add(rs.getString(1));
}
});

Note that application code within the callback is free to throw SQLException: Spring will catch any exceptions and rethrow them in its own hierarchy. The application developer can choose which exceptions, if any, to catch and handle.
注意这段没有callback的代码可以自由的抛出SQLException:Spring 将catch 任何一场和抛出他们自己的异常.应用开发者可以选择是否将异常捕获或者处理掉.

The JdbcTemplate provides many methods to support different scenarios including prepared statements and batch updates. The Spring JDBC abstraction has a very low performance overhead beyond standard JDBC, even in applications cases involving huge result sets.
JdbcTemplate 提供了许多的方法支持不同的情况, 包括准备statement 和批量更新. Spring JDBC 抽象的性能远远超过甚至在应用里包含大量的result sets 标准的JDBC.

The higher level JDBC abstraction is in the org.springframework.jdbc.object package. This is built on the core JDBC callback functionality, but provides an API in which an RDBMS operation - whether query, update or stored procedure - is modelled as a Java object. This API was partly inspired by the JDO query API, which I found intuitive and highly usable.
这个较高级的JDBC抽象在org.springframework.jdbc.object 包. 这建立在核心功能JDBC callback上,然而,提供了一组RDBMS操作的APIs – 无论query, update 或者 存储程序 – 模拟一个java object. 这组API的部分灵感来自JDO query API, 它非常的直观和有用.

A query object to return User objects might look like this:
一个query 对象返回User对象,大概这样:

代码:

class UserQuery extends MappingSqlQuery {

public UserQuery(DataSource datasource) {
super(datasource, \\\\\\\"SELECT * FROM PUB_USER_ADDRESS WHERE USER_ID = ?\\\\\\\");
declareParameter(new SqlParameter(Types.NUMERIC));
compile();
}

// Map a result set row to a Java object
protected Object mapRow(ResultSet rs, int rownum) throws SQLException {
User user = new User();
user.setId(rs.getLong(\\\\\\\"USER_ID\\\\\\\"));
user.setForename(rs.getString(\\\\\\\"FORENAME\\\\\\\"));
return user;
}

public User findUser(long id) {
// Use superclass convenience method to provide strong typing
return (User) findObject(id);
}
}

This class can be used as follows(这个class按照下列使用):

代码:

User user = userQuery.findUser(25);

Such objects are often inner classes inside DAOs. They are threadsafe, unless the subclass does something unusual.
这种对象经常在DAOs用到内部类. 他们线程安全的,除非子类做了不寻常的事情.

Another important class in the org.springframework.jdbc.object package is the StoredProcedure class. Spring enables a stored procedure to be proxied by a Java class with a single business method. If you like, you can define an interface that the stored procedure implements, meaning that you can free your application code from depending on the use of a stored procedure at all.
在org.springframework.jdbc.object里面另一些重要的class是StoredProcedure class. Spring 使一个存储程序能够被一个具有单个业务方法的Java class代理. 如果你喜欢, 你可以定义一个存储程序执行的接口, 意思是你可以依靠一个存储程序的是用来释放你的应用代码.

The Spring data access exception hierarchy is based on unchecked (runtime) exceptions. Having worked with Spring on several projects I’m more and more convinced that this was the right decision.
Spring 数据存储异常在运行时不检查的.对于Spring几个对象的所有工作, 我认为重中之重是确认这是对的结果.

Data access exceptions not usually recoverable. For example, if we can’t connect to the database, a particular business object is unlikely to be able to work around the problem. One potential exception is optimistic locking violations, but not all applications use optimistic locking. It’s usually bad to be forced to write code to catch fatal exceptions that can’t be sensibly handled. Letting them propagate to top-level handlers like the servlet or EJB container is usually more appropriate. All Spring data access exceptions are subclasses of DataAccessException, so if we do choose to catch all Spring data access exceptions, we can easily do so.
数据存储异常通常不能重新覆盖. 例如, 如果我们没有连接数据库, 一个特殊的业务对象不大可能正常的工作. 潜在的异常是一个乐观锁定违例, 但是不是所有的应用都用乐观锁定. 这通常分层强制编写代码catch 致命的且不能明显被操作的异常. 像servlet 或者 EJB容器一样让他们传到最上层比较的合适. 所有Spring 数据存储异常都是DataAccessException的子类,所以如果我们选择catch所有的数据存储异常,我们可以简单的完成.

Note that if we do want to recover from an unchecked data access exception, we can still do so. We can write code to handle only the recoverable condition. For example, if we consider that only an optimistic locking violation is recoverable, we can write code in a Spring DAO as follows:
注意如果我们想从一个未检查的数据访问异常恢复,我们同样可以. 我们只有编写代码来操作可恢复的条件.例如, 如果我们考虑只有一个乐观的锁定是不能恢复的,我们可以在Spring DAO里编写下列代码:

代码:

try {
// do work
}
catch (OptimisticLockingFailureException ex) {
// I\\\\\\\'m interested in this
}

If Spring data access exceptions were checked, we’d need to write the following code. Note that we could choose to write this anyway:
如果Spring 数据访问异常被检查, 我们需要写下列代码. 注意我们可以选择这么写:

代码:

try {
// do work
}
catch (OptimisticLockingFailureException ex) {
// I\\\\\\\'m interested in this
}
catch (DataAccessException ex) {
// Fatal; just rethrow it
}

One potential objection to the first example - that the compiler can’t enforce handling the potentially recoverable exception - applies also to the second. Because we’re forced to catch the base exception (DataAccessException), the compiler won’t enforce a check for a subclass (OptimisticLockingFailureException). So the compiler would force us to write code to handle an unrecoverable problem, but provide no help in forcing us to deal with the recoverable problem.
在第一个例子里有一个潜在的缺陷 – 编译器不能强制操作潜在的不能恢复的异常 – 第二个也是一样. 因为我们强制catch 基本异常(DataAccessException), 编译器不能强制为子类(OptimisticLockingFailureException)做检查.所以编译器强制我们写代码来操作不能恢复的程序,但并不提供任何帮助.

Spring’s use of unchecked data access exceptions is consistent with that of many - probably most - successful persistence frameworks. (Indeed, it was partly inspired by JDO.) JDBC is one of the few data access APIs to use checked exceptions. TopLink and JDO, for example, use unchecked exceptions exclusively. Gavin King now believes that Hibernate should also have opted for unchecked exceptions.
Spring 非检查访问异常的用法对于大部分情况都是一致的 – 成功的持久框架.(确实,这部分来自JDO的灵感.) JDBC 是一个在少数用于check exception数据访问的APIs.TopLink 和JDO,例如,不特定检查异常. Gavin King 现在艰辛Hibernate 也不检查unchecked exception.

Spring JDBC can help you in several ways:
Spring JDBC 可以帮助一下列几点:

You’ll never need to write a finally block again to use JDBC
根本不必像用JDBC一样写finally.

You’ll need to write much less code overall
不必写大量大代码

You’ll never need to dig through your RDBMS documentation to work out what obscure error code it returns for a bad column name. Your application won’t be dependent on RDBMS-specific error handling code.
不必钻研关系数据库文档就可以解决为一个错误列名而返回的隐含错误码.你的应用还不用依靠关系数据库制定的错误操作码.

Whatever persistence technology use, you’ll find it easy to implement the DAO pattern without business logic depending on any particular data access API.
不管怎样持久技术的使用,可以使你方便的实现DAO模式,而业务逻辑不依靠任何特殊的数据访问API.

In practice we find that all this amounts to substantial productivity gains and fewer bugs. I used to loathe writing JDBC code; now I find that I can focus on the SQL I want to execute, rather than the incidentals of JDBC resource management.
在实践中我们可以找到完全的实质生产力数量和更少的bugs. 我们憎恨JDBC代码;现在我可以把精力放在我想执行的SQL上,总比附加JDBC的资源管理要好得多.

Spring’s JDBC abstraction can be used standalone if desired - you are not forced to use the other parts of Spring.
Spring的JDBC 抽象可以单独使用 – 一个可以只用Spring的其他部分.

而在Spring里，已经很好的集成了Quartz，简单到像配cron一样，在xml文件里面配一下时间就可以自动执行，不需要写一行代码。

     <bean id="methodInvokingJobDetail" 
          class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
         <property name="targetObject"><ref bean="financeDAO"/></property>
         <property name="targetMethod"><value>confirmOrder</value></property>
    </bean>
    <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
          <property name="jobDetail"><ref bean="methodInvokingJobDetail"/></property>
          <property name="cronExpression"><value>0 0 6,12,20 * * ?</value></property>
    </bean>
    <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
            <property name="triggers"><list><ref local="cronTrigger"/></list></property>
    </bean>

上面这段配置文件规定了在早上6点和晚上8点执行financeDAO对象的confirmOrder()方法

附：cronExpression配置说明
字段
 
允许值
 
允许的特殊字符
秒
  
0-59
  
, - * /
分
  
0-59
  
, - * /
小时
  
0-23
  
, - * /
日期
  
1-31
  
, - * ? / L W C
月份
  
1-12 或者 JAN-DEC
  
, - * /
星期
  
1-7 或者 SUN-SAT
  
, - * ? / L C #
年（可选）
  
留空, 1970-2099
  
, - * /

  首先确定将要Proxy的目标，在Spring中默认采用JDK中的dynamic proxy，它只能够实现接口的代理，如果想对类进行代理的话，需要采用CGLIB的proxy。显然，选择“编程到接口”是更明智的做法，下面是将要代理的接口：

  public interface FooInterface {
    public void printFoo();
    public void dummyFoo();
  }
 
  以及其一个简单的实现：
 
  public class FooImpl implements FooInterface {
    public void printFoo() {
      System.out.println("In FooImpl.printFoo");
    }
    public void dummyFoo() {
      System.out.println("In FooImpl.dummyFoo");
    }
  }
 
  接下来创建一个Advice，在Spring中支持Around,Before,After returning和Throws四种Advice，这里就以简单的Before Advice举例：
 
  public class PrintBeforeAdvice implements MethodBeforeAdvice {
    public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
      System.out.println("In PrintBeforeAdvice");
    }
  }
 
  有了自己的business interface和advice，剩下的就是如何去装配它们了，首先利用ProxyFactory以编程方式实现，如下：
 
  public class AopTestMain {
    public static void main(String[] args) {
      FooImpl fooImpl = new FooImpl();
      PrintBeforeAdvice myAdvice = new PrintBeforeAdvice();
     
      ProxyFactory factory = new ProxyFactory(fooImpl);
      factory.addBeforeAdvice(myAdvice);
      FooInterface myInterface = (FooInterface)factory.getProxy();

      myInterface.printFoo();
      myInterface.dummyFoo();
    }
  }
 
  现在执行程序，神奇的结果就出现了：
 
  In PrintBeforeAdvice
  In FooImpl.printFoo
  In PrintBeforeAdvice
  In FooImpl.dummyFoo
 
  虽然这样能体会到Spring中AOP的用法，但这决不是值得推荐的方法，既然使用了Spring，在ApplicationContext中装配所需要 的bean才是最佳策略，实现上面的功能只需要写个简单的applicationContext就可以了，如下：
 
  <?xml version="1.0" encoding="UTF-8"?>
  <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
    "http://www.springframework.org/dtd/spring-beans.dtd">

  <beans>
    <description>The aop application context</description>
    <bean id="fooTarget" class="FooImpl"/>
    <bean id="myAdvice" class="PrintBeforeAdvice"/>
    <bean id="foo" class="org.springframework.aop.framework.ProxyFactoryBean">
     <property name="proxyInterfaces">
       <value>FooInterface</value>
     </property>
     <property name="target">
       <ref local="fooTarget"/>
     </property>
     <property name="interceptorNames">
       <list>
         <value>myAdvice</value>
       </list>
     </property>
    </bean>
  </beans>

  当然，main中的代码也要进行相应的修改：
    
  public static void main(String[] args) {
    ClassPathXmlApplicationContext context = new 
             ClassPathXmlApplicationContext("applicationContext.xml");
    FooInterface foo = (FooInterface)context.getBean("foo");
    foo.printFoo();
    foo.dummyFoo();
  }
 
  现在运行一下，结果将和上面的运行结果完全一样，这样是不是更优雅？当需要更改实现时，只需要修改配置文件就可以了，程序中的代码不需任何改动。
 
  但是，这时候会发现被proxy的object中的所有方法调用时都将运行advice中的before，这显然不能满足绝大多数情况下的需要，此时，只 需借用Advisor就可以了，当然要在Advisor中利用pattern设置好哪些方法需要advice，更改applicationContext 如下：
 
  <?xml version="1.0" encoding="UTF-8"?>
  <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
    "http://www.springframework.org/dtd/spring-beans.dtd">

  <beans>
    <description>The springeva application context</description>
    <bean id="fooTarget" class="FooImpl"/>
    <bean id="printBeforeAdvice" class="PrintBeforeAdvice"/>
    <bean id="myAdvisor"
          class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
      <property name="advice">
        <ref local="printBeforeAdvice"/>
      </property>
      <property name="pattern">
        <value>.*print.*</value>
      </property>
    </bean>
    <bean id="foo" class="org.springframework.aop.framework.ProxyFactoryBean">
      <property name="proxyInterfaces">
        <value>FooInterface</value>
      </property>
      <property name="target">
        <ref local="fooTarget"/>
      </property>
      <property name="interceptorNames">
        <list>
          <value>myAdvisor</value>
        </list>
      </property>
    </bean>
  </beans>

  主程序不需进行任何修改，运行结果已经变样了：

  In PrintBeforeAdvice
  In FooImpl.printFoo
  In FooImpl.dummyFoo
 
  至此，应该已经理解了Spring中AOP的使用方法，当然Spring中AOP最重要的应用是Transaction Manager，举个这方面的applicationContext例子看看：
 
  <?xml version="1.0" encoding="UTF-8"?>
  <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "spring-beans.dtd">

  <beans>
    <bean id="propertyConfigurer"   
         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
      <property name="location">
        <value>/WEB-INF/jdbc.properties</value>
      </property>
    </bean>
    <bean id="dataSource"
          class="org.springframework.jdbc.datasource.DriverManagerDataSource">
      <property name="driverClassName">
        <value>${jdbc.driverClassName}</value>
      </property>
      <property name="url">
        <value>${jdbc.url}</value>
      </property>
      <property name="username">
        <value>${jdbc.username}</value>
      </property>
      <property name="password">
        <value>${jdbc.password}</value>
      </property>
    </bean>
    <bean id="sessionFactory"
          class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
      <property name="dataSource">
        <ref local="dataSource"/>
      </property>
      <property name="mappingResources">
        <value>smartmenu.hbm.xml</value>
      </property>
      <property name="hibernateProperties">
        <props>
          <prop key="hibernate.dialect">${hibernate.dialect}</prop>
        </props>
      </property>
    </bean>
 
    <bean id="transactionManager"       
          class="org.springframework.orm.hibernate.HibernateTransactionManager">
      <property name="sessionFactory">
        <ref local="sessionFactory"/>
      </property>
    </bean>
    <bean id="smartmenuTarget" class="SmartMenuHibernate">
      <property name="sessionFactory">
        <ref local="sessionFactory"/>
      </property>
    </bean>
    <bean id="smartMenu"
        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
      <property name="transactionManager">
        <ref local="transactionManager"/>
      </property>
      <property name="target">
        <ref local="smartmenuTarget"/>
      </property>
      <property name="transactionAttributes">
        <props>
          <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
          <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
        </props>
      </property>
    </bean>
  </beans>
 
  嗯，要想彻底理解Spring的AOP，最好还是多看看源码，开源就是好啊！

(2) AppFuse集成了目前最流行的几个开源轻量级框架或者工具Ant,XDoclet,Spring,Hibernate(iBATIS),JUnit,Cactus,StrutsTestCase,Canoo's WebTest,Struts Menu,Display Tag Library,OSCache,JSTL,Struts 。
你可以通过AppFuse源代码来学习spring。
AppFuse网站：http://raibledesigns.com/wiki/Wiki.jsp?page=AppFuse

(3)Spring 开发指南(夏昕)（http://www.xiaxin.net/Spring_Dev_Guide.rar）
一本spring的入门书籍,里面介绍了反转控制和依赖注射的概念，以及spring的bean管理，spring的MVC，spring和hibernte，iBatis的结合。

(4) spring学习的中文论坛
SpringFramework中文论坛(http://spring.jactiongroup.net)
Java视线论坛(http://forum.javaeye.com)的spring栏目

2、利用Spring框架编程，console打印出log4j:WARN Please initialize the log4j system properly？
说明你的log4j.properties没有配置。请把log4j.properties放到工程的classpath中，eclipse的classpath为bin目录，由于编译后src目录下的文件会拷贝到bin目录下，所以你可以把log4j.properties放到src目录下。
这里给出一个log4j.properties的例子：

log4j.rootLogger=DEBUG,stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %5p (%F:%L) - %m%n

3、出现 java.lang.NoClassDefFoundError?
一般情况下是由于你没有把必要的jar包放到lib中。

比如你要采用spring和hibernate（带事务支持的话），你除了spring.jar外还需要hibernat.jar、aopalliance.jar、cglig.jar、jakarta-commons下的几个jar包。

http://www.springframework.org/download.html下载spring开发包，提供两种zip包
spring-framework-1.1.3-with-dependencies.zip和spring-framework-1.1.3.zip，我建议你下载spring-framework-1.1.3-with-dependencies.zip。这个zip解压缩后比后者多一个lib目录，其中有hibernate、j2ee、dom4j、aopalliance、jakarta-commons等常用包。

4、java.io.FileNotFoundException: Could not open class path resource [....hbm.xml],提示找不到xml文件？
原因一般有两个：
(1)该xml文件没有在classpath中。
(2)applicationContext-hibernate.xml中的xml名字没有带包名。比如：
<bean id="sessionFactory" class="org.springframework.orm.hibernate.LocalSessionFactoryBean">
        <property name="dataSource"><ref bean="dataSource"/></property>
        <property name="mappingResources">
            <list>
                <value>User.hbm.xml</value>         错，改为： <value>com/yz/spring/domain/User.hbm.xml</value>
            </list>
        </property>
        <property name="hibernateProperties">
         <props>
         <prop key="hibernate.dialect"> net.sf.hibernate.dialect.MySQLDialect </prop>
         <prop key="hibernate.show_sql">true</prop>
        </props>
        </property>
</bean>

5、org.springframework.beans.NotWritablePropertyException: Invalid property 'postDao' of bean class？
出现异常的原因是在application-xxx.xml中property name的错误。
<property name="...."> 中name的名字是与bean的set方法相关的，而且要注意大小写。
比如
public class PostManageImpl extends BaseManage implements PostManage {
    private PostDAO dao = null;
    public void setPostDAO(PostDAO postDAO){
        this.dao = postDAO;
    }
}
那么xml的定义应该是：
<bean id="postManage" parent="txProxyTemplate">
        <property name="target">
            <bean class="com.yz.spring.service.implement.PostManageImpl">
                <property name="postDAO"><ref bean="postDAO"/></property>    对
                <property name="dao"><ref bean="postDAO"/></property>             错
            </bean>
        </property>
</bean>

6、Spring中如何实现事务管理？
        首先，如果使用mysql，确定mysql为InnoDB类型。
        事务管理的控制应该放到商业逻辑层。你可以写个处理商业逻辑的JavaBean，在该JavaBean中调用DAO，然后把该Bean的方法纳入spring的事务管理。

比如：xml文件定义如下：
<bean id="txProxyTemplate" abstract="true"
        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <property name="transactionManager"><ref bean="transactionManager"/></property>
        <property name="transactionAttributes">
            <props>
                <prop key="save*">PROPAGATION_REQUIRED</prop>
                <prop key="remove*">PROPAGATION_REQUIRED</prop>
                <prop key="*">PROPAGATION_REQUIRED</prop>
            </props>
        </property>
</bean>

<bean id="userManage" parent="txProxyTemplate">
      <property name="target">
          <bean class="com.yz.spring.service.implement.UserManageImpl">
              <property name="userDAO"><ref bean="userDAO"/></property>
          </bean>
      </property>
</bean>

com.yz.spring.service.implement.UserManageImpl就是我们的实现商业逻辑的JavaBean。我们通过parent元素声明其事务支持。

7、如何管理Spring框架下更多的JavaBean？
        JavaBean越多，spring配置文件就越大，这样不易维护。为了使配置清晰，我们可以将JavaBean分类管理，放在不同的配置文件中。 应用启动时将所有的xml同时加载。
比如：
        DAO层的JavaBean放到applicationContext-hibernate.xml中，商业逻辑层的JavaBean放到applicationContext-service.xml中。然后启动类中调用以下代码载入所有的ApplicationContext。

String[] paths = {"com/yz/spring/dao/hibernate/applicationContext-hibernate.xml",
                          "com/yz/spring/service/applicationContext-service.xml"};
ctx = new ClassPathXmlApplicationContext(paths);

8、web应用中如何加载ApplicationContext？
可以通过定义web.xml，由web容器自动加载。

 <servlet>
  <servlet-name>context</servlet-name>
  <servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
  <load-on-startup>1</load-on-startup>
 </servlet>
 
 <context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>/WEB-INF/applicationContext-hibernate.xml</param-value>
  <param-value>/WEB-INF/applicationContext-service.xml</param-value>
 </context-param>

9、在spring中如何配置的log4j?
在web.xml中加入以下代码即可。
<context-param>
  <param-name>log4jConfigLocation</param-name>
  <param-value>/WEB-INF/log4j.properties</param-value>
</context-param>

10、Spring框架入门的编程问题解决了，我该如何更深地领会Spring框架呢？
这两本书你该去看看。这两本书是由Spring的作者Rod Johnson编写的。
Expert One on one J2EE Design and Development
Expert One on one J2EE Development Without EJB
你也该看看martinfowler的Inversion of Control Containers and the Dependency Injection pattern。
http://www.martinfowler.com/articles/injection.html

再好好研读一下spring的文档。
http://www.jactiongroup.net/reference/html/index.html（中文版，未全部翻译）

还有就是多实践吧。

作者：Eric M. Burke, coauthor of Java Extreme Programming Cookbook

原文：http://www.onjava.com/pub/a/onjava/2003/12/17/ant_bestpractices.html

译者：徐彤MSN:xt121@hotmail.com

在Ant出现之前，构建和部署Java应用需要使用包括特定平台的脚本、Make文件、各种版本的IDE甚至手工操作的“大杂烩”。现在，几乎所有的开源Java项目都在使用Ant，大多数公司的内部项目也在使用Ant。Ant在这些项目中的广泛使用自然导致了读者对一整套Ant最佳实践的迫切需求。

本文总结了我喜爱的Ant技巧或最佳实践，多数是从我亲身经历的项目错误或我听说的其他人经历的 “恐怖”故事中得到灵感的。比如，有人告诉我有个项目把XDoclet 生成的代码放入带有锁定文件功能的版本控制工具中。当开发者修改源代码时，他必须记住手工检出（Check out）并锁定所有将要重新生成的文件。然后，手工运行代码生成器，只到这时他才能够让Ant编译代码，这一方法还存在如下一些问题：

• 生成的代码无法存储在版本控制系统中。
• Ant（本案例中是Xdoclet）应该自动确定下一次构建涉及的源文件，而不应由程序员手工确定。
• Ant的构建文件应该定义好正确的任务依赖关系，这样程序员就不必为了完成构建而不得不按照特定顺序调用任务。

当我开始一个新项目时，我首先编写Ant构建文件。Ant文件明确地定义构建的过程，并被团队中的每个程序员使用。本文所列的技巧基于这样的假定：Ant构建文件是一个必须仔细编写的重要文件，它应在版本控制系统中得到维护，并被定期进行重构。下面是我的十五大Ant最佳实践。

1. 采用一致的编码规范

Ant用户有的喜欢有的痛恨其构建文件的XML语法。与其跳进这一令人迷惑的争论中，不如让我们先看一些能保持XML构建文件简洁的方法。

首先也是最重要的，花费时间格式化你的XML让它看上去很清晰。不论XML是否美观，Ant都可以工作。但是丑陋的XML很难令人读懂。倘若你在任务之间留出空行，有规则的缩进，每行文字不超过90列左右，那么XML令人惊讶地易读。再加上使用能够高亮XML语法的优秀编辑器或IDE工具，你就不会有阅读的麻烦。

同样，精选含意明确、容易读懂的词汇来命名任务和属性。比如，dir.reports就比rpts好。特定的编码规范并不重要，只要拿出一套规范并坚持使用就行。

2. 将build.xml放在项目根目录中

Ant构建文件build.xml可以放在任何位置，但是放在项目顶级目录中可以保持项目简洁。这是最常用的规范，开发者能够在顶级目录中找到预期的build.xml。把构建文件放在根目录中，也能够使人容易了解项目目录树中不同目录之间的逻辑关系。以下是一个典型的项目目录层次：

[root dir]
  | build.xml 
  +--src 
  +--lib (包含第三方 JAR包) 
  +--build (由 build任务生成) 
  +--dist (由 build任务生成)

当build.xml在顶级目录时，假设你处于项目某个子目录中，只要输入：ant -find compile 命令，不需要改变工作目录就能够以命令行方式编译代码。参数-find告诉Ant寻找存在于上级目录中的build.xml并执行。

3. 使用单一的构建文件

有人喜欢将一个大项目分解成几个小的构建文件，每个构建文件分担整个构建过程的一小部分工作。这确实是看法不同的问题，但是应该认识到，将构建文件分割会增加对整体构建过程的理解难度。要注意在单一构建文件能够清楚表现构建层次的情况下不要过工程化(over-engineer)。

即使你把项目划分为多个构建文件，也应使程序员能够在项目根目录下找到核心build.xml。尽管该文件只是将实际构建工作委派给下级构建文件，也应保证该文件可用。

4. 提供良好的帮助说明

应尽量使构建文件自文档化。增加任务描述是最简单的方法。当你输入ant -projecthelp时，你就可以看到带有描述的任务清单。比如，你可以这样定义任务：

最简单的规则是把所有你想让程序员通过命令行就可以调用的任务都加上描述。对于一般用来执行中间处理过程的内部任务，比如生成代码或建立输出目录等，就无法使用描述属性。

这时，可以通过在构建文件中加入XML注释来处理。或者专门定义一个help任务，当程序员输入ant help时来显示详细的使用说明。

5. 提供清除任务

每个构建文件都应包含一个清除任务，用来删除所有生成的文件和目录，使系统回到构建文件执行前的初始状态。执行清空任务后还存在的文件都应处在版本控制系统的管理之下。比如：

除非是在产生整个系统版本的特殊任务中，否则不要自动调用clean任务。当程序员仅仅执行编译任务或其他任务时，他们不需要构建文件事先执行既令人讨厌又没有必要的清空任务。要相信程序员能够确定何时需要清空所有文件。

6. 使用ANT管理任务从属关系

假设你的应用由Swing GUI组件、Web界面、EJB层和公共应用代码组成。在大型系统中，你需要清晰地定义每个Java包属于系统的哪一层。否则任何一点修改都要被迫重新编译成百上千个文件。糟糕的任务从属关系管理会导致过度复杂而脆弱的系统。改变GUI面板的设计不应造成Servlet和EJB的重编译。

当系统变得庞大后，稍不注意就可能将依赖于客户端的代码引入到服务端。这是因为典型的IDE项目文件编译任何文件都使用单一的classpath。而Ant能让你更有效地控制构建活动。

设计你的Ant构建文件编译大型项目的步骤：首先，编译公共应用代码，将编译结果打成JAR包文件。然后，编译上一层的项目代码，编译时依靠第一步产生的JAR文件。不断重复这一过程，直到最高层的代码编译完成。

分步构建强化了任务从属关系管理。如果你工作在底层Java框架上，偶然引用到高层的GUI模板组件，这时代码不需要编译。这是由于构建文件在编译底层框架时在源路径中没有包含高层GUI面板组件的代码。

7. 定义并重用文件路径

如果文件路径在一个地方一次性集中定义，并在整个构建文件中得到重用，那么构建文件更易于理解。以下是这样做的一个例子：

当项目不断增长构建日益复杂时，这一技术越发体现出其价值。你可能需要为编译不同层次的应用定义各自的文件路径，比如运行单元测试的、运行应用程序的、运行Xdoclet的、生成JavaDocs的等等不同路径。这种组件化路径定义的方法比为每个任务单独定义路径要优越得多。否则，很容易丢失任务从属关系的轨迹。

8. 定义恰当的任务从属关系

假设dist任务从属于jar任务，那么哪个任务从属于compile任务哪个任务从属于prepare任务呢？Ant构建文件最终定义了任务的从属关系图，它必须被仔细地定义和维护。

应该定期检查任务的从属关系以保证构建工作得到正确执行。大的构建文件随着时间推移趋向于增加更多的任务，所以到最后可能由于不必要的从属关系导致构建工作非常困难。比如，你可能发现在程序员只需编译一些没有使用EJB的GUI代码时又重新生成了EJB代码。

以“优化”的名义忽略任务的从属关系是另一种常见的错误。这种错误迫使程序员为了得到恰当的结果必须记住并按照特定的顺序调用一串任务。更好的做法是：提供描述清晰的公共任务，这些任务包含正确的任务从属关系；另外提供一套“专家”任务让你能够手工执行个别的构建步骤，这些任务不提供完整的构建过程，但是让那些专家用户在快速而恼人的编码期间能够跳过某些步骤。

9.使用属性

任何需要配置或可能发生变化的信息都应作为Ant属性定义下来。对于在构建文件中多次出现的值也同样处理。属性既可以在构建文件头部定义，也可以为了更好的灵活性而在单独的属性文件中定义。以下是在构建文件中定义属性的样式：

或者你可以使用属性文件：

在属性文件 sample.properties中:

用一个独立的文件定义属性是有好处的，它可以清晰地定义构建中的可配置部分。另外，在开发者工作在不同操作系统的情况下，你可以在不同的平台上提供该文件的不同版本。

10. 保持构建过程独立

为了最大限度的扩展性，不要应用外部路径和库文件。最重要的是不要依赖于程序员的CLASSPATH设置。取而代之的是，在构建文件中使用相对路径并定义自己的路径。如果你引用了绝对路径如C:\java\tools，其他开发者未必使用与你相同的目录结构，所以就无法使用你的构建文件。

如果你部署开放源码项目，应该提供包含编译代码所需的所有JAR文件的发行版本。当然，这是在遵守许可协议的基础上。对于内部项目，相关的JAR文件都应在版本控制系统的管理中，并捡出（check out）到大家都知道的位置。

当你必须引用外部路径时，应将路径定义为属性。使程序员能够用适合他们自己的机器环境的参数重载这些属性。你也可以使用以下语法引用环境变量：

11. 使用版本控制系统

构建文件是一个重要的制品，应该像代码一样进行版本控制。当你标记你的代码时，也应用同样的标签标记构建文件。这样当你需要回溯到旧版本并进行构建时，能够使用相应版本的构建文件。

除构建文件之外，你还应在版本控制中维护第三方JAR文件。同样，这使你能够重新构建旧版本的软件。这也能够更容易保证所有开发者拥有一致的JAR文件，因为他们都是同构建文件一起从版本控制系统中捡出的。

通常应避免在版本控制系统中存放构建成果。倘若你的源代码很好地得到了版本控制，那么通过构建过程你能够重新生成任何版本的产品。

12. 把Ant作为“最小公分母”

假设你的开发团队使用IDE工具，当程序员通过点击图标就能够构建整个应用时为什么还要为Ant而烦恼呢？

IDE的问题是一个关于团队一致性和重现性的问题。几乎所有的IDE设计初衷都是为了提高程序员的个人生产率，而不是开发团队的持续构建。典型的IDE要求每个程序员定义自己的项目文件。程序员可能拥有不同的目录结构，可能使用不同版本的库文件，还可能工作在不同的平台上。这将导致出现这种情况：在Bob那里运行良好的代码，到Sally那里就无法运行。

不管你的开发团队使用何种IDE，一定要建立所有程序员都能够使用的Ant构建文件。要建立一个程序员在将新代码提交版本控制系统前必须执行Ant构建文件的规则。这将确保代码是经过同一个Ant构建文件构建的。当出现问题时，要使用项目标准的Ant构建文件，而不是通过某个IDE来执行一个干净的构建。

程序员可以自由选择任何他们习惯使用的IDE工具或编辑器。但是Ant应作为公共基线以保证代码永远是可构建的。

13. 使用zipfileset属性

人们经常使用Ant产生WAR、JAR、ZIP和 EAR文件。这些文件通常都要求有一个特定的内部目录结构，但其往往与你的源代码和编译环境的目录结构不匹配。

一个最常用的方法是写一个Ant任务，按照期望的目录结构把一大堆文件拷贝到临时目录中，然后生成压缩文件。这不是最有效的方法。使用zipfileset属性是更好的解决方案。它让你从任何位置选择文件，然后把它们按照不同目录结构放进压缩文件中。以下是一个例子：

在这个例子中，所有JAR文件都放在EAR文件包的lib目录中。hr.jar和billing.jar是从构建目录拷贝过来的。因此我们使用zipfileset属性把它们移动到EAR文件包内部的lib目录。prefix属性指定了其在EAR文件中的目标路径。

14. 测试Clean任务

假设你的构建文件中有clean和compile的任务，执行以下的测试。第一步，执行ant clean；第二步，执行ant compile；第三步，再执行ant compile。第三步应该不作任何事情。如果文件再次被编译，说明你的构建文件有问题。

构建文件应该只在与输出文件相关联的输入文件发生变化时执行任务。一个构建文件在不必执行诸如编译、拷贝或其他工作任务的时候执行这些任务是低效的。当项目规模增长时，即使是小的低效工作也会成为大的问题。

15. 避免特定平台的Ant封装

不管什么原因，有人喜欢用简单的、名称叫做compile之类的批文件或脚本装载他们的产品。当你去看脚本的内容你会发现以下内容：

ant compile

其实开发人员都很熟悉Ant，并且完全能够自己键入ant compile。请不要仅仅为了调用Ant而使用特定平台的脚本。这只会使其他人在首次使用你的脚本时增加学习和理解的烦扰。除此之外，你不可能提供适用于每个操作系统的脚本，这是真正烦扰其他用户的地方。

总结

太多的公司依靠手工方法和特别程序来编译代码和生成软件发布版本。那些不使用Ant或类似工具定义构建过程的开发团队，花费了太多的时间来捕捉代码编译过程中出现的问题：在某些开发者那里编译成功的代码，到另一些开发者那里却失败了。

生成并维护构建脚本不是一项富有魅力的工作，但却是一项必需的工作。一个好的Ant构建文件将使你能够集中到更喜欢的工作——写代码中去！

参考

• Ant
• AntGraph: Ant依赖性的可视化工具
• Ant: The Definitive Guide, O'Reilly
• Java Extreme Programming Cookbook, O'Reilly

  主要的内容有：

    (1)建立一个项目
    (2)建立属性
    (3)对数据库的操作
    (4)javac编译
    (5)删除目录
    (6)建立目录
    (7)拷贝文件群
    (8)jar为一个包
    (9)拷贝单个文件
    (10)运行
  有更多更好的常用的,我没想到的,希望大家补充。 
 
  <!--(1)建立一个项目，默认的操作为target=all. -->
  <project name="proj" default="all" basedir=".">

    <!--(2)建立一些属性，以供下边的操作用到 -->
    <property name="root"  value="./" />
    <property name="deploy_path"  value="d:/deploy" />
    <property name="srcfile"  value="d:/srcfile" /> 
 
    <target name="all" depends="compile,deploy"/>

    <!--(3)对数据库的操作 demo.ddl中写的是sql语句 driver,url,userid,password随具体情况设置--> 
    <!-- Oracle -->
    <target name="db_setup_oracle" description="Database setup for Oracle">
      <antcall target="check_params_results"/>
      <sql driver="oracle.jdbc.driver.OracleDriver"
       url="jdbc:oracle:thin:@192.168.0.1:1521:oa"
       userid="oa" password="oa"
       onerror="continue"
       print="yes"
       src="./demo.ddl"/>
    </target>

    <!--(4)javac编译 --> 
    <target name="compile">  
    <javac srcdir="${srcfile}"
      destdir="${root}/oa/"
      includes="*.java"
      classpath="${CLASSPATH};${CLIENT_CLASSES}/utils_common.jar"   <!--CLASSPATH和CLIENT_CLASSES是环境变量-->
      />
    </target>
 
    <target name="deploy" depends="compile">
      <!-- Create the time stamp -->
      <tstamp/>
   
      <!--(5)删除目录-->   
      <!--(6)建立目录-->
      <delete dir="${root}/dist/"/>   
      <mkdir dir="${root}/dist/"/>     

      <delete dir="${deploy_path}"/>
    <mkdir dir="${deploy_path}"/>    
 
    <!--(7)拷贝文件群-->
    <copy todir="${root}/dist/">    
            <fileset dir="${root}/oa/">
                <include name="*.class"/>
            </fileset>
    </copy>
   
    <!--(8)jar为一个包-->   
    <jar jarfile="${deploy_path}/classjar.jar" basedir="${root}/dist" update="yes"></jar> 
 
    <!--(9)拷贝单个文件(上边是文件群,这是单个文件)-->
    <copy file="${deploy_path}/classjar.jar" todir="${root}/dist/"/>

    </target>
 
     <!--(10)运行(args中是参数,随应用程序的具体情况有所不同)->
   <target name="simplesql"  depends="compile,db_setup_oracle">
    <java classname="examples.jdbc.oracle.simplesql"
      fork="yes" failonerror="yes"
      args="-user zrb
            -password zrb
            "/>

  </project>