目录

摘要

Spring Boot 配置加载顺序

配置文件加载顺序

Spring Boot 配置加载方式

@Value

@Value 注解简单示例

@ConfigurationProperties

启动 @ConfigurationProperties

@ConfigurationProperties 验证

@ConfigurationProperties 与 @Value 对比

@Autowired

@Autowired 自动装配的策略

@Autowired 三种注入方式

属性注入

构造函数注入

Setter 方法注入

Java Bean 属性绑定

构造函数绑定

JSON应用程序属性

命令行参数

配置加载拓展

 @ConstructorBinding

@DefaultValue

YAML 映射到属性的扁平化处理

接收YAML 的List 类型属性

接收YAML 的Map 类型属性

配置引入方式

spring.config.name 

Spring.config-location

Spring.config.additional-location

Spring.config.import

配置文件相关语法

可选的配置

通配符

属性占位符

多文档分割处理

配置系统环境属性

使用示例

配置文件的使用

配置激活

导入无拓展名的文件

配置随机值

Spring Boot 自动配置

查询自动配置详细说明

@Enable*注解

参考文献

摘要

        本文参考Spring 官方，对Spring Boot 外部化配置模块进行详细的阐述和总结。旨在为广大学习者和开发者提供一个关于Spring Boot 配置模块实用的参考资料。

        Spring Boot 可以帮助你在不同的环境中使用一套代码。你可以使用各种不同的配置方式，例如Java 属性文件、YAML 文件、环境变量和命令行参数等。 ​

Spring Boot 配置加载顺序

        在Spring Boot 中属性源是按一定的顺序进行加载的，并且后面的属性源可以覆盖前面属性源中定义的相同属性值 。在 Spring Boot 中，注入资源的覆盖过程如下：

1. 默认属性：通过SpringApplication.setDefaultProperties(Map)设置的默认属性，这是最早被考虑的属性来源。

2. @PropertySource 注解：在@Configuration类上使用@PropertySource注解指定的属性源。需要注意的是，这些属性源直到应用上下文刷新时才会添加到Environment中，因此对于某些在刷新开始前就需要读取的属性（如logging.*和spring.main.*），这种方式配置为时已晚。

3. 配置数据：例如application.properties等文件中的配置数据。

4. 随机值属性源：RandomValuePropertySource，其属性仅存在于random.*中。

5. 操作系统环境变量：操作系统层面设置的环境变量。

6. Java 系统属性：通过System.getProperties()获取的 Java 系统属性。

7. JNDI 属性：来自java:comp/env的 JNDI 属性。

8. ServletContext 初始化参数：在 ServletContext 初始化时设置的参数。

9. ServletConfig 初始化参数：在 ServletConfig 初始化时设置的参数。

10. SPRING_APPLICATION_JSON 属性：嵌入在环境变量或系统属性中的内联 JSON 数据，即 SPRING_APPLICATION_JSON 中的属性。

11. 命令行参数：在启动应用程序时通过命令行传递的参数。

12. 测试属性：在测试中，@SpringBootTest及其他用于测试应用程序特定部分的测试注解中的properties属性。

13. @DynamicPropertySource 注解：在测试中使用@DynamicPropertySource注解定义的动态属性源。

14. @TestPropertySource 注解：在测试类上使用@TestPropertySource注解指定的属性源。

15. Devtools 全局设置属性：当 Devtools 处于活动状态时，$HOME/.config/spring-boot目录中的 Devtools 全局设置属性

配置文件加载顺序

    Spring Boot 的配置文件按以下顺序加载：

1. 打包在Jar包中的 application.properties

2. 打包在Jar包中的 application-{profile}.properties

3. 打包在Jar包之外的 application.properties

4. 打包在Jar包之外的 application-{profile}.properties

        这个覆盖规则我们在简单部署生产项目的时候经常会用到，就是将项目的.properites /.yml配置文件复制一份，放在项目的Jar 包外。然后将生产环境相关的配置文件直接写在外部的配置文件中，再执行Jar -jar 命令启动程序，就可以直接使用Jar包外部关于生产环境的配置了。

Spring Boot 配置加载方式

@Value

   @Value 注解主要用于将外部配置文件（如 application.properties 或 application.yml）中的属性值注入到 Spring 管理的 Bean 的属性中。

@Value 注解简单示例

@Component
public class MyBean {

	@Value("${name}")
	private String name;

	// ...

}

@ConfigurationProperties

   @ConfigurationProperties 提供了一种方便、灵活和可扩展的方式将外部配置文件中的属性绑定到 Java Bean 上。它支持简单和复杂的属性结构，包括嵌套属性、列表和映射，还支持构造函数绑定和属性验证。使用 @ConfigurationProperties 可以使配置管理更加清晰，将配置信息集中在 Java Bean 中，便于维护和测试。

        使用该注解时，要注意属性前缀的使用、不同属性类型的绑定方式以及属性验证的规则。它可以帮助你更好地组织和管理 Spring Boot 应用程序的配置信息，提高代码的可读性和可维护性，同时为不同的部署环境提供了更灵活的配置管理手段。

启动 @ConfigurationProperties

        为了使 @ConfigurationProperties 注解生效，你可以在主应用程序类上添加 @EnableConfigurationProperties 注解：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;

@SpringBootApplication
@EnableConfigurationProperties(MyAppProperties.class)
public class MyAppApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyAppApplication.class, args);
    }
}

@ConfigurationProperties 验证

        @ConfigurationProperties可以结合 JSR-303 约束注释，来确保这些属性符合预期的范围和格式。通过验证，可以防止因配置错误导致的运行时异常，提高应用程序的稳定性和可靠性。以下是官网提供的示例代码：

@ConfigurationProperties("my.service")
@Validated
public class MyProperties {

	@NotNull
	private InetAddress remoteAddress;

	// getters/setters...

	public InetAddress getRemoteAddress() {
		return this.remoteAddress;
	}

	public void setRemoteAddress(InetAddress remoteAddress) {
		this.remoteAddress = remoteAddress;
	}

}

        要将验证级联到嵌套属性，关联字段必须用 注释@Valid。

@ConfigurationProperties("my.service")
@Validated
public class MyProperties {

	@NotNull
	private InetAddress remoteAddress;

	@Valid
	private final Security security = new Security();

	// getters/setters...

	public InetAddress getRemoteAddress() {
		return this.remoteAddress;
	}

	public void setRemoteAddress(InetAddress remoteAddress) {
		this.remoteAddress = remoteAddress;
	}

	public Security getSecurity() {
		return this.security;
	}

	public static class Security {

		@NotEmpty
		private String username;

		// getters/setters...

		public String getUsername() {
			return this.username;
		}

		public void setUsername(String username) {
			this.username = username;
		}

	}

}

@ConfigurationProperties 与 @Value 对比

• 如果您想使用@Value，我们建议您使用其规范形式（仅使用小写字母的 kebab-case）引用属性名称。这将允许 Spring Boot 使用与@ConfigurationProperties宽松绑定时相同的逻辑。

@Autowired

   @Autowired 是 Spring 框架中的一个注解，用于自动装配 Spring Bean。它允许 Spring 容器自动将依赖注入到类的属性、构造函数、setter 方法或其他方法中，从而实现依赖注入（Dependency Injection，DI），是控制反转（Inversion of Control，IoC）原则的一种实现方式。

@Autowired 自动装配的策略

• 按类型：当使用 @Autowired 时，Spring 首先尝试按类型进行自动装配。它会查找容器中与属性或参数类型匹配的 Bean。如果只有一个匹配的 Bean，Spring 会将其注入。

• 按名称：如果容器中有多个相同类型的 Bean，Spring 可以根据名称进行自动装配。你可以使用 @Qualifier 注解指定 Bean 的名称

@Autowired 三种注入方式

        @Autowired 包含三种注入方式，分别是属性注入，构造函数注入和Setter 方法注入。

属性注入

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MyService {
    @Autowired
    private MyRepository myRepository;
}

• @Autowired 直接标注在属性上，Spring 容器会自动将 MyRepository 类型的 Bean 注入到 myRepository 属性中。

• 这种方式比较简洁，但它将依赖关系隐藏在类的内部，对于测试可能不太方便，因为无法在不使用 Spring 容器的情况下轻松替换依赖。

构造函数注入

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MyService {
    private final MyRepository myRepository;

    @Autowired
    public MyService(MyRepository myRepository) {
        this.myRepository = myRepository;
    }
}

• @Autowired 注解放在构造函数上，Spring 容器会在创建 MyService 实例时，自动将 MyRepository 类型的 Bean 注入到构造函数中。

• 这种方式的优点是可以将依赖声明为 final，提高代码的健壮性和可测试性。

Setter 方法注入

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MyService {
    private MyRepository myRepository;

    @Autowired
    public void setMyRepository(MyRepository myRepository) {
        this.myRepository = myRepository;
    }
}

• @Autowired 标注在 setMyRepository 方法上，Spring 容器会调用该方法，并将 MyRepository 类型的 Bean 作为参数传入，完成注入。

• 这种方式在某些场景下比较灵活，尤其是当你需要在 setter 方法中添加额外的逻辑时。

Java Bean 属性绑定

        Java Bean 属性绑定是将外部配置源（如 application.properties 或 application.yml 文件）中的属性值映射到 Java Bean 的属性上的过程。这使得配置信息可以以对象的形式在 Spring 容器中管理和使用，方便代码中的访问和操作。

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "app")
public class AppConfig {
    private String name;
    private String version;
    private String description;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getVersion() {
        return version;
    }

    public void setVersion(String version) {
        this.version = version;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

• 这里，prefix = "app" 表示将以 app. 开头的属性绑定到 AppConfig 类的相应属性上。

构造函数绑定

        从 Spring Boot 2.2 开始，支持使用构造函数绑定，这提供了一种更具类型安全性的配置绑定方式。例如：

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.ConstructorBinding;
import org.springframework.stereotype.Component;

@Component
@ConstructorBinding
@ConfigurationProperties(prefix = "myconfig")
public class MyConfigBean {
    private final String name;
    private final int age;

    public MyConfigBean(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

• 这种方式使用构造函数注入，使得属性一旦初始化就不能修改，增强了代码的安全性和可维护性。

JSON应用程序属性

        由于环境变量和系统属性在命名上存在限制，某些属性名无法使用。为解决这一问题，Spring Boot 支持将一组属性编码为单个 JSON 结构。在应用程序启动时，Spring Boot 会自动解析spring.application.json 或 SPRING_APPLICATION_JSON 属性，并将其添加到应用的Environment中。

• 设置 JSON 属性的方式：

  • 作为环境变量在命令行设置：在 UN*X shell 中，可通过设置 SPRING_APPLICATION_JSON环境变量来提供 JSON 数据。例如：

    • $SPRING_APPLICATION_JSON='{"my":{"name":"test"}}' java -jar myapp.jar

    • 最终在 Spring 环境中会得到my.name=test的属性。

  • 作为系统属性设置：可通过-D参数将spring.application.json作为系统属性来设置 JSON 数据。例如：

    • $ java -Dspring.application.json='{"my":{"name":"test"}}' -jar myapp.jar

  • 作为命令行参数设置：可在运行java -jar命令时，通过--spring.application.json参数来设置 JSON 数据。例如：

    • $ java -jar myapp.jar --spring.application.json='{"my":{"name":"test"}}'

  • 在经典应用服务器中通过 JNDI 变量设置：如果将应用部署到经典应用服务器，可以使用名为java:comp/env/spring.application.json的 JNDI 变量来提供 JSON 数据。

命令行参数

         默认情况下，SpringApplication将任何命令行选项参数（即以--开头的参数，例如--server.port=9000）转换为property并将它们添加到 Spring Environment。如前所述，命令行属性始终优先于基于文件的属性源。

        如果您不想将命令行属性添加到Environment，则可以禁用它们。

SpringApplication.setAddCommandLineProperties(false)

配置加载拓展

 @ConstructorBinding

• @ConstructorBinding 是 Spring Framework 中的一个注解，它用于指示 Spring 在创建 bean 实例时使用带注解的构造函数进行依赖注入。

• @ConstructorBinding 通常与 @ConfigurationProperties 注解结合使用，用于定义外部配置属性如何映射到配置类的字段上。

• 注意事项

  • 这个注解在 Spring Boot 2.2 版本开始引入。

  • 当使用 @ConstructorBinding 时，构造函数中的所有参数都必须在配置文件中有对应的值，否则 Spring 将无法创建 bean 实例。

  • @ConstructorBinding 不支持字段注入，所有依赖都必须通过构造函数注入

@DefaultValue

        在加载属性值的过程中，构造函数参数可以使用@DefaultValue给属性指定默认值

	public MyProperties(boolean enabled, InetAddress remoteAddress, @DefaultValue Security security) {
		this.enabled = enabled;
		this.remoteAddress = remoteAddress;
		this.security = security;
	}

YAML 映射到属性的扁平化处理

        YAML 映射扁平化处理是将嵌套的 YAML 结构转换为平面结构的过程，即将多层次的键值对转换为单一层次的键值对。这在某些情况下很有用，特别是当你需要将 YAML 配置文件中的信息转换为环境变量或其他简单的键值存储时。

• 以下是一个YAML 文件示例：

environments:
  dev:
    url: "https://dev.example.com"
    name: "Developer Setup"
  prod:
    url: "https://another.example.com"
    name: "My Cool App"

• 为了从Environment访问这些属性，在经过扁平化处理后，等同于：

environments.dev.url=https://dev.example.com
environments.dev.name=Developer Setup
environments.prod.url=https://another.example.com
environments.prod.name=My Cool App

接收YAML 的List 类型属性

• list 类型的 yml 配置如下所示：

myapp:
  nestedConfig:
    list:
      - subItem1
      - subItem2

• 在经过扁平化处理后，等同于：

myapp.nestedConfig.list[0]=subItem1
myapp.nestedConfig.list[1]=subItem2

• 使用该[index]符号的属性可以绑定到 Java List 或 Set使用 Spring Boot BInder类的对象。

接收YAML 的Map 类型属性

• map 类型的yml 配置如下所示：

• 绑定到Map属性时，您可能需要使用特殊的括号表示法，以便key保留原始值。如果键没有被 []包围，则任何非字母数字的字符-或.都会被删除。

• 对于 YAML 文件，括号需要用引号括起来，以便正确解析键。

myapp:
  nestedConfig:
    map:
      "[/subKey1]": "subValue1"
      "[/subKey2]": "subValue1"

• 在经过扁平化处理后，等同于：

myapp.nestedConfig.map[/subkey1]=subValue1
myapp.nestedConfig.map[/subkey2]=subValue2

• 最后给出关于接收List 和Map 映射的Java 配置类的代码示例：

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;

@Component
@ConfigurationProperties(prefix = "myapp.nestedConfig")
public class NestedConfig {
    private Map<String, String> map;
    private List<String> list;

    public Map<String, String> getMap() {
        return map;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public List<String> getList() {
        return list;
    }

    public void setList(List<String> list) {
        this.list = list;
    }
}

配置引入方式

spring.config.name 

        如果您不喜欢application配置文件名，可以通过指定spring.config.name环境属性切换到其他文件名。例如，要查找myproject.properties和myproject.yaml文件，您可以按如下方式运行应用程序：

$ java -jar myproject.jar --spring.config.name=myproject

Spring.config-location

         您还可以使用环境属性spring.config.location来引用明确的位置。此属性接受要检查的一个或多个位置的逗号分隔列表。

• Spring.config-location用于指定 Spring Boot 应用程序的配置文件的位置。

• 它会覆盖 Spring Boot 的默认配置文件搜索路径。当你使用 spring.config.location 时，Spring Boot 将只从你指定的位置查找配置文件，而不会再去查找默认的位置（如 classpath:/, classpath:/config/, file:./, file:./config/）。

• 可以指定多个位置，用逗号分隔，且会按顺序加载，后面的配置会覆盖前面的配置。

• 命令行参数配置

java -jar myapp.jar --spring.config.location=classpath:/custom-config/,file:/etc/myapp/

• 代码配置方式

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyAppApplication implements CommandLineRunner {

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(MyAppApplication.class);
        app.setDefaultProperties(Collections.singletonMap("spring.config.location", "classpath:/custom-config/,file:/etc/myapp/"));
        app.run(args);
    }

    @Override
    public void run(String... args) throws Exception {
        // 应用程序逻辑
    }
}

Spring.config.additional-location

• 功能：

  • 用于添加额外的配置文件位置，而不是替代默认的配置文件搜索路径。

  • Spring Boot 会先在默认位置查找配置文件，然后再到你指定的额外位置查找。这样可以在不影响 Spring Boot 原有的配置文件搜索逻辑的前提下，添加新的配置文件来源。

  • 同样可以指定多个位置，用逗号分隔，且会按顺序加载，后面的配置会覆盖前面的配置。

• 命令行参数配置

java -jar myapp.jar --spring.config.additional-location=classpath:/extra-config/,file:/etc/myapp/extra/

• 代码配置

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import java.util.Collections;

@SpringBootApplication
public class MyAppApplication implements CommandLineRunner {

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(MyAppApplication.class);
        app.setDefaultProperties(Collections.singletonMap("spring.config.additional-location", "classpath:/extra-config/,file:/etc/myapp/extra/"));
        app.run(args);
    }

    @Override
    public void run(String... args) throws Exception {
        // 应用程序逻辑
    }
}

Spring.config.import

  spring.config.import 为 Spring Boot 应用程序提供了一种灵活且强大的配置导入机制，支持从多种来源导入配置，包括本地文件、类路径和配置服务器。它允许同时导入多个配置，且支持配置的覆盖和动态更新，为配置管理带来了更多的便利性和可扩展性，特别是在使用 Spring Cloud Config 进行集中式配置管理时，它是实现动态配置管理的重要手段之一。你可以根据应用程序的实际情况和需求，灵活运用该属性，更好地管理和更新配置信息。

        使用 spring.config.import 时，需要注意配置的顺序和来源，确保配置的正确性和一致性，同时要根据不同的部署环境和需求合理选择配置的导入来源，以实现最佳的配置管理效果。

与 Spring Cloud Config 的结合使用

• 当使用 Spring Cloud Config 时，spring.config.import 可以方便地与配置服务器进行集成：

  • 你可以将配置服务器的地址添加到 spring.config.import 中，Spring Boot 会从配置服务器中拉取配置信息，并且会根据应用程序的 spring.application.name 和 spring.profiles.active 等属性来拉取特定的配置。

• 配置示例：

spring.application.name=myapp
spring.profiles.active=dev
spring.config.import=configserver:http://configserver.example.com:8888

• 上述配置将使 Spring Boot 从 http://configserver.example.com:8888 拉取 myapp-dev.properties 或 myapp-dev.yml 等相应的配置文件。

配置文件相关语法

可选的配置

• 如果您想指定一个位置，但不介意它并不总是存在，则可以使用optional:前缀。您可以将此前缀与spring.config.location和spring.config.additional-location属性以及spring.config.import声明一起使用。

• 默认情况下，当指定的配置数据位置不存在时，Spring Boot 将抛出一个错误ConfigDataLocationNotFoundException，并且您的应用程序将无法启动。

• 配置示例：

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

通配符

• 如果配置文件位置包含*最后一个路径段的字符，则该位置被视为位置通配符。加载配置时会展开通配符，以便还会检查直接子目录。当存在多个配置属性源时，位置通配符在 Kubernetes 等环境中特别有用。

• 例如，如果您有一些 Redis 配置和一些 MySQL 配置，您可能希望将这两部分配置分开，同时要求它们都存在于一个application.properties文件中。这可能会导致两个单独的application.properties文件安装在不同的位置，例如/config/redis/application.properties和/config/mysql/application.properties。在这种情况下，使用位置通配符config/*/，将导致两个文件都被处理。

• 默认情况下，Spring Boot 包含config/*/默认搜索位置。这意味着/config将搜索 jar 之外的目录的所有子目录。

• 您可以自己将通配符位置与spring.config.location和spring.config.additional-location属性结合使用。

• 通配符位置仅适用于外部目录。您不能在classpath:位置中使用通配符。

属性占位符

• application.properties和application.yaml中的值在使用时会通过现有值进行过滤，因此您可以引用之前定义的值（例如，来自系统属性或环境变量）。标准属性占位符语法${name}可以在值中的任何位置使用。

• 属性占位符还可以使用：来指定默认值，以：将默认值与属性名称分开，例如。${name:default}。以下示例展示了带有和不带有默认值的占位符的使用：

• 您应该始终使用其规范形式（仅使用小写字母的 kebab-case）引用占位符中的属性名称。

多文档分割处理

• 对于application.properties文件，可以使用特殊 #---或 !--- 注释来标记文档分割：

spring.application.name=MyApp
#---
spring.application.name=MyCloudApp
spring.config.activate.on-cloud-platform=kubernetes

配置系统环境属性

• 在使用 Spring Boot 时，你可能会遇到多个 Spring Boot 应用程序共享同一系统环境的情况，而这些应用程序可能有不同的配置需求。为了避免不同应用程序的配置属性之间发生混淆或冲突，Spring Boot 支持为系统环境属性设置前缀。

• 系统环境属性通常是通过操作系统的环境变量来设置的，例如在 Linux 系统中使用 export 命令，在 Windows 系统中使用 set 命令。

• 可以直接在 SpringApplication 上设置系统环境属性的前缀。这样做的好处是可以将环境属性进行隔离，确保不同应用程序使用不同的前缀，防止命名冲突。

• 例如，如果你设置了前缀为 input，那么一个原本名为 remote.timeout 的属性在系统环境中会被解析为 input.remote.timeout。这意味着 Spring Boot 应用程序在查找 remote.timeout 这个配置属性时，会首先查找带有前缀的 input.remote.timeout 环境变量。

使用示例

• 我们先设置一个环境变量（windows系统）

set input.remote.timeout=5000

• 而后，我们在Spring Boot 启动类设置系统环境属性的前缀

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;

@SpringBootApplication
public class MySpringBootApp {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplicationBuilder(MySpringBootApp.class)
              .properties("spring.config.name:myapp", "spring.config.location:/config/")
              .build();
        // 设置系统环境属性的前缀
        app.setEnvironmentPrefix("input");
        app.run(args);
    }
}

• 通过调用 setEnvironmentPrefix 方法将环境属性的前缀设置为 input。这样，当 Spring Boot 应用程序查找环境属性时，会自动添加这个前缀。例如，如果你在系统环境中设置了一个环境变量 input.remote.timeout=5000，Spring Boot 应用程序会将其作为 remote.timeout 属性的值。

• 使用环境属性示例：

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "remote")
public class RemoteConfig {
    private int timeout;

    public int getTimeout() {
        return timeout;
    }

    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }
}

• 这样RemoteConfig 中的timeout 属性最终将会从环境变量input.remote.timeout 中取值。

配置文件的使用

配置激活

        有时spring.config.activate.* 仅在满足特定条件时激活一组给定的属性会很有用。例如，您可能拥有仅在特定配置文件处于活动状态时才相关的属性。您可以有条件地使用激活属性。

•         激活属性说明：

        例如，以下内容指定第二个文档仅在 Kubernetes 上运行时才处于活动状态，并且仅当“prod”或“staging”配置文件处于活动状态时：

myprop=always-set
#---
spring.config.activate.on-cloud-platform=kubernetes
spring.config.activate.on-profile=prod | staging
myotherprop=sometimes-set

导入无拓展名的文件

配置随机值

        RandomValuePropertySource 对于注入随机值（例如，注入机密或测试用例）很有用。它可以生成整数、长整型、uuid 或字符串，如以下示例所示：

my:
  secret: "${random.value}"
  number: "${random.int}"
  bignumber: "${random.long}"
  uuid: "${random.uuid}"
  number-less-than-ten: "${random.int(10)}"
  number-in-range: "${random.int[1024,65536]}"

Spring Boot 自动配置

• 开启自动配置：Spring Boot 开启自动配置的条件是使用@SpringBootApplication 或 @EnableAutoConfiguration。其中@SpringBootApplication 包含 @EnableAutoConfiguration。

• 禁用特定的自动配置：如果您发现应用中存在不想要的特定自动配置类，则可以使用@SpringBootApplication 中的排除属性来禁用它们，如下例所示：

  @SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })
  public class MyApplication {
  
  }

  • 如果类不在类路径上，则可以使用excludeName注释的属性并指定完全限定名称。
  • @EnableAutoConfiguration 同样包含exclude 和 excludeName 属性
  • 您还可以使用配置文件属性 spring.autoconfigure.exclude 来控制要排除的自动配置列表。

查询自动配置详细说明

        我们可以在启动Jar 包时，加入 -Ddebug 来查看Spring Boot 自动配置的内容。在IDEA 中，我们可以直接选择启动配置项 Enable debug output来开启Spring Debug日志，从而查看自动配置的详细说明。

​

​

@Enable*注解

        在Spring Boot中，以@Enable*开头的注解通常用于开启特定的功能或配置。这些注解可以用来激活Spring框架中的某些特性，或者集成第三方库。以下是一些常见的@Enable开头的注解：

• @EnableConfigurationProperties 是 Spring Boot 提供的一个注解，用于激活配置属性的支持。这个注解可以让你将外部配置（例如来自 application.properties 或 application.yml 文件的配置）绑定到一个或多个 Java 类中，这些类通常被称为配置属性类。

• @EnableAutoConfiguration：启用Spring Boot的自动配置机制，尝试根据类路径中的依赖自动配置Spring应用。

• @EnableTransactionManagement：启用基于注解的事务管理功能。

• @EnableScheduling：启用计划任务的支持，允许使用@Scheduled来标记计划执行的方法。

• @EnableCaching：启用缓存支持，允许使用如@Cacheable等注解来进行方法级别的缓存。

• @EnableAspectJAutoProxy：启用对AspectJ代理的支持，这通常意味着会为AOP（面向切面编程）提供支持。

• @EnableAsync：启用异步方法执行，允许使用@Async来标记那些应该异步执行的方法。

• @EnableJpaRepositories：与Spring Data JPA一起使用，用于指定仓库接口的位置，并启用JPA存储库支持。

• @EnableWebMvc：当需要完全控制Spring MVC的配置时使用，它禁用Spring Boot的默认MVC配置。

• @EnableDiscoveryClient：此注解用于激活Spring Cloud的发现客户端功能。它使得应用程序能够注册到服务注册中心（如Eureka, Consul, or Zookeeper），并且也能够从服务注册中心获取其他服务的位置信息。这有助于实现服务之间的动态查找和通信。使用该注解后，应用将自动配置为服务注册与发现的客户端，并且可以利用DiscoveryClient接口来查询服务实例。

• @EnableFeignClients：此注解用于开启Feign声明式HTTP客户端的支持。

参考文献

Externalized Configuration :: Spring Boot

Configuration Classes :: Spring Boot

Auto-configuration :: Spring Boot