功能

本节将深入介绍Spring Boot。在这里，您可以了解可能要使用和自定义的关键功能。如果您尚未这样做，则可能需要阅读“ Getting -started.html ”和“ using-spring-boot.html ”部分，以便您有足够的基础知识。

1. SpringApplication

本SpringApplication类提供了一个方便的方式来引导该从开始Spring应用程序main()的方法。在许多情况下，您可以委托给静态SpringApplication.run方法，如以下示例所示：

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

当您的应用程序启动时，您应该看到类似于以下输出的内容：
。_
/ \ / __‘ __ （） \ \ \ \
（（）\ __ |’ |’ | |’ \ / ` | \ \ \ \ \
\ / ）| | ）| | | | | || （ | |））））
‘| _ | . | | | | | | \ ，| / / / /
======== | | ============= | __ / = / / / _ /
:: Spring Boot :: v2.4.3

2019-04-31 13：09：54.117 INFO 56603 —- [main] osbsapp.SampleApplication：在我的计算机上使用PID 56603（/apps/myapp.jar由pwebb启动）启动SampleApplication v0.1.0
2019-04-31 13：09：54.166 INFO 56603 —- [main] ationConfigServletWebServerApplicationContext：刷新org.springframework.boot.web.ser vlet.context.AnnotationConfigServletWebServerApplicationContext @ 6e5a8246：启动日期[WDT Jul 31 00:08:16 PDT 2013]；上下文层次结构的根
2019-04-01 13：09：56.912信息41370 —- [main] .t.TomcatServletWebServerFactory：服务器初始化为端口：8080
2019-04-01 13：09：57.501信息41370 —- [main] osbsapp.SampleApplication：在2.992秒内启动SampleApplication（JVM运行3.658）
默认情况下，显示INFO日志消息，包括一些相关的启动详细信息，例如启动应用程序的用户。如果您需要除以外的其他日志级别INFO，则可以按日志级别中所述进行设置。使用主应用程序类包中的实现版本来确定应用程序版本。设置spring.main.log-startup-info为可以关闭启动信息记录false。这还将关闭应用程序活动配置文件的日志记录。

1.1 启动失败

如果您的应用程序无法启动，则注册FailureAnalyzers后将有机会提供专门的错误消息和解决该问题的具体措施。例如，如果在port上启动Web应用程序8080并且该端口已在使用中，则应该看到类似于以下消息的内容：
**
申请启动失败
**

描述：

嵌入式Servlet容器无法启动。端口8080已被使用。

行动：

确定并停止正在端口8080上侦听的进程，或将此应用程序配置为在另一个端口上侦听。

如果没有故障分析器能够处理该异常，您仍然可以显示完整情况报告，以更好地了解出了什么问题。要做到这一点，你需要使debug财产或启用DEBUG日志记录的org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener。
例如，如果使用来运行应用程序java -jar，则可以debug按如下所示启用属性：
$ java -jar myproject-0.0.1-SNAPSHOT.jar —debug

1.2 延迟初始化

SpringApplication允许延迟地初始化应用程序。启用惰性初始化后，将根据需要创建bean，而不是在应用程序启动期间创建bean。因此，启用延迟初始化可以减少应用程序启动所花费的时间。在Web应用程序中，启用延迟初始化将导致许多与Web相关的Bean直到收到HTTP请求后才被初始化。
延迟初始化的缺点是，它可能会延迟发现应用程序问题的时间。如果延迟配置了错误配置的Bean，则在启动过程中将不再发生故障，并且只有在初始化Bean时问题才会变得明显。还必须注意确保JVM具有足够的内存来容纳所有应用程序的bean，而不仅仅是启动期间初始化的bean。由于这些原因，默认情况下默认不启用延迟初始化，因此建议在启用延迟初始化之前先对JVM的堆大小进行微调。
可以使用lazyInitializationon方法SpringApplicationBuilder或setLazyInitializationon方法以编程方式启用延迟初始化SpringApplication。另外，可以使用spring.main.lazy-initialization以下示例中所示的属性来启用它：
特性
Yaml

spring:
  main:
    lazy-initialization: true

1.3 自定义横幅

可以通过将banner.txt文件添加到类路径或将spring.banner.location属性设置为此类文件的位置来更改启动时打印的横幅。如果文件的编码不是UTF-8，则可以设置spring.banner.charset。除了一个文本文件，你还可以添加一个banner.gif，banner.jpg或banner.png图像文件到类路径或设置spring.banner.image.location属性。图像将转换为ASCII艺术作品并打印在任何文字横幅上方。
在banner.txt文件内部，可以使用以下任意占位符：
表1.标语变量

您还可以使用该spring.main.banner-mode属性来确定横幅是否必须在System.out（console）上打印，发送到配置的记录器（log）或根本不制作（off）。
打印的横幅注册为下面的这名一个singleton bean： springBootBanner。

1.4 自定义SpringApplication

如果SpringApplication默认设置不符合您的喜好，则可以创建一个本地实例并对其进行自定义。例如，要关闭横幅，您可以编写：

public static void main(String[] args) {
    SpringApplication app = new SpringApplication(MySpringConfiguration.class);
    app.setBannerMode(Banner.Mode.OFF);
    app.run(args);
}

也可以SpringApplication通过使用application.properties文件来配置。有关详细信息，请参见外部化配置。
有关配置选项的完整列表，请参见SpringApplicationJavadoc。

1.5 Fluent Builder API

如果您需要构建ApplicationContext层次结构（具有父/子关系的多个上下文），或者您更喜欢使用“流利的”构建器API，则可以使用SpringApplicationBuilder。
在SpringApplicationBuilder让要链接的多个方法调用，并且包括parent和child其让你创建层次结构，以显示在下面的示例性方法：

new SpringApplicationBuilder()
        .sources(Parent.class)
        .child(Application.class)
        .bannerMode(Banner.Mode.OFF)
        .run(args);

1.6 应用程序可用性

在平台上部署后，应用程序可以使用诸如Kubernetes Probes之类的基础结构向平台提供有关其可用性的信息。Spring Boot对常用的“活动性”和“就绪性”可用性状态提供了开箱即用的支持。如果您使用的是Spring Boot的“执行器”支持，那么这些状态将作为运行状况端点组公开。
另外，您还可以通过将ApplicationAvailability接口注入您自己的bean中来获取可用性状态。

1.6.1 生命状态

应用程序的“活动”状态表明其内部状态是否允许其正常运行，或者在当前出现故障时自行恢复。损坏的“活动”状态意味着应用程序处于无法恢复的状态，并且基础结构应重新启动应用程序。

Spring Boot应用程序的内部状态主要由Spring表示ApplicationContext。如果应用程序上下文已成功启动，则Spring Boot会假定该应用程序处于有效状态。刷新上下文后，应用程序即被视为处于活动状态，请参阅Spring Boot应用程序生命周期和相关的Application Events。

1.6.2 准备状态

应用程序的“就绪”状态告诉应用程序是否已准备好处理流量。失败的“就绪”状态告诉平台当前不应将流量路由到应用程序。这通常发生在启动过程中，正在处理CommandLineRunner和ApplicationRunner处理组件时，或者在任何时候，如果应用程序认为它太忙而无法获得额外的流量，就会发生这种情况。
一旦调用了应用程序和命令行运行程序，就认为该应用程序已准备就绪，请参阅Spring Boot应用程序生命周期和相关的Application Events。

1.6.3 管理应用程序可用性状态

通过注入ApplicationAvailability接口并在接口上调用方法，应用程序组件可以随时检索当前的可用性状态。应用程序通常会希望监听状态更新或更新应用程序的状态。
例如，我们可以将应用程序的“就绪”状态导出到一个文件，以便Kubernetes的“ exec Probe”可以查看此文件：

@Component
public class ReadinessStateExporter {
    @EventListener
    public void onStateChange(AvailabilityChangeEvent<ReadinessState> event) {
        switch (event.getState()) {
        case ACCEPTING_TRAFFIC:
            // create file /tmp/healthy
        break;
        case REFUSING_TRAFFIC:
            // remove file /tmp/healthy
        break;
        }
    }
}

当应用程序崩溃且无法恢复时，我们还可以更新应用程序的状态：

@Component
public class LocalCacheVerifier {
    private final ApplicationEventPublisher eventPublisher;
    public LocalCacheVerifier(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }
    public void checkLocalCache() {
        try {
            //...
        }
        catch (CacheCompletelyBrokenException ex) {
            AvailabilityChangeEvent.publish(this.eventPublisher, ex, LivenessState.BROKEN);
        }
    }
}

Spring Boot通过Actuator Health Endpoints为“活动性”和“就绪性”提供Kubernetes HTTP探针。您可以在专用部分中获得有关在Kubernetes上部署Spring Boot应用程序的更多指南。

1.7 应用程序事件和监听器

除了通常的Spring Framework事件（例如）外ContextRefreshedEvent，SpringApplication还会发送一些其他应用程序事件。

应用程序事件在您的应用程序运行时按以下顺序发送：

1. ApplicationStartingEvent在运行开始时发送an ，但在进行任何处理之前（侦听器和初始化程序的注册除外）发送。
   
2. 一个ApplicationEnvironmentPreparedEvent当被发送Environment到中已知的上下文中使用，但是在创建上下文之前。
   
3. ApplicationContextInitializedEvent在ApplicationContext准备好且已调用ApplicationContextInitializers之后但未加载任何bean定义之前，发送an 。
   
4. ApplicationPreparedEvent在刷新开始之前但在加载bean定义之后发送an 。
   
5. 一个ApplicationStartedEvent上下文已被刷新后发送，但是任何应用程序和命令行亚军都被调用前。
   
6. 紧随AvailabilityChangeEvent其后发送的LivenessState.CORRECT，表示该应用程序被视为已生效。
   
7. 在ApplicationReadyEvent任何之后被送到应用程序和命令行亚军已被调用。
   
8. 紧随AvailabilityChangeEvent其后发送一个，ReadinessState.ACCEPTING_TRAFFIC以指示该应用程序已准备好处理请求。
   
9. 一个ApplicationFailedEvent如果在启动时异常发送。
   

上面的列表仅包含SpringApplicationEvent与绑定的SpringApplication。除这些以外，以下事件也在之后ApplicationPreparedEvent和之前发布ApplicationStartedEvent：

• 准备就绪 WebServerInitializedEvent后发送A。和分别是servlet和反应式变量。WebServer``ServletWebServerInitializedEvent``ReactiveWebServerInitializedEvent
  
• 刷新ContextRefreshedEvent时发送A。ApplicationContext
  | | 您通常不需要使用应用程序事件，但是很容易知道它们的存在。在内部，Spring Boot使用事件来处理各种任务。 | | :—-: | —- |

应用程序事件是通过使用Spring Framework的事件发布机制发送的。此机制的一部分确保在子级上下文中发布给侦听器的事件也在任何祖先上下文中也发布给侦听器。结果，如果您的应用程序使用SpringApplication实例的层次结构，则侦听器可能会收到同一类型的应用程序事件的多个实例。
为了使您的侦听器能够区分其上下文的事件和后代上下文的事件，它应请求注入其应用程序上下文，然后将注入的上下文与事件的上下文进行比较。可以通过实现来注入上下文，ApplicationContextAware或者，如果侦听器是bean，则可以使用注入上下文@Autowired。

1.8 网络环境

一个SpringApplication试图创建正确类型的ApplicationContext代表您。用于确定a的算法WebApplicationType如下：

• 如果存在Spring MVC，AnnotationConfigServletWebServerApplicationContext则使用
  
• 如果不存在Spring MVC且存在Spring WebFlux，AnnotationConfigReactiveWebServerApplicationContext则使用
  
• 否则，AnnotationConfigApplicationContext使用
  

这意味着，如果您WebClient在同一应用程序中使用Spring MVC和Spring WebFlux中的新功能，则默认情况下将使用Spring MVC。您可以通过调用轻松覆盖它setWebApplicationType(WebApplicationType)。
也可以完全控制ApplicationContext调用所使用的类型setApplicationContextClass(…)。

1.9 访问应用程序参数

如果您需要访问传递给的应用程序参数，则SpringApplication.run(…)可以注入org.springframework.boot.ApplicationArgumentsBean。该ApplicationArguments接口提供对原始String[]参数以及已解析option和non-option参数的访问，如以下示例所示：

import org.springframework.boot.*;
import org.springframework.beans.factory.annotation.*;
import org.springframework.stereotype.*;
@Component
public class MyBean {
    @Autowired
    public MyBean(ApplicationArguments args) {
        boolean debug = args.containsOption("debug");
        List<String> files = args.getNonOptionArgs();
        // if run with "--debug logfile.txt" debug=true, files=["logfile.txt"]
    }
}

1.10 使用ApplicationRunner或CommandLineRunner

如果启动后需要运行一些特定的代码SpringApplication，则可以实现ApplicationRunner或CommandLineRunner接口。这两个接口以相同的方式工作，并提供一个单一的run方法，该方法在SpringApplication.run(…)完成之前就被调用。

所述CommandLineRunner接口提供访问的应用程序的参数作为一个字符串数组，而ApplicationRunner用途ApplicationArguments接口前面讨论。以下示例显示了一个CommandLineRunnerwithrun方法：

import org.springframework.boot.*;
import org.springframework.stereotype.*;
@Component
public class MyBean implements CommandLineRunner {
    public void run(String... args) {
        // Do something...
    }
}

如果定义了多个CommandLineRunner或ApplicationRunner必须按特定顺序调用的bean，则可以额外实现org.springframework.core.Ordered接口或使用org.springframework.core.annotation.Order批注。

1.11 申请退出

每个都SpringApplication向JVM注册一个关闭钩子，以确保ApplicationContext退出时正常关闭。可以使用所有标准的Spring生命周期回调（例如DisposableBean接口或@PreDestroy批注）。
另外，org.springframework.boot.ExitCodeGenerator如果bean希望在SpringApplication.exit()调用时返回特定的退出代码，则可以实现该接口。然后可以将此退出代码传递System.exit()为状态代码，以将其返回，如以下示例所示：

@SpringBootApplication
public class ExitCodeApplication {
    @Bean
    public ExitCodeGenerator exitCodeGenerator() {
        return () -> 42;
    }
    public static void main(String[] args) {
        System.exit(SpringApplication.exit(SpringApplication.run(ExitCodeApplication.class, args)));
    }
}

而且，该ExitCodeGenerator接口可以通过异常来实现。当遇到这样的异常时，Spring Boot返回由实现的getExitCode()方法提供的退出代码。

1.12 管理员功能

通过指定spring.application.admin.enabled属性，可以为应用程序启用与管理员相关的功能。这将SpringApplicationAdminMXBean在平台上公开MBeanServer。您可以使用此功能来远程管理Spring Boot应用程序。此功能对于任何服务包装器实现也可能有用。

1.13 应用程序启动跟踪

在应用程序启动期间，SpringApplication和ApplicationContext执行许多与应用程序生命周期，bean生命周期甚至处理应用程序事件有关的任务。使用ApplicationStartupSpring Framework ，您可以使用StartupSteps跟踪应用程序的启动顺序。可以收集这些数据以进行概要分析，或者只是为了更好地了解应用程序启动过程。
您可以ApplicationStartup在设置SpringApplication实例时选择一种实现。例如，要使用BufferingApplicationStartup，您可以编写：

public static void main(String[] args) {
    SpringApplication app = new SpringApplication(MySpringConfiguration.class);
    app.setApplicationStartup(new BufferingApplicationStartup(2048));
    app.run(args);
}

FlightRecorderApplicationStartupSpring Framework提供了第一个可用的实现。它将特定于Spring的启动事件添加到Java Flight Recorder会话中，旨在对应用程序进行性能分析并将其Spring上下文生命周期与JVM事件相关联（例如分配，GC，类加载…）。配置完成后，您可以在启用了Flight Recorder的情况下通过运行应用程序来记录数据：

$ java -XX:StartFlightRecording:filename=recording.jfr,duration=10s -jar demo.jar

Spring Boot随BufferingApplicationStartup变种一起提供；此实现旨在缓冲启动步骤，并将其排入外部度量标准系统。应用程序可以BufferingApplicationStartup在任何组件中要求类型的Bean 。此外，Spring Boot Actuator将公开一个startup端点以将此信息公开为JSON文档。

2.外部化配置

Spring Boot使您可以外部化配置，以便可以在不同环境中使用相同的应用程序代码。您可以使用各种外部配置源，包括Java属性文件，YAML文件，环境变量和命令行参数。
属性值可以通过直接注射到你的bean@Value注释，通过Spring的访问Environment抽象，或者被绑定到结构化对象通过@ConfigurationProperties。
Spring Boot使用一个非常特殊的PropertySource顺序，该顺序旨在允许合理地覆盖值。按以下顺序考虑属性（较低项的值覆盖较早项的值）：

1. 默认属性（通过设置指定SpringApplication.setDefaultProperties）。
   
2. @PropertySource@Configuration类上的注释。请注意，Environment在刷新应用程序上下文之前，不会将此类属性源添加到中。现在配置某些属性（如logging.*和spring.main.*在刷新开始之前先读取）为时已晚。
   
3. 配置数据（例如application.properties文件）
   
4. 一RandomValuePropertySource，只有在拥有性能random.*。
   
5. 操作系统环境变量。
   
6. Java系统属性（System.getProperties()）。
   
7. 的JNDI属性java:comp/env。
   
8. ServletContext 初始化参数。
   
9. ServletConfig 初始化参数。
   
10. 来自的属性SPRING_APPLICATION_JSON（嵌入在环境变量或系统属性中的嵌入式JSON）。
    
11. 命令行参数。
    
12. properties测试中的属性。可用于测试应用程序的特定部分@SpringBootTest的测试注释和注释。
    
13. @TestPropertySource 测试中的注释。
    
14. $HOME/.config/spring-boot当devtools处于活动状态时，目录中的Devtools全局设置属性。
    

配置数据文件按以下顺序考虑：

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

为了提供一个具体的示例，假设您开发了一个@Component使用name属性的，如以下示例所示：

import org.springframework.stereotype.*;
import org.springframework.beans.factory.annotation.*;
@Component
public class MyBean {
    @Value("${name}")
    private String name;
    // ...
}

在您的应用程序类路径上（例如，在jar内），您可以使用一个application.properties文件，该文件为提供合理的默认属性值name。在新环境中运行时，application.properties可以在jar外部提供一个文件，该文件将覆盖name。对于一次性测试，您可以使用特定的命令行开关（例如，java -jar app.jar --name="Spring"）启动。

2.1 访问命令行属性

默认情况下，SpringApplication将任何命令行选项参数（即以开头的参数--，例如--server.port=9000）转换为aproperty并将其添加到Spring Environment。如前所述，命令行属性始终优先于基于文件的属性源。
如果不希望将命令行属性添加到中Environment，则可以使用禁用它们SpringApplication.setAddCommandLineProperties(false)。

2.2 JSON应用程序属性

环境变量和系统属性通常具有一些限制，这意味着无法使用某些属性名称。为了解决这个问题，Spring Boot允许您将属性块编码为单个JSON结构。
当您的应用程序启动时，任何spring.application.json或SPRING_APPLICATION_JSON属性都会被解析并添加到中Environment。
例如，SPRING_APPLICATION_JSON可以在命令行中将UN * X shell中的属性作为环境变量提供：
$ SPRING_APPLICATION_JSON =’{“ acme”：{“ name”：“ test”}}}’java -jar myapp.jar
在前面的示例中，您最终acme.name=test在Spring中Environment。
相同的JSON也可以作为系统属性提供：
$ java -Dspring.application.json =’{“ acme”：{“ name”：“ test”}}}’-jar myapp.jar
或者，您可以使用命令行参数来提供JSON：
$ java -jar myapp.jar —spring.application.json =’{“ acme”：{“ name”：“ test”}}}’
如果要部署到经典的Application Server，则还可以使用名为的JNDI变量java:comp/env/spring.application.json。

2.3 外部应用程序属性

春天开机就会自动查找和加载application.properties和application.yaml应用程序启动时的文件从以下位置：

1. 类路径根
   
2. 类路径/config包
   
3. 当前目录
   
4. /config当前目录中的子目录
   
5. 的的直接子目录/config的子目录
   

该列表按优先级排序（较低项的值覆盖较早项的值）。来自已加载文件的文档将添加PropertySources到Spring中Environment。
如果您不喜欢application配置文件名，则可以通过指定spring.config.name环境属性来切换到另一个文件名。您还可以通过使用spring.config.locationenvironment属性（目录位置或文件路径的逗号分隔列表）来引用显式位置。以下示例显示如何指定其他文件名：
$ java -jar myproject.jar —spring.config.name = myproject
下面的示例演示如何指定两个位置：
$ java -jar myproject.jar —spring.config.location =可选：classpath：/default.properties，可选：classpath：/override.properties

如果spring.config.location包含目录（而不是文件），则应以目录结尾/（在运行时，将在目录后附加从生成spring.config.name之前生成的名称）。指定的文件spring.config.location按原样使用。无论是直接指定还是包含在目录中，配置文件都必须在名称中包含文件扩展名。所支持外的开箱典型的扩展是.properties，.yaml和.yml。
如果指定了多个位置，则后面的位置可以覆盖前面的位置。
通过使用配置的位置spring.config.location替换默认位置。例如，如果spring.config.location配置为value optional:classpath:/custom-config/,optional:file:./custom-config/，则考虑的位置的完整集合为：

1. optional:classpath:custom-config/
   
2. optional:file:./custom-config/
   

如果您希望添加其他位置，而不是替换它们，则可以使用spring.config.additional-location。从其他位置加载的属性可以覆盖默认位置的属性。例如，如果spring.config.additional-location使用value进行配置，则所optional:classpath:/custom-config/,optional:file:./custom-config/考虑的位置的完整集合为：

1. optional:classpath:/
   
2. optional:classpath:/config/
   
3. optional:file:./
   
4. optional:file:./config/
   
5. optional:file:./config/*/
   
6. optional:classpath:custom-config/
   
7. optional:file:./custom-config/
   

通过此搜索顺序，您可以在一个配置文件中指定默认值，然后在另一个配置文件中有选择地覆盖这些值。您可以在以下默认位置之一为您的应用程序提供默认值application.properties（或您选择的任何其他基本名称spring.config.name）。然后，可以在运行时使用自定义位置之一中的其他文件覆盖这些默认值。

2.3.1 可选位置

默认情况下，当指定的配置数据位置不存在时，Spring Boot将抛出，ConfigDataLocationNotFoundException并且您的应用程序将不会启动。
如果要指定位置，但不介意它并不总是存在，则可以使用optional:前缀。您可以将此前缀与spring.config.location和spring.config.additional-location属性以及spring.config.import声明一起使用。
例如，spring.config.import值为optional:file:./myconfig.properties，即使myconfig.properties文件丢失，也允许您的应用程序启动。
如果要忽略所有内容ConfigDataLocationNotFoundExceptions并始终继续启动应用程序，则可以使用该spring.config.on-not-found属性。将值设置为ignore使用SpringApplication.setDefaultProperties(…)或与系统/环境变量一起使用。

2.3.2 通配符位置

如果配置文件位置包含*最后一个路径段的字符，则将其视为通配符位置。加载配置时，通配符会展开，以便也检查直接子目录。当存在多个配置属性源时，通配符位置在诸如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属性使用通配符位置。

2.3.3 配置文件专用文件

除了application属性文件，Spring Boot还将尝试使用命名约定来加载特定于配置文件的文件application-{profile}。例如，如果你的应用程序启动了一个名为轮廓prod，并使用YAML文件，然后双方application.yml并application-prod.yml会予以考虑。
特定于配置文件的属性从与standard相同的位置加载application.properties，特定于配置文件的文件始终会覆盖非特定文件。如果指定了多个配置文件，则采用后赢策略。例如，如果属性prod,live指定了配置文件spring.profiles.active，则中的值application-prod.properties可以被中的值覆盖application-live.properties。
在Environment具有一组默认的配置文件（默认[default]）如果没有活动的简档设置中使用。换句话说，如果未明确激活任何配置文件，则将application-default考虑来自的属性。

2.3.4 导入其他数据

应用程序属性可以使用该spring.config.import属性从其他位置导入其他配置数据。导入时将对其进行处理，并将其视为在声明该导入的文件正下方插入的其他文档。
例如，您的类路径application.properties文件中可能包含以下内容：
特性
Yaml

spring:
  application:
    name: "myapp"
  config:
    import: "optional:file:./dev.properties"

这将触发dev.properties当前目录中文件的导入（如果存在这样的文件）。来自导入的值dev.properties将优先于触发导入的文件。在上面的示例中，dev.properties可以重新定义spring.application.name为其他值。不论声明多少次，导入都只会导入一次。在properties / yaml文件中的单个文档中定义导入的顺序无关紧要。例如，以下两个示例产生相同的结果：
特性
Yaml

spring:
  config:
    import: my.properties
my:
  property: value

特性
Yaml

my:
  property: value
spring:
  config:
    import: my.properties

在以上两个示例中，my.properties文件中的值将优先于触发其导入的文件。
可以在一个spring.config.import键下指定多个位置。位置将按照定义的顺序进行处理，以后的导入将优先。

2.3.5 导入无扩展名文件

某些云平台无法将文件扩展名添加到已装入卷的文件中。要导入这些无扩展名的文件，您需要给Spring Boot一个提示，以便它知道如何加载它们。您可以通过在方括号中添加扩展提示来做到这一点。
例如，假设您有一个/etc/config/myconfig要导入为yaml的文件。您可以application.properties使用以下方法从中导入它：
特性
Yaml

spring:
  config:
    import: "file:/etc/config/myconfig[.yaml]"

2.3.6 使用配置树

在云平台上运行应用程序（例如Kubernetes）时，您通常需要读取平台提供的配置值。为此目的使用环境变量并不罕见，但是这样做可能会有弊端，特别是如果该值应该保密的话。
作为环境变量的替代方法，许多云平台现在允许您将配置映射到装入的数据卷中。例如，Kubernetes可以批量挂载ConfigMaps和Secrets。
可以使用两种常见的卷安装模式：

1. 单个文件包含完整的属性集（通常写为YAML）。
   
2. 多个文件被写入目录树，文件名成为“键”，内容成为“值”。
   

对于第一种情况，你可以直接导入使用YAML或属性文件中spring.config.import所描述的以上。对于第二种情况，您需要使用configtree:前缀，以便Spring Boot知道它需要将所有文件公开为属性。
作为示例，让我们想象一下Kubernetes已经安装了以下卷：

etc/
  config/
    myapp/
      username
      password

该username文件的内容将是一个配置值，而其中的内容password将是一个秘密。
要导入这些属性，可以将以下内容添加到您的application.properties或application.yaml文件中：
特性
Yaml

spring:
  config:
    import: "optional:configtree:/etc/config/"

然后，您可以按照通常的方式从中访问或注入myapp.username和myapp.password属性Environment。

如果要从同一父文件夹导入多个配置树，则可以使用通配符快捷方式。任何configtree:以结尾结尾的位置/*/都将所有直接子级导入为配置树。
例如，给定以下卷：

etc/
  config/
    dbconfig/
      db/
        username
        password
    mqconfig/
      mq/
        username
        password

您可以configtree:/etc/config/*/用作导入位置：
特性
Yaml

spring:
  config:
    import: "optional:configtree:/etc/config/*/"

这将增加db.username，db.password，mq.username和mq.password属性。

2.3.7 财产占位符

使用中的application.properties和时，它们中的值application.yml会通过现有的值进行过滤Environment，因此您可以参考以前定义的值（例如，从“系统”属性中）。标准的${name}property-placeholder语法可以在值中的任何位置使用。
例如，以下文件将设置app.description为“ MyApp是Spring Boot应用程序”：
特性
Yaml

app:
  name: "MyApp"
  description: "${app.name} is a Spring Boot application"

2.3.8 处理多文档文件

Spring Boot允许您将单个物理文件拆分为多个逻辑文档，每个逻辑文档都独立添加。从上到下按顺序处理文档。以后的文档可以覆盖以前的文档中定义的属性。
对于application.yml文件，使用标准的YAML多文档语法。三个连续的连字符代表一个文档的末尾，以及下一个文档的开始。
例如，以下文件具有两个逻辑文档：

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

对于application.properties文件，特殊#---注释用于标记文档拆分：

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

2.3.9 激活属性

有时仅在满足某些条件时才激活给定的属性获取，这很有用。例如，您可能具有仅在特定配置文件处于活动状态时才相关的属性。
您可以使用来有条件地激活属性文档spring.config.activate.*。
可以使用以下激活属性：
表2.激活属性

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

myprop:
  always-set
---
spring:
  config:
    activate:
      on-cloud-platform: "kubernetes"
      on-profile: "prod | staging"
myotherprop: sometimes-set

2.4。加密属性

Spring Boot不提供对加密属性值的任何内置支持，但是，它确实提供了修改Spring包含的值所必需的挂钩点Environment。该EnvironmentPostProcessor界面允许您Environment在应用程序启动之前进行操作。有关详细信息，请参见howto.html。
如果您正在寻找一种安全的方式来存储凭据和密码，则Spring Cloud Vault项目提供了对在HashiCorp Vault中存储外部化配置的支持。

2.5 使用YAML

YAML是JSON的超集，因此是一种用于指定层次结构配置数据的便捷格式。该SpringApplication级自动支持YAML来替代，只要你有属性SnakeYAML在classpath库。

2.5.1 将YAML映射到属性

YAML文档需要从其层次结构格式转换为可以与Spring一起使用的平面结构Environment。例如，考虑以下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列表也需要进行展平。它们表示为带有[index]取消引用程序的属性键。例如，考虑以下YAML：

my:
 servers:
 - dev.example.com
 - another.example.com

前面的示例将转换为以下属性：

my.servers[0]=dev.example.com
my.servers[1]=another.example.com

2.5.2 直接加载YAML

Spring Framework提供了两个方便的类，可用于加载YAML文档。该YamlPropertiesFactoryBean负载YAML作为Properties和YamlMapFactoryBean负载YAML作为Map。
YamlPropertySourceLoader如果要将YAML作为Spring加载，也可以使用该类PropertySource。

2.6 配置随机值

的RandomValuePropertySource是用于注射的随机值（例如，进入机密或试验例）是有用的。它可以产生整数，longs，uuid或字符串，如以下示例所示：
特性
Yaml

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]}"

该random.int*语法是OPEN value (,max) CLOSE其中的OPEN,CLOSE任何字符和value,max是整数。如果max提供，value则为最小值，max为最大值（不包括）。

2.7 类型安全的配置属性

使用@Value("${property}")注释注入配置属性有时会很麻烦，尤其是当您使用多个属性或数据本质上是分层的时。Spring Boot提供了一种使用属性的替代方法，该方法使强类型的Bean可以管理和验证应用程序的配置。

2.7.1 JavaBean属性绑定

可以绑定一个声明标准JavaBean属性的bean，如以下示例所示：

package com.example;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties("acme")
public class AcmeProperties {
    private boolean enabled;
    private InetAddress remoteAddress;
    private final Security security = new Security();
    public boolean isEnabled() { ... }
    public void setEnabled(boolean enabled) { ... }
    public InetAddress getRemoteAddress() { ... }
    public void setRemoteAddress(InetAddress remoteAddress) { ... }
    public Security getSecurity() { ... }
    public static class Security {
        private String username;
        private String password;
        private List<String> roles = new ArrayList<>(Collections.singleton("USER"));
        public String getUsername() { ... }
        public void setUsername(String username) { ... }
        public String getPassword() { ... }
        public void setPassword(String password) { ... }
        public List<String> getRoles() { ... }
        public void setRoles(List<String> roles) { ... }
    }
}

前面的POJO定义了以下属性：

• acme.enabled，false默认值为。
  
• acme.remote-address，其类型可以从强制转换String。
  
• acme.security.username，带有嵌套的“安全”对象，其名称由属性的名称确定。特别是，返回类型根本不使用，可能已经使用过SecurityProperties。
  
• acme.security.password。
  
• acme.security.roles，其中的一个集合String默认为USER。
  | | 映射到@ConfigurationPropertiesSpring Boot中可用类的属性是公共API，这些属性是通过属性文件，YAML文件，环境变量等配置的，但是类本身的访问器（获取器/设置器）不能直接使用。 | | :—-: | —- |

| | 这种安排依赖于默认的空构造函数，并且getter和setter通常是强制性的，因为绑定是通过标准Java Beans属性描述符进行的，就像在Spring MVC中一样。在以下情况下，可以忽略二传手：
- 只要将地图初始化，它们就需要使用吸气剂，但不一定需要使用setter，因为它们可以被活页夹改变。

• 可以通过索引（通常使用YAML）或使用单个逗号分隔的值（属性）来访问集合和数组。在后一种情况下，必须使用二传手。我们建议始终为此类类型添加设置器。如果初始化集合，请确保它不是不可变的（如上例所示）。

• 如果嵌套的POJO属性已初始化（如Security前面示例中的字段），则不需要setter。如果希望活页夹通过使用其默认构造函数动态创建实例，则需要一个setter。

有些人使用Lombok项目自动添加获取器和设置器。确保Lombok不会为这种类型生成任何特定的构造函数，因为容器会自动使用它来实例化该对象。
最后，仅考虑标准Java Bean属性，不支持对静态属性的绑定。 | | :—-: | —- |

2.7.2 构造函数绑定

上一节中的示例可以以不变的方式重写，如下例所示：

package com.example;
import java.net.InetAddress;
import java.util.List;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.ConstructorBinding;
import org.springframework.boot.context.properties.bind.DefaultValue;
@ConstructorBinding
@ConfigurationProperties("acme")
public class AcmeProperties {
    private final boolean enabled;
    private final InetAddress remoteAddress;
    private final Security security;
    public AcmeProperties(boolean enabled, InetAddress remoteAddress, Security security) {
        this.enabled = enabled;
        this.remoteAddress = remoteAddress;
        this.security = security;
    }
    public boolean isEnabled() { ... }
    public InetAddress getRemoteAddress() { ... }
    public Security getSecurity() { ... }
    public static class Security {
        private final String username;
        private final String password;
        private final List<String> roles;
        public Security(String username, String password,
                @DefaultValue("USER") List<String> roles) {
            this.username = username;
            this.password = password;
            this.roles = roles;
        }
        public String getUsername() { ... }
        public String getPassword() { ... }
        public List<String> getRoles() { ... }
    }
}

在此设置中，@ConstructorBinding注释用于指示应使用构造函数绑定。这意味着绑定器将期望找到带有您希望绑定的参数的构造函数。
类的嵌套成员@ConstructorBinding（例如Security上例）也将通过其构造函数进行绑定。
可以使用指定默认值，@DefaultValue并且将应用相同的转换服务将String值强制为缺少属性的目标类型。默认情况下，如果未绑定任何属性Security，则AcmeProperties实例将包含的null值security。如果您希望Security即使没有属性绑定也返回一个非null的实例，则可以使用一个空的@DefaultValue注释来这样做：

package com.example;
import java.net.InetAddress;
import java.util.List;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.ConstructorBinding;
import org.springframework.boot.context.properties.bind.DefaultValue;
@ConstructorBinding
@ConfigurationProperties("acme")
public class AcmeProperties {
    private final boolean enabled;
    private final InetAddress remoteAddress;
    private final Security security;
    public AcmeProperties(boolean enabled, InetAddress remoteAddress, @DefaultValue Security security) {
        this.enabled = enabled;
        this.remoteAddress = remoteAddress;
        this.security = security;
    }
}

2.7.3 启用@ConfigurationProperties注释的类型

Spring Boot提供了绑定@ConfigurationProperties类型并将其注册为Bean的基础架构。您可以逐类启用配置属性，也可以启用与组件扫描类似的方式进行配置属性扫描。
有时，带注释的类@ConfigurationProperties可能不适合扫描，例如，如果您正在开发自己的自动配置，或者想要有条件地启用它们。在这些情况下，请使用@EnableConfigurationProperties注释指定要处理的类型列表。可以在任何@Configuration类上完成此操作，如以下示例所示：

@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(AcmeProperties.class)
public class MyConfiguration {
}

要使用配置属性扫描，请将@ConfigurationPropertiesScan注释添加到您的应用程序。通常，它将添加到带有注释的主应用程序类中，@SpringBootApplication但可以将其添加到任何@Configuration类中。默认情况下，将从声明注释的类的包中进行扫描。如果要定义要扫描的特定程序包，可以按照以下示例所示进行操作：

@SpringBootApplication
@ConfigurationPropertiesScan({ "com.example.app", "org.acme.another" })
public class MyApplication {
}

我们建议@ConfigurationProperties仅处理环境，尤其不要从上下文中注入其他bean。对于极端情况，可以使用setter注入或*Aware框架提供的任何接口（例如，EnvironmentAware如果需要访问Environment）。如果仍然要使用构造函数注入其他bean，则必须使用注释配置属性bean@Component并使用基于JavaBean的属性绑定。

2.7.4 使用@ConfigurationProperties注释的类型

这种配置样式特别适用于SpringApplication外部YAML配置，如以下示例所示：

acme:
    remote-address: 192.168.1.1
    security:
        username: admin
        roles:
          - USER
          - ADMIN

要使用@ConfigurationPropertiesbean，可以像使用其他任何bean一样注入它们，如以下示例所示：

@Service
public class MyService {
    private final AcmeProperties properties;
    @Autowired
    public MyService(AcmeProperties properties) {
        this.properties = properties;
    }
    //...
    @PostConstruct
    public void openConnection() {
        Server server = new Server(this.properties.getRemoteAddress());
        // ...
    }
}

2.7.5 第三方配置

除了@ConfigurationProperties用于注释类之外，您还可以在公共@Bean方法上使用它。当您要将属性绑定到控件之外的第三方组件时，这样做特别有用。
要从Environment属性中配置bean ，请添加@ConfigurationProperties到其bean注册中，如以下示例所示：

@ConfigurationProperties(prefix = "another")
@Bean
public AnotherComponent anotherComponent() {
    ...
}

用another前缀定义的任何JavaBean属性都AnotherComponent以类似于前面AcmeProperties示例的方式映射到该bean 。

2.7.6 轻松绑定

Spring Boot使用一些宽松的规则将Environment属性绑定到@ConfigurationPropertiesBean，因此Environment属性名称和Bean属性名称之间不需要完全匹配。有用的常见示例包括破折号分隔的环境属性（例如，context-path绑定到contextPath）和大写的环境属性（例如，PORT绑定到port）。
例如，考虑以下@ConfigurationProperties类：

@ConfigurationProperties(prefix="acme.my-project.person")
public class OwnerProperties {
    private String firstName;
    public String getFirstName() {
        return this.firstName;
    }
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
}

通过前面的代码，可以一起使用以下属性名称：
表3.宽松的绑定

表4.每个属性源的宽松绑定规则

绑定图

绑定到Map属性时，可能需要使用特殊的括号符号，以便key保留原始值。如果键没有被包围[]，则所有非字母数字-或.已删除的字符。
例如，考虑将以下属性绑定到Map<String,String>：
特性
Yaml

acme:
  map:
    "[/key1]": "value1"
    "[/key2]": "value2"
    "/key3": "value3"

上面的性质将结合一个Map具有/key1，/key2并key3作为映射中的键。由于斜杠key3没有被方括号包围，因此已将其删除。
如果您key包含.且绑定到非标量值，则有时可能还需要使用括号符号。例如，绑定a.b=c到Map<String, Object>将返回带有条目的Map，{"a"={"b"="c"}}而[a.b]=c将返回带有条目的Map {"a.b"="c"}。

从环境变量绑定

大多数操作系统在可用于环境变量的名称周围施加严格的规则。例如，Linux shell变量只能包含字母（atoz或Ato Z），数字（0to 9）或下划线字符（_）。按照约定，Unix shell变量也将以大写字母命名。
Spring Boot的宽松绑定规则尽可能设计成与这些命名限制兼容。
要将规范形式的属性名称转换为环境变量名称，可以遵循以下规则：

• .用下划线（_）代替点（）。
  
• 删除所有破折号（-）。
  
• 转换为大写。
  

例如，配置属性spring.main.log-startup-info将是名为的环境变量SPRING_MAIN_LOGSTARTUPINFO。
绑定到对象列表时也可以使用环境变量。要绑定到List，元素编号应在变量名称中用下划线括起来。
例如，配置属性my.acme[0].other将使用名为的环境变量MY_ACME_0_OTHER。

2.7.7 合并复杂类型

如果在多个位置配置了列表，则通过替换整个列表来进行覆盖。
例如，假定默认情况下MyPojo具有name和description属性的对象null。以下示例公开了MyPojo来自的对象列表AcmeProperties：

@ConfigurationProperties("acme")
public class AcmeProperties {
    private final List<MyPojo> list = new ArrayList<>();
    public List<MyPojo> getList() {
        return this.list;
    }
}

考虑以下配置：
特性
Yaml

acme:
  list:
  - name: "my name"
    description: "my description"
---
spring:
  config:
    activate:
      on-profile: "dev"
acme:
  list:
  - name: "my another name"

如果dev配置文件未激活，则AcmeProperties.list包含一个MyPojo条目，如先前所定义。dev但是，如果启用了配置文件，则list 仍然仅包含一个条目（名称为my another name，说明为null）。此配置不会将第二个MyPojo实例添加到列表中，并且不会合并项目。
List在多个配置文件中指定a时，将使用优先级最高的一个（并且只有该优先级）。考虑以下示例：
特性
Yaml

acme:
  list:
  - name: "my name"
    description: "my description"
  - name: "another name"
    description: "another description"
---
spring:
  config:
    activate:
      on-profile: "dev"
acme:
  list:
  - name: "my another name"

在前面的示例中，如果dev配置文件处于活动状态，则AcmeProperties.list包含一个 MyPojo条目（名称为my another name，说明为null）。对于YAML，可以使用逗号分隔的列表和YAML列表来完全覆盖列表的内容。
对于Map属性，可以绑定从多个来源绘制的属性值。但是，对于多个源中的同一属性，将使用优先级最高的属性。以下示例公开了Map<String, MyPojo>from AcmeProperties：

@ConfigurationProperties("acme")
public class AcmeProperties {
    private final Map<String, MyPojo> map = new HashMap<>();
    public Map<String, MyPojo> getMap() {
        return this.map;
    }
}

考虑以下配置：
特性
Yaml

acme:
  map:
    key1:
      name: "my name 1"
      description: "my description 1"
---
spring:
  config:
    activate:
      on-profile: "dev"
acme:
  map:
    key1:
      name: "dev name 1"
    key2:
      name: "dev name 2"
      description: "dev description 2"

如果dev配置文件未处于活动状态，则AcmeProperties.map包含一个带有键的条目key1（名称为my name 1，说明为my description 1）。dev但是，如果启用了配置文件，则map包含两个带有键的项key1（名称为dev name 1和的描述为my description 1和key2，名称为dev name 2和的描述为dev description 2）。

2.7.8 属性转换

当Spring Boot绑定到@ConfigurationPropertiesbean时，它试图将外部应用程序属性强制为正确的类型。如果您需要自定义类型转换，则可以提供一个ConversionServiceBean（具有一个名为的Bean conversionService）或一个定制属性编辑器（通过一个CustomEditorConfigurerBean）或定制Converters（具有定义为的Bean @ConfigurationPropertiesBinding）。

转换时间

Spring Boot为表达持续时间提供了专门的支持。如果公开java.time.Duration属性，则应用程序属性中的以下格式可用：

• 常规long表示形式（使用毫秒作为默认单位，除非@DurationUnit已指定a）
  
• 标准的ISO-8601格式使用java.time.Duration
  
• 值和单位耦合的更易读的格式（例如，10s表示10秒）
  

考虑以下示例：

@ConfigurationProperties("app.system")
public class AppSystemProperties {
    @DurationUnit(ChronoUnit.SECONDS)
    private Duration sessionTimeout = Duration.ofSeconds(30);
    private Duration readTimeout = Duration.ofMillis(1000);
    public Duration getSessionTimeout() {
        return this.sessionTimeout;
    }
    public void setSessionTimeout(Duration sessionTimeout) {
        this.sessionTimeout = sessionTimeout;
    }
    public Duration getReadTimeout() {
        return this.readTimeout;
    }
    public void setReadTimeout(Duration readTimeout) {
        this.readTimeout = readTimeout;
    }
}

要指定30秒的会话超时30，PT30S和30s都等效。500毫秒的读取超时可以以任何形式如下指定：500，PT0.5S和500ms。
您也可以使用任何受支持的单位。这些是：

• ns 十亿分之一秒
  
• us 微秒
  
• ms 毫秒
  
• s 几秒钟
  
• m 几分钟
  
• h 用了几个小时
  
• d 好几天
  

默认单位是毫秒，可以使用@DurationUnit上面的示例中所示的方法进行覆盖。
如果您更喜欢使用构造函数绑定，则可以公开相同的属性，如以下示例所示：

@ConfigurationProperties("app.system")
@ConstructorBinding
public class AppSystemProperties {
    private final Duration sessionTimeout;
    private final Duration readTimeout;
    public AppSystemProperties(@DurationUnit(ChronoUnit.SECONDS) @DefaultValue("30s") Duration sessionTimeout,
            @DefaultValue("1000ms") Duration readTimeout) {
        this.sessionTimeout = sessionTimeout;
        this.readTimeout = readTimeout;
    }
    public Duration getSessionTimeout() {
        return this.sessionTimeout;
    }
    public Duration getReadTimeout() {
        return this.readTimeout;
    }
}

转换期

除了持续时间，Spring Boot还可以使用java.time.Periodtype。可以在应用程序属性中使用以下格式：

• 常规int表示形式（除非@PeriodUnit指定，否则使用天作为默认单位）
  
• 标准的ISO-8601格式使用java.time.Period
  
• 值和单位对耦合的更简单格式（例如，1y3d表示1年零3天）
  

简单格式支持以下单位：

• y 多年
  
• m 几个月
  
• w 数周
  
• d 好几天
  | | 该java.time.Period类型从不实际存储星期数，这是一个快捷方式，表示“ 7天”。 | | :—-: | —- |

转换数据大小

Spring Framework的DataSize值类型表示字节大小。如果公开DataSize属性，则应用程序属性中的以下格式可用：

• 常规long表示形式（除非@DataSizeUnit已指定，否则使用字节作为默认单位）
  
• 值和单位耦合的更具可读性的格式（例如，10MB意味着10兆字节）
  

考虑以下示例：

@ConfigurationProperties("app.io")
public class AppIoProperties {
    @DataSizeUnit(DataUnit.MEGABYTES)
    private DataSize bufferSize = DataSize.ofMegabytes(2);
    private DataSize sizeThreshold = DataSize.ofBytes(512);
    public DataSize getBufferSize() {
        return this.bufferSize;
    }
    public void setBufferSize(DataSize bufferSize) {
        this.bufferSize = bufferSize;
    }
    public DataSize getSizeThreshold() {
        return this.sizeThreshold;
    }
    public void setSizeThreshold(DataSize sizeThreshold) {
        this.sizeThreshold = sizeThreshold;
    }
}

指定10 MB的缓冲区大小，10并且10MB等效。可以将256个字节的大小阈值指定为256或256B。
您也可以使用任何受支持的单位。这些是：

• B 对于字节
  
• KB 千字节
  
• MB 兆字节
  
• GB 千兆字节
  
• TB 太字节
  

默认单位是字节，可以使用@DataSizeUnit上面的示例中所示的方法覆盖它。
如果您更喜欢使用构造函数绑定，则可以公开相同的属性，如以下示例所示：

@ConfigurationProperties("app.io")
@ConstructorBinding
public class AppIoProperties {
    private final DataSize bufferSize;
    private final DataSize sizeThreshold;
    public AppIoProperties(@DataSizeUnit(DataUnit.MEGABYTES) @DefaultValue("2MB") DataSize bufferSize,
            @DefaultValue("512B") DataSize sizeThreshold) {
        this.bufferSize = bufferSize;
        this.sizeThreshold = sizeThreshold;
    }
    public DataSize getBufferSize() {
        return this.bufferSize;
    }
    public DataSize getSizeThreshold() {
        return this.sizeThreshold;
    }
}

2.7.9 @ConfigurationProperties验证

@ConfigurationProperties每当使用Spring的@Validated注释对其进行注释时，Spring Boot就会尝试验证类。您可以javax.validation直接在配置类上使用JSR-303约束注释。为此，请确保在类路径上有兼容的JSR-303实现，然后将约束注释添加到字段中，如以下示例所示：

@ConfigurationProperties(prefix="acme")
@Validated
public class AcmeProperties {
    @NotNull
    private InetAddress remoteAddress;
    // ... getters and setters
}

为了确保始终为嵌套属性触发验证，即使未找到任何属性，相关字段也必须使用注释@Valid。下面的示例基于前面的AcmeProperties示例：

@ConfigurationProperties(prefix="acme")
@Validated
public class AcmeProperties {
    @NotNull
    private InetAddress remoteAddress;
    @Valid
    private final Security security = new Security();
    // ... getters and setters
    public static class Security {
        @NotEmpty
        public String username;
        // ... getters and setters
    }
}

您还可以Validator通过创建名为的bean定义来添加自定义Spring configurationPropertiesValidator。该@Bean方法应声明static。配置属性验证器是在应用程序生命周期的早期创建的，并且将@Bean方法声明为static可以使Bean得以创建而不必实例化@Configuration该类。这样做避免了由早期实例化引起的任何问题。

2.7.10 @ConfigurationProperties与@Value

的@Value注释是核心容器的功能，和它不提供相同的功能，类型安全配置属性。下表总结了@ConfigurationProperties和支持的功能@Value：

如果您为自己的组件定义了一组配置键，我们建议您将它们组合在以标记的POJO中@ConfigurationProperties。这样做将为您提供结构化的，类型安全的对象，您可以将其注入到自己的bean中。
SpEL在解析这些文件并填充环境时，不会处理来自应用程序属性文件的表达式。但是，可以在中编写SpEL表达式@Value。如果应用程序属性文件中属性的值是一个SpEL表达式，则通过进行使用时将对其求值@Value。

3.个人资料

Spring Profiles提供了一种隔离应用程序配置部分并使之仅在某些环境中可用的方法。任何@Component，@Configuration或@ConfigurationProperties可与被标记@Profile，当它被加载到限制，因为显示在下面的例子：

@Configuration(proxyBeanMethods = false)
@Profile("production")
public class ProductionConfiguration {
    // ...
}

您可以使用spring.profiles.active Environment属性来指定哪些配置文件处于活动状态。您可以通过本章前面介绍的任何方式指定属性。例如，您可以将其包括在您的中application.properties，如以下示例所示：
特性
Yaml

spring:
  profiles:
    active: "dev,hsqldb"

您还可以使用以下开关在命令行上指定它：--spring.profiles.active=dev,hsqldb。

3.1 添加活动配置文件

该spring.profiles.active属性与其他属性遵循相同的排序规则：最高PropertySource获胜。这意味着您可以在其中指定活动配置文件application.properties，然后使用命令行开关替换它们。
有时，将属性添加到活动配置文件而不是替换它们很有用。该SpringApplication入口点设置额外的配置文件的Java API（即，是对那些被激活的顶级spring.profiles.active属性）。参见SpringApplication中的setAdditionalProfiles()方法。如果给定的配置文件处于活动状态，则下一部分中描述的配置文件组也可以用于添加活动的配置文件。

3.2 个人资料组

有时，您在应用程序中定义和使用的配置文件的粒度太细，使用起来很麻烦。例如，您可能具有proddb和prodmq配置文件，用于分别启用数据库和消息传递功能。
为了解决这个问题，Spring Boot允许您定义配置文件组。使用配置文件组，您可以为相关的配置文件组定义逻辑名。
例如，我们可以创建一个production由proddb和prodmq配置文件组成的组。
特性
Yaml

spring:
  profiles:
    group:
      production:
      - "proddb"
      - "prodmq"

我们的应用程序现在可以使用开始--spring.profiles.active=production活跃了production，proddb和prodmq一重击轮廓。

3.3 以编程方式设置配置文件

您可以SpringApplication.setAdditionalProfiles(…)在应用程序运行之前通过调用来以编程方式设置活动配置文件。也可以通过使用Spring的ConfigurableEnvironment界面来激活配置文件。

3.4 特定于配置文件的配置文件

application.properties（或application.yml）和通过引用引用的文件的特定于档案的特定变体@ConfigurationProperties都被视为文件并已加载。有关详细信息，请参见“配置文件专用文件”。

4.记录

Spring Boot使用Commons Logging进行所有内部日志记录，但是使底层日志实现保持打开状态。提供了Java Util Logging，Log4J2和Logback的默认配置。在每种情况下，记录器都已预先配置为使用控制台输出，同时还提供可选文件输出。
默认情况下，如果使用“启动器”，则使用Logback进行日志记录。还包括适当的Logback路由，以确保使用Java Util Logging，Commons Logging，Log4J或SLF4J的从属库都可以正常工作。

4.1 日志格式

Spring Boot的默认日志输出类似于以下示例：
2019-03-05 10：57：51.112信息45469 —- [main] org.apache.catalina.core.StandardEngine：启动Servlet引擎：Apache Tomcat / 7.0.52
2019-03-05 10：57：51.253信息45469 —- [ost-startStop-1] oaccC [Tomcat]。[localhost]。[/]：初始化Spring嵌入式WebApplicationContext
2019-03-05 10：57：51.253信息45469-[ost-startStop-1] osweb.context.ContextLoader：根WebApplicationContext：初始化在1358毫秒内完成
2019-03-05 10：57：51.698信息45469-[ost-startStop-1] osbceServletRegistrationBean：映射servlet：’dispatcherServlet’到[/]
2019-03-05 10：57：51.702信息45469 —- [ost-startStop-1] osbcembedded.FilterRegistrationBean：映射过滤器：’hiddenHttpMethodFilter’到：[/ *]
输出以下项目：

• 日期和时间：毫秒精度，易于排序。
  
• 日志级别：ERROR，WARN，INFO，DEBUG，或TRACE。
  
• 进程ID。
  
• 一个---分离器来区分实际日志消息的开始。
  
• 线程名称：用方括号括起来（对于控制台输出可能会被截断）。
  
• 记录器名称：这通常是源类名称（通常缩写）。
  
• 日志消息。
  | | Logback没有FATAL级别。它映射到ERROR。 | | :—-: | —- |

4.2 控制台输出

缺省日志配置在写入消息时将消息回显到控制台。默认情况下，将记录ERROR-level，WARN-level和INFO-level消息。您还可以通过使用--debug标志启动应用程序来启用“调试”模式。
$ java -jar myapp.jar-调试

启用调试模式后，将配置一些核心记录器（嵌入式容器，Hibernate和Spring Boot）以输出更多信息。启用调试模式并没有配置您的应用程序记录所有消息DEBUG的水平。
另外，您可以通过使用--trace标志（或trace=true在中application.properties）启动应用程序来启用“跟踪”模式。这样做可以为某些核心记录器（嵌入式容器，Hibernate模式生成以及整个Spring产品组合）启用跟踪记录。

4.2.1 颜色编码输出

如果您的终端支持ANSI，则使用彩色输出来提高可读性。您可以设置spring.output.ansi.enabled为支持的值以覆盖自动检测。
通过使用%clr转换字来配置颜色编码。转换器以最简单的形式根据对数级别为输出着色，如以下示例所示：

%clr(%5p)

下表描述了日志级别到颜色的映射：

或者，您可以通过将其提供为转换的选项来指定应使用的颜色或样式。例如，要使文本变黄，请使用以下设置：

%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){yellow}

支持以下颜色和样式：

• blue
  
• cyan
  
• faint
  
• green
  
• magenta
  
• red
  
• yellow
  

  4.3 文件输出

  默认情况下，Spring Boot仅记录到控制台，不写日志文件。如果除了控制台输出外还想写日志文件，则需要设置一个logging.file.name或logging.file.path属性（例如，在中application.properties）。
  下表显示了如何logging.*一起使用这些属性：
  表5.日志记录属性

日志文件达到10 MB时会旋转，并且与控制台输出一样，默认情况下会记录ERROR-level，WARN-level和INFO-level消息。

4.4 文件旋转

如果您使用的是Logback，则可以使用application.properties或application.yaml文件微调日志轮播设置。对于所有其他日志记录系统，您需要直接自己配置轮转设置（例如，如果使用Log4J2，则可以添加log4j.xml文件）。
支持以下轮换策略属性：

4.5 日志级别

通过在其中使用TRACE，DEBUG，INFO，WARN，ERROR，FATAL或OFF之一，可以在Spring中设置所有记录器级别Environment（例如，在中application.properties）。该记录器可以通过使用被配置。logging.level.<logger-name>=<level>``level``root``logging.level.root
以下示例显示了中的潜在日志记录设置application.properties：
特性
Yaml

logging:
  level:
    root: "warn"
    org.springframework.web: "debug"
    org.hibernate: "error"

也可以使用环境变量来设置日志记录级别。例如，LOGGING_LEVEL_ORG_SPRINGFRAMEWORK_WEB=DEBUG将设置org.springframework.web为DEBUG。

4.6 日志组

能够将相关记录器分组在一起通常很有用，以便可以同时配置它们。例如，您可能通常会更改所有与Tomcat相关的记录器的记录级别，但是您不容易记住顶层软件包。
为了解决这个问题，Spring Boot允许您在Spring中定义日志记录组Environment。例如，这是通过将“ tomcat”组添加到您的方式来定义它的方法application.properties：
特性
Yaml

logging:
  group:
    tomcat: "org.apache.catalina,org.apache.coyote,org.apache.tomcat"

定义后，您可以使用一行更改该组中所有记录器的级别：
特性
Yaml

logging:
  level:
    tomcat: "trace"

Spring Boot包含以下预定义的日志记录组，它们可以直接使用：

4.7 使用日志关闭挂钩

为了释放日志记录资源，通常最好在应用程序终止时停止日志记录系统。不幸的是，没有一种方法可以适用于所有应用程序类型。如果您的应用程序具有复杂的上下文层次结构或作为war文件部署，则需要研究基础日志系统直接提供的选项。例如，Logback提供了上下文选择器，允许每个Logger在其自己的上下文中创建。
对于在自己的JVM中部署的简单“单罐”应用程序，可以使用该logging.register-shutdown-hook属性。设置logging.register-shutdown-hook为true将会注册一个关闭挂钩，该挂钩将在JVM退出时触发日志系统清理。
您可以在application.properties或application.yaml文件中设置属性：
特性
Yaml

logging:
  register-shutdown-hook: true

4.8 自定义日志配置

可以通过在类路径中包含适当的库来激活各种日志记录系统，并可以通过在类路径的根目录或以下SpringEnvironment属性指定的位置中提供适当的配置文件来进一步自定义各种日志记录系统logging.config。
您可以通过使用org.springframework.boot.logging.LoggingSystemsystem属性来强制Spring Boot使用特定的日志记录系统。该值应该是实现的完全限定的类名LoggingSystem。您还可以通过使用值完全禁用Spring Boot的日志记录配置none。

根据您的日志记录系统，将加载以下文件：

为了帮助进行定制，Environment如下表所述，一些其他属性从Spring转移到System属性：

如果您使用的是Logback，还将传输以下属性：

所有受支持的日志记录系统在解析其配置文件时都可以查阅系统属性。有关spring-boot.jar示例，请参见中的默认配置：

• 退回
  
• Log4j 2
  
• Java Util日志记录
  | | 如果要在日志记录属性中使用占位符，则应使用Spring Boot的语法而不是基础框架的语法。值得注意的是，如果您使用Logback，则应将其:用作属性名称与其默认值之间的分隔符，而不应使用:-。 | | :—-: | —- |

| | 您可以通过仅覆盖LOG_LEVEL_PATTERN（或logging.pattern.level使用Logback）将MDC和其他临时内容添加到日志行。例如，如果使用logging.pattern.level=user:%X{user} %5p，则默认日志格式包含“ user”的MDC条目（如果存在），如以下示例所示。2019-08-30 12：30：04.031用户：某人INFO 22174-[[nio-8080-exec-0] demo.Controller 处理已认证的请求 | | :—-: | —- |

4.9 登录扩展

Spring Boot包含许多Logback扩展，可以帮助进行高级配置。您可以在logback-spring.xml配置文件中使用这些扩展名。

ch.qos.logback.core.joran.spi.Interpreter@4中的错误：71-[springProperty]没有适用的操作，当前ElementPath是[[configuration] [springProperty]]ch.qos.logback.core.joran.spi.Interpreter@4中的
错误：71-[springProfile]没有适用的操作，当前ElementPath是[[configuration] [springProfile]]

4.9.1 特定于配置文件的配置

使用<springProfile>标签，您可以根据活动的Spring配置文件选择包括或排除配置部分。概要文件部分在<configuration>元素内的任何位置都受支持。使用name属性指定哪个配置文件接受配置。所述<springProfile>标记可包含简档名称（例如staging）或轮廓表达。简档表达式允许例如表达更复杂的简档逻辑production & (eu-central | eu-west)。有关更多详细信息，请参阅参考指南。以下清单显示了三个样本概要文件：

<springProfile name="staging">
    <!-- configuration to be enabled when the "staging" profile is active -->
</springProfile>
<springProfile name="dev | staging">
    <!-- configuration to be enabled when the "dev" or "staging" profiles are active -->
</springProfile>
<springProfile name="!production">
    <!-- configuration to be enabled when the "production" profile is not active -->
</springProfile>

4.9.2 环境特性

该<springProperty>标签可以让你从Spring公开属性Environment的范围内的logback使用。如果要从application.propertiesLogback配置中访问文件中的值，则这样做很有用。该标签的工作方式类似于Logback的标准<property>标签。但是，value您无需指定direct，而是可以指定source属性的（来自Environment）。如果需要将属性存储在local范围之外的其他位置，则可以使用该scope属性。如果需要后备值（如果未在中设置属性Environment），则可以使用defaultValue属性。以下示例显示如何公开用于Logback的属性：

<springProperty scope="context" name="fluentHost" source="myapp.fluentd.host"
        defaultValue="localhost"/>
<appender name="FLUENT" class="ch.qos.logback.more.appenders.DataFluentAppender">
    <remoteHost>${fluentHost}</remoteHost>
    ...
</appender>

5.国际化

Spring Boot支持本地化消息，因此您的应用程序可以迎合不同语言首选项的用户。默认情况下，Spring Bootmessages在类路径的根目录下查找资源包的存在。

可以使用spring.messages名称空间来配置资源包的基本名称以及其他几个属性，如以下示例所示：
特性
Yaml

spring:
  messages:
    basename: "messages,config.i18n.messages"
    fallback-to-system-locale: false

请参阅MessageSourceProperties以获取更多受支持的选项。

6. JSON

Spring Boot提供了与三个JSON映射库的集成：

• 格森
  
• 杰克逊
  
• JSON-B
  

Jackson是首选的默认库。

6.1 杰克逊

提供了Jackson的自动配置功能，并且Jackson是的一部分spring-boot-starter-json。当Jackson放在类路径上时，将ObjectMapper自动配置Bean。提供了几个配置属性，用于自定义的配置ObjectMapper。

6.2 格森

提供了Gson的自动配置。当Gson在类路径上时，将Gson自动配置Bean。spring.gson.*提供了几个配置属性用于自定义配置。为了获得更多控制权，GsonBuilderCustomizer可以使用一个或多个bean。

6.3 JSON-B

提供了JSON-B的自动配置。当JSON-B API和实现位于类路径上时，Jsonb将自动配置Bean。首选的JSON-B实现是提供依赖管理的Apache Johnzon。

7.开发Web应用程序

Spring Boot非常适合Web应用程序开发。您可以使用嵌入式Tomcat，Jetty，Undertow或Netty创建独立的HTTP服务器。大多数Web应用程序都使用该spring-boot-starter-web模块来快速启动和运行。您还可以选择使用该spring-boot-starter-webflux模块来构建反应式Web应用程序。
如果尚未开发Spring Boot Web应用程序，则可以遵循“ Hello World！”。入门部分中的示例。

7.1 “ Spring Web MVC框架”

在春天Web MVC框架（通常被称为“春MVC”）是一个丰富的“模型视图控制器” Web框架。Spring MVC允许您创建特殊的@Controller或@RestControllerbean来处理传入的HTTP请求。控制器中的方法通过使用@RequestMapping批注映射到HTTP 。
以下代码显示了@RestController提供JSON数据的典型代码：

@RestController
@RequestMapping(value="/users")
public class MyRestController {
    @RequestMapping(value="/{user}", method=RequestMethod.GET)
    public User getUser(@PathVariable Long user) {
        // ...
    }
    @RequestMapping(value="/{user}/customers", method=RequestMethod.GET)
    List<Customer> getUserCustomers(@PathVariable Long user) {
        // ...
    }
    @RequestMapping(value="/{user}", method=RequestMethod.DELETE)
    public User deleteUser(@PathVariable Long user) {
        // ...
    }
}

Spring MVC是核心Spring Framework的一部分，有关详细信息，请参阅参考文档。在spring.io/guides上还有一些涵盖Spring MVC的指南。

7.1.1 Spring MVC自动配置

Spring Boot为Spring MVC提供了自动配置，可与大多数应用程序完美配合。
自动配置在Spring的默认值之上添加了以下功能：

• 包含ContentNegotiatingViewResolver和BeanNameViewResolver。
  
• 支持提供静态资源，包括对WebJars的支持（在本文档的后面部分中有介绍）。
  
• 自动注册Converter，GenericConverter和Formatter豆类。
  
• 支持HttpMessageConverters（在本文档后面介绍）。
  
• 自动注册MessageCodesResolver（在本文档后面介绍）。
  
• 静态index.html支持。
  
• 自动使用ConfigurableWebBindingInitializerbean（在本文档后面部分中介绍）。
  

如果要保留这些Spring Boot MVC定制并进行更多的MVC定制（拦截器，格式化程序，视图控制器和其他功能），则可以添加自己@Configuration的type类，WebMvcConfigurer但不添加 @EnableWebMvc。
如果你想提供的定制情况RequestMappingHandlerMapping，RequestMappingHandlerAdapter或者ExceptionHandlerExceptionResolver，仍然保持弹簧引导MVC自定义，你可以声明类型的豆WebMvcRegistrations，并用它来提供这些组件的定制实例。
如果你想利用Spring MVC中的完全控制，你可以添加自己的@Configuration注解为@EnableWebMvc，或者添加自己的@Configuration-annotatedDelegatingWebMvcConfiguration中的Javadoc中所述@EnableWebMvc。

7.1.2 HttpMessageConverters

Spring MVC使用该HttpMessageConverter接口转换HTTP请求和响应。开箱即用中包含明智的默认设置。例如，可以将对象自动转换为JSON（通过使用Jackson库）或XML（通过使用Jackson XML扩展（如果可用）或通过使用JAXB（如果Jackson XML扩展不可用））。默认情况下，字符串编码为UTF-8。
如果需要添加或自定义转换器，则可以使用Spring Boot的HttpMessageConverters类，如以下清单所示：

import org.springframework.boot.autoconfigure.http.HttpMessageConverters;
import org.springframework.context.annotation.*;
import org.springframework.http.converter.*;
@Configuration(proxyBeanMethods = false)
public class MyConfiguration {
    @Bean
    public HttpMessageConverters customConverters() {
        HttpMessageConverter<?> additional = ...
        HttpMessageConverter<?> another = ...
        return new HttpMessageConverters(additional, another);
    }
}

HttpMessageConverter上下文中存在的任何Bean都将添加到转换器列表中。您也可以用相同的方法覆盖默认转换器。

7.1.3 自定义JSON序列化器和反序列化器

如果使用Jackson来序列化和反序列化JSON数据，则可能需要编写自己的JsonSerializer和JsonDeserializer类。自定义序列化程序通常是通过模块向Jackson进行注册的，但是Spring Boot提供了一种可选的@JsonComponent注释，使直接注册Spring Bean变得更加容易。
您可以使用@JsonComponent直接的注解JsonSerializer，JsonDeserializer或KeyDeserializer实现。您还可以在包含序列化器/反序列化器作为内部类的类上使用它，如以下示例所示：

import java.io.*;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import org.springframework.boot.jackson.*;
@JsonComponent
public class Example {
    public static class Serializer extends JsonSerializer<SomeObject> {
        // ...
    }
    public static class Deserializer extends JsonDeserializer<SomeObject> {
        // ...
    }
}

中的所有@JsonComponentbean都会ApplicationContext自动向Jackson进行注册。因为使用@JsonComponent进行了元注释@Component，所以适用通常的组件扫描规则。
Spring Boot还提供了JsonObjectSerializer和JsonObjectDeserializer基类，它们在序列化对象时为标准Jackson版本提供了有用的替代方法。有关详细信息，请参见JsonObjectSerializer和JsonObjectDeserializer在Javadoc中。

7.1.4。MessageCodesResolver

Spring MVC的具有产生错误代码从绑定错误的渲染错误消息的策略：MessageCodesResolver。如果设置spring.mvc.message-codes-resolver-format属性PREFIX_ERROR_CODE或POSTFIX_ERROR_CODE，Spring Boot会为您创建一个（请参阅中的枚举DefaultMessageCodesResolver.Format）。

7.1.5。静态内容

默认情况下，Spring Boot从类路径中名为/static（/public或/resources或/META-INF/resources）的目录或根目录提供静态内容ServletContext。它使用ResourceHttpRequestHandlerSpring MVC中的from，因此您可以通过添加自己WebMvcConfigurer的addResourceHandlers方法并覆盖该方法来修改该行为。
在独立的Web应用程序中，还启用了容器中的默认servlet，并将其用作后备，从ServletContextSpring决定不处理它的根开始提供内容。在大多数情况下，这不会发生（除非您修改默认的MVC配置），因为Spring始终可以通过处理请求DispatcherServlet。
默认情况下，资源映射到/**，但是您可以使用spring.mvc.static-path-pattern属性对其进行调整。例如，将所有资源重新分配到/resources/**以下位置即可：
特性
Yaml

spring:
  mvc:
    static-path-pattern: "/resources/**"

您也可以使用spring.web.resources.static-locations属性来自定义静态资源位置（用目录位置列表替换默认值）。根Servlet上下文路径"/"也会自动添加为位置。
除了前面提到的“标准”静态资源位置，Webjars内容也有特殊情况。/webjars/**如果jar文件以Webjars格式打包，则从jar文件提供带有路径的所有资源。

Spring Boot还支持Spring MVC提供的高级资源处理功能，允许使用案例，例如缓存清除静态资源或对Webjars使用版本无关的URL。
要对Webjar使用版本无关的URL，请添加webjars-locator-core依赖项。然后声明您的Webjar。使用jQuery作为一个例子，将"/webjars/jquery/jquery.min.js"在结果中"/webjars/jquery/x.y.z/jquery.min.js"，其中x.y.z是Webjar版本。

要使用缓存清除，以下配置为所有静态资源配置了缓存清除解决方案，从而有效地<link href="/css/spring-2a2d595e6ed9a0b24f027f2b63b134d6.css"/>在URL中添加了内容哈希，例如，：
特性
Yaml

spring:
  web:
    resources:
      chain:
        strategy:
          content:
            enabled: true
            paths: "/**"

例如，当使用JavaScript模块加载器动态加载资源时，不可以重命名文件。这就是为什么其他策略也受支持并且可以组合的原因。“固定”策略在URL中添加静态版本字符串，而不更改文件名，如以下示例所示：
特性
Yaml

spring:
  web:
    resources:
      chain:
        strategy:
          content:
            enabled: true
            paths: "/**"
          fixed:
            enabled: true
            paths: "/js/lib/"
            version: "v12"

通过这种配置，位于下面的JavaScript模块"/js/lib/"使用固定的版本控制策略（"/v12/js/lib/mymodule.js"），而其他资源仍使用内容版本（<link href="/css/spring-2a2d595e6ed9a0b24f027f2b63b134d6.css"/>）。
请参阅ResourceProperties以获取更多受支持的选项。

7.1.6。欢迎页面

Spring Boot支持静态和模板欢迎页面。它首先index.html在配置的静态内容位置中查找文件。如果找不到，则寻找index模板。如果找到任何一个，它将自动用作应用程序的欢迎页面。

7.1.7。路径匹配和内容协商

Spring MVC可以通过查看请求路径并将其匹配到应用程序中定义的映射（例如，@GetMappingController方法的注释）来将传入的HTTP请求映射到处理程序。
Spring Boot默认选择禁用后缀模式匹配，这意味着"GET /projects/spring-boot.json"类似的请求将不会与@GetMapping("/projects/spring-boot")映射匹配。这被认为是Spring MVC应用程序的最佳实践。过去，此功能主要用于未发送正确的“ Accept”请求标头的HTTP客户端。我们需要确保将正确的内容类型发送给客户端。如今，内容协商已变得更加可靠。
还有其他处理HTTP客户端的方法，这些方法不能始终发送正确的“ Accept”请求标头。除了使用后缀匹配，我们还可以使用查询参数来确保将诸如这样的请求"GET /projects/spring-boot?format=json"映射到@GetMapping("/projects/spring-boot")：
特性
Yaml

spring:
  mvc:
    contentnegotiation:
      favor-parameter: true

或者，如果您更喜欢使用其他参数名称：

spring:
  mvc:
    contentnegotiation:
      favor-parameter: true
      parameter-name: "myparam"

开箱即用地支持大多数标准媒体类型，但是您也可以定义新的媒体类型：
特性
Yaml

spring:
  mvc:
    contentnegotiation:
      media-types:
        markdown: "text/markdown"

后缀模式匹配已被弃用，并将在以后的版本中删除。如果您了解了注意事项，但仍希望您的应用程序使用后缀模式匹配，则需要以下配置：

spring.mvc.contentnegotiation.favor-path-extension=true
spring.mvc.pathmatch.use-suffix-pattern=true

另外，与其打开所有后缀模式，不如只支持注册的后缀模式，这更安全：
特性
Yaml

spring:
  mvc:
    contentnegotiation:
      favor-path-extension: true
    pathmatch:
      use-registered-suffix-pattern: true

从Spring Framework 5.3开始，Spring MVC支持多种实现策略，用于将请求路径匹配到Controller处理程序。它以前仅支持该AntPathMatcher策略，但现在也提供了PathPatternParser。Spring Boot现在提供一个配置属性供您选择和选择新策略：
特性
Yaml

spring:
  mvc:
    pathmatch:
      matching-strategy: "path-pattern-parser"

有关为什么应考虑使用此新实现的更多详细信息，请查看 专用博客文章。