Spring Boot文档翻译【转】

目录

Part I.Spring Boot文档

本节简要介绍Spring Boot参考文档

1.关于这个文档

Spring参考文档可以通过如下三种途径获得：

1. Html
2. PDF
3. EPUB

注：考虑到大家翻墙问题，我准备了一份PDF，通过百度云盘分享的方式。

2.获得帮助

如果您在使用Spring Boot中遇到困难，我们希望能够提供帮助：

• 尝试使用How to文档。它们提供常规的解决方法。
• 学习Spring的基础知识，Spring Boot建立在它们之上。查阅Spring.io网站获取丰富的资料。
• 在StackOverflow提问，我们监视Spring-Boot为标签的问题。
• 在github.com/spring-projects/spring-boot/issues上报告错误。

3.第一步

如果您正在开始使用Spring Boot或“Spring”，请从以下主题开始：

从头开始：概览| 要求| 安装
教程：第1部分| 第2部分
运行您的示例：第1部分| 第2部分

4.使用Spring Boot

准备好真正开始使用Spring Boot？ 我们涵盖如下知识：

构建系统：Maven | Gradle | ant|Starters
最佳实践：代码结构| @Configuration | @EnableAutoConfiguration | bean以及相关依赖注入
运行您的代码IDE |Packaged | Maven | Gradle
打包你的应用程序：生产Jar
Spring Boot CLI：使用CLI

5.学习Spring Boot特性

需要更多关于Spring Boot核心功能的细节？ 以下内容适合您：

核心特性：SpringApplication | 外部配置| 配置文件|日志
Web应用程序：MVC | 嵌入式容器
使用数据：SQL |NO-SQL
消息：概述|JMS
测试：概述| 启动应用程序|utils
扩展：自动配置| @条件

6.转向生产

当你准备把你的Spring Boot应用程序投入生产时，我们有一些你可能会喜欢的技巧：

管理端点：概览|定制
连接选项：HTTP |JMX
监测：指标| 审计| 追踪| 处理

7.高级主题

最后，我们有更多高级用户的一些话题：

Spring Boot应用程序部署：云部署| OS服务
构建工具插件：Maven |gradle
附录：应用程序属性| 自动配置类| 可执行的jars

Part II.入门

如果您正在开始使用Spring Boot，或者一般情况下使用“Spring”，请先阅读本节。 它回答了基本的“什么？”，“如何？”和“为什么？”的问题。 它包括一个Spring Boot的介绍，以及安装说明。 然后，我们将引导您构建您的第一个Spring Boot应用程序，并讨论一些核心原则。

8.介绍Spring Boot

Spring Boot使您可以轻松创建可以运行的独立的，生产级的基于Spring的应用程序。我们对Spring平台和第三方库有一个自己的看法，这样你就可以用最小的麻烦开始。大多数Spring Boot应用程序只需要很少的Spring配置。

您可以使用Spring Boot来创建可以使用java -jar或更传统的war部署启动的Java应用程序。我们还提供了一个运行“春天脚本”的命令行工具。

我们的主要目标是：

为所有Spring开发提供一个更快，更广泛的入门体验。
开箱即用，但是随着需求开始偏离默认值，快速退出。
提供大量项目（如嵌入式服务器，安全性，指标，运行状况检查和外部配置）通用的一系列非功能性功能。
绝对不会生成代码，也不需要XML配置。

9.系统要求

Spring Boot 2.0.0.BUILD-SNAPSHOT需要Java 8和Spring Framework 5.0.2.RELEASE或更高版本。 为Maven 3.2+和Gradle 4提供了明确的构建支持。

9.1.Servlet容器

开箱即用支持以下嵌入式servlet容器：

您也可以将Spring Boot应用程序部署到任何与Servlet 3.0+兼容的容器。

10.安装Spring Boot

Spring Boot可以与“经典”的Java开发工具一起使用，也可以作为命令行工具安装。 无论哪种方式，您都需要Java SDK v1.8或更高版本。 在开始之前，您应该使用以下命令检查当前的Java安装版本：

$ java -version

如果您对Java开发不熟悉，或者想要尝试Spring Boot，则可能需要先尝试Spring Boot CLI（命令行界面），否则请阅读“经典”安装说明。

10.1 Java开发人员的安装说明

您可以像使用任何标准Java库一样使用Spring Boot。 为此，请在类路径中包含相应的spring-boot - *.jar文件。 Spring Boot不需要任何特殊的工具集成，因此您可以使用任何IDE或文本编辑器。 此外，Spring Boot应用程序没有什么特别之处，所以您可以像运行其他任何Java程序一样运行和调试Spring Boot应用程序。

尽管您可以复制Spring Boot 的jar包，但我们通常建议您使用支持依赖管理的构建工具（如Maven或Gradle）。

10.1.1 Maven安装

Spring Boot与Apache Maven 3.2或更高版本兼容。 如果您还没有安装Maven，可以按照https://maven.apache.org/上的说明进行操作。

注：在许多操作系统上，Maven可以安装一个包管理器。 如果您使用OSX Homebrew，请尝试brew install maven。 Ubuntu用户可以运行sudo apt-get install maven。 具有Chocolatey的Windows用户可以从提升（管理员）提示符运行choco install maven。

Spring Boot依赖使用org.springframework.boot groupId。 通常，您的Maven POM文件从spring-boot-starter-parent项目继承，并将依赖关系声明为一个或多个“Starter”。 Spring Boot还提供了一个可选的Maven插件来创建可执行的jar文件。

以下列表显示了一个典型的pom.xml文件：

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

    <groupId>com.example</groupId>
    <artifactId>myproject</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <!-- Inherit defaults from Spring Boot -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.BUILD-SNAPSHOT</version>
    </parent>

    <!-- Add typical dependencies for a web application -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <!-- Package as an executable jar -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <!-- Add Spring repositories -->
    <!-- (you don't need this if you are using a .RELEASE version) -->
    <repositories>
        <repository>
            <id>spring-snapshots</id>
            <url>http://repo.spring.io/snapshot</url>
            <snapshots><enabled>true</enabled></snapshots>
        </repository>
        <repository>
            <id>spring-milestones</id>
            <url>http://repo.spring.io/milestone</url>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>spring-snapshots</id>
            <url>http://repo.spring.io/snapshot</url>
        </pluginRepository>
        <pluginRepository>
            <id>spring-milestones</id>
            <url>http://repo.spring.io/milestone</url>
        </pluginRepository>
    </pluginRepositories>
</project>

注：有时您可能需要从不同的父POM继承，或者您可能不喜欢我们的默认设置 在这些情况下，请参见第13.2.2节“使用不带父项的Spring Boot”，以获得使用import scope的替代解决方案。

10.1.2 Gradle安装

Spring Boot与Gradle 4兼容。如果您没有安装Gradle，您可以按照www.gradle.org上的说明进行操作。

Spring Boot依赖可以通过使用org.springframework.boot组声明，Spring Boot提供了一个有用的Gradle插件，可以用来简化依赖声明和创建可执行的jar。

Gradle Wrapper
当您需要构建项目时，Gradle Wrapper提供了一个“获取”Gradle的好方法。 这是一个小脚本和库，与代码一起提交来引导构建过程。 有关详细信息，请参阅docs.gradle.org/4.2.1/userguide/gradle_wrapper.html。

以下示例显示了一个典型的build.gradle文件：

buildscript {
    repositories {
        jcenter()
        maven { url 'http://repo.spring.io/snapshot' }
        maven { url 'http://repo.spring.io/milestone' }
    }
    dependencies {
        classpath 'org.springframework.boot:spring-boot-gradle-plugin:2.0.0.BUILD-SNAPSHOT'
    }
}

apply plugin: 'java'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'

jar {
    baseName = 'myproject'
    version =  '0.0.1-SNAPSHOT'
}

repositories {
    jcenter()
    maven { url "http://repo.spring.io/snapshot" }
    maven { url "http://repo.spring.io/milestone" }
}

dependencies {
    compile("org.springframework.boot:spring-boot-starter-web")
    testCompile("org.springframework.boot:spring-boot-starter-test")
}

10.2安装Spring Boot CLI

Spring Boot CLI（命令行界面）是一个命令行工具，您可以使用它来快速使用Spring进行原型开发。 它可以让你运行Groovy脚本，这意味着你有一个熟悉的类Java语法，没有太多的样板代码。

您不需要使用CLI来与Spring Boot一起工作，但这绝对是让Spring应用程序起飞的最快捷方式。

10.2.1手动安装

您可以从Spring软件存储库下载Spring CLI发行版：

• spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin.zip
• spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin.tar.gz

最前沿的分布式快照也是可用的。

下载之后，请按照解压缩归档中的INSTALL.txt说明进行操作。 总之，在.zip文件的bin /目录中有一个spring脚本（用于Windows的spring.bat）。 或者，您可以使用带有.jar文件的java -jar（该脚本可以帮助您确保正确设置类路径）。

10.2.2使用SDKMAN安装！

SDKMAN！ （软件开发工具包管理器）可用于管理各种二进制SDK的多个版本，包括Groovy和Spring Boot CLI。 获取SDKMAN！ 从sdkman.io安装Spring Boot并使用以下命令：

$ sdk install springboot
$ spring --version
Spring Boot v2.0.0.BUILD-SNAPSHOT

如果您正在开发CLI的功能，并希望轻松访问您构建的版本，请使用以下命令：

$ sdk install springboot dev /path/to/spring-boot/spring-boot-cli/target/spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin/spring-2.0.0.BUILD-SNAPSHOT/
$ sdk default springboot dev
$ spring --version
Spring CLI v2.0.0.BUILD-SNAPSHOT

前面的说明安装了一个名为dev实例的spring的本地实例。 它指向你的目标构建位置，所以每当你重建Spring Boot时，spring都是最新的。

您可以通过运行以下命令来查看它：

$ sdk ls springboot

================================================================================
Available Springboot Versions
================================================================================
> + dev
* 2.0.0.BUILD-SNAPSHOT

================================================================================
+ - local version
* - installed
> - currently in use
================================================================================

10.2.3 OSX Homebrew安装

如果您在Mac上并使用Homebrew，则可以使用以下命令来安装Spring Boot CLI：
Homebrew 安装 spring 到 /usr/local/bin.

注：如果您没有看到该公式，那么您的brew的安装可能会过期。 在这种情况下，运行brew更新并重试。

10.2.4 MacPorts安装

如果您在Mac上并使用MacPorts，则可以使用以下命令安装Spring Boot CLI：

$ sudo port install spring-boot-cli

10.2.5命令行完成

Spring Boot CLI包含为BASH和zsh shell提供命令完成的脚本。 您可以在任何shell中获取脚本（也称为spring），或者将其放入您的个人或系统范围的bash完成初始化中。 在Debian系统上，系统范围的脚本在/ shell-completion / bash中，当一个新的shell启动时，该目录中的所有脚本都会被执行。 例如，如果您使用SDKMAN！安装了手动脚本，请使用以下命令：

$ . ~/.sdkman/candidates/springboot/current/shell-completion/bash/spring
$ spring <HIT TAB HERE>
  grab  help  jar  run  test  version

注：如果使用Homebrew或MacPorts安装Spring Boot CLI，则命令行完成脚本会自动注册您的shell。

10.2.6快速启动Spring CLI示例

您可以使用以下Web应用程序来测试您的安装。 首先，创建一个名为app.groovy的文件，如下所示：

@RestController
class ThisWillActuallyRun {

    @RequestMapping("/")
    String home() {
        "Hello World!"
    }

}

然后从shell中运行它，如下所示：

$ spring run app.groovy

注：由于依赖的库需要下载，第一次运行会比较慢。

打开 localhost:8080在您喜欢的浏览器中. 您将看到如下输出:

Hello World!

10.3从较早版本的Spring Boot升级

如果您是从早期版本的Spring Boot进行升级，请查看项目wiki上托管的“发行说明”。 您会发现升级说明以及每个版本的“新功能”和“值得注意”功能列表。

要升级现有的CLI安装，请使用相应的package manager命令（例如，brew升级），或者如果您手动安装了CLI，请按照标准说明记住更新PATH环境变量以删除任何旧的引用。

11.开发你的第一个Spring Boot应用程序

本节介绍如何开发一个简单的“Hello World！”Web应用程序，该应用程序突出了Spring Boot的一些主要功能。 我们使用Maven来构建这个项目，因为大多数IDE都支持它。

注：spring.io网站包含许多使用Spring Boot的“入门指南”。 如果您需要解决特定问题，请先在那里查看。
您可以通过转到start.spring.io并从依赖关系搜索器中选择“Web”起始器来快速执行以下步骤。 这样做会产生一个新的项目结构，以便您可以立即开始编码。 查看Spring Initializr文档以获取更多详细信息。

在开始之前，请打开终端并运行以下命令以确保您已安装了Java和Maven的有效版本：

$ java -version
java version "1.8.0_102"
Java(TM) SE Runtime Environment (build 1.8.0_102-b14)
Java HotSpot(TM) 64-Bit Server VM (build 25.102-b14, mixed mode)

$ mvn -v
Apache Maven 3.3.9 (bb52d8502b132ec0a5a3f4c09453c07478323dc5; 2015-11-10T16:41:47+00:00)
Maven home: /usr/local/Cellar/maven/3.3.9/libexec
Java version: 1.8.0_102, vendor: Oracle Corporation

此示例需要在其自己的文件夹中创建。 后续的说明假定你已经创建了一个合适的文件夹，并且它是你的“当前目录”。(windows环境下 提供Path路径即可)

11.1创建POM

我们需要从创建一个Maven pom.xml文件开始。 pom.xml是用来构建项目的配方。 打开你最喜欢的文本编辑器并添加以下内容：

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

    <groupId>com.example</groupId>
    <artifactId>myproject</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.BUILD-SNAPSHOT</version>
    </parent>

    <!-- Additional lines to be added here... -->

    <!-- (you don't need this if you are using a .RELEASE version) -->
    <repositories>
        <repository>
            <id>spring-snapshots</id>
            <url>http://repo.spring.io/snapshot</url>
            <snapshots><enabled>true</enabled></snapshots>
        </repository>
        <repository>
            <id>spring-milestones</id>
            <url>http://repo.spring.io/milestone</url>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>spring-snapshots</id>
            <url>http://repo.spring.io/snapshot</url>
        </pluginRepository>
        <pluginRepository>
            <id>spring-milestones</id>
            <url>http://repo.spring.io/milestone</url>
        </pluginRepository>
    </pluginRepositories>
</project>

上面的列表应该给你一个工作构建。 你可以通过运行mvn软件包来测试它（现在，你可以忽略“jar将是空的 - 没有内容被标记为包含！”警告）。

注：此时，您可以将项目导入IDE（大多数现代Java IDE包含对Maven的内置支持）。 为了简单起见，我们继续在这个例子中使用纯文本编辑器。

11.2添加类路径依赖关系

Spring Boot提供了许多“入门”，可以让您将jar添加到类路径中。 我们的示例应用程序已经在POM的父节点中使用了spring-boot-starter-parent。 spring-boot-starter-parent是一个特别的启动器，提供了有用的Maven默认值。 它还提供了一个依赖管理部分，以便您可以省略版本标记以获得“有福”的依赖关系。

其他“Starter”提供了在开发特定类型的应用程序时可能需要的依赖关系。 由于我们正在开发一个Web应用程序，因此我们添加了一个spring-boot-starter-web依赖项。 在此之前，我们可以通过运行以下命令来查看我们目前的状态：

$ mvn dependency:tree

[INFO] com.example:myproject:jar:0.0.1-SNAPSHOT

mvn依赖项：tree命令打印项目依赖项的树形表示。 你可以看到spring-boot-starter-parent本身不提供依赖关系。 要添加必要的依赖关系，请编辑您的pom.xml，并在父节点下方添加spring-boot-starter-web依赖项：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

如果再次运行mvn dependency：tree，则会看到现在有很多附加依赖项，包括Tomcat Web服务器和Spring Boot本身。

11.3编写代码

为了完成我们的应用程序，我们需要创建一个Java文件。 默认情况下，Maven从src / main / java编译源代码，因此您需要创建该文件夹结构，然后添加名为src / main / java / Example.java的文件以包含以下代码：

import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.web.bind.annotation.*;

@RestController
@EnableAutoConfiguration
public class Example {

    @RequestMapping("/")
    String home() {
        return "Hello World!";
    }

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

}

虽然这里没有太多的代码，但还是有很多重要的事在里头。 我们将在接下来的几节中介绍一些重要的部分。

11.3.1 @RestController和@RequestMapping注解

我们的Example类的第一个注解是@RestController。 这被称为stereotype注解。 它为阅读代码的人提供了线索，对于Spring来说，这个类扮演着特定的角色。 在这种情况下，我们的类是一个web @Controller，所以Spring在处理传入的Web请求时会考虑它。

@RequestMapping注解提供了“路由”信息。 它告诉Spring，任何带有/ path的HTTP请求都应该映射到home方法。@RestController注解告诉Spring将结果字符串直接返回给调用者。

注：stereotype含义:
表示类型或方法在整体架构中的角色（在概念层面而不是实施层面）。

@RestController和@RequestMapping注解是Spring MVC注解（它们不是Spring Boot特有的）。 有关更多详细信息，请参阅Spring参考资料中的MVC部分。

11.3.2 @EnableAutoConfiguration注解

第二个类级注解是@EnableAutoConfiguration。 这个注解告诉Spring Boot根据你添加的jar依赖来“猜测”你将如何配置Spring。 由于spring-boot-starter-web添加了Tomcat和Spring MVC，所以自动配置会假定你正在开发一个Web应用程序并相应地设置Spring。

入门和自动配置
自动配置旨在与“启动器”配合使用，但这两个概念并不直接相关。 您可以自由选择和选择初学者之外的jar依赖项，并且Spring Boot将尽其所能地自动配置您的应用程序。

11.3.3 “main” 方法

我们的应用程序的最后一部分是主方法。 这只是一个遵循Java约定的应用程序入口点的标准方法。 我们的主要方法通过调用run来委托Spring Boot的SpringApplication类。 SpringApplication将引导我们的应用程序，从Spring开始，它将启动自动配置的Tomcat Web服务器。 我们需要将Example.class作为参数传递给run方法，以告知SpringApplication是Spring的主要组件。 args数组也被传递以暴露任何命令行参数。

11.4运行示例

在这一点上我们的应用程序应该工作 由于我们使用了spring-boot-starter-parent POM，所以我们有一个有用的运行目标，我们可以使用它来启动应用程序。 键入mvn spring-boot：从根项目目录运行以启动应用程序：

$ mvn spring-boot:run

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v1.5.9.RELEASE)
....... . . .
....... . . . (log output here)
....... . . .
........ Started Example in 2.222 seconds (JVM running for 6.514)

如果你打开一个web浏览器到localhost：8080你应该看到下面的输出：

Hello World!

要正常退出应用程序点击ctrl-c。

11.5创建一个可执行的jar

让我们通过创建一个完全独立的可执行jar文件来完成我们的例子，我们可以在生产环境中运行它。 可执行jar（有时也称为“fat jars”）是包含您编译的类以及您的代码需要运行的所有jar依赖项的归档文件。

可执行的jar和Java

Java不提供任何标准的方式来加载嵌套的jar文件（即jar文件本身包含在jar中）。 如果您正在分发自包含的应用程序，这可能会有问题。

为了解决这个问题，许多开发者使用“超级”罐子。 超级罐子只是将所有罐子里的所有类打包成一个单一的档案。 这种方法的问题在于，很难在应用程序中看到实际使用的库。 如果在多个罐子中使用相同的文件名（但是具有不同的内容），则也可能是有问题的。

Spring Boot采用了不同的方法，可以直接嵌入jar。

要创建一个可执行的jar文件，我们需要将spring-boot-maven-plugin添加到我们的pom.xml。 在依赖关系部分下面插入以下几行：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

注：spring-boot-starter-parent POM包含配置来绑定重新打包目标。 如果您不使用父POM，则需要自行声明此配置。 有关详细信息，请参阅插件文档。

保存你的pom.xml并从命令行运行mvn包：

$ mvn package

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building myproject 0.0.1-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] .... ..
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ myproject ---
[INFO] Building jar: /Users/developer/example/spring-boot-example/target/myproject-0.0.1-SNAPSHOT.jar
[INFO]
[INFO] --- spring-boot-maven-plugin:1.5.9.RELEASE:repackage (default) @ myproject ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

如果您查看目标目录，则应该看到myproject-0.0.1-SNAPSHOT.jar。 该文件大小应该在10 MB左右。 如果你想查阅里面的内容，你可以使用jar tvf：

$ jar tvf target/myproject-0.0.1-SNAPSHOT.jar

您还应该在目标目录中看到一个名为myproject-0.0.1-SNAPSHOT.jar.original的小得多的文件。 这是Maven在被Spring Boot重新包装之前创建的原始jar文件。

要运行该应用程序，请使用java -jar命令：

$ java -jar target/myproject-0.0.1-SNAPSHOT.jar

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v1.5.9.RELEASE)
....... . . .
....... . . . (log output here)
....... . . .
........ Started Example in 2.536 seconds (JVM running for 2.864)

像以前一样，要优雅地退出应用程序点击ctrl-c。

12.接下来读什么

希望本节为您提供了一些Spring Boot的基础知识，并帮助您编写自己的应用程序。 如果您是面向任务的开发人员，则可能需要跳至spring.io，并查看一些入门指南，以解决具体的“如何使用Spring”问题; 我们也有Spring Boot特定的操作指南文档。

Spring Boot版本库也有一些你可以运行的样本。 样本独立于代码的其余部分（也就是说，您不需要构建其余的代码来运行或使用样本）。

否则，下一个逻辑步骤是阅读第三部分“使用Spring Boot”。 如果你真的不耐烦，也可以跳过来阅读Spring Boot的特性。

Part III. 使用Spring Boot

本节将更详细地介绍如何使用Spring Boot。 它涵盖了构建系统，自动配置以及如何运行应用程序等主题。 我们还介绍了一些Spring Boot的最佳实践。 尽管Spring Boot没有什么特别的地方（它只是你可以使用的另一个库），但是有一些建议，如果遵循这些建议，将使开发过程变得更容易一些。

如果您刚刚开始使用Spring Boot，则可能需要先阅读入门指南，然后再深入本节。

13.建立系统

强烈建议您选择支持依赖管理的构建系统，并且可以使用发布到“Maven Central”存储库的工件。 我们建议您选择Maven或Gradle。 Spring Boot可以与其他构建系统（例如Ant）一起工作，但是它们不会得到特别好的支持。

13.1依赖管理

Spring Boot的每个发行版都提供了一个支持的依赖列表。 在实践中，您不需要为构建配置中的任何这些依赖项提供一个版本，因为Spring Boot正在为您进行管理。 当您升级Spring Boot本身时，这些依赖关系也将以一致的方式升级。

注：如果您觉得有必要，您仍然可以指定一个版本并覆盖Spring Boot的建议。

助手列表包含您可以使用Spring Boot的所有Sping模块以及第三方库的精选列表。 该列表可以作为标准物料清单（spring-boot-dependencies）提供，也可以为Maven和Gradle提供额外的专用支持。

注：Spring Boot的每个版本都与Spring Framework的基础版本相关联，因此我们强烈建议您不要自行指定其版本。

13.2 Maven

Maven用户可以从spring-boot-starter-parent项目继承，以获得合理的默认值。 父项目提供以下功能：

• Java 1.6作为默认的编译器级别。
• UTF-8源码编译。
• 依赖管理部分，允许您省略继承自Spring-Boot-dependencies POM的通用依赖项的标记。明智的资源过滤。
• 明智的插件配置（(exec plugin, surefire, Git commit ID, shade）。
• 对application.properties和application.yml进行明智的资源过滤，包括特定于配置文件的文件（例如application-foo.properties和application-foo.yml）

最后一点：因为默认配置文件接受Spring样式占位符（$ {…}），Maven过滤被改为使用@ .. @占位符（你可以用Maven属性resource.delimiter覆盖）。

13.2.1继承初始父项

要将项目配置为从spring-boot-starter-parent继承，只需设置父项：

<!-- Inherit defaults from Spring Boot -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.9.RELEASE</version>
</parent>

注：您应该只需要在此依赖项上指定Spring Boot版本号。 如果您导入更多的启动器，则可以安全地省略版本号。

通过该设置，您还可以通过在自己的项目中重写属性来覆盖各个依赖项。 例如，要升级到另一个Spring Data发行版，您需要将以下内容添加到您的pom.xml中。

<properties>
    <spring-data-releasetrain.version>Fowler-SR2</spring-data-releasetrain.version>
</properties>

注：检查spring-boot-dependencies pom支持的属性列表。

13.2.2使用没有父POM的Spring Boot

不是每个人都喜欢从spring-boot-starter-parent POM继承。 你可能有你自己的企业标准，你需要使用，或者你可能只是喜欢显式声明所有的Maven配置。

如果您不想使用spring-boot-starter-parent，则仍然可以通过使用scope = import dependency来保留依赖项管理的好处：

<dependencyManagement>
     <dependencies>
        <dependency>
            <!-- Import dependency management from Spring Boot -->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>1.5.9.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

如上所述，该设置不允许您使用属性覆盖单个依赖项。 为了达到同样的结果，你需要在spring-boot-dependencies条目之前在项目的dependencyManagement中添加一个条目。 例如，要升级到另一个Spring Data发行版，您需要将以下内容添加到您的pom.xml中。

<dependencyManagement>
    <dependencies>
        <!-- Override Spring Data release train provided by Spring Boot -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-releasetrain</artifactId>
            <version>Fowler-SR2</version>
            <scope>import</scope>
            <type>pom</type>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>1.5.9.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

注：在上面的例子中，我们指定了一个BOM，但是任何依赖类型都可以被覆盖。

13.2.3更改Java版本

spring-boot-starter-parent选择相当保守的Java兼容性。 如果您想遵循我们的建议并使用较新的Java版本，则可以添加一个java.version属性：

<properties>
    <java.version>1.8</java.version>
</properties>

13.2.4使用Spring Boot Maven插件

Spring Boot包含一个Maven插件，可以将项目打包为可执行的jar文件。 如果你想使用它，请将插件添加到部分：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

注：如果你使用Spring Boot的启动父POM，只需要添加插件，除非你想改变在父代中定义的设置，否则不需要进行配置。

13.3 Gradle

Gradle用户可以在他们的依赖项部分直接导入’starters’。 与Maven不同的是，没有“超级父母”可以导入来共享某些配置。

repositories {
    jcenter()
}

dependencies {
    compile("org.springframework.boot:spring-boot-starter-web:1.5.9.RELEASE")
}

spring-boot-gradle-plugin也是可用的，并提供了创建可执行的jar和从源代码运行项目的任务。 它还提供依赖性管理，除其他功能外，还允许您省略由Spring Boot管理的任何依赖项的版本号：

plugins {
    id 'org.springframework.boot' version '1.5.9.RELEASE'
    id 'java'
}


repositories {
    jcenter()
}

dependencies {
    compile("org.springframework.boot:spring-boot-starter-web")
    testCompile("org.springframework.boot:spring-boot-starter-test")
}

13.4Ant

可以使用Apache Ant + Ivy构建Spring Boot项目。 spring-boot-antlib“AntLib”模块也可以帮助Ant创建可执行的jar文件。

为了声明依赖关系，一个典型的ivy.xml文件将如下所示：

<ivy-module version="2.0">
    <info organisation="org.springframework.boot" module="spring-boot-sample-ant" />
    <configurations>
        <conf name="compile" description="everything needed to compile this module" />
        <conf name="runtime" extends="compile" description="everything needed to run this module" />
    </configurations>
    <dependencies>
        <dependency org="org.springframework.boot" name="spring-boot-starter"
            rev="${spring-boot.version}" conf="compile" />
    </dependencies>
</ivy-module>

一个典型的`build.xml“将如下所示：

<project
    xmlns:ivy="antlib:org.apache.ivy.ant"
    xmlns:spring-boot="antlib:org.springframework.boot.ant"
    name="myapp" default="build">

    <property name="spring-boot.version" value="1.5.9.RELEASE" />

    <target name="resolve" description="--> retrieve dependencies with ivy">
        <ivy:retrieve pattern="lib/[conf]/[artifact]-[type]-[revision].[ext]" />
    </target>

    <target name="classpaths" depends="resolve">
        <path id="compile.classpath">
            <fileset dir="lib/compile" includes="*.jar" />
        </path>
    </target>

    <target name="init" depends="classpaths">
        <mkdir dir="build/classes" />
    </target>

    <target name="compile" depends="init" description="compile">
        <javac srcdir="src/main/java" destdir="build/classes" classpathref="compile.classpath" />
    </target>

    <target name="build" depends="compile">
        <spring-boot:exejar destfile="build/myapp.jar" classes="build/classes">
            <spring-boot:lib>
                <fileset dir="lib/runtime" />
            </spring-boot:lib>
        </spring-boot:exejar>
    </target>
</project>

注：如果您不想使用spring-boot-antlib模块，请参见第84.10节“从Ant构建不使用spring-boot-antlib的可执行文件”。

13.5起动

启动器是一套方便的依赖描述符，可以包含在应用程序中。 您可以获得所需的所有Spring及相关技术的一站式服务，无需搜索示例代码，也不需要粘贴依赖关系描述符。 例如，如果你想开始使用Spring和JPA来访问数据库，只需在你的项目中加入spring-boot-starter-data-jpa依赖项，你就可以开始了。

初学者包含很多依赖项，您需要快速启动并运行一个项目，并使用一组支持的传递依赖项。

命名原则

所有官方首发者都遵循类似的命名模式; spring-boot-starter-，其中是特定类型的应用程序。 这种命名结构旨在帮助您找到启动器。 许多IDE中的Maven集成允许您按名称搜索依赖项。 例如，安装适当的Eclipse或STS插件后，只需在POM编辑器中点击ctrl-space并键入“spring-boot-starter”即可获得完整列表。

正如创建自己的启动器部分中所解释的，第三方启动器不应该以spring-boot开始，因为它是为官方的Spring Boot工件保留的。 acme的第三方初学者通常被命名为acme-spring-boot-starter。

以下应用程序启动程序由Spring Boot在org.springframework.boot组下提供：

表13.1。 Spring Boot应用程序启动器(链接实在太多 ,下次再补)

除了应用程序启动器之外，还可以使用以下启动器来添加生产准备功能：

表13.2。 Spring Boot生产启动器

最后，Spring Boot还包括一些可以用来排除或交换特定技术方面的入门知识：

注:有关其他社区贡献者的列表，请参阅GitHub上的spring-boot-starters模块中的README文件。

14.构建你的代码

Spring Boot不需要任何特定的代码布局，但是，有一些最佳实践可以提供帮助。

14.1使用“默认”软件包

当一个类不包含包声明时，它被认为是在“默认包”中。 通常不鼓励使用“默认软件包”，应该避免使用“默认软件包”。 对于使用@ComponentScan，@EntityScan或@SpringBootApplication注解的Spring Boot应用程序来说，这可能会导致特定的问题，因为每个jar的每个类都将被读取。

注：我们建议您遵循Java推荐的软件包命名约定，并使用反向域名（例如，com.example.project）。

14.2找到主应用程序类

我们通常建议您将主应用程序类放在其他类的根包中。 @EnableAutoConfiguration注解通常放在主类上，它隐式地为某些项目定义了一个基本的“搜索包”。 例如，如果您正在编写JPA应用程序，则@EnableAutoConfiguration注解类的包将用于搜索@Entity项目。

使用根包也允许使用@ComponentScan注解而不需要指定basePackage属性。 如果您的主类位于根包中，也可以使用@SpringBootApplication注解。

这是一个典型的布局：

com
 +- example
     +- myproject
         +- Application.java
         |
         +- domain
         |   +- Customer.java
         |   +- CustomerRepository.java
         |
         +- service
         |   +- CustomerService.java
         |
         +- web
             +- CustomerController.java

Application.java文件将声明main方法以及基本的@Configuration。

package com.example.myproject;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application {

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

}

15.配置类

Spring Boot支持基于Java的配置。 虽然可以使用XML源调用SpringApplication.run（），但我们通常建议您的主要来源是@Configuration类。 通常，定义main方法的类也是主要@Configuration的一个好候选。

注：在互联网上已经发布了许多使用XML配置的Spring配置示例。 如果可能，请始终尝试使用基于Java的等效配置。 搜索启用*注解可以是一个很好的起点。

15.1导入其他配置类

你不需要把所有的@Configuration放到一个类中。 @Import注解可用于导入其他配置类。 或者，您可以使用@ComponentScan自动获取所有Spring组件，包括@Configuration类。

15.2导入XML配置

如果您必须使用基于XML的配置，我们建议您仍以@Configuration类开头。 然后您可以使用额外的@ImportResource注解来加载XML配置文件。

16.自动配置

Spring Boot自动配置会尝试根据您添加的jar依赖项自动配置您的Spring应用程序。 例如，如果HSQLDB在您的类路径中，并且您没有手动配置任何数据库连接Bean，则Spring Boot会自动配置内存数据库。

您需要通过将@EnableAutoConfiguration或@SpringBootApplication注解添加到其中一个@Configuration类来选择自动配置。

注：您应该只添加一个@EnableAutoConfiguration注解。 我们通常建议您将其添加到您的主@Configuration类。

16.1逐渐更换自动配置

自动配置是非侵入式的。 在任何时候，您都可以开始定义自己的配置来替换自动配置的特定部分。 例如，如果添加您自己的DataSource Bean，则默认的嵌入式数据库支持会被取消。

如果您需要了解当前正在应用的自动配置，以及为什么使用–debug开关启动您的应用程序。 这样做可以启用调试日志以选择核心记录器，并将条件报告记录到控制台。

16.2禁用特定的自动配置类

如果您发现不需要的特定自动配置类正在应用，则可以使用@EnableAutoConfiguration的exclude属性来禁用它们，如以下示例所示：

import org.springframework.boot.autoconfigure.*;
import org.springframework.boot.autoconfigure.jdbc.*;
import org.springframework.context.annotation.*;

@Configuration
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
public class MyConfiguration {
}

如果类不在类路径中，则可以使用注解的excludeName属性，并指定完全限定的名称。 最后，您还可以使用spring.autoconfigure.exclude属性来控制要排除的自动配置类的列表。

注：您可以在注解级别和通过使用属性来定义排除。

17.Spirng bean和依赖注入

您可以自由使用任何标准的Spring框架技术来定义您的bean及其注入的依赖关系。 为了简单起见，我们经常发现使用@ComponentScan（查找你的bean）和使用@Autowired（做构造函数注入）。

如果按上面的建议构建代码（在根包中查找应用程序类），则可以添加@ComponentScan而不带任何参数。 所有的应用程序组件（@Component，@Service，@Repository，@Controller等）都会自动注册为Spring Beans。

以下示例显示了一个@Service Bean，它使用构造函数注入来获取所需的RiskAssessor bean：

package com.example.service;

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

@Service
public class DatabaseAccountService implements AccountService {

    private final RiskAssessor riskAssessor;

    @Autowired
    public DatabaseAccountService(RiskAssessor riskAssessor) {
        this.riskAssessor = riskAssessor;
    }

    // ...

}

如果一个bean只有一个构造函数，则可以省略@Autowired，如下例所示：

@Service
public class DatabaseAccountService implements AccountService {

    private final RiskAssessor riskAssessor;

    public DatabaseAccountService(RiskAssessor riskAssessor) {
        this.riskAssessor = riskAssessor;
    }

    // ...

注：注意如何使用构造函数注入让riskAssessor字段被标记为final，表明它不能被随后改变。

18.使用@SpringBootApplication注解

许多Spring Boot开发人员总是使用@Configuration，@EnableAutoConfiguration和@ComponentScan注解其主类。 由于这些注释经常一起使用（特别是如果您遵循以上最佳实践），Spring Boot提供了一种方便的@SpringBootApplication替代方法。

@SpringBootApplication注释等同于使用@Configuration，@EnableAutoConfiguration和@ComponentScan及其默认属性，如以下示例所示：

package com.example.myapplication;

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

@SpringBootApplication // same as @Configuration @EnableAutoConfiguration @ComponentScan
public class Application {

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

}

注：@SpringBootApplication还提供别名来自定义@EnableAutoConfiguration和@ComponentScan的属性。

19.运行您的应用程序

将应用程序封装为jar并使用嵌入式HTTP服务器的最大优点之一是，您可以像运行其他应用程序一样运行应用程序。 调试Spring Boot应用程序也很容易。 您不需要任何特殊的IDE插件或扩展。

注：本节仅介绍基于jar的包装。 如果您选择将应用程序打包为war文件，则应参考您的服务器和IDE文档。

19.1从IDE运行

您可以从IDE运行Spring Boot应用程序作为一个简单的Java应用程序。 但是，您首先需要导入您的项目。 导入步骤取决于您的IDE和构建系统。 大多数IDE可以直接导入Maven项目。 例如，Eclipse用户可以从File菜单中选择Import …→Existing Maven Projects。

如果不能直接将项目导入IDE，则可以使用构建插件生成IDE元数据。 Maven包含Eclipse和IDEA的插件。 Gradle为各种IDE提供插件。

提示:如果您意外运行两次Web应用程序，则会看到“端口已被使用”错误。 STS用户可以使用“重新启动”按钮而不是“运行”按钮来确保关闭任何现有的实例。

19.2作为打包应用程序运行

如果您使用Spring Boot Maven或Gradle插件创建可执行jar，则可以使用java -jar运行应用程序，如以下示例所示:

>$ java -jar target/myapplication-0.0.1-SNAPSHOT.jar

也可以运行打包的应用程序并启用远程调试支持。 这样做可以让您将调试器附加到打包的应用程序，如以下示例所示：

$ java -Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n \
       -jar target/myapplication-0.0.1-SNAPSHOT.jar

19.3使用Maven插件

Spring Boot Maven插件包含一个可用于快速编译和运行应用程序的运行目标。 应用程序以分解形式运行，就像在IDE中一样。

$ mvn spring-boot:run

您可能还想使用MAVEN_OPTS操作系统环境变量，如以下示例所示：

$ export MAVEN_OPTS=-Xmx1024m

19.4使用Gradle插件

Spring Boot Gradle插件还包含一个bootRun任务，可用于以分解形式运行您的应用程序。 无论何时应用org.springframework.boot和java插件，都会添加bootRun任务，并显示在以下示例中：

$ gradle bootRun

您可能还想使用JAVA_OPTS操作系统环境变量，如以下示例所示：

$ export JAVA_OPTS=-Xmx1024m

19.5热插拔

由于Spring Boot应用程序只是普通的Java应用程序，所以JVM热插拔应该是开箱即用的。 JVM热插拔在可以替换的字节码方面有一定的局限性。 对于更完整的解决方案，可以使用JRebel。

spring-boot-devtools模块还包括对快速应用程序重新启动的支持。 有关详细信息，请参阅下面的第20章开发人员工具部分以及热插拔“操作方法”。

20.开发工具

Spring Boot包含一组额外的工具，可以使应用程序开发体验更愉快。 spring-boot-devtools模块可以包含在任何项目中以提供额外的开发时间功能。 要包含devtools支持，请将模块依赖关系添加到您的构建中，如Maven和Gradle的以下列表所示：

Maven

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

Gradle

dependencies {
    compile("org.springframework.boot:spring-boot-devtools")
}

注意：运行完整打包的应用程序时，开发人员工具会自动禁用 如果您的应用程序是使用java -jar启动的，或者是从特定的类加载器启动的，那么它就被认为是“生产应用程序”。 将依赖关系标记为可选项是一种最佳实践，可以防止devtools通过项目传递到其他模块。 Gradle不支持可选的依赖关系，因此您可能需要查看propdeps-plugin。

提示：重新打包的archives 在默认情况下不包含devtools。 如果要使用某个远程devtools功能，则需要禁用excludeDevtools构建属性以包含它。 该属性支持Maven和Gradle插件。

20.1属性默认值

Spring Boot支持的一些库使用缓存来提高性能。 例如，模板引擎缓存已编译的模板以避免重复解析模板文件。 此外，Spring MVC可以在服务静态资源时将HTTP缓存头添加到响应中。

虽然缓存在生产中非常有益，但是在开发过程中可能会起到反作用，使您无法看到您在应用程序中所做的更改。 为此，spring-boot-devtools默认禁用缓存选项。

缓存选项通常由您的application.properties文件中的设置进行配置。 例如，Thymeleaf提供了spring.thymeleaf.cache属性。 spring-boot-devtools模块不需要手动设置这些属性，而是自动应用合理的开发时间配置。

注意:有关由devtools应用的属性的完整列表，请参阅DevToolsPropertyDefaultsPostProcessor。

20.2自动重启

当类路径上的文件发生变化时，使用spring-boot-devtools的应用程序会自动重启。 在IDE中工作时，这可能是一个有用的功能，因为它为代码更改提供了一个非常快速的反馈循环。 默认情况下，监视指向文件夹的类路径上的任何条目以进行更改。 请注意，某些资源（如静态资产和视图模板）不需要重新启动应用程序。

触发重启

由于DevTools监视类路径资源，触发重启的唯一方法是更新类路径。 导致类路径更新的方式取决于您使用的IDE。 在Eclipse中，保存修改后的文件将导致类路径更新并触发重启。 在IntelliJ IDEA中，构建项目（Build - > Make Project）具有相同的效果。

注意:只要分叉被启用，你也可以使用受支持的构建插件（Maven和Gradle）来启动你的应用程序，因为DevTools需要一个独立的应用程序类加载器才能正常运行。默认情况下，当Gradle和Maven检测到类路径上的DevTools时，它们会这样做。

提示:与LiveReload一起使用时，自动重新启动的效果非常好。有关详细信息，请参阅LiveReload部分。如果使用JRebel，则自动重新启动将被禁用，以支持动态类重新加载。其他devtools功能（如LiveReload和属性覆盖）仍然可以使用。

注意：DevTools依靠应用程序上下文的关闭hook在重新启动期间关闭它。如果您禁用了关闭hook（SpringApplication.setRegisterShutdownHook（false）），它将无法正常工作。

注意:当确定类路径上的条目在更改时会触发重新启动时，DevTools会自动忽略名为spring-boot，spring-boot-devtools，spring-boot-autoconfigure，spring-boot-actuator和spring-boot-starter的项目。

注意：DevTools需要自定义ApplicationContext使用的ResourceLoader。如果你的应用程序已经提供了一个，它将被包装。不支持直接覆盖ApplicationContext上的getResource方法。

重新启动vs重新加载

Spring Boot提供的重启技术通过使用两个类加载器来工作。 不改变的类（例如来自第三方jar的类）被加载到基类加载器中。 您正在开发的类将加载到重启类加载器中。 当应用程序重新启动时，重启classloader被丢弃，并创建一个新的。 这种方法意味着应用程序重新启动通常比“冷启动”快得多，因为基类加载器已经可用并且已经被填充了。

如果您发现重新启动对于您的应用程序来说不够快，或者遇到类加载问题，则可以考虑从ZeroTurnaround中重新加载技术，例如JRebel。 这些工作通过重写类，因为他们被加载，使他们更容易重新加载。

20.2.1记录条件评估中的变化

默认情况下，每次重新启动应用程序时，都会记录显示条件评估增量的报告。 该报告显示了对应用程序的自动配置进行的更改，例如添加或删除Bean以及设置配置属性。

要禁用报告的记录，请设置以下属性：

spring.devtools.restart.log-condition-evaluation-delta=false

20.2.2排除资源

某些资源不一定需要在更改时触发重新启动。 例如，Thymeleaf模板可以就地编辑。 默认情况下，更改/ META-INF / maven，/ META-INF / resources，/ resources，/ static，/ public或/ templates中的资源不会触发重新启动，但会触发实时重新加载。 如果您想要自定义这些排除，可以使用spring.devtools.restart.exclude属性。 例如，要仅排除/ static和/ public，您将设置以下属性：

spring.devtools.restart.exclude=static/**,public/**

提示:如果要保留这些默认值并添加其他排除项，请改为使用spring.devtools.restart.additional-exclude属性。

20.2.3观察其他路径

您可能希望在更改不在类路径中的文件时重新启动或重新加载应用程序。 为此，请使用spring.devtools.restart.additional-paths属性来配置其他路径以监视更改。 您可以使用上述的spring.devtools.restart.exclude属性来控制额外路径下的更改是触发完全重新启动还是实时重新加载。

20.2.4禁用重启

如果您不想使用重新启动功能，则可以使用spring.devtools.restart.enabled属性将其禁用。 在大多数情况下，您可以在application.properties中设置此属性（这样做仍会初始化重新启动类加载器，但不会监视文件更改）。

如果您需要完全禁用重新启动支持（例如，因为它不适用于特定的库），则需要在调用SpringApplication.run（…）之前将spring.devtools.restart.enabled System属性设置为false， 如以下示例所示：

public static void main(String[] args) {
    System.setProperty("spring.devtools.restart.enabled", "false");
    SpringApplication.run(MyApp.class, args);
}

20.2.5使用触发文件

如果您在IDE中工作，并尝试连续更改文件，则可能只希望在特定时间触发重新启动。 为此，您可以使用“触发文件”，这是一个特殊的文件，当您想要实际触发重新启动检查时，该文件必须被修改。 只更改文件会触发检查，只有Devtools检测到必须执行某些操作时才会重新启动。 触发器文件可以手动更新或使用IDE插件。

要使用触发器文件，请将spring.devtools.restart.trigger-file属性设置为触发器文件的路径。

提示：您可能希望将spring.devtools.restart.trigger-file设置为全局设置，以便所有项目的行为方式相同。

20.2.6自定义重启类加载器

如上面的重新启动vs重新加载部分所述，重新启动功能是通过使用两个类加载器来实现的。对于大多数应用程序来说，这种方法运行良好但是，有时会导致类加载问题。

默认情况下，IDE中的任何打开的项目都会加载“restart”类加载器，而任何常规的.jar文件都会加载“base”类加载器。如果您使用多模块项目，而不是每个模块都导入到IDE中，则可能需要自定义。为此，您可以创建一个META-INF / spring-devtools.properties文件。

spring-devtools.properties文件可以包含前缀为restart.exclude和restart.include的属性。 include元素是应该被拉入到“重启”类加载器中的项目，排除元素是应该被下推到“基本”类加载器中的项目。该属性的值是应用于类路径的正则表达式模式，如以下示例所示：

restart.exclude.companycommonlibs=/mycorp-common-[\\w-]+\.jar
restart.include.projectcommon=/mycorp-myproj-[\\w-]+\.jar

注意:所有的 property keys 必须是唯一的。 只要属性以restart.include开头。 或restart.exclude。都 已经被考虑了。

注意：所有类路径中的META-INF / spring-devtools.properties都将被加载。 您可以将文件打包到项目中，也可以打包到项目使用的库中。

21.打包您的应用

可执行的jar可用于生产部署。 由于它们是独立的，因此它们也非常适合基于云的部署。

对于额外的“生产准备”功能，例如运行状况，审计和公制REST或JMX端点，请考虑添加Spring boot执行器。 有关详细信息，请参阅第五部分“执行器：生产就绪功能”。

22.下一步阅读什么

您现在应该了解如何使用Spring Boot以及您应遵循的一些最佳实践。 您现在可以继续深入了解特定的Spring Boot功能，或者可以跳过并阅读Spring Boot的“生产准备”部分。

Part IV Spring Boot功能

本节将深入探讨Spring Boot的细节。 在这里，您可以了解您可能想要使用和定制的关键功能。 如果您还没有这样做，您可能需要阅读“第二部分”，入门指南“”和“第三部分”，使用Spring Boot“”部分，以便您具备良好的基础知识。

23. SpringApplication

SpringApplication类提供了一种方便的方式来引导从main（）方法启动的Spring应用程序。 在许多情况下，您可以委托给静态的SpringApplication.run方法，如下例所示：

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

当您的应用程序启动时，您应该看到类似于以下输出的内容：

 .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::   v2.0.0.BUILD-SNAPSHOT

2013-07-31 00:08:16.117  INFO 56603 --- [           main] o.s.b.s.app.SampleApplication            : Starting SampleApplication v0.1.0 on mycomputer with PID 56603 (/apps/myapp.jar started by pwebb)
2013-07-31 00:08:16.166  INFO 56603 --- [           main] ationConfigServletWebServerApplicationContext : Refreshing org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@6e5a8246: startup date [Wed Jul 31 00:08:16 PDT 2013]; root of context hierarchy
2014-03-04 13:09:54.912  INFO 41370 --- [           main] .t.TomcatServletWebServerFactory : Server initialized with port: 8080
2014-03-04 13:09:56.501  INFO 41370 --- [           main] o.s.b.s.app.SampleApplication            : Started SampleApplication in 2.992 seconds (JVM running for 3.658)

默认情况下，会显示INFO日志消息，其中包括一些相关的启动详细信息，例如启动应用程序的用户。

23.1启动失败

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

***************************
APPLICATION FAILED TO START
***************************

Description:

Embedded servlet container failed to start. Port 8080 was already in use.

Action:

Identify and stop the process that's listening on port 8080 or configure this application to listen on another port.

注：Spring Boot提供了大量的错误分析实现，您可以添加自己的。

如果没有故障分析仪能够处理异常情况，您仍然可以显示完整的情况报告，以更好地了解出了什么问题。 为此，您需要为org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener启用调试属性或启用DEBUG日志记录。

例如，如果使用java -jar运行应用程序，则可以按如下所示启用调试属性：

$ java -jar myproject-0.0.1-SNAPSHOT.jar --debug

23.2自定义横幅

启动时打印的横幅可以通过将banner.txt文件添加到类路径中或通过将spring.banner.location属性设置为此类文件的位置来更改。 如果文件的编码不是UTF-8，可以设置spring.banner.charset。 除了文本文件之外，还可以将banner.gif，banner.jpg或banner.png图像文件添加到您的类路径或设置spring.banner.image.location属性。 图像被转换成ASCII艺术表现形式，并打印在任何文字横幅上方。

在您的banner.txt文件中，您可以使用以下任何占位符：

提示：如果要以编程方式生成横幅，则可以使用SpringApplication.setBanner（…）方法。 使用org.springframework.boot.Banner接口并实现自己的printBanner（）方法。

288/5000
您还可以使用spring.main.banner-mode属性来确定横幅是否必须在System.out（控制台）上打印，发送到配置的记录器（日志），还是根本不生成（关闭）。

打印的横幅在以下名称下注册为singleton bean：springBootBanner。

注：YAML映射为false，因此如果要禁用应用程序中的横幅，请务必添加引号。

• spring:
  • main:
    • banner-mode: “off”

23.3定制SpringApplication

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

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

注：传递给SpringApplication的构造函数参数是spring bean的配置源。 在大多数情况下，它们都是对@Configuration类的引用，但也可能是对XML配置的引用或应该扫描的包。

也可以通过使用application.properties文件来配置SpringApplication。 有关详细信息，请参阅第24章，外部化配置。

有关配置选项的完整列表，请参阅SpringApplication Javadoc。

23.4 Fluent Builder API(流利的建造者API模式)

如果您需要构建一个ApplicationContext层次结构（具有父/子关系的多个上下文），或者您只需要使用“流利”构建器API，则可以使用SpringApplicationBuilder。

SpringApplicationBuilder允许将多个方法调用链接在一起，并包含可以创建层次结构的父级和子级方法，如以下示例所示：

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

注：创建ApplicationContext层次结构时有一些限制。 例如，Web组件必须包含在子上下文中，并且父环境和子环境都使用相同的环境。 有关完整的细节，请参阅SpringApplicationBuilder Javadoc。

23.5应用程序事件和监听器

除了通常的Spring框架事件，比如ContextRefreshedEvent，SpringApplication还会发送一些附加的应用程序事件。

注：有些事件实际上是在创建ApplicationContext之前触发的，因此您不能将这些监听器注册为@Bean。 您可以使用SpringApplication.addListeners（…）或SpringApplicationBuilder.listeners（…）方法注册它们。

如果您希望自动注册这些侦听器，无论创建应用程序的方式如何，都可以将META-INF / spring.factories文件添加到您的项目中，并使用org.springframework.context引用您的侦听器。 ApplicationListener键，如以下示例所示：

org.springframework.context.ApplicationListener= com.example.project.MyListener

应用程序事件按照以下顺序发送，就像您的应用程序运行一样：

1. ApplicationStartingEvent在运行开始时发送，除了注册监听器和初始化器之外的任何处理之前。
2. 当在上下文中使用的环境是已知的但在创建上下文之前发送ApplicationEnvironmentPreparedEvent。
3. ApplicationPreparedEvent在刷新开始之前，但在bean定义加载之后发送。
4. 在刷新之后发送ApplicationReadyEvent并处理任何相关的回调，以指示应用程序已准备好为请求提供服务。
5. 如果启动时出现异常，则发送ApplicationFailedEvent。

注：您不需要经常使用应用程序事件，但可以方便地知道它们存在。 在内部，Spring Boot使用事件来处理各种任务。

应用程序事件是通过使用Spring框架的事件发布机制发送的。 这种机制的一部分确保发布给子上下文中监听器的事件也发布给任何祖先上下文中的监听器。 因此，如果您的应用程序使用SpringApplication实例的层次结构，则侦听器可能会收到同一类型应用程序事件的多个实例。

为了让你的监听器区分上下文的事件和后代上下文的事件，它应该请求它的应用上下文被注入，然后比较注入的上下文和事件的上下文。 上下文可以通过实现ApplicationContextAware来注入，或者如果侦听器是一个bean，可以通过使用@Autowired注入。

23.6 Web环境

SpringApplication试图代表你创建正确类型的ApplicationContext。 默认情况下，使用AnnotationConfigApplicationContext或AnnotationConfigServletWebServerApplicationContext，具体取决于您是否正在开发Web应用程序。

用来确定“网络环境”的算法相当简单（它基于几个类的存在）。 如果您需要覆盖默认值，可以使用setWebEnvironment（boolean webEnvironment）。

也可以通过调用setApplicationContextClass（…）来完全控制ApplicationContext类型。

提示：在JUnit测试中使用SpringApplication时，通常需要调用setWebEnvironment（false）。

23.7访问应用程序参数

如果您需要访问传递给SpringApplication.run（…）的应用程序参数，则可以注入一个org.springframework.boot.ApplicationArguments bean。 ApplicationArguments接口提供对原始String []参数以及解析的选项和非选项参数的访问，如以下示例所示：

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

}

提示:Spring Boot还向Spring环境注册了一个CommandLinePropertySource。 这使您可以通过使用@Value注释来注入单个应用程序参数。

23.8使用ApplicationRunner或CommandLineRunner

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

CommandLineRunner接口作为一个简单的字符串数组提供对应用程序参数的访问，而ApplicationRunner使用前面讨论的ApplicationArguments接口。

import org.springframework.boot.*
import org.springframework.stereotype.*

@Component
public class MyBean implements CommandLineRunner {

    public void run(String... args) {
        // Do something...
    }

}

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

23.9应用退出

每个SpringApplication都会向JVM注册一个关闭钩子，以确保ApplicationContext在退出时正常关闭。 所有标准的Spring生命周期回调（比如DisposableBean接口或者@PreDestroy注解）都可以使用。

另外，如果在调用SpringApplication.exit（）时想要返回特定的退出代码，bean可以实现org.springframework.boot.ExitCodeGenerator接口。 然后可以将此退出代码传递给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（）方法提供的退出代码。

23.10管理员功能

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

提示：如果您想知道应用程序在哪个HTTP端口上运行，请使用local.server.port的key获取该属性。

24.外部化配置

Spring Boot允许您将配置外部化，以便在不同的环境中使用相同的应用程序代码。您可以使用属性文件，YAML文件，环境变量和命令行参数来外部化配置。属性值可以通过使用@Value注解直接注入到bean中，通过Spring的Environment抽象来访问，或者通过@ConfigurationProperties绑定到结构化对象。

Spring Boot使用了一个非常特殊的PropertySource命令，该命令旨在允许明智的重写值。属性按以下顺序考虑：

1. 在主目录上开发Devtools全局设置属性（当devtools处于活动状态时〜/ .spring-boot-devtools.properties）。
2. 在你的测试中使用@TestPropertySource注解。
3. 在你的测试中@ SpringBootTest＃属性注解属性。
4. 命令行参数。
5. 来自SPRING_APPLICATION_JSON的属性（嵌入在环境变量或系统属性中的内联JSON）。
6. ServletConfig初始化参数。
7. ServletContext初始化参数。
8. 来自java：comp / env的JNDI属性。
9. Java系统属性（System.getProperties（））。
10. OS环境变量。
11. 一个RandomValuePropertySource只具有随机的属性*。
12. 打包jar（application- {profile} .properties和YAML变体）之外的特定于配置文件的应用程序属性。
13. 打包在您的jar（application- {profile} .properties和YAML变体）中的特定于配置文件的应用程序属性。
14. 应用程序属性在打包的jar之外（application.properties和YAML变体）。
15. 打包在jar中的应用程序属性（application.properties和YAML变体）。
16. @Configuration类的@PropertySource注释。
17. 默认属性（使用SpringApplication.setDefaultProperties指定）。

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

import org.springframework.stereotype.*
import org.springframework.beans.factory.annotation.*

@Component
public class MyBean {

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

    // ...

}

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

提示：可以使用环境变量在命令行上提供SPRING_APPLICATION_JSON属性。 例如，您可以在UN * X shell中使用以下行：

$ SPRING_APPLICATION_JSON =’{“acme”：{“name”：“test”}}’java -jar myapp.jar
在前面的例子中，Spring结束了acme.name = test。 您也可以在System属性中将spring提供为spring.application.json，如下例所示：

$ java -Dspring.application.json =’{“name”：“test”}’-jar myapp.jar
您还可以使用命令行参数提供JSON，如以下示例所示：

$ java -jar myapp.jar –spring.application.json =’{“name”：“test”}’
您还可以将JSON作为JNDI变量提供，如下所示：java：comp / env / spring.application.json。

24.1配置随机值

RandomValuePropertySource用于注入随机值（例如，注入秘密或测试用例）。 它可以产生整数，长整数，uuids或字符串，如下例所示：

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

ndom.int *语法是OPEN值（，max）CLOSE其中OPEN，CLOSE是任何字符和值，max是整数。 如果提供最大值，则值是最小值，最大值是最大值（不包括）。

24.2访问命令行属性

默认情况下，SpringApplication将任何命令行选项参数（即以“ - ”开头的参数，例如–server.port = 9000）转换为属性并将其添加到Spring环境。 如前所述，命令行属性总是优先于其他属性源。

如果您不希望将命令行属性添加到环境中，则可以使用SpringApplication.setAddCommandLineProperties（false）将其禁用。

24.3应用程序属性文件

SpringApplication从以下位置的application.properties文件加载属性，并将它们添加到Spring环境中：

1. 当前目录的A / config子目录。
2. 当前目录
3. 一个classpath / config包
4. 类路径根

该列表按优先顺序排列（在列表中较高的位置定义的属性将覆盖在较低位置定义的属性）。

注:您也可以使用YAML（’.yml’）文件替代“.properties”。

如果您不喜欢application.properties作为配置文件名，则可以通过指定一个spring.config.name环境属性来切换到另一个文件名。 您还可以使用spring.config.location环境属性（逗号分隔的目录位置或文件路径列表）引用显式位置。 以下示例显示如何指定不同的文件名称：

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

以下示例显示如何指定两个位置：

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

警告：
spring.config.name和spring.config.location很早就用来确定哪些文件必须被加载，所以它们必须被定义为环境属性（通常是OS环境变量，系统属性或命令行参数）。

如果spring.config.location包含目录（而不是文件），则它们应该以/结尾（并且在运行时加载在加载之前从spring.config.name生成的名称，包括配置文件特定的文件名）。在spring.config.location中指定的文件原样使用，不支持特定于配置文件的变体，并被特定于配置文件的特性覆盖。

配置位置按相反顺序搜索。默认情况下，配置的位置是classpath：/，classpath：/ config /，file：./，file：./ config /。结果搜索顺序如下：

1. file:./config/
2. file:./
3. classpath:/config/
4. classpath:/

当使用spring.config.location配置自定义配置位置时，它们会替换默认位置。例如，如果使用值classpath：/ custom-config /，file：./ custom-config /配置了spring.config.location，则搜索顺序如下所示：

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

或者，使用spring.config.additional-location配置自定义配置位置时，除了默认位置以外，还会使用它们。在默认位置之前搜索其他位置。例如，如果配置了classpath：/ custom-config /，file：./ custom-config /的额外位置，则搜索顺序如下所示：

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

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

注：如果使用环境变量而非系统属性，则大多数操作系统不允许使用句点分隔的键名称，但可以使用下划线（例如，SPRING_CONFIG_NAME而不是spring.config.name）。

注：如果您的应用程序在容器中运行，则可以使用JNDI属性（在java：comp / env中）或servlet上下文初始化参数，而不是使用环境变量或系统属性。

24.4配置文件特定的属性

除了application.properties文件外，还可以使用命名约定application- {profile} .properties来定义配置文件特定的属性。如果没有设置活动配置文件，环境会有一组默认的配置文件（默认为[默认]）。换句话说，如果没有显式激活配置文件，则会加载来自application-default.properties的属性。

特定于配置文件的属性是从标准application.properties的相同位置加载的，配置文件特定的文件总是覆盖非特定的文件，而不管配置文件特定的文件位于打包的jar内还是外部。

如果指定了多个配置文件，则应用最后一个赢取策略。例如，由spring.profiles.active属性指定的配置文件将添加到通过SpringApplication API配置的配置文件之后，因此优先。

注：如果您在spring.config.location中指定了任何文件，则不考虑这些文件的特定于配置文件的变体。如果您还想使用配置文件特定的属性，请使用spring.config.location中的目录

24.5属性中有占位符

application.properties中的值在使用时会通过现有环境进行过滤，因此您可以返回到以前定义的值（例如，从System properties）。

app.name=MyApp
app.description=${app.name} 

提示：您也可以使用这种技术来创建现有Spring Boot属性的“简短”变体。 有关详细信息，请参见第73.4节“使用简短的”命令行参数“”。

24.6使用YAML而不是属性

YAML是JSON的一个超集，因此，它是用于指定分层配置数据的非常方便的格式。 SpringApplication类自动支持YAML作为属性的替代方法，只要在类路径中有SnakeYAML库。

注:如果您使用“Starter”，则SnakeYAML由spring-boot-starter自动提供。

24.6.1加载YAML

Spring框架提供了两个方便的类，可以用来加载YAML文档。 YamlPropertiesFactoryBean将YAML作为属性加载，YamlMapFactoryBean将YAML作为Map加载。

例如，请考虑以下YAML文档：

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

面的例子将被转换成以下属性：

environments.dev.url=http://dev.example.com
environments.dev.name=Developer Setup
environments.prod.url=http://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

要通过使用Spring DataBinder实用程序（这是@ConfigurationProperties所做的）绑定到这样的属性，您需要在java.util.List（或Set）类型的目标Bean中拥有一个属性，并且您需要提供一个setter 或者用一个可变的值初始化它。 例如，以下示例绑定到以前显示的属性：

@ConfigurationProperties(prefix="my")
public class Config {

    private List<String> servers = new ArrayList<String>();

    public List<String> getServers() {
        return this.servers;
    }
}

注：当列表配置在多个地方时，通过替换整个列表覆盖工作。 在前面的例子中，当my.servers在几个地方被重新定义时，来自PropertySource的整个列表具有更高的优先级，将覆盖该列表的任何其他配置。 逗号分隔列表和yaml列表都可以用来完全覆盖列表的内容。

24.6.2在Spring环境中将YAML作为属性公开

YamlPropertySourceLoader类可以用来在Spring环境中将YAML作为一个PropertySource公开。 这样做可以让您使用带有占位符语法的@Value注释来访问YAML属性。

24.6.3多配置文件YAML文件

您可以通过使用spring.profiles键来指定多个配置文件特定的YAML文档在单个文件中，以指示文档何时适用，如以下示例所示：

server:
    address: 192.168.1.100
---
spring:
    profiles: development
server:
    address: 127.0.0.1
---
spring:
    profiles: production
server:
    address: 192.168.1.120

在前面的示例中，如果开发配置文件处于活动状态，则server.address属性为127.0.0.1。同样，如果生产配置文件处于活动状态，则server.address属性为192.168.1.120。如果开发和生产配置文件未启用，则属性值为192.168.1.100。

如果应用程序上下文启动时没有显式激活，则激活默认配置文件。所以，在下面的YAML中，我们为spring.security.user.password设置了一个只在“默认”配置文件中可用的值：

server:
  port: 8000
---
spring:
  profiles: default
  security:
    user:
      password: weak

而在以下示例中，由于密码未附加到任何配置文件，因此始终设置密码，必须根据需要在所有其他配置文件中明确重置该密码：

server:
  port: 8000
spring:
  security:
    user:
      password: weak

通过使用“spring.profiles”元素指定的spring配置文件可以有选择地使用！字符。如果为单个文档指定了否定配置文件和非否定配置文件，则至少有一个非否定配置文件必须匹配，且否定配置文件可能不匹配。

24.6.4 YAML的缺点
YAML文件不能使用@PropertySource注解加载。 所以，如果您需要以这种方式加载值，则需要使用属性文件。

24.6.5合并YAML列表
正如我们上面看到的，任何YAML内容最终都会转换为属性。 当通过配置文件重写“列表”属性时，该过程可能是违反直觉的。

例如，假设名称和描述属性默认为空的MyPojo对象。 以下示例公开了AcmeProperties中的MyPojo列表：

@ConfigurationProperties("acme")
public class AcmeProperties {

    private final List<MyPojo> list = new ArrayList<>();

    public List<MyPojo> getList() {
        return this.list;
    }

}

考虑以下配置：

acme:
  list:
    - name: my name
      description: my description
---
spring:
  profiles: dev
acme:
  list:
       - name: my another name

如果dev配置文件不活动，AcmeProperties.list包含一个如上定义的MyPojo条目。 如果启用配置文件但是，列表仍然只包含一个条目（名称为“我的另一个名称”和描述为空）。 此配置不会将第二个MyPojo实例添加到列表中，并且不合并这些项目。

当在多个配置文件中指定一个集合时，将使用具有最高优先级（只有那个）的集合：

acme:
  list:
    - name: my name
      description: my description
    - name: another name
      description: another description
---
spring:
  profiles: dev
acme:
  list:
     - name: my another name

在前面的示例中，如果dev配置文件处于活动状态，则AcmeProperties.list包含一个MyPojo条目（名称为“我的另一个名称”，空描述）。

24.7类型安全的配置属性

使用@Value（“$ {property}”）注释来注入配置属性有时会非常麻烦，特别是如果您使用多个属性或者您的数据是分层的。 Spring Boot提供了另一种使用属性的方法，可以让强类型的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的集合。

注：getters和setter通常是强制的，因为绑定是通过标准的Java Beans属性描述符来完成的，就像在Spring MVC中一样。在以下情况下，可能会忽略setter：

地图，只要它们被初始化，需要一个getter，但不一定是一个setter，因为它们可以被绑定器改变。
集合和数组可以通过索引（通常使用YAML）或使用单个逗号分隔值（属性）来访问。在后一种情况下，二传手是强制性的。我们建议始终为这种类型添加一个setter。如果初始化一个集合，确保它不是不可变的（如前面的例子）。
如果嵌套的POJO属性被初始化（如上例中的Security域），则不需要setter。如果您希望活页夹使用其默认构造函数即时创建实例，则需要一个setter。
有些人使用Project Lombok来自动添加getter和setter。确保Lombok不会为这种类型生成任何特定的构造函数，因为它被容器自动使用来实例化对象。

提示：另请参阅@Value和@ConfigurationProperties之间的区别。

您还需要列出要在@EnableConfigurationProperties注释中注册的属性类：

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