How do you implement application configuration properties in Spring Boot?

Table of Contents

• Introduction
• 1. Setting Up Configuration Properties
  • Example of application.properties:
  • Example of application.yml:
• 2. Accessing Configuration Properties with **@Value** Annotation
  • Example: Injecting a property value using @Value
  • Using default values:
• 3. Binding Configuration Properties to a POJO
  • Step 1: Create a POJO class
  • Step 2: Enable configuration properties in your application.properties or application.yml
  • Step 3: Access the configuration in a service
  • Benefits:
• 4. Profile-Specific Configuration
  • Example: Defining properties for different profiles
  • Activating a profile:
• 5. Using **@ConfigurationProperties** with Validation
  • Example: Adding validation to configuration properties
• Conclusion
  • Key Takeaways:

Introduction

In Spring Boot, external configuration properties allow you to customize your application's behavior without modifying the code itself. By using configuration files like **application.properties** or **application.yml**, you can externalize application settings such as database connections, server configurations, and feature toggles. This approach enhances flexibility and helps manage different environments (development, production, etc.).

This guide explains how to implement and use application configuration properties in Spring Boot applications.

1. Setting Up Configuration Properties

Spring Boot supports two types of configuration files: **application.properties** and **application.yml**. Both can be used to define key-value pairs, but **application.yml** is more structured and supports hierarchical configurations. **application.properties** is simpler and more commonly used.

Example of application.properties:

Example of application.yml:

Both files serve the same purpose, and the choice between them depends on your preference.

2. Accessing Configuration Properties with **@Value** Annotation

The most straightforward way to access configuration properties in a Spring Boot application is by using the **@Value** annotation. This allows you to inject property values directly into your Spring beans.

Example: Injecting a property value using @Value

In this example:

• The **@Value("${property.name}")** annotation is used to inject values from the configuration file into the fields of the MyService class.
• The value of server.port will be injected into serverPort, and the value of spring.datasource.url will be injected into dataSourceUrl.

Using default values:

You can also specify a default value in case the property is not found:

In this case, if the app.timeout property is not defined in the configuration, it will default to 5000.

3. Binding Configuration Properties to a POJO

In Spring Boot, you can also bind configuration properties directly to a Java class (POJO). This is particularly useful when you have a set of related properties.

Step 1: Create a POJO class

Step 2: Enable configuration properties in your application.properties or application.yml

Step 3: Access the configuration in a service

Benefits:

• Clean and Structured: This approach is cleaner and more maintainable, especially for larger sets of properties.
• Type Safety: Using Java classes provides type safety when accessing configuration properties.

4. Profile-Specific Configuration

Spring Boot allows you to define different properties for different environments (e.g., development, production) using profiles. This is done by creating profile-specific configuration files.

Example: Defining properties for different profiles

In application.properties:

In application-dev.properties (for development profile):

In application-prod.properties (for production profile):

Activating a profile:

You can activate a profile by adding the following to your application.properties or as a command-line parameter:

Alternatively, set the active profile via command line when running the application:

This will load the appropriate properties for the active profile.

5. Using **@ConfigurationProperties** with Validation

Spring Boot also supports validation for configuration properties, using the **@Validated** annotation along with JSR-303/JSR-380 annotations like **@NotNull**.

Example: Adding validation to configuration properties

In this example:

• The **@NotNull** annotation ensures that the appName property must be provided, otherwise, Spring Boot will throw a validation exception.
• **@Validated** triggers the validation when the configuration properties are loaded.

Conclusion

Spring Boot makes it easy to manage and use external configuration properties in your applications. Whether you use **application.properties**, **application.yml**, or bind properties to a Java class using **@ConfigurationProperties**, you can externalize settings for flexibility and easier management across different environments. Additionally, profiles, validation, and default values enhance your configuration strategy.

Key Takeaways:

• Use **@Value** to inject individual properties directly into Spring beans.
• Use **@ConfigurationProperties** to map related properties to a Java class.
• Leverage profiles to handle different environments and configurations.
• Add validation to your configuration properties to ensure data integrity.

By following these practices, you can implement a clean and maintainable configuration strategy for your Spring Boot applications.