Configuring Separate Spring DataSource for Tests – 为测试配置独立的Spring DataSource

最后修改: 2017年 4月 9日

1. Overview


When testing a Spring application that relies on a persistence layer, such as JPA, we may want to set up a test data source to use a smaller, faster database different from the one we use to run the application, in order to make running our tests much easier.


Configuring a data source in Spring requires defining a bean of type DataSource. We can do this either manually, or if using Spring Boot, through standard application properties.

在Spring中配置数据源需要定义一个DataSource类型的bean。我们可以手动完成这项工作,如果使用Spring Boot,也可以通过标准的应用程序属性完成。

In this quick tutorial, we’ll learn several ways to configure a separate data source for testing in Spring.


2. Maven Dependencies


We’re going to create a Spring Boot application using Spring JPA and testing, so we’ll need the following dependencies:

我们将使用Spring JPA和测试来创建一个Spring Boot应用程序,因此我们需要以下依赖性。


The latest versions of spring-boot-starter-data-jpa, h2, and spring-boot-starter-test can be downloaded from Maven Central.


Now let’s look at a few different ways to configure a DataSource for testing.


3. Using a Standard Properties File in Spring Boot

3.在Spring Boot中使用标准属性文件

The standard properties file that Spring Boot picks up automatically when running an application is called It resides in the src/main/resources folder.

Spring Boot在运行应用程序时自动获取的标准属性文件称为,它位于src/main/resources文件夹中。

If we want to use different properties for tests, we can override the properties file in the main folder by placing another file with the same name in src/test/resources.


The file in the src/test/resources folder should contain the standard key-value pairs necessary for configuring a data source. These properties are prefixed with spring.datasource.


For example, let’s configure an H2 in-memory database as a data source for tests:



Spring Boot will use these properties to automatically configure a DataSource bean.

Spring Boot将使用这些属性来自动配置一个DataSourcebean。

Let’s define a very simple GenericEntity and repository using Spring JPA:

让我们使用Spring JPA定义一个非常简单的GenericEntity和存储库。

public class GenericEntity {
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String value;

    //standard constructors, getters, setters
public interface GenericEntityRepository
  extends JpaRepository<GenericEntity, Long> { }

Next, let’s write a JUnit test for the repository. In order for a test in a Spring Boot application to pick up the standard data source properties we defined, we have to annotate it with @SpringBootTest:

接下来,让我们为资源库写一个JUnit测试。为了让Spring Boot应用程序中的测试能够获取我们定义的标准数据源属性,我们必须用@SpringBootTest来注释它。

@SpringBootTest(classes = Application.class)
public class SpringBootJPAIntegrationTest {
    private GenericEntityRepository genericEntityRepository;

    public void givenGenericEntityRepository_whenSaveAndRetreiveEntity_thenOK() {
        GenericEntity genericEntity = genericEntityRepository
          .save(new GenericEntity("test"));
        GenericEntity foundEntity = genericEntityRepository
        assertEquals(genericEntity.getValue(), foundEntity.getValue());

4. Using a Custom Properties File


If we don’t want to use the standard file and keys, or if we’re not using Spring Boot, we can define a custom .properties file with custom keys, then read this file in a @Configuration class to create a DataSource bean based on the values it contains.

如果我们不想使用标准的application.properties文件和键,或者不使用Spring Boot,我们可以定义一个带有自定义键的自定义.properties文件,然后在@Configuration类中读取该文件,根据其中包含的值创建一个DataSourcebean。

This file will be placed in the src/main/resources folder for the normal running mode of the application, and in src/test/resources in order to be picked up by tests.


Let’s create a file called that uses an H2 in-memory database for tests, and place it in the src/test/resources folder:

让我们创建一个名为persistence-generic-entity.properties的文件,该文件使用H2内存数据库进行测试,并将其放在 src/test/resources文件夹中。


Next, we can define the DataSource bean based on these properties in a @Configuration class that loads our as a property source:

接下来,我们可以在@Configuration类中基于这些属性定义DataSource Bean,该类将我们的persistence-generic-entity.properties作为属性源加载。

@EnableJpaRepositories(basePackages = "org.baeldung.repository")
public class H2JpaConfig {
    // ...

For a more detailed example of this configuration, we can read through the section “JPA Configuration” in our previous article on Self-contained testing with an in-memory database.

关于这种配置的更详细的例子,我们可以通读我们之前关于使用内存数据库进行自含测试的文章中的 “JPA配置 “部分

Then we can create a JUnit test similar to the previous one, except it’ll load our configuration class:


@SpringBootTest(classes = {Application.class, H2JpaConfig.class})
public class SpringBootH2IntegrationTest {
    // ...

5. Using Spring Profiles

5.使用Spring Profiles

Another way we can configure a separate DataSource for testing is by leveraging Spring Profiles to define a DataSource bean that’s only available in a test profile.

我们为测试配置单独的DataSource的另一种方式是利用Spring Profiles来定义一个DataSource Bean,它只在test profile中可用。

For this, we can use a .properties file, as before, or we can write the values in the class itself.


Let’s define a DataSource bean for the test profile in a @Configuration class that will be loaded by our test:

让我们在@Configuration类中为test配置文件定义一个DataSource bean,该类将被我们的测试加载。

@EnableJpaRepositories(basePackages = {
public class H2TestProfileJPAConfig {

    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();

        return dataSource;
    // configure entityManagerFactory
    // configure transactionManager
    // configure additional Hibernate properties

Then, in the JUnit test class, we need to specify that we want to use the test profile by adding the @ActiveProfiles annotation:


@SpringBootTest(classes = {
public class SpringBootProfileIntegrationTest {
    // ...

6. Conclusion


In this brief article, we explored several ways to configure a separate DataSource for testing in Spring.


As always, the full source code of the examples can be found over on GitHub.