Inject a Map from a YAML File With Spring
An Application YAML file or application properties file in a Spring or Spring Boot application demonstrates the externalization of important settings. We can read and bind those configurations into Java objects to Spring Boot’s @ConfigurationProperties annotation. We will work on a YAML-based configuration. We may use any similar application properties file with any of the examples in this article.
Implementation of Injecting a Map from a YAML File with Spring
Below are the steps to inject a map from a YAML file with the Spring application.
Step 1: Spring Framework’s YAML Files
Spring developers frequently use YAML files to hold external configuration data. The SnakeYAML is used by Spring to parse YAML documents, which serve as a substitute for properties. Let’s quickly see what a common YAML file looks like:
server:
port: 8090
application:
name: myapplication
url: http://myapplication.com
Step 2: Inject a Map from a YAML File
Data externalization has been elevated by Spring Boot by using @ConfigurationProperties annotation. The purpose of this annotation is to make it simple to add external attributes to Java objects straight from configuration files. We will start by defining a few key-value attributes for the application.yml:
server:
application:
name: InjectMapFromYAML
url: http://injectmapfromyaml.dev
description: Inject a Map from a YAML File with Spring
config:
ips:
- 10.10.10.10
- 10.10.10.11
- 10.10.10.12
- 10.10.10.13
filesystem:
- /dev/root
- /dev/md2
- /dev/md4
users:
root:
username: root
password: rootpass
guest:
username: guest
password: guestpass
Step 3: Create a bean class
Next, we are going to develop a bean class called ServerProperties, which will include the logic for binding our configuration parameters to Maps:
Java
import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.stereotype.Component; import java.util.List; import java.util.Map; @Component @ConfigurationProperties (prefix = "server" ) public class ServerProperties { private Map<String, String> application; private Map<String, List<String>> config; private Map<String, Credential> users; // getters and setters // Inner class representing credential properties public static class Credential { private String username; private String password; // getters and setters } } |
- As we can see, @ConfigurationProperties was used to add properties the ServerProperties class.
- In this manner, we instruct Spring to map every property to an instance of ServerProperties that has the prefix we specify.
- Remember that while most Spring Boot apps handle this automatically, our app still has to be enabled for configuration settings.
Step 4: Inject the ApplicationProps bean into a test class
The ApplicationProps bean is then injected into a test class, and we check to see that our profiles YAML list is injected as a ListObject correctly:
Java
@ExtendWith (SpringExtension. class ) @ContextConfiguration (initializers = ConfigDataApplicationContextInitializer. class ) @EnableConfigurationProperties (value = ApplicationProps. class ) class YamlSimpleListUnitTest { @Autowired private ApplicationProps applicationProps; @Test public void whenYamlList_thenLoadSimpleList() { // Assertions for the "profiles" property in ApplicationProps assertThat(applicationProps.getProfiles().get( 0 )).isEqualTo( "dev" ); assertThat(applicationProps.getProfiles().get( 4 ).getClass()).isEqualTo(Integer. class ); assertThat(applicationProps.getProfiles().size()).isEqualTo( 5 ); } } |
Step 5: Test a YAML properties
Lastly, we will verify that our YAML attributes have been correctly inserted as Maps:
Java
import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.context.junit4.SpringRunner; import static org.assertj.core.api.Assertions.assertThat; @RunWith (SpringRunner. class ) @SpringBootTest class MapFromYamlIntegrationTest { @Autowired private ServerProperties serverProperties; @Test public void whenYamlFileProvidedThenInjectSimpleMap() { // Assertions for the "server.application" properties assertThat(serverProperties.getApplication()) .containsOnlyKeys( "name" , "url" , "description" ); assertThat(serverProperties.getApplication() .get( "name" )).isEqualTo( "InjectMapFromYAML" ); } @Test public void whenYamlFileProvidedThenInjectComplexMap() { // Assertions for the "server.config" properties assertThat(serverProperties.getConfig()).hasSize( 2 ); assertThat(serverProperties.getConfig() .get( "ips" ) .get( 0 )).isEqualTo( "10.10.10.10" ); // Assertions for the "server.users" properties assertThat(serverProperties.getUsers() .get( "root" ) .getUsername()).isEqualTo( "root" ); } } |
Contact Us