依赖引入

为了简化依赖，直接引入引入SpringBoot POM，但是只用Spring+SpringTest来使用单测

  1. <dependency>
  2.   <groupId>org.springframework.boot</groupId>
  3.   <artifactId>spring-boot-starter-test</artifactId>
  4. </dependency>
  5. <!-- spring-boot-starter-test已经内置junit,这里是显示引入,表示使用Junit4 -->
  6.  <dependency>
  7.    <groupId>junit</groupId>
  8.    <artifactId>junit</artifactId>
  9.    <version>4.12</version>
  10.  </dependency>

XML-Based

ContextConfiguration+Xml+Properties+Component-scan

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration(locations = "classpath:beans.xml")
  3. public class SpringJunitTest implements ApplicationContextAware {
  5. }

外部XML可以配置properties文件，或component-scan

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
  7.     <context:component-scan base-package="com.spring"/>
  8.     <context:property-placeholder location="application.properties"/>
  10.    <!-- 事务注解 -->
  11.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  12.         <property name="dataSource" ref="grus"/>
  13.     </bean>
  14.     <tx:annotation-driven transaction-manager="transactionManager"/>
  16. </beans>

ContextConfiguration+XML+Properties+事物回滚

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @TestPropertySource(locations = {"classpath:spring/config-env.properties"})
  3. @ContextConfiguration(locations = {"classpath*:spring/applicationContext*.xml", "classpath*:springmvc/springmvc-backend.xml"})
  4. @Transactional
  5. @Rollback
  6. public abstact class IntegrationTestBase implements ApplicationContextAware {
  8. }
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
  7.    <!-- 事务注解 -->
  8.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  9.         <property name="dataSource" ref="grus"/>
  10.     </bean>
  11.     <tx:annotation-driven transaction-manager="transactionManager"/>
  13. </beans>

JavaConfig-Based(零XML）

@Configuration与XML 配置类似

ContextConfiguration+内部配置类+AnnotationConfigContextLoader

如果使用了AnnotationConfigContextLoader，则需要指定配置类，也就是@Configuration标注的Class
如果ContextConfiguration未指定classes,也就是未使用独立的配置类，则AnnotationConfigContextLoader会从当前类里查找静态内部类作为配置类，如果有则扫描Bean。
注意：当前的静态内部类不能是final,不能是private.

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration(loader = AnnotationConfigContextLoader.class)
  3. public class SpringJunitTest implements ApplicationContextAware {
  5.     private ApplicationContext applicationContext;
  7.     @Configuration
  8.     static class ExtraConfig {
  9.         // this bean will be injected into the OrderServiceTest class
  10.         @Bean
  11.         public OrderService orderService() {
  12.             OrderService orderService = new OrderService();
  13.             // set properties, etc.
  14.             return orderService;
  15.         }
  16.     }
  17. }
  19. @RunWith(SpringJUnit4ClassRunner.class)
  20. @ContextConfiguration() // 走默认的Loader,自动决策
  21. public class SpringJunitTest implements ApplicationContextAware {
  23.     private ApplicationContext applicationContext;
  25.     @Configuration
  26.     static class ExtraConfig {
  27.         // this bean will be injected into the OrderServiceTest class
  28.         @Bean
  29.         public OrderService orderService() {
  30.             OrderService orderService = new OrderService();
  31.             // set properties, etc.
  32.             return orderService;
  33.         }
  34.     }
  35. }

ContextConfiguration+独立配置类+Loader

指定ContextConfiguration的classes为某个配置类或某些配置类。如果未指定loader，默认为：DelegatingSmartContextLoader，会自动决策. 如果加载的是XML配置，则使用：GenericXmlContextLoader， 如果是配置类，则使用AnnotationConfigContextLoader。

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. // loader=AnnotationConfigContextLoader 可默认不写
  3. @ContextConfiguration(classes = App.class, loader = AnnotationConfigContextLoader.class)
  4. public class SpringJunitTest implements ApplicationContextAware {
  6. }
  8. @RunWith(SpringJUnit4ClassRunner.class)
  9. // loader=AnnotationConfigContextLoader 可默认不写， 走自动识别Loader
  10. @ContextConfiguration(classes = App.class)
  11. public class SpringJunitTest implements ApplicationContextAware {
  13. }
  15. @ComponentScan(basePackages = {"com.spring"})
  16. @Configuration
  17. public class App {
  18. }

独立配置类，与JavaConfig用法一致，可使用@ComponentScan，@Import, @ImportResource.
当然不建议Import XML文件，因为推荐使用零配置，都采用注解风格。

  1. @ComponentScan(basePackages = {"com.spring"})
  2. @Configuration
  3. @ImportResource("classpath:app.xml")
  4. @Import(User.class)
  5. public class App {
  6. }

ContextConfiguration+配置继承

XML-Based

  1. @ContextConfiguration("base-context.xml")
  2. @RunWith(SpringJUnit4ClassRunner.class)
  3. public class BaseTest {
  4.     // ...
  5. }
  7. @ContextConfiguration("extended-context.xml")
  8. public class ExtendedTest extends BaseTest {
  9.     // ...
  10. }

JavaConfig-Based

  1. @ContextConfiguration(classes=BaseConfig.class)
  2. @RunWith(SpringJUnit4ClassRunner.class)
  3. public class BaseTest {
  4.     // ...
  5. }
  7. @ContextConfiguration(classes=ExtendedConfig.class)
  8. public class ExtendedTest extends BaseTest {
  9.     // ...
  10. }

ContextConfiguration+Profile

XML-Based

使用@ActiveProfiles

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. // ApplicationContext will be loaded from "classpath:/app-config.xml"
  3. @ContextConfiguration("/app-config.xml")
  4. @ActiveProfiles("dev")
  5. public class TransferServiceTest {
  7.     @Autowired
  8.     private TransferService transferService;
  10.     @Test
  11.     public void testTransferService() {
  12.         // test the transferService
  13.     }
  14. }
  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xmlns:jdbc="http://www.springframework.org/schema/jdbc"
  4.     xmlns:jee="http://www.springframework.org/schema/jee"
  5.     xsi:schemaLocation="...">
  7.     <bean id="transferService" class="com.bank.service.internal.DefaultTransferService">
  8.         <constructor-arg ref="accountRepository"/>
  9.         <constructor-arg ref="feePolicy"/>
  10.     </bean>
  12.     <bean id="accountRepository" class="com.bank.repository.internal.JdbcAccountRepository">
  13.         <constructor-arg ref="dataSource"/>
  14.     </bean>
  16.     <bean id="feePolicy" class="com.bank.service.internal.ZeroFeePolicy"/>
  18.     <beans profile="dev">
  19.         <jdbc:embedded-database id="dataSource">
  20.             <jdbc:script location="classpath:com/bank/config/sql/schema.sql"/>
  21.             <jdbc:script location="classpath:com/bank/config/sql/test-data.sql"/>
  22.         </jdbc:embedded-database>
  23.     </beans>
  25.     <beans profile="production">
  26.         <jee:jndi-lookup id="dataSource" jndi-name="java:comp/env/jdbc/datasource"/>
  27.     </beans>
  29. </beans>

JavaConfig-Based

  1. @Configuration
  2. @Profile("dev")
  3. public class StandaloneDataConfig {
  5.     @Bean
  6.     public DataSource dataSource() {
  7.         return new EmbeddedDatabaseBuilder()
  8.             .setType(EmbeddedDatabaseType.HSQL)
  9.             .addScript("classpath:com/bank/config/sql/schema.sql")
  10.             .addScript("classpath:com/bank/config/sql/test-data.sql")
  11.             .build();
  12.     }
  13. }
  15. @Configuration
  16. @Profile("production")
  17. public class JndiDataConfig {
  19.     @Bean
  20.     public DataSource dataSource() throws Exception {
  21.         Context ctx = new InitialContext();
  22.         return (DataSource) ctx.lookup("java:comp/env/jdbc/datasource");
  23.     }
  24. }
  26. @Configuration
  27. public class TransferServiceConfig {
  29.     @Autowired DataSource dataSource;
  31.     @Bean
  32.     public TransferService transferService() {
  33.         return new DefaultTransferService(accountRepository(), feePolicy());
  34.     }
  36.     @Bean
  37.     public AccountRepository accountRepository() {
  38.         return new JdbcAccountRepository(dataSource);
  39.     }
  41.     @Bean
  42.     public FeePolicy feePolicy() {
  43.         return new ZeroFeePolicy();
  44.     }
  45. }

测试类

  1. package com.bank.service;
  3. @RunWith(SpringJUnit4ClassRunner.class)
  4. @ContextConfiguration(loader=AnnotationConfigContextLoader.class,
  5.     classes={TransferServiceConfig.class, StandaloneDataConfig.class, JndiDataConfig.class})
  6. @ActiveProfiles("dev")
  7. public class TransferServiceTest {
  9.     @Autowired
  10.     private TransferService transferService;
  12.     @Test
  13.     public void testTransferService() {
  14.         // test the transferService
  15.     }
  16. }