试试怎么对的 -他们最常见的问题提供解决方案。
学习Spring基础知识 - Spring Boot构建在许多其他Spring项目上，查阅spring.io网站获取大量参考文档。如果您刚开始使用Spring，请尝试其中一个指南。
问一个问题 - 我们监视stackoverflow.com问题的标签spring-boot。
使用Spring Boot在github.com/spring-projects/spring-boot/issues报告错误。


	所有的Spring Boot都是开源的，包括文档！如果您发现文档有问题，或者如果你只是想改善他们，请参与。

3.第一步

如果你刚刚开始使用Spring Boot，或者一般来说就是 “Spring”，那么这就是开始的地方！

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

4.使用Spring Boot

准备好真正开始使用Spring Boot？我们已经涵盖了你。

扫描二维码关注公众号，回复： 137373 查看本文章

构建系统： Maven | Gradle | 蚂蚁 | 首发
最佳实践： 代码结构 | @Configuration | @EnableAutoConfiguration | 豆类和依赖注入
运行您的代码 IDE | 打包 | Maven | 摇篮
打包你的应用程序： 生产罐子
Spring Boot CLI： 使用CLI

5.学习Spring Boot的特性

需要更多关于Spring Boot核心功能的细节？这是给你的！

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

6.转向生产

当您准备将Spring Boot应用程序推向生产时，我们有一些您可能会喜欢的技巧！

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

7.高级主题

最后，我们针对更高级的用户有几个主题。

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

第二部分入门

如果你刚开始使用Spring Boot，或者一般来说就是“Spring”，那么这是你的一部分！这里我们回答基本的“什么”，“怎么做”和“为什么”的问题。你会发现一个温柔的介绍，以及安装说明的Spring Boot。然后，我们将构建我们的第一个Spring Boot应用程序，并讨论一些核心原则。

8.介绍Spring Boot

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

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

我们的主要目标是：

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

9.系统要求

默认情况下，Spring Boot 1.5.2.RELEASE需要Java 7和Spring Framework 4.3.7.RELEASE或更高版本。您可以使用带有Java 6的Spring Boot以及其他一些配置。有关更多详细信息，请参见第84.11节“如何使用Java 6”。为Maven（3.2+）和Gradle 2（2.9或更高版本）和3提供了明确的构建支持。


	虽然可以使用Java 6或7的Spring Boot，但是我们通常推荐使用Java 8。

9.1 Servlet容器

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

名称	Servlet版本	Java版本
雄猫8	3.1	Java 7+
雄猫7	3.0	Java 6+
码头9.3	3.1	Java 8+
码头9.2	3.1	Java 7+
码头8	3.0	Java 6+
Undertow 1.3	3.1	Java 7+

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

10.安装Spring Boot

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

$ java -version

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


	尽管Spring Boot与Java 1.6兼容，但如果可能的话，应该考虑使用最新版本的Java。

10.1 Java开发人员的安装说明

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

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

10.1.1 Maven安装

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


	在许多操作系统上，Maven可以通过包管理器来安装。如果您是OSX Homebrew用户，请尝试`brew install maven`。Ubuntu用户可以运行`sudo apt-get 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>

    <！ - 从Spring Boot继承默认值 - > 
    <parent> 
        <groupId> org.springframework.boot </ groupId> 
        <artifactId> spring-boot-starter-parent </ artifactId> 
        <version> 1.5.2.RELEASE < / version> 
    </ parent>

    <！ - 添加Web应用程序的典型依赖关系 - > 
    <dependencies> 
        <dependency> 
            <groupId> org.springframework.boot </ groupId> 
            <artifactId> spring-boot-starter-web </ artifactId> 
        </ dependency> 
    </依赖>

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

</项目>


	这`spring-boot-starter-parent`是一个使用Spring Boot的好方法，但它可能并不适合所有的时间。有时您可能需要从不同的父POM继承，或者您可能不喜欢我们的默认设置。有关使用范围的替代解决方案，请参见第13.2.2节“使用没有父POM的Spring Boot”`import`。

10.1.2 Gradle安装

Spring Boot与Gradle 2（2.9或更高版本）和Gradle 3兼容。如果您尚未安装Gradle，则可以按照www.gradle.org/上的说明进行操作。

Spring引导依赖可以使用org.springframework.boot group。通常，您的项目将声明依赖关系到一个或多个 “Starter”。Spring Boot提供了一个有用的Gradle插件，可以用来简化依赖声明和创建可执行的jar。

这是一个典型的build.gradle文件：

插件{
    ID 'org.springframework.boot'版本'1.5.2.RELEASE' 
    ID '的Java'
}


罐子{
    baseName = 'myproject'version 
    =   '0.0.1-SNAPSHOT'
}

储存库{
    jcenter（）
}

依赖{
    编译（“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发行版：

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

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

10.2.2使用SDKMAN安装！

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

$ sdk安装springboot
$ spring --version
Spring Boot v1.5.2.RELEASE

如果您正在开发CLI的功能并希望轻松访问您刚刚构建的版本，请按照这些额外的说明进行操作。

$ sdk install springboot dev /path/to/spring-boot/spring-boot-cli/target/spring-boot-cli-1.5.2.RELEASE-bin/spring-1.5.2.RELEASE/
$ sdk默认springboot dev
$ spring --version
Spring CLI v1.5.2.RELEASE

这将安装一个spring称为dev实例的本地实例。它指向你的目标构建位置，所以每次重建Spring Boot时，spring都会是最新的。

你可以看到这样做：

$ sdk ls springboot

================================================== ==============================
可用的Springboot版本
================================================== ==============================
> + dev
* 1.5.2.RELEASE

================================================== ==============================
+  - 本地版本
*  - 已安装
>  - 目前正在使用
================================================== ==============================

10.2.3 OSX Homebrew安装

如果您在Mac上并使用Homebrew，则只需安装Spring Boot CLI即可：

$ brew tap pivotal / tap
$ brew安装springboot

家酿将安装spring到/usr/local/bin。


	如果您没有看到该公式，那么您的brew的安装可能会过期。只要执行，`brew update`然后再试一次。

10.2.4 MacPorts安装

如果您在Mac上并使用MacPorts，则只需安装Spring Boot CLI即可：

$ sudo port install spring-boot-cli

10.2.5命令行完成

Spring Boot CLI提供了为BASH和 zsh shell 提供命令完成的脚本。你可以source把脚本（也叫做 spring）放在任何shell中，或者把它放在你的个人或者系统范围的bash中完成初始化。在Debian系统上，系统范围内的脚本将在/shell-completion/bash 新的shell启动时执行该目录中的所有脚本。要手动运行脚本，例如，如果您已经使用SDKMAN安装！

$。〜/ .sdkman /候选人/ springboot /电流/壳完成/庆典/弹簧
$ spring <HIT TAB HERE>
  抓住帮助jar运行测试版本


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

10.2.6快速启动Spring CLI示例

这是一个非常简单的Web应用程序，您可以使用它来测试您的安装。创建一个名为app.groovy：

@RestController
类 ThisWillActuallyRun {

    @RequestMapping（ “/”）
    String home（）{
        “你好，世界！”
    }

}

然后简单地从一个shell运行它：

$ spring run app.groovy


	首次运行应用程序需要一段时间，因为依赖关系被下载。后续运行将会更快。

在你喜欢的网页浏览器中打开localhost：8080，你应该看到下面的输出：

你好，世界！

10.3从早期版本的Spring Boot升级

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

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

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

我们用Java开发一个简单的“Hello World！”Web应用程序，重点介绍Spring Boot的一些关键特性。我们将使用Maven来构建这个项目，因为大多数IDE都支持它。

该spring.io网站包含使用Spring的引导许多“入门”指南。如果你想解决一个特定的问题，先在那里检查。

您可以通过转到start.spring.io并web从依赖关系搜索器中选择初学者来简化以下步骤。这将自动生成一个新的项目结构，以便您可以立即开始编码。检查文档以获取更多详细信息。

在开始之前，请打开一个终端，检查是否安装了Java和Maven的有效版本。

$ java -version
java版本“1.7.0_51”
Java（TM）SE运行时环境（build 1.7.0_51-b13）
Java HotSpot（TM）64位服务器虚拟机（构建24.51-b03，混合模式）

$ mvn -v
Apache Maven 3.2.3（33f8c3e1027c3ddde99d3cdebad2656a31e8fdf4; 2014-08-11T13：58：10-07：00）
Maven主页：/Users/user/tools/apache-maven-3.1.1
Java版本：1.7.0_51，供应商：甲骨文公司


	此示例需要在其自己的文件夹中创建。后续的说明假定你已经创建了一个合适的文件夹，并且它是你的“当前目录”。

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> 1.5.2.RELEASE </ version> 
    </ parent>

    <！ - 在这里添加的其他行...  - >

</项目>

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


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

11.2添加classpath依赖关系

Spring Boot提供了许多“入门”，可以方便地将jar添加到你的classpath中。我们的示例应用程序已经spring-boot-starter-parent在parentPOM 的部分中使用。这spring-boot-starter-parent是一个提供有用Maven默认设置的特别启动器。它还提供了一个 dependency-management 部分，以便您可以省略version“祝福”依赖项的标签。

其他“入门者”只是提供开发特定类型的应用程序时可能需要的依赖关系。由于我们正在开发一个Web应用程序，我们将添加一个spring-boot-starter-web依赖项 - 但在此之前，让我们看看我们目前有什么。

$ mvn依赖：树

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

该mvn dependency:tree命令打印您的项目依赖项的树形表示。你可以看到，spring-boot-starter-parent它本身不提供依赖关系。让我们编辑我们的，pom.xml并添加spring-boot-starter-web该parent部分正下方的依赖关系：

<dependency> 
    <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.stereotype。*;
import org.springframework.web.bind.annotation。*;

@RestController 
@EnableAutoConfiguration
 public  class Example {

    @RequestMapping（ “/”）
    String home（）{
        返回 “Hello World！” ;
    }

    公共 静态 无效的主要（字符串[]参数）抛出异常{
        SpringApplication.run（实施例类，参数）;
    }

}

虽然这里没有太多的代码，但还是有很多。我们来看看重要的部分。

11.3.1 @RestController和@RequestMapping注解

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

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


	在`@RestController`与`@RequestMapping`注解是Spring MVC的注解（他们并不是专门针对春季启动）。有关更多详细信息，请参阅Spring参考资料中的MVC部分。

11.3.2 @EnableAutoConfiguration注释

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

11.3.3“主要”方法

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

11.4运行示例

在这一点上我们的应用程序应该工作由于我们已经使用了 spring-boot-starter-parentPOM，我们有一个有用的run目标，我们可以用它来启动应用程序。mvn spring-boot:run从根项目目录中键入以启动应用程序：

$ mvn spring-boot：运行

  。____ _ __ _ _
 / \\ / _____ __ _ _（_）_ __ __ _ \ \ \ \
（（）\ ___ |'_ |'_ | |'_ \ / _` | \ \ \ \
 \\ / ___）| | _）| | | | | || （_ | |））））
  '| ____ | .__ | _ | | _ | _ | | _ \ __，| / / / /
 ========= | _ | ============== | ___ / = / _ / _ / _ /
 :: Spring Boot ::（v1.5.2.RELEASE）
....... 。。
....... 。。（在这里输出日志）
....... 。。
........启动例2.222秒（JVM运行6.514）

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

你好，世界！

优雅地退出应用程序命中ctrl-c。

11.5创建一个可执行的jar

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

可执行的罐子和Java

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

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

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

要创建一个可执行的jar我们需要添加spring-boot-maven-plugin到我们的 pom.xml。在dependencies部分下方插入以下几行：

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


	所述`spring-boot-starter-parent`POM包括`<executions>`配置以结合`repackage`目标。如果您不使用父POM，则需要自行声明此配置。有关详细信息，请参阅插件文档。

保存pom.xml并从命令行运行mvn package：

$ mvn包

[INFO]扫描项目...
[信息]
[INFO] ----------------------------------------------- -------------------------
[INFO]构建myproject 0.0.1-SNAPSHOT
[INFO] ----------------------------------------------- -------------------------
[信息] ....
[INFO] --- maven-jar-plugin：2.4：jar（默认jar）@ myproject ---
[INFO]构建jar：/Users/developer/example/spring-boot-example/target/myproject-0.0.1-SNAPSHOT.jar
[信息]
[INFO] --- spring-boot-maven-plugin：1.5.2.RELEASE：重新包装（默认）@ myproject ---
[INFO] ----------------------------------------------- -------------------------
[信息]建立成功
[INFO] ----------------------------------------------- -------------------------

如果你看看target你应该看到的目录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 在target目录中命名的小得多的文件。这是Maven在被Spring Boot重新包装之前创建的原始jar文件。

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

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

  。____ _ __ _ _
 / \\ / _____ __ _ _（_）_ __ __ _ \ \ \ \
（（）\ ___ |'_ |'_ | |'_ \ / _` | \ \ \ \
 \\ / ___）| | _）| | | | | || （_ | |））））
  '| ____ | .__ | _ | | _ | _ | | _ \ __，| / / / /
 ========= | _ | ============== | ___ / = / _ / _ / _ /
 :: Spring Boot ::（v1.5.2.RELEASE）
....... 。。
....... 。。（在这里输出日志）
....... 。。
........在2.536秒内启动例子（运行2.864的JVM）

像以前一样，优雅地退出应用程序命中ctrl-c。

12.接下来读什么

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

在春季启动库也有一堆样品可以运行。样本独立于代码的其余部分（也就是说，您不需要构建其余的代码来运行或使用样本）。

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

第三部分使用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的所有弹簧模块以及第三方库的精炼列表。该列表可以作为标准物料清单（spring-boot-dependencies）以及Maven和 Gradle的其他专用支持。


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

13.2 Maven

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

Java 1.6作为默认的编译器级别。
UTF-8源码编码。
一个依赖管理部分，让您省去<version>了公共依赖标签，从继承的 spring-boot-dependenciesPOM。
明智的资源过滤。
明智的插件配置（exec插件， surefire， Git提交ID，阴影）。
明智的资源过滤application.properties和application.yml包括配置文件特定的文件（例如application-foo.properties和application-foo.yml）

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

13.2.1继承初始父项

要配置你的项目从spring-boot-starter-parent简单的设置继承parent：

<！ - 从Spring Boot继承默认值 - > 
<parent> 
    <groupId> org.springframework.boot </ groupId> 
    <artifactId> spring-boot-starter-parent </ artifactId> 
    <version> 1.5.2.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-parentPOM 继承。你可能有你自己的企业标准的父母，你需要使用，或者你可能只是喜欢显式声明所有的Maven配置。

如果你不想使用它spring-boot-starter-parent，你仍然可以通过使用一个scope=import 依赖来保持依赖管理（而不是插件管理）的好处：

<dependencyManagement> 
     <依赖性> 
        <相关性> 
            <！ -从春天启动的进口依存度管理- > 
            <的groupId> org.springframework.boot </的groupId> 
            <artifactId的>弹簧引导依赖</ artifactId的> 
            <版本> 1.5 .2.RELEASE </ version> 
            <type> pom </ type> 
            <scope> import </ scope> 
        </ dependency> 
    </ dependencies> 
</ dependencyManagement>

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

<dependencyManagement> 
    <依赖性> 
        <！ -覆盖由弹簧引导提供弹簧数据释放列车- > 
        <依赖性> 
            <的groupId> org.springframework.data </的groupId> 
            <artifactId的>弹簧数据releasetrain </ artifactId的> 
            <版本> Fowler-SR2 </ version> 
            <scope> import </ scope> 
            <type> pom </ type> 
        </ dependency> 
        <dependency> 
            <groupId> org.springframework.boot </ groupId> 
            <artifactId> spring-boot -dependencies </ artifactId> 
            <version>1.5.2.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文件。<plugins> 如果你想使用它，将插件添加到你的部分：

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


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

13.3 Gradle

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

储存库{
    jcenter（）
}

依赖{
    编译（“org.springframework.boot：spring-boot-starter-web：1.5.2.RELEASE”）
}

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

插件{
    ID 'org.springframework.boot'版本'1.5.2.RELEASE' 
    ID '的Java'
}


储存库{
    jcenter（）
}

依赖{
    编译（“org.springframework.boot：spring-boot-starter-web”）
    testCompile（“org.springframework.boot：spring-boot-starter-test”）
}

13.4蚂蚁

可以使用Apache Ant + Ivy构建Spring Boot项目。该 spring-boot-antlib“的antlib”模块还可以帮助蚂蚁创建可执行的JAR文件。

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

<ivy-module  version = “2.0” > 
    <info  organization = “org.springframework.boot”  module = “spring-boot-sample-ant” /> 
    <configurations> 
        <conf  name = “compile”  description = “编译该模块” /> 
        <CONF  名称 = ‘运行时’  延伸 = ‘编译’  描述 = ‘一切来运行该模块需要’ /> 
    </配置> 
    <依赖性> 
        <依赖 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.3.0.BUILD-SNAPSHOT” />

    <目标 名称 = “解析”  描述 = “ - >检索与常春藤依赖性” > 
        <常春藤：检索 模式 = “LIB / [CONF] / [工件] - [式] - [修改] [EXT]” /> 
    </目标>

    <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>

    <目标 名称 = “构建”  取决于 = “编译” > 
        <弹簧引导：exejar  destfile = “建立/ myapp.jar”  类 = “建立/类” > 
            <弹簧引导：LIB> 
                <文件集 DIR = “LIB /运行时“ /> 
            </ spring-boot：lib> 
        </ spring-boot：exejar> 
    </ target> 
</ project>


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

13.5起动

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

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

什么是名字

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

正如创建你自己的启动器部分所解释的那样，第三方启动器不应该从spring-boot为启动器官方文件保留而开始。acme通常会命名为第三方初始者acme-spring-boot-starter。

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

表13.1。Spring Boot应用程序启动器

名称	描述	双响炮
`spring-boot-starter-thymeleaf`	使用Thymeleaf视图构建MVC Web应用程序的入门者	双响炮
`spring-boot-starter-data-couchbase`	初级用于使用Couchbase面向文档的数据库和Spring Data Couchbase	双响炮
`spring-boot-starter-artemis`	使用Apache Artemis启动JMS消息传递	双响炮
`spring-boot-starter-web-services`	使用Spring Web服务的入门者	双响炮
`spring-boot-starter-mail`	Starter使用Java Mail和Spring Framework的电子邮件发送支持	双响炮
`spring-boot-starter-data-redis`	使用Spring Data Redis和Jedis客户端使用Redis键值数据存储的入门者	双响炮
`spring-boot-starter-web`	用于构建Web的入门者，包括使用Spring MVC的RESTful应用程序。使用Tomcat作为默认的嵌入容器	双响炮
`spring-boot-starter-data-gemfire`	初学者使用GemFire分布式数据存储和Spring Data GemFire	双响炮
`spring-boot-starter-activemq`	使用Apache ActiveMQ启动JMS消息传递	双响炮
`spring-boot-starter-data-elasticsearch`	入门使用Elasticsearch搜索和分析引擎和Spring Data Elasticsearch	双响炮
`spring-boot-starter-integration`	初学者使用Spring集成	双响炮
`spring-boot-starter-test`	Starter用于测试包含JUnit，Hamcrest和Mockito等库的Spring Boot应用程序	双响炮
`spring-boot-starter-jdbc`	将JDBC与Tomcat JDBC连接池配合使用的初学者	双响炮
`spring-boot-starter-mobile`	使用Spring Mobile构建Web应用程序的入门者	双响炮
`spring-boot-starter-validation`	通过Hibernate Validator使用Java Bean验证的入门者	双响炮
`spring-boot-starter-hateoas`	使用Spring MVC和Spring HATEOAS构建基于超媒体的RESTful Web应用程序的入门者	双响炮
`spring-boot-starter-jersey`	使用JAX-RS和Jersey构建RESTful Web应用程序的入门者。替代方案`spring-boot-starter-web`	双响炮
`spring-boot-starter-data-neo4j`	初学者使用Neo4j图形数据库和Spring Data Neo4j	双响炮
`spring-boot-starter-data-ldap`	初学者使用Spring Data LDAP	双响炮
`spring-boot-starter-websocket`	使用Spring Framework的WebSocket支持构建WebSocket应用程序的入门者	双响炮
`spring-boot-starter-aop`	使用Spring AOP和AspectJ进行面向方面编程的入门者	双响炮
`spring-boot-starter-amqp`	使用Spring AMQP和Rabbit MQ的入门者	双响炮
`spring-boot-starter-data-cassandra`	入门使用Cassandra分布式数据库和Spring Data Cassandra	双响炮
`spring-boot-starter-social-facebook`	首先使用Spring社交Facebook	双响炮
`spring-boot-starter-jta-atomikos`	使用Atomikos启动JTA交易	双响炮
`spring-boot-starter-security`	Starter使用Spring Security	双响炮
`spring-boot-starter-mustache`	使用Mustache视图构建MVC Web应用程序的入门者	双响炮
`spring-boot-starter-data-jpa`	使用Spring数据JPA与Hibernate的入门	双响炮
`spring-boot-starter`	核心启动器，包括自动配置支持，日志记录和YAML	双响炮
`spring-boot-starter-groovy-templates`	使用Groovy模板视图构建MVC Web应用程序的入门者	双响炮
`spring-boot-starter-freemarker`	使用FreeMarker视图构建MVC Web应用程序的入门者	双响炮
`spring-boot-starter-batch`	使用Spring Batch的入门者	双响炮
`spring-boot-starter-social-linkedin`	使用Spring社交LinkedIn的站点	双响炮
`spring-boot-starter-cache`	初学者使用Spring框架的缓存支持	双响炮
`spring-boot-starter-data-solr`	启动Spring Data Solr使用Apache Solr搜索平台	双响炮
`spring-boot-starter-data-mongodb`	入门使用MongoDB面向文档的数据库和Spring Data MongoDB	双响炮
`spring-boot-starter-jooq`	使用jOOQ访问SQL数据库的入门者。`spring-boot-starter-data-jpa`或者的替代方法`spring-boot-starter-jdbc`	双响炮
`spring-boot-starter-jta-narayana`	春天启动Narayana JTA起动器	双响炮
`spring-boot-starter-cloud-connectors`	使用Spring Cloud连接器的入门，可简化Cloud Foundry和Heroku等云平台中的服务连接	双响炮
`spring-boot-starter-jta-bitronix`	使用Bitronix启动JTA事务	双响炮
`spring-boot-starter-social-twitter`	使用Spring社交Twitter的入门者	双响炮
`spring-boot-starter-data-rest`	使用Spring Data REST通过REST公开Spring数据存储库的初学者	双响炮

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

表13.2。Spring Boot生产启动器

名称	描述	双响炮
`spring-boot-starter-actuator`	使用Spring Boot的执行器提供生产准备功能，帮助您监控和管理您的应用程序	双响炮
`spring-boot-starter-remote-shell`	Starter使用CRaSH远程shell通过SSH监视和管理您的应用程序。自1.5以来已弃用	双响炮

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

表13.3。Spring Boot技术首发

名称	描述	双响炮
`spring-boot-starter-undertow`	使用Undertow作为嵌入式servlet容器的初学者。替代方案`spring-boot-starter-tomcat`	双响炮
`spring-boot-starter-jetty`	使用Jetty作为嵌入式servlet容器的入门。替代方案`spring-boot-starter-tomcat`	双响炮
`spring-boot-starter-logging`	Starter使用Logback进行日志记录。默认日志启动器	双响炮
`spring-boot-starter-tomcat`	使用Tomcat作为嵌入式servlet容器的入门。默认的servlet容器启动器使用`spring-boot-starter-web`	双响炮
`spring-boot-starter-log4j2`	使用Log4j2进行日志记录的入门者。替代方案`spring-boot-starter-logging`	双响炮


	有关其他社区的列表贡献首先，看 README文件中 `spring-boot-starters`GitHub上的模块。

14.构建你的代码

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

14.1使用“默认”软件包

当一个类不包含package声明时，它被认为是在“默认包”中。通常不鼓励使用“默认软件包”，应该避免使用“默认软件包”。这可能会导致使用Spring的启动应用程序的特殊问题@ComponentScan，@EntityScan或@SpringBootApplication注解，因为从每一个罐子每一个类，将被读取。


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

14.2找到主应用程序类

我们通常建议您将主应用程序类放在其他类的根包中。该@EnableAutoConfiguration注解往往放在你的主类，它隐含地定义为某些项目一基地“搜索包”。例如，如果您正在编写JPA应用程序，@EnableAutoConfiguration则将使用带注释的类的包来搜索@Entity项目。

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

这是一个典型的布局：

COM
 +  - 例子
     +  - 我的项目
         +  -  Application.java
         |
         +  - 域
         | +  -  Customer.java
         | +  -  CustomerRepository.java
         |
         +  - 服务
         | +  -  CustomerService.java
         |
         +  - 网络
             +  -  CustomerController.java

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

包 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（应用类，参数）;
    }

}

15.配置类

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


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

15.1导入其他配置类

你不需要把所有的@Configuration东西都放到一个班上。所述@Import 注释可以用于导入额外的配置类。或者，您可以使用@ComponentScan自动获取所有Spring组件，包括 @Configuration类。

15.2导入XML配置

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

16.自动配置

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

您需要选择加入@EnableAutoConfiguration或 @SpringBootApplication注释到您的一个@Configuration类自动配置。


	你只能添加一个`@EnableAutoConfiguration`注释。我们通常建议您将其添加到您的主`@Configuration`类。

16.1逐渐更换自动配置

自动配置是非侵入式的，您可以随时开始定义自己的配置来替换自动配置的特定部分。例如，如果添加自己的DataSourceBean，则默认的嵌入式数据库支持将退出。

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

16.2禁用特定的自动配置

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

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.春豆和依赖注入

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

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

这是一个@Service使用构造函数注入来获取所需RiskAssessorbean 的示例Bean 。

包 com.example.service;

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

@Service
公共 类 DatabaseAccountService实现 AccountService {

    私人 最终 RiskAssessssor风险评估师;

    @Autowired
     public DatabaseAccountService（RiskAssessor riskAssessor）{
         this .riskAssessor = riskAssessor;
    }

    // ...

}

如果一个bean有一个构造函数，你可以省略@Autowired。

@Service
公共 类 DatabaseAccountService实现 AccountService {

    私人 最终 RiskAssessssor风险评估师;

    public DatabaseAccountService（RiskAssessor riskAssessor）{
         this .riskAssessor = riskAssessssor;
    }

    // ...

}


	请注意如何使用构造函数注入允许该`riskAssessor`字段被标记为`final`，指示它不能随后更改。

18.使用@SpringBootApplication注释

许多春季引导开发者总是有其主类注解为@Configuration， @EnableAutoConfiguration和@ComponentScan。由于这些注释经常一起使用（特别是如果您遵循以上最佳实践），Spring Boot提供了一个方便的@SpringBootApplication选择。

该@SpringBootApplication注解相当于使用@Configuration， @EnableAutoConfiguration并@ComponentScan与他们的默认属性：

包 com.example.myproject;

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

@SpringBootApplication  //与@Configuration相同@EnableAutoConfiguration @ComponentScan 
public  class Application {

    public  static  void main（String [] args）{
        SpringApplication.run（应用类，参数）;
    }

}


	`@SpringBootApplication`还提供了别名定制的属性 `@EnableAutoConfiguration`和`@ComponentScan`。

19.运行你的应用程序

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


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

19.1从IDE运行

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

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


	如果您不小心运行了两次Web应用程序，则会看到“端口已被使用”错误。STS用户可以使用该`Relaunch`按钮，而不是`Run`确保任何现有的实例关闭。

19.2作为打包应用程序运行

如果您使用Spring Boot Maven或Gradle插件来创建可执行的jar文件，您可以使用它来运行您的应用程序java -jar。例如：

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

也可以运行打包的应用程序并启用远程调试支持。这使您可以将调试器附加到打包的应用程序中：

$ java -Xdebug -Xrunjdwp：server = y，transport = dt_socket，address = 8000，suspend = n \
       -jar target / myproject-0.0.1-SNAPSHOT.jar

19.3使用Maven插件

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

$ mvn spring-boot：运行

您可能还想使用有用的操作系统环境变量：

$ export MAVEN_OPTS = -Xmx1024m -XX：MaxPermSize = 128M

19.4使用Gradle插件

Spring Boot Gradle插件还包含一个bootRun可用于以分解形式运行应用程序的任务。该bootRun每当你导入的任务添加spring-boot-gradle-plugin：

$ gradle bootRun

您可能也想使用这个有用的操作系统环境变量：

$ export JAVA_OPTS = -Xmx1024m -XX：MaxPermSize = 128M

19.5热插拔

由于Spring Boot应用程序只是普通的Java应用程序，所以JVM热插拔应该是开箱即用的。JVM热交换在某种程度上受限于它可以替换的字节码，为了获得更完整的解决方案，可以使用JRebel或 Spring Loaded项目。该 spring-boot-devtools模块还包括支持快速重新启动应用程序。

有关详细信息，请参阅下面的第20章开发人员工具部分和热插拔“操作方法”。

20.开发人员工具

Spring Boot包含一组额外的工具，可以使应用程序开发体验更愉快。该spring-boot-devtools模块可以包含在任何项目中以提供额外的开发时间功能。要包含devtools支持，只需将模块依赖关系添加到您的版本：

Maven的。

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

摇篮。

依赖{
    编译（“org.springframework.boot：spring-boot-devtools”）
}

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


	重新打包的档案在默认情况下不包含devtools。如果你想使用某些远程devtools功能，你需要禁用 `excludeDevtools`build属性来包含它。该属性支持Maven和Gradle插件。

20.1属性默认值

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

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

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


	有关应用的属性的完整列表，请参阅 DevToolsPropertyDefaultsPostProcessor。

20.2自动重启

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


	您也可以通过受支持的构建插件（即Maven和Gradle）启动您的应用程序，只要启用了分叉功能，因为DevTools需要隔离的应用程序类加载器才能正常运行。当Gradle和Maven在类路径中检测到DevTools时，默认会这样做。


	与LiveReload一起使用时，自动重新启动的效果非常好。详情请参阅下文。如果使用JRebel，自动重新启动将被禁用，以支持动态类重新加载。其他devtools功能（如LiveReload和属性覆盖）仍然可以使用。


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


	当决定是否在类路径中的条目应该触发重新启动时，它的变化，DevTools自动忽略命名的项目`spring-boot`，`spring-boot-devtools`，`spring-boot-autoconfigure`，`spring-boot-actuator`，和`spring-boot-starter`。

重新启动vs重新加载

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

如果您发现重新启动对于您的应用程序来说不够快，或者遇到类加载问题，则可以考虑从ZeroTurnaround中重新加载技术，例如 JRebel。这些工作通过重写类，因为他们被加载，使他们更容易重新加载。 Spring Loaded提供了另一种选择，但是它不支持许多框架，并且没有商业支持。

20.2.1排除资源

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

spring.devtools.restart.exclude =静态/ **，公共/ **


	如果您想保留这些默认值并添加额外的排除项，请改用该 `spring.devtools.restart.additional-exclude`属性。

20.2.2看额外的路径

您可能希望在更改不在类路径中的文件时重新启动或重新加载应用程序。为此，请使用该 spring.devtools.restart.additional-paths属性来配置其他路径以查看更改。您可以使用spring.devtools.restart.exclude属性上述控制的其他路径下的变化是否会引发全面重启或只是一个活的重载。

20.2.3禁用重启

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

如果您需要完全禁用重新启动支持，例如，因为它不适用于特定的库，则需要System在调用之前设置属性 SpringApplication.run(…)。例如：

public  static  void main（String [] args）{
    System.setProperty（“spring.devtools.restart.enabled”，“false”）;
    SpringApplication.run（MyApp的类，参数）;
}

20.2.4使用触发文件

如果您使用连续编译已更改文件的IDE，则可能只希望在特定时间触发重新启动。要做到这一点，你可以使用“触发文件”，这是一个特殊的文件，当你想要实际触发重新启动检查时，必须修改这个文件。只更改文件会触发检查，只有Devtools检测到必须执行某些操作时才会重新启动。触发文件可以手动更新，也可以通过IDE插件进行更新。

要使用触发器文件，请使用该spring.devtools.restart.trigger-file属性。


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

20.2.5定制重启classloader

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

默认情况下，IDE中的任何打开的项目都将使用“重新启动”类加载器来加载，而任何常规.jar文件将使用“基本”类加载器加载。如果您使用多模块项目，而不是将每个模块导入到IDE中，则可能需要自定义项目。要做到这一点，你可以创建一个META-INF/spring-devtools.properties文件。

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

例如：

restart.exclude.companycommonlibs = / MyCorp的共用- [\\瓦特- ]。+ \罐子
 restart.include.projectcommon = / MyCorp的-的Myproj - [\\瓦特- ]。+ \罐


	所有的财产钥匙必须是唯一的。只要财产始于 `restart.include.`或`restart.exclude.`将被考虑。


	所有`META-INF/spring-devtools.properties`来自classpath的将被加载。您可以将文件打包到项目中，也可以打包到项目使用的库中。

20.2.6已知的限制

对于使用标准进行反序列化的对象，重新启动功能无法正常工作ObjectInputStream。如果你需要反序列化数据，你可能需要ConfigurableObjectInputStream结合Spring 使用 Thread.currentThread().getContextClassLoader()。

不幸的是，有些第三方库反序列化，而不考虑上下文类加载器。如果您发现这样的问题，您需要向原作者请求修复。

20.3 LiveReload

该spring-boot-devtools模块包含一个嵌入式LiveReload服务器，可用于在资源发生更改时触发浏览器刷新。LiveReload浏览器扩展可从livereload.com的 Chrome，Firefox和Safari免费获得。

如果您不想在应用程序运行时启动LiveReload服务器，则可以将该spring.devtools.livereload.enabled属性设置为false。


	一次只能运行一个LiveReload服务器。在开始您的应用程序之前，请确保没有其他LiveReload服务器正在运行。如果您从IDE启动多个应用程序，则只有第一个应用程序支持LiveReload。

20.4全局设置

您可以通过添加一个文件名为配置全局devtools设置 .spring-boot-devtools.properties你的$HOME文件夹（注意：文件名开头“”）。添加到此文件的任何属性都将应用于使用devtools的计算机上的所有 Spring Boot应用程序。例如，要将重新启动配置为始终使用触发器文件，可以添加以下内容：

〜/ .spring引导-devtools.properties。

spring.devtools.reload.trigger-file = .reloadtrigger

20.5远程应用程序

Spring Boot开发人员工具不仅限于本地开发。您还可以在远程运行应用程序时使用多个功能。远程支持是选择性的，为了启用它，您需要确保devtools包含在重新打包的存档中：

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

那么你需要设置一个spring.devtools.remote.secret属性，例如：

spring.devtools.remote.secret = mysecret


	启用`spring-boot-devtools`远程应用程序是一个安全风险。您不应该在生产部署上启用支持。

远程devtools支持分两部分提供; 有一个接受连接的服务器端点以及您在IDE中运行的客户端应用程序。在spring.devtools.remote.secret设置属性时，服务器组件会自动启用。客户端组件必须手动启动。

20.5.1运行远程客户端应用程序

远程客户端应用程序旨在从您的IDE中运行。您需要org.springframework.boot.devtools.RemoteSpringApplication使用与您要连接的远程项目相同的类路径运行。传递给应用程序的非选项参数应该是您要连接到的远程URL。

例如，如果您使用的是Eclipse或STS，并且您有一个my-app已经部署到Cloud Foundry的项目，则可以执行以下操作：

选择Run Configurations…从Run菜单。
创建一个新的Java Application“启动配置”。
浏览该my-app项目。
使用org.springframework.boot.devtools.RemoteSpringApplication作为主类。
添加https://myapp.cfapps.io到Program arguments（或任何您的远程URL是）。

正在运行的远程客户端将如下所示：

  。____ _ __ _ _
 / \\ / _____ __ _ _（_）_ __ _ _ ___ _ \ \ \ \
（（）\ ___ |'_ |'_ | |'_ \ / _` | | _ \ ___ _ __ ___ | | _ ___ \ \ \ \
 \\ / ___）| | _）| | | | | || （_ | [] :::::: [] / -_）'\ / _ \ _ / -_）））））
  '| ____ | .__ | _ | | _ | _ | | _ \ __，| | _ | _ \ ___ | _ | _ | _ \ ___ / \ __ \ ___ | / / / /
 ========= | _ | ============== | ___ / ===================== ============== / _ / _ / _ /
 :: Spring Boot Remote :: 1.5.2.RELEASE

2015-06-10 18：25：06.632信息14938 --- [main] osbdevtools.RemoteSpringApplication：在pwmbp上用PID 14938启动RemoteSpringApplication（/ Users / pwebb / projects / spring-boot / code / spring-boot-devtools / target / classes在/ Users / pwebb / projects / spring-boot / code / spring-boot-samples / spring-boot-sample-devtools中由pwebb启动）
2015-06-10 18：25：06.671 INFO 14938 --- [main] scaAnnotationConfigApplicationContext：Refreshing org.spring framework.context.annotation.AnnotationConfigApplicationContext @ 2a17b7b6：启动日期[Wed Jun 10 18:25:06 PDT 2015]; 上下文层次的根
2015-06-10 18：25：07.043 WARN 14938 --- [main] osbdrcRemoteClientConfiguration：连接到http：// localhost：8080是不安全的。您应该使用以“https：//”开头的网址。
2015-06-10 18：25：07.074信息14938 --- [main] osbdaOptionalLiveReloadServer：LiveReload服务器端口35729上运行
2015-06-10 18：25：07.130信息14938 --- [main] osbdevtools.RemoteSpringApplication：在0.74秒内启动RemoteSpringApplication（JVM运行为1.105）


	由于远程客户端使用与实际应用程序相同的类路径，因此可以直接读取应用程序属性。这是如何`spring.devtools.remote.secret` 读取属性并传递给服务器进行身份验证。


	总是建议使用`https://`连接协议，以便流量被加密并且密码不被拦截。


	如果您需要使用代理来访问远程应用程序，请配置 `spring.devtools.remote.proxy.host`和`spring.devtools.remote.proxy.port`属性。

20.5.2远程更新

远程客户端将以与本地重启相同的方式监视您的应用程序类路径的更改。任何更新的资源将被推送到远程应用程序，并（如果需要）触发重新启动。如果您正在迭代使用您本地没有的云服务的功能，这可能会非常有帮助。通常远程更新和重新启动比完整的重建和部署周期快得多。


	只有远程客户端正在运行时才监视文件。如果在启动远程客户端之前更改文件，则不会将其推送到远程服务器。

20.5.3远程调试隧道

Java远程调试在诊断远程应用程序的问题时非常有用。不幸的是，当您的应用程序部署在数据中心之外时，并不总是可以启用远程调试。如果您使用基于容器的技术（例如Docker），则远程调试也可能非常棘手。

为了帮助解决这些限制，devtools支持通过HTTP隧道传输远程调试流量。远程客户端在端口上提供本地服务器8000，您可以将其附加到远程调试器。建立连接后，调试流量将通过HTTP发送到远程应用程序。spring.devtools.remote.debug.local-port 如果您想使用其他端口，则可以使用该属性。

您需要确保您的远程应用程序在启用远程调试的情况下启动。通常这可以通过配置来实现JAVA_OPTS。例如，使用Cloud Foundry，您可以将以下内容添加到您的manifest.yml：

--- 
    env：
         JAVA_OPTS：“-Xdebug -Xrunjdwp：server = y，transport = dt_socket，suspend = n”


	请注意，您不需要传递`address=NNNN`选项`-Xrunjdwp`。如果省略，Java将简单地选取一个随机空闲端口。


	通过Internet调试远程服务可能会很慢，您可能需要增加IDE中的超时。例如，在Eclipse中，您可以选择`Java`→ `Debug` from `Preferences…`并将其更改`Debugger timeout (ms)`为更适合的值（`60000`在大多数情况下运行良好）。

在IntelliJ IDEA中使用远程调试通道时，必须将所有断点配置为挂起线程而不是VM。默认情况下，IntelliJ IDEA中的断点会挂起整个虚拟机，而不是挂起命中断点的线程。这具有暂停管理远程调试通道的线程的不良副作用，导致您的调试会话冻结。在IntelliJ IDEA中使用远程调试通道时，应将所有断点配置为挂起线程而不是VM。请参阅 IDEA-165769了解更多详情。

21.包装您的生产应用程序

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

对于其他“生产就绪”功能，如健康，审计和度量REST或JMX端点; 考虑加入spring-boot-actuator。有关详细信息，请参阅 第五部分“弹簧执行器：生产就绪功能”。

22.接下来读什么

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

第四部分 Spring Boot功能

本节将深入探讨Spring Boot的细节。在这里，您可以了解要使用和定制的关键功能。如果还没有，可能需要阅读第II部分“入门”和 第III部分“使用Spring Boot”部分，以便您了解基础知识。

23. SpringApplication

本SpringApplication类提供了一个方便的方式来引导，将来自启动Spring应用程序main()的方法。在许多情况下，你可以委托给静态SpringApplication.run方法：

public  static  void main（String [] args）{
    SpringApplication.run（MySpringConfiguration 类，参数）;
}

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

  。____ _ __ _ _
 / \\ / _____ __ _ _（_）_ __ __ _ \ \ \ \
（（）\ ___ |'_ |'_ | |'_ \ / _` | \ \ \ \
 \\ / ___）| | _）| | | | | || （_ | |））））
  '| ____ | .__ | _ | | _ | _ | | _ \ __，| / / / /
 ========= | _ | ============== | ___ / = / _ / _ / _ /
 :: Spring Boot :: v1.5.2.RELEASE

2013-07-31 00：08：16.117 INFO 56603 --- [main] osbsapp.SampleApplication：在我的电脑上用PID 56603启动SampleApplication v0.1.0（/apps/myapp.jar由pwebb启动）
2013-07-31 00：08：16.166 INFO 56603 --- [main] ationConfigEmbeddedWebApplicationContext：Refreshing org.springframework.boot .context.embedded.AnnotationConfigEmbeddedWebApplicationContext @ 6e5a8246：startup date [Wed Jul 31 00:08:16 PDT 2013]; 上下文层次的根
2014-03-04 13：09：54.912信息41370 --- [main] .t.TomcatEmbeddedServletContainerFactory：服务器初始化端口：8080
2014-03-04 13：09：56.501 INFO 41370 --- [main] osbsapp.SampleApplication：在2.992秒内启动SampleApplication（运行JVM 3.658）

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

23.1启动失败

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

***************************
应用程序无法启动
***************************

描述：

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

行动：

识别并停止在端口8080上侦听的进程或配置此应用程序在另一个端口上侦听。


	Spring Boot提供了很多的`FailureAnalyzer`实现，你可以很容易地添加你自己的。

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

例如，如果您正在使用您的应用程序运行您java -jar可以启用该 debug属性，如下所示：

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

23.2自定义横幅

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

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

表23.1。横幅变量

变量	描述
`${application.version}`	您申请的申请版本号`MANIFEST.MF`。例如`Implementation-Version: 1.0`打印为`1.0`。
`${application.formatted-version}`	您的应用程序的版本号`MANIFEST.MF`格式化为显示格式（包围括号并以前缀`v`）。例如`(v1.0)`。
`${spring-boot.version}`	您正在使用的Spring Boot版本。例如`1.5.2.RELEASE`。
`${spring-boot.formatted-version}`	您正在使用的弹簧启动版本被格式化显示（用方括号括起并且前缀`v`）。例如`(v1.5.2.RELEASE)`。
`${Ansi.NAME}`（或`${AnsiColor.NAME}`，`${AnsiBackground.NAME}`，`${AnsiStyle.NAME}`）	`NAME`ANSI转义代码的名称在哪里？见`AnsiPropertySource`细节。
`${application.title}`	你在申请中申请的标题`MANIFEST.MF`。例如`Implementation-Title: MyApp`打印为`MyApp`。


	`SpringApplication.setBanner(…)`如果要以编程方式生成横幅，则可以使用该方法。使用`org.springframework.boot.Banner`接口并实现您自己的`printBanner()`方法。

您也可以使用该spring.main.banner-mode属性来确定是否必须使用已配置的记录器（）或不是（all ）System.out（console）打印横幅log（off）。

打印的横幅将在名称下注册为一个singleton bean springBootBanner。

YAML映射off到false所以确保添加引号，如果你想在应用程序中禁用横幅。

春天：
     主要：
         横幅模式：“关闭”

23.3定制SpringApplication

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

public  static  void main（String [] args）{
    SpringApplication应用= 新 SpringApplication（MySpringConfiguration。类）;
    app.setBannerMode（Banner.Mode.OFF）;
    app.run（参数）;
}


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

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

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

23.4流利构建器API

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

将SpringApplicationBuilder让您链在一起的多个方法调用，包括parent和child，让您创建一个层次结构的方法。

例如：

新的 SpringApplicationBuilder（）
        .sources（父类）
        .child（应用程序类）
        .bannerMode（Banner.Mode.OFF）
        .RUN（参数）;


	在创建`ApplicationContext`层次结构时有一些限制，例如，Web组件必须包含在子上下文中，并且`Environment` 将同时用于父和子上下文。请参阅`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

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

An ApplicationStartingEvent在运行开始时发送，但是在除了监听器和初始化器的注册之外的任何处理之前。
在上下文中使用的情况下，但在创建上下文之前ApplicationEnvironmentPreparedEvent发送An Environment。
ApplicationPreparedEvent在刷新开始之前发送一个，但在bean定义被加载之后。
ApplicationReadyEvent在刷新之后发送一个并且已经处理了任何相关的回调以指示应用准备好为请求提供服务。
ApplicationFailedEvent如果启动时出现异常，则发送An 。


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

23.6网络环境

A SpringApplication将会尝试以ApplicationContext您的名义创建正确的类型。默认情况下，将使用AnnotationConfigApplicationContext或AnnotationConfigEmbeddedWebApplicationContext将被使用，这取决于您是否正在开发Web应用程序。

用于确定“Web环境”的算法相当简单（基于少数类的存在）。setWebEnvironment(boolean webEnvironment)如果您需要覆盖默认值，您可以使用。

也可以完全控制ApplicationContext将被调用的类型setApplicationContextClass(…)。


	在JUnit测试中`setWebEnvironment(false)`使用时通常需要调用`SpringApplication`。

23.7访问应用程序参数

如果您需要访问传递给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
公共 类 MyBean {

    @Autowired
     public MyBean（ApplicationArguments args）{
         boolean debug = args.containsOption（ “debug”）;
        List <String> files = args.getNonOptionArgs（）;
        //如果用“--debug logfile.txt”debug = true，files = [“logfile.txt”]
    }

}


	Spring Boot也将`CommandLinePropertySource`与Spring 注册一个`Environment`。这使您可以使用`@Value`注释来注入单个应用程序参数。

23.8使用ApplicationRunner或CommandLineRunner

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

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

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

@Component
公共 类 MyBean实现了 CommandLineRunner {

    公共 无效运行（字符串...参数）{
         //做些什么...
    }

}

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

23.9申请退出

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

另外，org.springframework.boot.ExitCodeGenerator 如果bean 在应用程序结束时希望返回特定的退出代码，则它们可以实现该接口。

23.10管理员功能

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


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


	启用此功能时要小心，因为MBean公开了一种关闭应用程序的方法。

24.外部化配置

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

Spring Boot使用了一个非常特殊的PropertySource命令，旨在让值得注意的重写。属性按以下顺序考虑：

在主目录上开发Devtools全局设置属性（~/.spring-boot-devtools.properties当devtools处于活动状态时）。
@TestPropertySource 您的测试中的注释。
@SpringBootTest#properties 注释属性在您的测试。
命令行参数。
从属性SPRING_APPLICATION_JSON（内联JSON嵌入在环境变量或系统特性）
ServletConfig 初始化参数。
ServletContext 初始化参数。
来自JNDI的属性java:comp/env。
Java系统属性（System.getProperties()）。
OS环境变量。
一个RandomValuePropertySource只有属性random.*。
打包jar（application-{profile}.properties和YAML变种）之外的特定于配置文件的应用程序属性
打包在您的jar（application-{profile}.properties 和YAML变体）中的特定于配置文件的应用程序属性
包装jar（application.properties和YAML变体）之外的应用程序属性。
打包在jar中的应用程序属性（application.properties和YAML变体）。
@PropertySource 在你的@Configuration课堂上的注释。
默认属性（使用指定SpringApplication.setDefaultProperties）。

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

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

@Component
公共 类 MyBean {

    @Value（“$ {name}”）
    私人字符串名称;

    // ...

}

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

这些SPRING_APPLICATION_JSON属性可以通过环境变量在命令行中提供。例如在一个UN * X shell中：

$ SPRING_APPLICATION_JSON ='{“foo”：{“bar”：“spam”}}'java -jar myapp.jar

在这个例子中，你将foo.bar=spam在春天结束Environment。您也可以像spring.application.json在系统变量中那样提供JSON ：

$ java -Dspring.application.json ='{“foo”：“bar”}'-jar myapp.jar

或命令行参数：

$ java -jar myapp.jar --spring.application.json ='{“foo”：“bar”}'

或者作为一个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]}

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

24.2访问命令行属性

默认情况下，SpringApplication会将任何命令行选项参数（以' - '开头--server.port=9000）转换为property并添加到Spring中 Environment。如上所述，命令行属性总是优先于其他属性源。

如果您不想将命令行属性添加到Environment您可以使用禁用它们SpringApplication.setAddCommandLineProperties(false)。

24.3应用程序属性文件

SpringApplication将从application.properties以下位置的文件加载属性并将其添加到Spring Environment：

一个/config当前目录下的子目录。
当前目录
一个类路径/config包
类路径根

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


	您也可以使用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 env，系统属性或命令行参数）。

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

classpath:,classpath:/config,file:,file:config/ 总是使用默认的搜索路径，而不考虑其值spring.config.location。此搜索路径按从低到高的顺序排列（file:config/胜出）。如果您确实指定了自己的位置，则它们优先于所有默认位置，并使用相同的从最低到最高的优先顺序。通过这种方式，您可以为您的应用程序application.properties（或您选择的其他基本名称 spring.config.name）设置默认值，并在运行时使用不同的文件覆盖它，保持默认值。


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


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

24.4配置文件特定的属性

除application.properties文件外，还可以使用命名约定来定义配置文件特定的属性application-{profile}.properties。在 Environment具有一组默认的配置文件（默认情况下[default]，如果没有激活的配置文件设置其中使用）（即，如果配置文件没有显式地激活然后从属性application-default.properties加载）。

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

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


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

24.5属性中的占位符

这些值在application.properties被使用的Environment 时候会被现有的过滤掉，所以你可以返回到以前定义的值（例如从系统属性中）。

app.name = MyApp
 app.description = $ {app.name}是一个Spring Boot应用程序


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

24.6使用YAML而不是属性

YAML是JSON的超集，因此是用于指定分层配置数据的非常方便的格式。该SpringApplication课程将自动支持YAML作为一种替代性，只要你有 SnakeYAML在classpath库。


	如果使用“Starter”，SnakeYAML将会自动提供 `spring-boot-starter`。

24.6.1加载YAML

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

例如，下面的YAML文件：

环境：
     dev：
         url：http://dev.bar.com
         名称：开发人员设置
     prod：
         url：http://foo.bar.com
         名称：我的酷应用程序

将被转化为这些属性：

environments.dev.url = http：//dev.bar.com
 environments.dev.name =开发人员设置
 environments.prod.url = http：//foo.bar.com
 environments.prod.name =我的酷应用程序

YAML列表被表示为具有[index]解引用的属性键，例如这个YAML：

我：
    服务器：
       -  dev.bar.com
       -  foo.bar.com

将被转化为这些属性：

my.servers [0] = dev.bar.com
 my.servers [1] = foo.bar.com

要使用Spring DataBinder实用程序绑定到类似的属性（这是什么 @ConfigurationProperties），你需要在java.util.List（或Set）类型的目标bean中拥有一个属性，并且你需要提供一个setter，或者用一个可变值初始化它，例如this将绑定到上面的属性

@ConfigurationProperties（prefix =“my”）
 public  class Config {

    private List <String> servers = new ArrayList <String>（）;

    公共列表<字符串> getServers（）{
         返回 这个 .servers;
    }
}

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

这个YamlPropertySourceLoader类可以用来在YAML中作为PropertySource Spring的一个Environment。这使您可以使用@Value带有占位符语法的熟悉注释来访问YAML属性。

24.6.3多文件YAML文件

您可以通过使用一个spring.profiles键来指定文档应用的时间，在单个文件中指定多个特定于配置文件的YAML文档。例如：

服务器：
     地址：192.168。1.100 
--- 
spring：
     profiles：开发
 服务器：
     地址：127.0。0.1 
--- 
春天：
     配置文件：生产
 服务器：
     地址：192.168。1.120

在上面的示例中，如果配置文件处于活动状态，则该server.address属性为。如果和配置文件没有启用，那么属性的值将是。127.0.0.1developmentdevelopmentproduction192.168.1.100

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

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

而在这个例子中，密码总是被设置的，因为它没有被附加到任何配置文件，并且必须在所有其他配置文件中显式重置，如有必要：

服务器：
   端口：8000 
安全性：
   用户：
     密码：弱

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

24.6.4 YAML的缺点

YAML文件不能通过@PropertySource注释加载。所以在需要以这种方式加载值的情况下，您需要使用一个属性文件。

24.6.5合并YAML列表

正如我们上面看到的，任何YAML内容最终都会转换为属性。当通过配置文件覆盖“列表”属性时，该过程可能不直观。

例如，假定默认情况下MyPojo具有name和description属性的对象null。让我们揭露的名单MyPojo来自FooProperties：

@ConfigurationProperties（“foo”）
公共 类 FooProperties {

    private  final List <MyPojo> list = new ArrayList <>（）;

    public List <MyPojo> getList（）{
         return  this .list;
    }

}

考虑以下配置：

foo：
   list：
     -  name：my name
       description：my description
 --- 
spring：
   profiles：dev
 foo：
   list：
     -  name：my another name

如果dev配置文件不活跃，FooProperties.list将包含MyPojo上面定义的一个条目。如果dev配置文件但是启用后，list将仍然只有一项（名称为“我的另一名”和说明null）。此配置不会将第二个MyPojo实例添加到列表中，也不会合并这些项目。

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

foo：
   list：
     -  name：my name
       description：my description
     -  name：another name
       description：another description
 --- 
spring：
   profiles：dev
 foo：
   list：
      -  name：my another name

在上面的示例中，考虑到dev配置文件处于活动状态，FooProperties.list 将包含一个 MyPojo条目（名称为“我的另一个名称”和说明null）。

24.7类型安全的配置属性

使用@Value("${property}")注释来注入配置属性有时会很麻烦，特别是如果您正在使用多个属性或者您的数据是分层的。Spring Boot提供了另一种使用属性的方法，允许强类型的bean管理和验证应用程序的配置。

包 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（“foo”）
公共 类 FooProperties {

    私有 布尔启用;

    私人 InetAddress remoteAddress;

    私人 最终安全安全= 新安全（）;

    public  boolean isEnabled（）{...}

    public  void setEnabled（boolean enabled）{...}

    公共 InetAddress getRemoteAddress（）{...}

    public  void setRemoteAddress（InetAddress remoteAddress）{...}

    公众安全getSecurity（）{...}

    公共 静态 类安全{

        私人字符串用户名

        私人字符串密码;

        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定义了以下属性：

foo.enabled，false默认情况下
foo.remote-address，可以被强制的类型 String
foo.security.username，一个嵌套的“安全”，其名称由财产的名称决定。特别是返回类型没有在那里使用，本来可以的SecurityProperties
foo.security.password
foo.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（FooProperties.class）
 public  class MyConfiguration {
}

当@ConfigurationPropertiesbean以这种方式注册时，这个bean将具有一个常规的名称：<prefix>-<fqn>，其中<prefix>是@ConfigurationProperties注释中指定的环境键前缀<fqn>，以及bean的完全限定名。如果注释不提供任何前缀，则只使用bean的完全限定名称。

在上面的例子中的bean名称将是foo-com.example.FooProperties。

即使上面的配置会创建一个正常的bean FooProperties，我们建议@ConfigurationProperties只处理环境，特别是不会从上下文中注入其他bean。话虽如此，@EnableConfigurationProperties注释也会自动应用到您的项目中，以便任何现有的注释的bean @ConfigurationProperties都将被配置Environment。你可以MyConfiguration通过确定FooProperties已经是一个bean 来实现上面的快捷方式：

@Component 
@ConfigurationProperties（prefix =“foo”）
 public  class FooProperties {

    // ... 往上看

}

这种风格的配置对SpringApplication外部YAML配置特别适用：

＃application.yml

foo：
     remote-address：192.168。1.1 
    安全性：
         用户名：foo
         角色：
          - 用户
          - 管理员

＃根据需要额外配置

要使用@ConfigurationPropertiesbean，您可以像注入其他bean一样注入它们。

@Service
公共 类 MyService {

    私人 最终的 FooProperties属性;

    @Autowired
     public MyService（FooProperties属性）{
         this .properties = properties;
    }

     // ...

    @PostConstruct
     public  void openConnection（）{
        Server server = new Server（this .properties.getRemoteAddress（））;
        // ...
    }

}


	使用`@ConfigurationProperties`还可以生成元数据文件，IDE可以使用这些元数据文件为自己的密钥提供自动完成功能，详情请参阅附录B，配置元数据附录。

24.7.1第三方配置

除了使用@ConfigurationProperties注释类之外，您还可以在公共@Bean方法中使用它。如果要将属性绑定到不受控制的第三方组件，这可能特别有用。

要从Environment属性配置一个bean ，添加@ConfigurationProperties到它的bean注册：

@ConfigurationProperties（prefix =“bar”）
@Bean
 public BarComponent barComponent（）{
    ...
}

用bar前缀定义的任何属性都将以与上例BarComponent类似的方式映射到该bean FooProperties上。

24.7.2轻松绑定

Spring Boot使用一些宽松的规则来绑定Environment到@ConfigurationPropertiesbean的属性，所以不需要在Environment属性名称和bean属性名称之间完全匹配。常见的例子，这是有用的包括虚线分隔（如context-path绑定contextPath），并大写（如PORT绑定port）环境属性。

例如，给以下@ConfigurationProperties班级：

@ConfigurationProperties（prefix =“person”）
 public  class OwnerProperties {

    私人字符串名字;

    公共字符串的getFirstName（）{
         返回 这个 .firstName;
    }

    public  void setFirstName（String firstName）{
         this .firstName = firstName;
    }

}

以下属性名称都可以使用：

表24.1。放松绑定

属性	注意
`person.firstName`	标准骆驼大小写语法。
`person.first-name`	虚线符号，推荐用于`.properties`和`.yml`文件。
`person.first_name`	下划线表示法，用于`.properties`和`.yml`文件的替代格式。
`PERSON_FIRST_NAME`	大写格式。建议使用系统环境变量时。

24.7.3属性转换

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


	由于这个bean在应用程序生命周期中很早被请求，因此请确保限制您`ConversionService`正在使用的依赖关系。通常情况下，您需要的任何依赖项可能在创建时未完全初始化。`ConversionService`如果不需要配置密钥强制，只需要依靠自定义转换器，就可以重命名自定义`@ConfigurationPropertiesBinding`。

24.7.4 @ConfigurationProperties验证

Spring Boot将会@ConfigurationProperties在Spring的@Validated批注中注释时尝试验证类。您可以javax.validation 直接在您的配置类上使用JSR-303 约束注释。只要确保符合JSR-303的实现在您的类路径上，然后将约束注释添加到您的字段中：

@ConfigurationProperties（prefix =“foo”）
@Validated
 public  class FooProperties {

    @NotNull
    私人 InetAddress remoteAddress;

    // ... getters和setter

}

为了验证嵌套属性的值，必须注释相关字段@Valid以触发其验证。例如，建立在上面的 FooProperties例子上：

@ConfigurationProperties（prefix =“connection”）
@Validated
 public  class FooProperties {

    @NotNull
    私人 InetAddress remoteAddress;

    @Valid
    私有 最终安全security = new Security（）;

    // ... getters和setter

    公共 静态 类安全{

        @NotEmpty
        公共字符串的用户名;

        // ... getters和setter

    }

}

你也可以Validator通过创建一个名为的bean定义来添加一个自定义的Spring configurationPropertiesValidator。该@Bean方法应该声明static。配置属性验证器是在应用程序生命周期的早期创建的，并且声明@Bean方法为静态的，允许创建bean而不必实例化@Configuration类。这避免了可能由于实例化提前而导致的任何问题。有一个属性验证示例，所以你可以看到如何设置的东西。


	该`spring-boot-actuator`模块包含一个暴露所有`@ConfigurationProperties`bean 的端点。只需将您的Web浏览器指向`/configprops` 或使用等效的JMX端点即可。请参阅生产准备功能。部分的细节。

24.7.5 @ConfigurationProperties与@Value

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

特征	`@ConfigurationProperties`	`@Value`
轻松的绑定	是	没有
元数据支持	是	没有
`SpEL` 评测	没有	是

如果您为自己的组件定义了一组配置密钥，我们建议您将它们分组在POJO注释@ConfigurationProperties。另请注意，由于@Value不支持轻松绑定，如果您需要使用环境变量提供值，它不是一个好的选择。

最后，尽管您可以在其中编写SpEL表达式@Value，但是这些表达式不会从应用程序属性文件处理。

25.简介

Spring Profiles提供了一种分离部分应用程序配置的方法，并使其仅在特定环境中可用。任何@Component或@Configuration可以标记@Profile以限制何时加载：

@Configuration 
@Profile（“production”）
 public  class ProductionConfiguration {

    // ...

}

以普通的Spring方式，您可以使用spring.profiles.active Environment属性来指定哪些配置文件处于活动状态。您可以用任何常用的方式指定属性，例如，您可以将其包含在application.properties：

spring.profiles.active = dev，hsqldb

或使用开关在命令行中指定--spring.profiles.active=dev,hsqldb。

25.1添加活动的配置文件

该spring.profiles.active物业遵循与其他物业相同的订购规则，最高PropertySource会赢。这意味着您可以指定活动配置文件，application.properties然后使用命令行开关替换它们。

有时，将特定于配置文件的属性添加到活动配置文件而不是替换它们会很有用。该spring.profiles.include属性可以用来无条件添加活动配置文件。该SpringApplication入口点还设置额外的配置文件（即对那些被激活顶部的Java API的 spring.profiles.active属性）：看setAdditionalProfiles()方法。

例如，当与以下属性的应用程序正在使用开关运行 --spring.profiles.active=prod的proddb和prodmq轮廓也将被激活：

--- 
my.property：fromyamlfile
 --- 
spring.profiles：PROD
 spring.profiles.include：
  -  proddb
  -  prodmq


	请记住，`spring.profiles`可以在YAML文档中定义该属性，以确定何时将此特定文档包含在配置中。有关更多详细信息，请参见第72.7节“根据环境更改配置”。

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

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

25.3配置文件特定的配置文件

application.properties（或application.yml）和通过引用的文件的特定于配置文件的变体@ConfigurationProperties被视为加载文件。有关详细信息，请参见第24.4节“配置文件特定属性”。

26.记录

Spring Boot使用Commons Logging进行所有内部日志记录，但是将底层日志实现保留为打开状态。为Java Util Logging， Log4J2和Logback提供了默认配置。在每种情况下，记录器都预先配置为使用控制台输出，可选的文件输出也可用。

默认情况下，如果使用“Starter”，Logback将用于日志记录。还包括适当的Logback路由，以确保使用Java Util日志记录，Commons日志记录，Log4J或SLF4J的相关库都能正常工作。


	Java有很多可用的日志框架。如果上面的列表看起来很混乱，请不要担心。一般来说，你不需要改变日志的依赖关系，Spring Boot的默认设置就可以正常工作。

26.1日志格式

Spring Boot的默认日志输出如下所示：

2014-03-05 10：57：51.112 INFO 45469 --- [main] org.apache.catalina.core.StandardEngine：启动Servlet引擎：Apache Tomcat / 7.0.52
2014-03-05 10：57：51.253 INFO 45469 --- [ost-startStop-1] oaccC [Tomcat]。[localhost]。[/]：初始化Spring嵌入WebApplicationContext
2014-03-05 10：57：51.253信息45469 --- [ost-startStop-1] osweb.context.ContextLoader：根WebApplicationContext：初始化在1358 ms完成
2014-03-05 10：57：51.698信息45469 --- [ost-startStop-1] osbceServletRegistrationBean：将servlet：'dispatcherServlet'映射到[/]
2014-03-05 10：57：51.702 INFO 45469 --- [ost-startStop-1] osbcembedded.FilterRegistrationBean：映射过滤器：'hiddenHttpMethodFilter'到：[/ *]

以下项目被输出：

日期和时间 - 精确到毫秒，易于排序。
日志级别- ， ERROR，，WARN 或。INFODEBUGTRACE
进程ID。
一个---分离器来区分实际日志消息的开始。
线程名称 - 括在方括号中（可能会截断控制台输出）。
记录器名称 - 这通常是源类名称（通常缩写）。
日志消息。


	Logback没有一个`FATAL`级别（它被映射到`ERROR`）

26.2控制台输出

默认日志配置会在写入消息时将消息回送到控制台。默认情况下ERROR，WARN和INFO级别的消息被记录。你也可以通过启动一个--debug标志来启动你的应用程序来启用“调试”模式。

$ java -jar myapp.jar --debug


	你也可以`debug=true`在你的指定`application.properties`。

当启用调试模式时，会选择一些核心记录器（嵌入式容器，Hibernate和Spring Boot）来输出更多的信息。启用调试模式并没有配置您的应用程序记录所有消息DEBUG的水平。

或者，您可以启用一个“跟踪”模式，通过一个--trace标志（或trace=true在您的application.properties）启动您的应用程序。这将启用对核心记录器（嵌入式容器，Hibernate模式生成和整个Spring产品组合）选择的跟踪记录。

26.2.1彩色编码输出

如果您的终端支持ANSI，则会使用彩色输出来提高可读性。您可以设置 spring.output.ansi.enabled为支持的值来覆盖自动检测。

颜色编码是使用%clr转换字配置的。在最简单的形式中，转换器将根据日志级别为输出着色，例如：

％CLR（％5P）

日志级别与颜色的映射如下所示：

水平	颜色
`FATAL`	红
`ERROR`	红
`WARN`	黄色
`INFO`	绿色
`DEBUG`	绿色
`TRACE`	绿色

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

％clr（％d {yyyy-MM-dd HH：mm：ss.SSS}）{yellow}

支持以下颜色和样式：

blue
cyan
faint
green
magenta
red
yellow

26.3文件输出

默认情况下，Spring Boot将只能登录到控制台，不会写入日志文件。如果除了输出控制台之外还想写日志文件，你需要设置一个logging.file或者一个 logging.path属性（比如你的application.properties）。

下表显示了这些logging.*属性如何一起使用：

表26.1。记录属性

`logging.file`	`logging.path`	例	描述
（没有）	（没有）		仅限控制台日志。
具体文件	（没有）	`my.log`	写入指定的日志文件。名称可以是一个确切的位置或相对于当前目录。
（没有）	具体的目录	`/var/log`	写入`spring.log`指定的目录。名称可以是一个确切的位置或相对于当前目录。

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


	日志记录系统在应用程序生命周期的早期初始化，因此在通过`@PropertySource` 注释加载的属性文件中不会找到这样的日志记录属性。


	日志记录属性独立于实际的日志记录基础结构。因此，特定的配置键（如`logback.configurationFile`Logback）不受Spring Boot的管理。

26.4日志级别

所有支持的日志记录系统都可以使用logging.level。* = LEVEL 在Spring中设置日志级别 Environment，例如application.propertiesLEVEL，其中LEVEL是TRACE，DEBUG，INFO，WARN，ERROR，FATAL，OFF之一。该root记录器可以通过以下方式配置logging.level.root。例如application.properties：

logging.level.root = WARN
 logging.level.org.springframework.web = DEBUG
 logging.level.org.hibernate = ERROR


	默认情况下，Spring Boot会重新映射Thymeleaf `INFO`消息，以便它们在`DEBUG`级别上被记录。这有助于减少标准日志输出中的噪音。请参阅`LevelRemappingAppender` 有关如何在自己的配置中应用重新映射的详细信息。

26.5自定义日志配置

可以通过在类路径中包含适当的库来激活各种日志记录系统，并且可以通过在类路径的根目录中或者在由Spring Environment属性指定的位置中提供合适的配置文件来进一步进行定制logging.config。

您可以使用org.springframework.boot.logging.LoggingSystem系统属性强制Spring Boot使用特定的日志记录系统。该值应该是实现的完全限定的类名称LoggingSystem。你也可以通过使用一个值来完全禁用Spring Boot的日志配置none。


	由于记录被初始化之前的`ApplicationContext`创建，这是不可能控制来自伐木`@PropertySources`春季`@Configuration`文件。系统属性和传统的Spring Boot外部配置文件工作得很好。）

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

记录系统	定制
的logback	`logback-spring.xml`，`logback-spring.groovy`，`logback.xml`或者`logback.groovy`
Log4j2	`log4j2-spring.xml` 要么 `log4j2.xml`
JDK（Java Util日志记录）	`logging.properties`


	在可能的情况下，我们建议您使用`-spring`变体进行日志配置（例如，`logback-spring.xml`而不是`logback.xml`）。如果使用标准配置位置，Spring将无法完全控制日志初始化。


	Java Util Logging存在已知的类加载问题，从“可执行jar”运行时会导致问题。我们建议您尽可能避免它。

为了帮助定制，一些其他的属性从Spring传递 Environment给System属性：

春天的环境	系统属性	注释
`logging.exception-conversion-word`	`LOG_EXCEPTION_CONVERSION_WORD`	记录异常时使用的转换字。
`logging.file`	`LOG_FILE`	用于默认日志配置（如果已定义）。
`logging.path`	`LOG_PATH`	用于默认日志配置（如果已定义）。
`logging.pattern.console`	`CONSOLE_LOG_PATTERN`	在控制台上使用的日志模式（stdout）。（仅支持默认的登录设置。）
`logging.pattern.file`	`FILE_LOG_PATTERN`	在文件中使用的日志模式（如果启用LOG_FILE）。（仅支持默认的登录设置。）
`logging.pattern.level`	`LOG_LEVEL_PATTERN`	用于呈现日志级别的格式（默认`%5p`）。（仅支持默认的登录设置。）
`PID`	`PID`	当前的进程ID（如果可能，还没有被定义为OS环境变量时发现）。

所有支持的日志系统在解析其配置文件时都可以查询系统属性。例如，请参阅默认配置spring-boot.jar。


	如果您想在日志记录属性中使用占位符，则应该使用 Spring Boot的语法，而不是基础框架的语法。值得注意的是，如果您使用的是Logback，则应该将其 `:`用作属性名称与其默认值之间的分隔符，而不是`:-`。

您可以通过仅覆盖LOG_LEVEL_PATTERN（或logging.pattern.level使用Logback）来添加MDC和其他临时内容。例如，如果使用，logging.pattern.level=user:%X{user} %5p那么默认的日志格式将包含“用户”的MDC条目（如果存在），例如

2015-09-30 12：30：04.031 user：juergen INFO 22174 --- [nio-8080-exec-0] demo.Controller
处理认证的请求

26.6 Logback扩展

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


	您不能在标准`logback.xml`配置文件中使用扩展，因为它太早加载。您需要使用`logback-spring.xml`或定义一个 `logging.config`属性。


	这些扩展名不能用于Logback的配置扫描。如果您尝试这样做，则更改配置文件将导致类似于以下记录之一的错误：

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

26.6.1配置文件特定的配置

该<springProfile>标签允许您根据活动的Spring配置文件选择性地包含或排除部分配置。<configuration>元素中的任何位置都支持Profile部分。使用该name属性来指定哪个配置文件接受配置。可以使用逗号分隔列表指定多个配置文件。

<springProfile  name = “staging” > 
    <！ - 当“暂存”配置文件处于活动状态时要启用的配置 - > 
</ springProfile>

<springProfile  name = “dev，staging” > 
    <！ - 在“dev”或“staging”配置文件处于活动状态时启用的配置 - > 
</ springProfile>

<springProfile  name = “！production” > 
    <！ - 当“production”配置文件未激活时要启用的配置 - > 
</ springProfile>

26.6.2环境属性

该<springProperty>标签允许您在Spring Environment 中使用Spring的属性。如果要application.properties在您的logback配置中访问文件中的值，这可能很有用。标签的工作方式与Logback的标准<property>标签类似，但不是指定直接value 指定source属性（从Environment）。scope 如果您需要将属性存储在local范围以外的其他位置，则可以使用该属性。如果您需要回退值，以防在属性中未设置属性，则Environment可以使用该defaultValue属性。

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


	将`RelaxedPropertyResolver`用于访问`Environment`属性。如果指定`source`虚线符号（`my-property-name`）所有的放松变化将受审（`myPropertyName`，`MY_PROPERTY_NAME`等）。

27.开发Web应用程序

Spring Boot非常适合Web应用程序的开发。您可以使用嵌入式Tomcat，Jetty或Undertow轻松创建自包含的HTTP服务器。大多数Web应用程序将使用该spring-boot-starter-web模块快速启动并运行。

如果您还没有开发Spring Boot Web应用程序，则可以按照“Hello World！”进行操作。例如在入门部分。

27.1“Spring Web MVC框架”

Spring Web MVC框架（通常简称为“Spring 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框架的一部分，详细信息见参考文档。在spring.io / guides中也有几个指南，涵盖了Spring MVC。

27.1.1 Spring MVC自动配置

Spring Boot为Spring MVC提供了自动配置，可以与大多数应用程序配合使用。

自动配置在Spring的默认设置之上添加以下功能：

包括ContentNegotiatingViewResolver和BeanNameViewResolver豆类。
支持静态资源，包括对WebJars的支持（见下文）。
自动登记Converter，GenericConverter，Formatter豆类。
支持HttpMessageConverters（见下文）。
自动注册MessageCodesResolver（见下文）。
静态index.html支持。
自定义Favicon支持（见下文）。
自动使用一个ConfigurableWebBindingInitializerbean（见下文）。

如果你想保持Spring Boot MVC的功能，而你只是想添加额外的MVC配置（拦截器，格式化器，视图控制器等），你可以添加自己的@Configuration类的类WebMvcConfigurerAdapter，但没有 @EnableWebMvc。如果您希望提供自定义实例RequestMappingHandlerMapping，RequestMappingHandlerAdapter或者ExceptionHandlerExceptionResolver您可以声明WebMvcRegistrationsAdapter 提供此类组件的实例。

如果你想完全控制Spring MVC，你可以添加你自己的@Configuration 注释@EnableWebMvc。

27.1.2 HttpMessageConverters

Spring MVC使用该HttpMessageConverter接口来转换HTTP请求和响应。明智的默认是包括在盒子，例如对象可以自动转换为JSON（使用杰克逊库）或XML（使用杰克逊XML扩展如果可用，否则使用JAXB）。字符串UTF-8默认使用编码。

如果你需要添加或定制转换器，你可以使用Spring Boot的 HttpMessageConverters类：

import org.springframework.boot.autoconfigure.web.HttpMessageConverters;
import org.springframework.context.annotation。*;
import org.springframework.http.converter。*;

@Configuration
 public  class MyConfiguration {

    @Bean
    公共 HttpMessageConverters customConverters（）{
        HttpMessageConverter <？>附加= ...
        HttpMessageConverter <？>另一个= ...
        返回 新的 HttpMessageConverters（另外，另一个）;
    }

}

任何HttpMessageConverter存在于上下文中的bean都将被添加到转换器列表中。您也可以通过这种方式覆盖默认转换器。

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

如果您使用Jackson来序列化和反序列化JSON数据，您可能需要编写自己的JsonSerializer和JsonDeserializer类。自定义序列化器通常通过一个模块向Jackson注册，但Spring Boot提供了一个备选@JsonComponent注释，这使得直接注册Spring Beans变得更容易。

您可以@JsonComponent直接使用JsonSerializer或JsonDeserializer 执行。您也可以在包含序列化器/反序列化器的类中使用它作为内部类。例如：

import java.io. *;
import com.fasterxml.jackson.core。*;
import com.fasterxml.jackson.databind。*;
import org.springframework.boot.jackson。*;

@JsonComponent
公共 类示例{

    公共 静态 类序列化器扩展 JsonSerializer <SomeObject> {
         // ...
    }

    公共 静态 类 Deserializer 扩展 JsonDeserializer <SomeObject> {
         // ...
    }

}

所有的@JsonComponentbean ApplicationContext都将自动注册到Jackson，并且由于@JsonComponent是用元注释的@Component，通常的组件扫描规则适用。

春季启动也提供 JsonObjectSerializer和 JsonObjectDeserializer基类，其序列化对象时提供标准版本的杰克逊有用的替代。有关详细信息，请参阅Javadoc。

27.1.4 MessageCodesResolver

Spring MVC有一个策略来生成错误代码，用于从绑定错误中呈现错误消息MessageCodesResolver。如果您设置了spring.mvc.message-codes-resolver.format属性PREFIX_ERROR_CODE或 POSTFIX_ERROR_CODE（参见枚举DefaultMessageCodesResolver.Format），Spring Boot将为您创建一个。

27.1.5静态内容

默认情况下，Spring Boot将从类路径或者根目录中的/static（ /public或者/resources或者/META-INF/resources）目录中提供静态内容ServletContext。它使用ResourceHttpRequestHandlerSpring MVC，所以你可以通过添加你自己WebMvcConfigurerAdapter的 addResourceHandlers方法来修改这个行为。

在独立的Web应用程序中，容器中的默认servlet也被启用，并作为后备，从ServletContextSpring 的根目录提供内容，如果Spring决定不处理它。大多数情况下，这不会发生（除非你修改默认的MVC配置），因为Spring总是能够通过DispatcherServlet。

默认情况下，资源已映射，/**但您可以通过调整 spring.mvc.static-path-pattern。比如，将所有的资源转移到/resources/** 可以实现如下：

spring.mvc.static-path-pattern = / resources / **

您还可以使用自定义静态资源位置spring.resources.static-locations（使用目录位置列表替换默认值）。如果您这样做，则默认的欢迎页面检测将切换到您的自定义位置，因此，如果index.html启动时在您的任何位置有一个位置，它将是应用程序的主页。

除了上面的“标准”静态资源位置之外，Webjars内容还有一个特殊情况。任何带有路径的资源/webjars/** 如果以Webjars格式打包，将从jar文件提供。


	`src/main/webapp`如果您的应用程序将被打包为jar，请不要使用该目录。虽然这个目录是一个通用的标准，但是它只能用于war包装，如果你生成一个jar包，它会被大多数的构建工具默默地忽略。

Spring Boot还支持Spring MVC提供的高级资源处理功能，允许使用例如缓存清除静态资源或使用Webjars的版本不可知的URL。

要为Webjars使用版本不可知的URL，只需添加webjars-locator依赖关系即可。然后宣布你Webjar，采取的jQuery例如，如"/webjars/jquery/dist/jquery.min.js" 导致"/webjars/jquery/x.y.z/dist/jquery.min.js"地方x.y.z是Webjar版本。


	如果你正在使用JBoss，你需要声明`webjars-locator-jboss-vfs` 依赖关系，而不是`webjars-locator`; 否则所有的Webjars解析为`404`。

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

spring.resources.chain.strategy.content.enabled = true
 spring.resources.chain.strategy.content.paths = / **


	在模板中，资源链接在运行时被重写，这要归功于 `ResourceUrlEncodingFilter`Thymeleaf和FreeMarker的自动配置。使用JSP时，您应该手动声明此过滤器。其他模板引擎现在不是自动支持，但可以使用自定义模板宏/助手和使用 `ResourceUrlProvider`。

例如，在使用JavaScript模块加载程序动态加载资源时，重命名文件不是一个选项。这就是为什么其他策略也支持并可以结合的原因。“固定”策略将在URL中添加静态版本字符串，而不更改文件名称：

spring.resources.chain.strategy.content.enabled = true
 spring.resources.chain.strategy.content.paths = / **
 spring.resources.chain.strategy.fixed.enabled = true
 spring.resources.chain.strategy.fixed .paths = / js / lib /
 spring.resources.chain.strategy.fixed.version = v12

使用此配置，位于下方的JavaScript模块"/js/lib/"将使用固定版本控制策略，"/v12/js/lib/mymodule.js"而其他资源仍将使用该内容<link href="/css/spring-2a2d595e6ed9a0b24f027f2b63b134d6.css"/>。

请参阅ResourceProperties 更多支持的选项。


	这个特性已经在一个专门的博客文章和Spring框架的参考文档中有详细的描述。

27.1.6自定义的Favicon

Spring Boot favicon.ico在配置的静态内容位置和类路径的根目录（按此顺序）中查找a 。如果这样的文件存在，它会自动用作应用程序的图标。

27.1.7 ConfigurableWebBindingInitializer

Spring MVC使用a WebBindingInitializer来初始化WebDataBinder一个特定的请求。如果你自己创建ConfigurableWebBindingInitializer @Bean，Spring Boot会自动配置Spring MVC来使用它。

27.1.8模板引擎

除了REST Web服务，您还可以使用Spring MVC来提供动态HTML内容。Spring MVC支持各种模板技术，包括Thymeleaf，FreeMarker和JSP。许多其他模板引擎也提供了自己的Spring MVC集成。

Spring Boot包含以下模板引擎的自动配置支持：


	如果可能的话，JSP应该被避免，在嵌入的servlet容器中使用它们有几个已知的限制。

当您使用默认配置的模板引擎之一时，您的模板将自动从中提取src/main/resources/templates。

IntelliJ IDEA根据你运行应用程序的方式不同地命令类路径。通过主要方法在IDE中运行应用程序将导致与使用Maven或Gradle或从其打包的jar运行应用程序时不同的顺序。这可能会导致Spring Boot无法在类路径中找到模板。如果您受到这个问题的影响，您可以在IDE中重新排序类路径，以便首先放置模块的类和资源。或者，您可以配置模板前缀来搜索类路径中的每个模板目录：classpath*:/templates/。

27.1.9错误处理

Spring Boot provides an /error mapping by default that handles all errors in a sensible way, and it is registered as a ‘global’ error page in the servlet container. For machine clients it will produce a JSON response with details of the error, the HTTP status and the exception message. For browser clients there is a ‘whitelabel’ error view that renders the same data in HTML format (to customize it just add a View that resolves to ‘error’). To replace the default behaviour completely you can implementErrorController and register a bean definition of that type, or simply add a bean of type ErrorAttributes to use the existing mechanism but replace the contents.


	在`BasicErrorController`可以用作自定义基类`ErrorController`。如果要为新的内容类型添加处理程序（默认情况下是`text/html`专门处理并提供其他所有内容的回退），这一点特别有用。要做到这一点，只需扩展`BasicErrorController`并添加一个`@RequestMapping`具有`produces`属性的公共方法，并创建一个新的类型的bean。

您还可以定义一个@ControllerAdvice自定义JSON文档以返回特定的控制器和/或异常类型。

@ControllerAdvice（basePackageClasses = FooController.class）
 public  class FooControllerAdvice extends ResponseEntityExceptionHandler {

    @ExceptionHandler（YourException.class）
    @ResponseBody
    ResponseEntity <？> handleControllerException（HttpServletRequest请求，Throwable前）{
        HttpStatus状态= getStatus（请求）;
        返回 新的 ResponseEntity <>（新的 CustomErrorType（status.value（），ex.getMessage（）），状态）;
    }

    私人 HttpStatus getStatus（HttpServletRequest请求）{
        整数statusCode =（整数）request.getAttribute（“javax.servlet.error.status_code”）;
        if（statusCode == null）{
             return HttpStatus.INTERNAL_SERVER_ERROR;
        }
        返回 HttpStatus.valueOf（statusCode）;
    }

}

在上面的例子中，如果YourException由在同一个包中定义的控制器抛出，将使用POJO FooController的json表示CustomerErrorType来代替ErrorAttributes表示。

自定义错误页面

如果要为给定状态代码显示自定义HTML错误页面，请将文件添加到文件/error夹。错误页面可以是静态HTML（即添加在任何静态资源文件夹下）或使用模板构建。该文件的名称应该是确切的状态码或一系列掩码。

例如，要映射404到静态HTML文件，您的文件夹结构如下所示：

SRC /
 +  - 主/
     +  -  java /
     | + <源代码>
     +  - 资源/
         +  - 公共/
             +  - 错误/
             | +  -  404.html
             +  -  <其他公共资产>

要5xx使用FreeMarker模板映射所有的错误，你会有这样的结构：

SRC /
 +  - 主/
     +  -  java /
     | + <源代码>
     +  - 资源/
         +  - 模板/
             +  - 错误/
             | +  -  5xx.ftl
             +  -  <其他模板>

对于更复杂的映射，你也可以添加实现ErrorViewResolver 接口的bean 。

公共 类 MyErrorViewResolver 实现 ErrorViewResolver {

    @覆盖
    公共的ModelAndView resolveErrorView（HttpServletRequest的请求，
            HttpStatus状态，Map <String，Object>模型）{
        //使用请求或状态来选择返回一个ModelAndView 
        返回 ...
    }

}

您还可以使用常规的Spring MVC功能，如 @ExceptionHandler方法和 @ControllerAdvice。然后ErrorController 将会拿起任何未处理的异常。

在Spring MVC之外映射错误页面

对于不使用Spring MVC的应用程序，可以使用该ErrorPageRegistrar 接口直接注册ErrorPages。这个抽象直接与底层的嵌入式servlet容器一起工作，即使你没有Spring MVC也可以工作 DispatcherServlet。

@Bean
 public ErrorPageRegistrar errorPageRegistrar（）{
     return  new MyErrorPageRegistrar（）;
}

// ...

私有 静态 类 MyErrorPageRegistrar 实现 ErrorPageRegistrar {

    @覆盖
    公共 无效 registerErrorPages（ErrorPageRegistry注册表）{
        registry.addErrorPages（new ErrorPage（HttpStatus.BAD_REQUEST，“/ 400”））;
    }

}

注意，如果你注册了ErrorPage一个将被最终处理的路径 Filter（比如像Jersey和Wicket这样的非Spring Web框架常见的），那么Filter必须明确注册为一个ERROR调度器，例如

@Bean
 public FilterRegistrationBean myFilter（）{
    FilterRegistrationBean注册= 新的 FilterRegistrationBean（）;
    registration.setFilter（new MyFilter（））;
    ...
    registration.setDispatcherTypes（EnumSet.allOf（DispatcherType。类））;
    返回注册;
}

（默认FilterRegistrationBean不包括ERROR调度程序类型）。

WebSphere Application Server上的错误处理

在部署到servlet容器时，Spring Boot使用其错误页面过滤器将具有错误状态的请求转发到适当的错误页面。如果响应尚未提交，则只能将请求转发到正确的错误页面。默认情况下，WebSphere Application Server 8.0和更高版本在成功完成servlet的服务方法后提交响应。您应该通过设置com.ibm.ws.webcontainer.invokeFlushAfterService为禁用此行为 false

27.1.10春天的HATEOAS

如果您正在开发一个使用超媒体的RESTful API，Spring Boot为Spring HATEOAS提供了自动配置，可以与大多数应用程序配合使用。自动配置取代了使用@EnableHypermediaSupport和注册大量bean的需求，以便构建基于超媒体的应用程序，包括 LinkDiscoverers（用于客户端支持）和被ObjectMapper配置为将响应正确地编组到所需表示中。在ObjectMapper将根据定制spring.jackson.*的属性或者Jackson2ObjectMapperBuilder如果存在豆。

你可以通过使用控制Spring HATEOAS的配置 @EnableHypermediaSupport。请注意，这将禁用上述ObjectMapper定制。

27.1.11 CORS支持

跨源资源共享（CORS）是大多数浏览器实现的W3C规范，允许您以灵活的方式指定什么样的跨域请求被授权，而不是使用像IFRAME或JSONP那样的不太安全和功能较弱的方法。

从4.2版开始，Spring MVC 支持CORS开箱即用。使用控制器方法@CrossOrigin 在Spring Boot应用程序中使用带注释的CORS配置不需要任何特定的配置。全局CORS配置可以通过WebMvcConfigurer使用自定义addCorsMappings(CorsRegistry) 方法注册一个bean来定义：

@Configuration
 public  class MyConfiguration {

    @Bean
     public WebMvcConfigurer corsConfigurer（）{
         return  new WebMvcConfigurerAdapter（）{
             @
             Override public  void addCorsMappings（CorsRegistry registry）{
                registry.addMapping（“/ api / **”）;
            }
        };
    }
}

27.2 JAX-RS和泽西岛

如果您更喜欢REST端点的JAX-RS编程模型，则可以使用其中一个可用的实现，而不是Spring MVC。新泽西州的1.x和Apache CXF工作不错，开箱即用的，如果你只是注册他们Servlet或Filter为@Bean您的应用程序上下文。Jersey 2.x有一些原生的Spring支持，所以我们还在Spring Boot中为它提供了自动配置支持。

要开始使用Jersey 2.x，只需将其spring-boot-starter-jersey作为依赖项，然后您需要注册所有端点@Bean的类型ResourceConfig之一：

@Component
 public  class JerseyConfig extends ResourceConfig {

    公开 JerseyConfig（）{
        寄存器（端点。类）;
    }

}


	泽西对扫描可执行档案的支持是相当有限的。例如，它无法扫描`WEB-INF/classes`运行可执行文件时发现的包中的端点。为了避免这种限制，`packages`不应该使用该`register`方法，并应使用上述方法单独注册端点。

您还可以注册任意数量的bean，实现ResourceConfigCustomizer 更高级的自定义。

所有注册的端点应该@Components与HTTP资源注释（@GET等），例如

@Component 
@Path（“/ hello”）
 public  class Endpoint {

    @GET
     public String message（）{
         return  “Hello” ;
    }

}

由于Endpoint是一个Spring，@Component它的生命周期由Spring管理，你可以@Autowired依赖并注入外部配置@Value。Jersey servlet将被/*默认注册并映射到。您可以通过添加@ApplicationPath到您的更改映射ResourceConfig。

默认情况下，Jersey将被设置为一个名为@Bean的类型的Servlet 。默认情况下，servlet将被懒惰地初始化，但是你可以使用它自定义它。你可以通过创建一个你自己的名字来禁用或者重载这个bean。您也可以通过设置（在这种情况下替换或覆盖）来使用Filter而不是Servlet 。该servlet有一个你可以设置的。Servlet和Filter注册都可以被赋予init参数，用来指定一个属性映射。ServletRegistrationBeanjerseyServletRegistrationspring.jersey.servlet.load-on-startupspring.jersey.type=filter@BeanjerseyFilterRegistration@Orderspring.jersey.filter.orderspring.jersey.init.*

有一个泽西岛样本，所以你可以看到如何设置的东西。还有一个泽西岛1.x样本。请注意，在Jersey 1.x示例中，spring-boot maven插件已被配置为解压缩某些Jersey Jars，以便JAX-RS实现可以扫描它们（因为示例要求在Filter注册时扫描它们）。如果任何JAX-RS资源打包为嵌套罐，则可能需要执行相同的操作。

27.3嵌入式servlet容器支持

Spring Boot包含对嵌入式Tomcat，Jetty和Undertow服务器的支持。大多数开发人员只需使用适当的“Starter”来获取完全配置的实例。默认情况下，嵌入式服务器将侦听端口上的HTTP请求8080。

如果您选择在CentOS上使用Tomcat，请注意，默认情况下会使用一个临时目录来存储已编译的JSP，文件上传等。tmpwatch当您的应用程序运行导致失败时，可能会删除此目录。为了避免这种情况，您可能需要自定义tmpwatch配置，以便tomcat.* 不删除目录，或者进行配置，server.tomcat.basedir以便嵌入式Tomcat使用不同的位置。

27.3.1 Servlet，过滤器和监听器

使用嵌入式servlet容器时，可以HttpSessionListener通过使用Spring bean或通过扫描Servlet组件来注册Servlet规范（例如Servlet规范）中的所有监听器。

注册Servlet，过滤器和侦听器为Spring bean

任何Servlet，Filter或者Servlet *Listener实例，它是一个Spring bean将与嵌入容器注册。如果要application.properties在配置期间引用您的值，这可能会特别方便。

默认情况下，如果上下文只包含一个Servlet，它将被映射到/。在多个Servlet bean的情况下，bean名称将被用作路径前缀。过滤器将映射到/*。

如果以公约为基础测绘不够灵活，你可以使用 ServletRegistrationBean，FilterRegistrationBean而ServletListenerRegistrationBean 类的完全控制。

27.3.2 Servlet上下文初始化

嵌入式servlet容器不会直接执行Servlet 3.0+ javax.servlet.ServletContainerInitializer接口或Spring的org.springframework.web.WebApplicationInitializer接口。这是一个有意的设计决策，旨在降低设计在战争中运行的第三方库将破坏Spring Boot应用程序的风险。

如果您需要在Spring Boot应用程序中执行servlet上下文初始化，则应该注册一个实现该org.springframework.boot.context.embedded.ServletContextInitializer接口的bean 。单一的onStartup方法提供了访问权限ServletContext，并且WebApplicationInitializer如果需要的话，可以容易地用作现有适配器。

扫描Servlet，筛选器和侦听器

当使用嵌入式容器，自动注册@WebServlet，@WebFilter和@WebListener注解的类可以使用启用@ServletComponentScan。


	`@ServletComponentScan` 在独立容器中将不起作用，容器的内置发现机制将被使用。

27.3.3 EmbeddedWebApplicationContext

Spring Boot使用了一种新的ApplicationContext用于嵌入式servlet容器的支持。这EmbeddedWebApplicationContext是一种特殊的类型WebApplicationContext，它通过搜索一个EmbeddedServletContainerFactorybean 来引导自己。通常一个TomcatEmbeddedServletContainerFactory，JettyEmbeddedServletContainerFactory或者UndertowEmbeddedServletContainerFactory将会自动配置。


	您通常不需要知道这些实现类。大多数应用程序将自动配置`ApplicationContext`， `EmbeddedServletContainerFactory`并将以您的名义创建适当的应用程序。

27.3.4定制嵌入式servlet容器

通用的servlet容器设置可以使用Spring Environment 属性进行配置。通常你会在你的application.properties 文件中定义属性。

通用服务器设置包括：

网络设置：传入HTTP请求的监听端口（server.port），绑定的接口地址server.address等
会话设置：会话是持久性（server.session.persistence），会话超时（server.session.timeout），会话数据位置（server.session.store-dir）和会话cookie配置（server.session.cookie.*）。
错误管理：错误页面的位置（server.error.path）等
SSL
HTTP压缩

Spring Boot尽可能地尝试暴露常见的设置，但这并不总是可能的。对于这些情况，专用名称空间提供了特定于服务器的自定义（请参阅 server.tomcat和server.undertow）。例如，可以使用嵌入式servlet容器的特定功能来配置访问日志。


	查看`ServerProperties` 课程的完整列表。

程序化定制

如果你需要通过编程来配置你的嵌入式servlet容器，你可以注册一个实现这个EmbeddedServletContainerCustomizer接口的Spring bean 。EmbeddedServletContainerCustomizer提供访问权限， ConfigurableEmbeddedServletContainer其中包括许多定制设置方法。

import org.springframework.boot.context.embedded。*;
import org.springframework.stereotype.Component;

@Component
公共 类 CustomizationBean实现了 EmbeddedServletContainerCustomizer {

    @Override
     public  void customize（ConfigurableEmbeddedServletContainer container）{
        container.setPort（9000）;
    }

}

直接自定义ConfigurableEmbeddedServletContainer

如果上面的定制技术太有限，你可以注册 TomcatEmbeddedServletContainerFactory，JettyEmbeddedServletContainerFactory或UndertowEmbeddedServletContainerFactory自己动手。

@Bean
 public EmbeddedServletContainerFactory servletContainer（）{
    TomcatEmbeddedServletContainerFactory factory = new TomcatEmbeddedServletContainerFactory（）;
    factory.setPort（9000）;
    factory.setSessionTimeout（10，TimeUnit.MINUTES）;
    factory.addErrorPages（new ErrorPage（HttpStatus.NOT_FOUND，“/ notfound.html”））;
    退货工厂;
}

安装程序提供了许多配置选项。还提供了几个受保护的方法“钩子”，如果你需要做更奇特的事情。有关详细信息，请参阅源代码文档。

27.3.5 JSP限制

运行使用嵌入式servlet容器的Spring Boot应用程序（并打包为可执行文件）时，JSP支持有一些限制。

有了Tomcat，如果你使用war包，也就是说可执行的war会起作用，并且也可以部署到一个标准的容器（不仅限于Tomcat），还可以部署到Tomcat。由于Tomcat中的硬编码文件模式，可执行jar不起作用。
使用Jetty时，如果使用战争包装，即可执行的战争将起作用，并且也可以部署到任何标准容器，则应该可以工作。
Undertow不支持JSP。
创建自定义error.jsp页面将不会覆盖缺省视图错误处理，自定义错误页应改为使用。

有一个JSP示例，所以你可以看到如何设置。

28.安全

如果Spring Security位于类路径上，那么默认情况下，Web应用程序将在所有HTTP端点上进行“基本”身份验证。要向Web应用程序添加方法级别的安全性，您还可以添加@EnableGlobalMethodSecurity所需的设置。更多的信息可以在Spring Security Reference中找到。

默认情况下AuthenticationManager有一个用户（“用户”用户名和随机密码，在应用程序启动时以INFO级别打印）

使用默认安全密码：78fa095d-3f4c-48b1-ad50-e24c31d5cf35


	如果您对日志记录配置进行了微调，请确保该 `org.springframework.boot.autoconfigure.security`类别设置为记录日志`INFO`消息，否则默认密码将不会被打印。

您可以通过提供一个更改密码security.user.password。这个和其他有用的属性是通过 SecurityProperties （属性前缀“安全”）外化。

默认的安全配置是在SecurityAutoConfiguration从那里导入的类中实现的（SpringBootWebSecurityConfiguration对于网络安全和AuthenticationManagerConfiguration用于在非web应用中也是相关的认证配置）。要完全关闭默认的Web应用程序安全配置，您可以添加一个bean @EnableWebSecurity（这不会禁用身份验证管理器配置或执行器的安全性）。要定制它，通常使用外部属性和类型的bean WebSecurityConfigurerAdapter （例如添加基于表单的登录）。要关闭身份验证管理器配置，您可以添加一个类型的bean AuthenticationManager，或者AuthenticationManager通过AuthenticationManagerBuilder在某个@Configuration类中自动装配一个方法来配置全局。在这里有几个安全的应用程序Spring Boot示例让您开始使用常见用例。

您在Web应用程序中使用的基本功能是：

AuthenticationManager具有内存中存储和单个用户的bean（请参阅用户 SecurityProperties.User的属性）。
常见的静态资源位置忽略（不安全的）路径（/css/**，/js/**， /images/**，/webjars/**和**/favicon.ico）。
所有其他端点的HTTP基本安全性。
发布到Spring的安全事件ApplicationEventPublisher（成功和不成功的身份验证和访问被拒绝）。
Spring Security提供的常用低级特性（HSTS，XSS，CSRF，缓存）默认是开启的。

以上所有可以打开和关闭或使用外部属性（security.*）修改。要覆盖访问规则不改变任何其它的自动配置功能添加@Bean型WebSecurityConfigurerAdapter与@Order(SecurityProperties.ACCESS_OVERRIDE_ORDER)并对其进行配置，以满足您的需求。


	默认情况下，a `WebSecurityConfigurerAdapter`将匹配任何路径。如果您不想完全覆盖Spring Boot的自动配置的访问规则，则您的适配器必须显式配置您想覆盖的路径。

28.1 OAuth2

如果你有spring-security-oauth2你的类路径，你可以利用一些自动配置，以便设置授权或资源服务器。有关完整的详细信息，请参阅Spring Security OAuth 2开发人员指南。

28.1.1授权服务器

要创建授权服务器并授予您需要使用@EnableAuthorizationServer和提供的权限 security.oauth2.client.client-id以及security.oauth2.client.client-secret]属性。客户端将在内存资源库中注册。

完成之后，您将能够使用客户端凭据创建访问令牌，例如：

$ curl client：secret @ localhost ：8080 / oauth / token -d grant_type = password -d username = user -d password = pwd

和/token端点的基本身份验证凭证是client-id和 client-secret。用户凭证是普通的Spring Security用户详细信息（在Spring Boot中默认为“user”和一个随机密码）。

要关闭自动配置并自己配置授权服务器功能，只需添加一个@Bean类型即可AuthorizationServerConfigurer。

28.1.2资源服务器

要使用访问令牌，您需要一个资源服务器（可以与授权服务器相同）。创建资源服务器很简单，只需添加 @EnableResourceServer并提供一些配置，以允许服务器解码访问令牌。如果您的应用程序也是一个授权服务器，它已经知道如何解码令牌，所以没有别的办法。如果你的应用是一个独立的服务，那么你需要给它更多的配置，以下选项之一：

security.oauth2.resource.user-info-uri使用/me资源（例如 https://uaa.run.pivotal.io/userinfo在PWS上）
security.oauth2.resource.token-info-uri使用令牌解码端点（例如 https://uaa.run.pivotal.io/check_token在PWS上）。

如果你同时指定user-info-uri和token-info-uri那么你可以设置一个标志，说一个是优于另一个（prefer-token-info=true是默认）。

或者（代替user-info-uri或token-info-uri）如果令牌是JWT，您可以配置一个security.oauth2.resource.jwt.key-value本地解码（密钥是验证密钥）。验证密钥值是对称密钥或PEM编码的RSA公钥。如果你没有密钥并且它是公开的，你可以提供一个可以下载的URI（作为一个带有“value”字段的JSON对象）security.oauth2.resource.jwt.key-uri。例如在PWS上：

$ curl https://uaa.run.pivotal.io/token_key
{“alg”：“SHA256withRSA”，“value”：“----- BEGIN PUBLIC KEY ----- \ nMIIBI ... \ n ----- END PUBLIC KEY ----- \ n” }


	如果您使用`security.oauth2.resource.jwt.key-uri`授权服务器需要在您的应用程序启动时运行。如果找不到密钥，它会记录警告，并告诉您如何解决问题。

OAuth2资源受命令过滤器链保护， security.oauth2.resource.filter-order默认情况下，过滤器默认保护执行器端点（因此除非您更改顺序，否则执行器端点将保持在HTTP基本上）。

28.2令牌类型的用户信息

Google和某些其他第三方身份提供商对标头中发送给用户信息端点的标记类型名称更为严格。默认是“承载”，适合大多数提供者，并符合规范，但如果你需要改变它，你可以设置 security.oauth2.resource.token-type。

28.3自定义用户信息RestTemplate

如果有user-info-uri，资源服务器功能使用OAuth2RestTemplate 内部获取用户详细信息进行身份验证。这是作为一种@Bean类型提供的UserInfoRestTemplateFactory。对于大多数提供者来说，默认值应该是可以的，但是偶尔你可能需要添加额外的拦截器，或者改变请求认证者（这是令牌被附加到传出请求的方式）。要添加一个自定义，只需创建一个类型的bean UserInfoRestTemplateCustomizer- 它有一个方法，在bean被创建之后但在被初始化之前被调用。这里正在定制的其余模板仅用于内部执行身份验证。或者，你可以定义你自己的UserInfoRestTemplateFactory @Bean完全控制。

要在YAML中设置一个RSA键值，使用“管道”连续标记将其分割成多行（“|”）并记住缩进键值（这是一个标准的YAML语言功能）。例：

安全性：
     oauth2：
         资源：
             jwt：
                 keyValue：|
                    ----- BEGIN PUBLIC KEY -----
                    MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC ...
                    -----结束公钥-----

28.3.1客户端

为了让您的网络应用程序成为一个OAuth2客户端，您可以简单地添加@EnableOAuth2Client和Spring Boot将创建一个OAuth2ClientContext和OAuth2ProtectedResourceDetails创建一个OAuth2RestOperations。Spring Boot不会自动创建这样的bean，但您可以轻松创建自己的：

@Bean
 public OAuth2RestTemplate oauth2RestTemplate（OAuth2ClientContext oauth2ClientContext，
        OAuth2ProtectedResourceDetails细节）{
    返回 新的 OAuth2RestTemplate（details，oauth2ClientContext）;
}


	您可能需要添加限定符并检查您的配置，因为`RestTemplate`可能会在您的应用程序中定义多个配置。

此配置使用security.oauth2.client.*作为凭据（您可能会在授权服务器中使用相同），但此外，它需要知道授权服务器中的授权和令牌URI。例如：

application.yml。

安全：
     的oauth2：
         客户端：
             的clientId：bd1c0a783ccdd1c9b9e4
             clientSecret：1 a9030fbca47a5b2c28e92f19050bb77824b5ad1
             accessTokenUri：https://github.com/login/oauth/access_token
             userAuthorizationUri：https://github.com/login/oauth/authorize
             clientAuthenticationScheme：形式

这个配置的应用程序将重定向到Github进行授权，当您尝试使用OAuth2RestTemplate。如果您已经登录到Github，您甚至不会注意到它已经通过身份验证。如果您的应用程序在端口8080上运行（在Github或其他提供程序中注册您自己的客户端应用程序以获得更大的灵活性），这些特定的凭据将仅适用。

为了限制客户端在获取访问令牌时所要求的范围，您可以设置 security.oauth2.client.scope（逗号分隔或YAML中的数组）。默认情况下，作用域是空的，授权服务器决定默认应该是什么，通常取决于它所保存的客户端注册的设置。


	还有一个`security.oauth2.client.client-authentication-scheme` 默认设置为“header”的设置（但是，如果像Github一样，您的OAuth2提供者不喜欢头认证，则可能需要将其设置为“form”）。事实上， `security.oauth2.client.*`属性绑定到一个实例， `AuthorizationCodeResourceDetails`所有的属性都可以被指定。

在非web应用程序中，您仍然可以创建一个OAuth2RestOperations并且仍然连线到security.oauth2.client.*配置中。在这种情况下，它是一个“客户端凭据令牌授予”，如果您使用它（并且不需要使用@EnableOAuth2Client或@EnableOAuth2Sso），您将要求您提供。为了防止定义基础设施，只需security.oauth2.client.client-id从配置中删除（或使其成为空字符串）。

28.3.2单点登录

可以使用OAuth2客户端从提供者获取用户详细信息（如果这些功能可用），然后将其转换Authentication为Spring Security 的令牌。上面的资源服务器通过user-info-uri属性支持这是基于OAuth2的单点登录（SSO）协议的基础，Spring Boot通过提供注释使得参与变得容易@EnableOAuth2Sso。上面的Github客户端可以使用Github /user/端点来保护其所有资源并进行身份验证，通过添加该注释并声明在哪里可以找到端点（除了security.oauth2.client.*上面已经列出的配置之外）：

application.yml。

安全性：
     oauth2：
...
    资源：
         userInfoUri：https:
         //api.github.com/user preferTokenInfo：false

由于默认情况下所有路径都是安全的，所以没有“主页”页面，您可以向未经身份验证的用户显示并请他们登录（通过访问/login路径或指定的路径security.oauth2.sso.login-path）。

要定制访问规则或路径来保护，所以你可以添加一个“主页”的页面，例如@EnableOAuth2Sso可以添加到一个WebSecurityConfigurerAdapter和注释将导致它被装饰和增强与必要的作品，以获得/login路径工作。例如，在这里，我们只允许对“/”的主页进行未经验证的访问，并保留其他所有的默认值：

@Configuration
 public  class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {

    @Override
     public  void init（WebSecurity web）{
        web.ignore（“/”）;
    }

    @Override
    保护 无效配置（HttpSecurity http）抛出异常{
        http.antMatcher（“/ **”）.authorizeRequests（）。anyRequest（）。authenticated（）;
    }

}

28.4执行器安全

如果执行器也在使用中，您会发现：

即使应用程序端点不安全，管理端点也是安全的。
安全事件被转换成AuditEvent实例并发布给 AuditEventRepository。
默认用户将具有ACTUATOR角色以及USER角色。

执行器安全功能可以使用外部属性（management.security.*）进行修改。要覆盖应用程序访问规则添加一个@Bean类型的WebSecurityConfigurerAdapter和使用@Order(SecurityProperties.ACCESS_OVERRIDE_ORDER)，如果你不希望覆盖驱动器的访问规则，或者@Order(ManagementServerProperties.ACCESS_OVERRIDE_ORDER) 如果你不希望覆盖驱动器的访问规则。

29.使用SQL数据库

Spring框架为使用SQL数据库提供了广泛的支持。从使用直接JDBC访问JdbcTemplate到完成“对象关系映射”技术（如Hibernate）。Spring Data提供了额外的功能级别，Repository直接从接口创建实现，并使用约定从方法名称中生成查询。

29.1配置数据源

Java的javax.sql.DataSource接口提供了使用数据库连接的标准方法。传统上，DataSource使用URL一些凭据来建立数据库连接。


	检查更多高级示例的“操作方法”部分，通常要完全控制DataSource的配置。

29.1.1嵌入式数据库支持

使用内存嵌入式数据库开发应用程序通常很方便。显然，内存数据库不提供持久性存储; 您将需要在应用程序启动时填充数据库，并准备在应用程序结束时丢弃数据。


	“操作方法”部分包含有关如何初始化数据库的一节

Spring Boot可以自动配置嵌入式H2， HSQL和Derby数据库。您不需要提供任何连接URL，只需将构建依赖项包含到要使用的嵌入式数据库中即可。


	如果您在测试中使用此功能，则可能会注意到无论您使用的是多少个应用程序上下文，整个测试套件都会重复使用相同的数据库。如果你想确保每个上下文有一个单独的嵌入式数据库，你应该设置`spring.datasource.generate-unique-name`为`true`。

例如，典型的POM依赖将是：

<dependency> 
    <groupId> org.springframework.boot </ groupId> 
    <artifactId> spring-boot-starter-data-jpa </ artifactId> 
</ dependency> 
<dependency> 
    <groupId> org.hsqldb </ groupId> 
    <artifactId > hsqldb </ artifactId> 
    <scope> runtime </ scope> 
</ dependency>


	您需要依赖于`spring-jdbc`嵌入式数据库来自动配置。在这个例子中，它通过传递方式被拉动 `spring-boot-starter-data-jpa`。


	如果出于某种原因，您要为嵌入式数据库配置连接URL，则应注意确保数据库的自动关闭被禁用。如果你使用H2，你应该`DB_CLOSE_ON_EXIT=FALSE`这样做。如果你正在使用HSQLDB，你应该确保`shutdown=true`不使用。禁用数据库的自动关闭允许Spring Boot控制何时关闭数据库，从而确保在不再需要访问数据库时发生。

29.1.2连接到生产数据库

生产数据库连接也可以使用池进行自动配置DataSource。以下是选择特定实现的算法：

我们更喜欢Tomcat池DataSource的性能和并发性，所以如果可用，我们总是选择它。
否则，如果HikariCP可用，我们将使用它。
如果Tomcat池数据源和HikariCP都不可用，并且Commons DBCP可用，我们将使用它，但我们不建议在生产中使用它，并且不支持它。
最后，如果Commons DBCP2可用，我们将使用它。

如果你使用spring-boot-starter-jdbcor spring-boot-starter-data-jpa starters，你会自动获得依赖tomcat-jdbc。


	您可以完全绕过该算法，并通过`spring.datasource.type`属性指定要使用的连接池。如果您在`tomcat-jdbc`默认情况下提供的Tomcat容器中运行应用程序，这一点尤其重要。


	其他连接池可以始终手动配置。如果你定义你自己的`DataSource`bean，自动配置将不会发生。

数据源配置由外部配置属性控制 spring.datasource.*。例如，您可以在以下部分声明以下部分 application.properties：

spring.datasource.url = jdbc：mysql：// localhost / test
 spring.datasource.username = dbuser
 spring.datasource.password =
 dbpass spring.datasource.driver-class-name = com.mysql.jdbc.Driver


	您至少应该使用`spring.datasource.url`属性指定url，否则Spring Boot将尝试自动配置嵌入式数据库。


	你通常不需要指定，`driver-class-name`因为Spring引导可以从大多数数据库中推导出来`url`。


	为了`DataSource`创建一个池，我们需要能够验证一个有效的 `Driver`类是可用的，所以我们在做任何事之前检查它。也就是说，如果你设置了，`spring.datasource.driver-class-name=com.mysql.jdbc.Driver`那么这个类必须是可加载的。

请参阅DataSourceProperties 更多支持的选项。这些是标准选项，不管实际的实施情况如何。也可以使用其各自的前缀微调实现特定的设置（spring.datasource.tomcat.*， spring.datasource.hikari.*，和spring.datasource.dbcp2.*）。请参阅您正在使用的连接池实现的文档以获取更多详细信息。

例如，如果您正在使用 Tomcat连接池，则可以自定义许多其他设置：

＃如果没有连接可用，则在抛出异常之前要等待的毫秒数。
spring.datasource.tomcat.max-wait = 10000

＃可同时从该池中分配的最大活动连接数。
spring.datasource.tomcat.max-active = 50

＃在从池中借用它之前验证连接。
spring.datasource.tomcat.test-on-borrow = true

29.1.3连接到JNDI数据源

如果您将Spring Boot应用程序部署到应用程序服务器，则可能需要使用应用程序服务器内置功能来配置和管理数据源，并使用JNDI访问它。

该spring.datasource.jndi-name属性可以用来替代特定的JNDI位置spring.datasource.url，spring.datasource.username以及spring.datasource.password 访问DataSource特定JNDI位置的属性。例如，下面的部分application.properties将向您展示如何访问定义的JBoss ASDataSource：

spring.datasource.jndi-name = java：jboss / datasources / customers

29.2使用JdbcTemplate

Spring的类JdbcTemplate和NamedParameterJdbcTemplate类是自动配置的，你可以@Autowire直接把它们放到你自己的bean中：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

@Component
公共 类 MyBean {

    私人 最终 JdbcTemplate jdbcTemplate;

    @Autowired
     public MyBean（JdbcTemplate jdbcTemplate）{
         this .jdbcTemplate = jdbcTemplate;
    }

    // ...

}

29.3 JPA和“Spring Data”

Java持久性API是一种标准技术，允许您将对象映射到关系数据库。该spring-boot-starter-data-jpaPOM提供了上手的快捷方式。它提供了以下关键依赖关系：

Hibernate - 最流行的JPA实现之一。
Spring Data JPA - 使实现基于JPA的存储库变得很容易。
Spring ORM - Spring框架的核心ORM支持。


	我们在这里不会涉及太多的JPA或Spring Data的细节。您可以按照 “使用JPA访问数据”从引导 spring.io并宣读了春天的数据JPA 和Hibernate的参考文档。


	默认情况下，Spring Boot使用Hibernate 5.0.x. 但是，如果您愿意，也可以使用4.3.x或5.2.x。请参阅 Hibernate 4和 Hibernate 5.2示例以了解如何执行此操作。

29.3.1实体类

传统上，JPA的“实体”类是在persistence.xml文件中指定的。使用Spring Boot这个文件是不必要的，而是使用“实体扫描”。默认情况下，将会搜索主要配置类（使用@EnableAutoConfigurationor 注释的那个@SpringBootApplication）下面的所有包。

任何类注解@Entity，@Embeddable或@MappedSuperclass将被考虑。典型的实体类看起来像这样：

包 com.example.myapp.domain;

import java.io.Serializable;
import javax.persistence。*;

@Entity
 public  class City实现 Serializable {

    @Id 
    @GeneratedValue
    私人长ID;

    @Column（nullable = false）
    私人字符串名称;

    @Column（nullable = false）
    私人字符串状态;

    // ...额外的成员，通常包括@OneToMany映射

    protected City（）{
         // JPA spec要求的无参数构造函数
        //这个函数是受保护的，因为它不应该直接使用
    }

    public City（String name，String state）{
         this .name = name;
        这个 .country = country;
    }

    公共字符串的getName（）{
         返回 此。名称;
    }

    public String getState（）{
         return  this .state;
    }

    // ...等

}


	您可以使用`@EntityScan`注释来自定义实体扫描位置。请参阅第77.4节“从Spring配置中分离@实体定义”。

29.3.2 Spring数据JPA存储库

Spring Data JPA存储库是您可以定义以访问数据的接口。JPA查询是从您的方法名称自动创建的。例如，一个CityRepository 界面可能会声明一个findAllByState(String state)方法来查找给定状态下的所有城市。

对于更复杂的查询，您可以使用Spring Data的Query批注注释您的方法。

Spring数据存储库通常从Repository或 CrudRepository接口扩展。如果您正在使用自动配置，则将从包含您的主配置类（使用@EnableAutoConfiguration或注@SpringBootApplication）的包中搜索存储库。

这是一个典型的Spring数据库：

包 com.example.myapp.domain;

import org.springframework.data.domain。*;
import org.springframework.data.repository。*;

公共 接口 CityRepository 扩展了 Repository <City，Long> {

    Page <City> findAll（可分页）;

    城市findByNameAndCountryAllIgnoringCase（String name，String country）;

}


	我们几乎没有触及Spring Data JPA的表面。有关完整的详细检查他们的参考文档。

29.3.3创建和删除JPA数据库

默认情况下，只有在使用嵌入式数据库（H2，HSQL或Derby）时才会自动创建JPA数据库。您可以使用spring.jpa.*属性显式配置JPA设置。例如，要创建和删除表，您可以将以下内容添加到您的表中application.properties。

spring.jpa.hibernate.ddl-AUTO =创造降


	Hibernate自己的内部属性名称（如果你碰巧记得更好）是`hibernate.hbm2ddl.auto`。您可以使用`spring.jpa.properties.*`（在将前缀添加到实体管理器之前剥离前缀）将其与其他Hibernate本机属性一起设置。例：

spring.jpa.properties.hibernate.globally_quoted_identifiers =真

传递hibernate.globally_quoted_identifiers给Hibernate实体管理器。

默认情况下，DDL执行（或验证）被延迟，直到ApplicationContext 启动。还有一个spring.jpa.generate-ddl标志，但是如果Hibernate的autoconfig处于活动状态，这个标志就不会被使用，因为这些ddl-auto设置更加细化了。

29.3.4在View中打开EntityManager

如果你正在运行一个web应用程序，Spring Boot将默认注册 OpenEntityManagerInViewInterceptor 应用“Open EntityManager in View”模式，即允许在web视图中延迟加载。如果你不希望这种行为，你应该设置spring.jpa.open-in-view到 false你application.properties。

29.4使用H2的Web控制台

该H2数据库提供了一个基于浏览器的控制台是春天开机即可自动为您配置。当满足以下条件时，控制台将自动配置：

您正在开发一个Web应用程序
com.h2database:h2 在类路径上
您正在使用Spring Boot的开发人员工具


	如果你没有使用Spring Boot的开发工具，但是仍然想使用H2的控制台，那么你可以通过配置`spring.h2.console.enabled` 属性值来实现`true`。H2控制台仅用于开发过程中，因此请注意确保`spring.h2.console.enabled`不会`true`在生产中使用。

29.4.1改变H2控制台的路径

默认情况下，控制台将在/h2-console。您可以使用该spring.h2.console.path属性自定义控制台的路径。

29.4.2固定H2控制台

当Spring Security在类路径上并且启用了基本身份验证时，H2控制台将使用基本身份验证自动进行保护。以下属性可用于自定义安全性配置：

security.user.role
security.basic.authorize-mode
security.basic.enabled

29.5使用jOOQ

Java面向对象查询（jOOQ）是Data Geekery的一个流行产品，它可以从您的数据库中生成Java代码，并允许您通过其流畅的API来构建类型安全的SQL查询。商业和开源版本都可以和Spring Boot一起使用。

29.5.1代码生成

为了使用jOOQ类型安全的查询，您需要从数据库模式生成Java类。您可以按照jOOQ用户手册中的说明进行操作。如果你正在使用jooq-codegen-maven插件（你也使用spring-boot-starter-parent“父POM”），你可以安全地省略插件的<version> 标签。你也可以使用Spring Boot定义的版本变量（例如h2.version）来声明插件的数据库依赖性。这是一个例子：

<plugin> 
    <groupId> org.jooq </ groupId> 
    <artifactId> jooq-codegen-maven </ artifactId> 
    <executions>
        ...
    </处决> 
    <依赖性> 
        <依赖性> 
            <的groupId> com.h2database </的groupId> 
            <artifactId的> H2 </ artifactId的> 
            <版本> $ {h2.version} </版本> 
        </依赖性> 
    </依赖> 
    <配置> 
        <jdbc> 
            <driver> org.h2.Driver </ driver> 
            <url> jdbc：h2：〜/ yourdatabase </ url> 
        </ jdbc> 
        <generator>
            ...
        </ generator> 
    </ configuration> 
</ plugin>

29.5.2使用DSLContext

jOOQ提供的流畅的API是通过org.jooq.DSLContext接口启动的。Spring Boot将自动配置DSLContext为一个Spring Bean并将其连接到您的应用程序DataSource。要使用DSLContext你可以只是@Autowire它：

@Component
公共 类 JooqExample实现 CommandLineRunner {

    私人 最终 DSLContext创建;

    @Autowired
     public JooqExample（DSLContext dslContext）{
         this .create = dslContext;
    }

}


	jOOQ手册倾向于使用一个名字`create`来保存的变量`DSLContext`，在这个例子中我们做了相同的处理。

然后，您可以使用DSLContext来构建您的查询：

public List <GregorianCalendar> authorsBornAfter1980（）{
     return  this .create.selectFrom（AUTHOR）
        。凡（AUTHOR.DATE_OF_BIRTH.greaterThan（新的GregorianCalendar（1980，0，1）））
        .fetch（AUTHOR.DATE_OF_BIRTH）;
}

29.5.3定制jOOQ

您可以通过spring.jooq.sql-dialect在您的设置中自定义jOOQ使用的SQL方言application.properties。例如，要指定Postgres，您可以添加：

spring.jooq.sql-dialect = Postgres

更高级的定制可以通过定义你自己的@Bean定义来实现，这些定义将在jOOQ Configuration创建时使用。您可以为以下jOOQ类型定义bean：

ConnectionProvider
TransactionProvider
RecordMapperProvider
RecordListenerProvider
ExecuteListenerProvider
VisitListenerProvider

org.jooq.Configuration @Bean如果你想完全控制jOOQ配置，你也可以创建你自己的。

30.使用NoSQL技术

Spring Data提供的其他项目可以帮助您访问各种NoSQL技术，包括 MongoDB， Neo4J， Elasticsearch， Solr， Redis， Gemfire， Cassandra， Couchbase和 LDAP。Spring Boot提供Redis，MongoDB，Neo4j，Elasticsearch，Solr Cassandra，Couchbase和LDAP的自动配置; 你可以使用其他项目，但是你需要自己配置它们。请参阅projects.spring.io/spring-data上的相应参考文档。

30.1 Redis

Redis是一个缓存，消息代理和功能丰富的键值存储。Spring Boot为Jedis客户端库和Spring Data Redis提供的抽象类提供基本的自动配置。有一个spring-boot-starter-data-redis“Starter”以方便的方式收集依赖关系。

30.1.1连接到Redis

你可以注入一个自动配置的RedisConnectionFactory，StringRedisTemplate或者香草RedisTemplate实例，就像其他的Spring Bean一样。默认情况下，实例将尝试使用以下命令连接到Redis服务器localhost:6379：

@Component
公共 类 MyBean {

    私人 StringRedisTemplate模板;

    @Autowired
     public MyBean（StringRedisTemplate template）{
         this .template = template;
    }

    // ...

}

如果添加@Bean自己的任何自动配置类型，它将替换默认值（除非RedisTemplate排除的情况是基于bean名称“redisTemplate”而不是其类型）。如果commons-pool2是在类路径中，默认情况下会得到一个池连接工厂。

30.2 MongoDB

MongoDB是一个开源NoSQL文档数据库，它使用类似JSON的模式而不是传统的基于表格的关系数据。Spring Boot为MongoDB提供了一些便利，包括spring-boot-starter-data-mongodb“Starter”。

30.2.1连接到MongoDB数据库

你可以注入一个自动配置org.springframework.data.mongodb.MongoDbFactory来访问Mongo数据库。默认情况下，实例将尝试使用URL连接到MongoDB服务器mongodb://localhost/test：

import org.springframework.data.mongodb.MongoDbFactory;
import com.mongodb.DB;

@Component
公共 类 MyBean {

    私人 最终的 MongoDbFactory mongo;

    @Autowired
     public MyBean（MongoDbFactory mongo）{
         this .mongo = mongo;
    }

    // ...

    public  void example（）{
        DB db = mongo.getDb（）;
        // ...
    }

}

您可以设置spring.data.mongodb.uri属性来更改URL并配置其他设置，如副本集：

spring.data.mongodb.uri = mongodb：// user：[email protected] ：12345，mongo2.example.com：23456 / test

另外，只要你使用Mongo 2.x，指定一个host/ port。例如，您可以在以下内容中声明以下内容application.properties：

spring.data.mongodb.host = mongoserver
 spring.data.mongodb.port = 27017


	`spring.data.mongodb.hostspring.data.mongodb.port`如果您使用的是Mongo 3.0 Java驱动程序，则不受支持。在这种情况下，`spring.data.mongodb.uri`应该用来提供所有的配置。


	如果`spring.data.mongodb.port`未指定，`27017`则使用默认值。你可以简单地从上面的示例中删除这一行。


	如果你不使用Spring Data Mongo，你可以注入`com.mongodb.Mongo`bean而不是使用`MongoDbFactory`。

如果要完全控制建立MongoDB连接，还可以声明自己的MongoDbFactory或Mongobean。

30.2.2 MongoTemplate

Spring Data Mongo提供了一个 MongoTemplate类似于Spring的设计的类JdbcTemplate。和JdbcTemplateSpring Boot一样，自动配置一个bean来简单地注入：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.stereotype.Component;

@Component
公共 类 MyBean {

    私人 最终的 MongoTemplate mongoTemplate;

    @Autowired
     public MyBean（MongoTemplate mongoTemplate）{
         this .mongoTemplate = mongoTemplate;
    }

    // ...

}

有关MongoOperations完整的详细信息，请参阅Javadoc。

30.2.3 Spring Data MongoDB存储库

Spring Data包含对MongoDB的存储库支持。和前面讨论的JPA库一样，基本的原则是查询是基于方法名自动为你构建的。

实际上，Spring Data JPA和Spring Data MongoDB共享相同的通用基础结构; 所以你可以从之前的JPA例子中，假设City 现在是Mongo数据类而不是JPA @Entity，它将以相同的方式工作。

包 com.example.myapp.domain;

import org.springframework.data.domain。*;
import org.springframework.data.repository。*;

公共 接口 CityRepository 扩展了 Repository <City，Long> {

    Page <City> findAll（可分页）;

    城市findByNameAndCountryAllIgnoringCase（String name，String country）;

}


	有关Spring Data MongoDB的完整详细信息，包括丰富的对象映射技术，请参阅其参考文档。

30.2.4嵌入式Mongo

Spring Boot为嵌入式Mongo提供自动配置。要在Spring Boot应用程序中使用它，请添加一个依赖项 de.flapdoodle.embed:de.flapdoodle.embed.mongo。

Mongo将监听的端口可以使用该spring.data.mongodb.port 属性进行配置。要使用随机分配的空闲端口，请使用零值。在MongoClient 由创建MongoAutoConfiguration将被自动配置为使用随机分配的端口。


	如果您不配置自定义端口，默认情况下嵌入式支持将使用随机端口（而不是27017）。

如果你在类路径上有SLF4J，Mongo产生的输出将被自动路由到一个名为logger的记录器org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongo。

您可以声明自己的IMongodConfig和IRuntimeConfigbean来控制Mongo实例的配置和日志路由。

30.3 Neo4j

Neo4j是一个开放源代码的NoSQL图形数据库，它使用由一级关系相关的丰富的节点数据模型，比传统的rdbms方法更适合于连接大数据。Spring Boot为使用Neo4j提供了一些便利，包括spring-boot-starter-data-neo4j“Starter”。

30.3.1连接到Neo4j数据库

你可以注入的自动配置Neo4jSession，Session或者Neo4jOperations，就像任何其他的Spring Bean实例。默认情况下，实例将尝试使用以下命令连接到Neo4j服务器localhost:7474：

@Component
公共 类 MyBean {

    私人 最终 Neo4jTemplate neo4jTemplate;

    @Autowired
     public MyBean（Neo4jTemplate neo4jTemplate）{
         this .neo4jTemplate = neo4jTemplate;
    }

    // ...

}

您可以通过添加org.neo4j.ogm.config.Configuration @Bean自己的配置来完全控制配置。另外，添加一个@Bean类型 Neo4jOperations将禁用自动配置。

您可以通过以下spring.data.neo4j.* 属性配置用户和凭证：

spring.data.neo4j.uri = http：// my-server：7474
 spring.data.neo4j.username = neo4j
 spring.data.neo4j.password = secret

30.3.2使用嵌入模式

如果添加org.neo4j:neo4j-ogm-embedded-driver到应用程序的依赖项中，Spring Boot将自动配置Neo4j的进程中嵌入式实例，在应用程序关闭时不会保留任何数据。您可以使用显式禁用该模式spring.data.neo4j.embedded.enabled=false。您也可以为嵌入模式启用持久性：

	spring.data.neo4j.uri =文件：//var/tmp/graph.db

30.3.3 Neo4jSession

默认情况下，如果您正在运行Web应用程序，则会话将被绑定到线程以进行整个请求处理（即“打开会话在视图中”模式）。如果您不想要这种行为，请将以下内容添加到您的application.properties：

	spring.data.neo4j.open式视=假

30.3.4 Spring Data Neo4j存储库

Spring数据包括Neo4j的存储库支持。

实际上，Spring Data JPA和Spring Data Neo4j共享相同的通用基础结构; 所以你可以从之前的JPA例子中，假设City 现在是Neo4j OGM @NodeEntity而不是JPA @Entity，它将以相同的方式工作。


	您可以使用`@EntityScan`注释来自定义实体扫描位置。

要启用存储库支持（并可选择支持@Transactional），请将以下两个注释添加到您的Spring配置中：

@ EnableNeo4jRepositories（basePackages =“com.example.myapp.repository”） 
@EnableTransactionManagement

30.3.5存储库示例

包 com.example.myapp.domain;

import org.springframework.data.domain。*;
import org.springframework.data.repository。*;

公共 接口 CityRepository 扩展 GraphRepository <City> {

    Page <City> findAll（可分页）;

    城市findByNameAndCountry（String name，String country）;

}


	有关Spring Data Neo4j的完整详细信息，包括丰富的对象映射技术，请参阅其参考文档。

30.4宝石

Spring Data Gemfire为访问Pivotal Gemfire数据管理平台提供了方便Spring的工具。有一个spring-boot-starter-data-gemfire“Starter”以方便的方式收集依赖关系。目前没有Gemfire的自动配置支持，但你可以使用单个注释（@EnableGemfireRepositories）来启用Spring Data Repositories 。

30.5 Solr

Apache Solr是一个搜索引擎。Spring Boot为Solr 5客户端库和Spring Data Solr提供的抽象类提供基本的自动配置。有一个spring-boot-starter-data-solr“Starter”以方便的方式收集依赖关系。

30.5.1连接到Solr

您可以像注入SolrClient其他Spring bean一样注入一个自动配置的实例。默认情况下，实例将尝试使用localhost:8983/solr以下命令连接到服务器：

@Component
公共 类 MyBean {

    私有的 SolrClient solr;

    @Autowired
     public MyBean（SolrClient solr）{
         this .solr = solr;
    }

    // ...

}

如果你添加一个@Bean你自己的类型，SolrClient它会替换默认的。

30.5.2 Spring Data Solr存储库

Spring Data包含Apache Solr的存储库支持。和前面讨论的JPA库一样，基本的原则是查询是基于方法名自动为你构建的。

实际上，Spring Data JPA和Spring Data Solr共享相同的通用基础结构; 所以你可以从之前的JPA例子中，假设City现在是一个 @SolrDocument类而不是JPA @Entity，它将以同样的方式工作。


	有关Spring Data Solr的完整详细信息，请参阅其参考文档。

30.6 Elasticsearch

Elasticsearch是一个开源的，分布式的实时搜索和分析引擎。Spring Boot为弹性数据Elasticsearch提供的Elasticsearch和抽象类提供了基本的自动配置。有一个spring-boot-starter-data-elasticsearch“Starter”以方便的方式收集依赖关系。Spring Boot也支持 Jest。

30.6.1使用Jest连接到Elasticsearch

如果您有Jest类路径，则可以默认注入一个自动配置的JestClient 目标localhost:9200。您可以进一步调整客户端的配置方式：

spring.elasticsearch.jest.uris = http：//search.example.com：9200
 spring.elasticsearch.jest.read-timeout = 10000
 spring.elasticsearch.jest.username = user
 spring.elasticsearch.jest.password = secret

您还可以注册任意数量的bean，实现 HttpClientConfigBuilderCustomizer更高级的自定义。下面的例子调整额外的HTTP设置：

静态 类 HttpSettingsCustomizer 实现 HttpClientConfigBuilderCustomizer {

    @Override
     public  void customize（HttpClientConfig.Builder builder）{
        builder.maxTotalConnection（100）.defaultMaxTotalConnectionPerRoute（5）;
    }

}

要完全控制注册，请定义一个JestClientbean。

30.6.2使用Spring Data连接到Elasticsearch

你可以注入一个自动配置的ElasticsearchTemplate或Elasticsearch Client 实例，就像其他的Spring Bean一样。默认情况下，实例将嵌入一个本地内存服务器（Node以Elasticsearch术语来说），并使用当前工作目录作为服务器的主目录。在这个设置中，首先要做的是告诉Elasticsearch在哪里存储文件：

spring.data.elasticsearch.properties.path.home = / foo / bar

或者，您可以TransportClient通过设置spring.data.elasticsearch.cluster-nodes为以逗号分隔的“主机：端口”列表来切换到远程服务器（即a ）。

spring.data.elasticsearch.cluster-nodes = localhost：9300

@Component
公共 类 MyBean {

    私人 Elasticsearch模板模板;

    @Autowired
     public MyBean（ElasticsearchTemplate模板）{
         this .template = template;
    }

    // ...

}

如果你添加一个@Bean你自己的类型，ElasticsearchTemplate它会替换默认的。

30.6.3 Spring Data Elasticsearch存储库

Spring Data包含Elasticsearch的存储库支持。和前面讨论的JPA库一样，基本的原则是查询是基于方法名自动为你构建的。

实际上，Spring Data JPA和Spring Data Elasticsearch共享相同的通用基础结构; 所以你可以从之前的JPA例子中，假设 City现在是Elasticsearch @Document类而不是JPA @Entity，它将以相同的方式工作。


	有关Spring Data Elasticsearch的完整详细信息，请参阅其参考文档。

30.7卡桑德拉

Cassandra是一个开源的分布式数据库管理系统，用于处理大量商品服务器上的大量数据。Spring Boot提供了Cassandra的自动配置和Spring Data Cassandra提供的抽象。有一个spring-boot-starter-data-cassandra“Starter”以方便的方式收集依赖关系。

30.7.1连接到Cassandra

您可以像使用其他Spring Bean一样注入自动配置CassandraTemplate或Cassandra Session实例。这些spring.data.cassandra.* 属性可以用来定制连接。一般你会提供 keyspace-name和contact-points属性：

spring.data.cassandra.keyspace-name = mykeyspace
 spring.data.cassandra.contact-points = cassandrahost1，cassandrahost2

@Component
公共 类 MyBean {

    私人 CassandraTemplate模板;

    @Autowired
     public MyBean（CassandraTemplate模板）{
         this .template = template;
    }

    // ...

}

如果你添加一个@Bean你自己的类型，CassandraTemplate它会替换默认的。

30.7.2 Spring Data Cassandra存储库

Spring Data包含对Cassandra的基本存储库支持。目前这比前面讨论的JPA存储库更有限，并且需要用查找方法来注释@Query。


	有关Spring Data Cassandra的完整详细信息，请参阅其参考文档。

30.8沙发

Couchbase是一个开源的分布式多模型NoSQL面向文档的数据库，针对交互式应用进行了优化。Spring Boot提供了Couchbase的自动配置和Spring Data Couchbase提供的抽象。有一个spring-boot-starter-data-couchbase“Starter”以方便的方式收集依赖关系。

30.8.1连接到Couchbase

你可以很容易得到Bucket，并Cluster通过添加Couchbase SDK和一些配置。这些spring.couchbase.*属性可以用来定制连接。一般你会提供引导主机，存储桶名称和密码：

spring.couchbase.bootstrap-hosts = my-host-1,192.168.1.123
 spring.couchbase.bucket.name = my-bucket
 spring.couchbase.bucket.password = secret


	您至少需要提供引导主机，在这种情况下，存储区名称是`default`，密码是空字符串。或者，您可以定义自己的权限`org.springframework.data.couchbase.config.CouchbaseConfigurer` `@Bean`来控制整个配置。

也可以自定义一些CouchbaseEnvironment设置。例如，以下配置更改用于打开新的Bucket启用SSL支持的超时时间：

spring.couchbase.env.timeouts.connect = 3000
 spring.couchbase.env.ssl.key-store = / location / of / keystore.jks
 spring.couchbase.env.ssl.key-store-password = secret

检查spring.couchbase.env.*属性的更多细节。

30.8.2 Spring Data Couchbase存储库

Spring Data包含Couchbase的存储库支持。有关Spring Data Couchbase的完整详细信息，请参阅其参考文档。

CouchbaseTemplate只要缺省 CouchbaseConfigurer值可用（如上所述，启用了couchbase支持时会发生这种情况），您可以像使用其他Spring Bean一样注入自动配置的实例。

@Component
公共 类 MyBean {

    私人 最终的 CouchbaseTemplate模板;

    @Autowired
     public MyBean（CouchbaseTemplate模板）{
         this .template = template;
    }

    // ...

}

您可以在自己的配置中定义几个bean来覆盖自动配置提供的bean：

一个CouchbaseTemplate @Bean名字couchbaseTemplate
一个IndexManager @Bean名字couchbaseIndexManager
一个CustomConversions @Bean名字couchbaseCustomConversions

为了避免在自己的配置中对这些名称进行硬编码，可以使用BeanNamesSpring Data Couchbase提供的重用。例如，您可以自定义转换器使用如下：

@Configuration
 public  class SomeConfiguration {

    @Bean（BeanNames.COUCHBASE_CUSTOM_CONVERSIONS）
     public CustomConversions myCustomConversions（）{
         return  new CustomConversions（...）;
    }

    // ...

}


	如果您想完全绕过Spring Data Couchbase的自动配置，请提供您自己的`org.springframework.data.couchbase.config.AbstractCouchbaseDataConfiguration` 实现。

30.9 LDAP

LDAP（轻量级目录访问协议）是一种开放的，厂商中立的行业标准应用协议，用于通过IP网络访问和维护分布式目录信息服务。Spring Boot为任何兼容的LDAP服务器提供自动配置，并支持来自UnboundID的嵌入式内存LDAP服务器。

Spring Data LDAP提供LDAP抽象。有一个spring-boot-starter-data-ldap“Starter”以方便的方式收集依赖关系。

30.9.1连接到LDAP服务器

要连接到LDAP服务器，请确保声明对spring-boot-starter-data-ldap“Starter” 的依赖关系，或者spring-ldap-core在application.properties中声明服务器的URL：

spring.ldap.urls = ldap：// myserver：1235
 spring.ldap.username = admin
 spring.ldap.password = secret

如果您需要自定义连接设置，则可以使用spring.ldap.base和 spring.ldap.base-environment属性。

30.9.2 Spring Data LDAP存储库

Spring Data包含LDAP的存储库支持。有关Spring Data LDAP的完整详细信息，请参阅其参考文档。

您也可以LdapTemplate像使用其他Spring Bean一样注入自动配置的实例。

@Component
公共 类 MyBean {

    私人 最终 LdapTemplate模板;

    @Autowired
     public MyBean（LdapTemplate模板）{
         this .template = template;
    }

    // ...

}

30.9.3嵌入式内存LDAP服务器

出于测试目的，Spring Boot支持从UnboundID自动配置内存中的LDAP服务器。要配置服务器，添加一个依赖项com.unboundid:unboundid-ldapsdk并声明一个base-dn属性：

spring.ldap.embedded.base-dn = dc = spring，dc = io

默认情况下，服务器将在随机端口上启动，并触发常规的LDAP支持（不需要指定spring.ldap.urls属性）。

如果schema.ldif你的类路径中有一个文件，它将被用来初始化服务器。spring.ldap.embedded.ldif如果要从其他资源加载初始化脚本，也可以使用该属性。

默认情况下，将使用标准模式来验证LDIF文件，您可以使用该spring.ldap.embedded.validation.enabled属性完全关闭验证。如果您有自定义属性，则可以使用它spring.ldap.embedded.validation.schema来定义自定义属性类型或对象类。

31.缓存

Spring框架提供了对应用程序透明地添加缓存的支持。其核心是抽象将缓存应用于方法，从而根据缓存中可用的信息减少执行次数。缓存逻辑是透明应用的，对调用者没有任何干扰。


	查看Spring Framework参考的相关部分以获取更多详细信息。

简而言之，将缓存添加到服务的操作中，就像将相关的注释添加到其方法一样简单：

import javax.cache.annotation.CacheResult;

import org.springframework.stereotype.Component;

@Component
公共 类 MathService {

    @CacheResult
     public  int computePiDecimal（ int i）{
         // ...
    }

}


	您可以透明地使用标准的JSR-107（JCache）注释或Spring自己的缓存注释。我们强烈建议您不要混淆和匹配。


	透明地更新或驱逐缓存中的数据也是可能的。

31.1支持的缓存提供程序

缓存抽象不提供实际的存储，并依赖于org.springframework.cache.Cache和 org.springframework.cache.CacheManager接口实现的抽象。CacheManager只要通过@EnableCaching注释启用缓存支持，Spring Boot就会根据实现自动配置一个合适的配置。


	如果您正在使用非基于接口的Bean的缓存基础结构，请确保启用`proxyTargetClass`属性`@EnableCaching`。


	使用`spring-boot-starter-cache`“Starter”快速添加基本的缓存依赖关系。初学者带来`spring-context-support`：如果您手动添加依赖关系，如果您打算使用JCache，EhCache 2.x或Guava支持，则必须包含它。

如果你还没有定义类型CacheManager或CacheResolver命名的bean cacheResolver（参见参考资料CachingConfigurer），Spring Boot将尝试检测以下提供程序（按此顺序）：

通用
JCache（JSR-107）（EhCache 3，Hazelcast，Infinispan等）
EhCache 2.x
Hazelcast
Infinispan的
Couchbase
Redis的
咖啡因
番石榴（已弃用）
简单


	也可以强制缓存提供程序通过该`spring.cache.type` 属性使用。如果您需要在特定环境（例如测试）中完全禁用缓存，请使用此属性。

如果CacheManager是由Spring Boot自动配置，那么可以通过公开一个实现CacheManagerCustomizer接口的bean来完全初始化它的配置。以下设置要使用的缓存名称。

@Bean
 public CacheManagerCustomizer <ConcurrentMapCacheManager> cacheManagerCustomizer（）{
     return  new CacheManagerCustomizer <ConcurrentMapCacheManager>（）{
         @
         Override public  void customize（ConcurrentMapCacheManager cacheManager）{
            cacheManager.setCacheNames（Arrays.asList（“one”，“two”））;
        }
    };
}


	在上面的例子中，a `ConcurrentMapCacheManager`预计将被配置。如果不是这样，定制程序将不会被调用。你可以有任意多的定制器，你也可以像往常一样使用`@Order`or命令`Ordered`。

31.1.1通用

如果上下文定义了至少一个 org.springframework.cache.Cachebean，则使用通用缓存CacheManager。

31.1.2 JCache（JSR-107）

JCache通过javax.cache.spi.CachingProvider类路径（即兼容JSR-107的缓存库）和“Starter” JCacheCacheManager 提供的引导来引导spring-boot-starter-cache。在那里有各种兼容的库，Spring Boot提供Ehcache 3，Hazelcast和Infinispan的依赖管理。任何其他兼容的库也可以添加。

可能会出现多个供应商存在的情况，在这种情况下，供应商必须明确指定。即使JSR-107标准没有强制规定配置文件的位置，Spring Boot也会尽力满足实现细节。

＃只有当多个提供者存在时才需要
spring.cache.jcache.provider = com.acme.MyCachingProvider
 spring.cache.jcache.config = classpath：acme.xml


	由于缓存库可能提供本地实现和JSR-107支持，因此Spring Boot将更喜欢JSR-107支持，因此如果切换到不同的JSR-107实现，则可以使用相同的功能。

有几种方法来定制基础javax.cache.cacheManager：

缓存可以在启动时通过spring.cache.cache-names属性创建。如果定义了一个自定义javax.cache.configuration.Configurationbean，它将用于自定义它们。
org.springframework.boot.autoconfigure.cache.JCacheManagerCustomizerbean被调用，CacheManager以完全定制的参考。


	如果`javax.cache.CacheManager`定义了一个标准的bean，它将被自动包装在`org.springframework.cache.CacheManager`抽象所期望的实现中。没有进一步的定制应用于此。

31.1.3 EhCache 2.x

如果ehcache.xml可以在类路径的根目录找到一个名为的文件，则使用EhCache 2.x。如果EhCache 2.x，EhCacheCacheManager由spring-boot-starter-cache'Starter' 提供，并且存在这样的文件，它将用于引导缓存管理器。备用配置文件也可以使用：

spring.cache.ehcache.config = classpath：config / another-config.xml

31.1.4 Hazelcast

Spring Boot 对Hazelcast有广泛的支持。如果a HazelcastInstance已被自动配置，则会自动包装在a中 CacheManager。

31.1.5 Infinispan

Infinispan没有默认配置文件位置，因此必须明确指定（或使用默认引导程序）。

spring.cache.infinispan.config = infinispan.xml

缓存可以在启动时通过spring.cache.cache-names属性创建。如果定义了一个自定义 ConfigurationBuilderbean，它将用于自定义它们。

31.1.6 Couchbase

如果Couchbase java客户端和couchbase-spring-cache实现可用并且Couchbase已配置， CouchbaseCacheManager则将自动配置a。也可以使用该spring.cache.cache-names属性在启动时创建额外的缓存。这些将在Bucket自动配置的操作。您可以还创建另一个附加缓存中 Bucket使用定制：假设您需要在“主”两个高速缓存Bucket（foo 和bar）和一个biz高速缓存使用自定义的时间对生活的2秒another Bucket。首先，您可以简单地通过配置创建两个第一个缓存：

spring.cache.cache-names = foo，bar

然后定义这个额外@Configuration配置额外Bucket和biz 缓存：

@Configuration
 public  class CouchbaseCacheConfiguration {

    私人 最终群集群;

    公共 CouchbaseCacheConfiguration（群集群集）{
         this .cluster = cluster;
    }

    @Bean
     public Bucket anotherBucket（）{
         return  this .cluster.openBucket（ “another”， “secret”）;
    }

    @Bean
     public CacheManagerCustomizer <CouchbaseCacheManager> cacheManagerCustomizer（）{
         return c  - > {
            c.prepareCache（“biz”，CacheBuilder.newInstance（anotherBucket（））
                    .withExpiration（2））;
        };
    }

}

此示例配置将重新使用Cluster通过自动配置创建的配置。

31.1.7 Redis

如果Redis可用并已配置，RedisCacheManager则会自动配置。也可以使用该spring.cache.cache-names 属性在启动时创建额外的缓存。


	默认情况下，添加一个关键字前缀，以防止如果两个单独的缓存使用相同的密钥，Redis将有重叠的键，并可能返回无效的值。我们强烈建议您在创建自己的设置时保持启用此设置`RedisCacheManager`。

31.1.8咖啡因

Caffeine是Guava缓存的Java 8重写，将取代Spring Boot 2.0中的Guava支持。如果咖啡因存在，则CaffeineCacheManager（由 spring-boot-starter-cache“起动器”提供）自动配置。可以使用该spring.cache.cache-names属性在启动时创建缓存，并按以下顺序（按此顺序）进行自定义：

缓存规范定义的 spring.cache.caffeine.spec
一个com.github.benmanes.caffeine.cache.CaffeineSpecbean被定义
一个com.github.benmanes.caffeine.cache.Caffeinebean被定义

举例来说，下面的配置创建foo和bar高速缓存按照500的最大尺寸和存活时间为10分钟

spring.cache.cache-names = foo，bar
 spring.cache.caffeine.spec = maximumSize = 500，expireAfterAccess = 600s

另外，如果com.github.benmanes.caffeine.cache.CacheLoader定义了一个bean，它会自动关联到CaffeineCacheManager。由于CacheLoader要与缓存管理器管理的所有缓存关联，因此必须将其定义为CacheLoader<Object, Object>。任何其他泛型类型将被自动配置忽略。

31.1.9番石榴（已弃用）

如果番石榴存在，a GuavaCacheManager自动配置。可以使用该spring.cache.cache-names属性在启动时创建缓存，并按以下顺序（按此顺序）进行自定义：

缓存规范定义的 spring.cache.guava.spec
一个com.google.common.cache.CacheBuilderSpecbean被定义
一个com.google.common.cache.CacheBuilderbean被定义

举例来说，下面的配置创建foo和bar高速缓存按照500的最大尺寸和存活时间为10分钟

spring.cache.cache-names = foo，bar
 spring.cache.guava.spec = maximumSize = 500，expireAfterAccess = 600s

另外，如果com.google.common.cache.CacheLoader定义了一个bean，它会自动关联到GuavaCacheManager。由于CacheLoader要与缓存管理器管理的所有缓存关联，因此必须将其定义为 CacheLoader<Object, Object>。任何其他泛型类型将被自动配置忽略。

31.1.10简单

如果这些选项中没有一个解决了，则使用ConcurrentHashMap 缓存存储的简单实现将被配置。如果应用程序中没有缓存库，则这是默认值。

31.1.11没有

当@EnableCaching您的配置中存在时，预计也会有合适的缓存配置。如果您需要在某些环境中完全禁用缓存，则强制缓存类型none使用无操作的实现：

spring.cache.type =无

信息

Spring框架为消息系统集成提供了广泛的支持：从简化的JMS API使用JmsTemplate到完整的基础结构，以便异步接收消息。Spring AMQP为“高级消息队列协议”提供了类似的功能，而Spring Boot也为RabbitTemplateRabbitMQ 提供了自动配置选项。在Spring WebSocket中也支持STOMP消息本身，Spring Boot通过启动器和少量的自动配置支持。Spring Boot也支持Apache Kafka。

32.1 JMS

该javax.jms.ConnectionFactory接口提供了一个创建javax.jms.Connection与JMS代理交互的标准方法。虽然Spring需要 ConnectionFactory使用JMS，但通常不需要直接使用它，而是可以依赖更高级别的消息抽象（请参阅Spring Framework参考文档的相关部分以了解详细信息）。Spring Boot还会自动配置发送和接收消息的必要基础结构。

32.1.1 ActiveMQ支持

当Spring Boot ConnectionFactory检测到ActiveMQ在类路径中可用时，它也可以配置它。如果代理存在，则会自动启动并配置嵌入式代理（只要未通过配置指定代理URL）。


	如果您正在使用`spring-boot-starter-activemq`必要的依赖关系来连接或嵌入一个ActiveMQ实例，以及与JMS集成的Spring基础结构。

ActiveMQ配置由外部配置属性控制 spring.activemq.*。例如，您可以在以下部分声明以下部分 application.properties：

spring.activemq.broker-url = tcp：//192.168.1.210：9876
 spring.activemq.user = admin
 spring.activemq.password = secret

请参阅 ActiveMQProperties 更多支持的选项。

默认情况下，如果ActiveMQ不存在，ActiveMQ将创建一个目标，因此目标将根据其提供的名称进行解析。

32.1.2 Artemis支持

当Spring Boot ConnectionFactory检测到Artemis在类路径中可用时，Spring Boot可以自动配置它。如果代理存在，则会自动启动并配置嵌入式代理（除非已明确设置mode属性）。支持的模式是:( embedded明确规定嵌入式代理是必需的，如果代理在类路径中不可用，则会导致错误），并native使用netty传输协议连接到代理。当配置后者时，Spring Boot ConnectionFactory使用默认设置配置到在本地机器上运行的代理的连接。


	如果您正在使用`spring-boot-starter-artemis`必要的依赖关系来连接现有的Artemis实例，以及与JMS集成的Spring基础结构。添加`org.apache.activemq:artemis-jms-server`到您的应用程序允许您使用嵌入式模式。

Artemis配置由外部配置属性控制 spring.artemis.*。例如，您可以在以下部分声明以下部分 application.properties：

spring.artemis.mode = native
 spring.artemis.host = 192.168.1.210
 spring.artemis.port = 9876
 spring.artemis.user = admin
 spring.artemis.password = secret

在嵌入代理时，可以选择是否要启用持久性，以及应该使其可用的目标列表。这些可以被指定为逗号分隔的列表，以使用默认选项创建它们; 或者您可以分别定义类型的bean org.apache.activemq.artemis.jms.server.config.JMSQueueConfiguration或org.apache.activemq.artemis.jms.server.config.TopicConfiguration高级队列和主题配置。

请参阅 ArtemisProperties 更多支持的选项。

根本不涉及任何JNDI查找，并且使用Artemis配置中的“name”属性或通过配置提供的名称来解析目的地的名称。

32.1.3使用JNDI ConnectionFactory

如果您正在应用程序服务器中运行您的应用程序，Spring Boot将尝试ConnectionFactory使用JNDI 查找JMS 。默认情况下，位置java:/JmsXA和java:/XAConnectionFactory将被检查。spring.jms.jndi-name如果您需要指定替代位置，则可以使用该属性：

spring.jms.jndi-name = java：/ MyConnectionFactory

32.1.4发送消息

Spring的JmsTemplate是自动配置的，你可以直接将它自动装入到你自己的bean中：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.stereotype.Component;

@Component
公共 类 MyBean {

    私人 最终 JmsTemplate jmsTemplate;

    @Autowired
     public MyBean（JmsTemplate jmsTemplate）{
         this .jmsTemplate = jmsTemplate;
    }

    // ...

}


	`JmsMessagingTemplate` 可以以类似的方式注入。如果定义了a `DestinationResolver`或`MessageConverter`bean，它们将自动关联到自动配置`JmsTemplate`。

32.1.5接收消息

当存在JMS基础结构时，可以使用注释@JmsListener来创建侦听器端点。如果没有JmsListenerContainerFactory定义，则默认配置是自动配置的。如果定义了a DestinationResolver或MessageConverterbeans，它们将自动关联到默认工厂。

默认工厂默认是事务性的。如果您运行在a JtaTransactionManager存在的基础结构中，则默认情况下将关联到侦听器容器。否则，sessionTransacted标志将被启用。在后一种情况下，您可以通过添加@Transactional侦听器方法（或其代理），将本地数据存储事务与传入消息的处理关联起来。这将确保一旦本地事务完成，传入消息就被确认。这还包括发送已在相同的JMS会话上执行的响应消息。

以下组件在someQueue目标上创建一个侦听器端点：

@Component
公共 类 MyBean {

    @JmsListener（destination =“someQueue”）
     public  void processMessage（String content）{
         // ...
    }

}


	检查Javadoc的`@EnableJms` 更多细节。

如果你需要创建更多的JmsListenerContainerFactory实例，或者如果你想覆盖默认值，Spring Boot提供了一个DefaultJmsListenerContainerFactoryConfigurer 可以用来初始化一个DefaultJmsListenerContainerFactory与自动配置相同的设置的实例。

例如，以下公开了使用特定的另一个工厂 MessageConverter：

@Configuration
静态 类 JmsConfiguration {

    @Bean
     public DefaultJmsListenerContainerFactory myFactory（
            DefaultJmsListenerContainerFactoryConfigurer配置器）{
        DefaultJmsListenerContainerFactory factory =
                新的 DefaultJmsListenerContainerFactory（）;
        configurer.configure（factory，connectionFactory（））;
        factory.setMessageConverter（myMessageConverter（））;
        退货工厂;
    }

}

那么你可以使用任何@JmsListener-annotated方法如下：

@Component
公共 类 MyBean {

    @JmsListener（destination = “someQueue”，containerFactory =“myFactory”）
     public  void processMessage（String content）{
         // ...
    }

}

32.2 AMQP

高级消息队列协议（AMQP）是面向消息中间件的平台中立的有线协议。Spring AMQP项目将核心Spring概念应用于基于AMQP的消息传递解决方案的开发。Spring Boot为通过RabbitMQ处理AMQP提供了一些便利，包括 spring-boot-starter-amqp“Starter”。

32.2.1 RabbitMQ支持

RabbitMQ是一个基于AMQP协议的轻量级，可靠，可扩展和可移植的消息代理。Spring使用RabbitMQAMQP协议进行通信。

RabbitMQ配置由外部配置属性控制 spring.rabbitmq.*。例如，您可以在以下部分声明以下部分 application.properties：

spring.rabbitmq.host = localhost
 spring.rabbitmq.port = 5672
 spring.rabbitmq.username = admin
 spring.rabbitmq.password = secret

请参阅RabbitProperties 更多支持的选项。


	检查了解AMQP，RabbitMQ使用的协议了解更多细节。

32.2.2发送消息

Spring的，AmqpTemplate并且AmqpAdmin是自动配置的，你可以直接将它们自动装入到你自己的bean中：

import org.springframework.amqp.core.AmqpAdmin;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
公共 类 MyBean {

    私人 最终 AmqpAdmin amqpAdmin;
    私人 最终 AmqpTemplate amqpTemplate;

    @Autowired
     public MyBean（AmqpAdmin amqpAdmin，AmqpTemplate amqpTemplate）{
         this .amqpAdmin = amqpAdmin;
        这个 .amqpTemplate = amqpTemplate;
    }

    // ...

}


	`RabbitMessagingTemplate` 可以以类似的方式注入。如果`MessageConverter`定义了一个bean，它将自动关联到自动配置`AmqpTemplate`。

任何org.springframework.amqp.core.Queue被定义为一个bean的东西都会被自动用来在RabbitMQ实例上声明一个相应的队列。

您可以AmqpTemplate对重试操作启用重试，例如在代理连接丢失的情况下。重试是默认禁用的。

32.2.3接收消息

当Rabbit基础结构存在时，任何bean都可以被注释 @RabbitListener以创建一个监听端点。如果没有RabbitListenerContainerFactory 定义，则默认配置是自动配置的。如果定义了a MessageConverter或 MessageRecovererbeans，它们将自动关联到默认工厂。

以下组件在someQueue队列上创建一个侦听器端点：

@Component
公共 类 MyBean {

    @RabbitListener（queues =“someQueue”）
     public  void processMessage（String content）{
         // ...
    }

}


	检查Javadoc的`@EnableRabbit` 更多细节。

如果你需要创建更多的RabbitListenerContainerFactory实例，或者如果你想覆盖默认值，Spring Boot提供了一个SimpleRabbitListenerContainerFactoryConfigurer可以用来初始化一个 SimpleRabbitListenerContainerFactory与自动配置相同的设置的实例。

例如，以下公开了使用特定的另一个工厂 MessageConverter：

@Configuration
静态 类 RabbitConfiguration {

    @Bean
     public SimpleRabbitListenerContainerFactory myFactory（
            SimpleRabbitListenerContainerFactoryConfigurer配置器）{
        SimpleRabbitListenerContainerFactory factory =
                新的 SimpleRabbitListenerContainerFactory（）;
        configurer.configure（factory，connectionFactory）;
        factory.setMessageConverter（myMessageConverter（））;
        退货工厂;
    }

}

那么你可以使用任何@RabbitListener-annotated方法如下：

@Component
公共 类 MyBean {

    @RabbitListener（queues = “someQueue”，containerFactory =“myFactory”）
     public  void processMessage（String content）{
         // ...
    }

}

您可以启用重试来处理侦听器引发异常的情况。默认情况下RejectAndDontRequeueRecoverer使用，但你可以定义一个MessageRecoverer 你自己的。当重试耗尽时，如果代理配置如此，则该消息将被拒绝并丢弃或路由到死信交换。重试是默认禁用的。

	重要
	如果重试未启用，并且侦听器引发异常，默认情况下，传递将无限期地重试。您可以通过两种方式修改此行为; 设置 `defaultRequeueRejected`财产`false`和零重新交付将尝试; 或者，发出`AmqpRejectAndDontRequeueException`信号应该被拒绝。这是启用重试并达到最大传送次数时使用的机制。

32.3 Apache Kafka支持

通过提供spring-kafka项目的自动配置来支持 Apache Kafka。

卡夫卡配置由外部配置属性控制 spring.kafka.*。例如，您可以在以下部分声明以下部分 application.properties：

spring.kafka.bootstrap-servers = localhost：9092
 spring.kafka.consumer.group-id = myGroup

请参阅KafkaProperties 更多支持的选项。

32.3.1发送消息

Spring的KafkaTemplate是自动配置的，你可以直接在你自己的bean中自动装配它们：

@Component
公共 类 MyBean {

	私人 最终 KafkaTemplate kafkaTemplate;

	@Autowired
	 public MyBean（KafkaTemplate kafkaTemplate）{
		 this .kafkaTemplate = kafkaTemplate;
	}

	// ...

}

32.3.2接收消息

当存在Apache Kafka基础结构时，可以使用注释 @KafkaListener来创建侦听器端点。如果KafkaListenerContainerFactory 未定义，则使用定义的键自动配置默认值 spring.kafka.listener.*。

以下组件为该someTopic主题创建一个侦听器端点：

@Component
公共 类 MyBean {

    @KafkaListener（topics =“someTopic”）
     public  void processMessage（String content）{
         // ...
    }

}

32.3.3额外的卡夫卡属性

附录A“ 通用应用程序属性”中显示了自动配置支持的属性。请注意，这些属性（连字符或camelCase）大部分直接映射到Apache Kafka虚线属性，有关详细信息，请参阅Apache Kafka文档。

前面几个属性适用于生产者和消费者，但是如果你想为每个生产者和消费者使用不同的值，可以在生产者或消费者层面指定。Apache Kafka指定重要属性：HIGH，MEDIUM和LOW。Spring Boot自动配置支持所有HIGH重要性属性，一些选择MEDIUM和LOW，以及任何没有默认值的属性。

只有Kafka支持的属性的一个子集可以通过这个KafkaProperties 类来使用。如果您希望使用不直接支持的其他属性来配置生产者或消费者，请使用以下命令：

spring.kafka.properties.foo.bar = baz

这将普通的foo.bar卡夫卡物业设置为baz。

这些属性将由消费者和生产者工厂bean共享。如果您希望使用不同的属性自定义这些组件，例如为每个属性使用不同的度量标准读取器，则可以覆盖这些bean定义，如下所示：

@Configuration
公共 静态 类 CustomKafkaBeans {

    / **
     *定制的ProducerFactory bean。
     * @参数属性的kafka属性。
     * @返回bean。
     * / 
    @Bean
     public ProducerFactory <?,？> kafkaProducerFactory（KafkaProperties属性）{
        Map <String，Object> producerProperties = properties.buildProducerProperties（）;
        producerProperties.put（CommonClientConfigs.METRIC_REPORTER_CLASSES_CONFIG，
                MyProducerMetricsReporter。类）;
        返回 新的 DefaultKafkaProducerFactory <Object，Object>（producerProperties）;
    }

    / **
     *定制的ConsumerFactory bean。
     * @参数属性的kafka属性。
     * @返回bean。
     * / 
    @Bean
     public ConsumerFactory <？，？> kafkaConsumerFactory（KafkaProperties属性）{
        Map <String，Object> consumerProperties = properties.buildConsumerProperties（）;
        consumerProperties.put（CommonClientConfigs.METRIC_REPORTER_CLASSES_CONFIG，
                MyConsumerMetricsReporter。类）;
        返回 新的 DefaultKafkaConsumerFactory <Object，Object>（consumerProperties）;
    }

}

33.调用REST服务

如果您需要从您的应用程序调用远程REST服务，则可以使用Spring Framework的RestTemplate类。由于RestTemplate实例经常需要在使用之前进行定制，因此Spring Boot不提供任何单个自动配置的 RestTemplatebean。但是，它会自动配置一个RestTemplateBuilder可用于RestTemplate在需要时创建实例的配置。自动配置RestTemplateBuilder将确保合理HttpMessageConverters应用于RestTemplate实例。

这是一个典型的例子：

@Service
公共 类 MyBean {

    私人 决赛 RestTemplate restTemplate;

    public MyBean（RestTemplateBuilder restTemplateBuilder）{
         this .restTemplate = restTemplateBuilder.build（）;
    }

    公众详细someRestCall（字符串名称）{
         返回 此 .restTemplate.getForObject（“/ {名} /详细信息”，详细信息。类，名）;
    }

}


	`RestTemplateBuilder`包括一些有用的方法，可以用来快速配置一个`RestTemplate`。例如，要添加BASIC认证支持，您可以使用`builder.basicAuthorization("user", "password").build()`。

33.1 RestTemplate自定义

RestTemplate定制有三种主要方法，具体取决于您希望自定义应用的范围。

要使自定义的范围尽可能窄，请注入自动配置 RestTemplateBuilder，然后根据需要调用其方法。每个方法调用都会返回一个新RestTemplateBuilder实例，所以自定义只会影响构建器的这种使用。

为了在整个应用程序范围内进行添加定制，RestTemplateCustomizer可以使用bean。所有这些bean都会自动注册到自动配置 RestTemplateBuilder，并将应用于任何与之一起构建的模板。

以下是定制器的一个示例，它为所有主机配置代理的使用，除了 192.168.0.5：

静态 类 ProxyCustomizer 实现 RestTemplateCustomizer {

    @Override
     public  void customize（RestTemplate restTemplate）{
        HttpHost代理= 新的 HttpHost（“proxy.example.com”）;
        HttpClient httpClient = HttpClientBuilder.create（）
                .setRoutePlanner（new DefaultProxyRoutePlanner（proxy）{

                    @覆盖
                    公共 HttpHost determineProxy（HttpHost目标，
                            HttpRequest请求，HttpContext上下文）
                                    抛出 HttpException {
                         if（target.getHostName（）。equals（“192.168.0.5”））{
                             return null;
                        }
                        返回 超级 .determineProxy（目标，请求，上下文）;
                    }

                }）。建立（）;
        restTemplate.setRequestFactory（
                新的 HttpComponentsClientHttpRequestFactory（httpClient））;
    }

}

最后，最极端的（也是很少使用的）选项是创建你自己的 RestTemplateBuilderbean。这将关闭a的自动配置， RestTemplateBuilder并会阻止任何RestTemplateCustomizerbean被使用。

34.验证

只要JSR-303实现（例如Hibernate验证器）位于类路径上，Bean Validation 1.1支持的方法验证功能就会自动启用。这允许bean方法用javax.validation参数和/或返回值的约束进行注释。具有这种带注释的方法的目标类需要使用@Validated类型级别的注解来标注其内联约束注释的搜索方法。

例如，下面的服务触发第一个参数的验证，确保它的大小在8到10之间

@Service 
@Validated
公共 类 MyBean {

    public Archive findByCodeAndAuthor（@Size（min = 8，max = 10） String code，
            作者作者）{
        ...
    }

}

35.发送电子邮件

Spring框架为使用JavaMailSender界面发送电子邮件提供了一个简单的抽象，Spring Boot为它提供了自动配置以及一个入门模块。


	检查参考文档以获得如何使用的详细说明`JavaMailSender`。

如果spring.mail.host和相关的库（如定义的 spring-boot-starter-mail）可用，JavaMailSender则如果不存在，则创建默认值。发件人可以通过spring.mail 命名空间中的配置项进一步自定义，请参阅 MailProperties更多详细信息。

特别是，某些默认的超时值是无限的，您可能想要更改该值以避免线程阻塞无响应的邮件服务器：

spring.mail.properties.mail.smtp.connecttimeout = 5000
 spring.mail.properties.mail.smtp.timeout = 3000
 spring.mail.properties.mail.smtp.writetimeout = 5000

36.与JTA分布式事务

Spring Boot使用Atomikos或Bitronix 嵌入式事务管理器支持跨多个XA资源的分布式JTA事务。在部署到合适的Java EE应用服务器时，也支持JTA事务。

当检测到JTA环境时，Spring JtaTransactionManager将用于管理事务。自动配置的JMS，DataSource和JPA bean将被升级以支持XA事务。您可以使用标准的Spring成语@Transactional来参与分布式事务。如果您处于JTA环境中并且仍想使用本地事务，则可以将该spring.jta.enabled属性设置false为禁用JTA自动配置。

36.1使用Atomikos事务管理器

Atomikos是一个流行的开源事务管理器，可以嵌入到Spring Boot应用程序中。您可以使用spring-boot-starter-jta-atomikosStarter来拉入相应的Atomikos库。Spring Boot将自动配置Atomikos，并确保适当的depends-on设置适用于您的Spring bean，以便正确启动和关闭顺序。

默认情况下，Atomikos事务日志将写入transaction-logs应用程序主目录（应用程序jar文件所在的目录）中的一个目录。您可以通过spring.jta.log-dir在application.properties文件中设置属性来自定义此目录。启动属性spring.jta.atomikos.properties 也可以用来定制Atomikos UserTransactionServiceImp。有关完整的详细信息，请参阅 AtomikosPropertiesJavadoc。


	为确保多个事务管理器可以安全地协调相同的资源管理器，必须为每个Atomikos实例配置一个唯一的ID。默认情况下，这个ID是运行Atomikos的机器的IP地址。为确保生产中的唯一性，您应该`spring.jta.transaction-manager-id` 为每个应用程序实例配置一个不同的值。

36.2使用Bitronix事务管理器

Bitronix是流行的开源JTA事务管理器实现。您可以使用spring-boot-starter-jta-bitronix启动器将相应的Bitronix依赖项添加到您的项目中。和Atomikos一样，Spring Boot会自动配置Bitronix，并对bean进行后处理，以确保启动和关闭顺序是正确的。

默认情况下，Bitronix事务日志文件（part1.btm和part2.btm）将被写入transaction-logs您的应用程序主目录中的一个目录。您可以使用该spring.jta.log-dir属性自定义此目录。开始属性 spring.jta.bitronix.properties也绑定到bitronix.tm.Configurationbean，允许完全定制。有关详细信息，请参阅 Bitronix文档。


	为了确保多个事务管理器可以安全地协调相同的资源管理器，每个Bitronix实例必须配置一个唯一的ID。默认情况下，这个ID是Bitronix运行的机器的IP地址。为确保生产中的唯一性，您应该`spring.jta.transaction-manager-id` 为每个应用程序实例配置一个不同的值。

36.3使用Narayana事务管理器

Narayana是JBoss支持的流行的开源JTA事务管理器实现。您可以使用spring-boot-starter-jta-narayana启动器将相应的Narayana依赖项添加到您的项目中。与Atomikos和Bitronix一样，Spring Boot会自动配置Narayana并后处理您的bean，以确保启动和关闭顺序是正确的。

默认情况下，Narayana事务日志将写入transaction-logs应用程序主目录（应用程序jar文件所在的目录）中的一个目录。您可以通过spring.jta.log-dir在application.properties文件中设置属性来自定义此目录。启动属性spring.jta.narayana.properties 也可以用来自定义Narayana配置。有关完整的详细信息，请参阅 NarayanaPropertiesJavadoc。


	为确保多个事务管理器可以安全地协调相同的资源管理器，必须为每个Narayana实例配置一个唯一的ID。默认情况下，这个ID被设置为`1`。为确保生产中的唯一性，您应该`spring.jta.transaction-manager-id`为每个应用程序实例配置一个不同的值。

36.4使用Java EE管理的事务管理器

如果您正在打包春季启动应用程序作为war或ear文件，并将其部署到Java EE应用服务器，您可以使用内置的事务管理器应用程序服务器。春天开机时会试图通过寻找共同的JNDI位置（自动配置一个事务管理器java:comp/UserTransaction， java:comp/TransactionManager等等）。如果您正在使用应用程序服务器提供的事务服务，则通常还需要确保所有资源都由服务器管理并通过JNDI公开。Spring Boot将尝试通过ConnectionFactory在JNDI路径中查找来自动配置JMS，java:/JmsXA或者java:/XAConnectionFactory您可以使用该 spring.datasource.jndi-name属性来配置您的DataSource。

36.5混合XA和非XA JMS连接

使用JTA时，主要的JMS ConnectionFactorybean将被XA感知并参与分布式事务。在某些情况下，您可能需要使用非XA来处理某些JMS消息ConnectionFactory。例如，您的JMS处理逻辑可能需要比XA超时更长的时间。

如果你想使用非XA，ConnectionFactory你可以注入 nonXaJmsConnectionFactorybean而不是@Primary jmsConnectionFactorybean。为了保持一致性，jmsConnectionFactory还使用bean别名提供了bean xaJmsConnectionFactory。

例如：

//注入主（XA知道）ConnectionFactory 
@Autowired
私有 ConnectionFactory defaultConnectionFactory;

//注入XA感知的ConnectionFactory（使用别名并注入相同）
@Autowired 
@Qualifier（“xaJmsConnectionFactory”）
 private ConnectionFactory xaConnectionFactory;

//注入非XA感知的ConnectionFactory 
@Autowired 
@Qualifier（“nonXaJmsConnectionFactory”）
 private ConnectionFactory nonXaConnectionFactory;

36.6支持另一种嵌入式事务管理器

该XAConnectionFactoryWrapper 和XADataSourceWrapper接口可用于支持替代嵌入式事务经理。该接口是负责包装XAConnectionFactory和XADataSource豆类，把它们作为普通ConnectionFactory和DataSource豆类将在分布式事务透明报名。只要你有一个JtaTransactionManagerbean和适当的XA包装bean注册在你的数据库中，DataSource和JMS自动配置将使用JTA变体ApplicationContext。

该BitronixXAConnectionFactoryWrapper 和BitronixXADataSourceWrapper 提供了如何编写XA包装很好的例子。

37. Hazelcast

如果类路径中有hazelcast，Spring Boot会自动配置一个HazelcastInstance 你可以注入到你的应用程序中。HazelcastInstance只有在找到配置的情况下才会创建。

你可以定义一个com.hazelcast.config.Configbean，我们将使用它。如果您的配置定义了一个实例名称，我们将尝试找到一个现有的实例，而不是创建一个新的实例。

您也可以hazelcast.xml通过配置指定配置文件来使用：

spring.hazelcast.config = classpath：config / my-hazelcast.xml

否则，Spring Boot将尝试从默认位置（即hazelcast.xml工作目录或类路径的根目录）中查找Hazelcast配置。我们还检查hazelcast.config系统属性是否设置。检查Hazelcast文档了解更多详情。


	Spring Boot也对Hazelcast有明确的缓存支持。该 `HazelcastInstance`自动包裹在一个`CacheManager`如果启用缓存实现。

38.春天一体化

Spring Boot为Spring Integration提供了一些便利，包括spring-boot-starter-integration“Starter”。Spring Integration提供了对消息传递和其他传输（如HTTP，TCP等）的抽象。如果Spring集成在你的类路径中可用，它将通过@EnableIntegration注释初始化。如果消息处理统计信息'spring-integration-jmx'也在类路径上，则会通过JMX发布。查看 IntegrationAutoConfiguration 班级了解更多详情。

39.春季会议

Spring Boot为广泛的商店提供了Spring Session自动配置：

JDBC
MongoDB的
Redis的
Hazelcast
HashMap中

如果Spring Session可用，则必须选择 StoreType您希望用来存储会话的那个。例如，要将JDBC用作后端存储，您可以按如下方式配置您的应用程序：

spring.session.store-type = jdbc


	您可以通过设置禁用春季会议`store-type`到`none`。

每个商店都有特定的附加设置。例如，可以为jdbc存储自定义表的名称：

spring.session.jdbc.table-name = SESSIONS

40.监控和管理JMX

Java管理扩展（JMX）提供了一个标准机制来监视和管理应用程序。默认情况下，春季启动将创建一个MBeanServer豆ID“的MBeanServer”，揭露你的任何豆被标注有春天JMX注释（@ManagedResource，@ManagedAttribute，@ManagedOperation）。

查看 JmxAutoConfiguration 班级了解更多详情。

41.测试

Spring Boot提供了许多实用程序和注释来帮助您测试应用程序。测试支持由两个模块提供; spring-boot-test包含核心项目，并spring-boot-test-autoconfigure支持自动配置测试。

大多数开发人员只需使用spring-boot-starter-test“Starter”，它可以导入两个Spring Boot测试模块以及JUnit，AssertJ，Hamcrest和其他一些有用的库。

41.1测试范围依赖关系

如果您使用 spring-boot-starter-test“入门”（在test scope）中，您将找到以下提供的库：

JUnit - 单元测试Java应用程序的事实标准。
Spring测试和Spring Boot测试 - Spring Boot应用程序的实用程序和集成测试支持。
AssertJ - 一个流畅的断言库。
Hamcrest - 匹配器对象库（也称为约束或谓词）。
Mockito - 一个Java嘲笑框架。
JSONassert - JSON的断言库。
JsonPath - 用于JSON的XPath。


	默认情况下，Spring Boot使用Mockito 1.x. 但是，如果你愿意，也可以使用2.x。

这些是我们通常在编写测试时觉得有用的常用库。如果这些不符合您的需求，您可以自由添加您自己的附加测试依赖项。

41.2测试Spring应用程序

依赖注入的一个主要优点是它应该使你的代码更容易进行单元测试。你new甚至可以使用操作符实例化对象，甚至不涉及Spring。您也可以使用模拟对象而不是真正的依赖关系。

通常你需要超越“单元测试”，开始“集成测试”（ApplicationContext实际上涉及到Spring的一个Spring ）。能够在不需要部署应用程序或不需要连接到其他基础架构的情况下执行集成测试就很有用。

Spring Framework包含一个专门用于这种集成测试的测试模块。你可以直接声明一个依赖org.springframework:spring-test或者使用spring-boot-starter-test'Starter'来传递它。

如果您spring-test在阅读Spring框架参考文档的相关部分之前已经没有使用该模块。

41.3测试Spring Boot应用程序

一个Spring Boot应用程序只是一个Spring ApplicationContext，所以没有什么特别的事情要做，以超越你通常使用vanilla Spring上下文来测试它。但要注意的一点是，Spring Boot的外部属性，日志记录和其他功能仅在默认环境下安装，如果您使用 SpringApplication它来创建它。

当您需要Spring Boot功能时，Spring Boot提供了一个@SpringBootTest注释，可以用来替代标准spring-test @ContextConfiguration注释。注释的工作原理是通过ApplicationContext在测试中创建使用SpringApplication。

您可以使用该webEnvironment属性@SpringBootTest来进一步优化测试的运行方式：

MOCK - 加载WebApplicationContext并提供一个模拟servlet环境。嵌入式servlet容器在使用此注释时不会启动。如果servlet API不在你的类路径上，这个模式将透明地回退到创建一个普通的非web页面ApplicationContext。可以结合使用， @AutoConfigureMockMvc为MockMvc您的应用程序的基于测试。
RANDOM_PORT - 加载EmbeddedWebApplicationContext并提供一个真正的servlet环境。嵌入式servlet容器启动并在随机端口上侦听。
DEFINED_PORT - 加载EmbeddedWebApplicationContext并提供一个真正的servlet环境。嵌入式servlet容器启动并监听定义的端口（即从您的application.properties或默认端口8080）。
NONE - 加载ApplicationContext使用SpringApplication但不提供任何 servlet环境（模拟或其他）。


	除了`@SpringBootTest`一些其他的注释，还提供了测试应用程序的更具体的切片。详情请参阅下文。


	不要忘记添加`@RunWith(SpringRunner.class)`到您的测试，否则注释将被忽略。

41.3.1检测测试配置

如果您熟悉Spring Test Framework，那么您可能习惯于使用 @ContextConfiguration(classes=…)它来指定@Configuration 要加载哪个Spring 。或者，您可能经常@Configuration在测试中使用嵌套类。

在测试Spring Boot应用程序时，这通常不是必需的。Spring Boot的@*Test注释会自动搜索你的主要配置，只要你没有明确的定义。

搜索算法从包含测试的包直到找到 @SpringBootApplication或@SpringBootConfiguration注释类。只要你以合理的方式构建你的代码，你的主要配置通常是可以找到的。

如果你想定制主配置，你可以使用嵌套 @TestConfiguration类。与@Configuration将使用嵌套类而不是应用程序的主配置不同，@TestConfiguration除了应用程序的主配置之外，还将使用嵌套类。


	Spring的测试框架将缓存测试之间的应用程序上下文。因此，只要您的测试共享相同的配置（不管它如何被发现），加载上下文的潜在的耗时过程将只发生一次。

41.3.2不包括测试配置

如果您的应用程序使用组件扫描，例如，如果您使用 @SpringBootApplication或@ComponentScan，您可能会发现只为特定测试创建的组件或配置意外地被拾取到处。

为了防止这种情况发生，Spring Boot提供了可以在类中使用的注释@TestComponent和@TestConfiguration注释，src/test/java指出不应该通过扫描来拾取它们。


	`@TestComponent`而`@TestConfiguration`只需要在顶层类。如果你在测试中定义`@Configuration`或`@Component`作为内部类（任何具有`@Test`方法的类`@RunWith`），它们将被自动过滤。


	如果你直接使用`@ComponentScan`（即不通过`@SpringBootApplication`），你将需要注册`TypeExcludeFilter`与它。有关详细信息，请参阅 Javadoc。

41.3.3使用随机端口

如果您需要启动完整的运行服务器进行测试，我们建议您使用随机端口。如果你使用@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT) 一个可用的端口，将会在你的测试运行时随机选取。

该@LocalServerPort注释可用于注射使用的实际端口到您的测试。为了方便起见，需要对REST调用启动的服务器可以额外测试 @Autowire一个TestRestTemplate将解析到正在运行的服务器相对链接。

import org.junit.Test;
import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.test.context.junit4.SpringRunner;

导入 静态 org.assertj.core.api.Assertions.assertThat;

@RunWith（SpringRunner.class）
@SpringBootTest（webEnvironment = WebEnvironment.RANDOM_PORT）
 public  class RandomPortExampleTests {

	@Autowired
	私人 TestRestTemplate restTemplate;

	@Test
	 public  void exampleTest（）{
		串体= 此 .restTemplate.getForObject（“/” ，串。类）;
		assertThat（body）.isEqualTo（“Hello World”）;
	}

}

41.3.4嘲笑和窥探豆子

运行测试时有时需要在应用程序上下文中模拟某些组件。例如，您可能对开发期间不可用的某个远程服务有一个正面。当你想模拟在真实环境中很难触发的故障时，模拟也是有用的。

Spring Boot包含一个@MockBean注释，可以用来为你的bean中的bean定义一个Mockito模拟ApplicationContext。您可以使用注释来添加新的bean，或者替换一个现有的bean定义。注释可以直接用于测试类，测试中的字段或者@Configuration类和字段。当在字段上使用时，创建的模拟实例也将被注入。模拟豆类在每种测试方法后自动重置。

下面是一个典型的例子，我们RemoteService用一个模拟实现替换一个现有的bean：

import org.junit。*;
import org.junit.runner。*;
import org.springframework.beans.factory.annotation。*;
import org.springframework.boot.test.context。*;
import org.springframework.boot.test.mock.mockito。*;
import org.springframework.test.context.junit4。*;

导入 静态 org.assertj.core.api.Assertions。*;
import  static org.mockito.BDDMockito。*;

@RunWith（SpringRunner.class）
@SpringBootTest
 public  class MyTests {

    @MockBean
    私有 RemoteService remoteService ;

    @Autowired
    私人反向器反向器;

    @Test
    公共 空隙 exampleTest（）{
         // RemoteService已注入的反向豆 
        给定的（这 .remoteService.someCall（））willReturn（ “ 模拟”）;
        String reverse = reverser.reverseSomeCall（）;
        assertThat（reverse）.isEqualTo（“kcom”）;
    }

}

另外你也可以使用@SpyBeanMockito来包装任何现有的bean spy。请参阅Javadoc了解详细信息。

41.3.5自动配置的测试

Spring Boot的自动配置系统适用于应用程序，但有时可能对测试有点太多。只加载测试应用程序的“切片”所需的配置部分通常很有帮助。例如，您可能想要测试Spring MVC控制器是否正确映射了URL，并且您不希望在这些测试中涉及数据库调用; 或者您可能想要测试JPA实体，并且在这些测试运行时您对web层不感兴趣。

该spring-boot-test-autoconfigure模块包括一些可以用来自动配置这些“切片”的注释。它们中的每一个都以类似的方式工作，提供@…Test加载注释ApplicationContext和一个或多个@AutoConfigure…可用于自定义自动配置设置的注释。


	每个切片加载一组非常有限的自动配置类。如果您需要排除其中的一个，则大多数`@…Test`注释都会提供一个`excludeAutoConfiguration` 属性。或者，您可以使用`@ImportAutoConfiguration#exclude`。


	也可以使用`@AutoConfigure…`带有标准 `@SpringBootTest`注释的注释。如果您对“切片”应用程序不感兴趣，但想要一些自动配置的测试bean，则可以使用此组合。

41.3.6自动配置的JSON测试

要测试对象JSON序列化和反序列化是否按预期工作，可以使用@JsonTest注释。@JsonTest将自动配置杰克逊ObjectMapper，任何@JsonComponent豆子和任何杰克逊Modules。它也配置Gson 你是否正在使用，而不是，或杰克逊。如果您需要配置自动配置的元素，则可以使用@AutoConfigureJsonTesters 注释。

Spring Boot包含基于AssertJ的帮助程序，它们与JSONassert和JsonPath库一起工作来检查JSON是否如预期的那样。的JacksonTester，GsonTester和BasicJsonTester类可用于分别杰克逊，GSON和字符串。测试类中的任何助手字段可以@Autowired在使用时使用@JsonTest。

import org.junit。*;
import org.junit.runner。*;
import org.springframework.beans.factory.annotation。*;
import org.springframework.boot.test.autoconfigure.json。*;
import org.springframework.boot.test.context。*;
import org.springframework.boot.test.json。*;
import org.springframework.test.context.junit4。*;

导入 静态 org.assertj.core.api.Assertions。*;

@RunWith（SpringRunner.class）
@JsonTest
公共 类 MyJsonTests {

    @Autowired
    私人 JacksonTester <VehicleDetails> json;

    @Test
    公共 无效 testSerialize（）抛出异常{
        VehicleDetails details = new VehicleDetails（“Honda”，“Civic”）;
        //断言与测试 
        assertThat（this .json.write（details））。isEqualToJson（“expected.json”）相同的包中的`.json`文件 ;
        //或使用基于JSON路径的断言 
        assertThat（this .json.write（details））。hasJsonPathStringValue（“@ .make”）;
        assertThat（此 .json.write（详细信息））。extractingJsonPathStringValue（“@。使”）
                .isEqualTo（“Honda”）;
    }

    @Test
    公共 无效 testDeserialize（）抛出异常{
        String content = “{\”make \“：\”Ford \“，\”model \“：\”Focus \“}” ;
        assertThat（this .json.parse（content））
                .isEqualTo（new VehicleDetails（“Ford”，“Focus”））;
        assertThat（此 .json.parseObject（内容）.getMake（））isEqualTo（ “ 福特”）;
    }

}


	JSON帮助程序类也可以直接在标准的单元测试中使用。如果您不使用，只需`initFields`在您的`@Before`方法中调用助手的方法即可 `@JsonTest`。

@JsonTest可以在附录中找到启用的自动配置列表。

41.3.7自动配置的Spring MVC测试

为了测试Spring MVC控制器正在按预期工作，您可以使用@WebMvcTest 注释。@WebMvcTest将自动配置Spring MVC的基础设施和限制扫描豆@Controller，@ControllerAdvice，@JsonComponent，Filter， WebMvcConfigurer和HandlerMethodArgumentResolver。@Component使用此注释时，常规bean将不会被扫描。

通常@WebMvcTest将被限制在一个单一的控制器，并结合使用 @MockBean，为所需的合作者提供模拟实现。

@WebMvcTest也可以自动配置MockMvc。模拟MVC提供了一种快速测试MVC控制器的强大方法，无需启动完整的HTTP服务器。


	您也可以`MockMvc`在非`@WebMvcTest`（例如`SpringBootTest`）中通过注释来进行自动配置`@AutoConfigureMockMvc`。

import org.junit。*;
import org.junit.runner。*;
import org.springframework.beans.factory.annotation。*;
import org.springframework.boot.test.autoconfigure.web.servlet。*;
import org.springframework.boot.test.mock.mockito。*;

导入 静态 org.assertj.core.api.Assertions。*;
import  static org.mockito.BDDMockito。*;
import  static org.springframework.test.web.servlet.request.MockMvcRequestBuilders。*;
导入 静态 org.springframework.test.web.servlet.result.MockMvcResultMatchers。*;

@RunWith（SpringRunner.class）
@WebMvcTest（UserVehicleController.class）
 public  class MyControllerTests {

    @Autowired
    私人 MockMvc mvc;

    @MockBean
    私人 UserVehicleService userVehicleService;

    @Test
     public  void testExample（） throws Exception {
        给（这个 .userVehicleService.getVehicleDetails（“sboot”））
                .willReturn（new VehicleDetails（“Honda”，“Civic”））;
        这个 .mvc.perform（get（“/ sboot / vehicle”）.accept（MediaType.TEXT_PLAIN））
                .andExpect（status（）。isOk（））andExpect（content（）。string（“Honda Civic”））;
    }

}


	如果您需要配置自动配置的元素（例如，应用servlet过滤器），则可以在`@AutoConfigureMockMvc` 注释中使用属性。

如果使用HtmlUnit或Selenium，则自动配置也将提供一个WebClientbean和/或一个WebDriverbean。这里是一个使用HtmlUnit的例子：

import com.gargoylesoftware.htmlunit。*;
import org.junit。*;
import org.junit.runner。*;
import org.springframework.beans.factory.annotation。*;
import org.springframework.boot.test.autoconfigure.web.servlet。*;
import org.springframework.boot.test.mock.mockito。*;

导入 静态 org.assertj.core.api.Assertions。*;
import  static org.mockito.BDDMockito。*;

@RunWith（SpringRunner.class）
@WebMvcTest（UserVehicleController.class）
 public  class MyHtmlUnitTests {

    @Autowired
    私人 WebClient webClient;

    @MockBean
    私人 UserVehicleService userVehicleService;

    @Test
     public  void testExample（） throws Exception {
        给（这个 .userVehicleService.getVehicleDetails（“sboot”））
                .willReturn（new VehicleDetails（“Honda”，“Civic”））;
        HtmlPage page = this .webClient.getPage（“/sboot/vehicle.html”）;
        assertThat（page.getBody（）。getTextContent（））。isEqualTo（“Honda Civic”）;
    }

}


	默认情况下，Spring Boot会把`WebDriver`bean放在一个特殊的“范围”中，以确保每次测试后驱动程序都退出，并注入新的实例。如果你不想要这种行为，你可以添加`@Scope("singleton")`到你的`WebDriver` `@Bean` 定义。

@WebMvcTest可以在附录中找到启用的自动配置列表。

41.3.8自动配置的数据JPA测试

@DataJpaTest可以用来测试JPA应用程序。默认情况下，它将配置内存中的嵌入式数据库，扫描@Entity类并配置Spring Data JPA存储库。常规的@Componentbean将不会被加载到 ApplicationContext。

数据JPA测试是默认情况下每个测试结束时的事务性和回滚性，有关更多详细信息，请参阅Spring参考资料中的相关章节。如果这不是你想要的，你可以按照以下步骤禁用一个测试或整个类的事务管理：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.test.context.junit4.SpringRunner;
导入 org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@RunWith（SpringRunner.class）
@DataJpaTest 
@Transactional（propagation = Propagation.NOT_SUPPORTED）
 public  class ExampleNonTransactionalTests {

}

数据JPA测试也可能注入一个 TestEntityManager bean，它提供了EntityManager专门为测试而设计的标准JPA的替代方案。如果你想TestEntityManager在@DataJpaTests你之外使用，也可以使用@AutoConfigureTestEntityManager注释。JdbcTemplate如果您需要，也可以使用A。

import org.junit。*;
import org.junit.runner。*;
import org.springframework.boot.test.autoconfigure.orm.jpa。*;

导入 静态 org.assertj.core.api.Assertions。*;

@RunWith（SpringRunner.class）
@DataJpaTest
 public  class ExampleRepositoryTests {

    @Autowired
    私人 TestEntityManager entityManager;

    @Autowired
    私人 UserRepository存储库;

    @Test
     public  void testExample（） throws Exception {
         this .entityManager.persist（ new User（ “sboot”， “1234”））;
        User user = this .repository.findByUsername（“sboot”）;
        assertThat（user.getUsername（））。isEqualTo（“sboot”）;
        assertThat（user.getVin（））。isEqualTo（“1234”）;
    }

}

内存中的嵌入式数据库通常可以很好地用于测试，因为它们速度快，不需要任何开发者安装。但是，如果您喜欢对真实数据库运行测试，则可以使用@AutoConfigureTestDatabase注释：

@RunWith（SpringRunner.class）
@DataJpaTest 
@AutoConfigureTestDatabase（replace = Replace.NONE）
 public  class ExampleRepositoryTests {

    // ...

}

@DataJpaTest可以在附录中找到启用的自动配置列表。

41.3.9自动配置的JDBC测试

@JdbcTest类似于@DataJpaTest纯jdbc相关的测试。默认情况下，它也将配置一个内存嵌入式数据库和一个JdbcTemplate。常规的 @Componentbean将不会被加载到ApplicationContext。

JDBC测试在每个测试结束时都是事务性的和回滚的，默认情况下，请参阅Spring Reference Documentation中的相关部分以获取更多细节。如果这不是你想要的，你可以按照以下步骤禁用一个测试或整个类的事务管理：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.autoconfigure.jdbc.JdbcTest;
import org.springframework.test.context.junit4.SpringRunner;
导入 org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@RunWith（SpringRunner.class）
@JdbcTest 
@Transactional（propagation = Propagation.NOT_SUPPORTED）
 public  class ExampleNonTransactionalTests {

}

如果你喜欢你的测试对一个真实的数据库运行，你可以使用与 @AutoConfigureTestDatabase注释相同的方式DataJpaTest。

@JdbcTest可以在附录中找到启用的自动配置列表。

41.3.10自动配置的数据MongoDB测试

@DataMongoTest可以用来测试MongoDB应用程序。默认情况下，它将配置内存中嵌入的MongoDB（如果可用），配置a MongoTemplate，扫描@Document类并配置Spring Data MongoDB存储库。常规 @Componentbean将不会被加载到ApplicationContext：

import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.mongo.DataMongoTest;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith（SpringRunner.class）
@DataMongoTest
 public  class ExampleDataMongoTests {

    @Autowired
    私人 MongoTemplate mongoTemplate;

    // 
}

内存中的嵌入式MongoDB通常适用于测试，因为它速度快，不需要任何开发人员的安装。但是，如果您希望针对真正的MongoDB服务器运行测试，则应该排除嵌入式MongoDB自动配置：

import org.junit.runner.RunWith;
import org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration;
import org.springframework.boot.test.autoconfigure.data.mongo.DataMongoTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith（SpringRunner.class）
@DataMongoTest（excludeAutoConfiguration = EmbeddedMongoAutoConfiguration.class）
 public  class ExampleDataMongoNonEmbeddedTests {

}

@DataMongoTest可以在附录中找到启用的自动配置列表。

41.3.11自动配置的REST客户端

的@RestClientTest，如果你想测试REST客户注释可以使用。默认情况下，它会自动配置Jackson和GSON支持，配置RestTemplateBuilder和添加支持MockRestServiceServer。您要测试的特定bean应该使用value或者指定components属性@RestClientTest：

@RunWith（SpringRunner.class）
@RestClientTest（RemoteVehicleDetailsService.class）
 public  class ExampleRestClientTest {

    @Autowired
    私人 RemoteVehicleDetailsService服务;

    @Autowired
    私有 MockRestServiceServer服务器;

    @Test
    公共 空隙 getVehicleDetailsWhenResultIsSuccessShouldReturnDetails（）
            抛出异常{
        此 .server.expect（requestTo（ “/迎接/方式”））
                .andRespond（withSuccess（“hello”，MediaType.TEXT_PLAIN））;
        String greeting = this .service.callRestService（）;
        assertThat（greeting）.isEqualTo（“hello”）;
    }

}

@RestClientTest可以在附录中找到启用的自动配置列表。

41.3.12自动配置的Spring REST Docs测试

的@AutoConfigureRestDocs，如果你想使用Spring REST文档在测试中的注释都可以使用。它会自动配置MockMvc使用Spring REST Docs，并删除对Spring REST Docs的JUnit规则的需求。

import org.junit.Test;
import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;
导入 org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;

import  static org.springframework.restdocs.mockmvc.MockMvcRestDocumentation.document;
导入 静态 org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
导入 静态 org.springframework.test.web.servlet.result.MockMvcResultMatchers。*;

@RunWith（SpringRunner.class）
@WebMvcTest（UserController.class）
@AutoConfigureRestDocs（“target / generated-snippets”）
 public  class UserDocumentationTests {

    @Autowired
    私人 MockMvc mvc;

    @测试
    公共 无效 listUsers（）抛出异常{
        这个 .mvc.perform（获取（ “/用户”）。接受（MediaType.TEXT_PLAIN））
                .andExpect（状态（）。ISOK（））
                .andDo（document（“list-users”））;
    }

}

除了配置输出目录之外，@AutoConfigureRestDocs还可以配置将出现在任何记录的URI中的主机，方案和端口。如果您需要更多地控制Spring REST Docs的配置，RestDocsMockMvcConfigurationCustomizer可以使用一个 bean：

@TestConfiguration
静态 类 CustomizationConfiguration
        实现了 RestDocsMockMvcConfigurationCustomizer {

    @Override
     public  void customize（MockMvcRestDocumentationConfigurer configurer）{
        。configurer.snippets（）withTemplateFormat（TemplateFormats.markdown（））;
    }

}

如果你想使用Spring REST Docs对参数化输出目录的支持，你可以创建一个RestDocumentationResultHandlerbean。自动配置将alwaysDo使用此结果处理程序调用，从而导致每个MockMvc调用自动生成默认片段：

@TestConfiguration
静态 类 ResultHandlerConfiguration {

    @Bean
     public RestDocumentationResultHandler restDocumentation（）{
         return MockMvcRestDocumentation.document（ “{method-name}”）;
    }

}

41.3.13使用Spock测试Spring Boot应用程序

如果你想使用Spock来测试一个Spring Boot应用程序，你应该在Spock的spock-spring模块上添加一个依赖到你的应用程序的版本。spock-spring将Spring的测试框架集成到Spock中。具体如何使用Spock来测试Spring Boot应用程序取决于您正在使用的Spock版本。


	Spring Boot为Spock 1.0提供依赖管理。如果你想使用Spock 1.1，你应该覆盖`spock.version`你的`build.gradle`或`pom.xml`文件中的属性。

当使用斯波克1.1，注释上述只能用，你可以注解你Specification用 @SpringBootTest，以满足您的测试需求。

使用Spock 1.0时，@SpringBootTest不适用于Web项目。你需要使用 @SpringApplicationConfiguration和@WebIntegrationTest(randomPort = true)。无法使用@SpringBootTest意味着你也失去了自动配置的 TestRestTemplatebean。您可以使用以下配置自行创建等价的bean：

@Configuration
静态 类 TestRestTemplateConfiguration {

    @Bean
     public TestRestTemplate testRestTemplate（
            ObjectProvider <RestTemplateBuilder> builderProvider，
            环境环境）{
        RestTemplateBuilder builder = builderProvider.getIfAvailable（）;
        TestRestTemplate模板=生成器== null？新的 TestRestTemplate（）
                ：new TestRestTemplate（builder.build（））;
        template.setUriTemplateHandler（新的 LocalHostUriTemplateHandler（环境））;
        返回模板;
    }

}

41.4测试实用程序

在测试应用程序时，将一些测试实用程序类打包为spring-boot通用的一部分。

41.4.1 ConfigFileApplicationContextInitializer

ConfigFileApplicationContextInitializer是一个ApplicationContextInitializer可以用来加载Spring Boot application.properties文件的测试。当你不需要所提供的全部功能时，你可以使用它@SpringBootTest。

@ContextConfiguration（classes =配置类，
    初始化器= ConfigFileApplicationContextInitializer。类）


	`ConfigFileApplicationContextInitializer`单独使用不会为`@Value("${…}")`注射提供支持。它唯一的工作是确保`application.properties`文件被加载到Spring中`Environment`。对于`@Value`支持，您需要另外配置一个`PropertySourcesPlaceholderConfigurer`或使用`@SpringBootTest` 自动为您配置的地方。

41.4.2 EnvironmentTestUtils

EnvironmentTestUtils允许您快速添加属性到 ConfigurableEnvironment或ConfigurableApplicationContext。只需用key=value字符串调用它：

EnvironmentTestUtils.addEnvironment（env，“org = Spring”，“name = Boot”）;

41.4.3 OutputCapture

OutputCapture是一个Rule可以用来捕获System.out和 System.err输出的JUnit 。简单地声明捕获作为一个@Rule然后toString() 用于断言：

import org.junit.Rule;
import org.junit.Test;
import org.springframework.boot.test.rule.OutputCapture;

import  static org.hamcrest.Matchers。*;
import  static org.junit.Assert。*;

公共 类 MyTest {

	@Rule
	 public OutputCapture capture = new OutputCapture（）;

	@Test
	公共 无效 testName（）抛出异常{
		System.out.println（“Hello World！”）;
		assertThat（capture.toString（），containsString（“World”））;
	}

}

41.4.4 TestRestTemplate

TestRestTemplate是Spring的一个方便的选择，RestTemplate在集成测试中很有用。您可以获得一个香草模板或一个发送基本HTTP认证（使用用户名和密码）的模板。在任何一种情况下，模板都将以一种友好的方式运行：不遵循重定向（所以你可以断言响应位置），忽略cookie（所以模板是无状态的），并且不会在服务器端错误上抛出异常。建议使用Apache HTTP Client（版本4.3.2或更高版本），但不是强制性的，如果你的类路径上有这个，HTTP TestRestTemplate 会通过适当地配置客户端来响应。

公共 类 MyTest {

	私人 TestRestTemplate模板= 新的 TestRestTemplate（）;

	@Test
	公共 无效 testRequest（）抛出异常{
		HttpHeaders头= template.getForEntity（“http://myhost.com” ，字符串。类）.getHeaders（）;
		assertThat（headers.getLocation（）。toString（），containsString（“myotherhost”））;
	}

}

如果您使用or @SpringBootTest注释，您可以注入完全配置并开始使用它。如有必要，可以通过bean 应用额外的自定义设置：WebEnvironment.RANDOM_PORTWebEnvironment.DEFINED_PORTTestRestTemplateRestTemplateBuilder

@RunWith（SpringRunner.class）
@SpringBootTest
 public  class MyTest {

	@Autowired
	私人 TestRestTemplate模板;

	@Test
	公共 无效 testRequest（）抛出异常{
		HttpHeaders头= template.getForEntity（“http://myhost.com” ，字符串。类）.getHeaders（）;
		assertThat（headers.getLocation（）。toString（），containsString（“myotherhost”））;
	}

	@TestConfiguration
	静态 类配置{

		@Bean
		 public RestTemplateBuilder restTemplateBuilder（）{
			 return  new RestTemplateBuilder（）
				.additionalMessageConverters（...）
				.customizers（...）;
		}

	}

}

42. WebSockets

Spring Boot为嵌入式Tomcat（8和7），Jetty 9和Undertow提供WebSockets自动配置。如果您将war文件部署到独立容器，Spring Boot会假定该容器将负责配置其WebSocket支持。

Spring Framework提供了丰富的WebSocket支持，可以通过spring-boot-starter-websocket模块轻松访问。

43.网络服务

Spring Boot提供Web服务自动配置，以便所有需要定义您的Endpoints。

在春天的Web服务功能可以通过方便地访问spring-boot-starter-webservices模块。

44.创建你自己的自动配置

如果您在开发共享库的公司工作，或者如果您在开源或商业库上工作，则可能需要开发自己的自动配置。自动配置类可以捆绑在外部的瓶子里，并且仍然可以被Spring Boot找到。

自动配置可以与提供自动配置代码的“启动器”以及您将使用的典型库相关联。我们将首先介绍您需要知道的构建自己的自动配置，然后我们将继续执行创建自定义启动器所需的典型步骤。


	一个示范项目提供展示如何创建一步首发一步。

44.1了解自动配置的bean

在引擎盖下，自动配置是用标准的@Configuration类来实现的。其他@Conditional注释用于约束何时应用自动配置。通常自动配置类使用@ConditionalOnClass和@ConditionalOnMissingBean注释。这确保了自动配置仅适用于找到相关的类并且没有声明自己的类时@Configuration。

您可以浏览源代码spring-boot-autoconfigure 以查看@Configuration我们提供的类（请参阅 META-INF/spring.factories 文件）。

44.2找到自动配置候选

Spring Boot检查META-INF/spring.factories发布的jar文件中是否存在文件。该文件应该列出您的配置类下的 EnableAutoConfiguration密钥。

org.springframework.boot.autoconfigure.EnableAutoConfiguration = \
com.mycorp.libx.autoconfigure.LibXAutoConfiguration，\
com.mycorp.libx.autoconfigure.LibXWebAutoConfiguration

如果需要按特定顺序应用配置，则可以使用注释@AutoConfigureAfter或 @AutoConfigureBefore注释。例如，如果您提供特定于Web的配置，则可能需要在之后应用您的课程 WebMvcAutoConfiguration。

如果您想要订购某些不应该彼此直接了解的自动配置，您也可以使用@AutoconfigureOrder。该注释与常规注释具有相同的语义，@Order但为自动配置类提供了专用的顺序。


	自动配置，必须加载的方式只。确保它们在特定的包装空间中定义，并且它们绝对不是特别针对组件扫描的目标。

44.3条件注释

您几乎总是希望@Conditional在自动配置类中包含一个或多个注释。这@ConditionalOnMissingBean是一个常见的例子，如果开发人员不满意你的默认值，开发人员可以“覆盖”自动配置。

Spring Boot包含许多@Conditional注释，您可以在自己的代码中重复使用批注@Configuration类或单个@Bean方法。

44.3.1班级条件

的@ConditionalOnClass和@ConditionalOnMissingClass注解允许基于特定类的存在或不存在要被包括配置。由于使用ASM解析注释元数据的事实，您实际上可以使用该value属性来引用真实的类，即使该类可能实际上并不出现在正在运行的应用程序类路径中。name如果您希望使用String值指定类名称，也可以使用该属性。

44.3.2豆条件

的@ConditionalOnBean和@ConditionalOnMissingBean注解允许基于特定豆的存在或不存在要被包括的bean。您可以使用该value 属性来按类型指定bean，或者name按名称指定bean。该search 属性允许您限制ApplicationContext搜索bean时应考虑的层次结构。


	您需要非常小心添加bean定义的顺序，因为这些条件是基于到目前为止已经处理的内容来评估的。出于这个原因，我们建议只在自动配置类上使用`@ConditionalOnBean`和`@ConditionalOnMissingBean`注释（因为在添加了任何用户定义的bean定义之后，这些保证会被加载）。


	`@ConditionalOnBean`并且`@ConditionalOnMissingBean`不要阻止`@Configuration` 创建类。在课堂上使用这些条件等同于`@Bean`用注释标记每个包含的方法。

44.3.3财产状况

该@ConditionalOnProperty注释允许基于Spring的环境属性，包括配置。使用prefix和name属性来指定应该检查的属性。默认情况下，任何存在且不相等的属性false将被匹配。您还可以使用havingValue 和matchIfMissing属性创建更高级的检查。

44.3.4资源条件

该@ConditionalOnResource注释允许被包括配置仅当特定资源是否存在。资源可以使用通常的Spring约定来指定，例如file:/home/user/test.dat。

44.3.5 Web应用程序的条件

的@ConditionalOnWebApplication和@ConditionalOnNotWebApplication注解允许根据应用是否是一个“web应用程序”被包括配置。Web应用程序是使用Spring的任何应用程序 WebApplicationContext，定义一个session范围或具有一个StandardServletEnvironment。

44.3.6 SpEL表达条件

该@ConditionalOnExpression注释允许基于一个的结果被包括配置使用SpEL表达。

44.4创建您自己的启动器

一个完整的Spring Boot启动器可能包含以下组件：

autoconfigure包含自动配置代码的模块。
将starter其提供给自动配置模块的依赖关系，以及库和通常是有用的任何附加的依赖性模块。简而言之，添加启动器应该足以开始使用该库。


	如果您不需要将这两个问题分开，您可以将自动配置代码和依赖管理结合在一个模块中。

44.4.1命名

请确保为您的初学者提供适当的名称空间。spring-boot即使您使用的是不同的Maven groupId，也不要使用模块名称。我们可能会为您将来自动配置的东西提供官方支持。

这是一个经验法则。假设您正在为“acme”创建一个启动器，命名自动配置模块acme-spring-boot-autoconfigure和启动器 acme-spring-boot-starter。如果只有一个模块组合这两个模块，请使用 acme-spring-boot-starter。

此外，如果您的初学者提供配置密钥，请为其使用适当的名称空间。特别是，不包括你在春天开机使用的命名空间（如按键 server，management，spring，等）。这些都是“我们的”，我们可能会在未来改善/修改它们，这样可能会破坏你的东西。

确保触发元数据生成，以便您的密钥也可以使用IDE帮助。您可能需要查看生成的元数据（META-INF/spring-configuration-metadata.json）以确保您的密钥已正确记录。

44.4.2自动配置模块

自动配置模块包含开始使用库所需的一切。它还可能包含配置键定义（@ConfigurationProperties）和任何回调接口，可用于进一步定制组件的初始化方式。


	您应该将库的依赖项标记为可选，以便您可以更轻松地将自动配置模块包含在项目中。如果你这样做，库将不会被提供，Spring Boot默认会退出。

44.4.3入门模块

首先是一个空罐子，真的。它唯一的目的是提供必要的依赖来与图书馆合作。把它看作是对开始所需要的东西的一种自以为是的观点。

不要对添加起动器的项目做出假设。如果您自动配置的库通常需要其他启动器，请提及它们。如果可选依赖项的数量很高，那么提供一组适当的默认依赖关系可能会很困难，因为您应该避免为库的典型用法带来不必要的依赖关系。

45.下一步阅读什么

如果您想了解更多关于本节讨论的任何类的信息，可以查看Spring Boot API文档，也可以直接浏览源代码。如果您有具体问题，请参阅操作指南部分。

如果您对Spring Boot的核心功能感到满意，可以继续阅读有关生产就绪功能。

第五部分Spring Boot Actuator：生产就绪功能

Spring Boot包含许多附加功能，可帮助您在应用程序投入生产时监视和管理应用程序。您可以选择使用HTTP端点，JMX甚至远程shell（SSH或Telnet）来管理和监视您的应用程序。审计，健康和指标收集可以自动应用于您的应用程序。

执行器HTTP端点仅适用于基于Spring MVC的应用程序。特别是，除非启用Spring MVC，否则它将不能与Jersey一起工作。

46.启用生产就绪功能

该spring-boot-actuator模块提供了Spring Boot的所有生产就绪功能。启用这些功能的最简单方法是向spring-boot-starter-actuator“Starter” 添加依赖项。

要将执行器添加到基于Maven的项目中，请添加以下“Starter”依赖项：

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

对于Gradle，使用声明：

依赖{
    编译（“org.springframework.boot：spring-boot-starter-actuator”）
}

47.终点

执行器端点允许您监视和与您的应用程序进行交互。Spring Boot包含许多内置的端点，您也可以添加自己的端点。例如， health端点提供基本的应用程序健康信息。

端点的暴露方式取决于您选择的技术类型。大多数应用程序选择HTTP监视，其中端点的ID映射到一个URL。例如，默认情况下，health端点将被映射到/health。

以下技术不可知端点可用：

ID	描述	敏感的默认
`actuator`	为其他端点提供基于超媒体的“发现页面”。要求Spring HATEOAS在类路径上。	真正
`auditevents`	公开当前应用程序的审计事件信息。	真正
`autoconfig`	显示一个自动配置报告，显示所有自动配置候选人以及他们“被”或“不被”应用的原因。	真正
`beans`	显示应用程序中所有Spring bean的完整列表。	真正
`configprops`	显示所有的整理列表`@ConfigurationProperties`。	真正
`dump`	执行线程转储。	真正
`env`	公开来自Spring的属性`ConfigurableEnvironment`。	真正
`flyway`	显示已应用的所有Flyway数据库迁移。	真正
`health`	显示应用程序运行状况信息（应用程序安全时，通过未经身份验证的连接访问时的简单'状态'或通过身份验证时的完整邮件详细信息）。	假
`info`	显示任意的应用信息。	假
`loggers`	显示和修改应用程序中的记录器配置。	真正
`liquibase`	显示已经应用的任何Liquibase数据库迁移。	真正
`metrics`	显示当前应用程序的“指标”信息。	真正
`mappings`	显示所有`@RequestMapping`路径的整理列表。	真正
`shutdown`	允许应用程序正常关机（默认情况下不启用）。	真正
`trace`	显示跟踪信息（默认最后100个HTTP请求）。	真正

如果您使用Spring MVC，还可以使用以下附加端点：

ID	描述	敏感的默认
`docs`	显示执行器端点的文档，包括示例请求和响应。需要`spring-boot-actuator-docs`在类路径上。	假
`heapdump`	返回一个GZip压缩`hprof`堆转储文件。	真正
`jolokia`	通过HTTP公开JMX bean（当Jolokia在类路径上时）。	真正
`logfile`	返回日志文件的内容（如果`logging.file`或者`logging.path`属性已经设置）。支持使用HTTP `Range`头来检索部分日志文件的内容。	真正


	根据端点的暴露方式，该`sensitive`属性可能被用作安全提示。例如，敏感端点在通过HTTP访问时将需要用户名/密码（或者如果未启用Web安全性，则只需将其禁用）。

47.1自定义端点

端点可以使用Spring属性进行自定义。你可以改变一个端点 enabled是否被考虑sensitive，甚至是它id。

例如，这是一个application.properties改变beans端点的灵敏度和ID 并且启用shutdown。

endpoints.beans.id = springbeans
 endpoints.beans.sensitive = false
 endpoints.shutdown.enabled = true


	前缀“ `endpoints`+ `.`+ `name`”用于唯一标识正在配置的端点。

默认情况下，除了以外的所有端点都shutdown被启用。如果您希望专门“启用”端点启用，则可以使用该endpoints.enabled属性。例如，以下将禁用除以下所有端点info：

endpoints.enabled = false
 endpoints.info.enabled = true

同样，您也可以选择全局设置所有端点的“敏感”标志。默认情况下，敏感标志取决于端点的类型（请参阅上表）。例如，将所有端点标记为敏感，但info以下情况除外：

endpoints.sensitive = true
 endpoints.info.sensitive = false

47.2执行器MVC端点的超媒体

如果endpoints.hypermedia.enabled设置为，true并且 Spring HATEOAS位于类路径中（例如通过spring-boot-starter-hateoas或如果您使用的是 Spring Data REST），那么来自Actuator的HTTP端点将通过超媒体链接进行增强，并且添加一个“发现页面”端点。“发现页面” /actuator默认可用。它被实现为一个端点，允许使用属性来配置它的路径（endpoints.actuator.path）以及它是否被启用（endpoints.actuator.enabled）。

当定制管理上下文路径被配置时，“发现页面”将自动移动/actuator到管理上下文的根目录。例如，如果管理上下文路径是/management发现页面将可用/management。

如果HAL浏览器通过其webjar（org.webjars:hal-browser）在类路径上，或者通过spring-data-rest-hal-browserHAL浏览器形式的HTML“发现页面”来提供。

47.3 CORS支持

跨源资源共享（CORS）是W3C规范，允许您以灵活的方式指定哪种跨域请求被授权。执行器的MVC端点可以配置为支持这种情况。

CORS支持默认是禁用的，只有在endpoints.cors.allowed-origins属性设置后才能启用。下面的配置允许 GET和POST来自example.com域的呼叫：

endpoints.cors.allowed-origins = http：//example.com
 endpoints.cors.allowed-methods = GET，POST


	检查EndpointCorsProperties 以获取完整的选项列表。

47.4添加自定义端点

如果添加了一个@Bean类型Endpoint，它将自动通过JMX和HTTP（如果有可用的服务器）公开。可以通过创建类型的bean来进一步定制HTTP端点MvcEndpoint。你MvcEndpoint不是一个，@Controller但它可以使用@RequestMapping（和@Managed*）来公开资源。

如果你这样做是为库特征考虑增加带注释的配置类@ManagementContextConfiguration到/META-INF/spring.factories下键org.springframework.boot.actuate.autoconfigure.ManagementContextConfiguration。如果你这样做，那么如果你的用户要求一个单独的管理端口或地址，端点将会移动到所有其他MVC端点的子上下文中。以这种方式声明的配置可以是一个WebConfigurerAdapter如果它想要添加静态资源（例如）到管理端点。

47.5健康信息

健康信息可用于检查正在运行的应用程序的状态。如果生产系统停机，它通常被监控软件用来提醒某人。health端点公开的默认信息取决于访问方式。对于安全应用程序中的未经身份验证的连接，将返回一个简单的“状态”消息，对于已验证的连接，还会显示其他详细信息（请参见第48.7节“HTTP健康端点访问限制”了解HTTP详细信息）。

健康信息从您的所有HealthIndicatorbean中收集 ApplicationContext。Spring Boot包含了许多自动配置 HealthIndicators，你也可以自己写。

47.6安全与健康指标

返回的信息HealthIndicators往往在某种程度上是敏感的。例如，您可能不想将数据库服务器的详细信息发布到世界上。出于这个原因，默认情况下，只有健康状态暴露在未经身份验证的HTTP连接上。如果你很高兴为完整的健康信息总是被暴露你可以设置endpoints.health.sensitive到false。

还可以缓存健康响应以防止“拒绝服务”攻击。endpoints.health.time-to-live如果要更改1000毫秒的默认缓存时间段，请使用该属性。

47.6.1自动配置的HealthIndicators

以下HealthIndicators是适当的时候由Spring Boot自动配置的：

名称	描述
`CassandraHealthIndicator`	检查Cassandra数据库是否启动。
`DiskSpaceHealthIndicator`	检查磁盘空间不足。
`DataSourceHealthIndicator`	检查是否可以获得连接`DataSource`。
`ElasticsearchHealthIndicator`	检查Elasticsearch集群是否启动。
`JmsHealthIndicator`	检查JMS代理是否启动。
`MailHealthIndicator`	检查邮件服务器是否启动。
`MongoHealthIndicator`	检查Mongo数据库是否启动。
`RabbitHealthIndicator`	检查一个Rabbit服务器是否启动。
`RedisHealthIndicator`	检查Redis服务器是否启动。
`SolrHealthIndicator`	检查Solr服务器是否启动。


	可以使用该`management.health.defaults.enabled` 属性禁用它们。

47.6.2编写自定义的HealthIndicators

为了提供自定义的健康信息，你可以注册实现这个HealthIndicator接口的Spring bean 。您需要提供该health()方法的实现并返回Health 响应。的Health响应应该包括一个状态，并且可以任选地包括另外的细节被显示。

import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Component;

@Component
 public  class MyHealthIndicator实现了 HealthIndicator {

    @Override
     public Health health（）{
         int errorCode = check（）; //执行一些特定的健康检查
        if（errorCode！= 0）{
            返回 Health.down（）。withDetail（ “Error Code”，errorCode）.build（）;
        }
        返回 Health.up（）。build（）;
    }

}


	给定的标识符`HealthIndicator`是没有`HealthIndicator`后缀的bean的名称（如果存在的话）。在上面的示例中，健康信息将在名为的条目中可用`my`。

除了Spring Boot的预定义Status 类型之外，还可以Health返回Status代表新系统状态的自定义。在这种情况下，HealthAggregator 还需要提供接口的自定义实现，或者使用management.health.status.order配置属性来配置默认实现。

例如，假设在您的某个实现中使用了新Status的代码。要配置严重性顺序，请将以下内容添加到应用程序属性中：FATALHealthIndicator

management.health.status.order = DOWN，OUT_OF_SERVICE，UNKNOWN，UP

HealthMvcEndpoint 如果您通过HTTP访问运行状况端点，则可能还需要注册自定义状态映射。例如，你可以映射FATAL到 HttpStatus.SERVICE_UNAVAILABLE。

47.7申请信息

应用程序信息公开了从您的所有InfoContributorbean中收集的各种信息 ApplicationContext。Spring Boot包含了许多自动配置 InfoContributors，你也可以自己写。

47.7.1自动配置InfoContributors

以下InfoContributors是适当的时候由Spring Boot自动配置的：

名称	描述
`EnvironmentInfoContributor`	公开钥匙`Environment`下的任何`info`钥匙。
`GitInfoContributor`	如果`git.properties`文件可用，请暴露git信息。
`BuildInfoContributor`	如果`META-INF/build-info.properties`文件可用，则公开构建信息。


	可以使用该`management.info.defaults.enabled` 属性禁用它们。

47.7.2自定义应用程序信息信息

您可以info通过设置info.*Spring属性来自定义端点公开的数据。Environment信息键下的所有属性将被自动公开。例如，您可以将以下内容添加到您的application.properties：

info.app.encoding = UTF-8
 info.app.java.source = 1.8
 info.app.java.target = 1.8

而不是硬编码这些值，你也可以在构建时展开信息属性。

假设你正在使用Maven，你可以重写上面的例子，如下所示：

info.app.encoding [email protected] @
 info.app.java.source [email protected] @
 info.app.java.target [email protected] @

47.7.3 Git提交信息

info端点的另一个有用的特性是它能够git在项目构建时发布关于源代码库状态的信息。如果 GitProperties豆可用，git.branch，git.commit.id和git.commit.time属性将被暴露出来。


	一个`GitProperties`bean是自动配置，如果一个`git.properties`文件可在classpath的根目录。有关更多详细信息，请参阅生成git信息。

如果你想显示完整的git信息（即完整的内容 git.properties），使用management.info.git.mode属性：

management.info.git.mode = full

47.7.4构建信息

info如果BuildProperties bean可用，端点还可以发布关于您的构建的信息。如果META-INF/build-info.properties文件在类路径中可用，就会发生这种情况。


	Maven和Gradle插件都可以生成该文件，请参阅生成构建信息以获取更多详细信息。

47.7.5编写自定义的InfoContributors

为了提供定制的应用程序信息，你可以注册实现这个InfoContributor接口的Spring bean 。

下面的示例example为单个值赋值：

import java.util.Collections;

import org.springframework.boot.actuate.info.Info;
import org.springframework.boot.actuate.info.InfoContributor;
import org.springframework.stereotype.Component;

@Component
公共 类 ExampleInfoContributor实现 InfoContributor {

    @Override
     public  void contribution（Info.Builder builder）{
        builder.withDetail（“example”，
                Collections.singletonMap（“key”，“value”））;
    }

}

如果您点击了info端点，您将看到一个包含以下附加条目的响应：

{ 
    “example”：{ 
        “key”：“value” 
    } 
}

48.通过HTTP进行监控和管理

如果您正在开发Spring MVC应用程序，则Spring Boot Actuator将自动配置所有启用的端点以通过HTTP进行公开。默认约定是使用 id端点作为URL路径。例如，health被暴露为/health。

48.1访问敏感端点

默认情况下，所有敏感的HTTP端点都是安全的，只有具有ACTUATOR角色的用户可以访问它们。安全性是使用标准HttpServletRequest.isUserInRole方法强制执行的。


	`management.security.roles`如果你想要的东西不同，请使用属性 `ACTUATOR`。

如果您在防火墙后面部署应用程序，则可能希望无需验证即可访问您的所有执行器端点。你可以通过改变management.security.enabled属性来做到这一点：

application.properties。

management.security.enabled = false


	默认情况下，执行器端点暴露在提供常规HTTP通信的相同端口上。注意不要在更改`management.security.enabled`属性时意外暴露敏感信息。

如果您公开部署应用程序，则可能需要添加“Spring Security”来处理用户身份验证。当添加“Spring Security”时，默认情况下，“基本”身份验证将与用户名user和生成的密码一起使用（在应用程序启动时在控制台上打印）。


	生成的密码在应用程序启动时被记录。搜索“使用默认安全密码”。

您可以使用Spring属性来更改用户名和密码，并更改访问端点所需的安全角色。例如，你可以在你的下面设置application.properties：

security.user.name = admin
 security.user.password =秘密
 management.security.roles = SUPERUSER

48.2自定义管理端点路径

有时将所有管理端点分组在单一路径下是有用的。例如，您的应用程序可能已经/info用于其他目的。您可以使用该 management.context-path属性为您的管理端点设置前缀：

management.context-path = / manage

在application.properties上面的例子将端点从改变/{id}到 /manage/{id}（例如/manage/info）。

您还可以更改端点（使用endpoints.{name}.id）的“id” ，然后更改MVC端点的默认资源路径。法定端点ID仅由字母数字字符组成（因为它们可能会暴露在许多地方，包括禁止使用特殊字符的JMX对象名称）。MVC路径可以通过配置单独更改endpoints.{name}.path，并且对这些值没有验证（因此您可以使用URL路径中合法的任何内容）。例如，要更改/health端点的位置，/ping/me您可以设置 endpoints.health.path=/ping/me。


	如果您提供了一个自定义`MvcEndpoint`记住要包含一个可设置的`path`属性，并且默认它，`/{id}`如果你希望你的代码行为像标准的MVC端点。（看看`HealthMvcEndpoint`你会怎么做。）如果你的自定义端点是一个`Endpoint`（而不是一个`MvcEndpoint`），那么Spring Boot将为你的路径照顾。

48.3自定义管理服务器端口

使用默认的HTTP端口公开管理端点是基于云的部署的明智选择。但是，如果您的应用程序在您自己的数据中心内运行，则可能希望使用不同的HTTP端口公开端点。

该management.port属性可用于更改HTTP端口。

management.port = 8081

由于您的管理端口通常受防火墙保护，并且不向公众公开，即使您的主应用程序是安全的，您也可能不需要管理端点上的安全性。在这种情况下，您将在类路径上具有Spring Security，并且可以像这样禁用管理安全性：

management.security.enabled = false

（如果你在类路径上没有Spring Security，那么就不需要像这样明确地禁用管理安全性，甚至可能会破坏应用程序。）

48.4配置特定于管理的SSL

配置为使用自定义端口时，管理服务器也可以使用各种management.ssl.*属性配置自己的SSL 。例如，这允许管理服务器通过HTTP可用，而主应用程序使用HTTPS：

server.port = 8443
 server.ssl.enabled = true
 server.ssl.key-store = classpath：store.jks
 server.ssl.key-password = secret
 management.port = 8080
 management.ssl.enabled = false

或者，主服务器和管理服务器都可以使用SSL，但使用不同的密钥存储区：

server.port = 8443
 server.ssl.enabled = true
 server.ssl.key-store = classpath：main.jks server.ssl.key -password
 = secret
 management.port = 8080
 management.ssl.enabled = true
 management.ssl。 key-store = classpath：management.jks
 management.ssl.key-password = secret

48.5自定义管理服务器地址

您可以通过设置management.address属性来自定义管理端点可用的地址。如果您只想在内部网络或面向操作的网络上收听，或者仅收听连接，这会非常有用localhost。


	如果端口与主服务器端口不同，则只能监听其他地址。

这是一个application.properties不允许远程管理连接的例子：

management.port = 8081
 management.address = 127.0.0.1

48.6禁用HTTP端点

如果您不想通过HTTP公开端点，则可以将管理端口设置为-1：

management.port = -1

48.7 HTTP健康端点访问限制

健康端点公开的信息取决于是否匿名访问，以及封闭应用程序是否安全。默认情况下，当在安全应用程序中匿名访问时，隐藏有关服务器健康状况的任何细节，端点将简单指示服务器是启动还是关闭。此外，响应被缓存了一个可配置的时间段，以防止端点被用于拒绝服务攻击。该endpoints.health.time-to-live 属性用于配置以毫秒为单位的缓存周期。它默认为1000，即一秒。

可以增强上述限制，从而仅允许经认证的用户完全访问安全应用程序中的健康端点。为此，请设置 endpoints.health.sensitive为true。以下是行为总结（默认sensitive标志值为“false”，用粗体表示）：

`management.security.enabled`	`endpoints.health.sensitive`	未认证	经过身份验证
假	假	完整的内容	完整的内容
假	真正	仅状态	完整的内容
真正	假	仅状态	完整的内容
真正	真正	无内容	完整的内容

49.监视和管理JMX

Java管理扩展（JMX）提供了一个标准机制来监视和管理应用程序。默认情况下，Spring Boot会将管理端点公开为org.springframework.boot域下的JMX MBean 。

49.1定制MBean名称

MBean的名称通常是从id端点生成的。例如，health端点被暴露为org.springframework.boot/Endpoint/healthEndpoint。

如果您的应用程序包含多个Spring，ApplicationContext您可能会发现名称冲突。要解决这个问题，可以将endpoints.jmx.unique-names属性设置为true使MBean名称始终是唯一的。

您还可以自定义公开端点的JMX域。这里是一个例子application.properties：

endpoints.jmx.domain = myapp
 endpoints.jmx.unique-names = true

49.2禁用JMX端点

如果您不想通过JMX公开端点，则可以将该endpoints.jmx.enabled 属性设置为false：

endpoints.jmx.enabled = false

49.3使用Jolokia进行JMX over HTTP

Jolokia是一个JMX-HTTP桥梁，它提供了访问JMX bean的另一种方法。要使用Jolokia，只需添加一个依赖项即可org.jolokia:jolokia-core。例如，使用Maven，您可以添加以下内容：

<dependency> 
    <groupId> org.jolokia </ groupId> 
    <artifactId> jolokia-core </ artifactId> 
 </ dependency>

Jolokia然后可以使用/jolokia您的管理HTTP服务器上访问。

49.3.1定制Jolokia

Jolokia有许多你通常使用servlet参数进行配置的设置。使用Spring Boot，你可以使用你application.properties的参数，只需在参数前加上jolokia.config.：

jolokia.config.debug = true

49.3.2禁用Jolokia

如果您使用的是Jolokia，但您不希望Spring Boot进行配置，只需将该endpoints.jolokia.enabled属性设置为false：

endpoints.jolokia.enabled = false

50.使用远程shell进行监视和管理（不建议使用）

Spring Boot支持一个名为“CRaSH”的集成Java外壳。您可以使用CRaSH进入 ssh或telnet运行正在运行的应用程序。要启用远程shell支持，请将以下依赖项添加到您的项目中：

<dependency> 
    <groupId> org.springframework.boot </ groupId> 
    <artifactId> spring-boot-starter-remote-shell </ artifactId> 
 </ dependency>


	远程shell已被弃用，并将在Spring Boot 2.0中被删除。


	如果你还想启用telnet访问，你还需要依赖`org.crsh:crsh.shell.telnet`。


	CRaSH需要在运行中编译命令时使用JDK运行。如果基本 `help`命令失败，那么您可能正在运行JRE。

50.1连接到远程shell

默认情况下，远程shell将监听端口上的连接2000。默认用户是user，并且默认的密码将被随机生成并显示在日志输出中。如果您的应用程序使用Spring Security，则默认情况下，shell将使用相同的配置。如果没有，将应用一个简单的身份验证，你应该看到这样的消息：

使用默认密码进行shell访问：ec03e16c-4cf4-49ee-b745-7c8255c1dd7e

Linux和OSX用户可以使用ssh连接到远程shell，Windows用户可以下载并安装PuTTY。

$ ssh -p 2000 user @ localhost

user @ localhost 的密码：
  。____ _ __ _ _
 / \\ / _____ __ _ _（_）_ __ __ _ \ \ \ \
（（）\ ___ |'_ |'_ | |'_ \ / _` | \ \ \ \
 \\ / ___）| | _）| | | | | || （_ | |））））
  '| ____ | .__ | _ | | _ | _ | | _ \ __，| / / / /
 ========= | _ | ============== | ___ / = / _ / _ / _ /
 :: myhost上的Spring Boot ::（v1.5.2.RELEASE）

键入help命令列表。春季启动提供metrics，beans，autoconfig 和endpoint命令。

50.1.1远程外壳凭证

您可以使用management.shell.auth.simple.user.name和 management.shell.auth.simple.user.password属性来配置自定义连接凭证。也可以使用“Spring Security” AuthenticationManager来处理登录职责。见 CrshAutoConfiguration 和ShellProperties Javadoc文档的全部细节。

50.2扩展远程shell

远程shell可以用很多有趣的方式进行扩展。

50.2.1远程shell命令

您可以使用Groovy编写额外的shell命令（有关详细信息，请参阅CRaSH文档）。由于CRaSH的Java编译器的限制，不支持用Java编写的命令。默认情况下，Spring Boot将在以下位置搜索命令：

classpath*:/commands/**
classpath*:/crash/commands/**


	您可以通过设置`shell.command-path-patterns`属性来更改搜索路径。


	如果您使用的是可执行文件，shell命令所依赖的任何类都必须封装在嵌套的jar文件中，而不是直接放在可执行文件jar或war中。

这是一个简单的“hello”命令，可以从中加载 src/main/resources/commands/hello.groovy

包命令

import org.crsh.cli.Command
 import org.crsh.cli.Usage
 import org.crsh.command.InvocationContext

class hello {

    @Usage（“说你好”）
    @Command
    def main（InvocationContext context）{
        返回 “你好”
    }

}

Spring Boot添加了一些额外的属性InvocationContext，你可以从你的命令访问：

属性名称	描述
`spring.boot.version`	Spring Boot的版本
`spring.version`	核心Spring框架的版本
`spring.beanfactory`	进入春天 `BeanFactory`
`spring.environment`	进入春天 `Environment`

50.2.2远程shell插件

除了新命令外，还可以扩展其他CRaSH shell功能。所有延伸的Spring Beans org.crsh.plugin.CRaSHPlugin将自动注册到shell中。

有关更多信息，请参阅CRaSH参考文档。

伐木者

Spring Boot Actuator能够在运行时查看和配置应用程序的日志级别。您可以查看整个列表或单个记录器的配置，该配置由显式配置的日志记录级别以及记录框架给出的有效日志记录级别组成。这些级别可以是：

TRACE
DEBUG
INFO
WARN
ERROR
FATAL
OFF
null

并null指出没有明确的配置。

51.1配置记录器

为了配置一个给定的记录器，你需要POST一个部分实体到资源的URI：

{ 
    “configuredLevel”：“DEBUG” 
}

52.度量

Spring Boot Actuator包括一个带“量规”和“计数器”支持的度量服务。“计量器”记录一个单一的值; 和“计数器”记录增量（增量或减量）。Spring Boot Actuator还提供了一个PublicMetrics接口，您可以通过这个接口来公开您不能通过这两种机制之一记录的指标。看SystemPublicMetrics 一个例子。

所有HTTP请求的度量标准都会被自动记录下来，所以如果你点击了metrics 端点，你会看到类似于这样的响应：

{ 
    “counter.status.200.root”：20 ，
    “counter.status.200.metrics”：3 ，
    “counter.status.200.star-star”：5 ，
    “counter.status.401.root”：4 ，
    “gauge.response.star-star”：6 ，
    “gauge.response.root”：2 ，
    “gauge.response.metrics”：3 ，
    “classes”：5808 ，
    “classes.loaded”：5808 ，
    “classes。卸载“：0 ，
    “堆”：3728384，
    “heap.committed” ：986624 ，
    “heap.init” ：262144 ，
    “heap.used” ：52765 ，
    “非堆”：0 ，
    “nonheap.committed” ：77568 ，
    “nonheap.init” ：2496 ，
    “非堆。使用“：75826 ，
    ”mem“：986624 ，
    ”mem.free“：933858 ，
    ”processors“：8 ，
    ”threads“：15 ，
    “threads.daemon”：11，
    “threads.peak”：15 ，
    “threads.totalStarted”：42 ，
    “uptime”：494836 ，
    “instance.uptime”：489782 ，
    “datasource.primary.active”：5 ，
    “datasource.primary.usage”：0.25 
}

在这里我们可以看到基本的memory，heap，class loading，processor和thread pool 一些HTTP度量标准的信息。在这种情况下，root（'/'）和/metricsURL分别返回HTTP 200响应20和3时间。它也似乎root返回HTTP 401（未经授权）的4时间。双重的星号（star-star）来自Spring MVC匹配的请求/**（通常是一个静态资源）。

该gauge显示上次响应时间的请求。所以，最后一次请求root了 2ms回应，最后一个/metrics了3ms。


	在这个例子中，我们实际上是使用`/metrics`URL 通过HTTP访问端点，这就解释了为什么会`metrics`出现在响应中。

52.1系统度量

Spring Boot公开以下系统度量标准：

KB（mem）中的系统总内存
可用内存量（以KB为单位mem.free）
处理器数量（processors）
系统正常运行时间（毫秒）（uptime）
应用程序上下文正常运行时间（毫秒）（instance.uptime）
平均系统负载（systemload.average）
堆信息KB（，heap，heap.committed，）heap.initheap.used
线程信息（threads，thread.peak，thread.daemon）
类负载信息（classes，classes.loaded，classes.unloaded）
垃圾收集信息（gc.xxx.count，gc.xxx.time）

52.2数据源指标

针对DataSource您的应用程序中定义的每个支持，都公开以下指标：

活动连接的数量（datasource.xxx.active）
连接池（datasource.xxx.usage）的当前使用情况。

所有数据源度量标准共享datasource.前缀。前缀进一步限定为每个数据源：

如果数据源是主数据源（即唯一可用的数据源或现有数据源中标记的数据源@Primary），则前缀为 datasource.primary。
如果数据源豆名称结尾DataSource，前缀是bean的无名称DataSource（即datasource.batch对batchDataSource）。
在所有其他情况下，使用bean的名称。

可以通过注册一个具有定制版本的bean来覆盖部分或全部默认值DataSourcePublicMetrics。默认情况下，Spring Boot为所有支持的数据源提供元数据; DataSourcePoolMetadataProvider 如果您最喜欢的数据源不受支持，您可以添加额外的bean。看 DataSourcePoolMetadataProvidersConfiguration例子。

52.3高速缓存指标

针对您的应用程序中定义的每个受支持的缓存公开以下指标：

缓存的当前大小（cache.xxx.size）
命中率（cache.xxx.hit.ratio）
小姐比例（cache.xxx.miss.ratio）


	高速缓存提供程序不会以一致的方式显示命中/错过率。虽然一些暴露的聚集值（即自上次的统计信息被清除的命中率），其他暴露时间值（即最后一秒钟的命中率）。查看你的缓存提供者文档以获取更多细节。

如果两个不同的高速缓存管理器碰巧定义了相同的高速缓存，则高速缓存的名称将以该CacheManagerbean 的名称为前缀。

可以通过注册一个具有定制版本的bean来覆盖部分或全部默认值CachePublicMetrics。默认情况下，Spring Boot为EhCache，Hazelcast，Infinispan，JCache和Guava提供缓存统计信息。CacheStatisticsProvider如果您最喜欢的缓存库不支持开箱即用，您可以添加额外的 bean。看CacheStatisticsAutoConfiguration例子。

52.4 Tomcat会话度量

如果您使用Tomcat作为嵌入式servlet容器，会话度量标准将自动公开。在httpsessions.active与httpsessions.max键提供主动和最大会话数。

52.5记录你自己的指标

记录你自己的指标注入一个 CounterService和/或 GaugeService到你的bean。的CounterService自曝increment，decrement和reset方法; 在 GaugeService提供了一个submit方法。

下面是一个简单的例子，它计算一个方法被调用的次数：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.actuate.metrics.CounterService;
import org.springframework.stereotype.Service;

@Service
公共 类 MyService {

    私人 最终 CounterService counterService;

    @Autowired
     public MyService（CounterService counterService）{
         this .counterService = counterService;
    }

    public  void exampleMethod （）{
         this .counterService.increment（“services.system.myservice.invoked”）;
    }

}


	您可以使用任何字符串作为度量标准名称，但是您应该遵循所选商店/制图技术的指导原则。有关Graphite的一些很好的指导可以在 Matt Aimonetti的Blog上找到。

52.6添加您自己的公开指标

要添加每次调用度量标准端点时计算的其他度量标准，只需注册其他的PublicMetrics实施bean 即可。默认情况下，所有这些bean都由端点收集。你可以通过定义你自己的来轻松地改变它 MetricsEndpoint。

52.7 Java 8的特殊功能

Spring Boot 的默认实现GaugeService和CounterService提供依赖于您正在使用的Java版本。在Java 8（或更好的版本）的情况下，实现切换到一个高性能版本，这个版本是为了快速写入而优化的，由原子内存缓冲区支持，而不是由一成不变但相对昂贵的 Metric<?>类型（计数器的速度大约快5倍，并且大约是基于存储库的实现速度的两倍）。即使对于Java 7（它们具有某些Java 8并发库的反向端口），Dropwizard度量服务（见下文）也非常有效，但它们不记录度量值的时间戳。如果衡量指标收集的性能是一个问题，那么总是建议使用高性能选项之一，而且也只是偶尔读取指标，以便写入在本地进行缓冲，并且只在需要时才进行读取。


	如果您使用的是Java 8或者使用的是Dropwizard度量标准，那么旧的`MetricRepository`和其`InMemoryMetricRepository`实现不会默认使用。

52.8指标编写者，出口商和汇总

Spring Boot提供了一个标记接口的实现，Exporter 它可以用来将度量读数从内存缓冲区复制到可以分析和显示的地方。事实上，如果您提供了一个@Bean实现MetricWriter接口（或GaugeWriter简单用例）的接口并对其进行标记 @ExportMetricWriter，那么它将自动连接到Exporter每5秒（通过配置spring.metrics.export.delay-millis）更新的馈送度量标准。另外，MetricReader您定义和标记为的任何@ExportMetricReader值都将由默认导出器导出其值。


	此功能在您的应用程序（`@EnableScheduling`）中启用时间表，如果您运行集成测试，那么您的计划任务将启动，这可能会造成问题。您可以通过设置`spring.metrics.export.enabled`为禁用此行为`false`。

默认的导出器是一个MetricCopyExporter试图通过不复制自上次调用以来没有改变的值来优化自身（可以使用标志关闭优化）的导出器spring.metrics.export.send-latest。还要注意，Dropwizard MetricRegistry不支持时间戳，所以如果使用Dropwizard指标（所有的指标都会在每个时间戳中被复制），优化是不可用的。

对于出口触发的默认值（delay-millis，includes，excludes 和send-latest）可以设置为spring.metrics.export.*。对于特定个人的值MetricWriters可以被设置为 spring.metrics.export.triggers.<name>.*其中<name>是一个bean名称（或图案匹配bean的名字）。


	如果关闭默认值`MetricRepository`（例如，使用Dropwizard指标），则会自动导出度量标准。你可以获得相同的功能，声明一个你自己类型的bean `MetricReader`并声明它是`@ExportMetricReader`。

52.8.1示例：导出到Redis

如果您提供了一个@Bean类型RedisMetricRepository并将其标记，@ExportMetricWriter 则度量标准将导出到Redis缓存中进行聚合。该RedisMetricRepository有配置它用于此目的的两个重要参数：prefix和key（通过到它的构造）。最好使用对应用程序实例唯一的前缀（例如，使用随机值，也可以使用应用程序的逻辑名称，以便与同一应用程序的其他实例关联）。“键”用于保留所有度量名称的全局索引，因此它应该是唯一的“全局”，无论这意味着您的系统（例如，如果同一系统的两个实例具有不同的密钥，则可以共享一个Redis缓存）。

例：

@Bean 
@ExportMetricWriter
MetricWriter metricWriter（MetricExportProperties导出）{
    返回 新的 RedisMetricRepository（connectionFactory，
        export.getRedis（）。getPrefix（），export.getRedis（）。getKey（））;
}

application.properties。

spring.metrics.export.redis.prefix：metrics.mysystem。$ {spring.application.name:application}.${random.value:0000}
 spring.metrics.export.redis.key：keys.metrics.mysystem

前缀由最后的应用程序名称和ID构成，所以稍后可以很容易地用来标识具有相同逻辑名称的一组进程。

同时设置key和prefix。密钥用于所有存储库操作，并可由多个存储库共享。如果多个存储库共享一个密钥（就像在需要聚合的情况下那样），那么通常有一个只读的“主”存储库，它有一个简短但可识别的前缀（如“metrics.mysystem”），和许多只有以前缀开头的只写存储库（就像metrics.mysystem.*上面的例子）。从这样的“主”存储库中读取所有的密钥是有效的，但是读取具有较长前缀的子集（例如使用其中一个写入存储库）效率低下。


	上面的例子使用`MetricExportProperties`注入和提取密钥和前缀。这是作为一个方便的弹簧引导提供给你，配置合理的默认值。只要遵循建议，没有什么可以阻止你使用自己的价值观。

52.8.2示例：导出到打开TSDB

如果您提供一个@Bean类型OpenTsdbGaugeWriter并将其标记 @ExportMetricWriter为导出到打开TSDB进行聚合。该OpenTsdbGaugeWriter有一个url，你需要设置为打开TSDB“/放”端点，例如物业localhost:4242/api/put）。它还具有一个 namingStrategy可以自定义或配置的度量标准，以使度量标准与您在服务器上需要的数据结构相匹配。默认情况下，它只是将度量标准名称作为Open TSDB度量标准名称进行传递，并将标记“domain”（值为“org.springframework.metrics”）和“process”（其值等于命名的对象哈希值战略）。因此，在运行应用程序并生成一些指标之后，您可以检查TSD UI中的指标（默认为localhost：4242）。

例：

curl localhost：4242 / api / query？start = 1h-ago＆m = max：counter.status.200.root
[
    {
        “metric”：“counter.status.200.root”，
        “tags”：{
            “domain”：“org.springframework.metrics”，
            “过程”：“b968a76”
        }，
        “aggregateTags”：[]，
        “dps”：{
            “1430492872”：2，
            “1430492875”：6
        }
    }
]

52.8.3示例：导出到Statsd

要将度量值导出到Statsd，首先确保已经添加 com.timgroup:java-statsd-client为项目的依赖项（Spring Boot为其提供依赖项管理）。然后spring.metrics.export.statsd.host 为您的application.properties文件添加一个值。连接将打开到端口，8125 除非提供spring.metrics.export.statsd.port覆盖。spring.metrics.export.statsd.prefix如果你想要一个自定义的前缀，你可以使用。

或者，您可以提供一个@Bean类型StatsdMetricWriter并标记它 @ExportMetricWriter：

@value（ “$ {spring.application.name:application}.${random.value:0000}”）
私人字符串前缀= “度量” ;

@Bean 
@ExportMetricWriter
MetricWriter metricWriter（）{
    返回 新的 StatsdMetricWriter（前缀“localhost”，8125）;
}

52.8.4示例：导出到JMX

如果您提供了标记@Bean类型的度量标准，则会将度量标准作为MBean导出到本地服务器（只要启用，则由Spring Boot JMX自动配置提供）。然后可以使用任何了解JMX的工具（例如JConsole或JVisualVM）来检查，绘制度量标准，提醒等等。JmxMetricWriter@ExportMetricWriterMBeanExporter

例：

@Bean 
@ExportMetricWriter
MetricWriter metricWriter（MBeanExporter exporter）{
    返回 新的 JmxMetricWriter（exporter）;
}

每个度量都作为单独的MBean导出。其格式ObjectNames由ObjectNamingStrategy可以注入的JmxMetricWriter（默认分割度量标准名称，并以JVisualVM或JConsole中的度量值组很好的方式标记前两个由句点分隔的部分）给出。

52.9汇总来自多个来源的指标

有一个AggregateMetricReader，你可以用它来整合来自不同物理源指标。相同逻辑度量的来源只需要用句点分隔的前缀来发布它们，阅读器就会聚合（通过截断度量名称和删除前缀）。计数器被汇总，其他所有数据（例如量表）都取最近的值。

如果多个应用程序实例提供给中央（例如Redis）存储库并且要显示结果，这非常有用。特别推荐与a MetricReaderPublicMetrics连接以将结果连接到“/ metrics”端点。

例：

@Autowired
私有 MetricExportProperties导出;

@Bean
 public PublicMetrics metricsAggregate（）{
     return  new MetricReaderPublicMetrics（aggregatesMetricReader（））;
}

private MetricReader globalMetricsForAggregation（）{
     return  new RedisMetricRepository（this .connectionFactory ，
         this .export.getRedis（）。getAggregatePrefix（），this .export.getRedis （）。getKey（））;
}

private MetricReader aggregatesMetricReader（）{
    AggregateMetricReader repository = new AggregateMetricReader（
        globalMetricsForAggregation（））;
    退货库;
}


	上面的例子使用`MetricExportProperties`注入和提取密钥和前缀。这是作为一个方便的弹簧引导提供给你，默认值将是明智的。他们成立了`MetricExportAutoConfiguration`。


	在`MetricReaders`上述不`@Beans`和没有标记为 `@ExportMetricReader`，因为他们只是收集和分析来自其他存储库的数据，并且不希望出口他们的价值观。

Spring Boot参考指南

Spring Boot参考指南

作者

第一部分Spring Boot文档

1.关于文档

2.获得帮助

3.第一步

4.使用Spring Boot

5.学习Spring Boot的特性

6.转向生产

7.高级主题

第二部分 入门

8.介绍Spring Boot

9.系统要求

9.1 Servlet容器

10.安装Spring Boot

10.1 Java开发人员的安装说明

10.1.1 Maven安装

10.1.2 Gradle安装

10.2安装Spring Boot CLI

10.2.1手动安装

10.2.2使用SDKMAN安装！

10.2.3 OSX Homebrew安装

10.2.4 MacPorts安装

10.2.5命令行完成

10.2.6快速启动Spring CLI示例

10.3从早期版本的Spring Boot升级

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

11.1创建POM

11.2添加classpath依赖关系

11.3编写代码

11.3.1 @RestController和@RequestMapping注解

11.3.2 @EnableAutoConfiguration注释

11.3.3“主要”方法

11.4运行示例

11.5创建一个可执行的jar

12.接下来读什么

第三部分 使用Spring Boot

13.建立系统

13.1依赖管理

13.2 Maven

13.2.1继承初始父项

13.2.2使用没有父POM的Spring Boot

13.2.3更改Java版本

13.2.4使用Spring Boot Maven插件

13.3 Gradle

13.4蚂蚁

13.5起动

14.构建你的代码

14.1使用“默认”软件包

14.2找到主应用程序类

15.配置类

15.1导入其他配置类

15.2导入XML配置

16.自动配置

16.1逐渐更换自动配置

16.2禁用特定的自动配置

17.春豆和依赖注入

18.使用@SpringBootApplication注释

19.运行你的应用程序

19.1从IDE运行

19.2作为打包应用程序运行

19.3使用Maven插件

19.4使用Gradle插件

19.5热插拔

20.开发人员工具

20.1属性默认值

20.2自动重启

20.2.1排除资源

20.2.2看额外的路径

20.2.3禁用重启

20.2.4使用触发文件

20.2.5定制重启classloader

20.2.6已知的限制

20.3 LiveReload

20.4全局设置

20.5远程应用程序

20.5.1运行远程客户端应用程序

20.5.2远程更新

20.5.3远程调试隧道

第二部分入门

第三部分使用Spring Boot