在插件中通过Tomcat覆盖Spring Boot application.properties属性？

Question

We have a base project, example-platform and an extending customer project, example-customer1 that uses the platform as a dependency. The application.properties of the platform defines the default properties and the customer project overwrites these. For example, the platform can be run on its own so it has a spring.datasource.url for the database it uses and the customer project uses another.

Initially, I had hoped that this could be done simply by having an application.properties in the customer project that changed the necessary properties, but instead, only the properties in that file were used instead of anything in the platform's application.properties. At first I just copied over the application.properties file and changed some properties, but I don't like the idea of having to update the customer project if a new property is needed for platform. To fix that, I put the application.properties of the customer project into config/application.properties. That way I could have the properties from platform and override only the ones I needed to in the customer project.

Now I need to be able to override the properties when it's deployed as a War with Tomcat. That is, I need properties in example-platform / application.properties to be overridden by example-customer1 / config / application.properties to be overridden by some application.properties for Tomcat.

Before I put application.properties into the config folder for the customer project, I was able to have an application.properties on Tomcat under props/config and the properties were loaded from that. Now that the application.properties of the customer plugin is under /config, however, I think that's being used instead of the properties on Tomcat.

What is the most elegant "Spring" way to accomplish this hierarchy of properties?

edit: To clarify on what I want, let's say we have a property appName . In example-platform/application.properties I would have appName=platform-app , in application.properties of example-customer1/application.properties, appName=customer-app . Then in Tomcat I would like to have an application.properties to be able to override this again, so for one deployment it could be appName=cusomter-app-deployment1 .

Answer 1

The properties are loaded in this order ( source ):

• ...
• Profile-specific application properties outside of your packaged jar (application-{profile}.properties and YAML variants)
• Profile-specific application properties packaged inside your jar (application-{profile}.properties and YAML variants)
• Application properties outside of your packaged jar (application.properties and YAML variants).
• Application properties packaged inside your jar (application.properties and YAML variants).
• ...

By default, Spring-boot will look for application.properties in your classpath (folder and inside jars) at the locations ./ and ./config (either on disk or in a jar).

Quick solution

• Specify a spring profile ( customer1 ) when initializing your spring boot app
• use an example-platform/application.properties
• and example-customer1/application-customer1.properties .

Same solution - long version

(1) Platform project

• Create your default src/main/resources/application.properties
• Make sure that this application.properties is located in ./config or ./ in your packaged jar.

(2) Customer1 project

• Create an application-${profile}.properties for profile customer1 where you'll override the properties: src/main/resources/application-customer1.properties .
• Don't create a default application.properties here.

(3) Launching

Whether you launch your spring boot application from a jar or as a deployed war, you need to specify the profile customer1 :

@SpringBootApplication
public class SpringBootApp extends SpringBootServletInitializer{
    public static void main(String[] args){
        new SpringApplicationBuilder() //
        .sources(SpringBootApp.class)//
        .profiles("customer1")
        .run(args);
    }
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(SpringBootApp.class)//
        .profiles("customer1");
    }
}

That's it. Spring Boot will load the default application.properties from its classpasth (example-platform.jar), then load the application-customer1.properties over it.