Spring boot external configuration of property file

Question

I have a spring boot application that I can package in a war that I want to deploy to different environments. To automate this deployment it'd be easier to have the configuration file externalized.

Currently everything works fine with a application.properties file in src/main/resources. Then I use ´mvn install´ to build a war deployable to tomcat. But I would like to use a .yml file that does not need to be present on mvn install but that would be read from during deployment of the war and is in the same or a directory relative to my war.

24. externalized configuration shows where spring boot will look for files and 72.3 Change the location of external properties of an application gives more detail on how to configure this but I just do not understand how to translate this to my code.

My application class looks like this: package be.ugent.lca;

Updated below

Do I need to add a @PropertySource to this file? How would I refer to a certain relative path?

I feel like it's probably documented in there as most spring boot documentation but I just don't understand how they mean me to do this.

EDIT

Not sure if this should be a separate issue but I think it's still related.
Upon setting the os variable the error of yaml file not found went away. Yet I still get the same error again as when I had no application .properties or .yml file. Application now looks like this:

@Configuration
**@PropertySource("file:${application_home}/application.yml")**
@ComponentScan({"be.ugent.lca","be.ugent.sherpa.configuration"})
@EnableAutoConfiguration
@EnableSpringDataWebSupport
public class Application extends SpringBootServletInitializer{
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);

    }

The application_home OS variable

$ echo $application_home  
C:\Masterproef\clones\la15-lca-web\rest-service\target

My application.yml file(part it complains about):

sherpa:
  package:
    base: be.ugent.lca

Error upon java -jar *.war All variations upon:

Caused by: java.lang.IllegalArgumentException: Could not resolve placeholder 'sherpa.package.base' in string value "${sherpa.package.base}"
    at org.springframework.util.PropertyPlaceholderHelper.parseStringValue(PropertyPlaceholderHelper.java:174)
    at org.springframework.util.PropertyPlaceholderHelper.replacePlaceholders(PropertyPlaceholderHelper.java:126)
    at org.springframework.core.env.AbstractPropertyResolver.doResolvePlaceholders(AbstractPropertyResolver.java:204)
    at org.springframework.core.env.AbstractPropertyResolver.resolveRequiredPlaceholders(AbstractPropertyResolver.java:178)
    at org.springframework.context.support.PropertySourcesPlaceholderConfigurer$2.resolveStringValue(PropertySourcesPlaceholderConfigurer.java:172)
    at org.springframework.beans.factory.support.AbstractBeanFactory.resolveEmbeddedValue(AbstractBeanFactory.java:808)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1027)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:1014)
    at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:545)
    ... 142 more

Where is your properties/yml file? What props you want to read from it? The question seems unclear to me — Vasu, Mar 25 '17 at 19:21
Does my edit clear up the location? Properties are mostly the same in most location but database and database login may change depending on TST, QAS — turoni, Mar 25 '17 at 19:27

score 38 · Accepted Answer · edited Nov 02 '21 at 00:02

Using external properties files

The answer lies in the Spring Boot Docs, I'll try to break it down for you.

First of all, no you should not use @PropertySource when working with Yaml configuration, as mentioned here under the Yaml shortcomings :

YAML files can’t be loaded via the @PropertySource annotation. So in the case that you need to load values that way, you need to use a properties file.

So, how to load propery files? That is explained here Application Property Files

One is loaded for you: application.yml , place it in one of the directories as mentioned in the link above. This is great for your general configuration.

Now for your environment specific configuration (and stuff like passwords) you want to use external property files, how to do that is also explained in that section :

If you don’t like application.properties as the configuration file name you can switch to another by specifying a spring.config.name environment property. You can also refer to an explicit location using the spring.config.location environment property (comma-separated list of directory locations, or file paths).

So you use the spring.config.location environment property. Imagine you have an external config file: application-external.yml in the conf/ dir under your home directory, just add it like this: -Dspring.config.location=file:${home}/conf/application-external.yml as a startup parameter of your JVM. If you have multiple files, just seperate them with a comma. Note that you can easily use external properties like this to overwrite properties, not just add them.

I would advice to test this by getting your application to work with just your internal application.yml file , and then overwrite a (test) property in your external properties file and log the value of it somewhere.

Bind Yaml properties to objects

When working with Yaml properties I usually load them with @ConfigurationProperties, which is great when working with for example lists or a more complex property structure. (Which is why you should use Yaml properties, for straightforward properties you are maybe better of using regular property files). Read this for more information: Type-Safe Configuration properties

Extra: loading these properties in IntelliJ, Maven and JUnit tests

Sometimes you want to load these properties in your maven builds or when performing tests. Or just for local development with your IDE

If you use IntelliJ for development you can easily add this by adding it to your Tomcat Run Configuration : "Run" -> "Edit Configurations" , select your run configuration under "Tomcat Server" , check the Server tab and add it under "VM Options".

To use external configuration files in your Maven build : configure the maven surefire plugin like this in your pom.xml:

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-surefire-plugin</artifactId>
  <configuration>
     <argLine>-Dspring.config.location=file:${home}/conf/application-external.yml</argLine>
   </configuration>
</plugin>

When running JUnit tests in IntelliJ:

Run → Edit Configurations
Defaults → JUnit
add VM Options -> -ea -Dspring.config.location=file:${home}/conf/application-external.yml

@loїc Great answer! I regret that can't put more than one upvote) — VB_, May 18 '18 at 09:12
@loїc Thank you. Great answer. One question though, can we have multiple http external file systems can be added spring.config.location ?. In other words, how can we access external github and vault properties w/o application.properties defined with in the application. — siddhuKantipudi, Nov 05 '20 at 17:30

Vasu · Answer 2 · 2017-03-25T22:06:56.763

8

Yes, you need to use @PropertySource as shown below.

The important point here is that you need to provide the application_home property (or choose any other name) as OS environment variable or System property or you can pass as a command line argument while launching Spring boot. This property tells where the configuration file (.properties or .yaml) is exactly located (example: /usr/local/my_project/ etc..)

@Configuration
@PropertySource("file:${application_home}config.properties")//or specify yaml file
@ComponentScan({"be.ugent.lca","be.ugent.sherpa.configuration"})
@EnableAutoConfiguration
@EnableSpringDataWebSupport
public class Application extends SpringBootServletInitializer{
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

edited Mar 25 '17 at 22:06

answered Mar 25 '17 at 19:49

Vasu

21,832
11
51
67

So $application_home should contain the directory that contains my .yml? I've added what it echos to, that's where my .yml file (and war) are. – turoni Mar 25 '17 at 21:08
yes, you are right... set Windows OS environment variable like `application_home=C:\\myproject` (or any other OS variable) – Vasu Mar 25 '17 at 21:10
Strange that's how I did it. Any idea why it still cannot resolve my property? – turoni Mar 25 '17 at 21:20
one thing I could notice is, in your previous line, you says that `$application_home`, which is wrong, don't prefix `$` in the OS variable, it is required only in the java class as part of the Spring Expression Language – Vasu Mar 25 '17 at 21:22
The $ is just to refer to a variable. The name is application_home and I refer to it as you mentioned and as is shown in my updated classfile – turoni Mar 25 '17 at 21:46
Because you are using Windows, change it as `@PropertySource("file:${application_home}\\application.yml")` – Vasu Mar 25 '17 at 22:06
Let us [continue this discussion in chat](http://chat.stackoverflow.com/rooms/139055/discussion-between-javaguy-and-turoni). – Vasu Mar 25 '17 at 22:07
I didn't need to set my environment variable, because the current directory is the project root, so I just used: @PropertySource("file:config/config.properties") and it worked. I was missing the 'file:' part. So you helped me! Thanks. – ac_ Sep 23 '21 at 16:33

score 0 · Answer 3 · answered Jun 22 '22 at 09:27

0

There is a very simple way to achieve this.

Inside your original application.properties file you can just specify the following line:

spring.config.import=file:Directory_To_The_File/Property_Name.properties

It will automatically sync all the properties from the external property file.

Now lets say that you have a situation where you need to get properties from multiple property files. In that case, you can mention the same line in the external property file which in turn will take the remaining properties from the second property file and so on.

Consider the following example.

application.properties:

spring.config.import=file:Resources/Custom1.properties

Custom1.properties:

server.port=8090
.
.
.
spring.config.import=file:Resources/Custom2.properties

answered Jun 22 '22 at 09:27

Dominator_007

3
4

how to give the path if it is somewhere in drive lkie this E:\Mopendra\coding\application.properties , I tried spring.config.import=file:Resources/E:\Mopendra\coding\application.properties and few more combination but it didn't work – Mopendra Kumar May 10 '23 at 17:10
1

Try putting the following line under src/main/resources/application.properties spring.config.import=file:E:\Mopendra\coding\application.properties @MopendraKumar – Dominator_007 Aug 07 '23 at 07:35
Thanks, it worked with @PropertySource("file:E:////Mopendra////coding////application.properties"), actually //// This character sequence needed to handle both Windows and Linux operating system – Mopendra Kumar Aug 24 '23 at 16:44

score -1 · Answer 4 · answered Nov 12 '18 at 13:01

One of the easiest way to use externalized property file using system environment variable is, in application.properties file you can use following syntax:

spring.datasource.url = ${OPENSHIFT_MYSQL_DB_HOST}:${OPENSHIFT_MYSQL_DB_PORT}/"nameofDB"
spring.datasource.username = ${OPENSHIFT_MYSQL_DB_USERNAME}
spring.datasource.password = ${OPENSHIFT_MYSQL_DB_PORT}

Now, declare above used environment variables,

export OPENSHIFT_MYSQL_DB_HOST="jdbc:mysql://localhost"
export OPENSHIFT_MYSQL_DB_PORT="3306"
export OPENSHIFT_MYSQL_DB_USERNAME="root"
export OPENSHIFT_MYSQL_DB_PASSWORD="123asd"

This way you can use different value for same variable in different environments.

score -5 · Answer 5 · edited Mar 12 '18 at 08:22

-5

Use below code in your boot class:

@PropertySource({"classpath:omnicell-health.properties"})

use below code in your controller:

@Autowired
    private Environment env;

edited Mar 12 '18 at 08:22

Faysal Ahmed

7,501
5
28
50

answered Mar 12 '18 at 07:19

vinoth Kumar

1
1

Spring boot external configuration of property file

5 Answers5

Linked

Related