Spring 快速入门教程

(1)

Spring 快速入门教程

──开发你的第一个 Spring 程序

翻译整理：Hantsy Bai<[email protected]>

本章学习用 struts MVC 框架作前端，Spring 做中间层，Hibernate 作后端来开发一个简单的 Spring 应用程序。在第 4 章将使用 Spring MVC 框架对它进行重构。

本章包含以下内容：

编写功能性测试。

配置 Hibernate 和 Transaction。

载入 Spring 的 applicationContext.xml 文件。

设置业务代理(business delegates)和 DAO 的依赖性。

把 spring 写入 Struts 程序。

(2)

概述

你将会创建一个简单的程序完成最基本的 CRUD(Create, Retrieve, Update 和 Delete) 操作。这个程序叫 MyUsers，作为本书的样例。这是一个 3 层架构的 web 程序，通过一个 Action 来调用业务代理，再通过它来回调 DAO 类。下面的流程图表示了 MyUsers 是如何工作的。数字表明了流程的先后顺序，从 web 层(UserAction)到中间层(UserManager)，再到数据层(UserDAO)，然后返回。

鉴于大多数读者都比较熟悉 struts，本程序采用它作为 MVC 框架。Spring 的魅力在于它宣称式的事务处理，依懒性的绑定和持久性的支持。第 4 章中将用 Spring 框架对它进行重构。

接下来你会进行以下几个步骤：

1. 下载 Struts 和 Spring。

2. 创建项目目录和 ant Build 文件。

3. 为持久层创建一个单元测试(unit tests)。

4. 配置 Hibernate 和 Spring。

5. 编写 HIbernate DAO 的实现。

6. 进行单元测试，通过 DAO 验证 CRUD。

(3)

7. 创建一个 Manager 来声明事务处理。

8. 为 struts Action 编写测试程序。

9. 为 web 层创建一个 Action 和 model(DynaActionForm)。

10.进行单元测试，通过 Action 验证 CRUD。

11.创建 JSP 页面，以通过浏览器来进行 CRUD 操作。

12.通过浏览器来验证 JSP 页面的功能。

13.用 velocity 模板替换 JSP 页面。

14.使用 Commons Validator 添加验证。

(4)

下载 Struts 和 Spring

1.下载安装以下组件：

• JDK1.4.2(或以上)

• Tomcat5.0+

• Ant 1.6.1+

2.设置以下环境变量：

• JAVA_HOME

• ANT_HOME

• CATALINA_HOME

3.把以下路径添加到 PATH 中：

• JAVA_HOME/bin

• ANT_HOME/bin

• CATALINA_HOME/bin

为了开发基于 java 的 web 项目，开发人员必须事先下载必需的 jars,建好开发目录结构和 ant build 文件。对于单一的 struts 项目，可以利用 struts 中现成的 struts-

blank.war。对于基于 Spring MVC 框架的项目，可以用 Spring 中的 webapp-minimal.war。

这只为开发作准备，两者都没有进行 struts-spring 集成，也没有考虑单元测试。为此，我们为读者准备了 Equinox。

Equinox 为开发 Struts-spring 式的程序提供一个基本框架。它已经定义好了目录结构，

和 ant build 文件(针对 compiling,deploying,testing)，并且提供了 struts, spring, Hibernate 开发要用到的 jars 文件。Equinox 中大部分目录结构和 ant build 文件来自我的开源项目──AppFuse。可以说，Equinox 是一个简化的 AppFuse，它在最小配置情况下，为快速 web 开发提供了便利。由于 Equinox 源于 AppFuse,所以在包名，数据库名，及其它地方都找到它的影子。这是为让你从基于 Equinox 的程序过渡到更为复杂的 AppFuse。

从 http://sourcebeat.com/downloads 上下载 Equinox，解压到一个合适的位置，开始准备 MyUsers 的开发。

(5)

创建项目目录和 ant build 文件

为了设置初始的目录结构，把下载的 Equinox 解压到硬盘。建议 windows 用户把项目放在 C:\Source，Unix/Linux 用户放在~/dev(译注：在当前用户目录建一个 dev 目录)中。

windows 用户可以设置一个 HOME 环境变量，值为 C:\Source。最简单的方法是把 Equinox 解压到你的喜欢的地方，进入 equinox 目录，运行 ant new -Dapp.anme=myusers。

tips:在 windows 使用 cygwin(www.cygwin.org)就可以像 Unix/Linux 系统一样使用正斜杠，本书所有路径均采用正斜杠。其它使用反斜杠系统(如 windows 中命令行窗口)的用户请作相应的调整。

现在 MyUsers 程序已经有如下的目录结构：

Equinox 包含一个简单而功能强大的 build.xml,它可以用 ant 来进行编译，布署，和测试。ant 中已经定义好 targets,在 equinox 运行 ant,将看到如下内容：

[echo] Available targets are:

[echo] compile --> Compile all Java files [echo] war --> Package as WAR file

[echo] deploy --> Deploy application as directory [echo] deploywar --> Deploy application as a WAR file [echo] install --> Install application in Tomcat [echo] remove --> Remove application from Tomcat [echo] reload --> Reload application in Tomcat [echo] start --> Start Tomcat application [echo] stop --> Stop Tomcat application [echo] list --> List Tomcat applications

(6)

[echo] clean --> Deletes compiled classes and WAR [echo] new --> Creates a new project

Equinox 支持 tomcat 的 ant tasks(任务)。这些已经集成在 Equinox 中，解讲一下如何进行集成的有助于理解它们的工作原理。

Tomcat 和 ant

tomcat 中定义了一组任务，可以通过 Manager 来安装(install),删除(remove)，重载 (reload)webapps。要使用这些任务，可以把所有的定义写在一个属性文件中。在 Eqinox 的根目录下，有一个名为 tomcatTasks.properties 包含如下内容。

deploy=org.apache.catalina.ant.DeployTask undeploy=org.apache.catalina.ant.UndeployTask remove=org.apache.catalina.ant.RemoveTask reload=org.apache.catalina.ant.ReloadTask start=org.apache.catalina.ant.StartTask stop=org.apache.catalina.ant.StopTask list=org.apache.catalina.ant.ListTask

在 build.xml 定义一些任务来安装，删除，重新载入应用程序。

</classpath>

</taskdef>

<target name="install" description="Install application in Tomcat"

depends="war">

<deploy url="${tomcat.manager.url}" username="${tomcat.manager.username}"

password="${tomcat.manager.password}" path="/${webapp.name}" war="file:$

{dist.dir}/${webapp.name}.war"/>

</target>

<undeploy url="${tomcat.manager.url}" username="${tomcat.manager.username}"

password="${tomcat.manager.password}" path="/${webapp.name}"/>

(7)

</target>

<reload url="${tomcat.manager.url}" username="${tomcat.manager.username}"

</target>

<start url="${tomcat.manager.url}" username="${tomcat.manager.username}"

</target> <target name="stop" description="Stop Tomcat application">

<stop url="${tomcat.manager.url}" username="${tomcat.manager.username}"

</target>

<list url="${tomcat.manager.url}"

username="${tomcat.manager.username}"

password="${tomcat.manager.password}"/>

</target>

在上面列出的 target 中，必须定义一些${tomcat.*}变量。在根目录下有一个 build.properties 默认定义如下：

# Properties for Tomcat Server

tomcat.manager.url=http://localhost:8080/manager tomcat.manager.username=admin

tomcat.manager.password=admin

确保 admin 用户可以访问 Manager 应用，打开$CATALINA_HOME/conf/tomcat-

users.xml 中是否存在下面一行。如果不存在，请自己添加。注意，roles 属性可能是一个以逗号(“,”)隔开的系列。

为了测试所有修改，保存所有文件，启动 tomcat。从命令行中进行 myusers 目录，运行 ant list，可以看到 tomcat server 上运行的应用程序。

(8)

好了，现在运行 ant deploy 来安装 MyUsers。打开浏览器，在地址栏中输入 http://localhost:8080/myusers，出现如图 2.4 的“Equinox Welcome”画面。

下一节，将写一个 User 对象和一个维护其持久性的 Hibernate DAO 对象。用 Sping 来管理 DAO 类及其依赖性。最会写一个业务代理，用到 AOP 和声明式事务处理。

(9)

为持久层编写单元测试

在myUsers 程序，使用 Hibernat 作为持久层。Hinbernate 是一个 O/R 映像框架，用来关联java 对象和数据库中的表(tables)。它使得对象的 CRUD 操作变得非常简单，Spring 结合了 Hibernate 变得更加容易。从 Hibernate 转向 Spring+Hibernate 会减少 75%的代码。这主要是因为，ServiceLocater 和一些 DAOFactory 类的废弃，spring 的实时异常代替了 Hibernate 的检测式的异常。

写一个单元测试有助于规范 UserDAO 接口。为 UserDAO 写一个 JUint 测试程序，要完成以下几步：

1.在 test/org/appfuse/dao 下新建一个 UserDAOTest.java 类。它继承了同一个包中的 BaseDAOTestCase，其父类初始化了 Spring 的 ApplictionContext(来自 web/WEB-

INF/applictionContext.xml)，以下是 JUnit 测试的代码。

package org.appfuse.dao;

// use your IDE to handle imports

public class UserDAOTest extends BaseDAOTestCase { private User user = null;

private UserDAO dao = null;

protected void setUp() throws Exception {

log = LogFactory.getLog(UserDAOTest.class);

dao = (UserDAO) ctx.getBean("userDAO");

}

protected void tearDown() throws Exception { dao = null;

}

public static void main(String[] args) {

junit.textui.TestRunner.run(UserDAOTest.class);

}

这个类还不能编译，因为还没有UserDAO 接口。在这之前，来写一些来验证 User 的

CRUD 操作。

2.为 UserDAOTest 类添加 testSave 和 testAddAndRemove 方法，如下：

public void testSaveUser() throws Exception {

(10)

user = new User();

user.setFirstName("Rod");

user.setLastName("Johnson");

dao.saveUser(user);

assertTrue("primary key assigned", user.getId() != null);

log.info(user);

assertTrue(user.getFirstName() != null);

}

public void testAddAndRemoveUser() throws Exception { user = new User();

user.setFirstName("Bill");

user.setLastName("Joy");

dao.saveUser(user);

assertTrue(user.getId() != null);

assertTrue(user.getFirstName().equals("Bill"));

if (log.isDebugEnabled()) {

log.debug("removing user...");

}

dao.removeUser(user.getId());

assertNull(dao.getUser(user.getId()));

}

从这些方法中可以看到，你需要在UserDAO 创建以下方法：

saveUser(User) removeUser(Long) getUser(Long)

getUsers() (返回数据库的所有用户)

3.在 src/org/appfuse/dao 目录下建一个名为 UserDAO.java 类的，输入以下代码：

tips:如果你使用 eclipse,idea 之类的 IDE，左边会出现在一个灯泡，提示类不存在，可以即时创建。

package org.appfuse.dao;

public interface UserDAO extends DAO { public List getUsers();

public User getUser(Long userId);

(11)

public void saveUser(User user);

public void removeUser(Long userId);

}

为了UserDAO.java,UserDAOTest.java 编译通过，还要建一个 User.java 类。

4.在 src/org/appfuse/model 下建一个 User.java 文件，添加几个成员变量：

id,firstName,lastName，如下。

package org.appfuse.model;

public class User extends BaseObject { private Long id;

private String firstName;

private String lastName;

/* 用你熟悉的 IDE 来生成 getters 和 setters，Eclipse 中右击> Source -> Generate Getters and Setters */

}

注意，你继承了BaseObject 类，它包含几个有用的方法：toString(),equlas(),hasCode(), 后两个是Hibernate 必须的。建好 User 后，用 IDE 打开 UserDAO 和 UserDAOTest 两个类，

优化导入。

(12)

配置 Hibernate 和 Spring

现在已经有了POJO(Plain Old Java Object),写一个映像文件 Hibernate 就可能维护它。

1.在 org/appfuse/model 中新建一个名为 User.hbm.xml 文件，内容如下：

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

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping>

</id>

</class>

</hibernate-mapping>

2.在 web/WEB-INF/下的 applictionContext.xml 中添加映像。打开文件，找到<property name= mappingResources >，改成如下：

<list>

<value>org/appfuse/model/User.hbm.xml</value>

</list>

</property>

在applictionContext.xml 中，你可以看到数据库是怎幺工作的，Hibernate 和 Spring 是如何协作的。Eqinox 会使用名为 db/appfuse 的 HSQL 数据库。它将在你的 ant “db”目录下创建，

详细配置在“How Spring Is Configured in Equinox ”一节中描述。

3.运行 ant deploy reload(Tomcat 正在运行)，在 Tomcat 控制台的日志中可以看到，数据表正在创建。

INFO - SchemaExport.execute(98) | Running hbm2ddl schema export

INFO - SchemaExport.execute(117) | exporting generated schema to database

INFO - ConnectionProviderFactory.newConnectionProvider(53) | Initializing connection

(13)

provider: org.springframework.orm.hibernate.LocalDataSourceConnectionProvider

INFO - DriverManagerDataSource.getConnectionFromDriverManager(140) | Creating new JDBC connection to [jdbc:hsqldb:db/appfuse]

INFO - SchemaExport.execute(160) | schema export complete

Tip: 如果你想看到更多或更少的日志，修改 web/WEB-INF/ classes/log4j.xml 的设置。

4.为了验证数据库已经建好，运行 ant browser 启动 hsql console 。你会看到如的 HSQL Database Manager。

Equinox 中 spring 是怎幺配置的

使用Spring 配置任何基于 j2ee 的 web 程序都很简单。至少，你简单的添加 Spring 的 ContextLoaderListener 到你的 web.xml 中。

<listener-class>

org.springframework.web.context.ContextLoaderListener

</listener-class>

</listener>

这是一个ServletContextListener，它会在启动 web 应用进行初始化。默认情况下，它会

(14)

查找web/WEB-INF/applictionContext.xml 文件，你可以指定名为 contextConfigLocation 的

<context-param>元素来进行修改，例如：

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>/WEB-INF/sampleContext.xml</param-value>

</context-param>

<param-value>元素可以是以空格或是逗号隔开的一系列路径。在 Equnox 中，Spring 的配置使用了这个Listener 和默认的 contextConfigLocation。

那幺，Spring 怎幺知道 Hibernate 的存在？这就 Spring 的魅力所在，它让依赖性的绑定变得非常简单。请参阅applicationContext.xml 的全部内容：

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

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"

"http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

<bean id="dataSource"

class="org.springframework.jdbc.datasource.DriverManagerDataSource">

<value>org.hsqldb.jdbcDriver</value>

</property>

<value>jdbc:hsqldb:db/appfuse</value>

</property>

</property>

</property> </bean>

<bean id="sessionFactory"

class="org.springframework.orm.hibernate.LocalSessionFactoryBean">

(15)

</property>

<list>

<value>org/appfuse/model/User.hbm.xml</value>

</list>

</property>

<props>

<prop key="hibernate.dialect"> net.sf.hibernate.dialect.HSQLDialect </prop>

<prop key="hibernate.hbm2ddl.auto">create</prop>

</props>

</property>

</bean>

<bean id="transactionManager"

class="org.springframework.orm.hibernate.HibernateTransactionManager">

</property>

</bean>

</beans>

第一bean 代表 HSQL 数据库，Spring 仅仅是调用 LocalSessionFactoryBeanr 的

setDataSource(DataSource)使之工作。如果你想用 JNDI DataSource 替换，可以 bean 的定义改成类似下面的几行：

<value>java:comp/env/jdbc/appfuse</value>

</property>

</bean>

hibernate.hbm2ddl.auto 属性在 sessionFactory 定义中，这个属性是为了在应用启动时自动创建表，也可能是update 或 create-drop。

最后一个bean 是 transactionManager(你也可以使用 JTA transaction)，在处理跨越两个

(16)

数据库的分布式的事务处理中尤其重要。如果你想使用jta transaction manager ，将此 bean 的 class 属性改成

org.springframework.transaction.jta.JtaTransactionManager

下面实现UserDAO 类。

(17)

用 hibernate 实现 UserDAO

为了实现Hibernate UserDAO，需要完成以下几步：

1.在 src/org/appfuse/dao/hibernate(你要新建这个目录/包) 新建一个文件

UserDAOHibernate.ava。这个类继承了 HibernatDaoSupport 类，并实现了 UserDAO 接口。

package org.appfuse.dao.hibernate;

public class UserDAOHibernate extends HibernateDaoSupport implements UserDAO { private Log log = LogFactory.getLog(UserDAOHibernate.class);

public List getUsers() {

return getHibernateTemplate().find("from User");

}

public User getUser(Long id) {

return (User) getHibernateTemplate().get(User.class, id);

}

public void saveUser(User user) {

getHibernateTemplate().saveOrUpdate(user);

log.debug( userId set to: + user.getID());

} }

public void removeUser(Long id) {

Object user = getHibernateTemplate().load(User.class, id);

getHibernateTemplate().delete(user);

} }

Spring 的 HibernateDaoSupport 类是一个方便实现 Hibernate DAO 的超类，你可以它的

(18)

一些有用的方法，来获得Hibernate DAO 或是 SessionFactory。最方便的方法是 getHibernateTemplate()，它返回一个 HibernateTempalte 对象。这个模板把检测式异常 (checked exception)包装成实时式异常(runtime exception)，这使得你的 DAO 接口无需抛出 Hibernate 异常。

程序还没有把UserDAO 绑定到 UserDAOHibernate 上，必须创建它们之间的关联。

2.在 Spring 配置文件(web/WEB-INF/applictionContext.xml)中添加以下内容：

</property>

</bean>

这样就在你的UserDAOHibernate(从 HibernateDaoSupport 的 setSessionFactory 继承)中建了一个Hibernate Session Factory。Spring 会检测一个 Session(也就是，它在 web 层是开放的)

是否已经存在，并且直接使用它，而不是新建一个。这样你可以使用Spring 流行的 “

Open Session in View ” 模式来载入 collections。

(19)

进行单元测试，来验证 DAO 的 CRUD 操作

在进行第一个测试之前，把你的日志级别从“INFO”调到“WARN”。

1.把 log4j.xml(在 web/WEB-INF/classes 目录下)中<level value="INFO"/>改为<level value="WARN"/>。

2.键入 ant test 来运行 UserDAOTest。如果你有多个测试，你必须用 ant test

-Dtestcase=UserDAOTest 来指定要运行的测试。运行之后，你会如下类似的一些日志信息。

(20)

创建 Manager，声明事务处理(create manager and declare transactions)

J2EE 开发中建议将各层进行分离。换言之，不要把数据层(DAOs)和 web 层(servlets) 混在一起。使用 Spring,很容易做到这一点，但使用“业务代理”(business delegate)模式, 可以对这些层进一步分离。

使用业务代理模式的主要原因是：

● 大多数持久层组件执行一个业务逻辑单元，把逻辑放在一非 web 类中的最大好处是，

web service 或是丰富平台客户端(rich platform client)可以像使用 servlet 一样来用同一 API。

● 大多数业务逻辑都在同一方法中完成，当然可能多个 DAO。使用业务代理，使得你

可以高级业务代理层(level)使用 Spring 的声明式业务代理特性。

MyUsers 应用中 UserManager 和 UserDAO 拥有相同的一个方法。主要不同的是 Manager 对于 web 更为友好(web-friendly)，它可以接受 Strings,而 UserDAO 只能接受 Longs, 并且它可以在 saveUser 方法中返回一个 User 对象。这在插入一个新用户比如，要获得主键，是非常方便的。Manager(或称为业务代理)中也可以添加一些应用中所需要的其它业务逻辑。

1.启动“service”层，在 test/org/appfuse/service(你必须先建好这个目录)中新建一个 UserManagerTest 类，这个类继承了 JUnit 的 TestCase 类，代码如下：

package org.appfuse.service;

public class UserManagerTest extends TestCase {

private static Log log = LogFactory.getLog(UserManagerTest.class);

private ApplicationContext ctx;

private User user;

private UserManager mgr;

protected void setUp() throws Exception {

String[] paths = {"/WEB-INF/applicationContext.xml"};

ctx = new ClassPathXmlApplicationContext(paths);

mgr = (UserManager) ctx.getBean("userManager");

}

(21)

protected void tearDown() throws Exception { user = null;

mgr = null;

}

// add testXXX methods here

public static void main(String[] args) {

junit.textui.TestRunner.run(UserDAOTest.class);

}

在 setup 方法中，使用 ClassPathXmlApplicationContext 把 applicationContext.xml 载入变量 ApplicationContext 中。载入 ApplictionContext 有几种途径，从 classpath 中，

文件系统，或 web 应用内。这些方法将在第三章( The BeanFactory and How It Works.) 中描述。

2.输入第一个测试方法的代码，来验证 Manager 成功完成添加或是删除 User 对象。

public void testAddAndRemoveUser() throws Exception { user = new User();

user.setFirstName("Easter");

user.setLastName("Bunny");

user = mgr.saveUser(user);

assertTrue(user.getId() != null);

log.debug("removing user...");

}

String userId = user.getId().toString();

mgr.removeUser(userId);

user = mgr.getUser(userId);

if (user != null) {

fail("User object found in database!");

} }

这个测试实际上是一个集成测试(integration test)，而不是单元测试(unit test)。

(22)

为了更接近单元测试，可以使用 EasyMock 或是类似工具来“伪装”(fake) DAO。这样，就不必关心 ApplictionContext 和任何依赖 Spring API 的东西。建议在测试项目依赖 (Hibernate,Spring,自己的类)的内部构件，包括数据库。第 9 章，讨论重构

UserManagerTest,使用 mock 解决 DAO 的依赖性。

3.为了编译 UserManagerTest，在 src/org/appfuse/service 中新建一个接口─

─UserManager。在 org.appfuse.service 包中创建这个类，代码如下：

package org.appfuse.service;

// use your IDE to handle imports public interface UserManager { public List getUsers();

public User getUser(String userId);

public User saveUser(User user);

public void removeUser(String userId);

}

4.建一个名为 org.appfuse.service.impl 的子包，新建一个类实现 UserManager 接口的。

package org.appfuse.service.impl;

public class UserManagerImpl implements UserManager {

private static Log log = LogFactory.getLog(UserManagerImpl.class);

private UserDAO dao;

public void setUserDAO(UserDAO dao) { this.dao = dao;

}

public List getUsers() { return dao.getUsers();

}

public User getUser(String userId) {

User user = dao.getUser(Long.valueOf(userId));

if (user == null) {

(23)

log.warn("UserId '" + userId + "' not found in database.");

}

return user;

}

public User saveUser(User user) { dao.saveUser(user);

return user;

}

public void removeUser(String userId) { dao.removeUser(Long.valueOf(userId));

} }

这个类看不出你在使用 Hibernate。当你打算把持久层转向一种不同的技术时，这样做很重要。

这个类提供一个私有 dao 成员变量，和 setUserDAO 方法一样。这样能够让 Spring 能够表演“依赖性绑定”魔术(perform “dependency binding” magic)，把这些对象扎在一起。

在使用 mock 重构这个类时，你必须在 UserManager 接口中添加 serUserDAO 方法。

5.在进行测试之前，配置 Spring,让 getBeans 返回一个 UserManagerImpl 类。在 web/WEB-INF/applicationContext.xml 文件中，添加以下几行：

</property>

</bean>

唯一的问题，你还没有使 Spring 的 AOP,特别是声明式的事务处理发挥作用。

6.为了达到目的，使用 ProxyFactoryBean 代替 userManager。ProxyFactoryBean 是一个类的不同的实现，这样 AOP 能够解释和覆盖调用的方法。在事务处理中，使用

TransactionProxyFactoryBean 代替 UserManagerImpl 类。在 context 文件中添加下面 bean 的定义：

<bean id="userManager"

class="org.springframework.transaction.interceptor.TransactionProxy FactoryBean">

(24)

</property>

</property>

<props>

<prop key="save*">PROPAGATION_REQUIRED</prop>

<prop key="remove*">PROPAGATION_REQUIRED</prop>

<prop key="*">PROPAGATION_REQUIRED,readOnly</prop>

</props>

</property>

</bean>

从这个 xml 代码片断中可以看出，TransactionProxyFactoryBean 必须有一个 transactionManager 属性设置和 transactionAttributes 定义。

7.让事务处理代理服务器(Transaction Proxy)知道你要模仿的对象：

userManagerTarget。作为新 bean 的一部分，把原来的 userManager bean 改成拥有一个 userManagerTarget 的 id 属性。

编辑 applictionContext.xml 添加 userManager 和 userManagerTarget 的定义后，

运行 ant test -Dtestcase=UserManager ,看看终端输出：

8.如果你想看看事务处理的执行和提交情况，在 log4j.xml 中添加:

(25)

</logger>

重新运行测试，将看到大量日志信息，如它相关的对象，事务的创建和提交等。测试完毕，最好删除上面的日志定义(logger)。

祝贺你！你已经实现了一个 web 应用的 Spring/Hibernate 后端解决方案。并且你已经用 AOP 和声明式业务处理配置好了业务代理。了不起，自我鼓励一下！(This is no small feat; give yourself a pat on the back!)

(26)

对象 struts Action 进行单元测试

业务代理和 DAO 都起作用，我们看看 MVC 框架吸盘(sucker)的上部。停！不止这些吧，你可以进行 C(Controller),不是 V(View)。为了管理用户建一个 Struts Action,继续进行驱动测试(Test-Driven)开发。

Equinox 是为 Struts 配置的。配置 Struts 需要在 web.xml 中进行一些设置，并在 web/WEB-INF 下定义一个 struts-config.xml 文件。由于 Struts 开发人员比较多，这里先使用 Struts。第 4 章用 Spring 进行处理。你想跳过这一节，直接学习 Spring MVC 方法，请参考第 4 章：Spring s MVC Framework。

在 test/org/appfuse/web 目录下新建一个文件 UserActionTest.java，开发你的第一个 Struts Aciton 单元测试。文件内容如下：

package org.appfuse.web;

public class UserActionTest extends MockStrutsTestCase {

public UserActionTest(String testName) { super(testName);

}

public void testExecute() { setRequestPathInfo("/user");

addRequestParameter("id", "1");

actionPerform();

verifyForward("success");

verifyNoActionErrors();

} }

(27)

为 web 层创建 Action 和 Model(DynaActionForm)

1.在 src/org/appfuse/web 下新建一个文件 UserAction.java。这个扩展了 DispatchAction，你可以花几分钟，在这个类中，创建 CRUD 方法。

package org.appfuse.web;

public class UserAction extends DispatchAction {

private static Log log = LogFactory.getLog(UserAction.class);

public ActionForward execute(ActionMapping mapping, ActionForm form,

HttpServletRequest request,

HttpServletResponse response) throws Exception{

request.getSession().setAttribute("test", "succeeded!");

log.debug("looking up userId: " + request.getParameter("id"));

return mapping.findForward("success");

} }

2.为了配置 Struts,使”/user”这个请求路径代表其它。在 web/WEB-INF/struts- config.xml 中加入一个 action-mapping。打开文件加入：

</action>

3.执行命令 ant test -Dtestcase=UserAction ，你会看到友好的“BUILD SUCCESSFUL” 信息。

4.在 struts-config.xml 中添加 form-bean 定义。对于 Struts ActionForm,使用 DynaActionForm,这是一个 javabean，可以从 XML 定义中动态的创建。

<form-bean name="userForm" type="org.apache.struts.action.DynaActionForm">

<form-property name="user" type="org.appfuse.model.User"/>

</form-bean>

这里没有使用具体的 ActionForm,因为只使用一个 User 对象的包装器。理想情况下，

你可以 User 对象，但会失去 Struts 环境下的一些特性：验证属性(validate

properties)，checkbox 复位(reset checkboxs)。后面，将演示用 Spring 怎幺会更加简单，

(28)

它可以让你在 web 层使用 User 对象。

5.修改 action 定义,在 request 中使用这个 form。

<action path="/user" type="org.appfuse.web.UserAction" name="userForm"

scope="request">

</action>

6.修改 UserActionTest，测试不同的 CRUD 方法。

public class UserActionTest extends MockStrutsTestCase { public UserActionTest(String testName) {

super(testName);

}

// Adding a new user is required between tests because HSQL creates // an in-memory database that goes away during tests.

public void addUser() { setRequestPathInfo("/user");

addRequestParameter("method", "save");

addRequestParameter("user.firstName", "Juergen");

addRequestParameter("user.lastName", "Hoeller");

actionPerform();

verifyForward("list");

}

public void testAddAndEdit() { addUser();

// edit newly added user

addRequestParameter("method", "edit");

addRequestParameter("id", "1");

actionPerform();

verifyForward("edit");

}

public void testAddAndDelete() { addUser();

(29)

// delete new user

setRequestPathInfo("/user");

addRequestParameter("method", "delete");

addRequestParameter("user.id", "1");

actionPerform();

}

public void testList() { addUser();

setRequestPathInfo("/user");

addRequestParameter("method", "list");

actionPerform();

List users = (List) getRequest().getAttribute("users");

assertNotNull(users);

assertTrue(users.size() == 1);

} }

7.修改 UserAction，这样测试程序才能通过，并能处理(客户端)请求。最简单的方法是添加 edit,save 和 delete 方法，请确保你事先已经删除了 execute 方法。下面是修改过的 UserAction.java 文件。

public class UserAction extends DispatchAction {

private static Log log = LogFactory.getLog(UserAction.class);

private UserManager mgr = null;

public void setUserManager(UserManager userManager) { this.mgr = userManager;

}

public ActionForward delete(ActionMapping mapping, ActionForm form,

(30)

HttpServletResponse response) throws Exception{

log.debug("entering 'delete' method...");

}

mgr.removeUser(request.getParameter("user.id"));

ActionMessages messages = new ActionMessages();

messages.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage ("user.deleted"));

saveMessages(request, messages);

return list(mapping, form, request, response);

}

public ActionForward edit(ActionMapping mapping, ActionForm form,

HttpServletResponse response) throws Exception { if (log.isDebugEnabled()) {

log.debug("entering 'edit' method...");

}

DynaActionForm userForm = (DynaActionForm) form;

String userId = request.getParameter("id");

// null userId indicates an add

if (userId != null) {

User user = mgr.getUser(userId);

if (user == null) {

ActionMessages errors = new ActionMessages();

errors.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage ("user.missing"));

saveErrors(request, errors);

return mapping.findForward("list");

}

userForm.set("user", user);

}

(31)

return mapping.findForward("edit");

}

public ActionForward list(ActionMapping mapping, ActionForm form,

log.debug("entering 'list' method...");

}

request.setAttribute("users", mgr.getUsers());

return mapping.findForward("list");

}

public ActionForward save(ActionMapping mapping, ActionForm form,

log.debug("entering 'save' method...");

}

mgr.saveUser((User)userForm.get("user"));

ActionMessages messages = new ActionMessages();

messages.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage ("user.saved"));

saveMessages(request, messages);

return list(mapping, form, request, response);

} }

接下来，你可以修改这个类的 CRUD 方法。

8.修改 struts-config.xml，使用 ContextLoaderPlugin 来配置 Spring 的 UserManager 设置。要配置 ContextLoaderPlugin,把下面内容添加到你的 struts-config.xml 中。

<plug-in className= org.springframework.web.struts.ContextLoaderPlugIn >

<set-property property= contextConfigLocation value= /WEB-

(32)

INF/applicationContext.xml, /WEB-INF/action-servlet.xml />

</plug-in>

默认情况下这个插件会载入 action-servlet.xml 文件。要让 Test Action 知道你的 Manager，必须配置这个插件，如同载入 applicationContext。

9.对每个使用 Spring 的 action,定义一个 type=

org.springframework.web.struts.DelegatingActionProxy 的 action-mapping,为每个 Spring action 声明一个配对的 Spring bean。这样修改一下你的 action mapping 就能使用这个新类。

10.为 DispatchAction 修改 action mapping。

为了让 DispatchAction 运行，在 mapping 中添加参数 parameter= “method” , 它表示(在一个 URL 或是隐藏字段 hidden field)要调用的方法，同时转向(forwards)edit 和 list forwards(参考能进行 CRUD 操作的 UserAction 类).

<action path="/user"

type="org.springframework.web.struts.DelegatingActionProxy" name="userForm"

scope="request" parameter="method">

</action>

确保 web 目录下已经建好 userList.jsp 和 userForm.jsp 两个文件。暂时不必在文件中写入内容。

11.作为插件的一部分，配置 Spring,将/user bean 设置成“UserManager”。在 we/WEB-INF/action-servlet.xml 中添加以下定义。

</property>

</bean>

定义中，使用 singleton= false 。这样就为每个请求，新建一个 Action，减少线程安全的 Action 需求。不管是 Manager 还是 DAO 都有成员变量，可能不需要这些属性(默认 singleton= true )。

12.在 message.properties 上配置资源绑定。

在 userAction 类中，在完成一些操作后，会显示“成功”或是“错误”页面，这些信息的键可以存放在这个应用的 ResourceBundle(或 messages.properties 文件中)。特别是:

(33)

● user.saved

● user.missing

● user.deleted

把这些键存入 web/WEB-INF/下的 messages.properties 文件中。例如：

user.saved=User has been saved successfully.

user.missing=No user found with this id.

user.deleted=User successfully deleted.

这个文件通过 struts-config.xml 中的<message-resources>元素进行加载。

<message-resources parameter="messages"/>

运行 ant test -Dtestcase=UserAction. 输出结果如下：

(34)

填充 JSP 文件，这样可以通过浏览器来进行 CRUD 操作

1.在你的 jsp 文件(userFrom.jsp 和 userList.jsp)中添加代码，这样它们可以表示 actions 的结果。如果还事先准备，在 web 目录下建一个文件 userList.jsp。添加一些代码你就可以看到数据库中所有的用户资料。在下面代码中，第一行包含(include)了一个文件 taglibs.jsp。这个文件包含了应用所有 JSP Tag Library 的声明。大部分是 Struts

Tag,JSTL 和 SiteMesh(用来美化 JSP 页面)。

<%@ include file="/taglibs.jsp"%>

<title>MyUsers ~ User List</title>

<thead>

<tr>

<th>First Name</th>

</tr>

</thead>

<tbody>

<c:forEach var="user" items="${users}" varStatus="status">

<c:choose>

<c:when test="${status.count % 2 == 0}">

</c:when>

<c:otherwise>

</c:otherwise>

</c:choose>

<td>${user.firstName}</td>

<td>${user.lastName}</td>

</tr>

</c:forEach>

</tbody>

</table>

(35)

你可以有一行“标题头”(headings)(在<thead>中)。JSTL 的 <c:forEach>进行结果迭代，显示所有的用户。

2.向数据库添加一些数据，你就会看到一些真实(actual)的用户(users)。你可以选择一种方法，手工添加，使用 ant browse,或是在 build.xml 中添加如下的 target：

<sql driver="org.hsqldb.jdbcDriver" url="jdbc:hsqldb:db/appfuse"

userid="sa" password="">

INSERT INTO app_user (id, first_name, last_name) values (5, 'Julie', 'Raible');

INSERT INTO app_user (id, first_name, last_name) values (6, 'Abbie', 'Raible');

</sql>

</target>

警告:为了使内置的 HSQLDB 正常工作，从能运行 ant 的目录下启动 tomcat。在 Unix/Linux 键入 $CATALINA_HOME/bin/startup.sh ，在 win 上 %CATALINA_HOME%

\bin\startup.bat 。

(36)

通过浏览器验证 JSP 的功能

1.有了这个 JSP 文件和里面的样例数据，就可以通过浏览器来查看这个页面。运行 ant deploy reload,转到地址 http://localhost:8080/myusers/user.do?method=list。出现以下画面：

2.这个样例中，缺少国际化的页面标题头，和列标题头(column headings)。在 web/WEB-INF/classes 中 messages.properties 中加入一些键：

user.id=User Id

user.firstName=First Name user.lastName=Last Name

修改过的国际化的标题头如下：

<thead>

<tr>

</tr>

</thead>

注意同样可以使用 JSTL 的<fmt:message key= ... >标签。如果想为表添加排序和分

(37)

布功能，可以使用 Display Tag (http://displaytag.sf.net)。下面是使用这个标签的一个样例：

<display:table name="users" pagesize="10" styleClass="list"

requestURI="user.do?method=list">

<display:column property="id" paramId="id" paramProperty="id"

href="user.do?method=edit" sort="true"/>

<display:column property="firstName" sort="true"/>

<display:column property="lastName" sort="true"/>

</display:table>

请参考 display tag 文档中有关的列标题头国际化的部分。

3.你已经建好了显示(list),创建 form 就可以添加/编辑(add/edit)数据。如果事先没有准备，可以在 web 目录下新建一个 userForm.jsp 文件。向文件中添加以下代码：

<%@ include file="/taglibs.jsp"%>

<title>MyUsers ~ User Details</title>

<p>Please fill in user's information below:</p>

<html:form action="/user" focus="user.firstName">

<html:hidden property="user.id"/>

<table>

<tr>

</tr>

<tr>

</tr>

<tr>

<c:if test="${not empty param.id}">

<html:submit styleClass="button" onclick="this.form.method.value='delete'">

Delete</html:submit>

</c:if>

</td>

(38)

</table>

</html:form>

注意：如果你正在开发一个国际化的应用，把上面的信息和按钮标签替换成

<bean:message> 或是 <fmt:message> 标签。这是一个很好的练习。对于信息 message,建议把 key 名称写成”pageName.message”(例如：userForm.message )的形式，按钮名字写成“button.name”(例如 button.save)。

4.运行 ant deploy ，通过浏览器页面的 user form 来进行 CRUD 操作。

最后大部分 web 应用都需要验证。下一节中，配置 struts validator，要求用户的 last name 是必填的。

(39)

用 commons Validator 添加验证

为了在 Struts 中使用验证，执行以下几步：

1.在 struts-config.xml 中添加 ValidatorPlugin。

2.创建 validation.xml，指定 lastName 为必填字段。

3.仅为 save()方法设置验证(validation)。

4.在 message.properties 中添加 validation errors。

在 struts-config.xml 中添加 ValidatorPlugin

配置 Validatorp plugins,添加以下片断到 struts-config.xml(紧接着 Spring plugin):

<plug-in className="org.apache.struts.validator.ValidatorPlugIn">

<set-property property="pathnames" value="/WEB-INF/validator- rules.xml, /WEB-INF/validation.xml"/>

</plug-in>

从这里你可以看出，Validator 会查找 WEB-INF 下的两个文件 validator-ruls.xml 和 validation.xml。第一个文件，validator-rules.xml,是一个标准文件，作为 Struts 的一部分发布，它定义了所有可用的验证器(validators)，功能和客户端的 javascript 类似。

第二个文件，包含针对每个 form 的验证规则。

创建 validation.xml，指定 lastName 为必填字段

validation.xml 文件中包含很多 DTD 定义的标准元素。但你只需要如下所示的<form>

和<field>,更多信息请参阅 Validator 的文档。在 web/WEB-INF/validation.xml 中的 form- validation 标签之间添加 form-set 元素。

</form>

</formset>

把 DynaActionForm 改为 DynaValidatorForm

把 struts-config.xml 中的 DynaActionForm 改为 DynaValidatorForm。

(40)

<form-bean name="userForm"

type="org.apache.struts.validator.DynaValidatorForm">

为 save()方法设置验证(validation)

使用 Struts DispatchAction 弊端是，验证会在映射层(mapping level)激活。为了在 list 和 edit 页面关闭验证。你必须单独建一个”validate=false”的映射。例如，

AppFuse 的 UserAction 有两个映射：”/editUser” 和”/listUser”。然而有一个更简单的方法，可以减少xml，只是多了一些 java 代码。

1.在/user 映射中，添加 validate=false 。

2.修改 UserAction 中的 save()方法，调用 form.validate()方法，如果发现错误，返回编辑页面。

log.debug("entering 'save' method...");

}

// run validation rules on this form

ActionMessages errors = form.validate(mapping, request);

if (!errors.isEmpty()) { saveErrors(request, errors);

return mapping.findForward("edit");

}

当dispatchAction 运行时，与附带一个属性的两个映射相比，这样更加简洁。但用两个

映射也有一些优点：

● 验证失败时，可以指定转向”input”属性。

● 在映射中可以添加“role”属性，可以指定谁有访问权限。例如，任何人都可以看到

编辑(edit)页面，但只有管理员可以保存(save)。

运行ant deploy 重新载入(reload)，尝试添加一个新用户，不要填写 lastName。你会看到

一个验证错误，表明lastName 是必填字段，如下所示：

(41)

Struts Validator 的另一种比较好的特性是客户端验证(client-side validation)。

4.在 form 标签(web/userForm.jsp)中添加”onsubmit”属性，在 form 末尾添加

<html:javascript>。

<html:form action="/user" focus="user.firstName" onsubmit="return validateUserForm(this)">

...

</html:form>

<html:javascript formName="userForm"/>

现在如果运行 ant deploy,试图保存一个 lastname 为空的用户，会弹出一个

JavaScript 提示：“Last Name is required”。这里有一个问题，这个带 JavaScript 的 form 把 validator 的 JavaScript 功能都载入了页面。再好的方法是，从外部文件导入 Javascript。参见第 5 章。

恭喜你！你已经开发一个 web 应用，它包含数据库交互，验证实现，成功信息和错误信息的显示。第 4 章，将会把这个转向 Spring 框架。第 5 章中，会添加异常处理，文件上传，邮件发送等特性。第 6 章会看一下 JSP 的替代品，在第 7 章，会添加 DAO 的不同实现，

包括 iBATIS, JDO 和 Spring 的 JDBC。