spring中的单元测试的策略

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

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

  1. AbstractSpringContextTests:spring中使用spring上下文测试的Junit扩展类,我们一般不会使用这个类来进行单元测试,它是spring内部设计使用到的类
  2. AbstractDependencyInjectionSpringContextTests:这是AbstractSpringContextTests的直接子类,支持依赖spring上下文的测试类,这个类不支持事务。
  3. AbstractTransactionalSpringContextTests:这是AbstractDependencyInjectionSpringContextTests的直接子类,这个类一般应用在事务相关的测试中,一旦完成每个测试它就会正常地回滚事务,不会真正更新数据库,若要手动设置事务相关操作,你可以重载onSetUpInTransaction和onTearDownInTransaction方法,以便手工开始并提交事务,或者调用setComplete()方法。这个类也可以在没有事务的情况下,使用这个类。
  4. 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>

    
<!-- transaction -->
    
<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>

    
<!-- Base DAO -->
    
<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>
    
    
<!-- DAO -->
    
<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>

    
<!-- Service -->
    
<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的异常。
写一篇文章真是很痛苦,搞了5个小时,真消耗时间。
阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页