How do you use @PropertySource to load external properties?

Table of Contents

• Introduction
• Using @PropertySource to Load External Properties in Spring
  • 1. Basic Usage of @PropertySource
    • Example: Loading a Properties File from the Classpath
  • 2. Using the @Value Annotation to Access Properties
    • Example: Accessing Properties in a Bean
  • 3. Loading Multiple Property Files
    • Example: Loading Multiple Property Files
  • 4. Using @PropertySource with @ConfigurationProperties
    • Example: Binding Properties to a Configuration Bean
  • 5. Using Profiles with @PropertySource
    • Example: Loading Property Files Based on Profile
  • 6. Handling Non-Existent Property Files
    • Example: Optional Property File
• Conclusion

Introduction

In Spring, managing application configuration properties efficiently is essential for maintaining clean, maintainable, and flexible code. One way to externalize configuration in a Spring application is by using property files. The @PropertySource annotation in Spring is used to specify the location of external property files, allowing them to be loaded into the Spring Environment and accessed by beans in the application context.

By using @PropertySource, you can easily integrate external properties into your Spring-based applications, allowing for more flexible configurations. This is particularly useful when you need to change configuration values (like database URLs, server ports, etc.) without modifying the codebase.

In this guide, we will explore how to use @PropertySource to load external properties into a Spring application and access them in beans using @Value or other Spring mechanisms.

Using @PropertySource to Load External Properties in Spring

1. Basic Usage of @PropertySource

The @PropertySource annotation is used to specify the location of one or more external property files. These files can be in .properties or .yml format, but Spring's @PropertySource typically works with .properties files. You can specify the file location as a classpath resource or as an absolute path.

Example: Loading a Properties File from the Classpath

In this example, the application.properties file is loaded from the classpath and made available to the Spring Environment.

2. Using the @Value Annotation to Access Properties

Once the external property file is loaded with @PropertySource, you can access its values in your Spring beans using the @Value annotation.

Example: Accessing Properties in a Bean

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

For instance, if application.properties contains the following entries:

The MyBean class will output the following when printAppInfo() is called:

3. Loading Multiple Property Files

You can also load multiple property files by specifying additional @PropertySource annotations. Spring will load all the specified files and make their properties available to the application.

Example: Loading Multiple Property Files

In this example, both application.properties and config.properties files are loaded. If the properties overlap, the last one in the list will take precedence.

4. Using @PropertySource with @ConfigurationProperties

While @Value is useful for injecting individual properties, you can also use @ConfigurationProperties to bind groups of properties to a Java object. This is a more scalable way to manage large property files or complex configurations.

Example: Binding Properties to a Configuration Bean

In this example, all properties with the app prefix in the application.properties file are automatically bound to the AppConfig class. For example, if application.properties contains:

Spring will automatically inject the values into the AppConfig bean.

5. Using Profiles with @PropertySource

You can use Spring profiles with @PropertySource to load different property files based on the active profile. This is useful for managing environment-specific configurations (e.g., application-dev.properties, application-prod.properties).

Example: Loading Property Files Based on Profile

With this configuration, Spring will load the properties from a file like application-dev.properties when the dev profile is active, or application-prod.properties when the prod profile is active.

6. Handling Non-Existent Property Files

By default, if the property file specified in @PropertySource is not found, Spring will throw an exception. If you want to make the loading of the property file optional, you can set the ignoreResourceNotFound flag to true.

Example: Optional Property File

Conclusion

The @PropertySource annotation in Spring is a powerful tool for loading external property files into the Spring Environment. It allows you to easily externalize configuration values, making your application more flexible and adaptable to different environments. By using @PropertySource in combination with @Value, @ConfigurationProperties, and Spring profiles, you can create a robust and manageable configuration system for your Spring-based applications.

Whether you are working with application-specific properties, environment-specific configurations, or external resources, @PropertySource makes it simple to load and manage these properties in a Spring context.