Loading Multiple YAML Configuration Files in Spring Boot

1. Overview

When designing a Spring Boot application, we typically want to use external configuration to define our application properties. This lets us use the same code across different environments. In some cases, we may want to have our properties defined across multiple YAML configuration files even for the same environment.

In this tutorial, we’ll learn two ways to load multiple YAML configuration files when creating a Spring Boot application.

2. Using Spring Profiles

One way to include multiple YAML configuration files in an application is by using Spring profiles.

This approach takes advantage of Spring’s autoloading of YAML configuration files associated with an application profile.

Next, let’s walk through an example with two .yml files.

2.1. YAML Setup

Our first file lists students. We’ll name it application-students.yml and place it in our ./src/main/resources directory:

students:
  - Jane
  - Michael

Let’s name our second file application-teachers.yml and place in the same ./src/main/resources directory:

teachers:
  - Margo
  - Javier

2.2. Application

Now, let’s set up our example application. We’ll use the CommandLineRunner in our application to see our properties loading:

@SpringBootApplication
public class MultipleYamlApplication implements CommandLineRunner {

    @Autowired
    private MultipleYamlConfiguration config;

    public static void main(String[] args) {
        SpringApplication springApp = new SpringApplication(MultipleYamlApplication.class);
        springApp.setAdditionalProfiles("students", "teachers");
        springApp.run(args);
    }

    public void run(String... args) throws Exception {
        System.out.println("Students: " + config.getStudents());
        System.out.println("Teachers: " + config.getTeachers());

    }
}

In this example, we set our additional Spring profiles programmatically with the setAdditionalProfiles() method.

We could also use the spring.profiles.include parameter in a general application.yml file:

spring:
  profiles:
    include:
      - teachers
      - students

Either method can set the profiles, and during application startup, Spring loads any YAML configuration file following the pattern application-{profile}.yml.

2.3. Configuration

To finish our example, let’s create our configuration class. This loads the properties from the YAML files:

@Configuration
@ConfigurationProperties
public class MultipleYamlConfiguration {

    List<String> teachers;
    List<String> students;

    // standard setters and getters

}

Let’s check the logs after running our application:

c.b.p.m.MultipleYamlApplication : The following 2 profiles are active: "teachers", "students"

And here’s the output:

Students: [Jane, Michael]
Teachers: [Margo, Javier]

While this method works,  a drawback is that it uses the Spring profiles functionality in a way that is most likely not intended by the implementation.

Given that, let’s look at a second, more robust method to include multiple YAML files.

3. Using @PropertySources

We can specify multiple YAML configuration files via the @PropertySources annotation combined with using @PropertySource to load YAML.

3.1. Application

Let’s try again with a similar application:

@SpringBootApplication
public class MultipleYamlApplication implements CommandLineRunner {

    @Autowired
    private MultipleYamlConfiguration config;

    public static void main(String[] args) {
        SpringApplication.run(MultipleYamlApplication.class);
    }

    public void run(String... args) throws Exception {
        System.out.println("Students: " + config.getStudents());
        System.out.println("Teachers: " + config.getTeachers());

    }
}

We should note that, in this example, we’re not setting Spring profiles.

3.2. Configuration and PropertySourceFactory

Now, let’s implement our configuration class:

@Configuration
@ConfigurationProperties
@PropertySources({
        @PropertySource(value = "classpath:application-teachers.yml", factory = MultipleYamlPropertySourceFactory.class),
        @PropertySource(value = "classpath:application-students.yml", factory = MultipleYamlPropertySourceFactory.class)})
public class MultipleYamlConfiguration {

    List<String> teachers;
    List<String> students;

    // standard setters and getters

}

The @PropertySources annotation includes an @PropertySource for each YAML file we want to use in our application. The factory is a custom PropertySourceFactory that enables loading a YAML file:

public class MultipleYamlPropertySourceFactory implements PropertySourceFactory {

    @Override
    public PropertySource<?> createPropertySource(String name, EncodedResource encodedResource) throws IOException {
        YamlPropertiesFactoryBean factory = new YamlPropertiesFactoryBean();
        factory.setResources(encodedResource.getResource());

        Properties properties = factory.getObject();

        return new PropertiesPropertySource(encodedResource.getResource().getFilename(), properties);
    }
}

Running our MultipleYamlApplication, we see our expected outputs:

Students: [Jane, Michael]
Teachers: [Margo, Javier]

4. Conclusion

In this article, we looked at two possible ways to load multiple YAML configuration files in a Spring Boot application.