One obvious way to specify static pointcuts is regular expressions. Several AOP frameworks besides Spring make this possible. org.springframework.aop.support.JdkRegexpMethodPointcut is a generic regular expression pointcut, using the regular expression support in JDK 1.4+.

Using the JdkRegexpMethodPointcut class, you can provide a list of pattern Strings. If any of these is a match, the pointcut will evaluate to true. (So the result is effectively the union of these pointcuts.)

The usage is shown below:

<bean id="settersAndAbsquatulatePointcut"
        class="org.springframework.aop.support.JdkRegexpMethodPointcut">
    <property name="patterns">
        <list>
            <value>.*set.*</value>
            <value>.*absquatulate</value>
        </list>
    </property>
</bean>

Spring provides a convenience class, RegexpMethodPointcutAdvisor, that allows us to also reference an Advice (remember that an Advice can be an interceptor, before advice, throws advice etc.). Behind the scenes, Spring will use a JdkRegexpMethodPointcut. Using RegexpMethodPointcutAdvisor simplifies wiring, as the one bean encapsulates both pointcut and advice, as shown below:

<bean id="settersAndAbsquatulateAdvisor"
        class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
    <property name="advice">
        <ref bean="beanNameOfAopAllianceInterceptor"/>
    </property>
    <property name="patterns">
        <list>
            <value>.*set.*</value>
            <value>.*absquatulate</value>
        </list>
    </property>
</bean>

RegexpMethodPointcutAdvisor can be used with any Advice type.

An important type of static pointcut is a metadata-driven pointcut. This uses the values of metadata attributes: typically, source-level metadata.

Spring control flow pointcuts are conceptually similar to AspectJ cflow pointcuts, although less powerful. (There is currently no way to specify that a pointcut executes below a join point matched by another pointcut.) A control flow pointcut matches the current call stack. For example, it might fire if the join point was invoked by a method in the com.mycompany.web package, or by the SomeCaller class. Control flow pointcuts are specified using the org.springframework.aop.support.ControlFlowPointcut class.

用户自定义的测试执行监听器 TestExecutionListeners 可以通过注解 @TestExecutionListeners 注册到测试类及其 子类中。了解注解 @TestExecutionListeners 的详情和示例，请参阅注解支持 和javadocs。

通过注解 @TestExecutionListeners 注册用户自定义的测试执行监听器 TestExecutionListeners 适合用户 自定义监听器的有限测试场景；尽管如此，当用户自定义监听器跨越测试套件的时候将会非常麻烦。为了解决这个问题，Spring 框架 4.1 通过 SpringFactoriesLoader 机制支持 默认 测试执行监听器 TestExecutionListener 实现的自动发现。

具体的，spring-test 模块在属性文件 META-INF/spring.factories 下以org.springframework.test.context.TestExecutionListener 为键声明所有的核心默认测试执行监听器 TestExecutionListeners 。第三方框架和开发人员可以以相同的方式在属性文件中 增加他们自己的测试执行监听器 TestExecutionListeners 。

当TestContext框架通过前述的 SpringFactoriesLoader 机制发现默认的测试执行监听器 TestExecutionListeners， 实例化的监听器使用spring的比较器 AnnotationAwareOrderComparator 进行排序，该比较器实现了 Ordered 接口并加注 了 @Order 注解。spring提供的 AbstractTestExecutionListener 和所有的默认的测试执行监听器 TestExecutionListeners 都使用适当的值实现了 Ordered 接口。 因此，第三方框架和开发人员也要确保他们的 默认 测试执行监听器 TestExecutionListeners 使用适当的顺序注册，通过实现 Ordered 接口或者声明 @Order 注解。为了弄清楚每一个核心监听器赋值详情，可以查阅Javadoc来了解 默认的核心测试执行监听器 TestExecutionListeners 的 getOrder() 方法。

如果通过 @TestExecutionListeners 注解注册了用户自定义的测试执行监听器 TestExecutionListener，则 default 监听器将不再注册。在大多数测试场景下，这有效地强制了开发人员手动声明除了自定义监听器以外的所有默认监听器。下述的列表演示了 这种配置风格。

@ContextConfiguration
@TestExecutionListeners({
    MyCustomTestExecutionListener.class,
    ServletTestExecutionListener.class,
    DependencyInjectionTestExecutionListener.class,
    DirtiesContextTestExecutionListener.class,
    TransactionalTestExecutionListener.class,
    SqlScriptsTestExecutionListener.class
})
public class MyTest {
    // 类体...
}

这种方法的挑战时它需要开发人员确切地了解哪些监听器会默认注册。而且，这些默认的监听器在不同的版本之间还会变更-- 例如，SqlScriptsTestExecutionListener 监听器时在spring 4.1中被引入的。此外，第三方框架喜欢通过前述的 自动发现机制 来注册他们自己的默认的测试执行监听器 TestExecutionListener。

为了避免必须知道或者时重新声明 所有 默认 监听器，测试执行监听器注解 @TestExecutionListeners的 mergeMode 属性可以设置为 MergeMode.MERGE_WITH_DEFAULTS。 该属性用来指示本地声明的监听器应该与默认的 监听器进行合并。合并算法确保重复的监听器将从列表中删除并且合并的监听器结果集合是根据 AnnotationAwareOrderComparator 的语义有序排列的，其排序应该与 the section called “TestExecutionListeners 的顺序” 中的描述一致。如果一个监听器实现了 Ordered 接口或者时声明了 @Order 注解，它将影响与默认的监听器合并所在的位置，否则在合并的时候本地声明 的监听器将简单地追加到默认的监听器列表上。

例如，在前面的示例配置中，如果监听器 MyCustomTestExecutionListener 类的 order 值（例如，500） 小于 ServletTestExecutionListener 类的值（碰巧是1000），于是 MyCustomTestExecutionListener 将自动地合并到 ServletTestExecutionListener 类的 前面 ，前面的示例将替换成下述的形式。

@ContextConfiguration
@TestExecutionListeners(
    listeners = MyCustomTestExecutionListener.class,
    mergeMode = MERGE_WITH_DEFAULTS,
)
public class MyTest {
    // 类体...
}

@RunWith(SpringJUnit4ClassRunner.class)a
@ContextConfiguration
public class MyTest {

    @Autowired
    private ApplicationContext applicationContext;

    // 类体...
}

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration
public class MyWebAppTest {
    @Autowired
    private WebApplicationContext wac;

    // 类体...
}

使用XML配置文件为你的测试加载一个应用上下文 ApplicationContext ， 使用 @ContextConfiguration 注解你的测试类并以数组的形式配置 locations 属性，该属性包含XML配置元数据的资源位置。一个普通的相对路径 —— 例如，"context.xml" ——将会认为是相对于测试类定义所在包的相对路径。 如果一个路径以“/”开始，则该路径 被认为是一个绝对的类路径位置，例如，"/org/example/config.xml"。一个表示资源的URL（例如，一个路径前缀 为 classpath: , file: , http: , 等等）路径顾名思义。

@RunWith(SpringJUnit4ClassRunner.class)
// 应用上下文将会从类路径根下的 "/app-config.xml" 和 "/test-config.xml" 加载
@ContextConfiguration(locations={"/app-config.xml", "/test-config.xml"})
public class MyTest {
    // 类体...
}

注解 @ContextConfiguration 通过标准的Java value 属性支持 locations 属性的别名。 因此，如果在注解 @ContextConfiguration 中没有别的属性需要设置， 你可以忽略 locations 属性 的名字使用一种如下示例的简洁方式进行声明。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"/app-config.xml", "/test-config.xml"})
public class MyTest {
    // 类体...
}

如果你同时忽略了 @ContextConfiguration 注解的 locations 和 value 属性， 那么测试上下文框架 将会尝试探测默认的XML资源位置。确切地说，GenericXmlContextLoader 和 GenericXmlWebContextLoader 会 基于测试类的名字探测默认的位置，如果你的测试类命名为 com.example.MyTest ，GenericXmlContextLoader 类 将从 "classpath:com/example/MyTest-context.xml" 位置加载应用上下文。

package com.example;

@RunWith(SpringJUnit4ClassRunner.class)
// 应用上下文将从 "classpath:com/example/MyTest-context.xml" 位置加载
@ContextConfiguration
public class MyTest {
    // 类体...
}

使用Groovy脚本为你的测试类加载一个应用上下文 ApplicationContext，可以利用 Groovy DSL 注解你的测试类， 在注解 @ContextConfiguration 的 locations 和 value 属性中使用一个包含Groovy 脚本 的资源位置的数组配置属性。资源查找的语义和XML 配置文件的描述是一致的。

@RunWith(SpringJUnit4ClassRunner.class)
// 应用上下文将从类路径根下的 "/AppConfig.groovy" 和 "/TestConfig.groovy" 加载
@ContextConfiguration({"/AppConfig.groovy", "/TestConfig.Groovy"})
public class MyTest {
    // 类体...
}

如果你同时忽略了注解 @ContextConfiguration 的 locations 和 value 属性，则测试上下文框架将会 尝试探测默认的Groovy脚本。确切地说，加载器 GenericGroovyXmlContextLoader 和 GenericGroovyXmlWebContextLoader 基于测试类的名字探测默认的位置。如果你的测试类命名为 com.example.MyTest ， 那么Groovy上下文加载器将会 从位置 "classpath:com/example/MyTestContext.groovy" 加载你的应用上下文。

package com.example;

@RunWith(SpringJUnit4ClassRunner.class)
// 应用上下文 ApplicationContext 将从位置 "classpath:com/example/MyTestContext.groovy" 加载
@ContextConfiguration
public class MyTest {
    // 类体...
}

使用注解类 （参考???）为你的测试类加载一个应用上下文 ApplicationContext ，可以 为你的测试类增加注解 @ContextConfiguration 并使用一个数组配置其 classes 属性，该数组包含注解 类的引用。

@RunWith(SpringJUnit4ClassRunner.class)
// 应用上下文ApplicationContext 将从AppConfig 和 TestConfig 配置类加载
@ContextConfiguration(classes = {AppConfig.class, TestConfig.class})
public class MyTest {
    // 类体...
}

如果你忽略了直接 @ContextConfiguration 的 classes 属性，测试上下文框架将会尝试探测默认配置 类的存在。确切地说，加载器 AnnotationConfigContextLoader 和 AnnotationConfigWebContextLoader 将会探测满足需求的所有测试类的静态内部类， 这些内部类通过注解 @Configuration 指定了其配置。下述示例 中，测试类 OrderServiceTest 声明了一个名字为 Config 的静态内部配置类， 该类被用来为测试类加载应用 上下文 ApplicationContext 。请注意，配置类的名字是任意的。除此之外，必要时，一个测试类可以包含多个 静态内部配置类。

@RunWith(SpringJUnit4ClassRunner.class)
// 应用上下文 ApplicationContext 将从静态内部配置类 Config加载
@ContextConfiguration
public class OrderServiceTest {

    @Configuration
    static class Config {

        // 这个Bean将注入到OrderServiceTest中
        @Bean
        public OrderService orderService() {
            OrderService orderService = new OrderServiceImpl();
            // 设置属性， 等等操作
            return orderService;
        }
    }

    @Autowired
    private OrderService orderService;

    @Test
    public void testOrderService() {
        // 测试服务 orderService
    }

}

有时候，可以期望组合XML配置文件、Groovy脚本和注解类（例如，典型的 @Configuration 类）三种方式 来为你的测试类配置一个应用上下文。例如，你在产品中使用XML配置，在测试中你可能决定想使用注解类 @Configuration 来配置Springg管理的组件，反之亦然。

此外，一些第三方框架（就像Spring Boot）为加载应用上下文 ApplicationContext 提供了优秀的支持，他们 可以从不同类型的资源中同时加载（例如，XML配置文件，Groovy脚本和增加了 @Configuration 的类）。由于历史的原因， Spring框架没有以标准发布的形式支持混合配置。因此，Spring框架中的 spring-test 模块的大多数上下文 加载器 SmartContextLoader 的实现在每一个测试上下文中仅支持一种资源类型；尽管如此，这并不意味着你 不能同时使用它们。通用规则的一个例外是上下文加载器 GenericGroovyXmlContextLoader 和 GenericGroovyXmlWebContextLoader 同时支持XML配置文件和Groovy脚本。 此外，第三方框架可能通过注解 @ContextConfiguration 选择支持 locations 和 classes 的声明以及测试框架的标准测试支持， 你可以有如下的选项。

如果你想使用资源位置（例如，XML或Groovy脚本） 和 注解 @Configuration类配置你的测试类，你必须 选择一个作为 入口点 ，并且另外一个必须包括或者导入到另一个。例如，在XML或Groovy脚本中，你可以通过组件 扫描或正常定义Spring beans包含 @Configuration 类;反过来，在注解 @Configuration 配置的类中， 你可以使用注解 @ImportResource 导入XML配置文件。注意，这种行为与在产品中配置您的应用在语义上是等价的： 在产品配置中，你可以定义XML或Groovy资源位置的集合，或者配置类 @Configuration 的集合，产品的应用上下文 ApplicationContext 将从中加载， 但是你仍然有包含或导入其他类型配置的自由。

使用上下文初始化器为你的测试类配置一个应用上下文 ApplicationContext ，可以使用 @ContextConfiguration 注解你的测试类，然后使用一个数组配置其 initializers 属性，该数组包含实现了 ApplicationContextInitializer 的类的引用。 声明的上下文初始化器其后将被用来初始化测试类的 ConfigurableApplicationContext 。注意， 每一个具体的声明的初始化器支持的 ConfigurableApplicationContext 类型必须与使用 SmartContextLoader 创建的应用上下文 ApplicationContext 类型兼容。此外，初始化器被调用的顺序依赖于它们是否实现了Spring的 Ordered 接口或加注了Spring的 @Order 注解或加注了标准的 @Priority 注解。

@RunWith(SpringJUnit4ClassRunner.class)
// 应用上下文ApplicationContext将从配置类TestConfig加载并从TestAppCtxInitializer初始化
@ContextConfiguration(
    classes = TestConfig.class,
    initializers = TestAppCtxInitializer.class)
public class MyTest {
    //类体...
}

完全地忽略XML配置或注解类 @ContextConfiguration 方式的声明也成为了可能，取而代之的是仅仅声明在上 下文中负责注册beans的类 ApplicationContextInitializer —— 例如，从XML文件或配置类中以编程方式 加载bean定义。

@RunWith(SpringJUnit4ClassRunner.class)
// ApplicationContext 将被EntireAppInitializer初始化，假定EntireAppInitializer类在上下文中注册beans
@ContextConfiguration(initializers = EntireAppInitializer.class)
public class MyTest {
    // 类体...
}

注解 @ContextConfiguration 支持两个布尔属性 inheritLocations 和 inheritInitializers，这两个属性 指的是在潮类中声明的资源位置、注解类或上下文初始化器是否可以 继承 。它们两个的默认值都是 true。那意味着一个测试 类默认会继承超类的资源位置、注解类或上下文初始化器的配置。确切地说，一个测试类资源位置或者是注解类配置被追加到超类声明 的资源位置或注解类的列表上。类似地，指定测试类的初始化器将会增加到超类定义的初始化集合上。因此，子类拥有 继承 资源 位置、注解类或上下文初始化器的选项。

如何 @ContextConfiguration' 的 inheritLocations 或 inheritInitializers 属性设置为 false , 测试类的资源位置、注解类或上下文初始化器配置将会替代超类的配置。

在下述的使用XML资源位置的示例中，测试类 ExtendedTest 的应用上下文 ApplicationContext 将依序从 "base-config.xml" 和 "extended-config.xml" 两个配置文件中加载。 在 "extended-config.xml" 配置文件中定义的beans将会 覆盖 （例如，替换）在 "base-config.xml" 配置文件中定义的beans。

@RunWith(SpringJUnit4ClassRunner.class)
// 应用上下文ApplicationContext将从类路径根下的配置文件"/base-config.xml"中加载
@ContextConfiguration("/base-config.xml")
public class BaseTest {
    // 类体...
}

// 应用上下文ApplicationContext将从类路径根下的配置文件 "/base-config.xml"和"/extended-config.xml"中加载
@ContextConfiguration("/extended-config.xml")
public class ExtendedTest extends BaseTest {
    // 类体...
}

类似的，在下述使用注解类的示例中，ExtendedTest 的应用上下文 ApplicationContext 将会从 BaseConfig 和 ExtendedConfig 两个配置类中加载。在配置类 ExtendedConfig 中定义的beans因此将会覆盖在 BaseConfig 配置类中 定义的beans。

@RunWith(SpringJUnit4ClassRunner.class)
// 应用上下文ApplicationContext将从配置类BaseConfig中加载
@ContextConfiguration(classes = BaseConfig.class)
public class BaseTest {
    // 类体...
}

// 应用上下文ApplicationContext将从配置类BaseConfig 和 ExtendedConfig中加载
@ContextConfiguration(classes = ExtendedConfig.class)
public class ExtendedTest extends BaseTest {
    // 类体...
}

在下述使用上下文初始化器的示例中，测试类 ExtendedTest 的应用上下文 ApplicationContext 将使用初始化器 BaseInitializer 和 ExtendedInitializer 进行初始化。 注意，尽管如此，初始化器的调用顺序依赖于它们 是否实现了Spring的 Ordered 接口，加注 @Order 注解或是标准的 @Priority 注解。

@RunWith(SpringJUnit4ClassRunner.class)
// 应用上下文ApplicationContext 将通过初始化器BaseInitializer进行初始化
@ContextConfiguration(initializers = BaseInitializer.class)
public class BaseTest {
    // 类体...
}

// 应用上下文ApplicationContext 将通过BaseInitializer和ExtendedInitializer进行初始化
@ContextConfiguration(initializers = ExtendedInitializer.class)
public class ExtendedTest extends BaseTest {
    // 类体...
}

在Spring 3.1对环境和概要（也称为 bean 定义概要）的符号表示法引入了优秀的支持，集成测试可以 为各种不同的测试场景配置为可以激活特定的bean 定义概要。这些可以通过在测试类上增加 @ActiveProfiles 注解并为之提供一个概要的列表，这个概要列表将在为测试类加载应用上下文 ApplicationContext 的时候被 激活。

让我们看一些基于XML配置和基于配置类注解@Configuration的示例。

<!-- app-config.xml -->
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xsi:schemaLocation="...">

    <bean id="transferService"
            class="com.bank.service.internal.DefaultTransferService">
        <constructor-arg ref="accountRepository"/>
        <constructor-arg ref="feePolicy"/>
    </bean>

    <bean id="accountRepository"
            class="com.bank.repository.internal.JdbcAccountRepository">
        <constructor-arg ref="dataSource"/>
    </bean>

    <bean id="feePolicy"
        class="com.bank.service.internal.ZeroFeePolicy"/>

    <beans profile="dev">
        <jdbc:embedded-database id="dataSource">
            <jdbc:script
                location="classpath:com/bank/config/sql/schema.sql"/>
            <jdbc:script
                location="classpath:com/bank/config/sql/test-data.sql"/>
        </jdbc:embedded-database>
    </beans>

    <beans profile="production">
        <jee:jndi-lookup id="dataSource" jndi-name="java:comp/env/jdbc/datasource"/>
    </beans>

    <beans profile="default">
        <jdbc:embedded-database id="dataSource">
            <jdbc:script
                location="classpath:com/bank/config/sql/schema.sql"/>
        </jdbc:embedded-database>
    </beans>

</beans>

package com.bank.service;

@RunWith(SpringJUnit4ClassRunner.class)
// 应用上下文 ApplicationContext 将从配置文件 "classpath:/app-config.xml" 中加载
@ContextConfiguration("/app-config.xml")
@ActiveProfiles("dev")
public class TransferServiceTest {

    @Autowired
    private TransferService transferService;

    @Test
    public void testTransferService() {
        // test the transferService
    }
}

当测试类 TransferServiceTest 运行的时候，它的应用上下文 ApplicationContext 将从类路径根下的 配置文件 app-config.xml 中加载。如果检查配置文件，你会注意到bean accountRepository 依赖bean dataSource ;尽管如此，dataSource bean并没有被定义为一个顶层的bean。相反，它被定义了三次：分别 在 product 概要，dev 概要，以及 default 概要中。

通过使用 @ActiveProfiles("dev") 注解测试类 TransferServiceTest ，我们提示Spring 测试框架 使用激活的概要 {"dev"} 来加载应用上下文 ApplicationContext 。 于是，一个嵌入式数据库将被创建 并存储测试数据，并且 accountRepository bean将注入一个开发的 DataSource。这也是我们想在集成 测试中希望的。

将bean分配给 default 的概要有时候是很有用的。默认概要中的bean仅当没有其他的概要被激活时使用。这可以被 用来定义一个 fallback bean，该bean被用于应用的默认状态。例如，你可以显式地提供一个 dev 概要和一个 product 概要，但是当这两个都没有激活的情况下，你可以定义一个内存数据源作为默认值。

下述的示例代码演示了如何使用 @Configuration 类来实现与XML相同的配置。

@Configuration
@Profile("dev")
public class StandaloneDataConfig {

    @Bean
    public DataSource dataSource() {
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.HSQL)
            .addScript("classpath:com/bank/config/sql/schema.sql")
            .addScript("classpath:com/bank/config/sql/test-data.sql")
            .build();
    }
}

@Configuration
@Profile("production")
public class JndiDataConfig {

    @Bean
    public DataSource dataSource() throws Exception {
        Context ctx = new InitialContext();
        return (DataSource) ctx.lookup("java:comp/env/jdbc/datasource");
    }
}

@Configuration
@Profile("default")
public class DefaultDataConfig {

    @Bean
    public DataSource dataSource() {
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.HSQL)
            .addScript("classpath:com/bank/config/sql/schema.sql")
            .build();
    }
}

@Configuration
public class TransferServiceConfig {

    @Autowired DataSource dataSource;

    @Bean
    public TransferService transferService() {
        return new DefaultTransferService(accountRepository(), feePolicy());
    }

    @Bean
    public AccountRepository accountRepository() {
        return new JdbcAccountRepository(dataSource);
    }

    @Bean
    public FeePolicy feePolicy() {
        return new ZeroFeePolicy();
    }

}

package com.bank.service;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {
        TransferServiceConfig.class,
        StandaloneDataConfig.class,
        JndiDataConfig.class,
        DefaultDataConfig.class})
@ActiveProfiles("dev")
public class TransferServiceTest {

    @Autowired
    private TransferService transferService;

    @Test
    public void testTransferService() {
        // 测试相关逻辑
    }
}

这次的变化，我们将XML配置拆分成了四个独立注解了 @Configuration 的配置类：

在使用基于XML的配置示例中， 我们仍然使用 @ActiveProfiles("dev") 注解测试类 TransferServiceTest ， 但是这次我们通过注解 @ContextConfiguration指定了所有的四个配置类。测试类的本身没有发生任何改变。

通常的用例是在一个项目中跨越多个测试类使用一组概要配置。因此，为了避免注解 @ActiveProfiles 的 重复声明，可以在一个基类上只声明一次注解 @ActiveProfiles， 其子类将自动的继承父类的注解配置。在下列 的示例中，注解 @ActiveProfiles 的声明被移入了抽象超类 AbstractIntegrationTest 中。

package com.bank.service;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {
        TransferServiceConfig.class,
        StandaloneDataConfig.class,
        JndiDataConfig.class,
        DefaultDataConfig.class})
@ActiveProfiles("dev")
public abstract class AbstractIntegrationTest {
}

package com.bank.service;

// "dev" 概要从超类中继承
public class TransferServiceTest extends AbstractIntegrationTest {

    @Autowired
    private TransferService transferService;

    @Test
    public void testTransferService() {
        // 测试逻辑
    }
}

注解 @ActiveProfiles 也支持一个 inheritProfiles 属性，该属性可以用来禁止激活概要的继承特性。

package com.bank.service;

// "dev" 概要被 "production" 概要覆盖
@ActiveProfiles(profiles = "production", inheritProfiles = false)
public class ProductionTransferServiceTest extends AbstractIntegrationTest {
    // 测试体
}

此外，有些时候为测试类采用 可编程 的方式而非声明的方式解析激活的概要是必要的 —— 例如， 基于：

为了可编程地解析活动bean定义概要，简单地实现一个自定义的活动概要解析器 ActiveProfilesResolver 并 通过注解 @ActiveProfiles 的属性 resolver 来注册上。 下列的示例演示了如何实现一个用户自定义的 活动概要解析器 OperatingSystemActiveProfilesResolver 并注册之。想了解进一步的信息，可参考相关 的javadoc。

package com.bank.service;

// 通过自定义的解析器以编程方式覆盖 "dev" 概要
@ActiveProfiles(
    resolver = OperatingSystemActiveProfilesResolver.class,
    inheritProfiles = false)
public class TransferServiceTest extends AbstractIntegrationTest {
    // 测试体
}

package com.bank.service.test;

public class OperatingSystemActiveProfilesResolver implements ActiveProfilesResolver {

    @Override
    String[] resolve(Class<?> testClass) {
        String profile = ...;
        // 基于操作系统决定概要的取值
        return new String[] {profile};
    }
}

Spring 3.1 introduced first-class support in the framework for the notion of an environment with a hierarchy of property sources, and since Spring 4.1 integration tests can be configured with test-specific property sources. In contrast to the @PropertySource annotation used on @Configuration classes, the @TestPropertySource annotation can be declared on a test class to declare resource locations for test properties files or inlined properties. These test property sources will be added to the Environment's set of PropertySources for the ApplicationContext loaded for the annotated integration test.

Declaring test property sources

Test properties files can be configured via the locations or value attribute of @TestPropertySource as shown in the following example.

Both traditional and XML-based properties file formats are supported — for example, "classpath:/com/example/test.properties" or "file:///path/to/file.xml".

Each path will be interpreted as a Spring Resource. A plain path — for example, "test.properties" — will be treated as a classpath resource that is relative to the package in which the test class is defined. A path starting with a slash will be treated as an absolute classpath resource, for example: "/org/example/test.xml". A path which references a URL (e.g., a path prefixed with classpath:, file:, http:, etc.) will be loaded using the specified resource protocol. Resource location wildcards (e.g. **/*.properties) are not permitted: each location must evaluate to exactly one .properties or .xml resource.

@ContextConfiguration
@TestPropertySource("/test.properties")
public class MyIntegrationTests {
    // class body...
}

Inlined properties in the form of key-value pairs can be configured via the properties attribute of @TestPropertySource as shown in the following example. All key-value pairs will be added to the enclosing Environment as a single test PropertySource with the highest precedence.

The supported syntax for key-value pairs is the same as the syntax defined for entries in a Java properties file:

@ContextConfiguration
@TestPropertySource(properties = {"timezone = GMT", "port: 4242"})
public class MyIntegrationTests {
    // class body...
}

Default properties file detection

If @TestPropertySource is declared as an empty annotation (i.e., without explicit values for the locations or properties attributes), an attempt will be made to detect a default properties file relative to the class that declared the annotation. For example, if the annotated test class is com.example.MyTest, the corresponding default properties file is "classpath:com/example/MyTest.properties". If the default cannot be detected, an IllegalStateException will be thrown.

Precedence

Test property sources have higher precedence than those loaded from the operating system’s environment or Java system properties as well as property sources added by the application declaratively via @PropertySource or programmatically. Thus, test property sources can be used to selectively override properties defined in system and application property sources. Furthermore, inlined properties have higher precedence than properties loaded from resource locations.

In the following example, the timezone and port properties as well as any properties defined in "/test.properties" will override any properties of the same name that are defined in system and application property sources. Furthermore, if the "/test.properties" file defines entries for the timezone and port properties those will be overridden by the inlined properties declared via the properties attribute.

@ContextConfiguration
@TestPropertySource(
    locations = "/test.properties",
    properties = {"timezone = GMT", "port: 4242"}
)
public class MyIntegrationTests {
    // class body...
}

Inheriting and overriding test property sources

@TestPropertySource supports boolean inheritLocations and inheritProperties attributes that denote whether resource locations for properties files and inlined properties declared by superclasses should be inherited. The default value for both flags is true. This means that a test class inherits the locations and inlined properties declared by any superclasses. Specifically, the locations and inlined properties for a test class are appended to the locations and inlined properties declared by superclasses. Thus, subclasses have the option of extending the locations and inlined properties. Note that properties that appear later will shadow (i.e.., override) properties of the same name that appear earlier. In addition, the aforementioned precedence rules apply for inherited test property sources as well.

If @TestPropertySource's inheritLocations or inheritProperties attribute is set to false, the locations or inlined properties, respectively, for the test class shadow and effectively replace the configuration defined by superclasses.

In the following example, the ApplicationContext for BaseTest will be loaded using only the "base.properties" file as a test property source. In contrast, the ApplicationContext for ExtendedTest will be loaded using the "base.properties" and "extended.properties" files as test property source locations.

@TestPropertySource("base.properties")
@ContextConfiguration
public class BaseTest {
    // ...
}

@TestPropertySource("extended.properties")
@ContextConfiguration
public class ExtendedTest extends BaseTest {
    // ...
}

In the following example, the ApplicationContext for BaseTest will be loaded using only the inlined key1 property. In contrast, the ApplicationContext for ExtendedTest will be loaded using the inlined key1 and key2 properties.

@TestPropertySource(properties = "key1 = value1")
@ContextConfiguration
public class BaseTest {
    // ...
}

@TestPropertySource(properties = "key2 = value2")
@ContextConfiguration
public class ExtendedTest extends BaseTest {
    // ...
}

Spring 3.2 introduced support for loading a WebApplicationContext in integration tests. To instruct the TestContext framework to load a WebApplicationContext instead of a standard ApplicationContext, simply annotate the respective test class with @WebAppConfiguration.

The presence of @WebAppConfiguration on your test class instructs the TestContext framework (TCF) that a WebApplicationContext (WAC) should be loaded for your integration tests. In the background the TCF makes sure that a MockServletContext is created and supplied to your test’s WAC. By default the base resource path for your MockServletContext will be set to "src/main/webapp". This is interpreted as a path relative to the root of your JVM (i.e., normally the path to your project). If you’re familiar with the directory structure of a web application in a Maven project, you’ll know that "src/main/webapp" is the default location for the root of your WAR. If you need to override this default, simply provide an alternate path to the @WebAppConfiguration annotation (e.g., @WebAppConfiguration("src/test/webapp")). If you wish to reference a base resource path from the classpath instead of the file system, just use Spring’s classpath: prefix.

Please note that Spring’s testing support for WebApplicationContexts is on par with its support for standard ApplicationContexts. When testing with a WebApplicationContext you are free to declare either XML configuration files or @Configuration classes via @ContextConfiguration. You are of course also free to use any other test annotations such as @TestExecutionListeners, @TransactionConfiguration, @ActiveProfiles, etc.

The following examples demonstrate some of the various configuration options for loading a WebApplicationContext.

Conventions. 

@RunWith(SpringJUnit4ClassRunner.class)

// defaults to "file:src/main/webapp"
@WebAppConfiguration

// detects "WacTests-context.xml" in same package
// or static nested @Configuration class
@ContextConfiguration

public class WacTests {
    //...
}

The above example demonstrates the TestContext framework’s support for convention over configuration. If you annotate a test class with @WebAppConfiguration without specifying a resource base path, the resource path will effectively default to "file:src/main/webapp". Similarly, if you declare @ContextConfiguration without specifying resource locations, annotated classes, or context initializers, Spring will attempt to detect the presence of your configuration using conventions (i.e., "WacTests-context.xml" in the same package as the WacTests class or static nested @Configuration classes).

Default resource semantics. 

@RunWith(SpringJUnit4ClassRunner.class)

// file system resource
@WebAppConfiguration("webapp")

// classpath resource
@ContextConfiguration("/spring/test-servlet-config.xml")

public class WacTests {
    //...
}

This example demonstrates how to explicitly declare a resource base path with @WebAppConfiguration and an XML resource location with @ContextConfiguration. The important thing to note here is the different semantics for paths with these two annotations. By default, @WebAppConfiguration resource paths are file system based; whereas, @ContextConfiguration resource locations are classpath based.

Explicit resource semantics. 

@RunWith(SpringJUnit4ClassRunner.class)

// classpath resource
@WebAppConfiguration("classpath:test-web-resources")

// file system resource
@ContextConfiguration("file:src/main/webapp/WEB-INF/servlet-config.xml")

public class WacTests {
    //...
}

In this third example, we see that we can override the default resource semantics for both annotations by specifying a Spring resource prefix. Contrast the comments in this example with the previous example.

To provide comprehensive web testing support, Spring 3.2 introduced a ServletTestExecutionListener that is enabled by default. When testing against a WebApplicationContext this TestExecutionListener sets up default thread-local state via Spring Web’s RequestContextHolder before each test method and creates a MockHttpServletRequest, MockHttpServletResponse, and ServletWebRequest based on the base resource path configured via @WebAppConfiguration. ServletTestExecutionListener also ensures that the MockHttpServletResponse and ServletWebRequest can be injected into the test instance, and once the test is complete it cleans up thread-local state.

Once you have a WebApplicationContext loaded for your test you might find that you need to interact with the web mocks — for example, to set up your test fixture or to perform assertions after invoking your web component. The following example demonstrates which mocks can be autowired into your test instance. Note that the WebApplicationContext and MockServletContext are both cached across the test suite; whereas, the other mocks are managed per test method by the ServletTestExecutionListener.

Injecting mocks. 

@WebAppConfiguration
@ContextConfiguration
public class WacTests {

    @Autowired
    WebApplicationContext wac; // cached

    @Autowired
    MockServletContext servletContext; // cached

    @Autowired
    MockHttpSession session;

    @Autowired
    MockHttpServletRequest request;

    @Autowired
    MockHttpServletResponse response;

    @Autowired
    ServletWebRequest webRequest;

    //...
}

Once the TestContext framework loads an ApplicationContext (or WebApplicationContext) for a test, that context will be cached and reused for all subsequent tests that declare the same unique context configuration within the same test suite. To understand how caching works, it is important to understand what is meant by unique and test suite.

An ApplicationContext can be uniquely identified by the combination of configuration parameters that are used to load it. Consequently, the unique combination of configuration parameters are used to generate a key under which the context is cached. The TestContext framework uses the following configuration parameters to build the context cache key:

For example, if TestClassA specifies {"app-config.xml", "test-config.xml"} for the locations (or value) attribute of @ContextConfiguration, the TestContext framework will load the corresponding ApplicationContext and store it in a static context cache under a key that is based solely on those locations. So if TestClassB also defines {"app-config.xml", "test-config.xml"} for its locations (either explicitly or implicitly through inheritance) but does not define @WebAppConfiguration, a different ContextLoader, different active profiles, different context initializers, different test property sources, or a different parent context, then the same ApplicationContext will be shared by both test classes. This means that the setup cost for loading an application context is incurred only once (per test suite), and subsequent test execution is much faster.

Since having a large number of application contexts loaded within a given test suite can cause the suite to take an unnecessarily long time to execute, it is often beneficial to know exactly how many contexts have been loaded and cached. To view the statistics for the underlying context cache, simply set the log level for the org.springframework.test.context.cache logging category to DEBUG.

In the unlikely case that a test corrupts the application context and requires reloading — for example, by modifying a bean definition or the state of an application object — you can annotate your test class or test method with @DirtiesContext (see the discussion of @DirtiesContext in the section called “Spring 测试相关注解”). This instructs Spring to remove the context from the cache and rebuild the application context before executing the next test. Note that support for the @DirtiesContext annotation is provided by the DirtiesContextTestExecutionListener which is enabled by default.

When writing integration tests that rely on a loaded Spring ApplicationContext, it is often sufficient to test against a single context; however, there are times when it is beneficial or even necessary to test against a hierarchy of ApplicationContexts. For example, if you are developing a Spring MVC web application you will typically have a root WebApplicationContext loaded via Spring’s ContextLoaderListener and a child WebApplicationContext loaded via Spring’s DispatcherServlet. This results in a parent-child context hierarchy where shared components and infrastructure configuration are declared in the root context and consumed in the child context by web-specific components. Another use case can be found in Spring Batch applications where you often have a parent context that provides configuration for shared batch infrastructure and a child context for the configuration of a specific batch job.

As of Spring Framework 3.2.2, it is possible to write integration tests that use context hierarchies by declaring context configuration via the @ContextHierarchy annotation, either on an individual test class or within a test class hierarchy. If a context hierarchy is declared on multiple classes within a test class hierarchy it is also possible to merge or override the context configuration for a specific, named level in the context hierarchy. When merging configuration for a given level in the hierarchy the configuration resource type (i.e., XML configuration files or annotated classes) must be consistent; otherwise, it is perfectly acceptable to have different levels in a context hierarchy configured using different resource types.

The following JUnit-based examples demonstrate common configuration scenarios for integration tests that require the use of context hierarchies.

ControllerIntegrationTests represents a typical integration testing scenario for a Spring MVC web application by declaring a context hierarchy consisting of two levels, one for the root WebApplicationContext (loaded using the TestAppConfig @Configuration class) and one for the dispatcher servlet WebApplicationContext (loaded using the WebConfig @Configuration class). The WebApplicationContext that is autowired into the test instance is the one for the child context (i.e., the lowest context in the hierarchy).

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextHierarchy({
    @ContextConfiguration(classes = TestAppConfig.class),
    @ContextConfiguration(classes = WebConfig.class)
})
public class ControllerIntegrationTests {

    @Autowired
    private WebApplicationContext wac;

    // ...
}

The following test classes define a context hierarchy within a test class hierarchy. AbstractWebTests declares the configuration for a root WebApplicationContext in a Spring-powered web application. Note, however, that AbstractWebTests does not declare @ContextHierarchy; consequently, subclasses of AbstractWebTests can optionally participate in a context hierarchy or simply follow the standard semantics for @ContextConfiguration. SoapWebServiceTests and RestWebServiceTests both extend AbstractWebTests and define a context hierarchy via @ContextHierarchy. The result is that three application contexts will be loaded (one for each declaration of @ContextConfiguration), and the application context loaded based on the configuration in AbstractWebTests will be set as the parent context for each of the contexts loaded for the concrete subclasses.

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration("file:src/main/webapp/WEB-INF/applicationContext.xml")
public abstract class AbstractWebTests {}

@ContextHierarchy(@ContextConfiguration("/spring/soap-ws-config.xml")
public class SoapWebServiceTests extends AbstractWebTests {}

@ContextHierarchy(@ContextConfiguration("/spring/rest-ws-config.xml")
public class RestWebServiceTests extends AbstractWebTests {}

The following classes demonstrate the use of named hierarchy levels in order to merge the configuration for specific levels in a context hierarchy. BaseTests defines two levels in the hierarchy, parent and child. ExtendedTests extends BaseTests and instructs the Spring TestContext Framework to merge the context configuration for the child hierarchy level, simply by ensuring that the names declared via ContextConfiguration's name attribute are both "child". The result is that three application contexts will be loaded: one for "/app-config.xml", one for "/user-config.xml", and one for {"/user-config.xml", "/order-config.xml"}. As with the previous example, the application context loaded from "/app-config.xml" will be set as the parent context for the contexts loaded from "/user-config.xml" and {"/user-config.xml", "/order-config.xml"}.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextHierarchy({
    @ContextConfiguration(name = "parent", locations = "/app-config.xml"),
    @ContextConfiguration(name = "child", locations = "/user-config.xml")
})
public class BaseTests {}

@ContextHierarchy(
    @ContextConfiguration(name = "child", locations = "/order-config.xml")
)
public class ExtendedTests extends BaseTests {}

In contrast to the previous example, this example demonstrates how to override the configuration for a given named level in a context hierarchy by setting ContextConfiguration's inheritLocations flag to false. Consequently, the application context for ExtendedTests will be loaded only from "/test-user-config.xml" and will have its parent set to the context loaded from "/app-config.xml".

@RunWith(SpringJUnit4ClassRunner.class)
@ContextHierarchy({
    @ContextConfiguration(name = "parent", locations = "/app-config.xml"),
    @ContextConfiguration(name = "child", locations = "/user-config.xml")
})
public class BaseTests {}

@ContextHierarchy(
    @ContextConfiguration(
        name = "child",
        locations = "/test-user-config.xml",
        inheritLocations = false
))
public class ExtendedTests extends BaseTests {}

Test-managed transactions are transactions that are managed declaratively via the TransactionalTestExecutionListener or programmatically via TestTransaction (see below). Such transactions should not be confused with Spring-managed transactions (i.e., those managed directly by Spring within the ApplicationContext loaded for tests) or application-managed transactions (i.e., those managed programmatically within application code that is invoked via tests). Spring-managed and application-managed transactions will typically participate in test-managed transactions; however, caution should be taken if Spring-managed or application-managed transactions are configured with any propagation type other than REQUIRED or SUPPORTS (see the discussion on transaction propagation for details).

Annotating a test method with @Transactional causes the test to be run within a transaction that will, by default, be automatically rolled back after completion of the test. If a test class is annotated with @Transactional, each test method within that class hierarchy will be run within a transaction. Test methods that are not annotated with @Transactional (at the class or method level) will not be run within a transaction. Furthermore, tests that are annotated with @Transactional but have the propagation type set to NOT_SUPPORTED will not be run within a transaction.

Note that AbstractTransactionalJUnit4SpringContextTests and AbstractTransactionalTestNGSpringContextTests are preconfigured for transactional support at the class level.

The following example demonstrates a common scenario for writing an integration test for a Hibernate-based UserRepository. As explained in the section called “Transaction rollback and commit behavior”, there is no need to clean up the database after the createUser() method is executed since any changes made to the database will be automatically rolled back by the TransactionalTestExecutionListener. See Section 10.15.7, “PetClinic Example” for an additional example.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = TestConfig.class)
@Transactional
public class HibernateUserRepositoryTests {

    @Autowired
    HibernateUserRepository repository;

    @Autowired
    SessionFactory sessionFactory;

    JdbcTemplate jdbcTemplate;

    @Autowired
    public void setDataSource(DataSource dataSource) {
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }

    @Test
    public void createUser() {
        // track initial state in test database:
        final int count = countRowsInTable("user");

        User user = new User(...);
        repository.save(user);

        // Manual flush is required to avoid false positive in test
        sessionFactory.getCurrentSession().flush();
        assertNumUsers(count + 1);
    }

    protected int countRowsInTable(String tableName) {
        return JdbcTestUtils.countRowsInTable(this.jdbcTemplate, tableName);
    }

    protected void assertNumUsers(int expected) {
        assertEquals("Number of rows in the 'user' table.", expected, countRowsInTable("user"));
    }
}

By default, test transactions will be automatically rolled back after completion of the test; however, transactional commit and rollback behavior can be configured declaratively via the class-level @TransactionConfiguration and method-level @Rollback annotations. See the corresponding entries in the annotation support section for further details.

As of Spring Framework 4.1, it is possible to interact with test-managed transactions programmatically via the static methods in TestTransaction. For example, TestTransaction may be used within test methods, before methods, and after methods to start or end the current test-managed transaction or to configure the current test-managed transaction for rollback or commit. Support for TestTransaction is automatically available whenever the TransactionalTestExecutionListener is enabled.

The following example demonstrates some of the features of TestTransaction. Consult the javadocs for TestTransaction for further details.

@ContextConfiguration(classes = TestConfig.class)
public class ProgrammaticTransactionManagementTests extends
        AbstractTransactionalJUnit4SpringContextTests {

    @Test
    public void transactionalTest() {
        // assert initial state in test database:
        assertNumUsers(2);

        deleteFromTables("user");

        // changes to the database will be committed!
        TestTransaction.flagForCommit();
        TestTransaction.end();
        assertFalse(TestTransaction.isActive());
        assertNumUsers(0);

        TestTransaction.start();
        // perform other actions against the database that will
        // be automatically rolled back after the test completes...
    }

    protected void assertNumUsers(int expected) {
        assertEquals("Number of rows in the 'user' table.", expected, countRowsInTable("user"));
    }
}

Occasionally you need to execute certain code before or after a transactional test method but outside the transactional context — for example, to verify the initial database state prior to execution of your test or to verify expected transactional commit behavior after test execution (if the test was configured not to roll back the transaction). TransactionalTestExecutionListener supports the @BeforeTransaction and @AfterTransaction annotations exactly for such scenarios. Simply annotate any public void method in your test class with one of these annotations, and the TransactionalTestExecutionListener ensures that your before transaction method or after transaction method is executed at the appropriate time.

TransactionalTestExecutionListener expects a PlatformTransactionManager bean to be defined in the Spring ApplicationContext for the test. In case there are multiple instances of PlatformTransactionManager within the test’s ApplicationContext, @TransactionConfiguration supports configuring the bean name of the PlatformTransactionManager that should be used to drive transactions. Alternatively, a qualifier may be declared via @Transactional("myQualifier"), or TransactionManagementConfigurer can be implemented by an @Configuration class. Consult the javadocs for TestContextTransactionUtils.retrieveTransactionManager() for details on the algorithm used to look up a transaction manager in the test’s ApplicationContext.

The following JUnit-based example displays a fictitious integration testing scenario highlighting all transaction-related annotations. The example is not intended to demonstrate best practices but rather to demonstrate how these annotations can be used. Consult the annotation support section for further information and configuration examples. Transaction management for @Sql contains an additional example using @Sql for declarative SQL script execution with default transaction rollback semantics.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@TransactionConfiguration(transactionManager="txMgr", defaultRollback=false)
@Transactional
public class FictitiousTransactionalTest {

    @BeforeTransaction
    public void verifyInitialDatabaseState() {
        // logic to verify the initial state before a transaction is started
    }

    @Before
    public void setUpTestDataWithinTransaction() {
        // set up test data within the transaction
    }

    @Test
    // overrides the class-level defaultRollback setting
    @Rollback(true)
    public void modifyDatabaseWithinTransaction() {
        // logic which uses the test data and modifies database state
    }

    @After
    public void tearDownWithinTransaction() {
        // execute "tear down" logic within the transaction
    }

    @AfterTransaction
    public void verifyFinalDatabaseState() {
        // logic to verify the final state after transaction has rolled back
    }

}

Spring provides the following options for executing SQL scripts programmatically within integration test methods.

ScriptUtils provides a collection of static utility methods for working with SQL scripts and is mainly intended for internal use within the framework. However, if you require full control over how SQL scripts are parsed and executed, ScriptUtils may suit your needs better than some of the other alternatives described below. Consult the javadocs for individual methods in ScriptUtils for further details.

ResourceDatabasePopulator provides a simple object-based API for programmatically populating, initializing, or cleaning up a database using SQL scripts defined in external resources. ResourceDatabasePopulator provides options for configuring the character encoding, statement separator, comment delimiters, and error handling flags used when parsing and executing the scripts, and each of the configuration options has a reasonable default value. Consult the javadocs for details on default values. To execute the scripts configured in a ResourceDatabasePopulator, you can invoke either the populate(Connection) method to execute the populator against a java.sql.Connection or the execute(DataSource) method to execute the populator against a javax.sql.DataSource. The following example specifies SQL scripts for a test schema and test data, sets the statement separator to "@@", and then executes the scripts against a DataSource.

@Test
public void databaseTest {
    ResourceDatabasePopulator populator = new ResourceDatabasePopulator();
    populator.addScripts(
        new ClassPathResource("test-schema.sql"),
        new ClassPathResource("test-data.sql"));
    populator.setSeparator("@@");
    populator.execute(this.dataSource);
    // execute code that uses the test schema and data
}

Note that ResourceDatabasePopulator internally delegates to ScriptUtils for parsing and executing SQL scripts. Similarly, the executeSqlScript(..) methods in AbstractTransactionalJUnit4SpringContextTests and AbstractTransactionalTestNGSpringContextTests internally use a ResourceDatabasePopulator for executing SQL scripts. Consult the javadocs for the various executeSqlScript(..) methods for further details.

In addition to the aforementioned mechanisms for executing SQL scripts programmatically, SQL scripts can also be configured declaratively in the Spring TestContext Framework. Specifically, the @Sql annotation can be declared on a test class or test method to configure the resource paths to SQL scripts that should be executed against a given database either before or after an integration test method. Note that method-level declarations override class-level declarations and that support for @Sql is provided by the SqlScriptsTestExecutionListener which is enabled by default.

Path resource semantics

Each path will be interpreted as a Spring Resource. A plain path — for example, "schema.sql" — will be treated as a classpath resource that is relative to the package in which the test class is defined. A path starting with a slash will be treated as an absolute classpath resource, for example: "/org/example/schema.sql". A path which references a URL (e.g., a path prefixed with classpath:, file:, http:, etc.) will be loaded using the specified resource protocol.

The following example demonstrates how to use @Sql at the class level and at the method level within a JUnit-based integration test class.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@Sql("/test-schema.sql")
public class DatabaseTests {

    @Test
    public void emptySchemaTest {
        // execute code that uses the test schema without any test data
    }

    @Test
    @Sql({"/test-schema.sql", "/test-user-data.sql"})
    public void userTest {
        // execute code that uses the test schema and test data
    }
}

Default script detection

If no SQL scripts are specified, an attempt will be made to detect a default script depending on where @Sql is declared. If a default cannot be detected, an IllegalStateException will be thrown.

Declaring multiple @Sql sets

If multiple sets of SQL scripts need to be configured for a given test class or test method but with different syntax configuration, different error handling rules, or different execution phases per set, it is possible to declare multiple instances of @Sql. With Java 8, @Sql can be used as a repeatable annotation. Otherwise, the @SqlGroup annotation can be used as an explicit container for declaring multiple instances of @Sql.

The following example demonstrates the use of @Sql as a repeatable annotation using Java 8. In this scenario the test-schema.sql script uses a different syntax for single-line comments.

@Test
@Sql(scripts = "/test-schema.sql", config = @SqlConfig(commentPrefix = "`"))
@Sql("/test-user-data.sql")
public void userTest {
    // execute code that uses the test schema and test data
}

The following example is identical to the above except that the @Sql declarations are grouped together within @SqlGroup for compatibility with Java 6 and Java 7.

@Test
@SqlGroup({
    @Sql(scripts = "/test-schema.sql", config = @SqlConfig(commentPrefix = "`")),
    @Sql("/test-user-data.sql")
)}
public void userTest {
    // execute code that uses the test schema and test data
}

Script execution phases

By default, SQL scripts will be executed before the corresponding test method. However, if a particular set of scripts needs to be executed after the test method — for example, to clean up database state — the executionPhase attribute in @Sql can be used as seen in the following example. Note that ISOLATED and AFTER_TEST_METHOD are statically imported from Sql.TransactionMode and Sql.ExecutionPhase respectively.

@Test
@Sql(
    scripts = "create-test-data.sql",
    config = @SqlConfig(transactionMode = ISOLATED)
)
@Sql(
    scripts = "delete-test-data.sql",
    config = @SqlConfig(transactionMode = ISOLATED),
    executionPhase = AFTER_TEST_METHOD
)
public void userTest {
    // execute code that needs the test data to be committed
    // to the database outside of the test's transaction
}

Script configuration with @SqlConfig

Configuration for script parsing and error handling can be configured via the @SqlConfig annotation. When declared as a class-level annotation on an integration test class, @SqlConfig serves as global configuration for all SQL scripts within the test class hierarchy. When declared directly via the config attribute of the @Sql annotation, @SqlConfig serves as local configuration for the SQL scripts declared within the enclosing @Sql annotation. Every attribute in @SqlConfig has an implicit default value which is documented in the javadocs of the corresponding attribute. Due to the rules defined for annotation attributes in the Java Language Specification, it is unfortunately not possible to assign a value of null to an annotation attribute. Thus, in order to support overrides of inherited global configuration, @SqlConfig attributes have an explicit default value of either "" for Strings or DEFAULT for Enums. This approach allows local declarations of @SqlConfig to selectively override individual attributes from global declarations of @SqlConfig by providing a value other than "" or DEFAULT. Global @SqlConfig attributes are inherited whenever local @SqlConfig attributes do not supply an explicit value other than "" or DEFAULT. Explicit local configuration therefore overrides global configuration.

The configuration options provided by @Sql and @SqlConfig are equivalent to those supported by ScriptUtils and ResourceDatabasePopulator but are a superset of those provided by the <jdbc:initialize-database/> XML namespace element. Consult the javadocs of individual attributes in @Sql and @SqlConfig for details.

Transaction management for @Sql

By default, the SqlScriptsTestExecutionListener will infer the desired transaction semantics for scripts configured via @Sql. Specifically, SQL scripts will be executed without a transaction, within an existing Spring-managed transaction — for example, a transaction managed by the TransactionalTestExecutionListener for a test annotated with @Transactional — or within an isolated transaction, depending on the configured value of the transactionMode attribute in @SqlConfig and the presence of a PlatformTransactionManager in the test’s ApplicationContext. As a bare minimum however, a javax.sql.DataSource must be present in the test’s ApplicationContext.

If the algorithms used by SqlScriptsTestExecutionListener to detect a DataSource and PlatformTransactionManager and infer the transaction semantics do not suit your needs, you may specify explicit names via the dataSource and transactionManager attributes of @SqlConfig. Furthermore, the transaction propagation behavior can be controlled via the transactionMode attribute of @SqlConfig — for example, if scripts should be executed in an isolated transaction. Although a thorough discussion of all supported options for transaction management with @Sql is beyond the scope of this reference manual, the javadocs for @SqlConfig and SqlScriptsTestExecutionListener provide detailed information, and the following example demonstrates a typical testing scenario using JUnit and transactional tests with @Sql. Note that there is no need to clean up the database after the usersTest() method is executed since any changes made to the database (either within the the test method or within the /test-data.sql script) will be automatically rolled back by the TransactionalTestExecutionListener (see transaction management for details).

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = TestDatabaseConfig.class)
@Transactional
public class TransactionalSqlScriptsTests {

    protected JdbcTemplate jdbcTemplate;

    @Autowired
    public void setDataSource(DataSource dataSource) {
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }

    @Test
    @Sql("/test-data.sql")
    public void usersTest() {
        // verify state in test database:
        assertNumUsers(2);
        // execute code that uses the test data...
    }

    protected int countRowsInTable(String tableName) {
        return JdbcTestUtils.countRowsInTable(this.jdbcTemplate, tableName);
    }

    protected void assertNumUsers(int expected) {
        assertEquals("Number of rows in the 'user' table.", expected, countRowsInTable("user"));
    }
}

The org.springframework.test.context.junit4 package provides the following support classes for JUnit-based test cases.

AbstractJUnit4SpringContextTests is an abstract base test class that integrates the Spring TestContext Framework with explicit ApplicationContext testing support in a JUnit 4.9+ environment. When you extend AbstractJUnit4SpringContextTests, you can access a protected applicationContext instance variable that can be used to perform explicit bean lookups or to test the state of the context as a whole.

AbstractTransactionalJUnit4SpringContextTests is an abstract transactional extension of AbstractJUnit4SpringContextTests that adds some convenience functionality for JDBC access. This class expects a javax.sql.DataSource bean and a PlatformTransactionManager bean to be defined in the ApplicationContext. When you extend AbstractTransactionalJUnit4SpringContextTests you can access a protected jdbcTemplate instance variable that can be used to execute SQL statements to query the database. Such queries can be used to confirm database state both prior to and after execution of database-related application code, and Spring ensures that such queries run in the scope of the same transaction as the application code. When used in conjunction with an ORM tool, be sure to avoid false positives. As mentioned in Section 10.15.3, “JDBC 测试支持”, AbstractTransactionalJUnit4SpringContextTests also provides convenience methods which delegate to methods in JdbcTestUtils using the aforementioned jdbcTemplate. Furthermore, AbstractTransactionalJUnit4SpringContextTests provides an executeSqlScript(..) method for executing SQL scripts against the configured DataSource.

The Spring TestContext Framework offers full integration with JUnit 4.9+ through a custom runner (tested on JUnit 4.9 — 4.11). By annotating test classes with @RunWith(SpringJUnit4ClassRunner.class), developers can implement standard JUnit-based unit and integration tests and simultaneously reap the benefits of the TestContext framework such as support for loading application contexts, dependency injection of test instances, transactional test method execution, and so on. The following code listing displays the minimal requirements for configuring a test class to run with the custom Spring Runner. @TestExecutionListeners is configured with an empty list in order to disable the default listeners, which otherwise would require an ApplicationContext to be configured through @ContextConfiguration.

@RunWith(SpringJUnit4ClassRunner.class)
@TestExecutionListeners({})
public class SimpleTest {

    @Test
    public void testMethod() {
        // execute test logic...
    }
}

The org.springframework.test.context.testng package provides the following support classes for TestNG based test cases.

AbstractTestNGSpringContextTests is an abstract base test class that integrates the Spring TestContext Framework with explicit ApplicationContext testing support in a TestNG environment. When you extend AbstractTestNGSpringContextTests, you can access a protected applicationContext instance variable that can be used to perform explicit bean lookups or to test the state of the context as a whole.

AbstractTransactionalTestNGSpringContextTests is an abstract transactional extension of AbstractTestNGSpringContextTests that adds some convenience functionality for JDBC access. This class expects a javax.sql.DataSource bean and a PlatformTransactionManager bean to be defined in the ApplicationContext. When you extend AbstractTransactionalTestNGSpringContextTests you can access a protected jdbcTemplate instance variable that can be used to execute SQL statements to query the database. Such queries can be used to confirm database state both prior to and after execution of database-related application code, and Spring ensures that such queries run in the scope of the same transaction as the application code. When used in conjunction with an ORM tool, be sure to avoid false positives. As mentioned in Section 10.15.3, “JDBC 测试支持”, AbstractTransactionalTestNGSpringContextTests also provides convenience methods which delegate to methods in JdbcTestUtils using the aforementioned jdbcTemplate. Furthermore, AbstractTransactionalTestNGSpringContextTests provides an executeSqlScript(..) method for executing SQL scripts against the configured DataSource.

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration("test-servlet-context.xml")
public class ExampleTests {

    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @Before
    public void setup() {
        this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();
    }

    @Test
    public void getAccount() throws Exception {
        this.mockMvc.perform(get("/accounts/1").accept(MediaType.parseMediaType("application/json;charset=UTF-8")))
            .andExpect(status().isOk())
            .andExpect(content().contentType("application/json"))
            .andExpect(jsonPath("$.name").value("Lee"));
    }

}

The fluent API in the example above requires a few static imports such as MockMvcRequestBuilders.*, MockMvcResultMatchers.*, and MockMvcBuilders.*. An easy way to find these classes is to search for types matching "MockMvc*". If using Eclipse, be sure to add them as "favorite static members" in the Eclipse preferences underJava → Editor → Content Assist → Favorites. That will allow use of content assist after typing the first character of the static method name. Other IDEs (e.g. IntelliJ) may not require any additional configuration. Just check the support for code completion on static members.

The goal of server-side test setup is to create an instance of MockMvc that can be used to perform requests. There are two main options.

The first option is to point to Spring MVC configuration through the TestContext framework, which loads the Spring configuration and injects a WebApplicationContext into the test to use to create a MockMvc:

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration("my-servlet-context.xml")
public class MyWebTests {

    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @Before
    public void setup() {
        this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();
    }

    // ...

}

The second option is to simply register a controller instance without loading any Spring configuration. Instead basic Spring MVC configuration suitable for testing annotated controllers is automatically created. The created configuration is comparable to that of the MVC JavaConfig (and the MVC namespace) and can be customized to a degree through builder-style methods:

public class MyWebTests {

    private MockMvc mockMvc;

    @Before
    public void setup() {
        this.mockMvc = MockMvcBuilders.standaloneSetup(new AccountController()).build();
    }

    // ...

}

Which option should you use?

The "webAppContextSetup" loads the actual Spring MVC configuration resulting in a more complete integration test. Since the TestContext framework caches the loaded Spring configuration, it helps to keep tests running fast even as more tests get added. Furthermore, you can inject mock services into controllers through Spring configuration, in order to remain focused on testing the web layer. Here is an example of declaring a mock service with Mockito:

<bean id="accountService" class="org.mockito.Mockito" factory-method="mock">
    <constructor-arg value="org.example.AccountService"/>
</bean>

Then you can inject the mock service into the test in order set up and verify expectations:

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration("test-servlet-context.xml")
public class AccountTests {

    @Autowired
    private WebApplicationContext wac;

    private MockMvc mockMvc;

    @Autowired
    private AccountService accountService;

    // ...

}

The "standaloneSetup" on the other hand is a little closer to a unit test. It tests one controller at a time, the controller can be injected with mock dependencies manually, and it doesn’t involve loading Spring configuration. Such tests are more focused in style and make it easier to see which controller is being tested, whether any specific Spring MVC configuration is required to work, and so on. The "standaloneSetup" is also a very convenient way to write ad-hoc tests to verify some behavior or to debug an issue.

Just like with integration vs unit testing, there is no right or wrong answer. Using the "standaloneSetup" does imply the need for some additional "webAppContextSetup" tests to verify the Spring MVC configuration. Alternatively, you can decide write all tests with "webAppContextSetup" and always test against actual Spring MVC configuration.

To perform requests, use the appropriate HTTP method and additional builder-style methods corresponding to properties of MockHttpServletRequest. For example:

mockMvc.perform(post("/hotels/{id}", 42).accept(MediaType.APPLICATION_JSON));

In addition to all the HTTP methods, you can also perform file upload requests, which internally creates an instance of MockMultipartHttpServletRequest:

mockMvc.perform(fileUpload("/doc").file("a1", "ABC".getBytes("UTF-8")));

Query string parameters can be specified in the URI template:

mockMvc.perform(get("/hotels?foo={foo}", "bar"));

Or by adding Servlet request parameters:

mockMvc.perform(get("/hotels").param("foo", "bar"));

If application code relies on Servlet request parameters, and doesn’t check the query string, as is most often the case, then it doesn’t matter how parameters are added. Keep in mind though that parameters provided in the URI template will be decoded while parameters provided through the param(...) method are expected to be decoded.

In most cases it’s preferable to leave out the context path and the Servlet path from the request URI. If you must test with the full request URI, be sure to set the contextPath and servletPath accordingly so that request mappings will work:

mockMvc.perform(get("/app/main/hotels/{id}").contextPath("/app").servletPath("/main"))

Looking at the above example, it would be cumbersome to set the contextPath and servletPath with every performed request. That’s why you can define default request properties when building the MockMvc:

public class MyWebTests {

    private MockMvc mockMvc;

    @Before
    public void setup() {
        mockMvc = standaloneSetup(new AccountController())
            .defaultRequest(get("/")
            .contextPath("/app").servletPath("/main")
            .accept(MediaType.APPLICATION_JSON).build();
    }

The above properties will apply to every request performed through the MockMvc. If the same property is also specified on a given request, it will override the default value. That is why, the HTTP method and URI don’t matter, when setting default request properties, since they must be specified on every request.

Expectations can be defined by appending one or more .andExpect(..) after call to perform the request:

mockMvc.perform(get("/accounts/1")).andExpect(status().isOk());

MockMvcResultMatchers.* defines a number of static members, some of which return types with additional methods, for asserting the result of the performed request. The assertions fall in two general categories.

The first category of assertions verify properties of the response, i.e the response status, headers, and content. Those are the most important things to test for.

The second category of assertions go beyond the response, and allow inspecting Spring MVC specific constructs such as which controller method processed the request, whether an exception was raised and handled, what the content of the model is, what view was selected, what flash attributes were added, and so on. It is also possible to verify Servlet specific constructs such as request and session attributes. The following test asserts that binding/validation failed:

mockMvc.perform(post("/persons"))
    .andExpect(status().isOk())
    .andExpect(model().attributeHasErrors("person"));

Many times when writing tests, it’s useful to dump the result of the performed request. This can be done as follows, where print() is a static import from MockMvcResultHandlers:

mockMvc.perform(post("/persons"))
    .andDo(print())
    .andExpect(status().isOk())
    .andExpect(model().attributeHasErrors("person"));

As long as request processing causes an unhandled exception, the print() method will print all the available result data to System.out.

In some cases, you may want to get direct access to the result and verify something that cannot be verified otherwise. This can be done by appending .andReturn() at the end after all expectations:

MvcResult mvcResult = mockMvc.perform(post("/persons")).andExpect(status().isOk()).andReturn();
// ...

When all tests repeat the same expectations, you can define the common expectations once when building the MockMvc:

standaloneSetup(new SimpleController())
    .alwaysExpect(status().isOk())
    .alwaysExpect(content().contentType("application/json;charset=UTF-8"))
    .build()

Note that the expectation is always applied and cannot be overridden without creating a separate MockMvc instance.

When JSON response content contains hypermedia links created with Spring HATEOAS, the resulting links can be verified:

mockMvc.perform(get("/people").accept(MediaType.APPLICATION_JSON))
    .andExpect(jsonPath("$.links[?(@.rel == 'self')].href").value("http://localhost:8080/people"));

When XML response content contains hypermedia links created with Spring HATEOAS, the resulting links can be verified:

Map<String, String> ns = Collections.singletonMap("ns", "http://www.w3.org/2005/Atom");
mockMvc.perform(get("/handle").accept(MediaType.APPLICATION_XML))
    .andExpect(xpath("/person/ns:link[@rel='self']/@href", ns).string("http://localhost:8080/people"));

When setting up a MockMvc, you can register one or more Filter instances:

mockMvc = standaloneSetup(new PersonController()).addFilters(new CharacterEncodingFilter()).build();

Registered filters will be invoked through MockFilterChain from spring-test and the last filter will delegates to the DispatcherServlet.

The framework’s own tests include many sample tests intended to demonstrate how to use Spring MVC Test. Browse these examples for further ideas. Also the spring-mvc-showcase has full test coverage based on Spring MVC Test.

RestTemplate restTemplate = new RestTemplate();

MockRestServiceServer mockServer = MockRestServiceServer.createServer(restTemplate);
mockServer.expect(requestTo("/greeting")).andRespond(withSuccess("Hello world", MediaType.TEXT_PLAIN));

// use RestTemplate ...

mockServer.verify();

Just like with server-side tests, the fluent API for client-side tests requires a few static imports. Those are easy to find by searching "MockRest*". Eclipse users should add "MockRestRequestMatchers.*" and "MockRestResponseCreators.*" as "favorite static members" in the Eclipse preferences under Java → Editor → Content Assist → Favorites. That allows using content assist after typing the first character of the static method name. Other IDEs (e.g. IntelliJ) may not require any additional configuration. Just check the support for code completion on static members.

Spring MVC Test’s own tests include example tests of client-side REST tests.