本文介绍了SpringBoot的基础知识，包括安装指南、系统要求及快速启动示例。此外，还讲解了如何构建首个SpringBoot应用程序，涉及Maven项目搭建、依赖管理和运行方式等内容。
Spring Boot参考指南
1.5.2.RELEASE
版权所有©2012-2017
目录
-
I. Spring Boot文档
- II。入门
- III。使用Spring Boot
- IV。Spring Boot功能
-
-
23. SpringApplication
- 24.外部化配置
- 25.简介
- 26.记录
- 27.开发Web应用程序
- 28.安全
- 29.使用SQL数据库
- 30.使用NoSQL技术
- 31.缓存
- 信息
- 33.调用REST服务
- 34.验证 35.发送电子邮件 36.与JTA分布式事务
- 37. Hazelcast 38.春天一体化 39.春季会议 40.监控和管理JMX 41.测试
- 42. WebSockets 43.网络服务 44.创建你自己的自动配置
- 45.下一步阅读什么
V.弹簧执行器：生产就绪功能
- VI。部署Spring Boot应用程序
- 七。Spring启动CLI
- 八。构建工具插件
- IX。“如何做”指南
-
-
71. Spring Boot应用程序
- 72.属性和配置
- 73.嵌入式servlet容器
-
-
73.1。将Servlet，Filter或Listener添加到应用程序中
- 73.2。更改HTTP端口 73.3。使用随机未分配的HTTP端口 73.4。在运行时发现HTTP端口 73.5。配置SSL 73.6。配置访问记录 73.7。在前端代理服务器后面使用
- 73.8。配置Tomcat 73.9。使用Tomcat启用多个连接器 73.10。使用Tomcat的LegacyCookieProcessor 73.11。使用Jetty而不是Tomcat 73.12。配置码头 73.13。使用Undertow而不是Tomcat 73.14。配置Undertow 73.15。使用Undertow启用多个监听器 73.16。使用Tomcat 7.x或8.0
- 73.17。使用Jetty 9.2
- 73.18。使用Jetty 8
- 73.19。使用@ServerEndpoint创建WebSocket端点 73.20。启用HTTP响应压缩
74. Spring MVC
- 75. HTTP客户端
- 记录
- 77.数据访问
- 数据库初始化
- 信息
- 80.批量应用程序
- 81.执行器
- 82.安全
- 83.热插拔
- 84.建设
- 85.传统部署
十，附录
-
第一部分Spring Boot文档
本节简要介绍Spring Boot参考文档。将其视为文档其余部分的映射。您可以以线性方式阅读本参考指南，或者如果您不感兴趣，可以跳过部分内容。
Spring Boot参考指南有html， pdf 和epub文档。最新的副本位于docs.spring.io/spring-boot/docs/current/reference。
本文档的副本可以为您自己使用并分发给其他人，前提是您不收取这些副本的任何费用，并进一步规定每份副本均包含此版权声明，无论是以印刷版还是电子版分发。
在Spring Boot遇到问题，我们希望能提供帮助！
- 试试怎么对的 -他们最常见的问题提供解决方案。
- 学习Spring基础知识 - Spring Boot构建在许多其他Spring项目上，查阅spring.io网站获取大量参考文档。如果您刚开始使用Spring，请尝试其中一个指南。
- 问一个问题 - 我们监视stackoverflow.com问题的标签
spring-boot。 - 使用Spring Boot在github.com/spring-projects/spring-boot/issues报告错误。
![[注意]](https://i-blog.csdnimg.cn/blog_migrate/968711e6d39e9776532d7ca94d1dccec.png)
所有的Spring Boot都是开源的，包括文档！如果您发现文档有问题，或者如果你只是想改善他们，请参与。
准备好真正开始使用Spring Boot？我们已经涵盖了你。
需要更多关于Spring Boot核心功能的细节？ 这是给你的！
当您准备将Spring Boot应用程序推向生产时，我们有 一些您可能会喜欢的技巧！
如果你刚开始使用Spring Boot，或者一般来说就是“Spring”，那么这是你的一部分！这里我们回答基本的“什么”，“怎么做”和“为什么”的问题。你会发现一个温柔的介绍，以及安装说明的Spring Boot。然后，我们将构建我们的第一个Spring Boot应用程序，并讨论一些核心原则。
Spring Boot使您可以轻松创建独立的生产级基于Spring的应用程序，您可以“运行”。我们对Spring平台和第三方库有自己的看法，所以你可以从最小的麻烦开始。大多数Spring Boot应用程序只需要很少的Spring配置。
您可以使用Spring Boot来创建可以使用
java -jar或更传统的战争部署来启动的Java应用程序。我们还提供了一个运行“春天脚本”的命令行工具。我们的主要目标是：
- 为所有Spring开发提供一个更快，更广泛的入门体验。
- 开箱即用，但随着需求开始偏离默认设置，快速退出。
- 提供大型项目（例如嵌入式服务器，安全性，指标，运行状况检查，外部配置）通用的一系列非功能性功能。
- 绝对不会生成代码，也不需要XML配置。
默认情况下，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提供了明确的构建支持。
![[小费]](https://i-blog.csdnimg.cn/blog_migrate/e02bdbaa9322aecc47be0a74d058c917.png)
虽然可以使用Java 6或7的Spring Boot，但是我们通常推荐使用Java 8。
Spring Boot可以与“经典”Java开发工具一起使用，也可以作为命令行工具安装。无论如何，您将需要Java SDK v1.6或更高版本。在开始之前，您应该检查您当前的Java安装：
$ java -version如果您对Java开发不熟悉，或者您只是想尝试Spring Boot，则可能需要先尝试Spring Boot CLI，否则请阅读“经典”安装说明。
尽管Spring Boot与Java 1.6兼容，但如果可能的话，应该考虑使用最新版本的Java。
您可以像使用任何标准Java库一样使用Spring Boot。只需
spring-boot-*.jar在您的类路径中包含相应的文件即可。Spring Boot不需要任何特殊的工具集成，所以你可以使用任何IDE或文本编辑器; Spring Boot应用程序没有什么特别之处，所以您可以像运行其他任何Java程序一样运行和调试。尽管您可以复制Spring Boot jar，但我们通常建议您使用支持依赖管理的构建工具（如Maven或Gradle）。
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.bootgroupId。通常，您的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。Spring Boot与Gradle 2（2.9或更高版本）和Gradle 3兼容。如果您尚未安装Gradle，则可以按照www.gradle.org/上的说明进行操作。
Spring引导依赖可以使用
org.springframework.bootgroup。通常，您的项目将声明依赖关系到一个或多个 “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”） }
Spring Boot CLI是一个命令行工具，如果你想用Spring来快速创建原型，可以使用它。它允许你运行Groovy脚本，这意味着你有一个熟悉的类Java语法，没有太多的样板代码。
您不需要使用CLI来使用Spring Boot，但它绝对是使Spring应用程序停飞的最快捷方式。
您可以从Spring软件存储库下载Spring CLI发行版：
最前沿的快照分布 也是可用的。
下载之后，请按照 解压缩归档中的INSTALL.txt说明进行操作。总结：在文件目录中有一个
spring脚本（spring.bat用于Windows），或者也可以与该文件一起使用（该脚本可帮助您确保类路径设置正确）。bin/.zipjava -jar.jarSDKMAN！（软件开发工具包管理器）可用于管理各种二进制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 ================================================== ============================== + - 本地版本 * - 已安装 > - 目前正在使用 ================================================== ==============================
如果您在Mac上并使用Homebrew，则只需安装Spring Boot CLI即可：
$ brew tap pivotal / tap $ brew安装springboot
家酿将安装
spring到/usr/local/bin。如果您没有看到该公式，那么您的brew的安装可能会过期。只要执行，
brew update然后再试一次。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中注册。
这是一个非常简单的Web应用程序，您可以使用它来测试您的安装。创建一个名为
app.groovy：@RestController 类 ThisWillActuallyRun { @RequestMapping（ “/”） String home（）{ “你好，世界！” } }
然后简单地从一个shell运行它：
$ spring run app.groovy首次运行应用程序需要一段时间，因为依赖关系被下载。后续运行将会更快。
在你喜欢的网页浏览器中打开localhost：8080，你应该看到下面的输出：
你好，世界！我们用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，供应商：甲骨文公司
此示例需要在其自己的文件夹中创建。后续的说明假定你已经创建了一个合适的文件夹，并且它是你的“当前目录”。
我们需要从创建一个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的内置支持）。为了简单起见，我们将继续在这个例子中使用纯文本编辑器。
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本身。为了完成我们的应用程序，我们需要创建一个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（实施例类，参数）; } }
虽然这里没有太多的代码，但还是有很多。我们来看看重要的部分。
我们
Example班的第一个注释是@RestController。这被称为 刻板印记。它为阅读代码提供了线索，对于Spring来说，这个类扮演着特定的角色。在这种情况下，我们的类是一个Web，@Controller所以Spring在处理传入的Web请求时会考虑它。该
@RequestMapping注释提供“路由”的信息。它告诉Spring，任何具有路径“/”的HTTP请求都应映射到该home方法。该@RestController注解告诉Spring使得到的字符串直接返回给调用者。在
@RestController与@RequestMapping注解是Spring MVC的注解（他们并不是专门针对春季启动）。有关更多详细信息，请参阅Spring参考资料中的MVC部分。第二个级别的注释是
@EnableAutoConfiguration。这个注解告诉Spring Boot根据你添加的jar依赖来“猜测”你将如何配置Spring。自从spring-boot-starter-web添加了Tomcat和Spring MVC之后，自动配置将假定您正在开发一个Web应用程序并相应地设置Spring。在这一点上我们的应用程序应该工作 由于我们已经使用了
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。让我们通过创建一个完全独立的可执行jar文件来完成我们的例子，我们可以在生产环境中运行它。可执行jar（有时也称为“fat jars”）是包含您编译的类以及您的代码需要运行的所有jar依赖项的归档文件。
要创建一个可执行的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-parentPOM包括<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。希望本节为您提供了一些Spring Boot基础知识，并帮助您编写自己的应用程序。如果您是面向任务的开发人员，则可能需要跳至spring.io，并查看一些 入门指南，以解决具体的“如何使用Spring”问题; 我们也有Spring Boot特定 的操作指南文档。
在春季启动库也有 一堆样品可以运行。样本独立于代码的其余部分（也就是说，您不需要构建其余的代码来运行或使用样本）。
否则，下一个逻辑步骤是阅读第三部分“使用Spring Boot”。如果你真的不耐烦，也可以跳过来阅读 Spring Boot的特性。
本节将更详细地介绍如何使用Spring Boot。它涵盖了构建系统，自动配置以及如何运行应用程序等主题。我们还介绍了一些Spring Boot的最佳实践。尽管Spring Boot没有什么特别的地方（它只是你可以使用的另一个库），但是有一些建议，如果遵循这些建议，将使开发过程变得更容易一些。
如果您刚刚开始使用Spring Boot，则可能需要先阅读 入门指南，然后再深入本节。
强烈建议您选择支持依赖管理的构建系统 ，并且可以使用发布到“Maven Central”存储库的工件。我们建议您选择Maven或Gradle。Spring Boot可以与其他构建系统（例如Ant）一起工作，但是它们不会得到特别好的支持。
Spring Boot的每个发行版都提供了一个支持的依赖列表。在实践中，您不需要为构建配置中的任何这些依赖项提供一个版本，因为Spring Boot正在为您进行管理。当您升级Spring Boot本身时，这些依赖关系也将以一致的方式升级。
如果您觉得有必要，您仍然可以指定一个版本并覆盖Spring Boot的建议。
策划的列表包含您可以使用Spring Boot的所有弹簧模块以及第三方库的精炼列表。该列表可以作为标准 物料清单（
spring-boot-dependencies） 以及Maven和 Gradle的其他专用支持。![[警告]](https://i-blog.csdnimg.cn/blog_migrate/b419958fbc193c039ccf91b3ba519f38.png)
Spring Boot的每个版本都与Spring Framework的基础版本相关联，因此我们强烈建议您不要自行指定其版本。
Maven用户可以从
spring-boot-starter-parent项目中继承以获得合理的默认值。父项目提供以下功能：最后一点：由于默认配置文件接受Spring样式占位符（
${…}），Maven过滤被改为使用@..@占位符（您可以用Maven属性覆盖resource.delimiter）。要配置你的项目从
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-dependenciespom 以获取支持的属性列表。不是每个人都喜欢从
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，但是任何依赖类型都可以被覆盖。
该
spring-boot-starter-parent选相当保守的Java兼容性。如果您想遵循我们的建议并使用较新的Java版本，则可以添加一个java.version属性：<properties> <java.version> 1.8 </java.version> </ properties>
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，你只需要添加插件，除非你想改变在父代中定义的设置，否则不需要进行配置。
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”） }
可以使用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。启动器是一套方便的依赖描述符，可以包含在应用程序中。您可以获得所需的所有Spring及相关技术的一站式服务，无需搜索示例代码，也不需要粘贴依赖关系描述符。例如，如果您想开始使用Spring和JPA进行数据库访问，只需将
spring-boot-starter-data-jpa依赖项包含在您的项目中，那么您就可以开始使用了。初学者包含很多依赖项，您需要快速启动并运行一个项目，并使用一组支持的传递依赖项。
以下应用程序启动程序由Spring Boot提供
org.springframework.boot：表13.1。Spring Boot应用程序启动器
名称 描述 双响炮 使用Thymeleaf视图构建MVC Web应用程序的入门者
初级用于使用Couchbase面向文档的数据库和Spring Data Couchbase
使用Apache Artemis启动JMS消息传递
使用Spring Web服务的入门者
Starter使用Java Mail和Spring Framework的电子邮件发送支持
使用Spring Data Redis和Jedis客户端使用Redis键值数据存储的入门者
用于构建Web的入门者，包括使用Spring MVC的RESTful应用程序。使用Tomcat作为默认的嵌入容器
初学者使用GemFire分布式数据存储和Spring Data GemFire
使用Apache ActiveMQ启动JMS消息传递
入门使用Elasticsearch搜索和分析引擎和Spring Data Elasticsearch
初学者使用Spring集成
Starter用于测试包含JUnit，Hamcrest和Mockito等库的Spring Boot应用程序
将JDBC与Tomcat JDBC连接池配合使用的初学者
使用Spring Mobile构建Web应用程序的入门者
通过Hibernate Validator使用Java Bean验证的入门者
使用Spring MVC和Spring HATEOAS构建基于超媒体的RESTful Web应用程序的入门者
使用JAX-RS和Jersey构建RESTful Web应用程序的入门者。替代方案
spring-boot-starter-web初学者使用Neo4j图形数据库和Spring Data Neo4j
初学者使用Spring Data LDAP
使用Spring Framework的WebSocket支持构建WebSocket应用程序的入门者
使用Spring AOP和AspectJ进行面向方面编程的入门者
使用Spring AMQP和Rabbit MQ的入门者
入门使用Cassandra分布式数据库和Spring Data Cassandra
首先使用Spring社交Facebook
使用Atomikos启动JTA交易
Starter使用Spring Security
使用Mustache视图构建MVC Web应用程序的入门者
使用Spring数据JPA与Hibernate的入门
核心启动器，包括自动配置支持，日志记录和YAML
使用Groovy模板视图构建MVC Web应用程序的入门者
使用FreeMarker视图构建MVC Web应用程序的入门者
使用Spring Batch的入门者
使用Spring社交LinkedIn的站点
初学者使用Spring框架的缓存支持
启动Spring Data Solr使用Apache Solr搜索平台
入门使用MongoDB面向文档的数据库和Spring Data MongoDB
使用jOOQ访问SQL数据库的入门者。
spring-boot-starter-data-jpa或者的替代方法spring-boot-starter-jdbc春天启动Narayana JTA起动器
使用Spring Cloud连接器的入门，可简化Cloud Foundry和Heroku等云平台中的服务连接
使用Bitronix启动JTA事务
使用Spring社交Twitter的入门者
使用Spring Data REST通过REST公开Spring数据存储库的初学者
除了应用程序启动器之外，还可以使用以下启动器来添加 生产准备功能：
最后，Spring Boot还包括一些可以用来排除或交换特定技术方面的新手：
表13.3。Spring Boot技术首发
名称 描述 双响炮 使用Undertow作为嵌入式servlet容器的初学者。替代方案
spring-boot-starter-tomcat使用Jetty作为嵌入式servlet容器的入门。替代方案
spring-boot-starter-tomcatStarter使用Logback进行日志记录。默认日志启动器
使用Tomcat作为嵌入式servlet容器的入门。默认的servlet容器启动器使用
spring-boot-starter-web使用Log4j2进行日志记录的入门者。替代方案
spring-boot-starter-logging
有关其他社区的列表贡献首先，看 README文件中
spring-boot-startersGitHub上的模块。Spring Boot不需要任何特定的代码布局，但是，有一些最佳实践可以提供帮助。
当一个类不包含
package声明时，它被认为是在“默认包”中。通常不鼓励使用“默认软件包”，应该避免使用“默认软件包”。这可能会导致使用Spring的启动应用程序的特殊问题@ComponentScan，@EntityScan或@SpringBootApplication注解，因为从每一个罐子每一个类，将被读取。我们建议您遵循Java推荐的软件包命名约定，并使用颠倒的域名（例如
com.example.project）。我们通常建议您将主应用程序类放在其他类的根包中。该
@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（应用类，参数）; } }
Spring Boot支持基于Java的配置。虽然可以
SpringApplication.run()使用XML来源进行调用 ，但我们通常建议您的主要来源是一个@Configuration类。通常，定义main方法的类也是一个很好的候选者@Configuration。在互联网上已经发布了许多使用XML配置的Spring配置示例。如果可能，请始终尝试使用基于Java的等效配置。搜索
enable*注释可能是一个很好的起点。你不需要把所有的
@Configuration东西都放到一个班上。所述@Import注释可以用于导入额外的配置类。或者，您可以使用@ComponentScan自动获取所有Spring组件，包括@Configuration类。Spring Boot自动配置会尝试根据您添加的jar依赖项自动配置您的Spring应用程序。例如，If
HSQLDB在您的类路径中，并且您没有手动配置任何数据库连接Bean，那么我们将自动配置一个内存数据库。您需要选择加入
@EnableAutoConfiguration或@SpringBootApplication注释到您的一个@Configuration类自动配置。你只能添加一个
@EnableAutoConfiguration注释。我们通常建议您将其添加到您的主@Configuration类。自动配置是非侵入式的，您可以随时开始定义自己的配置来替换自动配置的特定部分。例如，如果添加自己的
DataSourceBean，则默认的嵌入式数据库支持将退出。如果您需要了解当前正在应用的自动配置，以及为什么使用
--debug交换机启动您的应用程序。这将启用选择核心记录器的调试日志，并将自动配置报告记录到控制台。如果您发现正在应用您不需要的特定自动配置类，则可以使用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属性控制自动配置类的列表 。您可以在注释级别和使用属性中定义排除。
您可以自由使用任何标准的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，指示它不能随后更改。许多春季引导开发者总是有其主类注解为
@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。将应用程序打包为jar并使用嵌入式HTTP服务器的最大优点之一是，您可以像运行其他应用程序一样运行应用程序。调试Spring Boot应用程序也很容易; 你不需要任何特殊的IDE插件或扩展。
本节仅介绍基于jar的打包。如果您选择将应用程序打包为war文件，则应参考您的服务器和IDE文档。
您可以从IDE运行Spring Boot应用程序作为简单的Java应用程序，但是，首先您需要导入项目。导入步骤取决于您的IDE和构建系统。大多数IDE可以直接导入Maven项目，例如Eclipse用户可以从菜单中选择
Import…→ 。Existing Maven ProjectsFile如果不能直接将项目导入IDE，则可以使用构建插件生成IDE元数据。Maven包含Eclipse和 IDEA的插件 ; Gradle为各种IDE提供插件。
如果您不小心运行了两次Web应用程序，则会看到“端口已被使用”错误。STS用户可以使用该
Relaunch按钮，而不是Run确保任何现有的实例关闭。如果您使用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
Spring Boot Maven插件包含一个
run可用于快速编译和运行应用程序的目标。应用程序以分解形式运行，就像在IDE中一样。$ mvn spring-boot：运行您可能还想使用有用的操作系统环境变量：
$ export MAVEN_OPTS = -Xmx1024m -XX：MaxPermSize = 128MSpring Boot Gradle插件还包含一个
bootRun可用于以分解形式运行应用程序的任务。该bootRun每当你导入的任务添加spring-boot-gradle-plugin：$ gradle bootRun您可能也想使用这个有用的操作系统环境变量：
$ export JAVA_OPTS = -Xmx1024m -XX：MaxPermSize = 128M由于Spring Boot应用程序只是普通的Java应用程序，所以JVM热插拔应该是开箱即用的。JVM热交换在某种程度上受限于它可以替换的字节码，为了获得更完整的解决方案， 可以使用JRebel或 Spring Loaded项目。该
spring-boot-devtools模块还包括支持快速重新启动应用程序。有关详细信息，请参阅下面的第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功能，你需要禁用
excludeDevtoolsbuild属性来包含它。该属性支持Maven和Gradle插件。Spring Boot支持的一些库使用缓存来提高性能。例如，模板引擎 将缓存已编译的模板，以避免重复解析模板文件。此外，Spring MVC可以在服务静态资源时将HTTP缓存头添加到响应中。
虽然缓存在生产中非常有益，但在开发过程中可能会产生反作用，使您无法看到您在应用程序中所做的更改。由于这个原因，spring-boot-devtools默认会禁用这些缓存选项。
缓存选项通常由
application.properties文件中的设置进行配置。例如，Thymeleaf提供的spring.thymeleaf.cache财产。不需要手动设置这些属性，spring-boot-devtools模块将自动应用合理的开发时间配置。有关应用的属性的完整列表，请参阅 DevToolsPropertyDefaultsPostProcessor。
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。某些资源不一定需要在更改时触发重新启动。例如，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属性。您可能希望在更改不在类路径中的文件时重新启动或重新加载应用程序。为此，请使用该
spring.devtools.restart.additional-paths属性来配置其他路径以查看更改。您可以使用spring.devtools.restart.exclude属性 上述控制的其他路径下的变化是否会引发全面重启或只是一个 活的重载。如果您不想使用重新启动功能，则可以使用该
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的类，参数）; }
如果您使用连续编译已更改文件的IDE，则可能只希望在特定时间触发重新启动。要做到这一点，你可以使用“触发文件”，这是一个特殊的文件，当你想要实际触发重新启动检查时，必须修改这个文件。只更改文件会触发检查，只有Devtools检测到必须执行某些操作时才会重新启动。触发文件可以手动更新，也可以通过IDE插件进行更新。
要使用触发器文件，请使用该
spring.devtools.restart.trigger-file属性。您可能希望将其设置
spring.devtools.restart.trigger-file为 全局设置，以便所有项目的行为方式相同。如上面的重新启动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的将被加载。您可以将文件打包到项目中，也可以打包到项目使用的库中。该
spring-boot-devtools模块包含一个嵌入式LiveReload服务器，可用于在资源发生更改时触发浏览器刷新。LiveReload浏览器扩展可从livereload.com的 Chrome，Firefox和Safari免费获得 。如果您不想在应用程序运行时启动LiveReload服务器，则可以将该
spring.devtools.livereload.enabled属性设置为false。一次只能运行一个LiveReload服务器。在开始您的应用程序之前，请确保没有其他LiveReload服务器正在运行。如果您从IDE启动多个应用程序，则只有第一个应用程序支持LiveReload。
您可以通过添加一个文件名为配置全局devtools设置
.spring-boot-devtools.properties你的$HOME文件夹（注意：文件名开头“”）。添加到此文件的任何属性都将应用于使用devtools的计算机上的所有 Spring Boot应用程序。例如，要将重新启动配置为始终使用触发器文件，可以添加以下内容：〜/ .spring引导-devtools.properties。
spring.devtools.reload.trigger-file = .reloadtrigger
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设置属性时，服务器组件会自动启用。客户端组件必须手动启动。远程客户端应用程序旨在从您的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属性。远程客户端将以与本地重启相同的方式监视您的应用程序类路径的更改。任何更新的资源将被推送到远程应用程序，并（如果需要）触发重新启动。如果您正在迭代使用您本地没有的云服务的功能，这可能会非常有帮助。通常远程更新和重新启动比完整的重建和部署周期快得多。
只有远程客户端正在运行时才监视文件。如果在启动远程客户端之前更改文件，则不会将其推送到远程服务器。
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→DebugfromPreferences…并将其更改Debugger timeout (ms)为更适合的值（60000在大多数情况下运行良好）。在IntelliJ IDEA中使用远程调试通道时，必须将所有断点配置为挂起线程而不是VM。默认情况下，IntelliJ IDEA中的断点会挂起整个虚拟机，而不是挂起命中断点的线程。这具有暂停管理远程调试通道的线程的不良副作用，导致您的调试会话冻结。在IntelliJ IDEA中使用远程调试通道时，应将所有断点配置为挂起线程而不是VM。请参阅 IDEA-165769了解更多详情。
可执行的罐子可用于生产部署。由于它们是独立的，因此它们也非常适合基于云的部署。
对于其他“生产就绪”功能，如健康，审计和度量REST或JMX端点; 考虑加入
spring-boot-actuator。有关详细信息，请参阅 第五部分“弹簧执行器：生产就绪功能”。22.接下来读什么
您现在应该对如何使用Spring Boot以及您应该遵循的一些最佳实践有很好的理解。您现在可以继续深入了解特定的 Spring Boot功能，或者可以跳过并阅读Spring Boot 的“ 生产准备 ”部分。
本节将深入探讨Spring Boot的细节。在这里，您可以了解要使用和定制的关键功能。如果还没有，可能需要阅读第II部分“入门”和 第III部分“使用Spring Boot”部分，以便您了解基础知识。
本
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将显示日志消息，包括一些相关的启动详细信息，如启动应用程序的用户。如果您的应用程序无法启动，注册
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启动时打印的横幅可以通过将
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}）NAMEANSI转义代码的名称在哪里？见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所以确保添加引号，如果你想在应用程序中禁用横幅。春天： 主要： 横幅模式：“关闭”
如果
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。如果您需要构建一个
ApplicationContext层次结构（具有父/子关系的多个上下文），或者您只是更喜欢使用“流利的”构建器API，则可以使用SpringApplicationBuilder。将
SpringApplicationBuilder让您链在一起的多个方法调用，包括parent和child，让您创建一个层次结构的方法。例如：
新的 SpringApplicationBuilder（） .sources（父类） .child（应用程序类） .bannerMode（Banner.Mode.OFF） .RUN（参数）;
在创建
ApplicationContext层次结构时有一些限制，例如，Web组件必须包含在子上下文中，并且Environment将同时用于父和子上下文。请参阅SpringApplicationBuilderJavadoc了解详细信息。除了通常的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发送AnEnvironment。 ApplicationPreparedEvent在刷新开始之前发送一个，但在bean定义被加载之后。ApplicationReadyEvent在刷新之后发送一个并且已经处理了任何相关的回调以指示应用准备好为请求提供服务。ApplicationFailedEvent如果启动时出现异常，则发送An 。
您通常不需要使用应用程序事件，但可以方便地知道它们存在。在内部，Spring Boot使用事件来处理各种任务。
A
SpringApplication将会尝试以ApplicationContext您的名义创建正确的类型。默认情况下，将使用AnnotationConfigApplicationContext或AnnotationConfigEmbeddedWebApplicationContext将被使用，这取决于您是否正在开发Web应用程序。用于确定“Web环境”的算法相当简单（基于少数类的存在）。
setWebEnvironment(boolean webEnvironment)如果您需要覆盖默认值，您可以使用。也可以完全控制
ApplicationContext将被调用的类型setApplicationContextClass(…)。在JUnit测试中
setWebEnvironment(false)使用时 通常需要调用SpringApplication。如果您需要访问传递给
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注释来注入单个应用程序参数 。如果您需要在启动后运行一些特定的代码
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，则必须按特定顺序调用它们。每个
SpringApplicationJVM都会注册一个关闭钩子，以确保ApplicationContext退出时正常关闭。所有标准的Spring生命周期回调（如DisposableBean接口或@PreDestroy注释）都可以使用。另外，
org.springframework.boot.ExitCodeGenerator如果bean 在应用程序结束时希望返回特定的退出代码，则它们可以实现该接口。可以通过指定
spring.application.admin.enabled属性为应用程序启用与管理相关的功能 。这暴露SpringApplicationAdminMXBean了平台上MBeanServer。您可以使用此功能远程管理您的Spring Boot应用程序。这对于任何服务包装实现也是有用的。如果您想知道应用程序在哪个HTTP端口上运行，请使用密钥获取该属性
local.server.port。启用此功能时要小心，因为MBean公开了一种关闭应用程序的方法。
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。这
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是最大（独占）。默认情况下，
SpringApplication会将任何命令行选项参数（以' - '开头--server.port=9000）转换为property并添加到Spring中Environment。如上所述，命令行属性总是优先于其他属性源。如果您不想将命令行属性添加到
Environment您可以使用禁用它们SpringApplication.setAddCommandLineProperties(false)。SpringApplication将从application.properties以下位置的文件加载属性并将其添加到SpringEnvironment：- 一个
/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.propertiesspring.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上下文初始化参数，而不是使用环境变量或系统属性。除
application.properties文件外，还可以使用命名约定来定义配置文件特定的属性application-{profile}.properties。在Environment具有一组默认的配置文件（默认情况下[default]，如果没有激活的配置文件设置其中使用）（即，如果配置文件没有显式地激活然后从属性application-default.properties加载）。特定于配置文件的属性是从标准的相同位置加载的
application.properties，配置文件特定的文件总是覆盖非特定的文件，而不管配置文件特定的文件是在打包的jar内还是外部。如果指定了多个配置文件，则应用最后一个赢取策略。例如，由
spring.profiles.active属性指定的配置文件将添加到通过SpringApplicationAPI 配置的配置文件之后，因此优先。如果您已经指定了任何文件
spring.config.location，则不会考虑这些文件的特定于配置文件的变体。如果您还想使用配置文件特定的属性，请使用`spring.config.location`中的目录。这些值在
application.properties被使用的Environment时候会被现有的过滤掉，所以你可以返回到以前定义的值（例如从系统属性中）。app.name = MyApp app.description = $ {app.name}是一个Spring Boot应用程序
您也可以使用这种技术来创建现有Spring Boot属性的“简短”变体。有关详细信息，请参见第72.4节“使用简短的命令行参数”。
YAML是JSON的超集，因此是用于指定分层配置数据的非常方便的格式。该
SpringApplication课程将自动支持YAML作为一种替代性，只要你有 SnakeYAML在classpath库。如果使用“Starter”，SnakeYAML将会自动提供
spring-boot-starter。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; } }
这个
YamlPropertySourceLoader类可以用来在YAML中作为PropertySourceSpring的一个Environment。这使您可以使用@Value带有占位符语法的熟悉注释来访问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”元素指定的弹簧配置文件可以有选择地使用该
!字符进行否定。如果为单个文档指定了否定配置文件和非否定配置文件，则至少有一个非否定配置文件必须匹配，且否定配置文件可能不匹配。正如我们上面看到的，任何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）。使用
@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，可以被强制的类型Stringfoo.security.username，一个嵌套的“安全”，其名称由财产的名称决定。特别是返回类型没有在那里使用，本来可以的SecurityPropertiesfoo.security.passwordfoo.security.roles，与一个集合String
getters和setter通常是强制的，因为绑定是通过标准的Java Beans属性描述符来完成的，就像在Spring MVC中一样。在某些情况下，可以省略setter：
- 地图，只要他们被初始化，需要一个getter，但不一定是一个setter，因为他们可以被活页夹变异。
- 集合和数组可以通过索引（通常使用YAML）或使用单个逗号分隔值（属性）来访问。在后一种情况下，二传手是强制性的。我们建议始终为这种类型添加一个setter。如果初始化一个集合，确保它不是不可变的（如上例）
- 如果嵌套的POJO属性被初始化（如
Security上面例子中的字段），则不需要setter。如果您希望活页夹使用其默认构造函数即时创建实例，则需要一个setter。
有些人使用Project Lombok来自动添加getter和setter。确保Lombok不会为这种类型生成任何特定的构造函数，因为它将被容器自动使用来实例化对象。
您还需要列出要在
@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，配置元数据附录。除了使用
@ConfigurationProperties注释类之外，您还可以在公共@Bean方法中使用它。如果要将属性绑定到不受控制的第三方组件，这可能特别有用。要从
Environment属性配置一个bean ，添加@ConfigurationProperties到它的bean注册：@ConfigurationProperties（prefix =“bar”） @Bean public BarComponent barComponent（）{ ... }
用
bar前缀定义的任何属性都将以与上例BarComponent类似的方式映射到该beanFooProperties上。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大写格式。建议使用系统环境变量时。
当它绑定到
@ConfigurationPropertiesbean 时，Spring将试图强制外部应用程序属性为正确的类型。如果您需要自定义类型转换，您可以提供一个ConversionServicebean（带有bean idconversionService）或自定义属性编辑器（通过CustomEditorConfigurerbean）或自定义Converters（带有注释为的bean定义@ConfigurationPropertiesBinding）。由于这个bean在应用程序生命周期中很早被请求，因此请确保限制您
ConversionService正在使用的依赖关系。通常情况下，您需要的任何依赖项可能在创建时未完全初始化。ConversionService如果不需要配置密钥强制，只需要依靠自定义转换器，就可以重命名自定义@ConfigurationPropertiesBinding。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定义 来添加一个自定义的SpringconfigurationPropertiesValidator。该@Bean方法应该声明static。配置属性验证器是在应用程序生命周期的早期创建的，并且声明@Bean方法为静态的，允许创建bean而不必实例化@Configuration类。这避免了可能由于实例化提前而导致的任何问题。有一个 属性验证示例，所以你可以看到如何设置的东西。该
spring-boot-actuator模块包含一个暴露所有@ConfigurationPropertiesbean 的端点 。只需将您的Web浏览器指向/configprops或使用等效的JMX端点即可。请参阅 生产准备功能。部分的细节。@Value是一个核心容器功能，它不提供类型安全的配置属性相同的功能。下表总结了@ConfigurationProperties和所支持的功能@Value：如果您为自己的组件定义了一组配置密钥，我们建议您将它们分组在POJO注释
@ConfigurationProperties。另请注意，由于@Value不支持轻松绑定，如果您需要使用环境变量提供值，它不是一个好的选择。最后，尽管您可以在其中编写
SpEL表达式@Value，但是这些表达式不会从应用程序属性文件处理。Spring Profiles提供了一种分离部分应用程序配置的方法，并使其仅在特定环境中可用。任何
@Component或@Configuration可以标记@Profile以限制何时加载：@Configuration @Profile（“production”） public class ProductionConfiguration { // ... }
以普通的Spring方式，您可以使用
spring.profiles.activeEnvironment属性来指定哪些配置文件处于活动状态。您可以用任何常用的方式指定属性，例如，您可以将其包含在application.properties：spring.profiles.active = dev，hsqldb
或使用开关在命令行中指定
--spring.profiles.active=dev,hsqldb。该
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节“根据环境更改配置”。您可以通过
SpringApplication.setAdditionalProfiles(…)在应用程序运行之前调用以编程方式设置活动配置 使用Spring的ConfigurableEnvironment界面也可以激活配置文件。application.properties（或application.yml）和通过引用的文件的特定于配置文件的变体@ConfigurationProperties被视为加载文件。有关详细信息，请参见第24.4节“配置文件特定属性”。Spring Boot使用Commons Logging进行所有内部日志记录，但是将底层日志实现保留为打开状态。为Java Util Logging， Log4J2和Logback提供了默认配置 。在每种情况下，记录器都预先配置为使用控制台输出，可选的文件输出也可用。
默认情况下，如果使用“Starter”，Logback将用于日志记录。还包括适当的Logback路由，以确保使用Java Util日志记录，Commons日志记录，Log4J或SLF4J的相关库都能正常工作。
Java有很多可用的日志框架。如果上面的列表看起来很混乱，请不要担心。一般来说，你不需要改变日志的依赖关系，Spring Boot的默认设置就可以正常工作。
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）默认日志配置会在写入消息时将消息回送到控制台。默认情况下
ERROR，WARN和INFO级别的消息被记录。你也可以通过启动一个--debug标志来启动你的应用程序来启用“调试”模式。$ java -jar myapp.jar --debug你也可以
debug=true在你的指定application.properties。当启用调试模式时，会选择一些核心记录器（嵌入式容器，Hibernate和Spring Boot）来输出更多的信息。启用调试模式并 没有配置您的应用程序记录所有消息
DEBUG的水平。或者，您可以启用一个“跟踪”模式，通过一个
--trace标志（或trace=true在您的application.properties）启动您的应用程序 。这将启用对核心记录器（嵌入式容器，Hibernate模式生成和整个Spring产品组合）选择的跟踪记录。如果您的终端支持ANSI，则会使用彩色输出来提高可读性。您可以设置
spring.output.ansi.enabled为 支持的值来覆盖自动检测。颜色编码是使用
%clr转换字配置的。在最简单的形式中，转换器将根据日志级别为输出着色，例如：％CLR（％5P）日志级别与颜色的映射如下所示：
水平 颜色 FATAL红
ERROR红
WARN黄色
INFO绿色
DEBUG绿色
TRACE绿色
或者，您可以通过提供转换选项来指定应使用的颜色或样式。例如，要使文本变成黄色：
％clr（％d {yyyy-MM-dd HH：mm：ss.SSS}）{yellow}支持以下颜色和样式：
bluecyanfaintgreenmagentaredyellow
默认情况下，Spring Boot将只能登录到控制台，不会写入日志文件。如果除了输出控制台之外还想写日志文件，你需要设置一个
logging.file或者一个logging.path属性（比如你的application.properties）。下表显示了这些
logging.*属性如何一起使用：表26.1。记录属性
logging.filelogging.path例 描述 （没有）
（没有）
仅限控制台日志。
具体文件
（没有）
my.log写入指定的日志文件。名称可以是一个确切的位置或相对于当前目录。
（没有）
具体的目录
/var/log写入
spring.log指定的目录。名称可以是一个确切的位置或相对于当前目录。
日志文件在达到10 MB时将会旋转，并且与控制台输出一样
ERROR，WARN并且INFO默认情况下会记录级别消息。日志记录系统在应用程序生命周期的早期初始化，因此在通过
@PropertySource注释加载的属性文件中不会找到这样的日志记录属性。日志记录属性独立于实际的日志记录基础结构。因此，特定的配置键（如
logback.configurationFileLogback）不受Spring Boot的管理。所有支持的日志记录系统都可以使用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有关如何在自己的配置中应用重新映射的详细信息。可以通过在类路径中包含适当的库来激活各种日志记录系统，并且可以通过在类路径的根目录中或者在由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.groovyLog4j2
log4j2-spring.xml要么log4j2.xmlJDK（Java Util日志记录）
logging.properties在可能的情况下，我们建议您使用
-spring变体进行日志配置（例如，logback-spring.xml而不是logback.xml）。如果使用标准配置位置，Spring将无法完全控制日志初始化。Java Util Logging存在已知的类加载问题，从“可执行jar”运行时会导致问题。我们建议您尽可能避免它。
为了帮助定制，一些其他的属性从Spring传递
Environment给System属性：春天的环境 系统属性 注释 logging.exception-conversion-wordLOG_EXCEPTION_CONVERSION_WORD记录异常时使用的转换字。
logging.fileLOG_FILE用于默认日志配置（如果已定义）。
logging.pathLOG_PATH用于默认日志配置（如果已定义）。
logging.pattern.consoleCONSOLE_LOG_PATTERN在控制台上使用的日志模式（stdout）。（仅支持默认的登录设置。）
logging.pattern.fileFILE_LOG_PATTERN在文件中使用的日志模式（如果启用LOG_FILE）。（仅支持默认的登录设置。）
logging.pattern.levelLOG_LEVEL_PATTERN用于呈现日志级别的格式（默认
%5p）。（仅支持默认的登录设置。）PIDPID当前的进程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 处理认证的请求
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]]
该
<springProfile>标签允许您根据活动的Spring配置文件选择性地包含或排除部分配置。<configuration>元素中的任何位置都支持Profile部分。使用该name属性来指定哪个配置文件接受配置。可以使用逗号分隔列表指定多个配置文件。<springProfile name = “staging” > <！ - 当“暂存”配置文件处于活动状态时要启用的配置 - > </ springProfile> <springProfile name = “dev，staging” > <！ - 在“dev”或“staging”配置文件处于活动状态时启用的配置 - > </ springProfile> <springProfile name = “！production” > <！ - 当“production”配置文件未激活时要启用的配置 - > </ springProfile>
该
<springProperty>标签允许您在SpringEnvironment中使用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等）。Spring Boot非常适合Web应用程序的开发。您可以使用嵌入式Tomcat，Jetty或Undertow轻松创建自包含的HTTP服务器。大多数Web应用程序将使用该
spring-boot-starter-web模块快速启动并运行。如果您还没有开发Spring Boot Web应用程序，则可以按照“Hello World！”进行操作。例如在 入门部分。
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。
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。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都将被添加到转换器列表中。您也可以通过这种方式覆盖默认转换器。如果您使用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> { // ... } }
所有的
@JsonComponentbeanApplicationContext都将自动注册到Jackson，并且由于@JsonComponent是用元注释的@Component，通常的组件扫描规则适用。春季启动也提供
JsonObjectSerializer和JsonObjectDeserializer基类，其序列化对象时提供标准版本的杰克逊有用的替代。有关详细信息，请参阅Javadoc。Spring MVC有一个策略来生成错误代码，用于从绑定错误中呈现错误消息
MessageCodesResolver。如果您设置了spring.mvc.message-codes-resolver.format属性PREFIX_ERROR_CODE或POSTFIX_ERROR_CODE（参见枚举DefaultMessageCodesResolver.Format），Spring Boot将为您创建一个。默认情况下，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 = / **
在模板中，资源链接在运行时被重写，这要归功于
ResourceUrlEncodingFilterThymeleaf和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 MVC使用a
WebBindingInitializer来初始化WebDataBinder一个特定的请求。如果你自己创建ConfigurableWebBindingInitializer@Bean，Spring Boot会自动配置Spring MVC来使用它。除了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/。Spring Boot provides an
/errormapping 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 aViewthat resolves to ‘error’). To replace the default behaviour completely you can implementErrorControllerand register a bean definition of that type, or simply add a bean of typeErrorAttributesto 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由在同一个包中定义的控制器抛出，将使用POJOFooController的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的应用程序，可以使用该
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调度程序类型）。如果您正在开发一个使用超媒体的RESTful API，Spring Boot为Spring HATEOAS提供了自动配置，可以与大多数应用程序配合使用。自动配置取代了使用
@EnableHypermediaSupport和注册大量bean的需求，以便构建基于超媒体的应用程序，包括LinkDiscoverers（用于客户端支持）和被ObjectMapper配置为将响应正确地编组到所需表示中。在ObjectMapper将根据定制spring.jackson.*的属性或者Jackson2ObjectMapperBuilder如果存在豆。你可以通过使用控制Spring HATEOAS的配置
@EnableHypermediaSupport。请注意，这将禁用上述ObjectMapper定制。跨源资源共享 （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 / **”）; } }; } }
如果您更喜欢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资源打包为嵌套罐，则可能需要执行相同的操作。Spring Boot包含对嵌入式Tomcat，Jetty和Undertow服务器的支持。大多数开发人员只需使用适当的“Starter”来获取完全配置的实例。默认情况下，嵌入式服务器将侦听端口上的HTTP请求
8080。如果您选择在CentOS上使用Tomcat，请注意，默认情况下会使用一个临时目录来存储已编译的JSP，文件上传等。
tmpwatch当您的应用程序运行导致失败时，可能会删除此目录。为了避免这种情况，您可能需要自定义tmpwatch配置，以便tomcat.*不删除目录，或者进行配置，server.tomcat.basedir以便嵌入式Tomcat使用不同的位置。使用嵌入式servlet容器时，可以
HttpSessionListener通过使用Spring bean或通过扫描Servlet组件来注册Servlet规范（例如Servlet规范）中的所有监听器。任何
Servlet，Filter或者Servlet*Listener实例，它是一个Spring bean将与嵌入容器注册。如果要application.properties在配置期间引用您的值，这可能会特别方便。默认情况下，如果上下文只包含一个Servlet，它将被映射到
/。在多个Servlet bean的情况下，bean名称将被用作路径前缀。过滤器将映射到/*。如果以公约为基础测绘不够灵活，你可以使用
ServletRegistrationBean，FilterRegistrationBean而ServletListenerRegistrationBean类的完全控制。嵌入式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如果需要的话，可以容易地用作现有适配器。Spring Boot使用了一种新的
ApplicationContext用于嵌入式servlet容器的支持。这EmbeddedWebApplicationContext是一种特殊的类型WebApplicationContext，它通过搜索一个EmbeddedServletContainerFactorybean 来引导自己 。通常一个TomcatEmbeddedServletContainerFactory，JettyEmbeddedServletContainerFactory或者UndertowEmbeddedServletContainerFactory将会自动配置。您通常不需要知道这些实现类。大多数应用程序将自动配置
ApplicationContext，EmbeddedServletContainerFactory并将以您的名义创建适当的应用程序。通用的servlet容器设置可以使用Spring
Environment属性进行配置。通常你会在你的application.properties文件中定义属性。通用服务器设置包括：
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）; } }
如果上面的定制技术太有限，你可以注册
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”））; 退货工厂; }
安装程序提供了许多配置选项。还提供了几个受保护的方法“钩子”，如果你需要做更奇特的事情。有关详细信息，请参阅源代码文档。
如果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（这不会禁用身份验证管理器配置或执行器的安全性）。要定制它，通常使用外部属性和类型的beanWebSecurityConfigurerAdapter（例如添加基于表单的登录）。要关闭身份验证管理器配置，您可以添加一个类型的beanAuthenticationManager，或者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的自动配置的访问规则，则您的适配器必须显式配置您想覆盖的路径。如果你有
spring-security-oauth2你的类路径，你可以利用一些自动配置，以便设置授权或资源服务器。有关完整的详细信息，请参阅Spring Security OAuth 2开发人员指南。要创建授权服务器并授予您需要使用
@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。要使用访问令牌，您需要一个资源服务器（可以与授权服务器相同）。创建资源服务器很简单，只需添加
@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基本上）。Google和某些其他第三方身份提供商对标头中发送给用户信息端点的标记类型名称更为严格。默认是“承载”，适合大多数提供者，并符合规范，但如果你需要改变它，你可以设置
security.oauth2.resource.token-type。如果有
user-info-uri，资源服务器功能使用OAuth2RestTemplate内部获取用户详细信息进行身份验证。这是作为一种@Bean类型提供的UserInfoRestTemplateFactory。对于大多数提供者来说，默认值应该是可以的，但是偶尔你可能需要添加额外的拦截器，或者改变请求认证者（这是令牌被附加到传出请求的方式）。要添加一个自定义，只需创建一个类型的beanUserInfoRestTemplateCustomizer- 它有一个方法，在bean被创建之后但在被初始化之前被调用。这里正在定制的其余模板仅用于内部执行身份验证。或者，你可以定义你自己的UserInfoRestTemplateFactory@Bean完全控制。要在YAML中设置一个RSA键值，使用“管道”连续标记将其分割成多行（“|”）并记住缩进键值（这是一个标准的YAML语言功能）。例：
安全性： oauth2： 资源： jwt： keyValue：| ----- BEGIN PUBLIC KEY ----- MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC ... -----结束公钥-----
为了让您的网络应用程序成为一个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从配置中删除（或使其成为空字符串）。可以使用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（）; } }
如果执行器也在使用中，您会发现：
- 即使应用程序端点不安全，管理端点也是安全的。
- 安全事件被转换成
AuditEvent实例并发布给AuditEventRepository。 - 默认用户将具有
ACTUATOR角色以及USER角色。
执行器安全功能可以使用外部属性（
management.security.*）进行修改。要覆盖应用程序访问规则添加一个@Bean类型的WebSecurityConfigurerAdapter和使用@Order(SecurityProperties.ACCESS_OVERRIDE_ORDER)，如果你不希望覆盖驱动器的访问规则，或者@Order(ManagementServerProperties.ACCESS_OVERRIDE_ORDER)如果你不希望覆盖驱动器的访问规则。Spring框架为使用SQL数据库提供了广泛的支持。从使用直接JDBC访问
JdbcTemplate到完成“对象关系映射”技术（如Hibernate）。Spring Data提供了额外的功能级别，Repository直接从接口创建实现，并使用约定从方法名称中生成查询。Java的
javax.sql.DataSource接口提供了使用数据库连接的标准方法。传统上，DataSource使用URL一些凭据来建立数据库连接。检查更多高级示例的“操作方法”部分，通常要完全控制DataSource的配置。
使用内存嵌入式数据库开发应用程序通常很方便。显然，内存数据库不提供持久性存储; 您将需要在应用程序启动时填充数据库，并准备在应用程序结束时丢弃数据。
“操作方法”部分包含有关如何初始化数据库的一节
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控制何时关闭数据库，从而确保在不再需要访问数据库时发生。生产数据库连接也可以使用池进行自动配置
DataSource。以下是选择特定实现的算法：- 我们更喜欢Tomcat池
DataSource的性能和并发性，所以如果可用，我们总是选择它。 - 否则，如果HikariCP可用，我们将使用它。
- 如果Tomcat池数据源和HikariCP都不可用，并且Commons DBCP可用，我们将使用它，但我们不建议在生产中使用它，并且不支持它。
- 最后，如果Commons DBCP2可用，我们将使用它。
如果你使用
spring-boot-starter-jdbcorspring-boot-starter-data-jpastarters，你会自动获得依赖tomcat-jdbc。您可以完全绕过该算法，并通过
spring.datasource.type属性指定要使用的连接池。如果您在tomcat-jdbc默认情况下提供的Tomcat容器中运行应用程序，这一点尤其重要。其他连接池可以始终手动配置。如果你定义你自己的
DataSourcebean，自动配置将不会发生。数据源配置由外部配置属性控制
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
如果您将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
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; } // ... }
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示例以了解如何执行此操作。
传统上，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配置中分离@实体定义”。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的表面。有关完整的详细检查他们的参考文档。
默认情况下，只有在使用嵌入式数据库（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设置更加细化了。如果你正在运行一个web应用程序，Spring Boot将默认注册
OpenEntityManagerInViewInterceptor应用“Open EntityManager in View”模式，即允许在web视图中延迟加载。如果你不希望这种行为，你应该设置spring.jpa.open-in-view到false你application.properties。该H2数据库提供了一个 基于浏览器的控制台是春天开机即可自动为您配置。当满足以下条件时，控制台将自动配置：
- 您正在开发一个Web应用程序
com.h2database:h2在类路径上- 您正在使用Spring Boot的开发人员工具
如果你没有使用Spring Boot的开发工具，但是仍然想使用H2的控制台，那么你可以通过配置
spring.h2.console.enabled属性值来实现true。H2控制台仅用于开发过程中，因此请注意确保spring.h2.console.enabled不会true在生产中使用。Java面向对象查询（jOOQ）是Data Geekery的一个流行产品， 它可以从您的数据库中生成Java代码，并允许您通过其流畅的API来构建类型安全的SQL查询。商业和开源版本都可以和Spring Boot一起使用。
为了使用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>
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）; }
您可以通过
spring.jooq.sql-dialect在您的设置中自定义jOOQ使用的SQL方言application.properties。例如，要指定Postgres，您可以添加：spring.jooq.sql-dialect = Postgres
更高级的定制可以通过定义你自己的
@Bean定义来实现，这些定义将在jOOQConfiguration创建时使用。您可以为以下jOOQ类型定义bean：ConnectionProviderTransactionProviderRecordMapperProviderRecordListenerProviderExecuteListenerProviderVisitListenerProvider
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上的相应参考文档 。
Redis是一个缓存，消息代理和功能丰富的键值存储。Spring Boot为Jedis客户端库和Spring Data Redis提供的抽象类提供基本的自动配置 。有一个
spring-boot-starter-data-redis“Starter”以方便的方式收集依赖关系。你可以注入一个自动配置的
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是在类路径中，默认情况下会得到一个池连接工厂。MongoDB是一个开源NoSQL文档数据库，它使用类似JSON的模式而不是传统的基于表格的关系数据。Spring Boot为MongoDB提供了一些便利，包括
spring-boot-starter-data-mongodb“Starter”。你可以注入一个自动配置
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：secret@mongo1.example.com ：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.Mongobean而不是使用MongoDbFactory。如果要完全控制建立MongoDB连接，还可以声明自己的
MongoDbFactory或Mongobean。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。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的完整详细信息，包括丰富的对象映射技术，请参阅其参考文档。
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实例的配置和日志路由。Neo4j是一个开放源代码的NoSQL图形数据库，它使用由一级关系相关的丰富的节点数据模型，比传统的rdbms方法更适合于连接大数据。Spring Boot为使用Neo4j提供了一些便利，包括
spring-boot-starter-data-neo4j“Starter”。你可以注入的自动配置
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
如果添加
org.neo4j:neo4j-ogm-embedded-driver到应用程序的依赖项中，Spring Boot将自动配置Neo4j的进程中嵌入式实例，在应用程序关闭时不会保留任何数据。您可以使用显式禁用该模式spring.data.neo4j.embedded.enabled=false。您也可以为嵌入模式启用持久性：spring.data.neo4j.uri =文件：//var/tmp/graph.db默认情况下，如果您正在运行Web应用程序，则会话将被绑定到线程以进行整个请求处理（即“打开会话在视图中”模式）。如果您不想要这种行为，请将以下内容添加到您的
application.properties：spring.data.neo4j.open式视=假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
包 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的完整详细信息，包括丰富的对象映射技术，请参阅其参考文档。
Spring Data Gemfire为访问Pivotal Gemfire数据管理平台提供了方便Spring的工具 。有一个
spring-boot-starter-data-gemfire“Starter”以方便的方式收集依赖关系。目前没有Gemfire的自动配置支持，但你可以使用单个注释（@EnableGemfireRepositories）来启用Spring Data Repositories 。Apache Solr是一个搜索引擎。Spring Boot为Solr 5客户端库和Spring Data Solr提供的抽象类提供基本的自动配置 。有一个
spring-boot-starter-data-solr“Starter”以方便的方式收集依赖关系。您可以像注入
SolrClient其他Spring bean一样注入一个自动配置的实例。默认情况下，实例将尝试使用localhost:8983/solr以下命令连接到服务器 ：@Component 公共 类 MyBean { 私有的 SolrClient solr; @Autowired public MyBean（SolrClient solr）{ this .solr = solr; } // ... }
如果你添加一个
@Bean你自己的类型，SolrClient它会替换默认的。Spring Data包含Apache Solr的存储库支持。和前面讨论的JPA库一样，基本的原则是查询是基于方法名自动为你构建的。
实际上，Spring Data JPA和Spring Data Solr共享相同的通用基础结构; 所以你可以从之前的JPA例子中，假设
City现在是一个@SolrDocument类而不是JPA@Entity，它将以同样的方式工作。有关Spring Data Solr的完整详细信息，请参阅其 参考文档。
Elasticsearch是一个开源的，分布式的实时搜索和分析引擎。Spring Boot为弹性数据Elasticsearch提供的Elasticsearch和抽象类提供了基本的自动配置 。有一个
spring-boot-starter-data-elasticsearch“Starter”以方便的方式收集依赖关系。Spring Boot也支持 Jest。如果您有
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。你可以注入一个自动配置的
ElasticsearchTemplate或ElasticsearchClient实例，就像其他的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它会替换默认的。Spring Data包含Elasticsearch的存储库支持。和前面讨论的JPA库一样，基本的原则是查询是基于方法名自动为你构建的。
实际上，Spring Data JPA和Spring Data Elasticsearch共享相同的通用基础结构; 所以你可以从之前的JPA例子中，假设
City现在是Elasticsearch@Document类而不是JPA@Entity，它将以相同的方式工作。有关Spring Data Elasticsearch的完整详细信息，请参阅其 参考文档。
Cassandra是一个开源的分布式数据库管理系统，用于处理大量商品服务器上的大量数据。Spring Boot提供了Cassandra的自动配置和Spring Data Cassandra提供的抽象。有一个
spring-boot-starter-data-cassandra“Starter”以方便的方式收集依赖关系。您可以 像使用其他Spring Bean一样注入自动配置
CassandraTemplate或CassandraSession实例。这些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它会替换默认的。Spring Data包含对Cassandra的基本存储库支持。目前这比前面讨论的JPA存储库更有限，并且需要用查找方法来注释
@Query。有关Spring Data Cassandra的完整详细信息，请参阅其 参考文档。
Couchbase是一个开源的分布式多模型NoSQL面向文档的数据库，针对交互式应用进行了优化。Spring Boot提供了Couchbase的自动配置和Spring Data Couchbase提供的抽象 。有一个
spring-boot-starter-data-couchbase“Starter”以方便的方式收集依赖关系。你可以很容易得到
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.*属性的更多细节。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实现。LDAP（轻量级目录访问协议）是一种开放的，厂商中立的行业标准应用协议，用于通过IP网络访问和维护分布式目录信息服务。Spring Boot为任何兼容的LDAP服务器提供自动配置，并支持来自UnboundID的嵌入式内存LDAP服务器 。
Spring Data LDAP提供LDAP抽象 。有一个
spring-boot-starter-data-ldap“Starter”以方便的方式收集依赖关系。要连接到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属性。Spring Data包含LDAP的存储库支持。有关Spring Data LDAP的完整详细信息，请参阅其 参考文档。
您也可以
LdapTemplate像使用其他Spring Bean一样注入自动配置的实例。@Component 公共 类 MyBean { 私人 最终 LdapTemplate模板; @Autowired public MyBean（LdapTemplate模板）{ this .template = template; } // ... }
出于测试目的，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来定义自定义属性类型或对象类。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自己的缓存注释。我们强烈建议您不要混淆和匹配。
缓存抽象不提供实际的存储，并依赖于
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命名 的beancacheResolver（参见参考资料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预计将被配置。如果不是这样，定制程序将不会被调用。你可以有任意多的定制器，你也可以像往常一样使用@Orderor命令Ordered。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抽象所期望的实现中。没有进一步的定制应用于此。如果
ehcache.xml可以在类路径的根目录找到一个名为的文件，则使用EhCache 2.x。如果EhCache 2.x，EhCacheCacheManager由spring-boot-starter-cache'Starter' 提供， 并且存在这样的文件，它将用于引导缓存管理器。备用配置文件也可以使用：spring.cache.ehcache.config = classpath：config / another-config.xml
Spring Boot 对Hazelcast有广泛的支持。如果a
HazelcastInstance已被自动配置，则会自动包装在a中CacheManager。Infinispan没有默认配置文件位置，因此必须明确指定（或使用默认引导程序）。
spring.cache.infinispan.config = infinispan.xml
缓存可以在启动时通过
spring.cache.cache-names属性创建。如果定义了一个自定义ConfigurationBuilderbean，它将用于自定义它们。如果Couchbase java客户端和
couchbase-spring-cache实现可用并且Couchbase已配置，CouchbaseCacheManager则将自动配置a。也可以使用该spring.cache.cache-names属性在启动时创建额外的缓存。这些将在Bucket自动配置的操作。您可以还创建另一个附加缓存中Bucket使用定制：假设您需要在“主”两个高速缓存Bucket（foo和bar）和一个biz高速缓存使用自定义的时间对生活的2秒anotherBucket。首先，您可以简单地通过配置创建两个第一个缓存：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通过自动配置创建的配置。如果Redis可用并已配置，
RedisCacheManager则会自动配置。也可以使用该spring.cache.cache-names属性在启动时创建额外的缓存。默认情况下，添加一个关键字前缀，以防止如果两个单独的缓存使用相同的密钥，Redis将有重叠的键，并可能返回无效的值。我们强烈建议您在创建自己的设置时保持启用此设置
RedisCacheManager。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>。任何其他泛型类型将被自动配置忽略。如果番石榴存在，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>。任何其他泛型类型将被自动配置忽略。Spring框架为消息系统集成提供了广泛的支持：从简化的JMS API使用
JmsTemplate到完整的基础结构，以便异步接收消息。Spring AMQP为“高级消息队列协议”提供了类似的功能，而Spring Boot也为RabbitTemplateRabbitMQ 提供了自动配置选项。在Spring WebSocket中也支持STOMP消息本身，Spring Boot通过启动器和少量的自动配置支持。Spring Boot也支持Apache Kafka。该
javax.jms.ConnectionFactory接口提供了一个创建javax.jms.Connection与JMS代理交互的标准方法 。虽然Spring需要ConnectionFactory使用JMS，但通常不需要直接使用它，而是可以依赖更高级别的消息抽象（请参阅Spring Framework参考文档的 相关部分以了解详细信息）。Spring Boot还会自动配置发送和接收消息的必要基础结构。当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将创建一个目标，因此目标将根据其提供的名称进行解析。
当Spring Boot
ConnectionFactory检测到Artemis在类路径中可用时，Spring Boot可以自动配置它。如果代理存在，则会自动启动并配置嵌入式代理（除非已明确设置mode属性）。支持的模式是:(embedded明确规定嵌入式代理是必需的，如果代理在类路径中不可用，则会导致错误），并native使用netty传输协议连接到代理。当配置后者时，Spring BootConnectionFactory使用默认设置配置到在本地机器上运行的代理的连接。如果您正在使用
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”属性或通过配置提供的名称来解析目的地的名称。
如果您正在应用程序服务器中运行您的应用程序，Spring Boot将尝试
ConnectionFactory使用JNDI 查找JMS 。默认情况下，位置java:/JmsXA和java:/XAConnectionFactory将被检查。spring.jms.jndi-name如果您需要指定替代位置，则可以使用该 属性：spring.jms.jndi-name = java：/ MyConnectionFactory
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可以以类似的方式注入。如果 定义了aDestinationResolver或MessageConverterbean，它们将自动关联到自动配置JmsTemplate。当存在JMS基础结构时，可以使用注释
@JmsListener来创建侦听器端点。如果没有JmsListenerContainerFactory定义，则默认配置是自动配置的。如果 定义了aDestinationResolver或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）{ // ... } }
高级消息队列协议（AMQP）是面向消息中间件的平台中立的有线协议。Spring AMQP项目将核心Spring概念应用于基于AMQP的消息传递解决方案的开发。Spring Boot为通过RabbitMQ处理AMQP提供了一些便利，包括
spring-boot-starter-amqp“Starter”。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使用的协议了解 更多细节。
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对重试操作启用重试，例如在代理连接丢失的情况下。重试是默认禁用的。当Rabbit基础结构存在时，任何bean都可以被注释
@RabbitListener以创建一个监听端点。如果没有RabbitListenerContainerFactory定义，则默认配置是自动配置的。如果定义了aMessageConverter或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你自己的。当重试耗尽时，如果代理配置如此，则该消息将被拒绝并丢弃或路由到死信交换。重试是默认禁用的。![[重要]](https://i-blog.csdnimg.cn/blog_migrate/cd26aeb4774773c5674107d1cdfef1e1.png)
重要 如果重试未启用，并且侦听器引发异常，默认情况下，传递将无限期地重试。您可以通过两种方式修改此行为; 设置
defaultRequeueRejected财产false和零重新交付将尝试; 或者，发出AmqpRejectAndDontRequeueException信号应该被拒绝。这是启用重试并达到最大传送次数时使用的机制。通过提供
spring-kafka项目的自动配置来支持 Apache Kafka。卡夫卡配置由外部配置属性控制
spring.kafka.*。例如，您可以在以下部分声明以下部分application.properties：spring.kafka.bootstrap-servers = localhost：9092 spring.kafka.consumer.group-id = myGroup
请参阅
KafkaProperties更多支持的选项。Spring的
KafkaTemplate是自动配置的，你可以直接在你自己的bean中自动装配它们：@Component 公共 类 MyBean { 私人 最终 KafkaTemplate kafkaTemplate; @Autowired public MyBean（KafkaTemplate kafkaTemplate）{ this .kafkaTemplate = kafkaTemplate; } // ... }
当存在Apache Kafka基础结构时，可以使用注释
@KafkaListener来创建侦听器端点。如果KafkaListenerContainerFactory未定义，则使用定义的键自动配置默认值spring.kafka.listener.*。以下组件为该
someTopic主题创建一个侦听器端点：@Component 公共 类 MyBean { @KafkaListener（topics =“someTopic”） public void processMessage（String content）{ // ... } }
附录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）; } }
如果您需要从您的应用程序调用远程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()。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被使用。只要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， 作者作者）{ ... } }
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
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自动配置。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也可以用来定制AtomikosUserTransactionServiceImp。有关 完整的详细信息，请参阅AtomikosPropertiesJavadoc。为确保多个事务管理器可以安全地协调相同的资源管理器，必须为每个Atomikos实例配置一个唯一的ID。默认情况下，这个ID是运行Atomikos的机器的IP地址。为确保生产中的唯一性，您应该
spring.jta.transaction-manager-id为每个应用程序实例配置一个不同的值。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为每个应用程序实例配置一个不同的值。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为每个应用程序实例配置 一个不同的值。如果您正在打包春季启动应用程序作为
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。使用JTA时，主要的JMS
ConnectionFactorybean将被XA感知并参与分布式事务。在某些情况下，您可能需要使用非XA来处理某些JMS消息ConnectionFactory。例如，您的JMS处理逻辑可能需要比XA超时更长的时间。如果你想使用非XA，
ConnectionFactory你可以注入nonXaJmsConnectionFactorybean而不是@PrimaryjmsConnectionFactorybean。为了保持一致性，jmsConnectionFactory还使用bean别名提供了beanxaJmsConnectionFactory。例如：
//注入主（XA知道）ConnectionFactory @Autowired 私有 ConnectionFactory defaultConnectionFactory; //注入XA感知的ConnectionFactory（使用别名并注入相同） @Autowired @Qualifier（“xaJmsConnectionFactory”） private ConnectionFactory xaConnectionFactory; //注入非XA感知的ConnectionFactory @Autowired @Qualifier（“nonXaJmsConnectionFactory”） private ConnectionFactory nonXaConnectionFactory;
该
XAConnectionFactoryWrapper和XADataSourceWrapper接口可用于支持替代嵌入式事务经理。该接口是负责包装XAConnectionFactory和XADataSource豆类，把它们作为普通ConnectionFactory和DataSource豆类将在分布式事务透明报名。只要你有一个JtaTransactionManagerbean和适当的XA包装bean注册在你的数据库中，DataSource和JMS自动配置将使用JTA变体ApplicationContext。该BitronixXAConnectionFactoryWrapper 和BitronixXADataSourceWrapper 提供了如何编写XA包装很好的例子。
如果类路径中有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如果启用缓存实现。Spring Boot为Spring Integration提供了一些便利，包括
spring-boot-starter-integration“Starter”。Spring Integration提供了对消息传递和其他传输（如HTTP，TCP等）的抽象。如果Spring集成在你的类路径中可用，它将通过@EnableIntegration注释初始化 。如果消息处理统计信息'spring-integration-jmx'也在类路径上，则会通过JMX发布。查看IntegrationAutoConfiguration班级了解更多详情。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
Java管理扩展（JMX）提供了一个标准机制来监视和管理应用程序。默认情况下，春季启动将创建一个
MBeanServer豆ID“的MBeanServer”，揭露你的任何豆被标注有春天JMX注释（@ManagedResource，@ManagedAttribute，@ManagedOperation）。查看
JmxAutoConfiguration班级了解更多详情。Spring Boot提供了许多实用程序和注释来帮助您测试应用程序。测试支持由两个模块提供;
spring-boot-test包含核心项目，并spring-boot-test-autoconfigure支持自动配置测试。大多数开发人员只需使用
spring-boot-starter-test“Starter”，它可以导入两个Spring Boot测试模块以及JUnit，AssertJ，Hamcrest和其他一些有用的库。如果您使用
spring-boot-starter-test“入门”（在testscope）中，您将找到以下提供的库：默认情况下，Spring Boot使用Mockito 1.x. 但是，如果你愿意，也可以使用2.x。
这些是我们通常在编写测试时觉得有用的常用库。如果这些不符合您的需求，您可以自由添加您自己的附加测试依赖项。
依赖注入的一个主要优点是它应该使你的代码更容易进行单元测试。你
new甚至可以使用操作符实例化对象，甚至不涉及Spring。您也可以使用模拟对象而不是真正的依赖关系。通常你需要超越“单元测试”，开始“集成测试”（
ApplicationContext实际上涉及到Spring的一个Spring ）。能够在不需要部署应用程序或不需要连接到其他基础架构的情况下执行集成测试就很有用。Spring Framework包含一个专门用于这种集成测试的测试模块。你可以直接声明一个依赖
org.springframework:spring-test或者使用spring-boot-starter-test'Starter'来传递它。如果您
spring-test在阅读Spring框架参考文档的相关部分之前已经没有使用该模块 。一个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)到您的测试，否则注释将被忽略。如果您熟悉Spring Test Framework，那么您可能习惯于使用
@ContextConfiguration(classes=…)它来指定@Configuration要加载哪个Spring 。或者，您可能经常@Configuration在测试中使用嵌套类。在测试Spring Boot应用程序时，这通常不是必需的。Spring Boot的
@*Test注释会自动搜索你的主要配置，只要你没有明确的定义。搜索算法从包含测试的包直到找到
@SpringBootApplication或@SpringBootConfiguration注释类。只要你 以合理的方式构建你的代码，你的主要配置通常是可以找到的。如果你想定制主配置，你可以使用嵌套
@TestConfiguration类。与@Configuration将使用嵌套类而不是应用程序的主配置不同，@TestConfiguration除了应用程序的主配置之外，还将使用嵌套类。Spring的测试框架将缓存测试之间的应用程序上下文。因此，只要您的测试共享相同的配置（不管它如何被发现），加载上下文的潜在的耗时过程将只发生一次。
如果您的应用程序使用组件扫描，例如，如果您使用
@SpringBootApplication或@ComponentScan，您可能会发现只为特定测试创建的组件或配置意外地被拾取到处。为了防止这种情况发生，Spring Boot提供 了可以在类中使用的注释
@TestComponent和@TestConfiguration注释，src/test/java指出不应该通过扫描来拾取它们。@TestComponent而@TestConfiguration只需要在顶层类。如果你在测试中定义@Configuration或@Component作为内部类（任何具有@Test方法的类@RunWith），它们将被自动过滤。如果你直接使用
@ComponentScan（即不通过@SpringBootApplication），你将需要注册TypeExcludeFilter与它。有关详细信息，请参阅 Javadoc。如果您需要启动完整的运行服务器进行测试，我们建议您使用随机端口。如果你使用
@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”）; } }
运行测试时有时需要在应用程序上下文中模拟某些组件。例如，您可能对开发期间不可用的某个远程服务有一个正面。当你想模拟在真实环境中很难触发的故障时，模拟也是有用的。
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来包装任何现有的beanspy。请参阅Javadoc了解详细信息。Spring Boot的自动配置系统适用于应用程序，但有时可能对测试有点太多。只加载测试应用程序的“切片”所需的配置部分通常很有帮助。例如，您可能想要测试Spring MVC控制器是否正确映射了URL，并且您不希望在这些测试中涉及数据库调用; 或者您可能想要测试JPA实体，并且在这些测试运行时您对web层不感兴趣。
该
spring-boot-test-autoconfigure模块包括一些可以用来自动配置这些“切片”的注释。它们中的每一个都以类似的方式工作，提供@…Test加载注释ApplicationContext和一个或多个@AutoConfigure…可用于自定义自动配置设置的注释。每个切片加载一组非常有限的自动配置类。如果您需要排除其中的一个，则大多数
@…Test注释都会提供一个excludeAutoConfiguration属性。或者，您可以使用@ImportAutoConfiguration#exclude。也可以使用
@AutoConfigure…带有标准@SpringBootTest注释的注释。如果您对“切片”应用程序不感兴趣，但想要一些自动配置的测试bean，则可以使用此组合。要测试对象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可以 在附录中找到启用的自动配置列表。为了测试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会把
WebDriverbean放在一个特殊的“范围”中，以确保每次测试后驱动程序都退出，并注入新的实例。如果你不想要这种行为，你可以添加@Scope("singleton")到你的WebDriver@Bean定义。@WebMvcTest可以 在附录中找到启用的自动配置列表。@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测试也可能注入一个
TestEntityManagerbean，它提供了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可以 在附录中找到启用的自动配置列表。@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可以 在附录中找到启用的自动配置列表。@DataMongoTest可以用来测试MongoDB应用程序。默认情况下，它将配置内存中嵌入的MongoDB（如果可用），配置aMongoTemplate，扫描@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可以 在附录中找到启用的自动配置列表。的
@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可以 在附录中找到启用的自动配置列表。的
@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}”）; } }
如果你想使用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通用的一部分。ConfigFileApplicationContextInitializer是一个ApplicationContextInitializer可以用来加载Spring Bootapplication.properties文件的测试。当你不需要所提供的全部功能时，你可以使用它@SpringBootTest。@ContextConfiguration（classes =配置类， 初始化器= ConfigFileApplicationContextInitializer。类）
ConfigFileApplicationContextInitializer单独使用不会为@Value("${…}")注射提供支持 。它唯一的工作是确保application.properties文件被加载到Spring中Environment。对于@Value支持，您需要另外配置一个PropertySourcesPlaceholderConfigurer或使用@SpringBootTest自动为您配置的地方。EnvironmentTestUtils允许您快速添加属性到ConfigurableEnvironment或ConfigurableApplicationContext。只需用key=value字符串调用它 ：EnvironmentTestUtils.addEnvironment（env，“org = Spring”，“name = Boot”）;
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”））; } }
TestRestTemplate是Spring的一个方便的选择，RestTemplate在集成测试中很有用。您可以获得一个香草模板或一个发送基本HTTP认证（使用用户名和密码）的模板。在任何一种情况下，模板都将以一种友好的方式运行：不遵循重定向（所以你可以断言响应位置），忽略cookie（所以模板是无状态的），并且不会在服务器端错误上抛出异常。建议使用Apache HTTP Client（版本4.3.2或更高版本），但不是强制性的，如果你的类路径上有这个，HTTPTestRestTemplate会通过适当地配置客户端来响应。公共 类 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（...）; } } }
Spring Boot为嵌入式Tomcat（8和7），Jetty 9和Undertow提供WebSockets自动配置。如果您将war文件部署到独立容器，Spring Boot会假定该容器将负责配置其WebSocket支持。
Spring Framework提供了丰富的WebSocket支持，可以通过
spring-boot-starter-websocket模块轻松访问。Spring Boot提供Web服务自动配置，以便所有需要定义您的
Endpoints。在春天的Web服务功能可以通过方便地访问
spring-boot-starter-webservices模块。如果您在开发共享库的公司工作，或者如果您在开源或商业库上工作，则可能需要开发自己的自动配置。自动配置类可以捆绑在外部的瓶子里，并且仍然可以被Spring Boot找到。
自动配置可以与提供自动配置代码的“启动器”以及您将使用的典型库相关联。我们将首先介绍您需要知道的构建自己的自动配置，然后我们将继续执行创建自定义启动器所需的 典型步骤。
一个示范项目 提供展示如何创建一步首发一步。
在引擎盖下，自动配置是用标准的
@Configuration类来实现的。其他@Conditional注释用于约束何时应用自动配置。通常自动配置类使用@ConditionalOnClass和@ConditionalOnMissingBean注释。这确保了自动配置仅适用于找到相关的类并且没有声明自己的类时@Configuration。您可以浏览源代码
spring-boot-autoconfigure以查看@Configuration我们提供的类（请参阅META-INF/spring.factories文件）。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但为自动配置类提供了专用的顺序。自动配置，必须加载的方式只。确保它们在特定的包装空间中定义，并且它们绝对不是特别针对组件扫描的目标。
您几乎总是希望
@Conditional在自动配置类中包含一个或多个注释。这@ConditionalOnMissingBean是一个常见的例子，如果开发人员不满意你的默认值，开发人员可以“覆盖”自动配置。Spring Boot包含许多
@Conditional注释，您可以在自己的代码中重复使用批注@Configuration类或单个@Bean方法。的
@ConditionalOnClass和@ConditionalOnMissingClass注解允许基于特定类的存在或不存在要被包括配置。由于使用ASM解析注释元数据的事实，您实际上可以使用该value属性来引用真实的类，即使该类可能实际上并不出现在正在运行的应用程序类路径中。name如果您希望使用String值指定类名称，也可以使用该 属性。的
@ConditionalOnBean和@ConditionalOnMissingBean注解允许基于特定豆的存在或不存在要被包括的bean。您可以使用该value属性来按类型指定bean，或者name按名称指定bean。该search属性允许您限制ApplicationContext搜索bean时应考虑的层次结构。您需要非常小心添加bean定义的顺序，因为这些条件是基于到目前为止已经处理的内容来评估的。出于这个原因，我们建议只在自动配置类上使用
@ConditionalOnBean和@ConditionalOnMissingBean注释（因为在添加了任何用户定义的bean定义之后，这些保证会被加载）。@ConditionalOnBean并且@ConditionalOnMissingBean不要阻止@Configuration创建类。在课堂上使用这些条件等同于@Bean用注释标记每个包含的方法。该
@ConditionalOnProperty注释允许基于Spring的环境属性，包括配置。使用prefix和name属性来指定应该检查的属性。默认情况下，任何存在且不相等的属性false将被匹配。您还可以使用havingValue和matchIfMissing属性创建更高级的检查。该
@ConditionalOnResource注释允许被包括配置仅当特定资源是否存在。资源可以使用通常的Spring约定来指定，例如file:/home/user/test.dat。的
@ConditionalOnWebApplication和@ConditionalOnNotWebApplication注解允许根据应用是否是一个“web应用程序”被包括配置。Web应用程序是使用Spring的任何应用程序WebApplicationContext，定义一个session范围或具有一个StandardServletEnvironment。该
@ConditionalOnExpression注释允许基于一个的结果被包括配置使用SpEL表达。一个完整的Spring Boot启动器可能包含以下组件：
autoconfigure包含自动配置代码的模块。- 将
starter其提供给自动配置模块的依赖关系，以及库和通常是有用的任何附加的依赖性模块。简而言之，添加启动器应该足以开始使用该库。
如果您不需要将这两个问题分开，您可以将自动配置代码和依赖管理结合在一个模块中。
请确保为您的初学者提供适当的名称空间。
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）以确保您的密钥已正确记录。自动配置模块包含开始使用库所需的一切。它还可能包含配置键定义（
@ConfigurationProperties）和任何回调接口，可用于进一步定制组件的初始化方式。您应该将库的依赖项标记为可选，以便您可以更轻松地将自动配置模块包含在项目中。如果你这样做，库将不会被提供，Spring Boot默认会退出。
如果您想了解更多关于本节讨论的任何类的信息，可以查看Spring Boot API文档，也可以直接浏览 源代码。如果您有具体问题，请参阅 操作指南部分。
如果您对Spring Boot的核心功能感到满意，可以继续阅读有关生产就绪功能。
Spring Boot包含许多附加功能，可帮助您在应用程序投入生产时监视和管理应用程序。您可以选择使用HTTP端点，JMX甚至远程shell（SSH或Telnet）来管理和监视您的应用程序。审计，健康和指标收集可以自动应用于您的应用程序。
执行器HTTP端点仅适用于基于Spring MVC的应用程序。特别是，除非启用Spring MVC，否则它将不能与Jersey一起工作。
该
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”） }
执行器端点允许您监视和与您的应用程序进行交互。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属性已经设置）。支持使用HTTPRange头来检索部分日志文件的内容。真正
根据端点的暴露方式，该
sensitive属性可能被用作安全提示。例如，敏感端点在通过HTTP访问时将需要用户名/密码（或者如果未启用Web安全性，则只需将其禁用）。端点可以使用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
如果
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“发现页面”来提供。跨源资源共享 （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 以获取完整的选项列表。
如果添加了一个
@Bean类型Endpoint，它将自动通过JMX和HTTP（如果有可用的服务器）公开。可以通过创建类型的bean来进一步定制HTTP端点MvcEndpoint。你MvcEndpoint不是一个，@Controller但它可以使用@RequestMapping（和@Managed*）来公开资源。如果你这样做是为库特征考虑增加带注释的配置类
@ManagementContextConfiguration到/META-INF/spring.factories下键org.springframework.boot.actuate.autoconfigure.ManagementContextConfiguration。如果你这样做，那么如果你的用户要求一个单独的管理端口或地址，端点将会移动到所有其他MVC端点的子上下文中。以这种方式声明的配置可以是一个WebConfigurerAdapter如果它想要添加静态资源（例如）到管理端点。健康信息可用于检查正在运行的应用程序的状态。如果生产系统停机，它通常被监控软件用来提醒某人。
health端点公开的默认信息取决于访问方式。对于安全应用程序中的未经身份验证的连接，将返回一个简单的“状态”消息，对于已验证的连接，还会显示其他详细信息（请参见 第48.7节“HTTP健康端点访问限制”了解HTTP详细信息）。健康信息从您的所有
HealthIndicatorbean中收集ApplicationContext。Spring Boot包含了许多自动配置HealthIndicators，你也可以自己写。返回的信息
HealthIndicators往往在某种程度上是敏感的。例如，您可能不想将数据库服务器的详细信息发布到世界上。出于这个原因，默认情况下，只有健康状态暴露在未经身份验证的HTTP连接上。如果你很高兴为完整的健康信息总是被暴露你可以设置endpoints.health.sensitive到false。还可以缓存健康响应以防止“拒绝服务”攻击。
endpoints.health.time-to-live如果要更改1000毫秒的默认缓存时间段，请使用该 属性。以下
HealthIndicators是适当的时候由Spring Boot自动配置的：名称 描述 检查Cassandra数据库是否启动。
检查磁盘空间不足。
检查是否可以获得连接
DataSource。检查Elasticsearch集群是否启动。
检查JMS代理是否启动。
检查邮件服务器是否启动。
检查Mongo数据库是否启动。
检查一个Rabbit服务器是否启动。
检查Redis服务器是否启动。
检查Solr服务器是否启动。
可以使用该
management.health.defaults.enabled属性禁用它们。为了提供自定义的健康信息，你可以注册实现这个
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的代码。要配置严重性顺序，请将以下内容添加到应用程序属性中：FATALHealthIndicatormanagement.health.status.order = DOWN，OUT_OF_SERVICE，UNKNOWN，UP
HealthMvcEndpoint如果您通过HTTP访问运行状况端点，则可能还需要注册自定义状态映射。例如，你可以映射FATAL到HttpStatus.SERVICE_UNAVAILABLE。应用程序信息公开了从您的所有
InfoContributorbean中收集的各种信息ApplicationContext。Spring Boot包含了许多自动配置InfoContributors，你也可以自己写。以下
InfoContributors是适当的时候由Spring Boot自动配置的：名称 描述 公开钥匙
Environment下的任何info钥匙。如果
git.properties文件可用，请暴露git信息。如果
META-INF/build-info.properties文件可用，则公开构建信息。可以使用该
management.info.defaults.enabled属性禁用它们。您可以
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 =@project.build.sourceEncoding @ info.app.java.source =@java.version @ info.app.java.target =@java.version @
info端点的另一个有用的特性是它能够git在项目构建时发布关于源代码库状态的信息。如果GitProperties豆可用，git.branch，git.commit.id和git.commit.time属性将被暴露出来。如果你想显示完整的git信息（即完整的内容
git.properties），使用management.info.git.mode属性：management.info.git.mode = full
info如果BuildPropertiesbean可用，端点还可以发布关于您的构建的信息。如果META-INF/build-info.properties文件在类路径中可用，就会发生这种情况。Maven和Gradle插件都可以生成该文件，请参阅 生成构建信息以获取更多详细信息。
为了提供定制的应用程序信息，你可以注册实现这个
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” } }
如果您正在开发Spring MVC应用程序，则Spring Boot Actuator将自动配置所有启用的端点以通过HTTP进行公开。默认约定是使用
id端点作为URL路径。例如，health被暴露为/health。默认情况下，所有敏感的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
有时将所有管理端点分组在单一路径下是有用的。例如，您的应用程序可能已经
/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将为你的路径照顾。使用默认的HTTP端口公开管理端点是基于云的部署的明智选择。但是，如果您的应用程序在您自己的数据中心内运行，则可能希望使用不同的HTTP端口公开端点。
该
management.port属性可用于更改HTTP端口。management.port = 8081
由于您的管理端口通常受防火墙保护，并且不向公众公开，即使您的主应用程序是安全的，您也可能不需要管理端点上的安全性。在这种情况下，您将在类路径上具有Spring Security，并且可以像这样禁用管理安全性：
management.security.enabled = false
（如果你在类路径上没有Spring Security，那么就不需要像这样明确地禁用管理安全性，甚至可能会破坏应用程序。）
配置为使用自定义端口时，管理服务器也可以使用各种
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
您可以通过设置
management.address属性来自定义管理端点可用的地址。如果您只想在内部网络或面向操作的网络上收听，或者仅收听连接，这会非常有用localhost。如果端口与主服务器端口不同，则只能监听其他地址。
这是一个
application.properties不允许远程管理连接的例子：management.port = 8081 management.address = 127.0.0.1
健康端点公开的信息取决于是否匿名访问，以及封闭应用程序是否安全。默认情况下，当在安全应用程序中匿名访问时，隐藏有关服务器健康状况的任何细节，端点将简单指示服务器是启动还是关闭。此外，响应被缓存了一个可配置的时间段，以防止端点被用于拒绝服务攻击。该
endpoints.health.time-to-live属性用于配置以毫秒为单位的缓存周期。它默认为1000，即一秒。可以增强上述限制，从而仅允许经认证的用户完全访问安全应用程序中的健康端点。为此，请设置
endpoints.health.sensitive为true。以下是行为总结（默认sensitive标志值为“false”，用粗体表示）：management.security.enabledendpoints.health.sensitive未认证 经过身份验证 假
假
完整的内容
完整的内容
假
真正
仅状态
完整的内容
真正
假
仅状态
完整的内容
真正
真正
无内容
完整的内容
Java管理扩展（JMX）提供了一个标准机制来监视和管理应用程序。默认情况下，Spring Boot会将管理端点公开为
org.springframework.boot域下的JMX 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
Jolokia是一个JMX-HTTP桥梁，它提供了访问JMX bean的另一种方法。要使用Jolokia，只需添加一个依赖项即可
org.jolokia:jolokia-core。例如，使用Maven，您可以添加以下内容：<dependency> <groupId> org.jolokia </ groupId> <artifactId> jolokia-core </ artifactId> </ dependency>
Jolokia然后可以使用
/jolokia您的管理HTTP服务器上访问。Jolokia有许多你通常使用servlet参数进行配置的设置。使用Spring Boot，你可以使用你
application.properties的参数，只需在参数前加上jolokia.config.：jolokia.config.debug = true
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。默认情况下，远程shell将监听端口上的连接
2000。默认用户是user，并且默认的密码将被随机生成并显示在日志输出中。如果您的应用程序使用Spring Security，则默认情况下，shell将使用 相同的配置。如果没有，将应用一个简单的身份验证，你应该看到这样的消息：使用默认密码进行shell访问：ec03e16c-4cf4-49ee-b745-7c8255c1dd7eLinux和OSX用户可以使用
ssh连接到远程shell，Windows用户可以下载并安装PuTTY。$ ssh -p 2000 user @ localhost user @ localhost 的密码： 。____ _ __ _ _ / \\ / _____ __ _ _（_）_ __ __ _ \ \ \ \ （（）\ ___ |'_ |'_ | |'_ \ / _` | \ \ \ \ \\ / ___）| | _）| | | | | || （_ | |）））） '| ____ | .__ | _ | | _ | _ | | _ \ __，| / / / / ========= | _ | ============== | ___ / = / _ / _ / _ / :: myhost上的Spring Boot ::（v1.5.2.RELEASE）
键入
help命令列表。春季启动提供metrics，beans，autoconfig和endpoint命令。您可以使用
management.shell.auth.simple.user.name和management.shell.auth.simple.user.password属性来配置自定义连接凭证。也可以使用“Spring Security”AuthenticationManager来处理登录职责。见CrshAutoConfiguration和ShellPropertiesJavadoc文档的全部细节。远程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.versionSpring Boot的版本
spring.version核心Spring框架的版本
spring.beanfactory进入春天
BeanFactoryspring.environment进入春天
Environment除了新命令外，还可以扩展其他CRaSH shell功能。所有延伸的Spring Beans
org.crsh.plugin.CRaSHPlugin将自动注册到shell中。有关更多信息，请参阅CRaSH参考文档。
Spring Boot Actuator能够在运行时查看和配置应用程序的日志级别。您可以查看整个列表或单个记录器的配置，该配置由显式配置的日志记录级别以及记录框架给出的有效日志记录级别组成。这些级别可以是：
TRACEDEBUGINFOWARNERRORFATALOFFnull
并
null指出没有明确的配置。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。在这个例子中，我们实际上是使用
/metricsURL 通过HTTP访问端点 ，这就解释了为什么会metrics出现在响应中。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）
针对
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例子。针对您的应用程序中定义的每个受支持的缓存公开以下指标：
- 缓存的当前大小（
cache.xxx.size） - 命中率（
cache.xxx.hit.ratio） - 小姐比例（
cache.xxx.miss.ratio）
高速缓存提供程序不会以一致的方式显示命中/错过率。虽然一些暴露的聚集值（即自上次的统计信息被清除的命中率），其他暴露时间值（即最后一秒钟的命中率）。查看你的缓存提供者文档以获取更多细节。
如果两个不同的高速缓存管理器碰巧定义了相同的高速缓存，则高速缓存的名称将以该
CacheManagerbean 的名称为前缀。可以通过注册一个具有定制版本的bean来覆盖部分或全部默认值
CachePublicMetrics。默认情况下，Spring Boot为EhCache，Hazelcast，Infinispan，JCache和Guava提供缓存统计信息。CacheStatisticsProvider如果您最喜欢的缓存库不支持开箱即用，您可以添加额外的 bean。看CacheStatisticsAutoConfiguration例子。如果您使用Tomcat作为嵌入式servlet容器，会话度量标准将自动公开。在
httpsessions.active与httpsessions.max键提供主动和最大会话数。记录你自己的指标注入一个
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上找到。
要添加每次调用度量标准端点时计算的其他度量标准，只需注册其他的
PublicMetrics实施bean 即可。默认情况下，所有这些bean都由端点收集。你可以通过定义你自己的来轻松地改变它MetricsEndpoint。Spring Boot 的默认实现
GaugeService和CounterService提供依赖于您正在使用的Java版本。在Java 8（或更好的版本）的情况下，实现切换到一个高性能版本，这个版本是为了快速写入而优化的，由原子内存缓冲区支持，而不是由一成不变但相对昂贵的Metric<?>类型（计数器的速度大约快5倍，并且大约是基于存储库的实现速度的两倍）。即使对于Java 7（它们具有某些Java 8并发库的反向端口），Dropwizard度量服务（见下文）也非常有效，但它们不记录度量值的时间戳。如果衡量指标收集的性能是一个问题，那么总是建议使用高性能选项之一，而且也只是偶尔读取指标，以便写入在本地进行缓冲，并且只在需要时才进行读取。如果您使用的是Java 8或者使用的是Dropwizard度量标准，那么旧的
MetricRepository和其InMemoryMetricRepository实现不会默认使用。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。还要注意，DropwizardMetricRegistry不支持时间戳，所以如果使用Dropwizard指标（所有的指标都会在每个时间戳中被复制），优化是不可用的。对于出口触发的默认值（
delay-millis，includes，excludes和send-latest）可以设置为spring.metrics.export.*。对于特定个人的值MetricWriters可以被设置为spring.metrics.export.triggers.<name>.*其中<name>是一个bean名称（或图案匹配bean的名字）。如果关闭默认值
MetricRepository（例如，使用Dropwizard指标），则会自动导出度量 标准。你可以获得相同的功能，声明一个你自己类型的beanMetricReader并声明它是@ExportMetricReader。如果您提供了一个
@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注入和提取密钥和前缀。这是作为一个方便的弹簧引导提供给你，配置合理的默认值。只要遵循建议，没有什么可以阻止你使用自己的价值观。如果您提供一个
@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 } } ]
要将度量值导出到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）; }
如果您提供了标记
@Bean类型的度量标准，则会将度量标准作为MBean导出到本地服务器（只要启用，则由Spring Boot JMX自动配置提供）。然后可以使用任何了解JMX的工具（例如JConsole或JVisualVM）来检查，绘制度量标准，提醒等等。JmxMetricWriter@ExportMetricWriterMBeanExporter例：
@Bean @ExportMetricWriter MetricWriter metricWriter（MBeanExporter exporter）{ 返回 新的 JmxMetricWriter（exporter）; }
每个度量都作为单独的MBean导出。其格式
ObjectNames由ObjectNamingStrategy可以注入的JmxMetricWriter（默认分割度量标准名称，并以JVisualVM或JConsole中的度量值组很好的方式标记前两个由句点分隔的部分）给出。有一个
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，因为他们只是收集和分析来自其他存储库的数据，并且不希望出口他们的价值观。
扫一扫
118
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
