这两天做Web开发，发现通过Spring进行对象管理之后，做测试变得复杂了。因为所有的Bean都需要在applicationContext.xml中加载好，之后再通过@Resource去取得。如果每次都要整个业务流做的差不多了再去测试，这样效率很低，也很麻烦。如果单独去写一个测试用类，这样太繁琐了。于是想起Spring有一个测试框架，能够整合JUnit进行测试，于是便拿出来试试~
废话不多说，教程直接开始。
1. 加入依赖包
使用Spring的测试框架需要加入以下依赖包：
· JUnit 4 （官方下载：https://github.com/KentBeck/junit/downloads）
· Spring Test （Spring框架中的test包）
· Spring 相关其他依赖包（不再赘述了，就是context等包）
2. 创建测试源目录和包
在此，推荐创建一个和src平级的源文件目录，因为src内的类都是为日后产品准备的，而此处的类仅仅用于测试。而包的名称可以和src中的目录同名，这样由于在test源目录中，所以不会有冲突，而且名称又一模一样，更方便检索。
3. 创建测试类
创建一个测试用的类，推荐名称为 “被测试类名称 + Test”。
测试类应该继承与 AbstractJUnit4SpringContextTests 或 AbstractTransactionalJUnit4SpringContextTests
对于 AbstractJUnit4springcontextTests 和 AbstractTransactionalJUnit4SpringContextTests 类的选择：
如果再你的测试类中，需要用到事务管理（比如要在测试结果出来之后回滚测试内容），就可以使用AbstractTransactionalJUnit4SpringTests类。事务管理的使用方法和正常使用Spring事务管理是一样的。再此需要注意的是，如果想要使用声明式事务管理，即使用AbstractTransactionalJUnitSpringContextTests类，请在applicationContext.xml文件中加入transactionManager bean：
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
如果没有添加上述bean，将会抛出NoSuchBeanDefinitionException，指明 No bean named 'transactionManager' is definded.
4. 配置测试类
添加如下内容在class前，用于配置applicationContext.xml文件的位置。
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
5. 创建测试方法
创建测试用方法，推荐名称为 “被测方法名称+ Test”。
测试方法上方加入 @Test
6. 通过JUnit 4 执行
右键方法名，选择则“Run As”→“JUnit Test”即可
附录1：整体测试类文件
/* @(#) UserDaoTest.java
*
* Date: 2012-1-16
*
* Author: Rainisic
*/
package com.mb.dao;
import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.mb.entity.User;
/**
* @author Rainisic
*
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
publicclass UserDaoTest extends AbstractJUnit4SpringContextTests {
@Resource
private UserDaoInterface userDao;
@Test
publicvoid saveTest() {
User user1 = new User();
user1.setUsername("rainisic");
user1.setPassword("123456");
user1.setNickName("rainisic");
user1.setEmail("rainisic@gmail.com");
User user2 = new User();
user2.setUsername("admin");
user2.setPassword("123456");
user2.setNickName("admin");
user2.setEmail("admin@admin.com");
User user3 = new User();
user3.setUsername("test");
user3.setPassword("123456");
user3.setNickName("test");
user3.setEmail("test@gmail.com");
userDao.save(user1);
userDao.save(user2);
userDao.save(user3);
}
}
OK，到此为止就可以使用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的异常。
948
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
