第06篇SpringBoot基础应用

第01章_SpringBoot快速入门

第一节 SpringBoot简介

1. 什么是SpringBoot?

SpringBoot是Spring项目的一个子工程，它将一些主流的技术与Spring框架进行了整合，基于约定优于配置的思想，为开发者提供了一个方便快捷的工程脚手架。

2. SpringBoot的主要作用

• 简化依赖管理：对于常见的业务场景，通过启动器(Starter)对所需依赖进行搭配和版本管理，开发者只需要引入场景启动器即可。

• 进行默认配置：分析导入的依赖，通过条件注解(@Condition)对业务场景进行默认配置，减少了项目中的"模板化"配置。

• 加载外部属性：从命令行参数、系统环境变量、外部属性文件等位置加载外部属性，并通过Environment进行统一管理。

• 提供运行监控：监控程序运行状况，通过端点的方式提供程序健康状态、安全指标、属性配置等监控信息。

• 内嵌servlet容器：通过Maven插件直接将程序打包为可执行的Jar包文件，无需应用服务器即可独立运行。

注意：

1. 由于SpringBoot需要基于模块装配+条件装配+SPI机制等实现“约定大于配置”的思想，因此一般采用注解配置的方式。

2. 基于XML的配置方式编写更灵活、易修改(无需重新打包)，但是不方便整合场景制作启动器(需要根据不同的情况进行注册)。

第二节 SpringBoot入门案例

SpringBoot为我们提供了非常快速的开发体验，通过下面几个步骤，将会搭建一个简单的Web应用程序。

1. 继承SpringBoot父工程

新建一个Maven项目，在pom.xml文件中继承SpringBoot父工程：spring-boot-starter-parent。

​x
1
<?xml version="1.0" encoding="UTF-8"?>
2
<project xmlns="http://maven.apache.org/POM/4.0.0"
3
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5
    <modelVersion>4.0.0</modelVersion>
6

7
    <groupId>org.example</groupId>
8
    <artifactId>SpringBoot-demo</artifactId>
9
    <version>1.0-SNAPSHOT</version>
10

11
    <!-- 继承SpringBoot父工程：spring-boot-starter-parent -->
12
    <parent>
13
        <groupId>org.springframework.boot</groupId>
14
        <artifactId>spring-boot-starter-parent</artifactId>
15
        <version>2.1.1.RELEASE</version>
16
    </parent>
17

18
</project>

注意：下面是本文档所使用的SpringBoot 2.1.1.RELEASE版本相关信息，请关注你所使用的SpringBoot版本！

1. 基础依赖版本：Java8+(兼容Java11)、Spring Framework 5.1.3.RELEASE+、Maven3.3+。

2. 内置容器版本：Tomcat 9.0(Servlet Version 4.0)。

2. 引入场景启动器

我们开发的是一个Web应用，则在pom.xml文件中引入Web应用场景的启动器：spring-boot-starter-web。

7
1
<dependencies>
2
    <dependency>
3
        <groupId>org.springframework.boot</groupId>
4
        <artifactId>spring-boot-starter-web</artifactId>
5
    </dependency>
6
</dependencies>
7

3. 编写启动类

SpringBoot应用一般需要一个启动类来进行引导程序的启动和开启自动配置。

12
1
package com.huangyuanxin.notes.springboot;
2

3
import org.springframework.boot.SpringApplication;
4
import org.springframework.boot.autoconfigure.SpringBootApplication;
5

6
@SpringBootApplication
7
public class MyApplication {
8
    public static void main(String[] args) {
9
        SpringApplication.run(MyApplication.class, args);
10
    }
11
}
12

4. 编写业务类

编写一个简单的/hello接口，来测试下我们的SpringBoot应用。

13
1
package com.huangyuanxin.notes.springboot.controller;
2

3
import org.springframework.web.bind.annotation.GetMapping;
4
import org.springframework.web.bind.annotation.RestController;
5

6
@RestController
7
public class HelloController {
8
    @GetMapping("hello")
9
    public String hello() {
10
        return "hello,SpringBoot!";
11
    }
12
}
13

4. 运行和测试

直接在IDEA中执行main函数，或者在工程根目录(pom.xml文件所在目录)通过mvn spring-boot:run命令启动。

当启动完成后，点击http://localhost:8080/hello即可进行访问！

5. 发布可执行Jar包

由于Java没有提供加载嵌套jar文件的标准方法，因此，需要引入一个插件spring-boot-maven-plugin来支持它。

9
1
<build>
2
    <plugins>
3
        <plugin>
4
            <groupId>org.springframework.boot</groupId>
5
            <artifactId>spring-boot-maven-plugin</artifactId>
6
        </plugin>
7
    </plugins>
8
</build>
9

然后，在工程根目录(pom.xml文件所在目录)使用mvn package -Dmaven.test.skip=true命令来对其进行打包。

打包完成后会生成SpringBoot-demo-1.1-SNAPSHOT.jar.original和SpringBoot-demo-1.1-SNAPSHOT.jar两个文件。前者为Maven生成的原始Jar文件，仅包含当前工程代码，一般提供给其它工程引用；后者为SpringBoot重新打包后生成的可执行jar文件，额外包含了工程的所有依赖Jar包及启动代码。

最后，使用java -jar SpringBoot-demo-1.0-SNAPSHOT.jar命令来启动和测试它！

提示：如果需要支持远程调试，请使用如下命令启动你的SpringBoot应用程序：

2
1
java -Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n 
2
  -jar SpringBoot-demo-1.0-SNAPSHOT.jar

第三节 入门案例扩展

1. SpringBoot父工程

一般来说，SpringBoot项目都会继承spring-boot-starter-parent作为父工程，它提供了版本管理和默认配置：

• 版本管理：通过dependencyManagement标签对常见依赖进行版本管理，这些依赖会随SpringBoot一起升级。

• 默认配置：提供了一些默认属性和插件配置，如默认的源码编译级别(1.8)、默认的字符编码(UTF-8)、使用-parameters编译等。

除此之外，SpringBoot父工程还会进行一些插件的默认配置以及对配置文件(application.properties)的进行敏感资源过滤等。

父工程中的默认属性，可以通过覆盖的方式修改它们，如下例所示：

5
1
<properties>
2
     <!--通过属性修改spring-data的默认版本为Fowler-SR2-->
3
     <spring-data-releasetrain.version>Fowler-SR2</spring-data-releasetrain.version>
4
</properties>
5

如果不想继承父工程，则也可以通过如下方式来使用SpringBoot的版本管理功能，但是你不能使用覆盖的方式去修改默认属性。

12
1
<dependencyManagement>
2
    <dependencies>
3
        <dependency>
4
            <!-- Import dependency management from Spring Boot -->
5
            <groupId>org.springframework.boot</groupId>
6
            <artifactId>spring-boot-dependencies</artifactId>
7
            <version>2.1.1.RELEASE</version>
8
            <type>pom</type>
9
            <scope>import</scope>
10
        </dependency>
11
    </dependencies>
12
</dependencyManagement>

2. 场景启动器

场景启动器(Starter)是SpringBoot管理复杂依赖关系的一种手段，你可以把它理解为一些用于某项功能所需要依赖的集合。SpringBoot官方为一些应用场景内置相应的启动器，一般以spring-boot-starter-开头，下面是常见的启动器列表：

除上述一些官方内置的启动器外，第三方项目也可以基于开放的接口定义自己的启动器，如MyBatis定义的mybatis-spring-boot-starter启动器等。更多第三方启动器，可参考GitHub上spring-boot-starters模块中的README file。

3. @SpringBootApplication

@SpringBootApplication注解用于标识该应用为一个SpringBoot应用程序，它由如下三个注解组成：

• @EnableAutoConfiguration：开启SpringBoot的自动配置(该注解只能被添加一次)。

• @SpringBootConfiguration：声明当前类是一个配置类，本质是@Configuration注解的包装类。

• @ComponentScan：配置注解扫描，等同于<context:component-scan />，默认扫描当前包及其子包。

提示：如果需要注册不在扫描路径内的Spring组件，可以使用Spring的@Import或@ImportResource注解。

如果想禁用某个自动配置，可以使用该注解的exclude属性，如以下示例所示：

7
1
@SpringBootApplication(exclude={DataSourceAutoConfiguration.class})
2
public class MyApplication {
3
    public static void main(String[] args) {
4
        SpringApplication.run(MyApplication.class, args);
5
    }
6
}
7

如果该类不在CLASSPATH中，则可以使用相关的excludeName属性，并指定全限定类名。除此之外，您也可以在application.yml中使用spring.autoconfigure.exclude属性来控制要排除的自动配置类的列表。

第02章_SpringBoot核心

第一节 SpringApplication

1. 创建SpringApplication

SpringApplication类提供了一个静态方法run，可以方便的从main函数来启动Spring应用程序，如下例所示。

5
1
public static void main(String[] args) {
2
    // 创建并引导启动Spring应用程序(第一个参数为@Configuration配置对象，第二个参数为main函数参数)
3
    SpringApplication.run(MyApplication.class, args);
4
}
5

当然，你也可以创建一个本地实例，并对其进行自定义设置后再启动。

5
1
public static void main(String[] args) {
2
    SpringApplication app = new SpringApplication(MyApplication.class);
3
    app.setBannerMode(Banner.Mode.OFF);
4
    app.run(args);
5
}

如果你更喜欢流式编程(Fluent Builder API)，也可以使用如下方式。

6
1
public static void main(String[] args) {
2
    new SpringApplicationBuilder()
3
        .sources(MyApplication.class)
4
        .bannerMode(Banner.Mode.OFF)
5
        .run(args);
6
}

此外，利用 SpringapplicationBuilder 可以构建具有层次关系的 Spring Boot 应用程序：

1
1
new springapplicationBuilder(...).parent(...).child(...).run(...);

2. 启动SpringApplication

2.1 如何启动

入门案例中已经讲解了如何启动SpringBoot应用程序。

2.2 生成PID和PORT文件

在META-INF/spring.factories文件中添加如下配置后，就可以生成相应的PID和PORT文件，默认的文件名为application.port和application.port。

4
1
org.springframework.context.ApplicationListener=\
2
org.springframework.boot.context.ApplicationPidFileWriter,\
3
org.springframework.boot.web.context.WebServerPortFileWriter
4

如需修改默认生成的文件名，可以使用spring.pid.file=/var/log/app.pid属性，或采用编程方式进行配置。

2.3 启动失败(FailureAnalyzer)

如果程序启动失败，SpringBoot会通过已注册的FailureAnalyzer来分析错误，以提供专用的错误消息和解决该问题的具体措施。如端口被占用时会打印如下错误报告。

12
1
***************************
2
APPLICATION FAILED TO START
3
***************************
4

5
Description:
6

7
The Tomcat connector configured to listen on port 8080 failed to start. The port may already be in use or the connector may be misconfigured.
8

9
Action:
10

11
Verify the connector's configuration, identify and stop any process that's listening on port 8080, or configure this application to listen on another port.
12

如果需要进行扩展，可继承针对于特定异常类型的AbstractFailureAnalyzer<T extends Throwable>抽象类，并在META-INF/spring.factories中通过如下配置进行注册。

2
1
org.springframework.boot.diagnostics.FailureAnalyzer=com.example.ProjectConstraintViolationFailureAnalyzer
2

提示：

1. 使用JSR-303注解出现异常时也会由FailureAnalyzer来分析错误。

2. 在FailureAnalyzer中，可以通过实现BeanFactoryAware和EnvironmentAware接口来获取BeanFactory和Environment。

3.SpringApplication的常用设置

SpringApplication可以在创建时通过其JavaAPI或spring.main前缀的外部化属性进行自定义设置。

9
1
# 设置sources属性(注意：该属性做了特殊处理，不会被覆盖，而是合并)
2
spring.main.sources=com.acme.Config,com.acme.ExtraConfig
3

4
# 开启Banner打印
5
spring.main.banner-mode=console
6

7
# 移除嵌入式Web服务器
8
spring.main.web-application-type=none
9

3.1 设置Banner

SpringBoot应用在启动时会自动加载类路径下的banner.txt文件或同名.gif/.jpg/.png结尾的图片(转化为ASCII艺术作品)来打印Banner。banner.txt文件示例如下：

11
1

2
  ${AnsiColor.RED} ██████╗ ${AnsiColor.BLUE}██╗  ██╗
3
  ${AnsiColor.RED}██╔═══██╗${AnsiColor.BLUE}██║ ██╔╝
4
  ${AnsiColor.RED}██║   ██║${AnsiColor.BLUE}█████╔╝
5
  ${AnsiColor.RED}██║   ██║${AnsiColor.BLUE}██╔═██╗
6
  ${AnsiColor.RED}╚██████╔╝${AnsiColor.BLUE}██║  ██╗
7
  ${AnsiColor.RED} ╚═════╝ ${AnsiColor.BLUE}╚═╝  ╚═╝
8

9
${AnsiColor.BRIGHT_BLUE}:: Running Spring Boot ${spring-boot.version} ::
10
:: http://notes.huangyuanxin.com ::${AnsiColor.DEFAULT}
11

在banner.txt中，可以使用下面一些占位符：

以及下面一些属性来进行相关配置：

除上述属性配置的方式外，也可以通过实现接口的方式来设置Banner。首先实现org.springframework.boot.Banner接口。

19
1
import org.springframework.boot.Banner;
2
import org.springframework.core.env.Environment;
3
import java.io.PrintStream;
4
 
5
public class MyBanner implements Banner {
6
    private static final String BANNER =
7
            "  ___ ___         .__  .__          \n" +
8
                    " /   |   \\   ____ |  | |  |   ____  \n" +
9
                    "/    ~    \\_/ __ \\|  | |  |  /  _ \\ \n" +
10
                    "\\    Y    /\\  ___/|  |_|  |_(  <_> )\n" +
11
                    " \\___|_  /  \\___  >____/____/\\____/ \n" +
12
                    "       \\/       \\/                  ";
13
 
14
    @Override
15
    public void printBanner(Environment environment, Class<?> sourceClass, PrintStream out) {
16
        out.println(BANNER);
17
        out.println();
18
    }
19
}

然后在启动应用前通过SpringApplication.setBanner(…)方法进行设置。

9
1
public static void main(String[] args) {
2
    SpringApplication springApplication = new SpringApplication(DemoApplication.class);
3
    // 开打印Banner到日志(默认打印到控制台)
4
    app.setBannerMode(Banner.Mode.LOG);
5
    // 设置自定义Banner
6
    springApplication.setBanner(new MyBanner());
7
    // 启动Spring Boot
8
    springApplication.run(args);
9
}

提示：该实现类会被注册为名称叫springBootBanner的单例Bean。

3.2 指定Web环境

SpringApplication根据当前依赖环境来为你创建合适的ApplicationContext实现。

• 如果存在SpringMVC，则优先创建AnnotationConfigServletWebServerApplicationContext；

• 如果不存在SpringMVC且存在Spring WebFlux，则创建AnnotationConfigReactiveWebServerApplicationContext；

• 否则创建AnnotationConfigApplicationContext。

如果需要修改，你可以通过setWebApplicationType(WebApplicationType.Xxx)轻松覆盖它！

提示：你也可以使用spring.main.web-application-type属性来修改WEB环境或直接通过setApplicationContextClass(…)来显式指定ApplicationContext的实现！

3.3 延迟初始化

如果需要设置Bean在使用时才创建，而不是在应用程序启动期间创建，可以设置其延迟初始化，但这会延迟应用程序问题的发现。

对所有Bean进行设置，可以通过spring.main.lazy-initialization=true属性或setLazyInitialization方法来实现。

对单个Bean进行设置，可以使用@Lazy(true)注解，它将会覆盖对所有Bean上的设置。

4. 生命周期回调

4.1 SpringApplicationRunListener

SpringApplicationRunListener贯穿SpringBoot启动的全程，是最常用的干涉SpringBoot启动过程的扩展点。

42
1
public interface SpringApplicationRunListener {
2

3
    // 调用 springApplication 的 run 方法时立即调用
4
    default void starting(ConfigurableBootstrapContext bootstrapContext) {
5
    }
6

7
    // Environment 构建完成，但在创建ApplicationContext之前
8
    default void environmentPrepared(ConfigurableBootstrapContext bootstrapContext,
9
            ConfigurableEnvironment environment) {
10
    }
11

12
    // 在创建和准备 Applicationcontext之后，但在加载之前
13
    default void contextPrepared(ConfigurableApplicationContext context) {
14
    }
15

16
    // ApplicationContext已加载,但尚未刷新容器时
17
    default void contextLoaded(ConfigurableApplicationContext context) {
18
    }
19

20
    // IOC 容器已刷新，但未调用CommandLineRunners和ApplicationRunners 时
21
    default void started(ConfigurableApplicationContext context, Duration timeTaken) {
22
        started(context);
23
    }
24
    @Deprecated
25
    default void started(ConfigurableApplicationContext context) {
26
    }
27

28
    // ???
29
    default void ready(ConfigurableApplicationContext context, Duration timeTaken) {
30
        running(context);
31
    }
32

33
    // 在 run 方法彻底完成之前
34
    @Deprecated
35
    default void running(ConfigurableApplicationContext context) {
36
    }
37

38
    // run 方法执行过程中抛出异常时
39
    default void failed(ConfigurableApplicationContext context, Throwable exception) {
40
    }
41

42
}

4.2 ApplicationListener

SpringBoot 内置了 一个 SpringApplicationRunListener 的实现类 EventPublishingRunListener，用于在上下文启动时发布一些关键事件，提供给使用者干涉上下文启动过程：

• 在运行开始时，但在进行任何处理之前(侦听器和初始化器的注册除外)，发送ApplicationStartingEvent。

• 当知道要在上下文中使用的Environment时，但在创建上下文之前，发送ApplicationEnvironmentPreparedEvent。

• 在刷新开始之前，但在加载 bean 定义之后，发送ApplicationPreparedEvent。

• 在刷新上下文之后，但在调用任何应用程序和命令行运行程序之前，发送ApplicationStartedEvent。

• 调用任何应用程序和命令行运行程序后，将发送ApplicationReadyEvent。它指示应用程序已准备就绪，可以处理请求。

• 如果启动时出现异常，则会发送ApplicationFailedEvent。

如下定义了一个 ApplicationStartingEvent 事件的监听器：

7
1
public class ApplicationStartingEventListener implements ApplicationListener<ApplicationStartingEvent> {
2
    @Override
3
    public void onApplicationEvent(ApplicationStartingEvent contextRefreshedEvent) {
4
        ApplicationContext applicationContext = contextRefreshedEvent.getApplicationContext();
5
        System.out.println("==============Spring容器刷新完毕==============");
6
    }
7
}

注意，上述部分事件触发时，可能 ApplicationContext 尚未创建完成，可能需要在META-INF/spring.factories文件中注册上述创建的监听器，如下所示：

7
1
// SpringApplicationBuilder
2
new SpringApplicationBuilder(SpringApplicationApplication.class)
3
    .listeners(new ApplicationStartingEventListener()).run(args);
4

5
// spring.factories
6
org.springframework.context.Applicationlistener=\
7
    com.linkedbear.springboot.listener.ApplicationStartingEventListener

或者通过使用SpringApplication.addListeners(…)方法或SpringApplicationBuilder.listeners(…)方法注册它们。

12
1
@SpringBootApplication
2
public class MyApplication {
3
    public static void main(String[] args) {
4
        SpringApplication springApplication = new SpringApplication(MyApplication.class);
5
        springApplication.addListeners(new ApplicationStartingEventListener());
6
        springApplication.run(args);
7
    }
8
}
9

10
// SpringApplicationBuilder
11
new SpringApplicationBuilder(SpringApplicationApplication.class)
12
    .listeners(new ApplicationStartingEventListener()).run(args);

或者在application.properties文件中进行注册：

2
1
# ApplicationStartingEventListener
2
context.listener.classes=com.huangyuanxin.notes.springboot.listener.ApplicationStartingEventListener

此外，还可以通过注册为Bean的方式来注册监听器，但是部分事件是在创建ApplicationContext之前触发的，因此对应的监听器不适用。

4.3 ApplicationContextInitializer

ApplicationContextInitializer在Springboot启动过程(refresh方法前)调用，是一种更加简单的介入方式。

7
1
public class MyApplicationContextInitializer implements ApplicationContextInitializer {
2
    @Override
3
    public void initialize(ConfigurableApplicationContext applicationContext) {
4
        System.out.println("===========MyApplicationContextInitializer=========");
5
    }
6
}
7

注册方式和监听器类似，推荐在META-INF/spring.factories文件中进行注册。

3
1
# ApplicationContextInitializer
2
org.springframework.context.ApplicationContextInitializer=com.huangyuanxin.notes.springboot.initializer.MyApplicationContextInitializer
3

当然，也可以使用SpringApplication.addInitializers(…)方法、SpringApplicationBuilder.initializers(…)方法或context.initializer.classes属性注册它们。

4.4 EnvironmentPostProcessor

EnvironmentPostProcessor可用于在刷新应用程序上下文之前自定义Environment。如下示例从Classpath加载YAML配置文件：

39
1
package com.huangyuanxin.notes.springboot.environment;
2

3
import org.springframework.boot.SpringApplication;
4
import org.springframework.boot.env.EnvironmentPostProcessor;
5
import org.springframework.boot.env.YamlPropertySourceLoader;
6
import org.springframework.core.env.ConfigurableEnvironment;
7
import org.springframework.core.env.PropertySource;
8
import org.springframework.core.io.ClassPathResource;
9
import org.springframework.core.io.Resource;
10
 
11
import java.io.IOException;
12

13
public class YmlLoadEnvironmentPostProcessor implements EnvironmentPostProcessor {
14

15
    private final YamlPropertySourceLoader loader = new YamlPropertySourceLoader();
16

17
    @Override
18
    public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
19
        // 从类路径加载YML文件
20
        Resource path = new ClassPathResource("com/huangyuanxin/notes/springboot/my-config.yml");
21
        PropertySource<?> propertySource = loadYaml(path);
22

23
        // 添加在末尾，优先于其它常见的属性源
24
        environment.getPropertySources().addLast(propertySource);
25
    }
26

27
    private PropertySource<?> loadYaml(Resource path) {
28
        if (!path.exists()) {
29
            throw new IllegalArgumentException("Resource " + path + " does not exist");
30
        }
31

32
        try {
33
            return this.loader.load("my-config", path).get(0);
34
        } catch (IOException ex) {
35
            throw new IllegalStateException("Failed to load yaml configuration from " + path, ex);
36
        }
37
    }
38

39
}

同样的，你需要在META-INF/spring.factories中进行注册，而不能通过注册组件的方式来注册它。

3
1
# EnvironmentPostProcessor
2
org.springframework.boot.env.EnvironmentPostProcessor=com.huangyuanxin.notes.springboot.environment.YmlLoadEnvironmentPostProcessor
3

提示：EnvironmentPostProcessor还可以用来处理属性加密。

4.5 ApplicationRunner/CommandLineRunner

如果在SpringApplication启动的最后，需要运行一些特定的代码，可以实现ApplicationRunner或CommandLineRunner接口，两者工作方式一致，仅run方法的参数类型不同。

• ApplicationRunner

  9
  1
  @Component // 可直接通过组件注解来注册
  2
  @Order(100) // 执行顺序，越小越先执行
  3
  public class MyApplicationRunner implements ApplicationRunner {
  4
  
  5
      @Override
  6
      public void run(ApplicationArguments args) throws Exception {
  7
          System.out.println("============MyApplicationRunner=============");
  8
      }
  9
  }
  

• CommandLineRunner

  10
  1
  @Component // 可直接通过组件注解来注册
  2
  @Order(200) // 执行顺序，越小越先执行
  3
  public class MyCommandLineRunner implements CommandLineRunner {
  4
  
  5
      @Override
  6
      public void run(String... args) {
  7
          System.out.println("============MyCommandLineRunner=============");
  8
      }
  9
  }
  10
  
  

提示：你可以通过实现Ordered接口或使用@Order注解来调整其执行顺序，值越大越后执行。

5. 获取命令行参数

如果需要访问启动时的命令行参数，可以通过注入org.springframework.boot.ApplicationArguments来获取。

24
1
@Component
2
public class ApplicationArgumentsTest {
3
    @Autowired
4
    private ApplicationArguments applicationArguments;
5

6
    @PostConstruct
7
    public void init() {
8
        // 1. 获取所有原始参数
9
        String[] sourceArgs = applicationArguments.getSourceArgs();
10

11
        // 2. 获取所有option参数及其值(--开头的参数)
12
        Set<String> optionNames = applicationArguments.getOptionNames();
13
        for (String optionName : optionNames) {
14
            List<String> optionValues = applicationArguments.getOptionValues(optionName);
15
        }
16

17
        // 3. 判断是否包含某个option参数
18
        boolean debug = applicationArguments.containsOption("debug");
19

20
        // 4. 获取所有非option参数
21
        List<String> nonOptionArgs = applicationArguments.getNonOptionArgs();
22
    }
23
}
24

除此之外，SpringBoot还向容器注册了一个CommandLinePropertySource。这样就可以使用@Value注解直接注入单个应用程序参数。

6. 关闭SpringApplication

每个应用在启动时都会向JVM注册一个关闭钩子，以确保在退出时正常关闭，保证所有标准的Spring生命周期回调如期生效。

另外，如果希望在调用SpringApplication.exit()时返回特定的退出代码，则可以实现ExitCodeGenerator接口，然后可以将此退出代码传递给System.exit()，以将其作为状态代码返回，如以下示例所示：

18
1
@SpringBootApplication
2
public class MyApplication {
3
    public static void main(String[] args) {
4
        // 创建和启动
5
        SpringApplication springApplication = new SpringApplication(MyApplication.class);
6
        ConfigurableApplicationContext context = springApplication.run(args);
7

8
        // 关闭应用
9
        System.exit(SpringApplication.exit(context));
10
    }
11

12
    // 设置上下文退出代码
13
    @Bean
14
    public ExitCodeGenerator exitCodeGenerator() {
15
        return () -> 42;
16
    }
17
}
18

此外，ExitCodeGenerator接口可能会通过异常实现。遇到此类异常时，Spring Boot 将返回已实现的getExitCode()方法提供的退出代码。

第二节 外部化属性配置

SpringBoot支持使用Properties文件、YAML文件、环境变量和命令行参数等多种方式来配置外部属性，并使用Environment进行统一管理，然后通过@Value注解注入到Bean，或通过@ConfigurationProperties注解绑定到结构化对象后使用。

1. 加载顺序

SpringBoot从不同来源加载的外部属性允许被覆盖，它们之间的优先级如下：

1. 主目录($HOME)中Devtools配置的全局属性(位于~/.spring-boot-devtools.properties)。

2. 通过@TestPropertySource等测试相关注解配置的属性。

3. 命令行参数。

4. SPRING_APPLICATION_JSON中配置的属性。

5. 来自Web环境的属性：ServletConfig的初始化参数、ServletContext的初始化参数和来自java:comp/env的JNDI属性。

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

7. 系统环境变量。

8. 通过RandomValuePropertySource生成随机值的属性(属性值为random.*前缀)。

9. 特定Profile的配置文件(application-{profile}.properties或类似YAML)(Jar包外部的优先)。

10. 默认配置文件(application.properties或类似YAML)(Jar包外部的优先)。

11. @Configuration类上的@PropertySource注解加载的配置文件。

12. 通过SpringApplication.setDefaultProperties指定的默认属性。

2. 属性配置

2.1 命令行参数

SpringBoot会将任何命令行选项参数(以--开头)或JVM属性(以-D开头)添加到Environment中，如下所示：

1
1
java -jar my-app.jar --name="Spring" --server.port=9000

小提示：

1. 可以使用SpringApplication.setAddCommandLineProperties(false)禁用此默认行为。

2. 可以在属性值中使用占位符来减短属性长度，如属性server.port=${port:8080}，只需通过--port=9000配置即可。

2.2 SPRING_APPLICATION_JSON

SPRING_APPLICATION_JSON是通过命令行参数、系统变量、环境属性等其它方式配置的内联JSON，SpringBoot会对其进行展开，提取JSON配置的属性。使用系统变量的配置方式如下：

其它配置方式可参考如下示例：

9
1
# JVM属性
2
java -Dspring.application.json='{"name":"test"}' -jar myapp.jar。
3

4
# 命令行参数
5
java -jar myapp.jar --spring.application.json='{"name":"test"}'。
6

7
# 环境属性
8
java:comp/env/spring.application.json
9

2.3 随机值属性

SpringBoot提供了RandomValuePropertySource类用于支持随机值的配置，类型可以是int、long、uuid或字符串等，示例如下：

6
1
# 随机字符串、整型、长整型、UUID
2
my.secret=${random.value}
3
my.number=${random.int}
4
my.bignumber=${random.long}
5
my.uuid=${random.uuid}
6

其中random.int和random.long属性支持一个范围后缀，其语法为：OPEN value (,max) CLOSE，其中OPEN和CLOSE可以是任何字符，max是整数。如果提供了max，则value是最小值，max是最大值(不含)。

4
1
# 带范围的随机值
2
my.number.less.than.ten=${random.int(10)}
3
my.number.in.range=${random.int[1024,65536]}
4

2.4 特定Profile的配置文件

Profiles是一种策略式的组件或配置文件的加载方式，可以方便的切换不同的环境配置，使用时分为标记和激活两个步骤。

• 标记

对于Spring组件可以使用@Profile注解进行标记：

4
1
@Configuration
2
@Profile("prod") // 标记为prod环境
3
public class ProductionConfiguration {
4
}

对于多个配置文件，可通过属性文件名-profile的方式来标记：

4
1
application.properties
2
application-dev.properties
3
application-test.properties
4
application-prod.properties

对于YML分段文件，可以使用spring.profiles属性来标记：

18
1
server:
2
    port: 8080
3
spring:
4
    profiles:
5
        active: dev    # 激活配置
6
---
7
# 开发环境
8
server:
9
    port: 8081
10
spring:
11
    profiles: dev
12
---
13
# 生产环境
14
server:
15
    port: 8083
16
spring:
17
    profiles: prod & eu-central
18
    

• 激活

可以通过spring.profiles.active属性来指定需激活的profile列表，该属性可以配置在属性文件中：

1
1
spring.profiles.active=dev,hsqldb

也可以在命令行上指定它：

1
1
java -jar my-app.jar --Dspring.profiles.active=dev,hsqldb

提示：该属性可以被覆盖，这意味着您可以在属性文件中指定默认的active配置，然后使用命令行开关“替换”它们。

• 附加

有时候，不需要对整个active属性进行替换，而是在此基础上附加一些额外的profile，可以使用spring.profiles.include属性。

10
1
---
2
my.property: fromyamlfile
3

4
---
5
# prod策略，并且级联激活proddb、prodmq策略
6
spring.profiles: prod
7
spring.profiles.include:
8
  - proddb
9
  - prodmq
10

除此之外，也可以使用编程的方式实现：

1
1
SpringApplication.setAdditionalProfiles(…)

2.5 默认配置文件

SpringBoot使用application.properties/application.yaml/application.yml(按优先级从高到低排序)作为默认的属性配置文件，将会从下列路径依次加载，后加载的同名属性会将之前的值覆盖。

• 1. ClassPath根目录。

• 2. ClassPath/config包。

• 3. Jar包执行的当前目录。

• 4. Jar包执行的当前目录/config子目录。

如果想修改默认属性文件名，可以使用spring.config.name进行指定。

3
1
# 指定默认的属性配置文件名为myapplication.properties/myapplication.yaml/myapplication.yml
2
java -jar myproject.jar --spring.config.name=myapplication
3

如果想修改默认加载目录，可以使用spring.config.location指定或通过spring.config.additional-location进行附加。

6
1
# 指定属性文件加载目录，加载的顺序从后往前(注意：支持特定于Profiles的变体)
2
java -jar myproject.jar --spring.config.location=classpath:/,classpath:/config/,file:./,file:./config/
3

4
# 附加属性文件加载目录，加载的顺序从后往前(注意：1. 支持特定于Profiles的变体。2. 附加目录优先加载，可能被默认目录下的值覆盖)
5
java -jar myproject.jar --spring.config.location=classpath:/,classpath:/config/,file:./,file:./config/
6

如果想同时指定加载目录和属性文件名，也可以使用spring.config.location属性：

3
1
# 显式指定路径下的某些文件(注意：不支持特定于Profiles件的变体)
2
java -jar myproject.jar --spring.config.additional-location=classpath:/custom-config/,file:./custom-config/
3

注意：

1. 由于上述属性在加载属性文件之前被使用，因此你必须使用系统变量、系统属性或命令行参数等高优先级的配置方式。

2. 大多操作系统不支持使用句点分隔的环境变量名，你可以使用下划线形式代替(例如：SPRING_CONFIG_NAME)。

2.6 其它配置文件

SpringBoot默认从application.properties文件加载属性配置，如果存在其它properties类型的配置文件，可以通过@PropertySource注解来加载。示例如下：

4
1
@Configuration
2
@PropertySource(value = {"com/huangyuanxin/notes/springboot/my-config.properties"})
3
public class LoadPropertiesConfig {
4
}

2.7 YML格式简介

YAML是JSON的超集，是一种用于指定层次结构配置数据的便捷格式，非常适合用来做以数据为中心的配置文件。spring-boot-starter自动引入了SnakeYAML库用于支持yaml格式，其基本语法如下：

• 数据格式为key: value，大小写敏感，并且kv之间必须有空格。

• 使用缩进表示层级关系，且缩进不允许使用tab，只允许空格。

• 缩进的空格数不重要，只要相同层级的元素左对齐即可。

• 注释行使用'#'开头，注意不支持行尾注释。

• 字符串可以不加引号，如果要加，''与""分别表示字符串内容会被转义和不转义。

• 可以使用---对文件进行分段，将多个YML文件整合为一个。

下面是使用yaml配置不同类型数据的语法格式：

21
1
# 1. 字面量类型：单个不可再分的值，如date、boolean、string、number、null等。
2
k: v
3

4
---
5

6
# 2. 对象类型：键值对的集合，如object、map、hash、set等。
7
k: {k1:v1,k2:v2,k3:v3}
8
k: 
9
  k1: v1
10
  k2: v2
11
  k3: v3
12

13
---
14

15
# 3. 数组类型：一组按次序排列的值，如array、list、queue等。
16
k: [v1,v2,v3]
17
k:
18
 - v1
19
 - v2
20
 - v3
21

具体案例可参考属性注入和绑定章节！

3. 属性注入和绑定

3.1 通过@Value("${Xxx}")注入

6
1
// 注入Environment中的spring.application.name属性
2
@RestController
3
public class HelloController {
4
    @Value("${spring.application.name}")
5
    private String appName;
6
}

注意：

1. 该注解不能在静态变量和常量上使用！

3.2 绑定到属性Bean

SpringBoot提供了@ConfigurationProperties注解将属性配置与强类型的JavaBean进行绑定，并且支持宽松的绑定格式、属性值转换、属性值验证及元数据提示等，使用起来更加方便。

有如下一个YML配置文件，已通过YmlLoadEnvironmentPostProcessor(见第二章节)进行加载：

27
1
# 配置person
2
person:
3
  userName: zhangsan
4
  boss: false
5
  birth: 2019/12/12 20:12:33
6
  age: 18
7
  pet: 
8
    name: tomcat
9
    weight: 23.4
10
  interests: [篮球,游泳]
11
  animal: 
12
    - jerry
13
    - mario
14
  score:
15
    english: 
16
      first: 30
17
      second: 40
18
      third: 50
19
    math: [131,140,148]
20
    chinese: {first: 128,second: 136}
21
  salarys: [3999,4999.98,5999.99]
22
  allPets:
23
    sick:
24
      - {name: tom}
25
      - {name: jerry,weight: 47}
26
    health: [{name: mario,weight: 47}]
27

我们可以通过如下JavaBean进行属性绑定，绑定后可直接通过容器中的PersonProperty实例使用绑定属性。

25
1
@Component
2
@ConfigurationProperties(prefix = "person")
3
public class PersonProperty {
4
    private String userName;
5
    private Boolean boss;
6
    private Date birth;
7
    private Integer age;
8
    private Pet pet;
9
    private String[] interests;
10
    private List<String> animal;
11
    private Map<String, Object> score;
12
    private Set<Double> salarys;
13
    private Map<String, List<Pet>> allPets;
14

15
    // getter/setter/toString...
16
    }
17

18
    static class Pet {
19
        private String name;
20
        private float weight;
21

22
        // getter/setter/toString...
23
    }
24
}
25

提示：@ConfigurationProperties有一些属性可以控制绑定时的行为。

• ignoreUnknownFields：默认为true，如果设置为false，则在属性文件中提供了属性类没有的属性时报错。

• ignoreInvalidFields：默认为false，如果设置为true，则在属性绑定失败时不报错。

如果该Bean不是Spring组件，则在必须在其它Spring组件上使用@EnableConfigurationProperties(Person.class)注解将其拉起。

5
1
@Configuration
2
@EnableConfigurationProperties(PersonProperty.class)
3
public class MyConfiguration {
4
}
5

属性Bean以属性前缀-全类名作为Bean名称，如果未配置属性前缀，则Bean名称为全类名。可以像使用其他任何Bean一样注入该属性Bean并使用，如构造函数注入、@Bean方法注入、@Autowird注入等。

9
1
@Service
2
public class MyService {
3
    private PersonProperty personProperty;
4

5
    @Autowired
6
    public MyService(PersonProperty personProperty) {
7
        this.personProperty = personProperty;
8
    }
9
}

注意：

1. 必须为配置的属性提供相关的getter/setter方法及默认构造函数，但二级属性等除外。

2. 不支持对静态属性进行绑定。

3. 使用@ConfigurationProperties还可让您生成元数据文件，IDE可以使用这些元数据文件为提供配置提示。

3.2 注入到第三方组件

如果需要将属性绑定到不可修改的第三方组件等，可以在@Bean方法上加@ConfigurationProperties注解来实现：

11
1
@Configuration
2
public class JdbcConfiguration {
3
    
4
    @Bean
5
    // 声明要注入的属性前缀，SpringBoot会自动把相关属性通过set方法注入到DataSource中
6
    @ConfigurationProperties(prefix = "jdbc")
7
    public DataSource dataSource() {
8
        DruidDataSource dataSource = new DruidDataSource();
9
        return dataSource;
10
    }
11
}

3.3 宽松的绑定规则

SpringBoot使用一些宽松的规则将加载的属性绑定到属性Bean，因此属性名称和Bean中的属性名不需要完全匹配。如下示例：

12
1
@ConfigurationProperties(prefix="acme.my-project.person")
2
public class OwnerProperties {
3
    private String firstName;
4

5
    public String getFirstName() {
6
        return this.firstName;
7
    }
8

9
    public void setFirstName(String firstName) {
10
        this.firstName = firstName;
11
    }
12
}

可以使用下列一些方式来配置firstName的属性值：

12
1
# 标准驼峰写法
2
acme.myProject.person.firstName
3

4
# 烤肉串(Kebab)形式，推荐在properties和yml文件中使用
5
acme.my-project.person.first-name
6

7
# 下划线形式，也推荐在properties和yml文件中使用
8
acme.my_project.person.first_name
9

10
# 大写下划线形式，一般在系统环境变量中使用
11
ACME_MYPROJECT_PERSON_FIRSTNAME
12

注意：

1. 前提：@ConfigurationProperties注解中的prefix属性必须是小写且由-分隔的形式，如acme.my-project.person。

2. 属性名建议使用小写的 kebab 格式存储，例如my.property-name=acme。

3. 如需在环境变量中配置列表数据，可以使用带下划线的数字值表示，如MY_ACME_1_OTHER = my.acme[1].other。

4. 绑定到Map属性时，如果key包含小写字母、数字字符或-以外的任何内容，则必须使用[]括起来，否则将会被删除。

   5
   1
   # 如下Map的配置效果为：/key1=value1，key2：value2
   2
   acme:
   3
     map:
   4
       "[/key1]": value1
   5
       /key2: value2
   

4. 属性覆盖与合并

默认情况下，SpringBoot会直接覆盖旧的属性值，但对于复杂类型，做了一些特殊处理。

• List类型属性

如果在多个属性源配置了同名的List属性，处理方式和基本属性一致，采用完全覆盖的方式，取优先级最高的配置。如下属性：

9
1
@ConfigurationProperties("acme")
2
public class AcmeProperties {
3
    private final List<MyPojo> list = new ArrayList<>();
4

5
    public List<MyPojo> getList() {
6
        return this.list;
7
    }
8
}
9

在外部属性源存在多个list的配置如下：

11
1
acme:
2
  list:
3
    - name: my name
4
      description: my description
5
---
6
spring:
7
  profiles: dev
8
acme:
9
  list:
10
    - name: my another name
11

最终生效情况如下：

9
1
# 情形一：未激活dev
2
list:
3
  - name: my name
4
    description: my description
5

6
# 情形二：激活dev
7
list:
8
  - name: my another name
9