How do you use property placeholders in Spring?

Table of Contents

• Introduction
• Methods to Use Property Placeholders in Spring
  • 1. Using **@Value** Annotation
    • Example:
  • 2. Using **PropertyPlaceholderConfigurer** in XML Configuration
    • Example:
  • 3. Using **@PropertySource** Annotation in Spring Boot
    • Example:
  • 4. Using **Environment** API in Spring Boot
    • Example:
  • 5. Using System Properties and Environment Variables
    • Example:
  • 6. Using **@Value** with Default Values
    • Example:
• Conclusion

Introduction

In Spring, property placeholders are a way to externalize configuration values so that they can be injected into Spring beans. This helps separate application logic from configuration, allowing you to change settings without modifying the source code. Property placeholders are commonly used to load values from property files, XML configuration, environment variables, or system properties into Spring beans.

Spring provides different ways to use property placeholders, including through XML configuration (PropertyPlaceholderConfigurer), the @Value annotation, and the Environment API in Spring Boot.

In this guide, we will walk through the different ways to use property placeholders in Spring applications.

Methods to Use Property Placeholders in Spring

There are multiple approaches to using property placeholders in Spring. Below are the most common ones.

1. Using **@Value** Annotation

In Spring, you can inject property values directly into fields, methods, or constructor parameters using the @Value annotation. This is the simplest way to use property placeholders in Spring, particularly in Spring Boot applications.

Example:

1. Define Property Placeholders in application.properties or application.yml:

2. Inject Values Using **@Value**:

In this example, the @Value annotation injects the values of app.name and app.version from the application.properties file into the appName and appVersion fields.

2. Using **PropertyPlaceholderConfigurer** in XML Configuration

For applications that use XML configuration, you can use the PropertyPlaceholderConfigurer bean to load external property files and replace property placeholders in your Spring bean definitions.

Example:

1. Define the Property File (e.g., application.properties):

2. Configure **PropertyPlaceholderConfigurer** in XML:

In this example, the PropertyPlaceholderConfigurer is used to load properties from application.properties. The dataSource bean then references these properties using ${} placeholders.

3. Using **@PropertySource** Annotation in Spring Boot

In Spring Boot, the @PropertySource annotation is typically used to specify property files from which configuration values will be loaded. This is particularly useful for loading custom property files.

Example:

1. Create a Property File (e.g., config.properties):

2. Define **@PropertySource** in Your Java Config:

Here, the @PropertySource annotation tells Spring to load config.properties. The @Value annotation then injects the property values into the fields.

4. Using **Environment** API in Spring Boot

Spring Boot offers the Environment API to access property values programmatically. You can inject the Environment object into your beans and use its methods to fetch property values.

Example:

In this example, the Environment object is used to retrieve property values (app.name and app.version). This method is useful when you need to programmatically access properties in your beans.

5. Using System Properties and Environment Variables

Spring allows you to access system properties and environment variables using property placeholders in Spring beans. This is useful when you want to inject values that are external to the application, such as operating system properties or environment-specific configurations.

Example:

1. Set an Environment Variable:

2. Use the Environment Variable in Spring:

In this example, Spring injects the value of the APP_NAME environment variable into the appName field.

6. Using **@Value** with Default Values

If a property is not found, you can provide a default value using the @Value annotation. This ensures that the application doesn’t fail if the property is missing.

Example:

In this example, if app.name or app.version is not found in the property file, default values (DefaultAppName and 1.0.0) will be used.

Conclusion

Property placeholders in Spring provide an effective way to externalize configuration and decouple the application's logic from its environment settings. Whether you're using @Value, PropertyPlaceholderConfigurer, @PropertySource, the Environment API, or environment variables, Spring makes it easy to inject properties into your beans and manage different configurations for various environments. By externalizing properties, you ensure that your application remains flexible, maintainable, and easily configurable across different environments.