Spring Boot参考指南

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 Boot都是开源的,包括文档!如果您发现文档有问题,或者如果你只是想改善他们,请参与

3.第一步

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

4.使用Spring Boot

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

5.学习Spring Boot的特性

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

6.转向生产

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

7.高级主题

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

第二部分 入门

如果你刚开始使用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 mavenUbuntu用户可以运行sudo apt-get install maven

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

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

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

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

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

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

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

</项目>
[小费]

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

10.1.2 Gradle安装

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

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

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

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


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

储存库{
    jcenter()
}

依赖{
    编译(“org.springframework.boot:spring-boot-starter-web”
    testCompile(“org.springframework.boot:spring-boot-starter-test”
}

10.2安装Spring Boot CLI

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

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

10.2.1手动安装

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

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

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

10.2.2使用SDKMAN安装!

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

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

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

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

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

你可以看到这样做:

$ sdk ls springboot

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

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

10.2.3 OSX Homebrew安装

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

$ brew tap pivotal / tap
$ brew安装springboot

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

[注意]

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

10.2.4 MacPorts安装

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

$ sudo port install spring-boot-cli

10.2.5命令行完成

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

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

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

10.2.6快速启动Spring CLI示例

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

@RestController
 ThisWillActuallyRun {

    @RequestMapping( “/”)
    String home(){
        “你好,世界!”
    }

}

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

$ spring run app.groovy
[注意]

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

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

你好,世界!

10.3从早期版本的Spring Boot升级

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

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

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

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

[小费]

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

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

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

$ java -version
java版本“1.7.0_51”
Java(TM)SE运行时环境(build 1.7.0_51-b13)
Java HotSpot(TM)64位服务器虚拟机(构建24.51-b03,混合模式)
$ mvn -v
Apache Maven 3.2.3(33f8c3e1027c3ddde99d3cdebad2656a31e8fdf4; 2014-08-11T13:58:10-07:00)
Maven主页:/Users/user/tools/apache-maven-3.1.1
Java版本:1.7.0_51,供应商:甲骨文公司
[注意]

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

11.1创建POM

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

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

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

    <parent> 
        <groupId> org.springframework.boot </ groupId> 
        <artifactId> spring-boot-starter-parent </ artifactId> 
        <version> 1.5.2.RELEASE </ version> 
    </ parent>

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

</项目>

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

[注意]

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

11.2添加classpath依赖关系

Spring Boot提供了许多“入门”,可以方便地将jar添加到你的classpath中。我们的示例应用程序已经spring-boot-starter-parentparentPOM 的 部分中使用。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-webparent部分正下方的依赖关系

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

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

11.3编写代码

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

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

@RestController 
@EnableAutoConfiguration
 public  class Example {

    @RequestMapping( “/”)
    String home(){
        返回 “Hello World!” ;
    }

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

}

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

11.3.1 @RestController和@RequestMapping注解

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

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

[小费]

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

11.3.2 @EnableAutoConfiguration注释

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

11.3.3“主要”方法

我们的应用程序的最后一部分是main方法。这只是一个遵循Java约定的应用程序入口点的标准方法。我们的主要方法是SpringApplication通过调用委托给Spring Boot的runSpringApplication将启动我们的应用程序,启动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依赖项的归档文件。

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

<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

12.接下来读什么

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

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

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

第三部分 使用Spring Boot

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

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

13.建立系统

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

13.1依赖管理

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

[注意]

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

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

[警告]

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

13.2 Maven

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

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

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

13.2.1继承初始父项

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

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

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

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

<properties> 
    <spring-data- releasetrain.version>
 Fowler-SR2 </spring-data-releasetrain.version> </ properties>
[小费]

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

13.2.2使用没有父POM的Spring Boot

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

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

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

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

<dependencyManagement> 
    <依赖性> 
        <! -覆盖由弹簧引导提供弹簧数据释放列车- > 
        <依赖性> 
            <的groupId> org.springframework.data </的groupId> 
            <artifactId的>弹簧数据releasetrain </ artifactId的> 
            <版本> Fowler-SR2 </ version> 
            <scope> import </ scope> 
            <type> pom </ type> 
        </ dependency> 
        <dependency> 
            <groupId> org.springframework.boot </ groupId> 
            <artifactId> spring-boot -dependencies </ artifactId> 
            <version>1.5.2.RELEASE </ version> 
            <type> pom</ type> 
            <scope> import </ scope> 
        </ dependency> 
    </ dependencies> 
</ dependencyManagement>
[注意]

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

13.2.3更改Java版本

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

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

13.2.4使用Spring Boot Maven插件

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

<build> 
    <plugins> 
        <plugin> 
            <groupId> org.springframework.boot </ groupId> 
            <artifactId> spring-boot-maven-plugin </ artifactId> 
        </ plugin> 
    </ plugins> 
</ build>
[注意]

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

13.3 Gradle

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

储存库{
    jcenter()
}

依赖{
    编译(“org.springframework.boot:spring-boot-starter-web:1.5.2.RELEASE”
}

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

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


储存库{
    jcenter()
}

依赖{
    编译(“org.springframework.boot:spring-boot-starter-web”
    testCompile(“org.springframework.boot:spring-boot-starter-test”
}

13.4蚂蚁

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

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

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

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

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

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

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

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

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

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

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

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

13.5起动

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

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

以下应用程序启动程序由Spring Boot提供 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-startersGitHub上的模块。

14.构建你的代码

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

14.1使用“默认”软件包

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

[小费]

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

14.2找到主应用程序类

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

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

这是一个典型的布局:

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

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

 com.example.myproject;

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

@Configuration 
@EnableAutoConfiguration 
@ComponentScan
 public  class Application {

    public  static  void main(String [] args){
        SpringApplication.run(应用,参数);
    }

}

15.配置类

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

[小费]

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

15.1导入其他配置类

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

15.2导入XML配置

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

16.自动配置

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

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

[小费]

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

16.1逐渐更换自动配置

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

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

16.2禁用特定的自动配置

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

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

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

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

[小费]

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

17.春豆和依赖注入

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

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

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

 com.example.service;

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

@Service
公共  DatabaseAccountService实现 AccountService {

    私人 最终 RiskAssessssor风险评估师;

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

    // ...

}

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

@Service
公共  DatabaseAccountService实现 AccountService {

    私人 最终 RiskAssessssor风险评估师;

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

    // ...

}
[小费]

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

18.使用@SpringBootApplication注释

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

@SpringBootApplication注解相当于使用@Configuration, @EnableAutoConfiguration@ComponentScan与他们的默认属性:

 com.example.myproject;

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

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

    public  static  void main(String [] args){
        SpringApplication.run(应用,参数);
    }

}
[注意]

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

19.运行你的应用程序

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

[注意]

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

19.1从IDE运行

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

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

[小费]

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

19.2作为打包应用程序运行

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

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

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

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

19.3使用Maven插件

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

$ mvn spring-boot:运行

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

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

19.4使用Gradle插件

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

$ gradle bootRun

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

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

19.5热插拔

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

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

20.开发人员工具

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

Maven的。 

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

摇篮。 

依赖{
    编译(“org.springframework.boot:spring-boot-devtools”
}

[注意]

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

[小费]

重新打包的档案在默认情况下不包含devtools。如果你想使用 某些远程devtools功能,你需要禁用 excludeDevtoolsbuild属性来包含它。该属性支持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-bootspring-boot-devtoolsspring-boot-autoconfigurespring-boot-actuator,和spring-boot-starter

20.2.1排除资源

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

spring.devtools.restart.exclude =静态/ **,公共/ **
[小费]

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

20.2.2看额外的路径

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

20.2.3禁用重启

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

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

public  static  void main(String [] args){
    System.setProperty(“spring.devtools.restart.enabled”“false”);
    SpringApplication.run(MyApp的,参数);
}

20.2.4使用触发文件

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

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

[小费]

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

20.2.5定制重启classloader

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

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

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

例如:

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

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

[小费]

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

20.2.6已知的限制

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

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

20.3 LiveReload

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

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

[注意]

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

20.4全局设置

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

〜/ .spring引导-devtools.properties。 

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

20.5远程应用程序

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

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

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

spring.devtools.remote.secret = mysecret
[警告]

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

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

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

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

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

  • 选择Run Configurations…​Run菜单。
  • 创建一个新的Java Application“启动配置”。
  • 浏览该my-app项目。
  • 使用org.springframework.boot.devtools.RemoteSpringApplication作为主类。
  • 添加https://myapp.cfapps.ioProgram 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.hostspring.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.gifbanner.jpgbanner.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.outconsole打印横幅logoff)。

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

[注意]

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

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

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让您链在一起的多个方法调用,包括parentchild,让您创建一个层次结构的方法。

例如:

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

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

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

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

23.6网络环境

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

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

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

[小费]

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

23.7访问应用程序参数

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

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

@Component
公共  MyBean {

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

}
[小费]

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

23.8使用ApplicationRunner或CommandLineRunner

如果您需要在启动后运行一些特定的代码SpringApplication,您可以实现ApplicationRunnerCommandLineRunner接口。这两个接口都以相同的方式工作,并提供一个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注释,如果定义了几个CommandLineRunnerApplicationRunnerbean,则必须按特定顺序调用它们。

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命令,旨在让值得注意的重写。属性按以下顺序考虑:

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

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

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

[注意]

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

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

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

要么

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

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

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

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

[注意]

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

[注意]

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

24.4配置文件特定的属性

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

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

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

[注意]

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

24.5属性中的占位符

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

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

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

24.6使用YAML而不是属性

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

[注意]

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

24.6.1加载YAML

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

例如,下面的YAML文件:

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

将被转化为这些属性:

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

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

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

将被转化为这些属性:

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

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

@ConfigurationProperties(prefix =“my”)
 public  class Config {

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

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

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

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

24.6.3多文件YAML文件

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

服务器    地址192.1681.100 
--- 
spring    profiles:开发
 服务器    地址127.00.1 
--- 
春天    配置文件:生产
 服务器    地址192.1681.120

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

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

server  port8000 
--- 
spring  profiles:default
 security  user    password:weak

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

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

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

24.6.4 YAML的缺点

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

24.6.5合并YAML列表

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

例如,假定默认情况下MyPojo具有namedescription属性对象null让我们揭露的名单MyPojo来自FooProperties

@ConfigurationProperties(“foo”)
公共  FooProperties {

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

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

}

考虑以下配置:

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

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

当在多个配置文件中指定一个集合时,将使用具有最高优先级的集合(并且只有那个):

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

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

24.7类型安全的配置属性

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

 com.example;

import java.net.InetAddress;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(“foo”)
公共  FooProperties {

    私有 布尔启用;

    私人 InetAddress remoteAddress;

    私人 最终安全安全= 安全();

    public  boolean isEnabled(){...}

    public  void setEnabled(boolean enabled){...}

    公共 InetAddress getRemoteAddress(){...}

    public  void setRemoteAddress(InetAddress remoteAddress){...}

    公众安全getSecurity(){...}

    公共 静态 安全{

        私人字符串用户名

        私人字符串密码;

        private List <String> roles = new ArrayList <>(Collections.singleton(“USER”));

        public String getUsername(){...}

        public  void setUsername(String username){...}

        public String getPassword(){...}

        public  void setPassword(String password){...}

        public List <String> getRoles(){...}

        public  void setRoles(List <String> roles){...}

    }
}

上面的POJO定义了以下属性:

  • foo.enabledfalse默认情况下
  • foo.remote-address,可以被强制的类型 String
  • foo.security.username,一个嵌套的“安全”,其名称由财产的名称决定。特别是返回类型没有在那里使用,本来可以的SecurityProperties
  • foo.security.password
  • foo.security.roles,与一个集合 String
[注意]

getters和setter通常是强制的,因为绑定是通过标准的Java Beans属性描述符来完成的,就像在Spring MVC中一样。在某些情况下,可以省略setter:

  • 地图,只要他们被初始化,需要一个getter,但不一定是一个setter,因为他们可以被活页夹变异。
  • 集合和数组可以通过索引(通常使用YAML)或使用单个逗号分隔值(属性)来访问。在后一种情况下,二传手是强制性的。我们建议始终为这种类型添加一个setter。如果初始化一个集合,确保它不是不可变的(如上例)
  • 如果嵌套的POJO属性被初始化(如Security上面例子中字段),则不需要setter。如果您希望活页夹使用其默认构造函数即时创建实例,则需要一个setter。

有些人使用Project Lombok来自动添加getter和setter。确保Lombok不会为这种类型生成任何特定的构造函数,因为它将被容器自动使用来实例化对象。

您还需要列出要在@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-address192.1681.1 
    安全性        用户名:foo
         角色
          - 用户
          - 管理员

#根据需要额外配置

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

@Service
公共  MyService {

    私人 最终的 FooProperties属性;

    @Autowired
     public MyService(FooProperties属性){
         this .properties = properties;
    }

     // ...

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

}
[小费]

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

24.7.1第三方配置

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

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

@ConfigurationProperties(prefix =“bar”)
@Bean
 public BarComponent barComponent(){
    ...
}

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

24.7.2轻松绑定

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

例如,给以下@ConfigurationProperties班级:

@ConfigurationProperties(prefix =“person”)
 public  class OwnerProperties {

    私人字符串名字;

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

    public  void setFirstName(String firstName){
         this .firstName = firstName;
    }

}

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

表24.1。放松绑定

属性注意

person.firstName

标准骆驼大小写语法。

person.first-name

虚线符号,推荐用于.properties.yml文件。

person.first_name

下划线表示法,用于.properties.yml文件的替代格式

PERSON_FIRST_NAME

大写格式。建议使用系统环境变量时。


24.7.3属性转换

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

[注意]

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

24.7.4 @ConfigurationProperties验证

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

@ConfigurationProperties(prefix =“foo”)
@Validated
 public  class FooProperties {

    @NotNull
    私人 InetAddress remoteAddress;

    // ... getters和setter

}

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

@ConfigurationProperties(prefix =“connection”)
@Validated
 public  class FooProperties {

    @NotNull
    私人 InetAddress remoteAddress;

    @Valid
    私有 最终安全security = new Security();

    // ... getters和setter

    公共 静态 安全{

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

        // ... getters和setter

    }

}

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

[小费]

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

24.7.5 @ConfigurationProperties与@Value

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

特征@ConfigurationProperties@Value

轻松的绑定

没有

元数据支持

没有

SpEL 评测

没有

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

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

25.简介

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

@Configuration 
@Profile(“production”)
 public  class ProductionConfiguration {

    // ...

}

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

spring.profiles.active = dev,hsqldb

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

25.1添加活动的配置文件

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

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

例如,当与以下属性的应用程序正在使用开关运行 --spring.profiles.active=prodproddbprodmq轮廓也将被激活:

--- 
my.property:fromyamlfile
 --- 
spring.profiles:PROD
 spring.profiles.include
  -  proddb
  -  prodmq
[注意]

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

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

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

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

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

26.记录

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

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

[小费]

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

26.1日志格式

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

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

以下项目被输出:

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

Logback没有一个FATAL级别(它被映射到ERROR

26.2控制台输出

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

$ java -jar myapp.jar --debug
[注意]

你也可以