How do you implement externalized configuration in Spring?

Table of Contents

• Introduction
• Methods for Implementing Externalized Configuration in Spring
  • 1. Using **application.properties** or **application.yml**
    • Example: application.properties
    • Example: application.yml
    • Accessing Configuration Values with @Value Annotation
  • 2. Using **@ConfigurationProperties** for Grouped Configuration
    • Example: application.properties
    • POJO Class with @ConfigurationProperties
  • 3. Using Profiles for Environment-Specific Configurations
    • Example: Environment-Specific Property Files
  • 4. Using **@Profile** Annotation
    • Example: Profile-Specific Bean
  • 5. Using Environment Variables and System Properties
    • Example: Accessing Environment Variables
  • 6. Using **@PropertySource** to Load Custom Property Files
    • Example: Using @PropertySource in a Configuration Class
• Conclusion

Introduction

Externalized configuration in Spring refers to the practice of keeping application settings, environment-specific configurations, and other variables outside of the application code itself. This practice provides flexibility and makes it easier to manage configurations for different environments (e.g., development, production, testing) without changing the codebase. Spring offers several mechanisms to handle externalized configuration, making it simple to inject values from property files, environment variables, and system properties.

This guide explains the different approaches to implementing externalized configuration in Spring, including using property files, the @Value annotation, @ConfigurationProperties, Spring Profiles, and environment variables.

Methods for Implementing Externalized Configuration in Spring

1. Using **application.properties** or **application.yml**

Spring Boot makes it incredibly simple to externalize configuration using application.properties or application.yml files. These files can contain key-value pairs that Spring will automatically load into the application context. These configurations can be environment-specific and can easily be overridden based on the active profile.

Example: application.properties

Example: application.yml

Accessing Configuration Values with @Value Annotation

You can inject values from these properties files directly into your Spring beans using the @Value annotation.

In this example, Spring injects the values of server.host and server.port into the serverHost and serverPort fields.

2. Using **@ConfigurationProperties** for Grouped Configuration

For more complex configurations, especially when dealing with a large set of related properties, you can use @ConfigurationProperties. This annotation allows you to bind multiple related properties into a single POJO (Plain Old Java Object). It's especially useful for hierarchical or nested configuration properties.

Example: application.properties

POJO Class with @ConfigurationProperties

In this example, Spring automatically binds properties prefixed with server to the ServerConfig class, including the nested ssl object.

3. Using Profiles for Environment-Specific Configurations

Spring Profiles allow you to create different sets of configurations for different environments (e.g., development, production). You can use profile-specific property files to manage configurations based on the active profile.

Example: Environment-Specific Property Files

You can specify the active profile in the application.properties or application.yml:

Or set it through an environment variable or command line argument:

Spring will automatically load the properties from application-dev.properties or application-prod.properties, depending on the active profile.

4. Using **@Profile** Annotation

You can also use the @Profile annotation to create beans that are only active under specific profiles. This is useful when you want to load certain beans or configurations based on the environment.

Example: Profile-Specific Bean

In this example, devDataSource() will only be created when the dev profile is active, and prodDataSource() will be used when the prod profile is active.

5. Using Environment Variables and System Properties

Spring allows you to use environment variables and system properties as part of your externalized configuration. These values can be injected into Spring beans via property placeholders.

Example: Accessing Environment Variables

You can set environment variables like so:

These environment variables can then be injected into your Spring beans using the @Value annotation.

6. Using **@PropertySource** to Load Custom Property Files

If you have custom property files that are not automatically loaded by Spring Boot (such as config.properties), you can use the @PropertySource annotation to load them.

Example: Using @PropertySource in a Configuration Class

In this example, config.properties will be loaded, and its values can be injected into Spring beans using @Value.

Conclusion

Implementing externalized configuration in Spring is a powerful way to separate your application's logic from its environment settings. By using property files (application.properties, application.yml), Spring Profiles, the @Value annotation, @ConfigurationProperties, and environment variables, Spring makes it easy to manage different configurations across various environments.

These mechanisms help you maintain flexibility and scalability, especially in complex applications or microservices, where configuration changes may need to be applied without changing the application's code. By leveraging these tools, you can ensure that your application remains adaptable, maintainable, and environment-agnostic.