spring junit集成测试

最新推荐文章于 2024-04-17 14:36:38 发布

neyanbhbin

最新推荐文章于 2024-04-17 14:36:38 发布

阅读量532

点赞数

分类专栏： spring 文章标签： spring junit 单元测试

spring 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

利用spring来进行集成测试：
1、AbstractSpringContextTests类[1],该类全部方法是protected的，通常不使用这个类，而使用它的子类们。

2、AbstractDependencyInjectionSpringContextTests类[2]：继承于类[1]：名字N长的。如果仅仅使用Spring依赖注入功能，可以让测试用例继承该类。

3、AbstractTransactionalSpringContextTests类[3]:继承于类[2]，继承该类的测试用例在spring管理的事务中进行，测试完后对数据库的记录不会造成任何影响。你对数据库进行一些操作后，它会自动把数据库回滚，这样就保证了你的测试对于环境没有任何影响

4、AbstractTransactionalDataSourceSpringContextTests：继承于类[3]，功能更强大，用于测试持久层组件,看其源代码，有一行"protected JdbcTemplate jdbcTemplate;"，提供了一个JdbcTemplate的变量，通过该对象可以直接操作数据库。

[url]http://lighter.iteye.com/blog/41733[/url] 还提供了两个用spring来进行集成测试(对数据库操作进行测试)，业务测试(对业务层进行测试)的例子供下载。

***如何在你的TestCase Class里取得spring context (注意路径问题)？***

你的TestCase Class必须继承的是上述四个AbstractXXXSpringContextTests中的其中一个，那么就必须实现下面这个方法来取得spring context：

protected abstract String[] getConfigLocations();

例如：

public String[] getConfigLocations() {
String[] configLocations = { "applicationContext.xml","hibernate-context.xml" };
return configLocations;
}

请注意要加载的context xml file的路径问题：上述的代码是基于classpath，因此applicationContext.xml和hibernate- context.xml必须放在classpath里（方法一是把xml files放到WEB-INF/classes目录下，另一种方法就是在project properties里把xml files的路径加到classpath里）

那么如果你一定要把context xml files放到WEB-INF目录下，也是可以的，那么应该基于file(基于file的相对路径是相对于project root folder)，代码如下：

public String[] getConfigLocations() {
String[] configLocations = { "file:WebContent/WEB-INF/applicationContext.xml"};
return configLocations;
}

AbstractXXXSpringContextTests就会根据根据getConfigLocations方法返回的context xml位置的数组来加载并且对加载的Context提供缓存。这是非常重要的，因为如果你在从事一个大项目时，启动时间可能成为一个问题－－这不是Spring自身的开销，而是被Spring容器实例化的对象在实例化自身时所需要的时间。例如，一个包括50-100个Hibernate映射文件的项目可能需要10-20秒的时间来加载上述的映射文件，如果在运行每个测试fixture里的每个测试案例前都有这样的开销，将导致整个测试工作的延时，最终有可能（实际上很可能）降低效率。

在某种极偶然的情况下，某个测试可能“弄脏”了配置场所，并要求重新加载－－例如改变一个bean的定义或者一个应用对象的状态－－你可以调用 AbstractDependencyInjectionSpringContextTests 上的 setDirty() 方法来重新加载配置并在执行下一个测试案例前重建application context

当类 AbstractDependencyInjectionSpringContextTests（及其子类）装载你的Application Context时，你可以通过Setter方法来注入你想要的来自context的bean,而不需要显式的调用applicationContext.getBean(XXX)。因为AbstractDependencyInjectionSpringContextTests会从getConfigLocations()方法指定的配置文件中帮你自动注入

下面的例子就是通过setter方法来获得context里的ProductManager bean：

public class MyTest extends AbstractDependencyInjectionSpringContextTests {
ProductManager productManager;

    public String[] getConfigLocations() {
        String[] configLocations = { "file:WebContent/WEB-INF/applicationContext.xml" };
        return configLocations;
    }

    public void testGetProduct() {
       assertEquals("tomson",productManager.getProductByName("tomson").getName());
    }

    //通过setter方法自动从context里注入productManager bean，而不用显示调用applicationContext.getBean(XXX)
    public void setProductManager(ProductManager productManager) {
       this.productManager = productManager;
    }
}

但是如果context里有多个bean都定义为一个类型（例如有多个bean都是ProductManager class类型的），那么对这些bean就无法通过setter方法来自动依赖注入（因为有多个bean同一个类型，不知要自动注入哪个）。在这种情况下你需要显示的调用applicationContext.getBean(XXX)来注入。如：

public class MyTest extends AbstractDependencyInjectionSpringContextTests {
ProductManager productManager;

   public String[] getConfigLocations() {
      String[] configLocations = { "file:WebContent/WEB-INF/applicationContext.xml" };
      return configLocations;
   }

   public void onSetUp() {
       productManager = (ProductManager) applicationContext.getBean("productManager");
   }

   public void testGetProduct() {
       assertEquals("tomson",productManager.getProductByName("tomson").getName());
   }

}

如果你的TestCase不使用依赖注入，只要不定义任何setters方法即可。或者你可以继承 AbstractSpringContextTests －－这个 org.springframework.test 包中的根类，而不是继承AbstractDependencyInjectionSpringContextTests（及其子类）。这是因为AbstractSpringContextTests 只包括用来加载Spring Context的便利方法但没有自动依赖注入的功能。

另外还有一篇文章介绍了spring单元测试的策略，见 [url]http://blog.csdn.net/wangjian5748/archive/2006/09/09/1199549.aspx[/url]

spring中的单元测试的策略

本文主要介绍使用spring提供的对junit的扩展机制来进行单元测试，没有设计mock方面的测试。

一、Spring提供的JUnit框架扩展：

AbstractSpringContextTests：spring中使用spring上下文测试的Junit扩展类，我们一般不会使用这个类来进行单元测试，它是spring内部设计使用到的类
AbstractDependencyInjectionSpringContextTests：这是AbstractSpringContextTests的直接子类，支持依赖spring上下文的测试类，这个类不支持事务。
AbstractTransactionalSpringContextTests：这是AbstractDependencyInjectionSpringContextTests的直接子类，这个类一般应用在事务相关的测试中，一旦完成每个测试它就会正常地回滚事务，不会真正更新数据库，若要手动设置事务相关操作，你可以重载onSetUpInTransaction和onTearDownInTransaction方法，以便手工开始并提交事务，或者调用setComplete()方法。这个类也可以在没有事务的情况下，使用这个类。
AbstractTransactionalDataSourceSpringContextTests：这是AbstractTransactionalSpringContextTests的直接子类，它使用了Spring的基于JDBC的jdbcTemplate工具类，支持数据库级别的事务。

我是按照继承顺序介绍上面四个类的，具体可以参考spring的api文档，或者可以阅读spring的源代码，很简单的代码。

二、测试策略：

下面用一个真实项目的简化版本来作例子，测试的具体目录路径：

test

--system

--dao

--UserDAOImplTest.java

......

--service

--UserServiceImplTest.java

......

--AbstractSystemTest.java

--testSystemContext.xml

--manage

--dao

--CustomerDAOImplTest.java

......

--service

--CustomerServiceImplTest.java

......

--AbstractManageTest.java

--testSystemContext.xml

--testApplicationContext.xml

解释：

test是测试路径，system与manage是模块名(这本来是package的路径，为了简化，我就把前面的包名删除了)，每个模块中有一个spring的配置文件(我的spring配置文件的命名策略是test+模块名+Context)，一个模块级别测试基类(主要是载入spring配置文件，每个该模块的单元测试类都继承该类)，然后是分层路径，这里是DAO和service层，包括所有的DAO与service单元测试类，我们还有一个总的spring配置文件testApplicationContext.xml。再多的解释，也不如代码最明显，下面是部分示例代码

testApplicationContext.xml

< bean id ="propertyConfigurer"

class ="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer" >

< property name ="locations" >

< list >

< value > jdbc.properties </ value >

</ list >

</ property >

</ bean >

< bean id ="dataSource"

class ="org.apache.commons.dbcp.BasicDataSource"

destroy-method ="close" >

< 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 ="parentSessionFactory" abstract ="true"

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

< property name ="hibernateProperties" >

< props >

< prop key ="hibernate.dialect" >

org.hibernate.dialect.Oracle9Dialect

</ prop >

< prop key ="hibernate.cache.provider_class" >

org.hibernate.cache.EhCacheProvider

</ prop >

< prop key ="hibernate.max_fetch_depth" > 3 </ prop >

< prop key ="hibernate.show_sql" > true </ prop >

< prop key ="hibernate.cglib.use_reflection_optimizer" >

true

</ prop >

</ props >

</ property >

< property name ="dataSource" >

< ref local ="dataSource" />

</ property >

</ bean >

< bean id ="transactionManager"

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

< property name ="dataSource" ref ="dataSource" />

</ bean >

< bean id ="baseTransactionProxy"

class ="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"

abstract ="true" >

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

< property name ="transactionAttributes" >

< props >

< prop key ="*" >

PROPAGATION_REQUIRED, -ApplicationException

</ prop >

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

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

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

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

</ props >

</ property >

</ bean >

< bean id ="baseDAO" abstract ="true"

class ="com.mycompany.myproject.framework.BaseDAOImpl" >

< property name ="sessionFactory" ref ="sessionFactory" />

</ bean >

所有的spring的基本配置文件都放在这里面，我巧妙的把利用spring提供的配置技巧声明了一个抽象的parentSessionFactory，然后让每个子模块的sessionFactory都继承这个对象，这样就减少了不少重复的配置文件

testSystemContext.xml

< bean id ="sessionFactory" parent ="parentSessionFactory"

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

< property name ="mappingDirectoryLocations" >

< list >

< value >

com/mycompany/myproject/domain/system/maps

</ value >

</ list >

</ property >

</ bean >

< bean id ="userDAO" parent ="baseDAO"

class ="com.mycompany.myproject.module.system.dao.UserDAOImpl" >

< constructor-arg >

< value > com.mycompany.myproject.domain.system.User </ value >

</ constructor-arg >

</ bean >

< bean id ="userService" parent ="baseTransactionProxy" >

< property name ="target" >

< bean

class ="com.mycompany.myproject.module.system.service.UserServiceImpl" >

< property name ="userDAO" ref ="userDAO" />

</ bean >

</ property >

</ bean >

在这个文件中，声明了一个继承parentSessionFactory的sessionFactory，只需配置mappingDirectoryLocations

AbstractSystemTest.java

public abstract class AbstractSystemTest extends

AbstractTransactionalDataSourceSpringContextTests {

protected String[] getConfigLocations() {

String[] config = new String[] { "testApplicationContext.xml",

"system/testSystemContext.xml" };

return config;

}

覆盖基类的方法，提供寻找配置文件的功能，自己可以根据情况把基类改为AbstractTransactionalSpringContextTests

UserDAOImplTest.java

public class UserDAOImplTest extends AbstractSystemTest {

public UserDAO getUserDAO() {

return (UserDAO) applicationContext.getBean("userDAO");

}

public void testLoadObject() {

User user = (User) this.getUserDAO().find("01");

assertNull(user);

}

UserServiceImplTest.java

public class UserServiceImplTest extends AbstractSystemTest {

public UserService getUserService() {

return (UserService) applicationContext.getBean("userService");

}

public void testLoadUser() {

User user = (User) this.getUserService().find("01");

assertNull(user);

}

我的基本策略，就是让让每个开发人员写的单元测试之间不会相互干扰，其实，在spring中的关键问题时把载入context配置文件相互不干扰。上面的示例表明，采用spring提供的配置文件可以轻松达到这个目的

但是，到了项目中后期的时候，会发现service经常需要访问不属于自己模块的DAO，或者是domain对象的关联被映射在hibernate配置文件中，这时会发现这个方式很耗时，因为你需要导入别的模块的配置文件，这时可以采用一个sessionFacotry的配置，而且这时domain对象也很稳定了，不会经常出现

unmmaped class的异常。