本人生活在互联网，从事web测试、安卓手机测试、接口测试和性能测试，对互联网相关的业务及测试工具有非常高的兴趣，也有一定的经验。 有正在从事安卓手机测试工作或想从事此行业的测友们，欢迎与我联系，相互交流！测试交流QQ群：226297901

spring之单元测试

上一篇 / 下一篇  2012-06-29 10:20:35 / 个人分类：性能测试

查看( 2357 ) / 评论( 0 ) / 评分( 0 / 0 )
今天对着spring的文档看了spring-test这节，现在赶紧记下来，有错误之处还请指出。

 

   spring可以基于junit3.8、junit4.4、testNG的环境，但是注意基于junit4.4和testNG要在java1.4(包括1.4)以上的版本。 

 

    首先环境(一)：spring2.5.4、junit3.8、java1.6、eclipse

 

   使用junit3.8有两种测试的方法，两种测试方法分别extends不同的类，我们一个一个来。

 

 第一种方法A：

    A方法要求测试的类继承org.springframework.test包中类，我们先来看看这个包的类的继承关系：

    AbstractSpringContextTests 

                    |

    AbstractSingleSpringContextTests

                    |

    AbstractDependencyInjectionSpringContextTests

                    |

    AbstractTransactionalSpringContextTests

                    |

    AbstractTransactionalDataSourceSpringContextTests

 

   最上面的是父类，接着第二个继承第一个以此类推。

   好了我们看看 AbstractSpringContextTests

 

Java代码复制代码 收藏代码
  1. /** 
  2.  * Map of context keys returned by subclasses of this class, to Spring 
  3.  * contexts. This needs to be static, as JUnit tests are destroyed and 
  4.  * recreated between running individual test methods. 
  5.  */  
  6. private static Map contextKeyToContextMap = new HashMap();   
  7.   
  8.   
  9. /** 
  10.  * Default constructor for AbstractSpringContextTests. 
  11.  */  
  12. public AbstractSpringContextTests() {   
  13. }   
  14.   
  15. /** 
  16.  * Constructor for AbstractSpringContextTests with a JUnit name. 
  17.  */  
  18. public AbstractSpringContextTests(String name) {   
  19.     super(name);   
  20. }  
Java代码复制代码 收藏代码
  1. /** 
  2.      * Load a new ApplicationContext for the given key. 
  3.      * <p> 
  4.      * To be implemented by subclasses. 
  5.      * 
  6.      * @param key the context key 
  7.      * @return the corresponding ApplicationContext instance (new) 
  8.      */  
  9.     protected abstract ConfigurableApplicationContext loadContext(Object key) throws Exception;  

 

   注意看这个static Map contextKeyToContextMap 这个是用来存放context的缓存区，作用稍后在说，

   看下面的这个抽象方法，它的作用是用来loadContext，这方法的实现在它子类AbstractSingleSpringContextTests

   中。看AbstractSingleSpringContextTests中的实现：

 

 

Java代码复制代码 收藏代码
  1.       /** 
  2.      * <p> 
  3.      * This implementation assumes a key of type String array and loads a 
  4.      * context from the given locations. 
  5.      * </p> 
  6.      * <p> 
  7.      * If you override {@link #contextKey()}, you will typically have to 
  8.      * override this method as well, being able to handle the key type that 
  9.      * <code>contextKey()</code> returns. 
  10.      * </p> 
  11.      * 
  12.      * @see #getConfigLocations() 
  13.      */  
  14.     protected ConfigurableApplicationContext loadContext(Object key) throws Exception {   
  15.         return loadContextLocations((String[]) key);   
  16.     }   
  17.   
  18. protected ConfigurableApplicationContext loadContextLocations(String[] locations) throws Exception {   
  19.         ++this.loadCount;   
  20.         if (this.logger.isInfoEnabled()) {   
  21.             this.logger.info("Loading context for locations: " + StringUtils.arrayToCommaDelimitedString(locations));   
  22.         }   
  23.         return createApplicationContext(locations);   
  24.     }   
  25.   
  26. protected ConfigurableApplicationContext createApplicationContext(final String[] locations) {   
  27.         GenericApplicationContext context = new GenericApplicationContext();   
  28.         customizeBeanFactory(context.getDefaultListableBeanFactory());   
  29.         createBeanDefinitionReader(context).loadBeanDefinitions(locations);   
  30.         context.refresh();   
  31.         return context;   
  32.     }  

 

 可以看到这个方法的实现了加载配置文件的作用，那我们怎么将我们的配置文件给AbstractSingleSpringContextTests

让它加载呢，AbstractSingleSpringContextTests有一个让我们测试类继承的方法String[] getConfigLocations()

 

Java代码复制代码 收藏代码
  1. protected String[] getConfigLocations() {   
  2.         String[] paths = getConfigPaths();   
  3.         String[] locations = new String[paths.length];   
  4.         for (int i = 0; i < paths.length; i++) {   
  5.             String path = paths[i];   
  6.             if (path.startsWith("/")) {   
  7.                 locations[i] = ResourceUtils.CLASSPATH_URL_PREFIX + path;   
  8.             }   
  9.             else {   
  10.                 locations[i] = ResourceUtils.CLASSPATH_URL_PREFIX +   
  11.                         StringUtils.cleanPath(ClassUtils.classPackageAsResourcePath(getClass()) + "/" + path);   
  12.             }   
  13.         }   
  14.         return locations;   
  15.     }  

 在上面所说的loadContext的方法中会调用getConfigLocations()获得配置文件的位置，所以我们在我们测试的类中重写这个方法，这样就覆盖了这个方法。所以我们的测试类应该这样写

 

Java代码复制代码 收藏代码
  1. public class TeacherDao2Test extends AbstractSingleSpringContextTests{   
  2.     protected String entryYear = "2010";   
  3.     protected Long gradeId = 1L;   
  4.     protected Long classId = 1L;   
  5.     protected Long subjectId = 1L;   
  6.     protected Long markId = 1L;   
  7.     protected Date toDate = new Date();   
  8.     protected Date fromDate;   
  9.        
  10.     protected ApplicationContext app;   
  11.        
  12. //  @Resource  
  13.     private GenericManager<AdjustedRateStandard, Long> adjustedRateStandardManager;   
  14.        
  15.     protected TeacherDao2 teacherDao2;   
  16.        
  17.     @Override  
  18.     protected String[] getConfigLocations() {   
  19.         return new String[] {"classpath:applicationContext-resources.xml",   
  20.                 "classpath:WEB-INF/applicationContext.xml",   
  21.         "classpath:applicationContext-dao.xml"};   
  22.     }   
  23.        
  24.     public void testGetQualityReviewResultArrayByDate() throws Exception {   
  25.            
  26.          GenericManager<AdjustedRateStandard, Long> adjustedRateStandardManager =  (GenericManager<AdjustedRateStandard, Long>) this.getApplicationContext().getBean("adjustedRateStandardManager");   
  27.             
  28.          List<AdjustedRateStandard> a = adjustedRateStandardManager.getAll();   
  29.          for(AdjustedRateStandard ar : a) {   
  30.              System.out.println(ar.getId());   
  31.              System.out.println(ar.getRate());   
  32.              System.out.println(ar.getDescription());   
  33.          }   
  34.          System.out.println("--------------");   
  35.         /* a = adjustedRateDao.getAll(); 
  36.          for(AdjustedRate ar : a) { 
  37.              System.out.println(ar.getAreaRate()); 
  38.              System.out.println(ar.getSubject().getName()); 
  39.          }*/  
  40.             
  41.     }   
  42.   
  43.     public void testa() {   
  44.         /*System.out.println(); 
  45.         Double x = 2.0; 
  46.         Double y = 3.0; 
  47.         Double z = 1.2; 
  48.         BigDecimal xb = new BigDecimal(String.valueOf(x)); 
  49.         BigDecimal yb = new BigDecimal(String.valueOf(y)); 
  50.         BigDecimal zb = new BigDecimal(String.valueOf(z)); 
  51.         System.out.println(x*y*z); 
  52.         System.out.println(xb.multiply(zb).multiply(yb)); 
  53.         double d = xb.multiply(zb).multiply(yb).doubleValue(); 
  54.         System.out.println(d);*/  
  55.         int[] a = {3,5,9,7,4,13,15,0,2,20};     
  56.         boolean[] b = new boolean[21];     
  57.              
  58.         for(int i=0;i<a.length;i++) {     
  59.           b[a[i]] = true;     
  60.         }     
  61.              
  62.         for(int i=0;i<b.length;i++) {     
  63.           if(b[i]) {     
  64.             System.out.print(i+",");     
  65.           }     
  66.              
  67.         }     
  68.     }   
  69. }  

这样的话测试类体通过getApplicationContext()就可以获得一个AplicationContext的对象，这个对象可以直接用getbean方法获得spring的容器中的对象了。

 

在AbstractSingleSpringContextTests类中只是简单的加载了容器，当使用AbstractDependencyInjectionSpringContextTests类(及其子类)载入你的应用上下文时， 它们可以通过Setter注入选择性配置你的测试类实例。你需要做的仅仅是定义实例变量和相应的setter方法。AbstractDependencyInjectionSpringContextTests将在getConfigLocations()方法定义的配置文件集中自动查找相应对象，注意它使用的是按类型自动装配，因此如果你有多个bean定义是相同的类型，就不能在这些bean中使用这种方法。 这种情况下，你可以使用继承的applicationContext实例变量并实现显式的查找（比如）， 调用applicationContext.getBean("id")方法。

如果你不希望在测试案例中使用依赖注入，只要不声明任何publicsetter方法就可以简单实现。 作为替代的，你可以扩展AbstractSpringContextTests- 在org.springframework.test包中的JUnit 3.8集成测试支持类层次的根 - 它仅仅包含了一些载入Spring上下文的简单方法，而且不在测试fixture中使用依赖注入。

 

AbstractTransactionalSpringContextTests类 依赖于应用上下文中定义的PlatformTransactionManagerbean。 名字是无关紧要的，因为使用了按类型自动装配，通常你会扩展其子类AbstractTransactionalDataSourceSpringContextTests。 这个类也需要在应用上下文中有一个DataSourcebean定义(同样可以是任意名称)。 它创建一个JdbcTemplate实例变量，可以用来方便的查询和删除选定表的内容（请记住默认情况下事务将被回滚，因而这样做是安全的）。

 

最后说说context缓存的问题，在每个测试的方法被执行的之前都会去加载一次配置文件，所以在spring第一次加载成功以后会将加载的文件名字为key，加载的得到的context为vlaue存在 contextKeyToContextMap ，这样下载在加载的时候就会先去 contextKeyToContextMap 找看有没有对应的key有的话就直接获得context。在一些少见的会“污染”应用上下文的案例中需要重新载入—— 例如，改变一个bean定义或应用对象的状态—— Spring的测试支持提供了在执行下一个测试前让测试fixture重新载入配置并重建应用上下文的机制。方法就是使用AbstractSingleSpringContextTests类中的setDirty()方法来让测试fixture在执行下一个测试案例时重新载AbstractAnnotationAwareTransactionalTests类，这个方法就是将contextKeyToContextMap 里的对应的记录给remove掉。

 

第二种方法B：

  我们也可以使用我们的测试类继承AbstractJUnit38SpringContextTests这个类，这是使用Spring TestContext Framework

 

 框架的核心包括TestContext和TestContextManager类以及TestExecutionListener接口。 每次测试都会创建TestContextManager。TestContextManager管理了一个TestContext， 它负责持有当前测试的上下文。TestContextManager还负责在测试执行过程中更新TestContext的状态并代 理到TestExecutionListener， 它用来监测测试实际的执行（如提供依赖注入、管理事务等等）。其实也就是在TestContextManager有一个TestExecutionListener的list，在每次执行测试方法前后是时候都会遍历这个list并执行对应的prepareTestInstance和beforeTestMethod和afterTestMethod方法。

  • TestContext：封装测试执行的上下文，与当前使用的测试框架无关。

  • TestContextManager：Spring TestContext Framework的主入口点， 负责管理单独的TestContext并在定义好的执行点上向所有注册的TestExecutionListener发出事件通知： 测试实例的准备，先于特定的测试框架的前置方法，迟于后置方法。

  • TestExecutionListener：定义了一个监听器API与TestContextManager发布的测试执行事件进行交互， 而该监听器就是注册到这个TestContextManager上的。

    Spring提供了TestExecutionListener的三个实现， 他们都是使用默认值进行配置的(通过@TestExecutionListeners注解)：DependencyInjectionTestExecutionListener、DirtiesContextTestExecutionListener及TransactionalTestExecutionListener， 他们对测试实例提供了依赖注入支持，处理@DirtiesContext注解，并分别使用默认的回滚语义对测试提供事务支持。

 好了，直接上例子:

 

Java代码复制代码 收藏代码
  1. @ContextConfiguration(locations = {"classpath:applicationContext-resources.xml",   
  2.                         "classpath:WEB-INF/applicationContext.xml",   
  3.                         "classpath:applicationContext-dao.xml"})   
  4. public class TeacherDao2Test extends AbstractJUnit38SpringContextTests {   
  5.     protected String entryYear = "2010";   
  6.     protected Long gradeId = 1L;   
  7.     protected Long classId = 1L;   
  8.     protected Long subjectId = 1L;   
  9.     protected Long markId = 1L;   
  10.     protected Date toDate = new Date();   
  11.     protected Date fromDate;   
  12.        
  13.     protected ApplicationContext app;   
  14.        
  15.     @Resource  
  16.     private GenericManager<AdjustedRateStandard, Long> adjustedRateStandardManager;   
  17.        
  18.     protected TeacherDao2 teacherDao2;   
  19.        
  20.     public void testGetQualityReviewResultArrayByDate() throws Exception {   
  21.            
  22. //       GenericManager<AdjustedRateStandard, Long> adjustedRateStandardManager =  (GenericManager<AdjustedRateStandard, Long>) this.getApplicationContext().getBean("adjustedRateStandardManager");  
  23.             
  24.         Assert.assertNotNull("not null", adjustedRateStandardManager);   
  25.          List<AdjustedRateStandard> a = adjustedRateStandardManager.getAll();   
  26.          for(AdjustedRateStandard ar : a) {   
  27.              System.out.println(ar.getId());   
  28.              System.out.println(ar.getRate());   
  29.              System.out.println(ar.getDescription());   
  30.          }   
  31.          System.out.println("--------------");   
  32.         /* a = adjustedRateDao.getAll(); 
  33.          for(AdjustedRate ar : a) { 
  34.              System.out.println(ar.getAreaRate()); 
  35.              System.out.println(ar.getSubject().getName()); 
  36.          }*/  
  37.             
  38.     }   
  39.   
  40.     public void testa() {   
  41.         /*System.out.println(); 
  42.         Double x = 2.0; 
  43.         Double y = 3.0; 
  44.         Double z = 1.2; 
  45.         BigDecimal xb = new BigDecimal(String.valueOf(x)); 
  46.         BigDecimal yb = new BigDecimal(String.valueOf(y)); 
  47.         BigDecimal zb = new BigDecimal(String.valueOf(z)); 
  48.         System.out.println(x*y*z); 
  49.         System.out.println(xb.multiply(zb).multiply(yb)); 
  50.         double d = xb.multiply(zb).multiply(yb).doubleValue(); 
  51.         System.out.println(d);*/  
  52.         int[] a = {3,5,9,7,4,13,15,0,2,20};     
  53.         boolean[] b = new boolean[21];     
  54.              
  55.         for(int i=0;i<a.length;i++) {     
  56.           b[a[i]] = true;     
  57.         }     
  58.              
  59.         for(int i=0;i<b.length;i++) {     
  60.           if(b[i]) {     
  61.             System.out.print(i+",");     
  62.           }     
  63.              
  64.         }     
  65.     }   
  66. }  

 

注意，这次我使用了注解@Resource来让spring来自己帮我进行注入，在前面一种方法使用@Resource不行，当然也可以AbstractJUnit38SpringContextTests 的protected ApplicationContext applicationContext来自己在spring中取得。

注意在类的定义处使用@ContextConfiguration注解来把配置文件的位子传递给测试类，@ContextConfiguration总共有3个配置的属性，其他两个是boolean类型inheritLocations以表明是否继承父类的locations和loader表示使用自己的context加载器。

 

这种方法上下文缓存的处理和第一种方法一样。但是与上面不同的是使用@DirtiesContext这个注解来表示重新加载，使用@DirtiesContext注解的前提是在TestExecutionListeners中加入DirtiesContextTestExecutionListener，而我们的AbstractJUnit38SpringContextTests 中已经设置了DirtiesContextTestExecutionListener，看：

Java代码复制代码 收藏代码
  1. @TestExecutionListeners({DependencyInjectionTestExecutionListener.class, DirtiesContextTestExecutionListener.class})   
  2. public abstract class AbstractJUnit38SpringContextTests extends TestCase implements ApplicationContextAware {   
  3.   
  4.     private static int disabledTestCount = 0;   
  5.   
  6.   
  7.     /** 
  8.      * Return the number of tests disabled in this environment. 
  9.      */  
  10.     public static int getDisabledTestCount() {   
  11.         return disabledTestCount;   
  12.     }   
  13.  ...   
  14. }  

 事务管理：

  对事务的支持可以通过在TestExecutionListeners加入TransactionalTestExecutionListener，同时在类或方法上加上@Transactional就可以支持事务了，在对AbstractJUnit38SpringContextTests类进行扩展了事务和SimpleJdbcTemplate的子类AbstractTransactionalJUnit38SpringContextTests.class是这样配置的。

Java代码复制代码 收藏代码
  1. @TestExecutionListeners({TransactionalTestExecutionListener.class})   
  2. @Transactional  
  3. public abstract class AbstractTransactionalJUnit38SpringContextTests extends AbstractJUnit38SpringContextTests {   
  4.   
  5.     /** 
  6.      * The SimpleJdbcTemplate that this base class manages, available to subclasses. 
  7.      */  
  8.     protected SimpleJdbcTemplate simpleJdbcTemplate;   
  9.   
  10.     private String sqlScriptEncoding;   
  11.   
  12.   
  13.     /** 
  14.      * Constructs a new AbstractTransactionalJUnit38SpringContextTests instance. 
  15.      */  
  16.     public AbstractTransactionalJUnit38SpringContextTests() {   
  17.         super();   
  18.     }   
  19. }  

 所以我们可以使测试类继承这个类AbstractTransactionalJUnit38SpringContextTests

 

下面环境改变： spring2.5.4、junit4.4、java1.6、eclipse

 同样的使用了Spring TestContext Framework，Spring TestContext Framework通过一个可定制的运行器提供了与JUnit 4.4的完全集成。 通过使用@Runwith(SpringJUnit4ClassRunner.class)来注解测试类，开发者可以实现标准的JUnit 4.4单元和集成测试， 同时还能获得TestContext框架的好处，上例子

 

 

 

Java代码复制代码 收藏代码
  1. @RunWith(SpringJUnit4ClassRunner.class)   
  2. @TestExecutionListeners({DependencyInjectionTestExecutionListener.class, DirtiesContextTestExecutionListener.class})   
  3. public abstract class AbstractJUnit4SpringContextTests implements ApplicationContextAware {   
  4.   
  5.     /** 
  6.      * Logger available to subclasses. 
  7.      */  
  8.     protected final Log logger = LogFactory.getLog(getClass());   
  9.   
  10.     /** 
  11.      * The {@link ApplicationContext} that was injected into this test instance 
  12.      * via {@link #setApplicationContext(ApplicationContext)}. 
  13.      */  
  14.     protected ApplicationContext applicationContext;   
  15.   
  16.   
  17.     /** 
  18.      * Set the {@link ApplicationContext} to be used by this test instance, 
  19.      * provided via {@link ApplicationContextAware} semantics. 
  20.      */  
  21.     public final void setApplicationContext(final ApplicationContext applicationContext) {   
  22.         this.applicationContext = applicationContext;   
  23.     }   
  24.   

收藏 举报

TAG:

 

评分：0

我来说两句

日历

« 2024-05-04  
日 一 二 三 四 五 六
   1234
567891011
12131415161718
19202122232425
262728293031 

数据统计

  • 访问量: 17199
  • 日志数: 24
  • 书签数: 1
  • 建立时间: 2012-05-28
  • 更新时间: 2013-06-05

RSS订阅

Open Toolbar