Mastering Spring Boot Configuration: 3 Powerful Techniques to Fetch Comple

As Spring Boot developers, we often face challenges when working with complex YAML configurations.

This guide explores three powerful techniques to efficiently fetch values from application properties, with a focus on complex YAML structures.

The Challenge of Complex YAML Structures

Imagine you're adding values to the application.yaml file by defining a complex data structure:

Copy
1# application.yaml
2security:
3  cors:
4    origins: 
5      - http://localhost:5173
6    methods:
7      - GET
8      - POST
9      - PUT
10      - DELETE
11      - OPTIONS

Your code to access these values might look like this:

Copy
1@Configuration
2@EnableWebSecurity
3public class SecurityConfig {
4
5  @Value("${security.cors.origins}")
6  private List<String> allowedOrigins;
7
8  @Value("${security.cors.methods}")
9  private List<String> allowedMethods;
10    
11  ...
12}

However, when you start the application, you're likely to encounter this error message:

Copy
1Caused by: java.lang.IllegalArgumentException: Could not resolve placeholder 'security.cors.origins' in value "${security.cors.origins}"
2// OR
3Caused by: java.lang.IllegalArgumentException: Could not resolve placeholder 'security.cors.methods' in value "${security.cors.methods}"

This occurs because Spring Boot can't fetch the complex data structure from the YAML file. As a result, it throws an IllegalArgumentException when compiling the application.

Three Techniques to Resolve Complex YAML Configuration Issues

1. @ConfigurationProperties Best for structured and complex properties, especially for nested configurations.
2. Binder API Advanced method for manually binding properties, giving you full control.
3. @PropertySource Useful for loading YAML from external files.

Technique 1: @ConfigurationProperties

This is the most structured and maintainable way to handle complex YAML in Spring Boot, especially when dealing with nested properties and lists.

Copy
1@Getter
2@Setter
3@Configuration
4@ConfigurationProperties(prefix = "security.cors")
5public class CorsProperties {
6  private List<String> methods;
7}
8
9@Component
10public class CorsConfigPrinter {
11
12  @Autowired
13  private CorsProperties corsProperties;
14
15  // Print the output
16  @PostConstruct
17  public void print() {
18    corsProperties.getMethods().forEach(System.out::println);
19  }
20}

Technique 2: Binder API

Spring Boot’s Binder API gives you fine-grained control over how properties are bound to objects. It allows you to manually bind complex YAML structures to objects.

Copy
1@Component
2public class MyComponent {
3
4  private final List<String> methods;
5
6  public MyComponent(Environment environment) {
7    Binder binder = Binder.get(environment);
8    this.methods = binder.bind("security.cors.methods", List.class).get();
9
10    // Print the output
11    print();
12  }
13
14  public void print() {
15    methods.forEach(System.out::println);
16  }
17}

Technique 3: @PropertySource

If you want to load the properties from an external YAML file (other than application.yml), you can use the @PropertySource annotation with a custom class.

Copy
1public class YamlPropertySourceFactory implements PropertySourceFactory {
2
3  @Override
4  public PropertySource<?> createPropertySource(@Nullable String name, EncodedResource resource)
5      throws IOException {
6    Yaml yaml = new Yaml();
7    Map<String, Object> yamlMap = yaml.load(resource.getInputStream());
8
9    // Safely handle nullable filename
10    String filename = (name != null ? name : resource.getResource().getFilename());
11    if (filename == null) {
12      filename = "defaultYaml";
13    }
14
15    return new MapPropertySource(filename, yamlMap);
16  }
17}
18
19@Configuration
20@PropertySource(value = "classpath:application.yaml", factory = YamlPropertySourceFactory.class)
21@ConfigurationProperties(prefix = "security.cors")
22@Getter
23@Setter
24public class ExternalCorsConfig {
25
26  private List<String> methods;
27
28	// Print the output
29  @PostConstruct
30  public void print() {
31    methods.forEach(System.out::println);
32  }
33}

Comparison of Three Techniques

This comparison table highlights the key differences between the three techniques discussed for handling complex YAML structures in Spring Boot applications.

1. @ConfigurationProperties: Ideal for structured, nested configurations closely tied to your application's domain model. It offers excellent type safety and maintainability, making it the go-to choice for most standard configuration needs.
2. Binder API: Perfect for scenarios requiring fine-grained control over property binding or when dealing with dynamic property names. This method shines in complex situations where standard property binding falls short.
3. @PropertySource: Essential for loading configurations from external YAML files, separate from your main application properties. This technique is particularly valuable for modular applications or managing environment-specific configurations.

Conclusion

In this article, we've explored three powerful techniques for managing complex YAML data structures in Spring Boot applications. Each method offers unique advantages, catering to different scenarios and developer preferences.

By mastering these three approaches, Spring Boot developers can significantly enhance their configuration management capabilities. This leads to more flexible, maintainable, and robust applications that can easily adapt to changing requirements and environments.

I hope you enjoy reading this post and learn how to fetch the value from complex YAML configuration file.