W的世界

Spring Boot参考指南

作者

菲利普· 韦伯，戴夫 Syer ，约什长，斯特凡尼科尔，罗布绞车，安迪· 威尔金森，马塞尔 Overdijk ，基督教杜普伊斯，塞巴斯蒂安· 德勒兹，迈克尔· 西蒙斯

1.5.2.RELEASE

I. Spring Boot文档

1.关于文档
2.获得帮助
3.第一步
4.使用Spring Boot
5.学习Spring Boot的特性
6.转向生产
7.高级主题

II。入门

8.介绍Spring Boot

9.系统要求

9.1。Servlet容器

10.安装Spring Boot

10.1。Java开发人员的安装说明

10.1.1。Maven安装
10.1.2。Gradle安装

10.2。安装Spring Boot CLI

10.2.1。手动安装
10.2.2。用SDKMAN安装！
10.2.3。OSX Homebrew安装
10.2.4。MacPorts安装
10.2.5。命令行完成
10.2.6。快速启动Spring CLI示例

10.3。从早期版本的Spring Boot升级

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

11.1。创建POM

11.2。添加classpath依赖关系

11.3。编写代码

11.3.1。@RestController和@RequestMapping注释
11.3.2。@EnableAutoConfiguration注释
11.3.3。“主要”方法

11.4。运行示例

11.5。创建一个可执行的jar

12.接下来读什么

III。使用Spring Boot

13.建立系统

13.1。依赖管理

13.2。Maven的

13.2.1。继承初始父项
13.2.2。使用没有父POM的Spring Boot
13.2.3。更改Java版本
13.2.4。使用Spring Boot Maven插件

13.3。摇篮

13.4。蚂蚁

13.5。首发

14.构建你的代码

14.1。使用“默认”软件包
14.2。找到主要的应用程序类

15.配置类

15.1。导入其他配置类
15.2。导入XML配置

16.自动配置

16.1。逐渐取代自动配置
16.2。禁用特定的自动配置

17.春豆和依赖注入

18.使用@SpringBootApplication注释

19.运行你的应用程序

19.1。从IDE运行
19.2。作为打包的应用程序运行
19.3。使用Maven插件
19.4。使用Gradle插件
19.5。热插拔

20.开发人员工具

20.1。属性默认值

20.2。自动重启

20.2.1。排除资源
20.2.2。看额外的路径
20.2.3。禁用重启
20.2.4。使用触发器文件
20.2.5。自定义重启类加载器
20.2.6。已知的限制

20.3。LiveReload

20.4。全局设置

20.5。远程应用程序

20.5.1。运行远程客户端应用程序
20.5.2。远程更新
20.5.3。远程调试隧道

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

22.接下来读什么

IV。Spring Boot功能

23. SpringApplication

23.1。启动失败
23.2。自定义横幅
23.3。自定义SpringApplication
23.4。流利的生成器API
23.5。应用程序事件和侦听器
23.6。网络环境
23.7。访问应用程序参数
23.8。使用ApplicationRunner或CommandLineRunner
23.9。申请退出
23.10。管理功能

24.外部化配置

24.1。配置随机值

24.2。访问命令行属性

24.3。应用程序属性文件

24.4。配置文件特定的属性

24.5。占位符属性

24.6。使用YAML而不是属性

24.6.1。加载YAML
24.6.2。在Spring环境中将YAML作为属性公开
24.6.3。多配置文件的YAML文件
24.6.4。YAML的缺点
24.6.5。合并YAML列表

24.7。类型安全的配置属性

24.7.1。第三方配置
24.7.2。轻松的绑定
24.7.3。属性转换
24.7.4。@ConfigurationProperties验证
24.7.5。@ConfigurationProperties与@Value

25.简介

25.1。添加活动配置文件
25.2。编程设置配置文件
25.3。配置文件特定的配置文件

26.记录

26.1。日志格式

26.2。控制台输出

26.2.1。彩色编码输出

26.3。文件输出

26.4。日志级别

26.5。自定义日志配置

26.6。Logback扩展

26.6.1。配置文件特定的配置
26.6.2。环境属性

27.开发Web应用程序

27.1。“Spring Web MVC框架”

27.1.1。Spring MVC自动配置

27.1.2。HttpMessageConverters

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

27.1.4。MessageCodesResolver的信息

27.1.5。静态内容

27.1.6。自定义Favicon

27.1.7。ConfigurableWebBindingInitializer

27.1.8。模板引擎

27.1.9。错误处理

自定义错误页面
在Spring MVC之外映射错误页面
WebSphere Application Server上的错误处理

10年1月27日。春天的HATEOAS

11年1月27日。CORS支持

27.2。JAX-RS和泽西岛

27.3。嵌入式servlet容器支持

27.3.1。Servlet，过滤器和监听器

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

27.3.2。Servlet上下文初始化

扫描Servlet，筛选器和侦听器

27.3.3。EmbeddedWebApplicationContext

27.3.4。定制嵌入式servlet容器

程序化定制
直接自定义ConfigurableEmbeddedServletContainer

27.3.5。JSP限制

28.安全

28.1。的OAuth2

28.1.1。授权服务器
28.1.2。资源服务器

28.2。用户信息中的令牌类型

28.3。自定义用户信息RestTemplate

28.3.1。客户
28.3.2。单一登录

28.4。执行器安全

29.使用SQL数据库

29.1。配置一个数据源

29.1.1。嵌入式数据库支持
29.1.2。连接到生产数据库
29.1.3。连接到一个JNDI数据源

29.2。使用JdbcTemplate

29.3。JPA和“Spring Data”

29.3.1。实体类
29.3.2。Spring数据JPA存储库
29.3.3。创建和删除JPA数据库
29.3.4。在View中打开EntityManager

29.4。使用H2的Web控制台

29.4.1。更改H2控制台的路径
29.4.2。保护H2控制台

29.5。使用jOOQ

29.5.1。代码生成
29.5.2。使用DSLContext
29.5.3。定制jOOQ

30.使用NoSQL技术

30.1。Redis的

30.1.1。连接到Redis

30.2。MongoDB的

30.2.1。连接到MongoDB数据库
30.2.2。MongoTemplate
30.2.3。Spring Data MongoDB存储库
30.2.4。嵌入式Mongo

30.3。Neo4j的

30.3.1。连接到Neo4j数据库
30.3.2。使用嵌入式模式
30.3.3。Neo4jSession
30.3.4。Spring Data Neo4j存储库
30.3.5。存储库示例

30.4。的GemFire

30.5。Solr的

30.5.1。连接到Solr
30.5.2。Spring Data Solr存储库

30.6。Elasticsearch

30.6.1。使用Jest连接到Elasticsearch
30.6.2。使用Spring Data连接到Elasticsearch
30.6.3。Spring Data Elasticsearch存储库

30.7。卡桑德拉

30.7.1。连接到Cassandra
30.7.2。Spring Data Cassandra存储库

30.8。Couchbase

30.8.1。连接到Couchbase
30.8.2。Spring Data Couchbase存储库

30.9。LDAP

30.9.1。连接到LDAP服务器
30.9.2。Spring Data LDAP存储库
30.9.3。嵌入式内存LDAP服务器

31.缓存

31.1。支持的缓存提供者

31.1.1。通用
31.1.2。JCache（JSR-107）
31.1.3。EhCache 2.x
31.1.4。Hazelcast
31.1.5。Infinispan的
31.1.6。Couchbase
31.1.7。Redis的
31.1.8。咖啡因
31.1.9。番石榴（已弃用）
10年1月31日。简单
11年1月31日。没有

信息

32.1。JMS

32.1.1。ActiveMQ支持
32.1.2。阿耳忒弥斯的支持
32.1.3。使用JNDI ConnectionFactory
32.1.4。发送消息
32.1.5。接收消息

32.2。AMQP

32.2.1。RabbitMQ支持
32.2.2。发送消息
32.2.3。接收消息

32.3。Apache Kafka支持

32.3.1。发送消息
32.3.2。接收消息
32.3.3。额外的卡夫卡属性

33.调用REST服务

33.1。RestTemplate自定义

34.验证

35.发送电子邮件

36.与JTA分布式事务

36.1。使用Atomikos事务管理器
36.2。使用Bitronix事务管理器
36.3。使用Narayana事务管理器
36.4。使用Java EE管理的事务管理器
36.5。混合XA和非XA JMS连接
36.6。支持另一种嵌入式事务管理器

37. Hazelcast

38.春天一体化

39.春季会议

40.监控和管理JMX

41.测试

41.1。测试范围依赖关系

41.2。测试Spring应用程序

41.3。测试Spring Boot应用程序

41.3.1。检测测试配置
41.3.2。排除测试配置
41.3.3。使用随机端口
41.3.4。嘲笑和窥探豆
41.3.5。自动配置的测试
41.3.6。自动配置的JSON测试
41.3.7。自动配置的Spring MVC测试
41.3.8。自动配置的数据JPA测试
41.3.9。自动配置的JDBC测试
41.3.10。自动配置的数据MongoDB测试
41.3.11。自动配置的REST客户端
41.3.12。自动配置的Spring REST Docs测试
41.3.13。使用Spock来测试Spring Boot应用程序

41.4。测试工具

41.4.1。ConfigFileApplicationContextInitializer
41.4.2。EnvironmentTestUtils
41.4.3。OutputCapture
41.4.4。TestRestTemplate

42. WebSockets

43.网络服务

44.创建你自己的自动配置

44.1。了解自动配置的bean

44.2。找到自动配置候选

44.3。条件注释

44.3.1。课堂条件
44.3.2。豆条件
44.3.3。物业条件
44.3.4。资源条件
44.3.5。Web应用程序条件
44.3.6。SpEL表达条件

44.4。创建你自己的启动器

44.4.1。命名
44.4.2。自动配置模块
44.4.3。入门模块

45.下一步阅读什么

V.弹簧执行器：生产就绪功能

46.启用生产就绪功能

47.终点

47.1。自定义端点

47.2。执行器MVC端点的超媒体

47.3。CORS支持

47.4。添加自定义端点

47.5。健康信息

47.6。与HealthIndicators的安全

47.6.1。自动配置的HealthIndicators
47.6.2。编写自定义的HealthIndicators

47.7。应用信息

47.7.1。自动配置InfoContributors
47.7.2。自定义应用程序信息
47.7.3。Git提交信息
47.7.4。建立信息
47.7.5。编写自定义InfoContributors

48.通过HTTP进行监控和管理

48.1。访问敏感端点
48.2。自定义管理端点路径
48.3。自定义管理服务器端口
48.4。配置特定于管理的SSL
48.5。自定义管理服务器地址
48.6。禁用HTTP端点
48.7。HTTP健康端点访问限制

49.监视和管理JMX

49.1。定制MBean名称

49.2。禁用JMX端点

49.3。通过HTTP使用Jolokia进行JMX

49.3.1。定制Jolokia
49.3.2。禁用Jolokia

50.使用远程shell进行监视和管理（不建议使用）

50.1。连接到远程shell

50.1.1。远程外壳凭证

50.2。扩展远程shell

50.2.1。远程shell命令
50.2.2。远程外壳插件

伐木者

51.1。配置记录器

52.度量

52.1。系统指标

52.2。数据源指标

52.3。缓存指标

52.4。Tomcat会话指标

52.5。记录您自己的指标

52.6。添加您自己的公开指标

52.7。Java 8的特殊功能

52.8。度量编写者，出口商和聚合

52.8.1。示例：导出到Redis
52.8.2。示例：导出到打开TSDB
52.8.3。示例：导出到Statsd
52.8.4。示例：导出到JMX

52.9。汇总来自多个来源的指标

52.10。Dropwizard指标

52.11。消息通道集成

53.审计

54.追踪

54.1。自定义跟踪

55.过程监控

55.1。扩展配置
55.2。编程

56. Cloud Foundry支持

56.1。禁用扩展的Cloud Foundry执行器支持
56.2。Cloud Foundry自签名证书
56.3。自定义安全配置

57.接下来读什么

VI。部署Spring Boot应用程序

58.部署到云

58.1。Cloud Foundry

58.1.1。绑定到服务

58.2。Heroku的

58.3。OpenShift

58.4。亚马逊网络服务（AWS）

58.4.1。AWS Elastic Beanstalk

使用Tomcat平台
使用Java SE平台
最佳做法

58.4.2。概要

58.5。Boxfuse和亚马逊网络服务

58.6。Google App Engine

59.安装Spring Boot应用程序

59.1。Unix / Linux服务

59.1.1。作为init.d服务安装（System V）

保护一个init.d服务

59.1.2。作为systemd服务安装

59.1.3。自定义启动脚本

在写脚本时自定义脚本
运行时自定义脚本

59.2。Microsoft Windows服务

60.接下来读什么

七。Spring启动CLI

61.安装CLI

62.使用CLI

62.1。使用CLI运行应用程序

62.1.1。推导出“抓取”依赖关系
62.1.2。推导出“抓取”坐标
62.1.3。默认导入语句
62.1.4。自动主方法
62.1.5。自定义依赖关系管理

62.2。测试你的代码

62.3。具有多个源文件的应用程序

62.4。打包你的应用程序

62.5。初始化一个新项目

62.6。使用嵌入式shell

62.7。向CLI添加扩展

63.使用Groovy beans DSL开发应用程序

64.使用settings.xml配置CLI

65.接下来要读什么

八。构建工具插件

66. Spring Boot Maven插件

66.1。包括插件
66.2。打包可执行jar和war文件

67. Spring Boot Gradle插件

67.1。包括插件

67.2。Gradle依赖管理

67.3。打包可执行jar和war文件

67.4。在原地运行项目

67.5。Spring Boot插件配置

67.6。重新包装配置

67.7。使用自定义Gradle配置重新打包

67.7.1。配置选项
67.7.2。可用的布局
67.7.3。使用自定义布局

67.8。了解Gradle插件如何工作

67.9。使用Gradle将工件发布到Maven存储库

67.9.1。配置Gradle生成继承依赖管理的pom
67.9.2。配置Gradle生成一个导入依赖管理的pom

68. Spring Boot AntLib模块

68.1。Spring Boot Ant任务

68.1.1。春季启动：exejar
68.1.2。例子

68.2。春季启动：findmainclass

68.2.1。例子

69.支持其他构建系统

69.1。重新包装档案
69.2。嵌套的库
69.3。找到一个主要的课程
69.4。示例重新包装实施

70.接下来要读什么

IX。“如何做”指南

71. Spring Boot应用程序

71.1。创建您自己的FailureAnalyzer
71.2。解决自动配置问题
71.3。在开始之前自定义Environment或ApplicationContext
71.4。构建一个ApplicationContext层次结构（添加父级或根级上下文）
71.5。创建一个非Web应用程序

72.属性和配置

72.1。在构建时自动扩展属性

72.1.1。使用Maven自动扩展属性
72.1.2。使用Gradle自动扩展属性

72.2。外部化SpringApplication的配置

72.3。更改应用程序的外部属性的位置

72.4。使用“简短”的命令行参数

72.5。使用YAML作为外部属性

72.6。设置活动的Spring配置文件

72.7。根据环境更改配置

72.8。发现外部属性的内置选项

73.嵌入式servlet容器

73.1。将Servlet，Filter或Listener添加到应用程序中

73.1.1。使用Spring bean添加一个Servlet，Filter或Listener

禁用Servlet或Filter的注册

73.1.2。使用类路径扫描添加Servlet，过滤器和监听器

73.2。更改HTTP端口

73.3。使用随机未分配的HTTP端口

73.4。在运行时发现HTTP端口

73.5。配置SSL

73.6。配置访问记录

73.7。在前端代理服务器后面使用

73.7.1。自定义Tomcat的代理配置

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.16.1。在Maven中使用Tomcat 7.x或8.0
73.16.2。在Gradle中使用Tomcat 7.x或8.0

73.17。使用Jetty 9.2

73.17.1。在Maven中使用Jetty 9.2
73.17.2。使用Jetty 9.2和Gradle

73.18。使用Jetty 8

73.18.1。在Maven中使用Jetty 8
73.18.2。使用码头8与Gradle

73.19。使用@ServerEndpoint创建WebSocket端点

73.20。启用HTTP响应压缩

74. Spring MVC

74.1。编写一个JSON REST服务
74.2。编写一个XML REST服务
74.3。自定义Jackson ObjectMapper
74.4。自定义@ResponseBody呈现
74.5。处理多部分文件上传
74.6。关闭Spring MVC DispatcherServlet
74.7。关闭默认的MVC配置
74.8。自定义ViewResolvers
74.9。使用Thymeleaf 3

75. HTTP客户端

75.1。配置RestTemplate以使用代理

记录

76.1。配置Logback进行日志记录

76.1.1。为文件只输出配置logback

76.2。配置Log4j进行日志记录

76.2.1。使用YAML或JSON来配置Log4j 2

77.数据访问

77.1。配置一个自定义的数据源
77.2。配置两个数据源
77.3。使用Spring数据存储库
77.4。单独的@Entity定义来自Spring配置
77.5。配置JPA属性
77.6。使用一个自定义的EntityManagerFactory
77.7。使用两个EntityManagers
77.8。使用传统的persistence.xml
77.9。使用Spring Data JPA和Mongo仓库
77.10。将Spring Data存储库公开为REST端点
77.11。配置由JPA使用的组件

数据库初始化

78.1。使用JPA初始化数据库

78.2。使用Hibernate初始化数据库

78.3。使用Spring JDBC初始化数据库

78.4。初始化一个Spring批处理数据库

78.5。使用更高级别的数据库迁移工具

78.5.1。在启动时执行Flyway数据库迁移
78.5.2。在启动时执行Liquibase数据库迁移

信息

79.1。禁用事务处理JMS会话

80.批量应用程序

80.1。在启动时执行Spring批处理作业

81.执行器

81.1。更改执行机构端点的HTTP端口或地址
81.2。自定义“whitelabel”错误页面
81.3。执行器和泽西岛

82.安全

82.1。关闭Spring Boot安全配置
82.2。更改AuthenticationManager并添加用户帐户
82.3。在代理服务器上运行时启用HTTPS

83.热插拔

83.1。重新加载静态内容

83.2。在不重新启动容器的情况下重新加载模板

83.2.1。Thymeleaf模板
83.2.2。FreeMarker模板
83.2.3。Groovy模板

83.3。快速应用程序重启

83.4。重新加载Java类而不重新启动容器

83.4.1。配置Spring加载用于Maven
83.4.2。配置Spring加载用于Gradle和IntelliJ IDEA

84.建设

84.1。生成构建信息

84.2。生成git信息

84.3。自定义依赖版本

84.4。用Maven创建一个可执行的JAR

84.5。使用Spring Boot应用程序作为依赖项

84.6。当一个可执行的jar运行时，提取特定的库

84.7。用排除来创建一个不可执行的JAR

84.8。远程调试使用Maven启动的Spring Boot应用程序

84.9。远程调试使用Gradle启动的Spring Boot应用程序

84.10。从Ant构建可执行文件，而不使用spring-boot-antlib

84.11。如何使用Java 6

84.11.1。嵌入式servlet容器兼容性
84.11.2。杰克逊
84.11.3。JTA API兼容性

85.传统部署

85.1。创建一个可部署的战争文件
85.2。为旧的servlet容器创建一个可部署的war文件
85.3。将现有的应用程序转换为Spring Boot
85.4。将WAR部署到WebLogic
85.5。在旧的（Servlet 2.5）容器中部署WAR

十，附录

A.通用应用程序属性

B.配置元数据

B.1。元数据格式

B.1.1。组属性
B.1.2。属性属性
B.1.3。提示属性
B.1.4。重复的元数据项目

B.2。提供手动提示

B.2.1。价值提示

B.2.2。价值提供者

任何
类参考
处理为
记录器名称
Spring bean引用
春天个人资料名称

B.3。使用注释处理器生成您自己的元数据

B.3.1。嵌套属性
B.3.2。添加额外的元数据

C.自动配置类

C.1。从“spring-boot-autoconfigure”模块
C.2。从“弹簧启动执行器”模块

D.测试自动配置注释

E.可执行的jar格式

E.1。嵌套的JAR

E.1.1。可执行的jar文件结构
E.1.2。可执行的war文件结构

E.2。Spring Boot的“JarFile”类

E.2.1。与标准Java“JarFile”兼容

E.3。启动可执行文件

E.3.1。启动程序清单
E.3.2。爆炸的档案

E.4。PropertiesLauncher特性

E.5。可执行的jar限制

E.5.1。邮编条目压缩
E.5.2。系统类加载器

E.6。替代单罐解决方案

F.依赖版本

第一部分Spring Boot文档

本节简要介绍Spring Boot参考文档。将其视为文档其余部分的映射。您可以以线性方式阅读本参考指南，或者如果您不感兴趣，可以跳过部分内容。

1.关于文档

Spring Boot参考指南有html， pdf 和epub文档。最新的副本位于docs.spring.io/spring-boot/docs/current/reference。

2.获得帮助

在Spring Boot遇到问题，我们希望能提供帮助！

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


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

3.第一步

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

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

4.使用Spring Boot

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

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

5.学习Spring Boot的特性

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

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

6.转向生产

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

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

7.高级主题

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

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

第二部分入门

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

8.介绍Spring Boot

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

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

我们的主要目标是：

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

9.系统要求

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


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

9.1 Servlet容器

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

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

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

10.安装Spring Boot

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

$ java -version

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


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

10.1 Java开发人员的安装说明

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

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

10.1.1 Maven安装

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


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

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

这是一个典型的pom.xml文件：

<？xml version =“1.0”encoding =“UTF-8”？> 
 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“ > 
     4.0.0 

     com.example  
     myproject  
     0.0.1-SNAPSHOT 

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

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

    <！ -  Package as a executable jar  - > 
     
         
             
                 org.springframework.boot  
                 spring-boot-maven-plugin


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

10.1.2 Gradle安装

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

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

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

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


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

储存库{
    jcenter（）
}

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

10.2安装Spring Boot CLI

Spring Boot CLI是一个命令行工具，如果你想用Spring来快速创建原型，可以使用它。它允许你运行Groovy脚本，这意味着你有一个熟悉的类Java语法，没有太多的样板代码。

您不需要使用CLI来使用Spring Boot，但它绝对是使Spring应用程序停飞的最快捷方式。

10.2.1手动安装

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

spring-boot-cli-1.5.2.RELEASE-bin.zip
弹簧引导CLI-1.5.2.RELEASE-bin.tar.gz

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

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

10.2.2使用SDKMAN安装！

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

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

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

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

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

你可以看到这样做：

$ sdk ls springboot

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

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

10.2.3 OSX Homebrew安装

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

$ brew tap pivotal / tap
$ brew安装springboot

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


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

10.2.4 MacPorts安装

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

$ sudo port install spring-boot-cli

10.2.5命令行完成

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

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


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

10.2.6快速启动Spring CLI示例

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

@RestController
类 ThisWillActuallyRun {

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

}

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

$ spring run app.groovy


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

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

你好，世界！

10.3从早期版本的Spring Boot升级

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

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

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

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

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

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

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

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

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


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

11.1创建POM

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

<？xml version =“1.0”encoding =“UTF-8”？> 
 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“ > 
     4.0.0 

     com.example  
     myproject  
     0.0.1-SNAPSHOT 

     
         org.springframework.boot  
         spring-boot-starter-parent  
         1.5.2.RELEASE  
    

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

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


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

11.2添加classpath依赖关系

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

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

$ mvn依赖：树

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

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

 
     
         org.springframework.boot  
         spring-boot-starter-web

如果mvn dependency:tree再次运行，您将会看到现在还有一些其他的依赖项，包括Tomcat Web服务器和Spring Boot本身。

11.3编写代码

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

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

@RestController 
@EnableAutoConfiguration
 public  class Example {

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

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

}

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

11.3.1 @RestController和@RequestMapping注解

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

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


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

11.3.2 @EnableAutoConfiguration注释

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

11.3.3“主要”方法

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

11.4运行示例

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

$ mvn spring-boot：运行

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

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

你好，世界！

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

11.5创建一个可执行的jar

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

可执行的罐子和Java

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

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

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

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

 
     
         
             org.springframework.boot  
             spring-boot-maven-plugin


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

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

$ mvn包

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

如果你看看target你应该看到的目录myproject-0.0.1-SNAPSHOT.jar。该文件大小应该在10 MB左右。如果你想偷看，你可以使用jar tvf：

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

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

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

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

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

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

12.接下来读什么

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

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

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

第三部分使用Spring Boot

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

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

13.建立系统

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

13.1依赖管理

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


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

策划的列表包含您可以使用Spring Boot的所有弹簧模块以及第三方库的精炼列表。该列表可以作为标准物料清单（spring-boot-dependencies）以及Maven和 Gradle的其他专用支持。


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

13.2 Maven

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

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

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

13.2.1继承初始父项

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

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


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

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

 
    releasetrain.version>
 Fowler-SR2


	检查`spring-boot-dependencies`pom 以获取支持的属性列表。

13.2.2使用没有父POM的Spring Boot

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

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

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

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

 
    <依赖性> 
        <！ -覆盖由弹簧引导提供弹簧数据释放列车- > 
        <依赖性> 
            <的groupId> org.springframework.data  
            弹簧数据releasetrain  
            <版本> Fowler-SR2  
             import  
             pom  
         
         
             org.springframework.boot  
             spring-boot -dependencies  
            1.5.2.RELEASE  
             pom 
             import


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

13.2.3更改Java版本

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

1.8

13.2.4使用Spring Boot Maven插件

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

 
     
         
             org.springframework.boot  
             spring-boot-maven-plugin


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

13.3 Gradle

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

储存库{
    jcenter（）
}

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

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

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


储存库{
    jcenter（）
}

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

13.4蚂蚁

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

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

 version = “2.0” > 
     organization = “org.springframework.boot”  module = “spring-boot-sample-ant” /> 
     
         name = “compile”  description = “编译该模块” /> 
         名称 = ‘运行时’  延伸 = ‘编译’  描述 = ‘一切来运行该模块需要’ /> 
     
    <依赖性> 
        <依赖 org =“org.springframework.boot”  name = “spring-boot-starter” 
            rev = “$ {spring-boot.version}”  conf = “compile” />

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


    xmlns：ivy = “antlib：org.apache.ivy.ant” 
    xmlns：spring-boot = “antlib：org.springframework.boot.ant” 
    name = “myapp”  default = “build” >

     name = “spring-boot.version”  value = “1.3.0.BUILD-SNAPSHOT” />

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

     name = “classpaths”  depends = “resolve” > 
         id = “compile.classpath” > 
             dir = “lib / compile”  includes = “* .jar” /> 
         
    

     name = “init”  depends = “classpaths” > 
         dir = “build / classes” /> 
    

     name = “compile”  depends = “init”  description = “compile” > 
         srcdir = “src / main / java”  destdir = “build / classes”  classpathref = “compile.classpath” /> 
    

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


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

13.5起动

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

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

什么是名字

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

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

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

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

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

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

表13.2。Spring Boot生产启动器

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

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

表13.3。Spring Boot技术首发

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


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

14.构建你的代码

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

14.1使用“默认”软件包

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


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

14.2找到主应用程序类

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

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

这是一个典型的布局：

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

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

包 com.example.myproject;

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

@Configuration 
@EnableAutoConfiguration 
@ComponentScan
 public  class Application {

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

}

15.配置类

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


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

15.1导入其他配置类

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

15.2导入XML配置

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

16.自动配置

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

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


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

16.1逐渐更换自动配置

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

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

16.2禁用特定的自动配置

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

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

@Configuration 
@EnableAutoConfiguration（exclude = {DataSourceAutoConfiguration.class}）
 public  class MyConfiguration {
}

如果类不在类路径上，则可以使用excludeName注释的属性并指定完全限定的名称。最后，还可以通过spring.autoconfigure.exclude属性控制自动配置类的列表。


	您可以在注释级别和使用属性中定义排除。

17.春豆和依赖注入

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

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

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

包 com.example.service;

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

@Service
公共 类 DatabaseAccountService实现 AccountService {

    私人 最终 RiskAssessssor风险评估师;

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

    // ...

}

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

@Service
公共 类 DatabaseAccountService实现 AccountService {

    私人 最终 RiskAssessssor风险评估师;

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

    // ...

}


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

18.使用@SpringBootApplication注释

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

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

包 com.example.myproject;

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

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

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

}


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

19.运行你的应用程序

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


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

19.1从IDE运行

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

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


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

19.2作为打包应用程序运行

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

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

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

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

19.3使用Maven插件

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

$ mvn spring-boot：运行

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

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

19.4使用Gradle插件

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

$ gradle bootRun

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

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

19.5热插拔

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

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

20.开发人员工具

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

Maven的。

 
     
         org.springframework.boot  
         spring-boot-devtools  
         true

摇篮。

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

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


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

20.1属性默认值

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

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

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


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

20.2自动重启

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


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


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


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


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

重新启动vs重新加载

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

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

20.2.1排除资源

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

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


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

20.2.2看额外的路径

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

20.2.3禁用重启

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

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

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

20.2.4使用触发文件

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

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


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

20.2.5定制重启classloader

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

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

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

例如：

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


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


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

20.2.6已知的限制

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

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

20.3 LiveReload

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

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


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

20.4全局设置

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

〜/ .spring引导-devtools.properties。

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

20.5远程应用程序

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

 
     
         
             org.springframework.boot  
             spring-boot-maven-plugin  
             
                 false

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

spring.devtools.remote.secret = mysecret


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

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

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

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

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

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

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

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

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


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


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


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

20.5.2远程更新

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


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

20.5.3远程调试隧道

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

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

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

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


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


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

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

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

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

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

22.接下来读什么

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

第四部分 Spring Boot功能

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

23. SpringApplication

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

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

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

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

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

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

23.1启动失败

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

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

描述：

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

行动：

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


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

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

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

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

23.2自定义横幅

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

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

表23.1。横幅变量

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


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

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

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

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

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

23.3定制SpringApplication

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

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


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

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

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

23.4流利构建器API

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

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

例如：

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


	在创建`ApplicationContext`层次结构时有一些限制，例如，Web组件必须包含在子上下文中，并且`Environment` 将同时用于父和子上下文。请参阅`SpringApplicationBuilder` Javadoc了解详细信息。

23.5应用程序事件和侦听器

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

有些事件实际上ApplicationContext是在创建之前被触发的，所以你不能在这些事件上注册一个监听器@Bean。您可以通过SpringApplication.addListeners(…)或SpringApplicationBuilder.listeners(…) 方法注册。

如果您希望这些监听器自动注册，而不管创建应用程序的方式如何，您可以将META-INF/spring.factories文件添加到项目中并使用该org.springframework.context.ApplicationListener 密钥来引用监听器。

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

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

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


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

23.6网络环境

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

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

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


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

23.7访问应用程序参数

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

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

@Component
公共 类 MyBean {

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

}


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

23.8使用ApplicationRunner或CommandLineRunner

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

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

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

@Component
公共 类 MyBean实现了 CommandLineRunner {

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

}

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

23.9申请退出

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

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

23.10管理员功能

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


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


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

24.外部化配置

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

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

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

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

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

@Component
公共 类 MyBean {

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

    // ...

}

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

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

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

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

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

或命令行参数：

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

或者作为一个JNDI变量java:comp/env/spring.application.json。

24.1配置随机值

这RandomValuePropertySource对注入随机值很有用（例如注入秘密或测试用例）。它可以产生整数，长整数，uuids或字符串，例如

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

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

24.2访问命令行属性

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

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

24.3应用程序属性文件

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

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

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


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

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

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

要么

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


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

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

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


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


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

24.4配置文件特定的属性

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

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

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


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

24.5属性中的占位符

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

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


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

24.6使用YAML而不是属性

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


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

24.6.1加载YAML

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

例如，下面的YAML文件：

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

将被转化为这些属性：

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

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

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

将被转化为这些属性：

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

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

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

    private List  servers = new ArrayList （）;

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

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

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

24.6.3多文件YAML文件

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

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

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

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

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

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

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

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

24.6.4 YAML的缺点

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

24.6.5合并YAML列表

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

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

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

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

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

Spring Boot参考指南

Spring Boot参考指南

作者

第一部分Spring Boot文档

1.关于文档

2.获得帮助

3.第一步

4.使用Spring Boot

5.学习Spring Boot的特性

6.转向生产

7.高级主题

第二部分 入门

8.介绍Spring Boot

9.系统要求

9.1 Servlet容器

10.安装Spring Boot

10.1 Java开发人员的安装说明

10.1.1 Maven安装

10.1.2 Gradle安装

10.2安装Spring Boot CLI

10.2.1手动安装

10.2.2使用SDKMAN安装！

10.2.3 OSX Homebrew安装

10.2.4 MacPorts安装

10.2.5命令行完成

10.2.6快速启动Spring CLI示例

10.3从早期版本的Spring Boot升级

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

11.1创建POM

11.2添加classpath依赖关系

11.3编写代码

11.3.1 @RestController和@RequestMapping注解

11.3.2 @EnableAutoConfiguration注释

11.3.3“主要”方法

11.4运行示例

11.5创建一个可执行的jar

12.接下来读什么

第三部分 使用Spring Boot

13.建立系统

13.1依赖管理

13.2 Maven

13.2.1继承初始父项

13.2.2使用没有父POM的Spring Boot

13.2.3更改Java版本

13.2.4使用Spring Boot Maven插件

13.3 Gradle

13.4蚂蚁

13.5起动

14.构建你的代码

14.1使用“默认”软件包

14.2找到主应用程序类

15.配置类

15.1导入其他配置类

15.2导入XML配置

16.自动配置

16.1逐渐更换自动配置

16.2禁用特定的自动配置

17.春豆和依赖注入

18.使用@SpringBootApplication注释

19.运行你的应用程序

19.1从IDE运行

19.2作为打包应用程序运行

19.3使用Maven插件

19.4使用Gradle插件

19.5热插拔

20.开发人员工具

20.1属性默认值

20.2自动重启

20.2.1排除资源

20.2.2看额外的路径

20.2.3禁用重启

20.2.4使用触发文件

20.2.5定制重启classloader

20.2.6已知的限制

20.3 LiveReload

20.4全局设置

20.5远程应用程序

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

20.5.2远程更新

20.5.3远程调试隧道

第二部分入门

第三部分使用Spring Boot