Bootstrapping Your Config: A Deep Dive into Spring Boot Configuration Properties with Profiles and Active Files

8 August 2024

Using Spring Boot Configuration Properties with Profiles and Active Files

When working with large-scale applications, managing configurations can become increasingly complex. Spring Boot provides a powerful solution to this problem through its configuration properties feature. In this article, we’ll explore how to effectively use Spring Boot’s Configuration Properties alongside profiles and active files for dynamic configuration management.

Understanding Spring Boot Configuration Properties

Spring Boot Configuration Properties is a mechanism that allows you to externalize your application configurations into properties files. This approach makes it easy to manage and change configurations without having to alter the code itself.
You can define these properties in various formats such as application.properties or application.yml files, which are located at the root of the classpath. Spring Boot automatically picks up these properties and makes them available through a @ConfigurationProperties annotated bean.

Integrating Profiles with Configuration Properties

Profiles in Spring Boot allow you to define different configurations for various environments, such as development, testing, and production. When using profiles alongside configuration properties, it’s possible to have unique settings for each environment without having to duplicate property files.
Here’s a simple example of how this can be achieved:

# application.properties (common settings)
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydatabase
    username: myuser
    password: mypassword
# application-dev.properties (development environment settings)
spring:
  datasource:
    url: jdbc:mysql://localhost:3307/devmydatabase
    username: devmyuser
    password: devmypassword
# application-test.properties (testing environment settings)
spring:
  datasource:
    url: jdbc:mysql://localhost:3308/testmydatabase
    username: testmyuser
    password: testmypassword

To switch between these profiles, you can use the @SpringBootConfiguration annotation and specify the profile to activate. Here’s how it looks in a Spring Boot application configuration class:

@Configuration
@Profile("dev")
public class DevConfiguration {
  
  @Bean
  public DataSource dataSource() {
    // configure development environment data source
  }
}
@Configuration
@Profile("test")
public class TestConfiguration {
  
  @Bean
  public DataSource dataSource() {
    // configure testing environment data source
  }
}

Active Files and Configuration Properties

Active files in Spring Boot allow you to override configuration properties at runtime. This feature is particularly useful when you need to change configurations dynamically without having to restart the application.
When using active files alongside configuration properties, it’s possible to have a common set of properties that are then overridden by environment-specific settings. Here’s an example:

# application.yml (common settings)
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydatabase
    username: myuser
    password: mypassword
# dev-active.yml (development environment active file)
datasource:
  url: jdbc:mysql://localhost:3307/devmydatabase
  username: devmyuser
  password: devmypassword
# test-active.yml (testing environment active file)
datasource:
  url: jdbc:mysql://localhost:3308/testmydatabase
  username: testmyuser
  password: testmypassword

To switch between these configurations, you can use the @SpringBootConfiguration annotation and specify the profile to activate. You can also add a custom configuration class that overrides the default configuration properties.

@Configuration
public class CustomConfiguration {
  
  @Bean
  public DataSource dataSource() {
    // configure data source based on active file settings
  }
}

Conclusion

Spring Boot’s Configuration Properties feature, when used alongside profiles and active files, provides a powerful solution for dynamic configuration management. By externalizing configurations into properties files and using profiles to switch between different environments, you can easily manage and change configurations without having to alter the code itself.
The use of active files allows you to override configuration properties at runtime, making it possible to have a common set of properties that are then overridden by environment-specific settings. This approach makes it easy to manage complex applications and ensures that configurations are always up-to-date and accurate.

Poespas Blog