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
:
- A
/config
subdirectory of the current directory - The current directory
- A classpath
/config
package - 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.