In this quick tutorial, we’ll learn how to use a YAML file to configure properties of a Spring Boot application.

What is YAML File?

Instead of having an application.properties in Spring, we can use the application.yml as our configuration file. YAML is a superset of JSON and we can use it for configuring data. The YAML files are more human-readable, especially when we have a lot of hierarchical configurations in place.

Let’s see what a very basic YAML file looks like:

src/main/resources/application.yml

server:
 url: http://localhost 
 myapp:
 name: MyApplication
 threadCount: 4
...

The above YAML file is equivalent to the below application.properties file:

server.url=http://localhost
server.myapp.name=MyApplication
server.myapp.threadCount=4
...

Spring uses SnakeYAML for parsing the YAML file, which is available in spring-boot-starter:

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter</artifactId>
 <version>2.1.5.RELEASE</version>
</dependency>

We can check out the latest version of this dependency at Maven Repository.

Spring Profiles In YAML:

We can use the spring.profiles key to mention the profile for which a property value applies. For example:

spring:
 profiles: dev | test
server:
 url: http://localhost 
 app:
 name: MyApplication
 threadCount: 4
 users: 
 - A
 - B
----
spring:
 profiles: prod
server:
 url: http://myapp.org 
 app:
 name: MyApplication
 threadCount: 10
 users: 
 - Jacob
 - James

The property values are then assigned based on the active spring profile. While running the Spring application, we can set the profile as:

-Dspring.profiles.active=dev

Binding YAML Configuration:

One way to access YAML properties is to use the @Value(“${property}”) annotation. However, there’s another popular method that ensures that the strongly typed beans govern and validate our app configuration.

To implement that, we’ll create a @ConfigurationProperties class which maps a set of related properties:

@ConfigurationProperties("server")
public class ServerProperties {
 
 private String url;
 
 private final App app = new App();
 
 public App getApp() {
 return app;
 }
 //getter and setter for url
 
 public static class App {
 
 private String name;
 private String threadCount;
 private List<String> users = new ArrayList<>();
 
 //getters and setters
 }
 
}

Note that we can create one or more of @ConfigurationProperties classes.

Let’s now define our AppConfig class:

@Configuration
@EnableConfigurationProperties(ServerProperties.class)
public class ApplicationConfig {
 
 ...
 
}

Here, we have mentioned the list of property classes to register in the @EnableConfigurationProperties annotation.

Accessing YAML Properties:

We can now access the YAML properties by making use of the @ConfigurationProperties beans that we have created. We’ll inject these property beans just like any regular Spring bean:

@Service
public class AppService {
 
 @Autowired
 private ServerProperties config;
 
 public void printConfigs() {
 System.out.println(this.config.getUrl());
 System.out.println(this.config.getApp().getName());
 System.out.println(this.config.getApp().getThreadCount());
 System.out.println(this.config.getApp().getUsers());
 }
}

We can then use the AppRunner to boot our Spring application and invoke our printConfigs() method. Our app will print out the property values depending on the active spring profile.

Conclusion:

In this tutorial, we learned how to use YAML configuration files in Spring Boot application.