Spring Boot和多个外部配置文件

我有多个要从类路径加载的属性文件。有一个默认设置，/src/main/resources它是的一部分myapp.jar。我springcontext希望文件位于类路径中。即

<util:properties id="Job1Props"
    location="classpath:job1.properties"></util:properties>

<util:properties id="Job2Props"
    location="classpath:job2.properties"></util:properties>

我还需要使用外部设置覆盖这些属性的选项。我在中有一个外部配置文件夹cwd。按照spring boot doc config文件夹应该在classpath上。但是从doc尚不清楚，它是否只会覆盖applicaiton.propertiesfrom那里或config中的所有属性。

当我测试它时，只会application.properties被拾取，其余属性仍会从中拾取/src/main/resources。我尝试将它们作为逗号分隔的列表提供，spring.config.location但默认设置仍未被覆盖。

如何使多个外部配置文件覆盖默认文件？

作为解决方法，我目前使用app.config.location通过命令行提供的（特定于应用程序的属性）。即

java -jar myapp.jar app.config.location=file:./config

我改变了我的applicationcontext给

<util:properties id="Job2Props"
    location="{app.config.location}/job2.properties"></util:properties>

这就是我在加载应用程序时如何在文件和类路径之间进行分隔的方法。
编辑：

//psuedo code

if (StringUtils.isBlank(app.config.location)) {
            System.setProperty(APP_CONFIG_LOCATION, "classpath:");
}

我真的不希望使用上述变通方法，并且让spring像在application.properties文件路径上那样覆盖classpath上的所有外部配置文件。

使用Spring Boot时，属性按以下顺序加载（请参阅Spring Boot参考指南中的“ 外部化配置 ”）。

1. 命令行参数。
2. Java系统属性（System.getProperties（））。
3. 操作系统环境变量。
4. 来自java：comp / env的JNDI属性
5. 一个RandomValuePropertySource，仅具有random。*属性。
6. 打包的jar之外的应用程序属性（application.properties，包括YAML和配置文件变体）。
7. 打包在jar中的应用程序属性（包括YAML和配置文件变体的application.properties）。
8. @Configuration类上的@PropertySource批注。
9. 默认属性（使用SpringApplication.setDefaultProperties指定）。

解析属性时（即@Value("${myprop}")以相反的顺序进行解析（因此从9开始）。

要添加其他文件，您可以使用spring.config.location以逗号分隔的属性文件或文件位置（目录）列表的属性。

-Dspring.config.location=your/config/dir/

上面的一个将添加一个目录，供application.properties文件参考。

-Dspring.config.location=classpath:job1.properties,classpath:job2.properties

这会将2个属性文件添加到已加载的文件中。

默认配置文件和位置在附加指定spring.config.location的文件和位置之前加载，这意味着后者将始终覆盖较早配置文件和位置中设置的属性。（另请参阅《 Spring Boot参考指南》的本节）。

如果spring.config.location包含目录（而不是文件），则目录应以/结尾（并spring.config.name在加载后附加从生成的名称）。classpath:,classpath:/config,file:,file:config/始终使用默认搜索路径，而与的值无关spring.config.location。这样，您可以在中设置应用程序的默认值application.properties（或使用来选择的其他任何基本名称spring.config.name），并在运行时使用其他文件覆盖它，并保持默认值。

更新：由于spring.config.location的行为现在将覆盖默认值，而不是添加至默认值。您需要使用spring.config.additional-location保留默认值。这是从1.x到2.x的行为更改

使用Spring boot，spring.config.location可以正常工作，只提供逗号分隔的属性文件。

见下面的代码

@PropertySource(ignoreResourceNotFound=true,value="classpath:jdbc-${spring.profiles.active}.properties")
public class DBConfig{

     @Value("${jdbc.host}")
        private String jdbcHostName;
     }
}

可以将默认版本的jdbc.properties放入应用程序中。可以设置外部版本。

java -jar target/myapp.jar --spring.config.location=classpath:file:///C:/Apps/springtest/jdbc.properties,classpath:file:///C:/Apps/springtest/jdbc-dev.properties

基于使用spring.profiles.active属性设置的配置文件值，将获取jdbc.host的值。因此，当（在Windows上）

set spring.profiles.active=dev

jdbc.host将从jdbc-dev.properties中获取值。

对于

set spring.profiles.active=default

jdbc.host将从jdbc.properties中获取值。

Spring Boot 1.X和Spring Boot 2.X没有提供相同的选项和行为 Externalized Configuration。

M. Deinum的很好回答是指Spring Boot 1的特殊性。
我将在这里为Spring Boot 2更新。

环境属性的来源和顺序

Spring Boot 2使用了一种非常特殊的PropertySource顺序，该顺序旨在允许合理地覆盖值。按以下顺序考虑属性：

• 您的主目录上的Devtools全局设置属性（在devtools处于活动状态时，为〜/ .spring-boot-devtools.properties）。

• @TestPropertySource 测试中的注释。

• @SpringBootTest#properties测试中的注释属性。命令行参数。

• 来自的属性SPRING_APPLICATION_JSON（嵌入在环境变量或系统属性中的嵌入式JSON）。

• ServletConfig 初始化参数。

• ServletContext 初始化参数。

• 的JNDI属性java:comp/env。

• Java系统属性（System.getProperties()）。

• 操作系统环境变量。

• 一个RandomValuePropertySource仅具有随机属性的*。

• 打包的jar（application-{profile}.properties和YAML变体）之外的特定于配置文件的应用程序属性。

• 打包在jar中的特定于配置文件的应用程序属性（application-{profile}.properties和YAML变体）。

• 打包的jar（application.properties和YAML变体）之外的应用程序属性。

• 打包在jar中的应用程序属性（application.properties和YAML变体）。

• @PropertySource@Configuration类上的注释。默认属性（通过设置指定 SpringApplication.setDefaultProperties）。

要指定外部属性文件，您应该对这些选项感兴趣：

• 打包的jar（application-{profile}.properties和YAML变体）之外的特定于配置文件的应用程序属性。

• 打包的jar（application.properties和YAML变体）之外的应用程序属性。

• @PropertySource@Configuration类上的注释。默认属性（通过设置指定 SpringApplication.setDefaultProperties）。

您只能使用这三个选项之一，也可以根据需要将它们组合在一起。
例如，在非常简单的情况下，仅使用特定于配置文件的属性就足够了，但在其他情况下，您可能要同时使用特定于配置文件的属性，默认属性和@PropertySource。

application.properties文件的默认位置

关于application.properties文件（和变体），默认情况下，Spring会按以下顺序加载它们并在环境中添加它们的属性：

• 当前目录的/ config子目录

• 当前目录

• 类路径/ config包

• 类路径根

从字面上看，更高的优先权是这样的：
classpath:/,classpath:/config/,file:./,file:./config/。

如何使用具有特定名称的属性文件？

默认位置并不总是足够的：默认位置（例如默认文件名（application.properties））可能不适合。此外，正如在OP问题中一样，您可能需要指定多个配置文件，而不是application.properties（和变体）。
所以spring.config.name还不够。

在这种情况下，您应该使用spring.config.location环境属性（目录位置或文件路径的逗号分隔列表）来提供显式位置。
要放心使用文件名模式，应优先使用文件路径列表而不是目录列表。
例如这样做：

java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties

这样，最冗长的做法就是只指定文件夹，但也可以很好地指定我们的配置文件并清楚地记录有效使用的属性。

spring.config.location现在替换默认位置，而不是添加到默认位置

对于Spring Boot 1，该spring.config.location参数在Spring环境中添加指定的位置。
但是从Spring Boot 2开始，spring.config.location如文档所述，将 Spring使用的默认位置替换为Spring环境中的指定位置。

使用来配置自定义配置位置后 spring.config.location，它们将替换默认位置。例如，如果spring.config.location配置了的值 classpath:/custom-config/，file:./custom-config/，搜索顺序变为下式：

1. file:./custom-config/

2. classpath:custom-config/

spring.config.location现在是一种确保application.properties必须明确指定任何文件的方法。
对于不应该打包application.properties文件的超级JAR ，这非常好。

为了保持spring.config.location使用Spring Boot 2时的旧行为，您可以使用new spring.config.additional-location属性，而不是按照文档说明的那样spring.config.location添加位置：

或者，当使用来配置自定义配置位置时spring.config.additional-location，除默认位置外，还会使用 它们。

在实践中

因此，假设像在OP问题中那样，您有2个要指定的外部属性文件和uber jar中包含的1个属性文件。

要仅使用您指定的配置文件：

-Dspring.config.location=classpath:/job1.properties,classpath:/job2.properties,classpath:/applications.properties   

要将配置文件添加到这些文件的默认位置：

-Dspring.config.additional-location=classpath:/job1.properties,classpath:/job2.properties

classpath:/applications.properties 在最后一个示例中不需要，因为默认位置具有该默认位置，并且此处默认位置不会被覆盖，而是扩展。

看一下PropertyPlaceholderConfigurer，我发现它比注解更清晰地使用。

例如

@Configuration
public class PropertiesConfiguration {


    @Bean
    public PropertyPlaceholderConfigurer properties() {
        final PropertyPlaceholderConfigurer ppc = new PropertyPlaceholderConfigurer();
//        ppc.setIgnoreUnresolvablePlaceholders(true);
        ppc.setIgnoreResourceNotFound(true);

        final List<Resource> resourceLst = new ArrayList<Resource>();

        resourceLst.add(new ClassPathResource("myapp_base.properties"));
        resourceLst.add(new FileSystemResource("/etc/myapp/overriding.propertie"));
        resourceLst.add(new ClassPathResource("myapp_test.properties"));
        resourceLst.add(new ClassPathResource("myapp_developer_overrides.properties")); // for Developer debugging.

        ppc.setLocations(resourceLst.toArray(new Resource[]{}));

        return ppc;
    }

这是使用弹簧靴的一种简单方法

TestClass.java

@Configuration
@Profile("one")
@PropertySource("file:/{selected location}/app.properties")
public class TestClass {

    @Autowired
    Environment env;

    @Bean
    public boolean test() {
        System.out.println(env.getProperty("test.one"));
        return true;
    }
}

在app.properties背景下，您选择的位置

test.one = 1234

您的Spring Boot应用程序

@SpringBootApplication

public class TestApplication {

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

和预定义的application.properties上下文

spring.profiles.active = one

您可以根据需要编写任意数量的配置类，并通过设置spring.profiles.active启用/禁用它们 =概要文件名称（用逗号分隔）

如您所见，Spring Boot非常棒，只需要一段时间就可以熟悉，值得一提的是，您也可以在字段中使用@Value

@Value("${test.one}")
String str;

我有同样的问题。我希望能够在启动时使用外部文件覆盖内部配置文件，类似于Spring Boot application.properties检测。在我的情况下，这是一个user.properties文件，用于存储我的应用程序用户。

我的要求：

从以下位置加载文件（按此顺序）

1. 类路径
2. 一/配置当前目录的子目录。
3. 当前目录
4. 在启动时由命令行参数指定的目录或文件位置

我想出了以下解决方案：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.PathResource;
import org.springframework.core.io.Resource;

import java.io.IOException;
import java.util.Properties;

import static java.util.Arrays.stream;

@Configuration
public class PropertiesConfig {

    private static final Logger LOG = LoggerFactory.getLogger(PropertiesConfig.class);

    private final static String PROPERTIES_FILENAME = "user.properties";

    @Value("${properties.location:}")
    private String propertiesLocation;

    @Bean
    Properties userProperties() throws IOException {
        final Resource[] possiblePropertiesResources = {
                new ClassPathResource(PROPERTIES_FILENAME),
                new PathResource("config/" + PROPERTIES_FILENAME),
                new PathResource(PROPERTIES_FILENAME),
                new PathResource(getCustomPath())
        };
        // Find the last existing properties location to emulate spring boot application.properties discovery
        final Resource propertiesResource = stream(possiblePropertiesResources)
                .filter(Resource::exists)
                .reduce((previous, current) -> current)
                .get();
        final Properties userProperties = new Properties();

        userProperties.load(propertiesResource.getInputStream());

        LOG.info("Using {} as user resource", propertiesResource);

        return userProperties;
    }

    private String getCustomPath() {
        return propertiesLocation.endsWith(".properties") ? propertiesLocation : propertiesLocation + PROPERTIES_FILENAME;
    }

}

现在，该应用程序使用类路径资源，但也在其他给定位置检查资源。存在的最后一个资源将被选择和使用。我可以使用java -jar myapp.jar --properties.location = / directory / myproperties.properties来启动我的应用程序，以使用使我的船浮起的属性位置。

此处的重要细节：@Value批注中，将空字符串用作properties.location的默认值，以避免在未设置属性时出错。

properties.location的约定为：使​​用目录或属性文件的路径作为properties.location。

如果只想覆盖特定的属性，则可以将setIgnoreResourceNotFound（true）的PropertiesFactoryBean与资源数组设置为位置一起使用。

我确信该解决方案可以扩展为处理多个文件...

编辑

这是我对多个文件的解决方案:)像以前一样，可以将其与PropertiesFactoryBean结合使用。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.PathResource;
import org.springframework.core.io.Resource;

import java.io.IOException;
import java.util.Map;
import java.util.Properties;

import static java.util.Arrays.stream;
import static java.util.stream.Collectors.toMap;

@Configuration
class PropertiesConfig {

    private final static Logger LOG = LoggerFactory.getLogger(PropertiesConfig.class);
    private final static String[] PROPERTIES_FILENAMES = {"job1.properties", "job2.properties", "job3.properties"};

    @Value("${properties.location:}")
    private String propertiesLocation;

    @Bean
    Map<String, Properties> myProperties() {
        return stream(PROPERTIES_FILENAMES)
                .collect(toMap(filename -> filename, this::loadProperties));
    }

    private Properties loadProperties(final String filename) {
        final Resource[] possiblePropertiesResources = {
                new ClassPathResource(filename),
                new PathResource("config/" + filename),
                new PathResource(filename),
                new PathResource(getCustomPath(filename))
        };
        final Resource resource = stream(possiblePropertiesResources)
                .filter(Resource::exists)
                .reduce((previous, current) -> current)
                .get();
        final Properties properties = new Properties();

        try {
            properties.load(resource.getInputStream());
        } catch(final IOException exception) {
            throw new RuntimeException(exception);
        }

        LOG.info("Using {} as user resource", resource);

        return properties;
    }

    private String getCustomPath(final String filename) {
        return propertiesLocation.endsWith(".properties") ? propertiesLocation : propertiesLocation + filename;
    }

}

Spring Boot允许我们编写不同的配置文件以针对不同的环境编写，例如，我们可以为生产，质量保证和本地环境提供单独的属性文件

根据我的本地计算机配置的application-local.properties文件是

spring.profiles.active=local

spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
spring.data.mongodb.database=users
spring.data.mongodb.username=humble_freak
spring.data.mongodb.password=freakone

spring.rabbitmq.host=localhost
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.port=5672

rabbitmq.publish=true

同样，我们可以根据需要编写许多属性文件，例如application-prod.properties和application-qa.properties。

然后编写一些脚本以针对不同的环境启动应用程序，例如

mvn spring-boot:run -Drun.profiles=local
mvn spring-boot:run -Drun.profiles=qa
mvn spring-boot:run -Drun.profiles=prod

我刚刚遇到了类似的问题，并最终找出了原因：application.properties文件的所有权和rwx属性错误。因此，当tomcat启动时，application.properties文件位于正确的位置，但由另一个用户拥有：

$ chmod 766 application.properties

$ chown tomcat application.properties

@mxsb解决方案的修改版，允许我们定义多个文件，在我的情况下，这些文件是yml文件。

在我的application-dev.yml中，添加了此配置，该配置使我可以注入其中包含-dev.yml的所有yml。这也可以是特定文件的列表。“ classpath：/test/test.yml，classpath：/test2/test.yml”

application:
  properties:
    locations: "classpath*:/**/*-dev.yml"

这有助于获取属性图。

@Configuration

public class PropertiesConfig {

private final static Logger LOG = LoggerFactory.getLogger(PropertiesConfig.class);

@Value("${application.properties.locations}")
private String[] locations;

@Autowired
private ResourceLoader rl;

@Bean
Map<String, Properties> myProperties() {
    return stream(locations)
            .collect(toMap(filename -> filename, this::loadProperties));
}

private Properties loadProperties(final String filename) {

    YamlPropertySourceLoader loader = new YamlPropertySourceLoader();
    try {
        final Resource[] possiblePropertiesResources = ResourcePatternUtils.getResourcePatternResolver(rl).getResources(filename);
        final Properties properties = new Properties();
        stream(possiblePropertiesResources)
                .filter(Resource::exists)
                .map(resource1 -> {
                    try {
                        return loader.load(resource1.getFilename(), resource1);
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                }).flatMap(l -> l.stream())
                .forEach(propertySource -> {
                    Map source = ((MapPropertySource) propertySource).getSource();
                    properties.putAll(source);
                });

        return properties;
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
}

但是，如果像我这样，我想必须为每个概要文件拆分yml文件并加载它们，然后在bean初始化之前将其直接注入spring配置。

config
    - application.yml
    - application-dev.yml
    - application-prod.yml
management
    - management-dev.yml
    - management-prod.yml

...你明白了

组件略有不同

@Component
public class PropertiesConfigurer extends     PropertySourcesPlaceholderConfigurer
    implements EnvironmentAware, InitializingBean {

private final static Logger LOG = LoggerFactory.getLogger(PropertiesConfigurer.class);

private String[] locations;

@Autowired
private ResourceLoader rl;
private Environment environment;

@Override
public void setEnvironment(Environment environment) {
    // save off Environment for later use
    this.environment = environment;
    super.setEnvironment(environment);
}

@Override
public void afterPropertiesSet() throws Exception {
    // Copy property sources to Environment
    MutablePropertySources envPropSources = ((ConfigurableEnvironment) environment).getPropertySources();
    envPropSources.forEach(propertySource -> {
        if (propertySource.containsProperty("application.properties.locations")) {
            locations = ((String) propertySource.getProperty("application.properties.locations")).split(",");
            stream(locations).forEach(filename -> loadProperties(filename).forEach(source ->{
                envPropSources.addFirst(source);
            }));
        }
    });
}


private List<PropertySource> loadProperties(final String filename) {
    YamlPropertySourceLoader loader = new YamlPropertySourceLoader();
    try {
        final Resource[] possiblePropertiesResources = ResourcePatternUtils.getResourcePatternResolver(rl).getResources(filename);
        final Properties properties = new Properties();
        return stream(possiblePropertiesResources)
                .filter(Resource::exists)
                .map(resource1 -> {
                    try {
                        return loader.load(resource1.getFilename(), resource1);
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                }).flatMap(l -> l.stream())
                .collect(Collectors.toList());
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

}

如果要覆盖application.properties文件中指定的值，则可以在运行应用程序时更改活动配置文件，并为该配置文件创建应用程序属性文件。因此，例如，让我们指定活动配置文件“ override”，然后，假设您已在/ tmp下创建了名为“ application-override.properties”的新应用程序属性文件，则可以运行

java -jar yourApp.jar --spring.profiles.active="override" --spring.config.location="file:/tmp/,classpath:/" 

在spring.config.location下指定的值以相反的顺序求值。因此，在我的示例中，首先评估classpat，然后评估文件值。

如果jar文件和“ application-override.properties”文件位于当前目录中，则实际上可以简单地使用

java -jar yourApp.jar --spring.profiles.active="override"

因为Spring Boot会为您找到属性文件

我发现这是遵循的有用模式：

@RunWith(SpringRunner)
@SpringBootTest(classes = [ TestConfiguration, MyApplication ],
        properties = [
                "spring.config.name=application-MyTest_LowerImportance,application-MyTest_MostImportant"
                ,"debug=true", "trace=true"
        ]
)

在这里，我们重写了对“ application.yml”的使用，以使用“ application-MyTest_LowerImportance.yml”以及“ application-MyTest_MostImportant.yml”
（Spring还将查找.properties文件）

另外，还包括调试和跟踪设置，它们另外包含在命令行中，作为额外的奖励，因此您可以根据需要将其注释掉；]

调试/跟踪非常有用，因为Spring将转储它加载的所有文件的名称以及它尝试加载的文件的名称。
在运行时，您将在控制台中看到以下行：

TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'file:./config/application-MyTest_MostImportant.properties' (file:./config/application-MyTest_MostImportant.properties) resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'file:./config/application-MyTest_MostImportant.xml' (file:./config/application-MyTest_MostImportant.xml) resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'file:./config/application-MyTest_MostImportant.yml' (file:./config/application-MyTest_MostImportant.yml) resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'file:./config/application-MyTest_MostImportant.yaml' (file:./config/application-MyTest_MostImportant.yaml) resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'file:./config/application-MyTest_LowerImportance.properties' (file:./config/application-MyTest_LowerImportance.properties) resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'file:./config/application-MyTest_LowerImportance.xml' (file:./config/application-MyTest_LowerImportance.xml) resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'file:./config/application-MyTest_LowerImportance.yml' (file:./config/application-MyTest_LowerImportance.yml) resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'file:./config/application-MyTest_LowerImportance.yaml' (file:./config/application-MyTest_LowerImportance.yaml) resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'file:./application-MyTest_MostImportant.properties' (file:./application-MyTest_MostImportant.properties) resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'file:./application-MyTest_MostImportant.xml' (file:./application-MyTest_MostImportant.xml) resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'file:./application-MyTest_MostImportant.yml' (file:./application-MyTest_MostImportant.yml) resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'file:./application-MyTest_MostImportant.yaml' (file:./application-MyTest_MostImportant.yaml) resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'file:./application-MyTest_LowerImportance.properties' (file:./application-MyTest_LowerImportance.properties) resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'file:./application-MyTest_LowerImportance.xml' (file:./application-MyTest_LowerImportance.xml) resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'file:./application-MyTest_LowerImportance.yml' (file:./application-MyTest_LowerImportance.yml) resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'file:./application-MyTest_LowerImportance.yaml' (file:./application-MyTest_LowerImportance.yaml) resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'classpath:/config/application-MyTest_MostImportant.properties' resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'classpath:/config/application-MyTest_MostImportant.xml' resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'classpath:/config/application-MyTest_MostImportant.yml' resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'classpath:/config/application-MyTest_MostImportant.yaml' resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'classpath:/config/application-MyTest_LowerImportance.properties' resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'classpath:/config/application-MyTest_LowerImportance.xml' resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'classpath:/config/application-MyTest_LowerImportance.yml' resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'classpath:/config/application-MyTest_LowerImportance.yaml' resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'classpath:/application-MyTest_MostImportant.properties' resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'classpath:/application-MyTest_MostImportant.xml' resource not found
DEBUG 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Loaded config file 'file:/Users/xxx/dev/myproject/target/test-classes/application-MyTest_MostImportant.yml' (classpath:/application-MyTest_MostImportant.yml)
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'classpath:/application-MyTest_MostImportant.yaml' resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'classpath:/application-MyTest_LowerImportance.properties' resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'classpath:/application-MyTest_LowerImportance.xml' resource not found
DEBUG 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Loaded config file 'file:/Users/xxx/dev/myproject/target/test-classes/application-MyTest_LowerImportance.yml' (classpath:/application-MyTest_LowerImportance.yml)
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'classpath:/application-MyTest_LowerImportance.yaml' resource not found
TRACE 93941 --- [   main] o.s.b.c.c.ConfigFileApplicationListener  : Skipped config file 'file:./config/application-MyTest_MostImportant-test.properties' (file:./config/application-MyTest_MostImportant-test.properties) resource not found

试图解决这个问题时，我遇到了很多问题。这是我的设置

开发环境：Windows 10，Java：1.8.0_25，Spring Boot：2.0.3.RELEASE，Spring：5.0.7.RELEASE

我发现，spring坚持“合理的配置默认值”概念。这就是说，您必须将所有属性文件作为war文件的一部分。进入该目录后，您可以使用“ --spring.config.additional-location”命令行属性覆盖它们，以指向外部属性文件。但是，如果属性文件不是原始war文件的一部分，则这将不起作用。

演示代码：https : //github.com/gselvara/spring-boot-property-demo/tree/master