How to load external configuration files after the SpringBoot project is made into a jar

1. External application.properties

Most of the configuration information is configured in application.properties, so can this file be external? Of course this is possible.

First define a property in application.preperties:

demo.name = hello.01

Use it in Controller:

@Value("${demo.name}")
private String demoName;
 
@RequestMapping("/test")
public String test(){
    return this.demoName;
}

Type the project into a jar package and start it using java -jar:

java -jar springboot-out-properties-0.0.1-SNAPSHOT.jar

The value read at this time is: hello.01.

Copy the application.properties in the project and put it in the same path as the jar package. Modify the property value to:

demo.name = hello.02

Then use the above command to restart and see the effect. The value is hello.02. Surprising or not, Spring Boot is so awesome. The jar package can be read directly under the same path.

If we create a new config under the jar and put application.properties in it, can we identify it using the above command? The answer is yes,

SpringApplication will load properties from application.properties files in the following locations and add them to the Spring environment:

• In the current directory /config subdirectory

• classpath root directory

• /config directory in classpath

• current Directory

If a customized directory, such as conf, will not be recognized at this time, but you can use --spring.config.location to specify the path. The execution command is as follows:

java -jar springboot-out-properties-0.0.1-SNAPSHOT.jar--spring.config.location=conf/application.properties

Of course, you can also use the absolute path to specify:

java -jar springboot-out-properties-0.0.1-SNAPSHOT.jar--spring.config.location=/Users/linxiangxian/Downloads/conf/application.properties

2. @PropertySource External

In the project, some configurations will use customized properties files, such as defining demo.properties:

demo.nickname = hello.10
demo.weixin = springboot

Use @PropertySource to specify the configuration file:

 /**
 * @PropertySource的例子
 * <p>
 */
@Configuration
@ConfigurationProperties(prefix = "demo")
@PropertySource(value = {"classpath:demo.properties"})
public class DemoProperties {
    private String nickname;
    private String weixin;
 
    public String getNickname() {
        return nickname;
    }
 
    public void setNickname(String nickname) {
        this.nickname = nickname;
    }
 
    public String getWeixin() {
        return weixin;
    }
 
    public void setWeixin(String weixin) {
        this.weixin = weixin;
    }
 
    @Override
    public String toString() {
        return "DemoProperties{" +
                "nickname=&#39;" + nickname + &#39;\&#39;&#39; +
                ", weixin=&#39;" + weixin + &#39;\&#39;&#39; +
                &#39;}&#39;;
    }
}

Then you can access this configuration file at this time, make it into a jar package, and execute the command:

java -jar springboot-out-properties-0.0.1-SNAPSHOT.jar

At this time The returned value is: hello.10

Put demo.properties in the same path as the jar package, modify the value of demo.name to hello.11, execute the above command, Barbie Q, the result is still hello .10, indicating that Spring Boot cannot find customized properties files from the outside.

So what can we do about this problem?

It’s very simple. @PropertySource supports multiple configurations and multiple paths, which can be configured like this:

@PropertySource(value = {"classpath:demo.properties","file:./demo.properties"},ignoreResourceNotFound = true)

When we configure multiple paths and the configuration files under the multiple paths exist, SpringBoot will load them all and will cover the same content. So when our configuration information only distinguishes external and internal paths and the contents are exactly the same, just write the file path at the end. When we start locally, because the file path does not exist, the classpath will be loaded; when the jar starts, the file path will overwrite the contents of the classpath path;

ignoreResourceNotFound = true must be added, otherwise it cannot be found An error will be reported. After adding, configuration files that cannot be found will be ignored.

At this point, just put the configuration file demo.properties under the same level as the jar package.

The above is the detailed content of How to load external configuration files after the SpringBoot project is made into a jar. For more information, please follow other related articles on the PHP Chinese website!