人在江湖

转载自 http://tech.it168.com/j/2007-10-19/200710190919953.shtml

在单元测试时，我们尽量在屏蔽模块间相互干扰的情况下，重点关注模块内部逻辑的正确性。而集成测试则是在将模块整合在一起后进行的测试，它的目的在于发现一些模块间整合的问题。有些功能很难通过模拟对象进行模拟，相反它们往往只能在真实模块整合后，才能真正运行起来，如事务管理就是其中比较典型的例子。
按照Spring的推荐（原话：You should not normally use the Spring container for unit tests: simply populate your POJOs in plain JUnit tests!），在单元测试时，你不应该依赖于Spring容器。换言之，你不应该在单元测试时启动ApplicatonContext并从中获取Bean，相反你应该通过模拟对象完成单元测试。而集成测试的前提则是事先装配好模块和模块之间的关联类，如将DAO层真实的UserDao和LoginLogDao装配到UserServiceImpl再进行测试。具体装配工作是在Spring配置文件中完成的，因此在一般情况下，集成测试需要启动Spring容器，你可以在测试类中简单地从Spring容器中取出目标Bean进行测试。
需要测试的业务接口
假设我们的应用中拥有一个UserService业务层接口，它拥有4个业务方法，其代码如下所示：
代码清单1 UserServie接口

   1: package com.baobaotao.service;
   2: import com.baobaotao.domain.User;
   3: import org.springframework.transaction.annotation.Transactional;
   4: @Transactional
   5: public interface UserService {
   6: boolean hasMatchUser(String userName,String password);
   7: User findUserByUserName(String userName);
   8: void loginSuccess(User user);
   9: void registerUser(User user);
  10: }

我们通过UserServiceImpl对UserService提供了实现：
代码清单2 UserServiceImpl实现UserService接口

   1: package com.baobaotao.service;
   2: import com.baobaotao.dao.LoginLogDao;
   3: import com.baobaotao.dao.UserDao;
   4: import com.baobaotao.domain.LoginLog;
   5: import com.baobaotao.domain.User;
   6: public class UserServiceImpl implements UserService {
   7: private UserDao userDao;
   8: private LoginLogDao loginLogDao;
   9: public boolean hasMatchUser(String userName, String password) {
  10: int matchCount =userDao.getMatchCount(userName, password);
  11: return matchCount > 0;
  12: }
  13: public User findUserByUserName(String userName) {
  14: return userDao.findUserByUserName(userName);
  15: }
  16: public void loginSuccess(User user) {
  17: user.setCredits( 5 + user.getCredits());
  18: LoginLog loginLog = new LoginLog();
  19: loginLog.setUserId(user.getUserId());
  20: loginLog.setIp(user.getLastIp());
  21: loginLog.setLoginDate(user.getLastVisit());
  22: userDao.updateLoginInfo(user);
  23: loginLogDao.insertLoginLog(loginLog);
  24: }
  25: public void setLoginLogDao(LoginLogDao loginLogDao) {
  26: this.loginLogDao = loginLogDao;
  27: }
  28: public void setUserDao(UserDao userDao) {
  29: this.userDao = userDao;
  30: }
  31: }

UserServiceImpl引用了两个DAO层的类（UserDao和LoginLogDao）共同实现UserService的接口，在UserServiceImpl开放使用之前，我们有必须对其进行集成测试，以保证实现逻辑的正确性。

使用传统的方式进行集成测试
下面，我们通过传统的方式为UserServiceImpl编写了一个集成测试用例，测试代码如下所示：
代码清单 3 TestUserService：UserService集成测试用例

   1: package com.baobaotao.service;

   2: …

   3: public class TestUserService extends TestCase {

   4: public ApplicationContext ctx = null; ①Spring容器引用

   5: private static String[] CONFIG_FILES = { ②Spring配置文件

   6: "baobaotao-dao.xml",

   7: "baobaotao-service.xml" };

   8: protected void setUp() throws Exception {③启动Spring容器

   9: ctx = new FileSystemXmlApplicationContext(CONFIG_FILES);

  10: }

  11: public void testHasMatchUser() { ④测试方法一

  12: ④-1从容器中获取Bean

  13: UserService userService = (UserService) ctx.getBean("userService");

  14: boolean b1 = userService.hasMatchUser("admin", "123456");

  15: boolean b2 = userService.hasMatchUser("admin", "1111");

  16: assertTrue(b1);

  17: assertTrue(!b2);

  18: }

  19: public void testAddLoginLog() {⑤测试方法二

  20: ⑤-1从容器中获取Bean

  21: UserService userService = (UserService) ctx.getBean("userService");

  22: User user = userService.findUserByUserName("admin");

  23: user.setUserId(1);

  24: user.setUserName("admin");

  25: user.setLastIp("192.168.12.7");

  26: user.setLastVisit(new Date());

  27: userService.loginSuccess(user);

  28: }

  29: …//省略其余的测试方法 

  30: } 

在这个测试用例中，我们使用了最原始的JUnit的TestCase进行集成测试，乍一看并没有多大的问题，但仔细分析一下，我们就可以总结出以下四点明显的不足：
1)导致多次Spring容器初始化问题：根据JUnit测试方法的调用流程（参见错误！未找到引用源。小节的描述），每执行一个测试方法都会创建一个TestUserService实例并调用setUp()方法。由于我们在setUp()方法中初始化Spring容器，这意味着TestUserService有多少个测试方法，Spring容器就会被重复初始化多少次。虽然初始化Spring容器的速度并不会太慢，但由于可能会在Sprnig容器初始化时执行加载Hibernate映射文件等耗时的操作，如果每执行一个测试方法都必须重复初始化Spring容器，则对测试性能的影响是不容忽视的；
2)需要使用硬编码方式手工获取Bean：在④-1和⑤-1处，我们通过ctx.getBean()方法从Spring容器中获取需要测试的目标Bean，并且还要进行强制类型转换的造型操作。这种乏味的操作迷漫在测试用例的代码中，让人觉得繁琐不堪；
3)数据库现场容易遭受破坏：⑤处的测试方法会对数据库记录进行插入操作，虽然是针对开发数据库进行操作，但如果数据操作的影响是持久的，可能会影响到后面的测试行为。举个例子，你在测试方法中插入一条ID为1的User记录，第一次运行不会有问题，第二次运行时，就会因为主键冲突而导致测试用例失败。所以应该既能够完成功能逻辑检查，又能够在测试完成后恢复现场，不会留下“后遗症”；
4)没有对数据操作正确性进行检查：⑤处我们向登录日志表插入了一条成功登录日志，可是我们却没有对t_login_log表中是否确实添加了一条记录进行检查。原来我们的方式是打开数据库，肉眼观察是否插入了相应的记录，但这严重违背了自动测试的原则。试想，你在测试包括成千上万个数据操作行为的程序时，如何用肉眼进行检查？
既然使用传统方式对Spring应用进行集成测试存在这么多不足，Spring责无旁贷地担当起革新之任。它通过扩展JUnit框架提供了一套专门测试Spring应用的有力工具。借助Spring集成测试工具的帮助，以上所罗列的种种问题将冰消雪融、云开雾散。

Spring在org.springframework.test包中为测试提供了几个有用的类，它们都是JUnit TestCase的子类。通过层层扩展，不断丰富测试的功能，我们可以通过下图了解这些类的继承关系：

图 1 Spring测试工具类
下面，我们来逐个了解这棵承继类树中每个节点测试类的功用，第一个要认识的是直接扩展于TestCase的ConditionalTestCase测试类。
ConditionalTestCase
如果你直接通过扩展TestCase创建测试用例，则所有带test前缀的测试方法都会被毫无例外地执行。而ConditionalTestCase可以让你在某些情况下，有选择地关闭掉一些测试方法，不让他们在测试用例中执行。这给开发者带来了很大的灵活性，因为他们可以在某次测试中关闭掉一些测试方法，而仅运行当前特别关注的测试方法，将问题域聚集到一定范围内。
如果你要关闭某个测试方法行，仅需实现ConditionalTestCase的 isDisabledInThisEnvironment(String testMethodName)方法就可以了，ConditionalTestCase在运行每一个测试方法前会根据isDisabledInThisEnvironment()方法判断是简单放弃目标方法的运行，还是按正常方式执行之。该方法默认情况下对所有的测试方法都返回false，也即执行所有的测试方法。让我们来看一个具体例子：
代码清单 4 ConditionalTest1：有条件执行测试方法

   1: package com.baobaotao.test;

   2: import org.springframework.test.ConditionalTestCase;

   3: public class ConditionalTest1 extends ConditionalTestCase {

   4: ①被忽略不执行的测试方法

   5: private static String[] IGNORED_METHODS = {"testMethod1","testMethod3"};

   6: @Override

   7: protected boolean isDisabledInThisEnvironment(String testMethodName) {②所有在

   8: for (String method : IGNORED_METHODS) { IGNORED_METHODS数组中

   9: if (method.equals(testMethodName)) { 的方法都忽略执行。

  10: return true;

  11: }

  12: }

  13: return false;

  14: }

  15: public void testMethod1(){ ③不执行

  16: System.out.println("method1");

  17: }

  18: public void testMethod2(){ ④执行

  19: System.out.println("method2");

  20: }

  21: public void testMethod3(){ ⑤不执行

  22: System.out.println("method3");

  23: }

  24: } 

如果我们直接承继JUnit的TestCase，③、④及⑤处的三个测试方法都会被执行，但现在我们通过继承ConditionalTestCase编写测试类，并覆盖了isDisabledInThisEnvironment()方法，当测试方法名位于IGNORED_METHODS数组中时，测试方法就被旁路掉了。因此当运行ConditionalTest1时，你会发现只有④处的testMethod2()测试方法得到了执行，其它两个测试方法看起来也被成功执行，只不过会程序日志会给出报告，告诉你哪些测试方法是真正被执行，而哪些方法被“伪执行”的。
ConditionalTestCase其实可用于任何程序的单元测试中，它本身并没有和Spring容器有任何关联，它仅添加了一个按条件执行测试方法的功能。
AbstractSpringContextTests
AbstractSpringContextTests扩展于ConditionalTestCase，它维护了一个static类型的缓存器（HashMap），它使用键保存Spring ApplicationContext实例，这意味着Spring ApplicationContext是JVM级的，不同测试用例、不同测试方法都可以共享这个实例。也就是说，在运行多个测试用例和测试方法时，Spring容器仅需要实例化一次就可以了，极大地提高了基于Spring容器测试程序的运行效率。Spring通过这个测试帮助类解决了前面我们所指出的第1)个问题。
AbstractSingleSpringContextTests

AbstractSingleSpringContextTests继承于AbstractSpringContextTests，它通过一些方法让你方便地指定Spring配置文件所在位置：
 String[] getConfigLocations()：该方法允许你在指定Spring配置文件时使用资源类型前缀，这些资源类型前缀包括：classpath:、file:。以类似于“com/baobaotao/beans.xml”形式指定的资源被当成类路径资源处理；
 String[] getConfigPaths()：以“/”开头的地址被当成类路径处理，如“/com/baobaotao/beans.xml”，而未以“/”开头的地址被当成相对于测试类所在包的文件路径，如“beans.xml”表示配置文件在测试类所在类包的目录下；
 String getConfigPath()：和getConfigPaths()类似，在仅需指定一个配置文件中使用。
以上三个方法，它们的优先级和我们介绍的先后顺序对应，也就是说，当你在子类中覆盖了getConfigLocations()方法后，其它两个方法就没有意义了。所以你仅需选择三者当中适合的方法进行覆盖，而没有必要同时覆盖多个方法。
AbstractSingleSpringContextTests将根据这些方法指定的Spring配置文件初始化Spring容器，然后将Spring容器引用添加到static缓存中。并通过getApplicationContext()向子类开放ApplicationContext的引用。
一般情况下，所有的测试类和测试方法都可以共享这个Spring容器直到测试完结，不过在某些极端情况下，测试方法可能会对Spring容器进行改动（比如通过程序改变Bean的配置定义），如果这种改变对于其它测试方法来说是有干扰的，这就相当于“弄脏”了作为测试现场的Spring容器，因此在下一个测试方法执行前必须“抹除”这个改变。你可以简单地在会“弄脏”Spring容器的测试方法中添加setDirty()方法向AbstractSingleSpringContextTests报告这一行为，这样在下一个测试方法执行前，AbstractSingleSpringContextTests就会重新加载Spring容器以修补被“弄脏”的部分。
虽然你可以直接继承AbstractSpringContextTests或AbstractSingleSpringContextTests创建自己的集成测试用例，不过你大可不必如此着急。Spring已经提供了几个功能齐全、实践性更强的子类，让我们继续探索Spring集成测试工具类的精彩篇章吧。

一般集成测试
应该说，Spring通过AbstractSpringContextTests或AbstractSingleSpringContextTests准备好了集成测试的一些基础设施，在建筑学上，这叫夯实地基，而AbstractDependencyInjectionSpringContextTests是在此地基之上建起的第一幢楼房。
AbstractDependencyInjectionSpringContextTests所新添的主要功能是其子类的属性能被Spring容器中的Bean自动装配，你无需手工通过ApplicationContext#getBean()从容器中获取目标Bean自行装配。它很好回答了前面我们所指出第2)问题，下面我们通过实例进行学习：

   1: package com.baobaotao.test;
   2: import org.springframework.test.AbstractDependencyInjectionSpringContextTests;
   3: import com.baobaotao.service.UserService;
   4: public class DependencyInjectionCtxTest
   5: extends AbstractDependencyInjectionSpringContextTests {
   6: private UserService userService;
   7: public void setUserService(UserService userService) {①该属性设置方法会被自动调动
   8: this.userService = userService;
   9: }
  10: @Override
  11: protected String[] getConfigLocations() { ②指定Spring配置文件所在位置
  12: return new String[]{"baobaotao-service.xml","baobaotao-dao.xml"};
  13: }
  14: public void testHasMatchUser(){ ③测试方法
  15: boolean match = userService.hasMatchUser("tom","123456");
  16: assertEquals(true, match);
  17: }
  18: …
  19: } 
代码清单 5 DependencyInjectionCtxTest
在②处，我们指定了Spring配置文件所在的位置，AbstractDependencyInjectionSpringContextTests将使用这些配置文件初始化好Spring容器，并将它们保存于static的缓存中。然后马上着手根据类型匹配机制（byType），
自动将Spring容器中匹配测试类属性的Bean通过Setter注入到测试类中。为了方便说明这一重要的特性，我们先看一下baobaotao-service.xml的内容： 

   1: <beans>

   2: <tx:annotation-driven/>

   3: ①按类型匹配于DependencyInjectionCtxTest的userService属性

   4: <bean id="userService" class="com.baobaotao.service.UserServiceImpl">

   5: <property name="userDao" ref="userDao"/>

   6: <property name="loginLogDao" ref="loginLogDao"/>

   7: </bean>

   8: …

   9: </beans> 

根据baobaotao-service.xml配置文件的内容，我们知道Spring容器中有一个UserService Bean，AbstractDependencyInjectionSpringContextTests探测到Spring容器中存在一个匹配于userService属性的Bean后，就将其注入到DependencyInjectionCtxTest的userService属性中。userService是这个集成测试类的测试固件，因此我们说AbstractDependencyInjectionSpringContextTests可以自己装配测试固件。

解决自动装配问题
如果Spring容器中拥有多个匹配UserService类型的Bean，由于Spring没有足够的信息做出取舍决策，因此会抛出UnsatisfiedDependencyException异常。假设我们采用以下传统的事务管理的配置方式对UserService进行配置，按类型匹配的自动装配机制就会引发问题：
①用于被代理的目标Bean，按类型匹配于UserService

   1: <bean id="userServiceTarget" class="com.baobaotao.service.UserServiceImpl">

   2: <property name="userDao" ref="userDao" />

   3: <property name="loginLogDao" ref="loginLogDao"></property>

   4: </bean> 

②通过事务代理工厂为UserServiceImpl创建的代理Bean，也按匹配于UserService

   1: <bean id="userService"

   2: class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

   3: <property name="transactionManager" ref="transactionManager" />

   4: <property name="target" ref="userServiceTarget" />

   5: <property name="transactionAttributes">

   6: …

   7: </property>

   8: </bean> 

由于①处和②处的Bean都按类型匹配于UserService，在对DependencyInjectionCtxTest的userService属性进行自动装配将会引发问题。有两种针对该问题的解决办法：
 调整配置文件，使按类型匹配于UserService的Bean仅有一个，具体有以下两个方法：
 将①处的Bean作为②处的内部Bean进行装配；
 使用基于注解驱动的事务管理配置机制，这样就无需在配置文件中定义两个UserService的Bean了。关于注解驱动事务管理配置的详细信息，请参见9.6小节的内容。
 改变DependencyInjectionCtxTest的自动装配机制：Spring默认使用byType类型的自动装配机制，但它允许你通过setAutowireMode()的方法改变默认自动装配的机制，比如你可以调用setAutowireMode(AUTOWIRE_BY_NAME)方法启用按名称匹配的自动装配机制。AbstractDependencyInjectionSpringContextTests定义了三个代表自动装配机制类型的常量，分别说明如下：
 AUTOWIRE_BY_TYPE：按类型匹配的方式进行自动装配，这个默认的机制；
 AUTOWIRE_BY_NAME：按名字匹配的方式进行自动装配
 AUTOWIRE_NO：不使用自动装配机制，这意味着你需要手工调用getBean()进行装配。
现在我们解决了在自动装配时，因Spring容器中存在多个匹配Bean而导致的问题，接下来让我们考察另一个自动装配的问题。
依赖检查
假设我们在DependencyInjectionCtxTest添加一个User类型的属性并提供Setter方法，而Spring容器中没有匹配该属性的Bean：

   1: package com.baobaotao.test;

   2: …

   3: import com.baobaotao.domain.User;

   4: public class DependencyInjectionCtxTest extends AbstractDependencyInjectionSpringContextTests {

   5: private User user;

   6: public void setUser(User user) {

   7: this.user = user;

   8: }

   9: …

  10: } 

猜想一下重新运行DependencyInjectionCtxTest将会发生什么情况呢？答案可能让你失望：UnsatisfiedDependencyException再次象黑幕一样降临。在默认情况下， AbstractDependencyInjectionSpringContextTests要求所有属性都能在Spring容器中找到对应Bean，否则抛出异常。
仔细思考一下，这种运行机制并非没有道理，因为既然你已经提供了Setter方法，就相当于给出了这样的暗示信息：“这个属性测试类自身创建不了，必须由外部提供”。而在使用自动装配机制的情况下，测试类属性自动从Spring容器中注入匹配的属性，一般情况下不会手工去调用Setter方法准备属性。
如果你出于一些特殊的理由，希望在采用自动装配的情况下，如果有属性未得到装配也不在乎，那么你可以在测试类构造函数中调用setDependencyCheck(false)方法达到目的：

   1: package com.baobaotao.test;

   2: …

   3: public class DependencyInjectionCtxTest extends AbstractDependencyInjectionSpringContextTests {

   4: public DependencyInjectionCtxTest(){

   5: setDependencyCheck(false); ①告知不进行属性依赖性检查

   6: }

   7: …

   8: } 

这个AbstractDependencyInjectionSpringContextTests就不会对测试类有些属性找不到匹配Bean而抛出异常了。

在不提供Setter方法的情况下自动注入
大多数IDE都提供了为属性变量自动生成Setter方法的操作，因此客观地说，为属性编写一个Setter方法的工作根本不值一提。如果你觉得众多的Setter方法影响了视觉感观，但又希望享受测试类属性自动装配的好处，Spring也不会让你失望的。你需要做的是以下两步的工作：
1) 将需要自动装配的属性变量声明为protected；
2) 在测试类构造函数中调用setPopulateProtectedVariables(true)方法。

   1: package com.baobaotao.test;

   2: …

   3: public class DependencyInjectionCtxTest extends AbstractDependencyInjectionSpringContextTests {

   4: protected UserService userService; ①将属性声明为protected

   5: // public void setUserService(UserService userService) { ②大胆将Setter方法移除掉

   6: // this.userService = userService;

   7: // } 

   8: public DependencyInjectionCtxTest(){

   9: setDependencyCheck(false);

  10: setPopulateProtectedVariables(true); ③启用直接对属性变量进行注释的机制

  11: }

  12: …

  13: } 

将属性声明为protected后并通过setPopulateProtectedVariables(true)启用对属性变量直接注入的机制（启用反射机制注入），你就可以避免为属性变量编写对应的Setter方法了。
提示 属性如果声明为public，虽然你也调用了setPopulateProtectedVariables(true)方法，属性变量依然不会被自动注入。所以这种机制仅限于protected的属性变量。
方便地恢复测试数据库现场
我们现在已经可以通过AbstractDependencyInjectionSpringContextTests的属性自动装配机制方便地建立起测试固件，省却手工调用getBean()自行准备测试固件的烦恼。当我们对UserService的hasMatchUser()和findUserByUserName()方法进行测试时，不会有任何问题，因为这两个方法仅对数据库执行读操作。但UserService以下两个接口方法会对数据库执行更改操作：

void loginSuccess(User user);
void registerUser(User user); 

当我们对这两个接口方法进行测试时，它们将会在数据库中产生持久化数据。考虑对registerUser(User user)方法进行测试时，我们可能编写如下所示的测试方法：

   1: public void testRegisterUser(){

   2: User user = new User();

   3: user.setUserId(2);

   4: user.setUserName("john");

   5: user.setPassword("123456");

   6: userService.registerUser(user);

   7: } 

当第一次成功运行testRegisterUser()测试方法时，将在数据库中产生一条主键为2的记录，如何第二次重新运行testRegisterUser()测试方法其结果将不言自明：因主键冲突导致测试方法执行失败，最终报告测试用例没有通过。在这种情况下，测试用例未通过并不是因为UserServiceImpl#registerUser(User user)存在逻辑错误，而是因为测试方法的积累效应导致外在设施的现场发生变化而引起的问题。
为了防止这种问题，测试用例必须在保证不对数据库状态产生持久化变化的情况下，对目标类的数据操作逻辑正确性进行检测。乍一听这一要求有点貌似于“既想马儿跑，又想马儿不吃草”一样充满悖论，实则不然。只要我们让测试方法不提交事务，在测试完后自动回滚事务，就皆大欢喜了。

让测试方法自动拥有回滚能力
AbstractTransactionalSpringContextTests专为解决以上问题而生，也就是说前面我们所提及的第3)个问题在此得到了回答。只要继承该类创建测试用例，在默认情况下，测试方法中所包含的事务性数据操作都会在测试方法返回前被回滚。由于事务回滚操作发生在测试方法返回前的点上，所以你可以象往常一样在测试方法体中对数据操作的正确性进行校验。

   1: package com.baobaotao.service;
   2: import org.springframework.test.AbstractTransactionalSpringContextTests;
   3: import com.baobaotao.domain.User;
   4: public class UserServiceIntegrateTest extends AbstractTransactionalSpringContextTests {
   5: private UserService userService;
   6: public void setUserService(UserService userService) {
   7: this.userService = userService;
   8: }
   9: @Override
  10: protected String[] getConfigLocations() {
  11: return new String[]{"baobaotao-service.xml", "baobaotao-dao.xml"};
  12: }
  13: public void testRegisterUser(){ ①测试方法中的数据操作将在方法返回前被回滚，不会对数据库
  14: User user = new User(); 产生永久性数据操作，第二次运行该测试方法时，依旧可以
  15: user.setUserId(2); 成功运行。
  16: user.setUserName("john");
  17: user.setPassword("123456");
  18: userService.registerUser(user);
  19: User user1 = userService.findUserByUserName("john"); ②对数据操作进行
  20: assertEquals(user.getUserId(), user1.getUserId()); 正确性检验
  21: }
  22: } 
代码清单 6 UserServiceIntegrateTest：
如果testRegisterUser()是直接继承于AbstractDependencyInjectionSpringContextTests类的测试方法，则重复运行该测试方法就会发生数据冲突问题。但因为它位于继承于
AbstractTransactionalSpringContextTests的测试用例类中，测试方法中对数据库的操作会被正确回滚，所以重复运行不会有任何问题。 
如果你确实希望测试方法中对数据库的操作持久生效而不是被回滚，Spring也可以满足你的要求，你仅需要在测试方法中添加setComplete()方法就可以了。 

   1: public void testRegisterUser(){

   2: …

   3: User user1 = userService.findUserByUserName("john");

   4: assertEquals(user.getUserId(), user1.getUserId());

   5: setComplete(); ①测试方法中的事务性数据操作将被提交

   6: } 

AbstractTransactionalSpringContextTests还拥有几个可用于初始化测试数据库，并在测试完成后清除测试数据的方法，分别介绍如下：
 onSetUpBeforeTransaction()/onTearDownAfterTransaction()：子类可以覆盖这两个方法，以便在事务性测试方法运行的前后执行一些数据库初始化的操作并在事务完成后清除之；
 onSetUpInTransaction()/onTearDownInTransaction()：这对方法和前面介绍的方法完成相同的功能，只不过它们是在测试方法的相同事务中执行的。
AbstractTransactionalSpringContextTests另外还提供了一组用于测试延迟数据加载的方法：endTransaction()/startNewTransaction()。我在测试Hibernate、JPA等允许延迟数据加载的应用时，如何模拟数据在Service层事务中被部分加载，当传递到Web层时重新打开事务完成延迟部分数据加载的测试场景呢？这两个方法即为此用途而生：你可以在测试方法中显式调用endTransaction()方法以模拟从Service层中获取部分数据后返回，尔后，再通过startNewTransaction()开启一个和原事务无关新事务——模拟在Web层中重新打开事务，接下来你就可以访问延迟加载的数据，看是否一切如期所料了。
在代码清单 6的②处，我们通过UserService#findUserByUserName()方法对前面registerUser(user)方法数据操作的正确性进行检验。应该说，我们非常幸运，因为在UserService中刚好存在一个可用于检测registerUser(user)数据操作正确性的方法。让我们考虑另外的一种情况：要是 UserService不存在这样的方法，我们该如何检测registerUser(user)数据操作结果的正确性呢？显然我们不能使用肉眼观察的方法，那难道为了验证数据操作正确性专门编写一个配合性的数据访问类不成？
通过JDBC访问数据库，检测数据操作正确性
正当我们“山重水复疑无路”的时候，让我们再往前走上一程，柳暗花明将倏忽而至
——AbstractTransactionalDataSourceSpringContextTests就是花开景明之所。该类继承于AbstractTransactionalSpringContextTests，它添加了一个JdbcTemplate，你可以借由此道快意直达数据库。它自动使用Spring容器中的数据源（DataSource）创建好一个JdbcTemplate实例并开放给子类使用。值得注意的是，如果你采用byName自动装配机制，数据源Bean的名称必须取名为“dataSource”。
让我们对UserServiceIntegrateTest进行改造，以便让其自动拥有访问数据库的设施（JdbcTemplate），并用灵活的方法访问数据库进行数据操作的检验，其代码如下所示：

代码清单 7 UserServiceIntegrateWithJdbcTest
   1: package com.baobaotao.service;
   2: import org.springframework.test.AbstractTransactionalDataSourceSpringContextTests;
   3: …
   4: public class UserServiceIntegrateWithJdbcTest
   5: extends AbstractTransactionalDataSourceSpringContextTests {①注意：继承类发生调整
   6: private UserService userService;
   7: public void setUserService(UserService userService) {
   8: this.userService = userService;
   9: }
  10: @Override
  11: protected String[] getConfigLocations() {
  12: return new String[]{"baobaotao-service.xml", "baobaotao-dao.xml"};
  13: }
  14: public void testRegisterUser(){
  15: User user = new User();
  16: user.setUserId(2);
  17: user.setUserName("john");
  18: user.setPassword("123456");
  19: userService.registerUser(user);
  20: String sqlStr = " SELECT user_id FROM t_user WHERE user_name ='john' ";
  21: int userId = jdbcTemplate.queryForInt(sqlStr); ①可以直接使用JdbcTemplate访问数据库了
  22: assertEquals(user.getUserId(), userId);
  23: setComplete();
  24: }
  25: }
jdbcTemplate是AbstractTransactionalDataSourceSpringContextTests类中定义的，子类可以直接使用它访问数据库。这样我们就可以灵活地访问数据库以检验目标测试方法的数据操作正确性。至此，我们终于毕其功于
一役于AbstractTransactionalDataSourceSpringContextTests，顺利解决前面我们中指出的最后问题。 只要你通过扩展AbstractTransactionalSpringContextTests及其子类创建测试用例，所有测试方法都会工作了
事务环境下。也就是说，即使某些测试方法不需要访问数据库，也会产生额外的事务管理开销，是否可以对测试方法启用事务管理的行为进行控制呢？此外，在一些情况下，除对目标方法逻辑运行的正确性进行检验外，我们还希望
对目标方法的运行性能进行测试：如当目标方法运行时间超过200毫秒时，则测试用例视为未通过。诸如此类的问题，我们目前学习到的知识还不能很好的应付。Spring 2.0新增了注解驱动的测试工具为我们指明了道路，你仅需要
通过简单为测试方法标注注解，我们刚才提出的“疑难”问题就可以迎刃而解了。
小结
本文我们讲述了使用Spring提供的一套测试工具对Spring应用程序进行集成测试所需的所有知识。 
Spring建议你不应该在单元测试时使用到Spring容器，你应该在集成测试时才使用到Spring容器。手工创建测试固件或者手工装配测试固件的工作都是单调乏味没有创意的工作，通过使用Spring为集成测试提供了帮助类，你就
可以享受测试固件自动装配的好处，将精力集中到目标类逻辑测试编写的工作上。 应该说大部分的Java应用都是Web应用，而大部分的Java Web应用都是数据库相关的应用，对数据库应用进行测试经常要考虑数据准备、数据库现
场恢复、灵活访问数据以验证数据操作正确性等等的问题。这些问题如果没有一个
很好的支持工具，将给编写测试用例造成挑战，幸好Spring都为我们搭建好满足这些需求的测试平台，你仅需要在此基础上编写特定的测试用例就可以了。