Spring @PropertySource annotation

1. Overview

In this article, we will learn about the Spring @PropertySource annotation. You can use the @PropertySource annotation to externalize your configuration to a properties file.

This provides a convenient and declarative mechanism for adding a PropertySource to Spring’s Environment.
A PropertySource<T> is nothing but an abstract base class representing a source of name/value property pairs. The underlying property source object can be of any type T that encapsulates properties such as Properties objects, Map objects, and so on.

2. Default base property

By default, SpringApplication loads properties from application.properties or application.yml files automatically by scanning the following locations and adds them to the Spring Environment:

1. A /config subdirectory of the current directory
2. The current directory
3. A classpath /config package
4. The classpath root

Sometimes you want to load properties from a different property file or multiple property files to the Spring Environment's set of PropertySources.

3. @PropertySource annotation

To load a different property source into your Spring application other than application.properties or application.yml, you can use @PropertySource annotations in your @Configuration classes.

Just having the cms.properties file in the class path does not make the Spring to load it in the application. You should have the @PropertySource to add the cms.property source to the application.

Assume you want to load a property file cms.properties from your class path.

samplebean.value=1000

You can add the @PropertySource annotation to your @Configuration class and use the properties defined in the cms.properties file.

@Configuration
@PropertySource("classpath:/cms.properties")
public class AppConfig {

    @Autowired
    Environment env;

    @Bean
    public SampleBean sampleBean() {
        SampleBean sampleBean = new SampleBean();
        sampleBean.setValue(env.getProperty("samplebean.value"));
        return sampleBean;
    }
}

@SpringBootApplication
public class PropertyPlaceholderApplication implements CommandLineRunner {
	private Logger logger = LoggerFactory.getLogger(PropertyPlaceholderApplication.class);

	@Autowired
	SampleBean sampleBean;

	public static void main(String[] args) {
		SpringApplication.run(PropertyPlaceholderApplication.class, args);
	}

	@Override
	public void run(String... args) throws Exception {
		logger.info(sampleBean.getValue());
	}
}

If you execute the above application, you can see that the value property is assigned to the SampleBean as expected.

2022-04-08 13:04:09.900  INFO 5816 --- [           main] c.t.p.PropertyPlaceholderApplication     : Started PropertyPlaceholderApplication in 2.91 seconds (JVM running for 4.551)
2022-04-08 13:04:09.936  INFO 5816 --- [           main] c.t.p.PropertyPlaceholderApplication     : 1000

Note that Spring does not add these property sources to the Environment until the application context is being refreshed.

This is too late to configure certain properties such as logging.* and spring.main.* which are read before refresh begins.

4. Multiple property sources

You can define the @PropertySource annotation repeatedly according to Java 8 conventions. Hence, if we’re using Java 8 or above, you can use this annotation to define multiple property locations:

@Configuration
@PropertySource("classpath:/cms.properties")
@PropertySource("classpath:/root.properties")
public class AppConfig 

Alternatively, you can use @PropertySources to define multiple property sources as an array:

@Configuration

@PropertySources({
        @PropertySource("classpath:/cms.properties"),
        @PropertySource("classpath:/root.properties")
})
public class AppConfig {

There are scenarios where a property key exists in more than one .properties file, the last @PropertySource annotation processed will ‘win’ and override any previous key with the same name.

5. Conclusion

To sum up, we have learned the Spring @PropertySource annotation with example.