How do you handle external configuration properties in Spring Boot?

Introduction
Ways to Handle External Configuration in Spring Boot
Conclusion
- Key Techniques:

Introduction

In Spring Boot, managing configuration settings efficiently is crucial for developing production-ready applications. While properties like database credentials, API keys, and service URLs often differ across environments (e.g., development, testing, production), hardcoding them directly into your application's configuration files or source code is not recommended. Externalizing configuration properties helps in separating code from configuration, making your application more flexible, secure, and easier to manage across different environments.

This guide explains how to handle external configuration properties in Spring Boot, including the various techniques that allow you to load properties from external sources such as environment variables, property files, and configuration management systems.

Ways to Handle External Configuration in Spring Boot

1. Using `application.properties` and `application.yml`

Spring Boot allows you to configure properties in two main formats: **application.properties** or **application.yml**. While the default configuration file is located within the src/main/resources directory, it can be overridden with external property files.

a. Externalizing with `application.properties` or `application.yml`

You can create an external application.properties or application.yml file outside of your application (for example, in a specific environment or deployment directory) and tell Spring Boot to load it at runtime. This is ideal when you want to override default settings or keep sensitive properties like database credentials out of the main codebase.

Example: External `application.yml`

If you want to place the application.yml file outside your project directory (e.g., /etc/myapp/config/application.yml), you can do so and then reference it by configuring the path via the command line or environment variables.

Command-Line Argument

You can provide an external path to the application.yml using the following command:

Environment Variable

Alternatively, set the environment variable to point to your external configuration:

This way, Spring Boot loads properties from the external application.yml file, overriding any defaults in the internal application.yml.

2. Using Environment Variables

Spring Boot allows you to use environment variables to externalize configuration properties. This approach is particularly useful for cloud-native applications, where configuration is often injected into the environment at runtime (e.g., through container orchestration systems like Kubernetes or cloud platforms like AWS or Azure).

Example: Setting Properties via Environment Variables

Suppose you have a property in your application.yml that defines a database URL:

You can set this property externally via environment variables like this:

Spring Boot automatically maps environment variables to the configuration properties based on the Spring Property Naming Convention, where . is replaced by _ (e.g., spring.datasource.url becomes SPRING_DATASOURCE_URL).

3. Using Command-Line Arguments

Another simple way to externalize configuration properties is by passing them as command-line arguments when running your application. This method is useful for quickly overriding properties at startup.

Example: Passing Properties as Arguments

You can specify properties directly from the command line when starting the application:

This allows you to pass environment-specific values dynamically without changing the application's internal configuration files.

4. Using `@Value` and `@ConfigurationProperties` for Externalized Properties

Spring Boot provides annotations like **@Value** and **@ConfigurationProperties** to access externalized configuration properties in your beans.

a. Using `@Value`

The @Value annotation allows you to inject individual properties into Spring-managed beans. It's ideal for injecting simple configuration values from properties files, environment variables, or system properties.

This allows you to access properties defined in application.properties or set as environment variables (e.g., SPRING_DATASOURCE_URL).

b. Using `@ConfigurationProperties`

For a more structured and type-safe way to bind multiple related properties, you can use **@ConfigurationProperties**. This approach is particularly useful when you have many related properties (such as multiple properties related to a data source configuration).

In this case, Spring will automatically map all properties with the spring.datasource prefix from the configuration files or environment variables into the fields of the DataSourceConfig class.

5. Using Spring Cloud Config Server

For larger applications or microservices architectures, managing configuration centrally becomes a necessity. Spring Cloud Config provides a way to externalize configuration in a Git repository or a file system, allowing you to manage application properties across multiple environments and applications.

a. Setting Up Spring Cloud Config Server

You can set up a Spring Cloud Config Server to serve configuration properties stored in a Git repository or file system. Here’s a basic example:

Start a Spring Cloud Config Server:
Define a **bootstrap.yml** in Client Application:

Git repository with properties: Store the application properties in a Git repository:
- myapp-dev.properties
- myapp-prod.properties

The Config Server fetches these properties and makes them available to client applications.

6. Using Profile-Specific Properties

Spring Boot also allows for profile-specific property files (e.g., application-dev.properties, application-prod.properties), which can be combined with the external configuration approach. This is particularly useful for separating environment-specific configurations, allowing you to load different configurations based on the active profile.

Example:

**application-dev.yml**:

**application-prod.yml**:

Spring Boot will load the appropriate configuration file depending on the profile active at runtime, providing flexibility for handling environment-specific settings.

7. Using Spring Boot's `@PropertySource` Annotation

The @PropertySource annotation allows you to load properties from external files into the Spring context. This is useful for situations where you need to load properties from a file that is not in the typical application.properties or application.yml format.

You can also reference files outside of the classpath if needed.

Conclusion

Handling external configuration properties in Spring Boot is a crucial step towards making your application more flexible, secure, and scalable across different environments. By utilizing external files, environment variables, and specialized tools like Spring Cloud Config, you can ensure that your application’s configuration is separated from the codebase and can be easily adapted for different environments, whether on-premises or in the cloud.

Key Techniques:

External configuration files (application.properties, application.yml)
Environment variables and command-line arguments
**@Value** and **@ConfigurationProperties** for binding properties to beans
Spring Cloud Config for centralized configuration management

By using these methods, Spring Boot provides a comprehensive and flexible approach for managing application configuration in a secure and maintainable manner.