├── .gitignore ├── README.md ├── config └── application.yml ├── jijicai └── img │ ├── toutiaohao.png │ └── weixin.png ├── spring-boot ├── myproject.iml ├── pom.xml ├── reference │ ├── 00SpringBoot参考指南 │ │ └── 00、SpringBoot参考指南.md │ ├── 01SpringBoot文档 │ │ └── 01、关于文档.md │ ├── 02入门 │ │ ├── 08、SpringBoot介绍.md │ │ ├── 10、安装SpringBoot.md │ │ ├── 11、开发你的第一个SpringBoot应用.md │ │ └── 12、接下来阅读什么.md │ ├── 03使用SpringBoot │ │ ├── 13、构建系统.md │ │ ├── 14、构建你的代码.md │ │ ├── 15、配置类.md │ │ ├── 16、自动配置.md │ │ ├── 17、SpringBeans和依赖注入.md │ │ ├── 18、使用@SpringBootApplication注解.md │ │ ├── 19、运行你的应用.md │ │ ├── 20、开发者工具.md │ │ └── 21~22、打包你的应用程序用于产生.md │ ├── 04SpringBoot功能 │ │ ├── 23、SpringApplication.md │ │ ├── 24、外部化配置.md │ │ ├── 25、配置文件.md │ │ ├── 26、日志.md │ │ ├── 27、国际化.md │ │ ├── 28、JSON.md │ │ ├── 29、开发Web应用程序.md │ │ ├── 30、安全.md │ │ ├── 31、使用SQL数据库.md │ │ ├── 32、使用NoSQL技术.md │ │ ├── 33、缓存.md │ │ ├── 34、消息传递.md │ │ ├── 35、使用RestTemplate调用REST服务.md │ │ ├── 36、使用WebClient调用REST服务.md │ │ ├── 37、验证.md │ │ ├── 38、发送电子邮件.md │ │ ├── 39、使用JTA的分布式事务.md │ │ ├── 40、Hazelcast.md │ │ ├── 41、Quartz调度器.md │ │ ├── 42、任务执行与调度.md │ │ ├── 43、Spring集成.md │ │ ├── 44、Spring会话.md │ │ ├── 45、JMX的监控和管理.md │ │ ├── 46、测试.md │ │ ├── 47、WebSockets.md │ │ ├── 48、Web服务.md │ │ ├── 49、创建你自己的自动配置.md │ │ ├── 50、Kotlin支持.md │ │ └── 51、延伸阅读.md │ ├── 05SpringBootActuator：生产就绪功能 │ │ ├── 52、启用生产就绪功能.md │ │ ├── 53、端点.md │ │ ├── 54、通过HTTP进行监控和管理.md │ │ ├── 55、通过JMX进行监控和管理.md │ │ ├── 56、日志器.md │ │ ├── 57、度量.md │ │ ├── 58、审计.md │ │ ├── 59、HTTP跟踪.md │ │ ├── 60、进程监控.md │ │ ├── 61、CloudFoundry支持.md │ │ └── 62、延伸阅读.md │ ├── 06部署SpringBoot应用程序 │ │ ├── 63、部署到云.md │ │ ├── 64、安装SpringBoot应用程序.md │ │ └── 65、延伸阅读.md │ ├── 07SpringBootCLI │ │ ├── 66、安装CLI.md │ │ ├── 67、使用CLI.md │ │ ├── 68、使用GroovyBeansDSL开发应用程序.md │ │ ├── 69、使用settings.xml配置CLI.md │ │ └── 70、延伸阅读.md │ ├── 08构建工具插件 │ │ ├── 71、SpringBootMaven插件.md │ │ ├── 72、SpringBootGradle插件.md │ │ ├── 73、SpringBootAntLib模块.md │ │ ├── 74、支持的其他构建系统.md │ │ └── 75、延伸阅读.md │ ├── 09操作指南 │ │ ├── 76、SpringBoot应用程序.md │ │ ├── 77、属性和配置.md │ │ ├── 78、嵌入式Web服务器.md │ │ ├── 79、SpringMVC.md │ │ ├── 80、使用SpringSecurity进行测试.md │ │ ├── 81、Jersey.md │ │ ├── 82、HTTP 客户端.md │ │ ├── 83、日志.md │ │ ├── 84、数据访问.md │ │ ├── 85、数据库初始化.md │ │ ├── 86、消息传递.md │ │ ├── 87、批处理应用程序.md │ │ ├── 88、Actuator.md │ │ ├── 89、安全.md │ │ ├── 90、热交换.md │ │ ├── 91、构建.md │ │ └── 92、传统部署.md │ └── 10附录 │ │ ├── A、常见应用程序属性.md │ │ ├── B、配置元数据.md │ │ ├── C、自动配置类.md │ │ ├── D、测试自动配置注解.md │ │ ├── E、可执行Jar格式.md │ │ └── F、依赖项版本.md └── src │ └── main │ ├── java │ └── cn │ │ └── jijicai │ │ └── springboot │ │ ├── Example.java │ │ └── MyConfiguration.java │ └── resources │ └── banner.txt └── spring-framework └── reference ├── 00Spring框架文档 └── 00、Spring框架文档.md └── 01概述 └── 01、Spring框架概述.md /.gitignore: -------------------------------------------------------------------------------- 1 | ### IntelliJ IDEA ### 2 | .idea -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Spring 全家桶（各个版本） 2 | 3 | 这个仓库中我会放置 Spring 系列中各类技术的翻译、教程等，如下所示： 4 | 5 | 1、Spring Boot 参考指南中文版（2.1.6.RELEASE）（已更新完毕）。 6 | 7 | 2、Spring Framework 参考指南中文版（5.2.4.RELEASE）。 8 | 9 | ![image](jijicai/img/weixin.png) 10 | ![image](jijicai/img/toutiaohao.png) 11 | -------------------------------------------------------------------------------- /config/application.yml: -------------------------------------------------------------------------------- 1 | server: 2 | port: 8082 3 | -------------------------------------------------------------------------------- /jijicai/img/toutiaohao.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jijicai/Spring/94b6d91d11bbd928e13ad7a29b7e2739731d89b6/jijicai/img/toutiaohao.png -------------------------------------------------------------------------------- /jijicai/img/weixin.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jijicai/Spring/94b6d91d11bbd928e13ad7a29b7e2739731d89b6/jijicai/img/weixin.png -------------------------------------------------------------------------------- /spring-boot/myproject.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | -------------------------------------------------------------------------------- /spring-boot/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 4 | 4.0.0 5 | 6 | com.example 7 | myproject 8 | 0.0.1-SNAPSHOT 9 | 10 | 11 | 12 | org.springframework.boot 13 | spring-boot-starter-parent 14 | 2.1.6.RELEASE 15 | 16 | 17 | 18 | 19 | 20 | org.springframework.boot 21 | spring-boot-starter-web 22 | 23 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | org.springframework.boot 35 | spring-boot-maven-plugin 36 | 37 | 38 | 39 | 40 | -------------------------------------------------------------------------------- /spring-boot/reference/00SpringBoot参考指南/00、SpringBoot参考指南.md: -------------------------------------------------------------------------------- 1 | # Spring Boot 参考指南 2 | 3 | ## 作者列表 4 | Phillip Webb, Dave Syer, Josh Long, Stéphane Nicoll, Rob Winch, Andy Wilkinson, Marcel Overdijk, Christian Dupuis, Sébastien Deleuze, Michael Simons, Vedran Pavić, Jay Bryant, Madhura Bhave 5 | 6 | ## 版本 7 | 8 | 本文档的版本：2.1.6.RELEASE，与 Spring Boot 对应。 9 | 10 | 11 | ## 版权 12 | 版权 © 2012-2018 13 | 14 | 本文件的复本可供你自己使用及分发予他人，但你不得就该等复本收取任何费用，并且每个副本都包含版权声明，无论以印刷品或电子方式分发。 -------------------------------------------------------------------------------- /spring-boot/reference/01SpringBoot文档/01、关于文档.md: -------------------------------------------------------------------------------- 1 | # 第一部分：Spring Boot 文档 2 | 3 | 本节简要概述了 Spring Boot 参考文档。它作为文档其余部分的参照。 4 | 5 | # 1、关于文档 6 | 7 | 可用的 Spring Boot 参考指南如下： 8 | 9 | （1）[HTML](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html) 10 | 11 | （2）[PDF](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/pdf/spring-boot-reference.pdf) 12 | 13 | （3）[EPUB](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/epub/spring-boot-reference.epub) 14 | 15 | 最新版本在网址：https://docs.spring.io/spring-boot/docs/current/reference 。 16 | 17 | 本文件的复本可供你自己使用及分发予他人，但你不得就该等复本收取任何费用，并且每个副本都包含版权声明，无论以印刷品或电子方式分发。 18 | 19 | # 2、得到帮助 20 | 21 | 如果你有 Spring Boot 的问题，我们愿意帮助你。 22 | 23 | （1）试一下：[操作指南文档](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/howto.html)。它们为最常见的问题提供解决方案。 24 | 25 | （2）学习 Spring 基础知识。Spring Boot 建立在许多其他 Spring 项目的基础上。查看 spring.io 网站以获取大量参考文档。如果你从 Spring 开始，可以尝试其中的一个[指南](https://spring.io/guides)。 26 | 27 | （3）提问问题。我们监视 stackoverflow.com，以查找带有 spring-boot 标记的问题。 28 | 29 | （4）报告 Spring Boot 的 BUG ，在网站：https://github.com/spring-projects/spring-boot/issues 上。 30 | 31 | 注释：Spring Boot 的所有都是开源的，包括文档。如果你发现这些文档有问题，或者如果你想改进它们，请[参与进来](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE)。 32 | 33 | # 3、第一步 34 | 35 | 如果你开始使用 Spring Boot 或“Spring”，请从以下主题开始： 36 | 37 | （1）从头开始： 38 | [概述](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/getting-started-introducing-spring-boot.html) 39 | | [要求](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/getting-started-system-requirements.html) 40 | | [安装](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/getting-started-installing-spring-boot.html) 41 | 42 | （2）教程： 43 | [第一部分](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/getting-started-first-application.html) 44 | | [第二部分](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/getting-started-first-application.html#getting-started-first-application-code) 45 | 46 | （3）运行示例： 47 | [第一部分](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/getting-started-first-application.html#getting-started-first-application-run) 48 | | [第二部分](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/getting-started-first-application.html#getting-started-first-application-executable-jar) 49 | 50 | # 4、和 Spring Boot 一起工作 51 | 52 | 准备好开始使用 Spring Boot 了吗？我们为你提供： 53 | 54 | （1）构建系统： 55 | [Maven](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/using-boot-build-systems.html#using-boot-maven) 56 | | [Gradle](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/using-boot-build-systems.html#using-boot-gradle) 57 | | [Ant](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/using-boot-build-systems.html#using-boot-ant) 58 | | [Starters](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/using-boot-build-systems.html#using-boot-starter) 59 | 60 | （2）最佳实践： 61 | [代码结构](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/using-boot-structuring-your-code.html) 62 | | [@Configuration](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/using-boot-configuration-classes.html) 63 | | [@EnableAutoConfiguration](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/using-boot-auto-configuration.html) 64 | | [Beans 和依赖注入](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/using-boot-spring-beans-and-dependency-injection.html) 65 | 66 | （3）运行代码： 67 | [IDE](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/using-boot-running-your-application.html#using-boot-running-from-an-ide) 68 | | [Packaged](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/using-boot-running-your-application.html#using-boot-running-as-a-packaged-application) 69 | | [Maven](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/using-boot-running-your-application.html#using-boot-running-with-the-maven-plugin) 70 | | [Gradle](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/using-boot-running-your-application.html#using-boot-running-with-the-gradle-plugin) 71 | 72 | （4）打包应用：[用于生产环境的 jars](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/using-boot-packaging-for-production.html) 73 | 74 | （5）Spring Boot CLI：[使用 CLI](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/cli.html) 75 | 76 | # 5、了解 Spring Boot 特性 77 | 78 | 需要了解更多关于 Spring Boot 核心特性的细节吗？以下内容是为你准备的： 79 | 80 | （1）核心特性： 81 | [SpringApplication](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-spring-application.html) 82 | | [外部配置](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-external-config.html) 83 | | [配置文件](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-profiles.html) 84 | | [日志](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-logging.html) 85 | 86 | （2）Web 应用： 87 | [MVC](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-developing-web-applications.html#boot-features-spring-mvc) 88 | | [嵌入式容器](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-developing-web-applications.html#boot-features-embedded-container) 89 | 90 | （3）使用数据： 91 | [SQL](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-sql.html) 92 | | [NO-SQL](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-nosql.html) 93 | 94 | （4）消息传递： 95 | [概述](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-messaging.html) 96 | | [JMS](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-messaging.html#boot-features-jms) 97 | 98 | （5）测试： 99 | [概述](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-testing.html) 100 | | [Spring Boot 应用](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-testing.html#boot-features-testing-spring-boot-applications) 101 | | [Utils](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-testing.html#boot-features-test-utilities) 102 | 103 | （6）扩展： 104 | [自动配置](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-developing-auto-configuration.html) 105 | | [@Conditions](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-developing-auto-configuration.html#boot-features-condition-annotations) 106 | 107 | # 6、转入生产（Moving to Production） 108 | 109 | 当你准备将 Spring Boot 应用投入生产时，我们有一些你可能喜欢的技巧： 110 | 111 | （1）管理端点： 112 | [概述](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/production-ready-endpoints.html) 113 | | [自定义](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/production-ready-endpoints.html#production-ready-endpoints-custom) 114 | 115 | （2）链接选项： 116 | [HTTP](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/production-ready-monitoring.html) 117 | | [JMX](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/production-ready-jmx.html) 118 | 119 | （3）监视： 120 | [度量](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/production-ready-metrics.html) 121 | | [审核](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/production-ready-auditing.html) 122 | | [追踪](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/production-ready-http-tracing.html) 123 | | [流程](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/production-ready-process-monitoring.html) 124 | 125 | # 7、高级主题 126 | 127 | 最后，我们为更高级的用户准备了一些主题： 128 | 129 | （1）Spring Boot 应用部署： 130 | [云部署](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/cloud-deployment.html) 131 | | [OS 服务](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/deployment-install.html#deployment-service) 132 | 133 | （2）构建工具插件： 134 | [Maven](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/build-tool-plugins-maven-plugin.html) 135 | | [Gradle](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/build-tool-plugins-gradle-plugin.html) 136 | 137 | （3）附录： 138 | [应用的属性](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/common-application-properties.html) 139 | | [自动配置类](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/auto-configuration-classes.html) 140 | | [可执行的 jar](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/executable-jar.html) -------------------------------------------------------------------------------- /spring-boot/reference/02入门/08、SpringBoot介绍.md: -------------------------------------------------------------------------------- 1 | # 第二部分：入门 2 | 3 | 如果你正在开始使用 Spring Boot，或者通常是“Spring”，请从阅读本节开始。本节回答了基本的问题：是什么？、怎么做？、为什么？。本节包括 Spring Boot 介绍，及其安装说明。然后，我们带领你构建你的第一个 Spring Boot 应用，同时讨论一些核心的原则。 4 | 5 | # 8、Spring Boot 介绍 6 | 7 | Spring Boot 使你可以轻松地创建独立的、生产级别基于 Spring 的可运行的应用。我们同等对待 Spring 平台和第三方库，这样你就可以轻松入门了。大多数 Spring Boot 应用只需要很少的 Spring 配置。 8 | 9 | 你可以使用 Spring Boot 创建 Java 应用程序，它们可以通过使用命令 java -jar 或更传统的 war 部署启动。我们还提供了一个运行“spring 脚本”的命令行工具。 10 | 11 | 我们的主要目标是： 12 | 13 | （1）为所有 Spring 开发提供一个更快、更容易获得的入门体验。 14 | （2）开箱即用，但要在需求开始偏离默认值时迅速离开。 15 | （3）提供对大型项目类（如嵌入式服务器、安全性、度量标准、健康检查和外部化配置）通用的一系列非功能特性。 16 | （4）完全不需要代码生成，也不需要 XML 配置。 17 | 18 | # 9、系统需求 19 | 20 | Spring Boot 2.1.6.RELEASE 需要 Java 8 ，并且兼容至 Java 11（包括在内）。Spring Framework 5.1.8.RELEASE 或更高版本也是必需的。 21 | 22 | 为以下构建工具提供显示地构建支持： 23 | 24 | |构建工具（Build Tool） |版本（Version）| 25 | |---|---| 26 | |Maven |3.3+| 27 | |Gradle |4.4+| 28 | 29 | ## 9.1 Servlet 容器 30 | 31 | Spring Boot 支持以下嵌入式的 servlet 容器： 32 | 33 | |名称（Nmae） |Servlet 版本（Servlet Version）| 34 | |---|---| 35 | |Tomcat 9.0 |4.0| 36 | |Jetty 9.4 |3.1| 37 | |Undertom 2.0 |4.0| 38 | 39 | 你还可以将 Spring Boot 应用部署到任何 Servlet 3.1+ 兼容的容器中。 40 | -------------------------------------------------------------------------------- /spring-boot/reference/02入门/10、安装SpringBoot.md: -------------------------------------------------------------------------------- 1 | # 10、安装 Spring Boot 2 | 3 | Spring Boot 可以与“经典”Java 开发工具一起使用，也可以作为命令行工具安装。不管怎样，你都需要 Java SDK v1.8 或更高版本。开始之前，应使用以下命令检查当前的 Java 安装： 4 | 5 | $ java -version 6 | 7 | 如果你是 Java 开发的新手，或如果你想体验 Spring Boot，那么你可能需要首先试一下 Spring Boot CLI（Command Line Interface）。否则，请继续阅读“经典”安装说明。 8 | 9 | ## 10.1 Java 开发者的安装说明 10 | 11 | 你可以像使用任何标准 Java 库一样使用 Spring Boot。为此，在类路径中包含适当的 spring-boot-*.jar 文件。Spring Boot 不需要任何特殊的工具集成，因此可以使用任何 IDE 或文本编辑器。此外，Spring Boot 应用没有什么特别之处，因此可以像任何其他 Java 程序一样运行、调试 Spring Boot 应用程序。 12 | 13 | 尽管你可以拷贝 Spring Boot jars，但是我们通常建议你使用一个支持依赖管理的构建工具（例如：Maven 或 Gradle）。 14 | 15 | ### 10.1.1 Maven 安装 16 | 17 | Spring Boot 兼容 Apache Maven 3.3 或以上版本。如果尚未安装 Maven，可以按照 maven.apache.org 网站的说明进行操作。 18 | 19 | 提示：在很多操作系统上，可以用包管理器安装 Maven。如果你使用 OSX Homebrew，则请试一下 brew install maven。Ubuntu 用户可以运行 sudo apt-get install maven。用 Chocolately 的 Windows 用户可以从提升的（管理员）提示符运行 choco install maven 。 20 | 21 | Spring Boot 依赖项使用 org.springframework.boot groupId。通常，Maven POM 文件继承自 spring-boot-starter-parent 项目，并声明一或多个启动器的依赖项。Spring Boot 也提供可选的 Maven 插件来创建可执行的 jars。 22 | 23 | 以下清单展示了一个典型的 pom.xml 文件： 24 | 25 | 26 | 28 | 4.0.0 29 | 30 | com.example 31 | myproject 32 | 0.0.1-SNAPSHOT 33 | 34 | 35 | 36 | org.springframework.boot 37 | spring-boot-starter-parent 38 | 2.1.6.RELEASE 39 | 40 | 41 | 42 | 43 | 44 | org.springframework.boot 45 | spring-boot-starter-web 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | org.springframework.boot 54 | spring-boot-maven-plugin 55 | 56 | 57 | 58 | 59 | 60 | 61 | 提示：spring-boot-startr-parent 是使用 Spring Boot 的一个好方法，但它可能并不总是适合的。有时候，你可能需要继承不同的 parent POM，或者你可能不喜欢我们的默认设置。在这些情况下，请参看 13.2.2 节“在没有 parent POM 的情况下使用 Spring Boot”，以获取使用 import 作用域的替代解决方案。 62 | 63 | ### 10.1.2 Gradle 安装 64 | 65 | Spring Boot 兼容 Gradle 4.4 或以上版本。如果你还没有安装 Gradle，你可以按照 gradle.org 网站的说明进行操作。 66 | 67 | Spring Boot 依赖项可以通过使用 org.springframework.boot group 来声明。通常，项目声明一或多个启动器的依赖项。Spring Boot 提供一个有用的 Gradle 插件，它可以用于简化依赖声明和创建可执行的 jars。 68 | 69 | Gradle 包装器 70 | Gradle 包装器提供了当需要创建项目时一个“获取” Gradle 的好方法。它是一个小脚本和库，你可以将它与代码一起提交以引导构建过程。有关详情，请查看：docs.gradle.org/4.2.1/userguide/gradle_wrapper.html （https://docs.gradle.org/4.2.1/userguide/gradle_wrapper.html）。 71 | 72 | 有关 Spring Boot 和 Gradle 入门的更多详情，请参见 Gradle 插件参考指南的入门部分。 73 | 74 | ## 10.2 安装 Spring Boot CLI 75 | 76 | Spring Boot CLI（Command Line Interface）是一个命令行工具，你可以使用它来快速创建 Spring 原型。它允许你运行 Groovy 脚本，这意味着你有一个熟悉的类似 Java 的语法，而没有那么多样板代码。 77 | 78 | 你不是必须使用 CLI 来处理 Spring Boot，但这绝对是让 Spring 应用程序起步的最快方法。 79 | 80 | ### 10.2.1 手动安装 81 | 82 | 你可以从 Spring 软件仓库下载 Spring CLI 发行版： 83 | 84 | （1）spring-boot-cli-2.1.6.RELEASE-bin.zip（https://repo.spring.io/release/org/springframework/boot/spring-boot-cli/2.1.6.RELEASE/spring-boot-cli-2.1.6.RELEASE-bin.zip） 85 | 86 | （2）spring-boot-cli-2.1.6.RELEASE-bin.tar.gz（https://repo.spring.io/release/org/springframework/boot/spring-boot-cli/2.1.6.RELEASE/spring-boot-cli-2.1.6.RELEASE-bin.tar.gz） 87 | 88 | 还提供了最新的快照分发版。 89 | 90 | 下载后，请按照解压缩的存档文件中的 INSTALL.txt 说明进行操作。总之，在 .zip 文件的 bin/ 目录中有一个 spring 脚本（Wingows中是spring.bat ）。或者，可以将 java -jar 与 .jar 文件一起使用（该脚本帮助你确保类路径设置正确）。 91 | 92 | ### 10.2.2 用 SDKMAN! 安装 93 | 94 | SDKMAN!（软件开发工具包管理器）可用于管理各种二进制 SDK 的多个版本，包括 Groovy 和 Spring Boot CLI。从网站 sdkman.io 得到 SDKMAN!，并且使用以下命令安装 Spring Boot： 95 | 96 | $ sdk install springboot 97 | $ spring --version 98 | Spring Boot v2.1.6.RELEASE 99 | 100 | 如果你开发了 CLI 的功能并希望轻松访问你构建的版本，请使用以下命令： 101 | 102 | $ sdk install springboot dev /path/to/spring-boot/spring-boot-cli/target/spring-boot-cli-2.1.6.RELEASE-bin/spring-2.1.6.RELEASE/ 103 | $ sdk default springboot dev 104 | $ spring --version 105 | Spring CLI v2.1.6.RELEASE 106 | 107 | 前面的指令安装一个名为 dev 实例的 Spring 本地实例。它指向你的目标构建位置，因此每次重新构建 Spring Boot 时，Spring 都是最新的。 108 | 109 | 你可以通过运行以下命令来查看它： 110 | 111 | $ sdk ls springboot 112 | 113 | ================================================================================ 114 | Available Springboot Versions 115 | ================================================================================ 116 | > + dev 117 | * 2.1.6.RELEASE 118 | 119 | ================================================================================ 120 | + - local version 121 | * - installed 122 | > - currently in use 123 | ================================================================================ 124 | 125 | ### 10.2.3 OSX Homebrew 安装 126 | 127 | 如果你在 Mac 上并使用 Homebrew，则可以通过使用以下命令安装 Spring Boot CLI： 128 | 129 | $ brew tap pivotal/tap 130 | $ brew install springboot 131 | 132 | Homebrew 将 spring 安装到 /usr/local/bin 目录中。 133 | 134 | 注释：如果你没有看到 formula，则brew 的安装可能已过期。在这种情况下，请运行 brew update，并重试。 135 | 136 | ### 10.2.4 MacPorts 安装 137 | 138 | 如果你在 Mac 上并使用 MacPorts，则可以使用以下命令安装 Spring Boot CLI： 139 | 140 | $ sudo port install spring-boot-cli 141 | 142 | ### 10.2.5 命令行自动补全 143 | 144 | Spring Boot CLI 包括为 BASH 和 zsh shell 提供命令自动补全的脚本。你可以在任何 shell 中获取脚本（也称为 spring）,也可以将其放入你的个人或系统范围的 bash 自动补全初始化中。在 Debian 系统中，系统范围的脚本位于 /shell-completion/bash 目录中，并且当新 shell 启动时，该目录中的所有脚本都被执行。例如，如果使用 SDKMAN! 安装了该脚本，则可以手动运行它，使用以下命令： 145 | 146 | $ . ~/.sdkman/candidates/springboot/current/shell-completion/bash/spring 147 | $ spring 148 | grab help jar run test version 149 | 150 | 注释：如果你使用 Homebrew 或 MacPorts 来安装 Spring Boot CLI，则命令行自动补全脚本会是和 shell 一起自动注册的。 151 | 152 | ### 10.2.6 Windows Scoop 安装 153 | 154 | 如果你在 Windows 上使用 Scoop，你可以使用以下命令安装 Spring Boot CLI： 155 | 156 | > scoop bucket add extras 157 | > scoop install springboot 158 | 159 | 注释：如果你没有看到 app manifest，则安装的 Scoop 可能已经过期。在这种情况下，请运行 scoop update，并重试。 160 | 161 | ### 10.2.7 快速启动 Spring CLI 示例 162 | 163 | 你可以使用下面的 web 应用程序来测试安装。首先，创建一个名为 app.groovy 的文件，如下所示： 164 | 165 | @RestController 166 | class ThisWillActuallyRun { 167 | 168 | @RequestMapping("/") 169 | String home() { 170 | "Hello World!" 171 | } 172 | 173 | } 174 | 175 | 然后从 shell 中运行它，如下所示： 176 | 177 | $ spring run app.groovy 178 | 179 | 注释：第一次运行应用程序比较慢，因为要加载依赖项。接下来的运行要快得多。 180 | 181 | 在你喜欢的 web 浏览器中打开 localhost:8080。你应该会看到以下输出： 182 | 183 | Hello World! 184 | 185 | ## 10.3 从早期版本的 Spring Boot 升级 186 | 187 | 如果你正在从早期版本的 Spring Boot 升级，则请查看项目 wiki 上提供的详细升级说明的“迁移指南”。还可以查看发布说明，以获得每个版本的新的和值得注意的特性列表。 188 | 189 | 当升级到一个新特性版本时，一些属性可能被重命名或删除。Spring Boot 提供了一种方法，可以在启动时分析应用程环境并打印诊断信息，还可以在运行时为你临时迁移属性。要启用该特性，请将以下依赖项添加到你的项目中： 190 | 191 | 192 | org.springframework.boot 193 | spring-boot-properties-migrator 194 | runtime 195 | 196 | 197 | 警告：后面添加到环境中的属性不会被考虑，例如：@PropertySource。 198 | 注释：一旦你做完迁移，请确保从你的项目依赖列表中移除此模块。 199 | 200 | 要想升级已安装的 CLI，请使用合适的包管理命令（例如：brew upgrade），或者，如果你手动安装了 CLI，请遵循标准说明，记得更新 PATH 环境变量以移除任何旧的引用。 201 | -------------------------------------------------------------------------------- /spring-boot/reference/02入门/11、开发你的第一个SpringBoot应用.md: -------------------------------------------------------------------------------- 1 | # 11、开发你的第一个SpringBoot应用 2 | 3 | 本节介绍如何开发一个简单的“Hello World!”应用程序，它突出了 Spring Boot 的一些关键特性。我们使用 Maven 来构建项目，因为大多数 IDE 都只支持它。 4 | 5 | 提示：spring.io 网站包含许多使用 Spring Boot 的入门指南。如果你需要解决某个特定的问题，请首先查看它们。你可以通过转到 start.spring.io 并从依赖项搜索器中选择“Web”启动器来简化以下步骤。这样做会生成一个新的项目结构，这样你就可以立即开始编码了。请参阅 Spring Initializr 文档以获得更多详细信息。 6 | 7 | 在开始之前，请打开终端并运行以下命令，以确保安装了有效的 Java 和Maven 版本： 8 | 9 | $ java -version 10 | java version "1.8.0_102" 11 | Java(TM) SE Runtime Environment (build 1.8.0_102-b14) 12 | Java HotSpot(TM) 64-Bit Server VM (build 25.102-b14, mixed mode) 13 | 14 | $ mvn -v 15 | Apache Maven 3.5.4 (1edded0938998edf8bf061f1ceb3cfdeccf443fe; 2018-06-17T14:33:14-04:00) 16 | Maven home: /usr/local/Cellar/maven/3.3.9/libexec 17 | Java version: 1.8.0_102, vendor: Oracle Corporation 18 | 19 | 注释：这个示例需要在它自己的文件夹中创建。后续说明假设您已经创建了一个合适的文件夹，并且它是你的当前目录。 20 | 21 | ## 11.1 创建 POM 22 | 23 | 我们需要从创建一个 Maven pom.xml 文件开始。这个 pom.xml 文件是一个用于构建项目的配方。打开你喜欢的文本编辑器，并添加以下内容： 24 | 25 | 26 | 28 | 4.0.0 29 | 30 | com.example 31 | myproject 32 | 0.0.1-SNAPSHOT 33 | 34 | 35 | org.springframework.boot 36 | spring-boot-starter-parent 37 | 2.1.6.RELEASE 38 | 39 | 40 | 41 | 42 | 43 | 44 | 前面的清单应该为你提供一个工作构建。你可以通过运行 mvn package 包来测试它（现在，你可以忽略警告“jar 将为空-没有内容被标记为包含！”）。 45 | 46 | 注释：此时，你可以将项目导入到 IDE 中（大多数现代 Java IDEs 包含对 Maven 的内置支持）。为了简单起见，我们在本例中继续使用纯文本编辑器。 47 | 48 | ## 11.2 添加类路径依赖项 49 | 50 | Spring Boot 提供了许多 “Starters”，可以将 jars 添加到类路径中。我们的示例应用已经在 POM 的 parent 部分中使用了 spring-boot-starter-parent。spring-boot-starter-parent 是一个特殊的启动器，它提供了有用的 Maven 默认设置。它还提供了一个 dependency-management 部分，这样你就可以省略依赖项的版本标记。 51 | 52 | 其他“Starters”提供了当开发特定类型的应用时可能需要的依赖项。由于我们正在开发一个 web 应用，所以我们添加 spring-boot-starter-web 依赖项。在此之前，我们可以通过运行以下命令查看当前有的依赖项： 53 | 54 | $ mvn dependency:tree 55 | 56 | [INFO] com.example:myproject:jar:0.0.1-SNAPSHOT 57 | 58 | mvn dependency:tree 命令打印树表示的项目依赖项。你可以看到 spring-boot-starter-parent 本身不提供依赖项。要添加这个必要的依赖项，请编辑pom.xml，并且立即在 parent 部分的下面添加 spring-boot-starter-web 依赖项： 59 | 60 | 61 | 62 | org.springframework.boot 63 | spring-boot-starter-web 64 | 65 | 66 | 67 | 如果你再次运行：mvn dependency:tree，你会看到现在有许多附加的依赖项，包括 Tomcat web 服务器和 Spring boot 本身。 68 | 69 | ## 11.3 编写代码 70 | 71 | 为了完成我们的应用程序，我们需要创建一个 Java 文件。默认情况下，Maven 编译“src/main/java”路径中的源代码，因此你需要创建该文件夹结构，然后添加一个名为"src/main/java/Example.java"文件，用于包含以下代码： 72 | 73 | import org.springframework.boot.*; 74 | import org.springframework.boot.autoconfigure.*; 75 | import org.springframework.web.bind.annotation.*; 76 | 77 | @RestController 78 | @EnableAutoConfiguration 79 | public class Example { 80 | 81 | @RequestMapping("/") 82 | String home() { 83 | return "Hello World!"; 84 | } 85 | 86 | public static void main(String[] args) { 87 | SpringApplication.run(Example.class, args); 88 | } 89 | 90 | } 91 | 92 | 虽然这里没有太多的代码，但是正在进行很多工作。我们将在接下来的几节中逐步介绍重要的部分。 93 | 94 | ### 11.3.1 注解：@RestController 和 @RequestMapping 95 | 96 | 我们的 Example 类的第一个注解是 @RestController。这就是所谓的原型注解。它为阅读代码的人和 Spring 提供了类扮演特定角色的提示。在本例中，我们的类是 web @Controller，因此 Spring 在处理传入的 web 请求时会考虑它。 97 | 98 | @RequestMapping 注解提供了“路由”信息。它告诉 Spring 任何路径为 / 的 HTTP 请求都应当被映射到 home 方法。@RestController 注解告诉 Spring 将渲染的结果字符串直接返回给调用者。 99 | 100 | 提示：@RestController 和 @RequestMapping 注解是 Spring MVC 注解（它们不是 Spring Boot 特有的）。有关更多详情，请查看 Spring 参考文档中的 MVC 部分。 101 | 102 | ### 11.3.2 @EnableAutoConfiguration 注解 103 | 104 | 第二个类级别注解是 @EnableAutoConfiguration。这个注解告诉 Spring Boot 根据你添加的 jar 依赖项“猜测”你想要如何配置 Spring。由于 spring-boot-starter-web 添加了 Tomcat 和 Spring MVC，因此自动配置假定你正在开发一个 web 应用程序并相应地设置 Spring。 105 | 106 | **启动器和自动配置** 107 | 108 | 自动配置被设为可以很好地与启动器一起工作，但是这两个概念并没有直接捆绑在一起。你可以在启动器之外自由地选择 jar 依赖项。Spring Boot 仍然尽力自动配置应用程序。 109 | 110 | ### 11.3.3 “main” 方法 111 | 112 | 我们应用的最后一部分是 main 方法。这只是一个遵循 Java 约定的应用程序入口点的标准方法。我们的 main 方法通过调用 run 方法来委托给 Spring Boot 的 SpringApplication 类。SpringApplication 引导我们的应用程序，启动 Spring，然后启动自动配置的 Tomcat web 服务器。我们需要将 Example.class 作为一个参数传递给 run 方法，以告诉 SpringApplication 哪个是主 Spring 组件。数组 args 也被传递来公开任何命令行参数。 113 | 114 | ## 11.4 运行示例 115 | 116 | 此时，你的应用程序应该可以工作了。由于使用了 spring-boot-starter-parent POM，因此你有了一个有用的 run 目标，可以用来启动应用程序。在项目的根目录中，敲下命令：mvn spring-boot:run，来启动应用程序。你应该可以看到与下面相似的输出： 117 | 118 | $ mvn spring-boot:run 119 | 120 | . ____ _ __ _ _ 121 | /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ 122 | ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ 123 | \\/ ___)| |_)| | | | | || (_| | ) ) ) ) 124 | ' |____| .__|_| |_|_| |_\__, | / / / / 125 | =========|_|==============|___/=/_/_/_/ 126 | :: Spring Boot :: (v2.1.6.RELEASE) 127 | ....... . . . 128 | ....... . . . (log output here) 129 | ....... . . . 130 | ........ Started Example in 2.222 seconds (JVM running for 6.514) 131 | 132 | 如果你打开浏览器访问：localhost:8080，你应该会看到以下输出： 133 | 134 | Hello World! 135 | 136 | 要优雅地退出应用程序，请按 ctrl-c。 137 | 138 | ## 11.5 创建一个可执行的 jar 文件 139 | 140 | 我们通过创建一个完全自包含的可执行 jar 文件来完成我们的示例，该文件可以在生成环境中运行。可执行 jar（有时候称为“胖 jar”）是包含编译类以及代码需要运行的所有 jar 依赖项的归档文件。 141 | 142 | **可执行的 jars 和 Java** 143 | 144 | Java 不提供加载嵌套 jar 文件（jar 文件本身包含在一个 jar 中）的标准方法。如果你希望发布一个自包含的应用程序，这可能会有问题。 145 | 146 | 为了解决这个问题，许多开发者使用“uber” jars。一个 uber jar 将应用程序的所有依赖项的所有类都打包到单个归档文件中。这种方法的问题是很难看出应用程序中有哪些库。如果在多个 jar 中使用相同的文件名（但内容不同），也可能会出现问题。 147 | 148 | Spring Boot 采用了一种不同的方法，允许你直接嵌套 jar。 149 | 150 | 要创建一个可执行 jar，我们需要将 spring-boot-maven-plugin 添加到 pom.xml 文件中。为此，请在 dependencies 部分的下面插入以下行： 151 | 152 | 153 | 154 | 155 | org.springframework.boot 156 | spring-boot-maven-plugin 157 | 158 | 159 | 160 | 161 | 注释：spring-boot-starter-parent POM 包含绑定 repackage 目标的 配置。如果你不使用 parent POM，则你需要自己声明此配置。有关详情，请参阅插件文档。（https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/maven-plugin/usage.html） 162 | 163 | 保存 pom.xml 并从命令行运行：mvn package，如下所示： 164 | 165 | $ mvn package 166 | 167 | [INFO] Scanning for projects... 168 | [INFO] 169 | [INFO] ------------------------------------------------------------------------ 170 | [INFO] Building myproject 0.0.1-SNAPSHOT 171 | [INFO] ------------------------------------------------------------------------ 172 | [INFO] .... .. 173 | [INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ myproject --- 174 | [INFO] Building jar: /Users/developer/example/spring-boot-example/target/myproject-0.0.1-SNAPSHOT.jar 175 | [INFO] 176 | [INFO] --- spring-boot-maven-plugin:2.1.6.RELEASE:repackage (default) @ myproject --- 177 | [INFO] ------------------------------------------------------------------------ 178 | [INFO] BUILD SUCCESS 179 | [INFO] ------------------------------------------------------------------------ 180 | 181 | 如果你查看 target 目录，你应该会看到 myproject-0.0.1-SANPSHOT.jar。这个文件应该在 10 MB 左右。如果你想查看内部，可以使用：jar tvf，如下所示： 182 | 183 | $ jar tvf target/myproject-0.0.1-SNAPSHOT.jar 184 | 185 | 你还应该在 target 目录中看到一个更小的文件 myproject-0.0.1-SNAPSHOT.jar.original。这是 Spring Boot 重新打包之前的Maven 创建的原始 jar 文件。 186 | 187 | 要运行该应用程序，请使用 java -jar 命令，如下所示： 188 | 189 | $ java -jar target/myproject-0.0.1-SNAPSHOT.jar 190 | 191 | . ____ _ __ _ _ 192 | /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ 193 | ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ 194 | \\/ ___)| |_)| | | | | || (_| | ) ) ) ) 195 | ' |____| .__|_| |_|_| |_\__, | / / / / 196 | =========|_|==============|___/=/_/_/_/ 197 | :: Spring Boot :: (v2.1.6.RELEASE) 198 | ....... . . . 199 | ....... . . . (log output here) 200 | ....... . . . 201 | ........ Started Example in 2.536 seconds (JVM running for 2.864) 202 | 203 | 和之前一样，要退出应用程序，请按 ctrl-c。 204 | -------------------------------------------------------------------------------- /spring-boot/reference/02入门/12、接下来阅读什么.md: -------------------------------------------------------------------------------- 1 | # 12、接下来阅读什么（What to Read Next） 2 | 3 | 希望本节提供了一些 Spring Boot 基础知识，并帮助你编写自己的应用程序。如果你是一个面向任务的开发者，你也许想跳到 spring.io 网站，并查看一些入门指南，以解决特定的“怎样用 Spring 做那件事？”问题。我们也有特定于 Spring Boot 的“如何”参考文档。（https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/howto.html） 4 | 5 | Spring Boot 仓库还有一组可以运行的示例。样例独立于代码的其余部分（也就是说，你不需要构建其余部分来运行或使用样例）。 6 | 7 | 否则，下一个逻辑步骤是阅读第三部分，“使用 Spring Boot”。如果你真的很不耐烦，你也可以跳到后面去阅读关于 Spring Boot 特性的文章。（https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features.html） 8 | -------------------------------------------------------------------------------- /spring-boot/reference/03使用SpringBoot/14、构建你的代码.md: -------------------------------------------------------------------------------- 1 | # 14、构建你的代码 2 | 3 | Spring Boot 不需要任何特定的代码布局就可以工作。然而，有一些最佳实践可以提供帮助。 4 | 5 | ## 14.1、使用“默认”包 6 | 7 | 当一个类不包含 package 声明时，就认为它在“默认包”中。通常不鼓励使用“默认包”，应该避免。对于使用 @ComponentScan、@EntityScan 或 @SpringBootApplication 注解的 Spring Boot 应用，它可能会导致特定的问题，因为每个 jar 中的每个类都被读取。 8 | 9 | 提示：我们建议你遵循 Java 推荐的包命名约定，并使用反向域名（例如：com.example.project）。 10 | 11 | ## 14.2、定位主应用程序类 12 | 13 | 我们通常建议将主应用类放在根包中，在其他类之上。@SpringBootApplication 注解通常放在主类上，它隐式地为某些项定义了一个基本的“搜索包”。例如，如果你正在编写一个 JPA 应用，那么 @SpringBootApplication 注解类的包将用于搜索 @Entity 项。使用根包还允许组件扫描仅应用于你的项目。 14 | 15 | 提示：如果你不想使用 @SpringBootApplication，则它导入的 @EnableAutoConfiguration 和 @ComponentScan 注解定义了该行为，因此也可以使用。 16 | 17 | 下面的清单展示了一个典型的布局： 18 | ``` 19 | com 20 | +- example 21 | +- myapplication 22 | +- Application.java 23 | | 24 | +- customer 25 | | +- Customer.java 26 | | +- CustomerController.java 27 | | +- CustomerService.java 28 | | +- CustomerRepository.java 29 | | 30 | +- order 31 | +- Order.java 32 | +- OrderController.java 33 | +- OrderService.java 34 | +- OrderRepository.java 35 | ``` 36 | Application.java 文件声明 main 方法，带有基础的 @SpringBootApplication 注解，如下： 37 | ``` 38 | package com.example.myapplication; 39 | 40 | import org.springframework.boot.SpringApplication; 41 | import org.springframework.boot.autoconfigure.SpringBootApplication; 42 | 43 | @SpringBootApplication 44 | public class Application { 45 | 46 | public static void main(String[] args) { 47 | SpringApplication.run(Application.class, args); 48 | } 49 | 50 | } 51 | ``` 52 | -------------------------------------------------------------------------------- /spring-boot/reference/03使用SpringBoot/15、配置类.md: -------------------------------------------------------------------------------- 1 | # 15.配置类 2 | 3 | Spring Boot 支持基于 Java 的配置类。尽管可以将 SpringApplication 与 XML 源一起使用，但我们通常建议你的主要源是单个 @Configuration 类。通常，定义 main 方法的类是主 @Configuration 的最佳候选类。 4 | 5 | 提示：许多 Spring 配置样例在互联网上已经发布，它们使用 XML 配置。如果可能，始终尝试使用等价的基于 Java 的配置。搜索 Enable* 注解可能是一个很好的起点。 6 | 7 | ## 15.1 导入其他配置类 8 | 9 | 你不需要将所有的 @Configuration 都放在一个类中。可以使用 @Import 注解导入其他配置类。或者，你可以使用 @ComponentScan 自动获取所有 Spring 组件，其中包括 @Configuration 类。 10 | 11 | ## 15.2 导入 XML 配置 12 | 13 | 如果你必须使用基于 XML 的配置，我们建议你仍然从 @Configuration 类开始。然后，你可以使用 @ImportResource 注解来加载 XML 配置文件。 14 | 15 | 16 | -------------------------------------------------------------------------------- /spring-boot/reference/03使用SpringBoot/16、自动配置.md: -------------------------------------------------------------------------------- 1 | # 16、自动配置 2 | 3 | Spring Boot 自动配置尝试根据你添加的 jar 依赖项自动配置 Spring 应用。例如，如果 HSQLDB 在你的类路径上，并且你没有手动配置任何数据库连接 beans，那么 Spring Boot 将会自动配置内存中的数据库。 4 | 5 | 你需要通过将 @EnableAutoConfiguration 或 @SpringBootApplication 注解添加到一个 @Configuration 类来选择自动配置。 6 | 7 | 提示：你应当永远仅添加一个 @SpringBootApplication 或 @EnableAutoConfiguration 注解。我们通常建议只向主 @Configuration 类添加一个或另一个。 8 | 9 | ## 16.1 逐渐取代自动配置 10 | 11 | 自动配置是无创的。在任何时候，你都能够开始定义自己的配置来替换自动配置的特定部分。例如，如果你添加了自己的数据源（DataSource）bean，则默认的嵌入式数据库支持将后退。 12 | 13 | 如果你需要了解当前应用的是什么自动配置，以及为什么，则可以切换到调试模式（--debug）来启动应用。这样做可以为选择的核心日志记录器启用调试日志，并将条件报告记录到控制台。 14 | 15 | ## 16.2 禁用特定的自动配置类 16 | 17 | 如果你发现应用了不想要的特定的自动配置类，则你可以使用 @EnableAutoConfiguration 的 exclude 属性来禁用它们，如下面示例所示： 18 | 19 | import org.springframework.boot.autoconfigure.*; 20 | import org.springframework.boot.autoconfigure.jdbc.*; 21 | import org.springframework.context.annotation.*; 22 | 23 | @Configuration 24 | @EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class}) 25 | public class MyConfiguration { 26 | } 27 | 28 | 如果某个类不在类路径中，则你可以使用该注解的excludeName 属性并指定完全限定名。最后，你还可以通过使用 spring.autoconfigure.exclude 属性来控制要排除的自动配置类的列表。 29 | 30 | 提示：你可以同时在注解级别和通过使用该属性定义排除项。 31 | 32 | 33 | -------------------------------------------------------------------------------- /spring-boot/reference/03使用SpringBoot/17、SpringBeans和依赖注入.md: -------------------------------------------------------------------------------- 1 | # 17、Spring Beans 和依赖注入 2 | 3 | 你可以自由地使用任何标准的 Spring Framework 技术来定义 beans 及其注入的依赖项。为简单起见，我们经常发现使用 @ComponentScan（查找 beans）和 @Autowired（执行构造函数注入）工作得很好。 4 | 5 | 如果按照上面的建议构造你的代码（将应用程序类放在根包中），则可以添加 @ComponentScan 而无需任何参数。所有应用程序组件（@Component、@Service、@Repository、@Controller 等等）都自动注册为 Spring Beans。 6 | 7 | 下面的示例展示了 @Service bean 使用构造方法注入来获取所需的 RiskAssessor bean： 8 | 9 | package com.example.service; 10 | 11 | import org.springframework.beans.factory.annotation.Autowired; 12 | import org.springframework.stereotype.Service; 13 | 14 | @Service 15 | public class DatabaseAccountService implements AccountService { 16 | 17 | private final RiskAssessor riskAssessor; 18 | 19 | @Autowired 20 | public DatabaseAccountService(RiskAssessor riskAssessor) { 21 | this.riskAssessor = riskAssessor; 22 | } 23 | 24 | // ... 25 | 26 | } 27 | 28 | 如果 bean 有一个构造方法，你可以省略 @Autowired，如下面的示例所示： 29 | 30 | @Service 31 | public class DatabaseAccountService implements AccountService { 32 | 33 | private final RiskAssessor riskAssessor; 34 | 35 | public DatabaseAccountService(RiskAssessor riskAssessor) { 36 | this.riskAssessor = riskAssessor; 37 | } 38 | 39 | // ... 40 | 41 | } 42 | 43 | 提示：请注意，使用构造方法注入可以将 riskAssessor 字段标记为 final，表示它随后不能更改。 44 | -------------------------------------------------------------------------------- /spring-boot/reference/03使用SpringBoot/18、使用@SpringBootApplication注解.md: -------------------------------------------------------------------------------- 1 | # 18、使用 @SpringBootApplication 注解 2 | 3 | 许多 Spring Boot 开发者希望他们的应用使用自动配置、组件扫描，并且能够在“应用程序类”中定义额外的配置。可以使用单个 @SpringBootApplication 注解来启用这三个特性，它们是： 4 | 5 | （1）@EnableAutoConfiguration：启动 Spring Boot 自动配置机制。 6 | （2）@ComponentScan：在应用程序所在的包上启用 @Component 扫描。 7 | （3）@Configuration：允许在上下文中注册额外的 beans 或者导入 其他配置类。 8 | 9 | @SpringBootApplication 注解等价于使用具有默认属性的 @Configuration、@EnableAutoConfiguration 和 @ComponentScan，如下面的示例所示： 10 | 11 | package com.example.myapplication; 12 | 13 | import org.springframework.boot.SpringApplication; 14 | import org.springframework.boot.autoconfigure.SpringBootApplication; 15 | 16 | @SpringBootApplication // same as @Configuration @EnableAutoConfiguration @ComponentScan 17 | public class Application { 18 | 19 | public static void main(String[] args) { 20 | SpringApplication.run(Application.class, args); 21 | } 22 | 23 | } 24 | 25 | 注释：@SpringBootApplication 还提供了别名来定制 @EnableAutoConfiguration 和 @ComponentScan 的属性。 26 | 27 | 注释：这些功能都不是强制的，你可以选择用它启用的任何功能来替换单个注解。例如，你也许不想在应用中使用组件扫描： 28 | 29 | package com.example.myapplication; 30 | 31 | import org.springframework.boot.SpringApplication; 32 | import org.springframework.context.annotation.ComponentScan 33 | import org.springframework.context.annotation.Configuration; 34 | import org.springframework.context.annotation.Import; 35 | 36 | @Configuration 37 | @EnableAutoConfiguration 38 | @Import({ MyConfig.class, MyAnotherConfig.class }) 39 | public class Application { 40 | 41 | public static void main(String[] args) { 42 | SpringApplication.run(Application.class, args); 43 | } 44 | 45 | } 46 | 47 | 注解：在本例子中，Application 与其他任何 Spring Boot 应用一样，只是不会自动检测 @Component 的类，并且显示地导入了用户定义的 bean（参见 @Import）。 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | -------------------------------------------------------------------------------- /spring-boot/reference/03使用SpringBoot/19、运行你的应用.md: -------------------------------------------------------------------------------- 1 | # 19、运行你的应用 2 | 3 | 把应用打包为 jar 并使用嵌入式 HTTP 服务器最大的好处之一是可以像运行其他应用一样运行你的应用。调试 Spring Boot 应用程序也很容易。你不需要任何特定的 IDE 插件或扩展。 4 | 5 | 注释：本节只介绍基于 jar 的打包。如果你选择将应用程序打包为 war 文件，你应当参考你的服务器和 IDE 文档。 6 | 7 | ## 19.1、在 IDE 中运行 8 | 9 | 你可以从 IDE 运行一个 Spring Boot 应用程序，将其作为一个简单的 Java 应用程序。但是，首先需要导入项目。导入步骤因 IDE 和 构建系统而异。大多数 IDE 可以直接将 Maven 项目导入。例如，Eclipse 用户可以从“文件”菜单中选择“导入...->现有的 Maven 项目”。 10 | 11 | 如果你不能直接将项目导入到 IDE，则你也许能通过使用构建插件来生成 IDE 元数据。Maven 包括 Eclipse 和 IDEA 的插件。Gradle 提供各种 IDE 的插件。 12 | 13 | 提示：如果意外地运行了两次 web 应用，则会看到“端口已经占用”的错误。STS 用户可以使用“重新运行”按钮而不使用“运行”按钮，以此来确保任何现有的实例都已关闭。 14 | 15 | ## 19.2、作为打包的应用程序运行 16 | 17 | 如果使用 Spring Boot Maven 或 Gradle 插件创建可执行的 jar，则可以使用 java -jar 运行应用，如下面示例所示： 18 | 19 | $ java -jar target/myapplication-0.0.1-SNAPSHOT.jar 20 | 21 | 还可以在启用远程调试支持的情况下运行打包的应用程序。这样做可以将调试器附加到打包的应用程序中，如下面示例所示： 22 | 23 | java -Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n \ 24 | -jar target/myapplication-0.0.1-SNAPSHOT.jar 25 | 26 | ## 19.3、使用 Maven 插件 27 | 28 | Spring Boot Maven 插件包括一个 run 目标，它可以用于快速编译和运行应用。应用以分解的形式运行，就像在 IDE 中一样。下面的示例展示了运行 Spring Boot 应用的典型 Maven 命令： 29 | 30 | $ mvn spring-boot:run 31 | 32 | 你可能还希望使用 MAVEN_OPTS 操作系统环境变量，如下面示例所示： 33 | 34 | $ export MAVEN_OPTS=-Xmx1024m 35 | 36 | ## 19.4、使用 Gradle 插件 37 | 38 | Spring Boot Gradle 插件包含一个 bootRun 任务，它可以用于以分解的形式运行应用。每当应用 org.springframework.boot 和 java 插件时，都会添加 bootRun，如下面示例所示： 39 | 40 | $ gradle bootRun 41 | 42 | 你可能还希望使用 JAVA_OPTS 操作系统环境变量，如下面示例所示： 43 | 44 | $ export JAVA_OPTS=-Xmx1024m 45 | 46 | ## 19.5、热交换（Hot Swapping） 47 | 48 | 由于 Spring Boot 应用只是普通的 Java 应用，JVM 热交换应该是现成的。JVM 热交换在某种程度上受限于它可以替换的字节码。对于更完整的解决方案，可以使用 JRebel。 49 | 50 | spring-boot-devtools 模块还支持快速应用重启。有关详细信息，请参阅本章后面的第 20 章“开发者工具”部分和热交换“如何”部分。 51 | -------------------------------------------------------------------------------- /spring-boot/reference/03使用SpringBoot/21~22、打包你的应用程序用于产生.md: -------------------------------------------------------------------------------- 1 | # 21、打包你的应用程序用于生产 2 | 3 | 可执行的 jar 可以用于生产部署。由于它们是自包含的，因此也非常适合于基于云的部署。 4 | 5 | 对于其它“生产就绪”的功能，例如：健康、审计和度量 REST 或 JMX 端点，请考虑添加 spring-boot-actuator。有关详情，请查看第五部分：Spring Boot Actuator：生产就绪功能。 6 | 7 | # 22、接下来阅读什么 8 | 9 | 现在你应该了解如何使用 Spring Boot 以及应该遵循的一些最佳实践。现在，你可以继续深入了解特定的 Spring Boot 特性，也可以跳到后面，阅读 Spring Boot 的“[生产就绪](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/production-ready.html)”方面的内容。 10 | -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/25、配置文件.md: -------------------------------------------------------------------------------- 1 | # 25、配置文件 2 | 3 | Spring Profiles 提供了一种方法来隔离应用程序配置的各个部分，并使其仅在某些环境中可用。任何 @Component 或 @Configuration 都可以用 @Profile 标记，以便限制加载时间，如下面的示例所示： 4 | ``` 5 | @Configuration 6 | @Profile("production") 7 | public class ProductionConfiguration { 8 | 9 | // ... 10 | 11 | } 12 | ``` 13 | 你可以使用 spring.profiles.active Environment 属性来指定激活哪个 profiles。你可以用前面章节描述的任何方式指定属性。例如，你可以在 application.properties 中包括它，如下面示例所示： 14 | 15 | spring.profiles.active=dev,hsqldb 16 | 17 | 通过使用 --spring.profiles.active=dev,hsqldb，你还可以在命令行上指定它。 18 | 19 | ## 25.1、添加活动配置文件 20 | 21 | spring.profiles.active 属性遵循与其他属性相同的排序规则：最高的 PropertySource 获胜。这意味着你可以在 application.properties 中指定活动的 profiles，然后通过使用命令行开关替换它们。 22 | 23 | 有时，将特定 profile 的属性添加到活动的 profiles 而不是替换它们是很有用的。spring.profiles.include 属性可用于无条件添加活动的 profiles。SpringApplication 入口点还有一个用于设置其他 profiles 的 Java API（也就是说，在 spring.profiles.active 属性激活的对象之上）。请查看 SpringApplication 中的 setAdditionalProfiles() 方法。 24 | 25 | 例如，当带以下属性的应用程序通过使用开关：--spring.profiles.active=prod 运行时，proddb 和 prodmq profiles 也被激活： 26 | 27 | --- 28 | my.property: fromyamlfile 29 | --- 30 | spring.profiles: prod 31 | spring.profiles.include: 32 | - proddb 33 | - prodmq 34 | 35 | 注释：请记住，可以在 YAML 文档中定义 spring.profiles 属性，以确定配置中何时包含此特定文档。详见[第 77.7 节：根据环境更改配置](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/howto-properties-and-configuration.html#howto-change-configuration-depending-on-the-environment)。 36 | 37 | ## 25.2、以编程方式设置配置文件 38 | 39 | 在运行应用程序之前，可以通过调用 SpringApplication.setAdditionalProfiles(…​)以编程方式设置活动的 profiles。也可以使用 Spring 的 ConfigurableEnvironment 接口激活 profiles。 40 | 41 | ## 25.3、特定 profile 的配置文件 42 | 43 | application.properties（或 application.yml）和通过 @ConfigurationProperties 引用的文件，这两者的特定 profile 变体都被视为文件并被加载。详见[第 24.4 节：特定 profile 的属性](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-external-config.html#boot-features-external-config-profile-specific-properties)。 44 | -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/27、国际化.md: -------------------------------------------------------------------------------- 1 | # 27、国际化 2 | 3 | Spring Boot 支持本地化消息，因此你的应用程序可以满足不同语言偏好的用户。默认情况下，Spring Boot 会在类路径根目录中查找是否存在 messages 资源包。 4 | 5 | 注释：当配置的资源包的默认属性文件可用时（即默认情况下为 messages.properties），将应用自动配置。如果资源包仅包含特定语言的属性文件，则需要添加默认值。 6 | 7 | 可以使用 spring.messages 命名空间配置资源包的基名以及其他几个属性，如下面示例所示： 8 | 9 | spring.messages.basename=messages,config.i18n.messages 10 | spring.messages.fallback-to-system-locale=false 11 | 12 | 提示：spring.messages.basename 支持以逗号分隔的位置列表，可以是包限定符，也可以是从类路径根解析的资源。 13 | 14 | 有关更多支持的选项，请参见 [MessageSourceProperties](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/context/MessageSourceProperties.java)。 -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/28、JSON.md: -------------------------------------------------------------------------------- 1 | # 28、JSON 2 | 3 | Spring Boot 提供了与三个 JSON 映射库的集成： 4 | 5 | （1）Gson 6 | （2）Jackson 7 | （3）JSON-B 8 | 9 | Jackson 是首选和默认库。 10 | 11 | ## 28.1、Jackson 12 | 13 | 提供了 Jackson 的自动配置，Jackson 是 spring-boot-starter-json 的一部分。当 Jackson 在类路径上时，会自动配置一个 ObjectMapper bean。为[自定义 ObjectMapper 的配置](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/howto-spring-mvc.html#howto-customize-the-jackson-objectmapper)提供了几个配置属性。 14 | 15 | ## 28.2、Gson 16 | 17 | 提供 Gson 的自动配置。当 Gson 位于类路径上时，将自动配置 Gson bean。提供了几个 spring.gson.* 配置属性来定制配置。要获得更多控制，可以使用一个或多个 GsonBuilderCustomizer bean。 18 | 19 | ## 28.3、JSON-B 20 | 21 | 提供了 JSON-B 的自动配置。当 JSON-B API 和其一个实现在类路径上时，Jsonb bean 将自动配置。首选的 JSON-B 实现是 Apache Johnzon，它提供了依赖管理。 22 | 23 | -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/30、安全.md: -------------------------------------------------------------------------------- 1 | # 30、安全 2 | 3 | 如果 Spring Security 在类路径上，那么 web 应用程序在默认情况下是安全的。Spring Boot 依赖于 Spring Security 的内容协商策略来决定是使用 httpBasic 还是 formLogin。要向 web 应用程序添加方法级安全性，还可以使用所需设置添加 @EnableGlobalMethodSecurity。其他信息可以在 Spring 安全参考指南中找到。 4 | 5 | 默认的 UserDetailsService 只有一个用户。用户名是 user，密码是随机的，在应用程序启动时在 INFO 级别打印，如下例所示： 6 | 7 | Using generated security password: 78fa095d-3f4c-48b1-ad50-e24c31d5cf35 8 | 9 | 注释：如果你微调了日志配置，请确保 org.springframework.boot.autoconfigure.security 类别设置为日志 INFO 级别的消息。否则，不会打印默认密码。 10 | 11 | 你可以通过提供 spring.security.user.name 和 spring.security.user.password 来更改用户名和密码。 12 | 13 | 默认情况下，web 应用程序的基本功能是： 14 | 15 | （1）一个具有内存存储的 UserDetailService（或者在 WebFlux 应用程序的情况下是 ReactiveUserDetailService）bean 和一个具有生成密码的用户（有关用户的属性，请参阅 [SecurityProperties.User](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/api/org/springframework/boot/autoconfigure/security/SecurityProperties.User.html)）。 16 | 17 | （2）整个应用程序的基于表单的登录或 HTTP 基于安全性（取决于请求中的 Accept 头）（如果 actuator 位于类路径上，则包括 actuator 端点）。 18 | 19 | （3）用于发布身份验证事件的 DefaultAuthenticationEventPublisher。 20 | 21 | 你可以通过为它添加一个 bean 来提供一个不同的 AuthenticationEventPublisher。 22 | 23 | ## 30.1、MVC 安全 24 | 25 | 默认的安全配置在 SecurityAutoConfiguration 和 UserDetailsServiceAutoConfiguration 中实现。SecurityAutoConfiguration 导入 SpringBootWebSecurityConfiguration 用于 web 安全和 UserDetailsServiceAutoConfiguration 用于配置身份验证，这在非 web 应用程序中也是相关的。要完全关闭默认的 web 应用程序安全配置，可以添加 WebSecurityConfiguerAdapter 类型的 bean（这样做不会禁用 UserDetailsService 配置或 Actuator 的安全性）。 26 | 27 | 还要关闭 UserDetailsService 配置，可以添加 UserDetailService、AuthenticationProvider 或 AuthenticationManager 类型的 bean。在 [Spring Boot 示例](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-samples/)中有几个安全应用程序可以帮助你开始使用常见的用例。 28 | 29 | 访问规则可以通过添加自定义 WebSecurityConfigurerAdapter 来重写。Spring Boot 提供了一些方便的方法，可以用来覆盖 actuator 端点和静态资源的访问规则。EndpointRequest 可用于创建基于 management.endpoints.web.base-path 属性的 RequestMatcher。PathRequest 可用于为常用位置的资源创建 RequestMatcher。 30 | 31 | ## 30.2、WebFlux 安全 32 | 33 | 与 Spring MVC 应用程序类似，你可以通过添加 spring-boot-starter-security 依赖项来保护 WebFlux 应用程序。默认安全配置是在 ReactiveSecurityAutoConfiguration 和 UserDetailServiceAutoConfiguration 中实现的。ReactiveSecurityAutoConfiguration 导入 WebFluxSecurityConfiguration 用于 web 安全和 UserDetailsServiceAutoConfiguration 用于配置身份验证，这在非 web 应用程序中也是相关的。要完全关闭默认的 web 应用程序安全配置，可以添加 WebFilterChainProxy 类型的 bean（这样做不会禁用 UserDetailsService 配置或 Actuator 的安全性）。 34 | 35 | 还要关闭 UserDetailsService 配置，可以添加 ReactiveUserDetailService 或 ReactiveAuthenticationManager 类型的 bean。 36 | 37 | 访问规则可以通过添加自定义 SecurityWebFilterChain 来重写。Spring Boot 提供了一些方便的方法，可以用来覆盖 actuator 端点和静态资源的访问规则。EndpointRequest 可用于创建基于 management.endpoints.web.base-path 属性的 ServerWebExchangeMatcher。 38 | 39 | PathRequest 可用于为常用位置的资源创建 ServerWebExchangeMatcher。 40 | 41 | 例如，你可以通过添加类似以下内容来自定义安全性配置： 42 | ``` 43 | @Bean 44 | public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) { 45 | return http 46 | .authorizeExchange() 47 | .matchers(PathRequest.toStaticResources().atCommonLocations()).permitAll() 48 | .pathMatchers("/foo", "/bar") 49 | .authenticated().and() 50 | .formLogin().and() 51 | .build(); 52 | } 53 | ``` 54 | ## 30.3、OAuth2 55 | 56 | OAuth2 是 Spring 支持的一个广泛使用的授权框架。 57 | 58 | ### 30.3.1、客户端 59 | 60 | 如果类路径上有 spring-security-oauth2-client，那么可以利用一些自动配置来轻松设置 OAuth2/Open ID Connect 客户端。此配置使用 OAuth2ClientProperties 下的属性。同样的属性适用于 servlet 和反应式应用程序。 61 | 62 | 可以在 spring.security.oauth2.client 前缀下注册多个 OAuth2 客户端和提供者，如下面示例所示： 63 | 64 | spring.security.oauth2.client.registration.my-client-1.client-id=abcd 65 | spring.security.oauth2.client.registration.my-client-1.client-secret=password 66 | spring.security.oauth2.client.registration.my-client-1.client-name=Client for user scope 67 | spring.security.oauth2.client.registration.my-client-1.provider=my-oauth-provider 68 | spring.security.oauth2.client.registration.my-client-1.scope=user 69 | spring.security.oauth2.client.registration.my-client-1.redirect-uri-template=https://my-redirect-uri.com 70 | spring.security.oauth2.client.registration.my-client-1.client-authentication-method=basic 71 | spring.security.oauth2.client.registration.my-client-1.authorization-grant-type=authorization_code 72 | 73 | spring.security.oauth2.client.registration.my-client-2.client-id=abcd 74 | spring.security.oauth2.client.registration.my-client-2.client-secret=password 75 | spring.security.oauth2.client.registration.my-client-2.client-name=Client for email scope 76 | spring.security.oauth2.client.registration.my-client-2.provider=my-oauth-provider 77 | spring.security.oauth2.client.registration.my-client-2.scope=email 78 | spring.security.oauth2.client.registration.my-client-2.redirect-uri-template=https://my-redirect-uri.com 79 | spring.security.oauth2.client.registration.my-client-2.client-authentication-method=basic 80 | spring.security.oauth2.client.registration.my-client-2.authorization-grant-type=authorization_code 81 | 82 | spring.security.oauth2.client.provider.my-oauth-provider.authorization-uri=http://my-auth-server/oauth/authorize 83 | spring.security.oauth2.client.provider.my-oauth-provider.token-uri=http://my-auth-server/oauth/token 84 | spring.security.oauth2.client.provider.my-oauth-provider.user-info-uri=http://my-auth-server/userinfo 85 | spring.security.oauth2.client.provider.my-oauth-provider.user-info-authentication-method=header 86 | spring.security.oauth2.client.provider.my-oauth-provider.jwk-set-uri=http://my-auth-server/token_keys 87 | spring.security.oauth2.client.provider.my-oauth-provider.user-name-attribute=name 88 | 89 | 对于支持 OpenID Connect 发现的 OpenID Connect 提供者，可以进一步简化配置。提供者需要用 issuer-uri 配置，该 uri 是它断言为其 Issuer Identifier 的URI。例如，如果提供的 issuer-uri 是“https ://example.com ”，那么将向“https ://example.com/.well-known/openid-configuration ”发出 OpenID Provider Configuration Request。结果应该是 OpenID Provider Configuration Response。以下示例显示如何使用 issuer-uri 配置 OpenID Connect Provider： 90 | 91 | spring.security.oauth2.client.provider.oidc-provider.issuer-uri=https://dev-123456.oktapreview.com/oauth2/default/ 92 | 93 | 默认情况下，Spring Security 的 OAuth2LoginAuthenticationFilter 只处理匹配 /login/oauth2/code/* 的 URLs。如果希望自定义 redirect-uri 以使用不同的模式，则需要提供配置来处理该自定义模式。例如，对于 servlet 应用程序，你可以添加自己的 WebSecurityConfigurerAdapter，类似于以下内容： 94 | ``` 95 | public class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter { 96 | 97 | @Override 98 | protected void configure(HttpSecurity http) throws Exception { 99 | http 100 | .authorizeRequests() 101 | .anyRequest().authenticated() 102 | .and() 103 | .oauth2Login() 104 | .redirectionEndpoint() 105 | .baseUri("/custom-callback"); 106 | } 107 | } 108 | ``` 109 | **常见提供者的 OAuth2 客户端注册** 110 | 111 | 对于常见的 OAuth2 和 OpenID 提供者，包括 Google、GitHub、Facebook 和Okta，我们提供了一组提供者默认值（分别是 google、gitHub、facebook 和 okta）。 112 | 113 | 如果不需要自定义这些提供程序，可以将 provider 属性设置为需要推断其默认值的属性。此外，如果客户端注册的 key 与默认支持的提供程序匹配，那么 Spring Boot 也会推断出这一点。 114 | 115 | 换句话说，以下示例中的两个配置使用 Google 提供者： 116 | 117 | spring.security.oauth2.client.registration.my-client.client-id=abcd 118 | spring.security.oauth2.client.registration.my-client.client-secret=password 119 | spring.security.oauth2.client.registration.my-client.provider=google 120 | 121 | spring.security.oauth2.client.registration.google.client-id=abcd 122 | spring.security.oauth2.client.registration.google.client-secret=password 123 | 124 | ### 30.3.2、资源服务器 125 | 126 | 如果类路径上有 spring-security-oauth2-resource-server，那么只要指定了 JWK Set URI 或 OIDC Issuer URI，Spring Boot 就可以设置 OAuth2 Resource Server，如下面示例所示： 127 | 128 | spring.security.oauth2.resourceserver.jwt.jwk-set-uri=https://example.com/oauth2/default/v1/keys 129 | spring.security.oauth2.resourceserver.jwt.issuer-uri=https://dev-123456.oktapreview.com/oauth2/default/ 130 | 131 | 相同的属性适用于 servlet 和反应式应用程序。 132 | 133 | 或者，你可以为 servlet 应用程序定义自己的 JwtDecoder bean，或者为反应式应用程序定义一个 ReactiveJwtDecoder。 134 | 135 | ### 30.3.3、认证服务器 136 | 137 | 目前，Spring Security 不支持实现 OAuth 2.0 认证服务器。但是，这个功能可以从 Spring Security OAuth 项目获得，该项目最终将被 Spring Security 完全取代。在此之前，你可以使用 spring-security-oauth2-autoconfigure 模块轻松设置 OAuth 2.0 认证服务器；有关说明，请参阅其[文档](https://docs.spring.io/spring-security-oauth2-boot)。 138 | 139 | ## 30.4、Actuator 安全 140 | 141 | 出于安全目的，默认情况下，除 /health 和 /info 之外的所有 actuators 都将被禁用。management.endpoints.web.exposure.include 属性可用于启用 actuators。 142 | 143 | 如果 Spring Security 位于类路径上，并且没有其他 WebSecurityConfigurerAdapter，那么除了 /health 和 /info 之外的所有 actuators 都由 Spring Boot 自动配置进行保护。如果你定义了一个自定义的 WebSecurityConfigurerAdapter，Spring Boot 自动配置将退出，你将完全控制 actuator 访问规则。 144 | 145 | 注释：在设置 management.endpoints.web.exposure.include 之前，请确保暴露的 actuators 不包含敏感信息，并且/或通过将其置于防火墙后或通过类似于 Spring Security 的方式进行保护。 146 | 147 | ### 30.4.1、跨站点请求防伪保护 148 | 149 | 由于 Spring Boot 依赖于 Spring Security 的默认值，所以 CSRF 保护默认打开。这意味着当使用默认安全配置时，需要 POST（关闭和记录器端点）、PUT 或 DELETE 的 actuator 端点将得到 403 禁止错误。 150 | 151 | 注释：我们建议仅在创建非浏览器客户端使用的服务时才完全禁用 CSRF 保护。 152 | 153 | 有关 CSRF 保护的其他信息，请参见 [Spring 安全参考指南](https://docs.spring.io/spring-security/site/docs/5.1.5.RELEASE/reference/htmlsingle#csrf)。 154 | -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/33、缓存.md: -------------------------------------------------------------------------------- 1 | # 33、缓存 2 | 3 | Spring Framework 支持透明地向应用程序添加缓存。抽象的核心是将缓存应用于方法，从而根据缓存中可用的信息减少执行次数。缓存逻辑的应用是透明的，不会对调用程序造成任何干扰。只要通过 @EnableCaching 注解启用了缓存支持，Spring Boot 就会自动配置缓存基础结构。 4 | 5 | 注释：有关更多详细信息，请查看 Spring Framework 参考的[相关部分](https://docs.spring.io/spring/docs/5.1.8.RELEASE/spring-framework-reference/integration.html#cache)。 6 | 7 | 简而言之，向服务的操作添加缓存与向其方法添加相关注解一样简单，如下面示例所示： 8 | ``` 9 | import org.springframework.cache.annotation.Cacheable; 10 | import org.springframework.stereotype.Component; 11 | 12 | @Component 13 | public class MathService { 14 | 15 | @Cacheable("piDecimals") 16 | public int computePiDecimal(int i) { 17 | // ... 18 | } 19 | 20 | } 21 | ``` 22 | 此示例演示如何在可能代价高昂的操作上使用缓存。在调用 computePiDecimal 之前，抽象在 piDecimals 缓存中查找与 i 参数匹配的条目。如果找到一个条目，缓存中的内容会立即返回给调用方，并且不会调用该方法。否则，将调用该方法，并在返回值之前更新缓存。 23 | 24 | 当心：你还可以透明地使用标准 JSR-107（JCache）注解（例如 @CacheResult ）。但是，我们强烈建议你不要混合和匹配 Spring Cache 和 JCache 注解。 25 | 26 | 如果不添加任何特定的缓存库，Spring Boot 会自动配置一个在内存中使用并发映射的简单提供器。当需要缓存时（如上例中的 piDecimals），此提供器将为你创建缓存。简单的提供器并不是真正推荐用于生产，但它对于入门和确保你了解这些特性非常有用。当你决定使用缓存提供器时，请确保阅读其文档以了解如何配置应用程序使用的缓存。几乎所有提供器都要求你显式配置在应用程序中使用的每个缓存。有些提供了一种自定义由 spring.cache.cache-names 属性定义的默认缓存的方法。 27 | 28 | 提示：也可以透明地从缓存中更新或移除数据。 29 | 30 | ## 33.1、支持的缓存提供器 31 | 32 | 缓存抽象不提供实际的存储，依赖于 org.springframework.cache.Cache 和 org.springframework.cache.CacheManager 接口实现的抽象。 33 | 34 | 如果尚未定义 CacheManager 类型的 bean 或名为 cacheResolver 的 CacheResolver（请参阅 CachingConfigurer），则 Spring Boot 将尝试检测以下提供器（按指示的顺序）： 35 | 36 | （1）[Generic](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-caching.html#boot-features-caching-provider-generic) 37 | 38 | （2）[JCache（JSR-107）（EhCache 3、Hazelcast、Infinispan 和其它）](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-caching.html#boot-features-caching-provider-jcache) 39 | 40 | （3）[EhCache 2.x](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-caching.html#boot-features-caching-provider-ehcache2) 41 | 42 | （4）[Hazelcast](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-caching.html#boot-features-caching-provider-hazelcast) 43 | 44 | （5）[Infinispan](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-caching.html#boot-features-caching-provider-infinispan) 45 | 46 | （6）[Couchbase](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-caching.html#boot-features-caching-provider-couchbase) 47 | 48 | （7）[Redis](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-caching.html#boot-features-caching-provider-redis) 49 | 50 | （8）[Caffeine](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-caching.html#boot-features-caching-provider-caffeine) 51 | 52 | （9）[Simple](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-caching.html#boot-features-caching-provider-simple) 53 | 54 | 提示：也可以通过设置 spring.cache.type 属性强制特定的缓存提供器。如果需要在某些环境（如测试）中完全禁用缓存，请使用此属性。 55 | 56 | 提示：使用 spring-boot-starter-cache “Starter”快速添加基本缓存依赖项。该 starter 提供了spring-context-support。如果手动添加依赖项，则必须包含 spring-context-support 才能使用 JCache、EhCache 2.x 或 Guava 支持。 57 | 58 | 如果 CacheManager 是由 Spring Boot 自动配置的，则可以通过公开实现 CacheManagerCustomizer 接口的 bean，在完全初始化之前进一步优化其配置。下面的示例设置一个标志，表示 null 值应该向下传递到底层映射： 59 | ``` 60 | @Bean 61 | public CacheManagerCustomizer cacheManagerCustomizer() { 62 | return new CacheManagerCustomizer() { 63 | @Override 64 | public void customize(ConcurrentMapCacheManager cacheManager) { 65 | cacheManager.setAllowNullValues(false); 66 | } 67 | }; 68 | } 69 | ``` 70 | 注释：在前面的示例中，需要一个自动配置的 ConcurrentMapCacheManager。如果不是这样（你提供了自己的配置或自动配置了其他缓存提供器），则根本不会调用自定义程序。你可以拥有任意数量的自定义程序，还可以使用 @Order 或 Ordered 对它们进行排序。 71 | 72 | ### 33.1.1、Generic 73 | 74 | 如果上下文定义了至少一个 org.springframework.cache.Cache bean，则使用 Generic 缓存。将创建包装该类型所有 bean 的 CacheManager。 75 | 76 | ### 33.1.2、JCache（JSR-107） 77 | 78 | JCache 是通过类路径上的 javax.cache.spi.CachingProvider 来引导的(也就是说，类路径上存在一个兼容 JSR-107 的缓存库)，JCacheCacheManager 是由 spring-boot-starter-cache “Starter”提供的。有各种兼容的库可用，Spring Boot 为 Ehcache 3、Hazelcast 和 Infinispan 提供了依赖管理。也可以添加任何其他兼容的库。 79 | 80 | 可能会出现多个提供器，在这种情况下，必须显式指定提供器。即使 JSR-107 标准没有强制使用标准化的方式来定义配置文件的位置，Spring Boot 也尽其所能地适应设置带有实现细节的缓存，如下面示例所示： 81 | 82 | # Only necessary if more than one provider is present 83 | spring.cache.jcache.provider=com.acme.MyCachingProvider 84 | spring.cache.jcache.config=classpath:acme.xml 85 | 86 | 注释：当缓存库同时提供本地实现和 JSR-107 支持时，Spring Boot 更喜欢 JSR-107 支持，因此如果切换到不同的 JSR-107 实现，也可以使用相同的特性。 87 | 88 | 提示：Spring Boot 一般支持 Hazelcast。如果只有一个 HazelcastInstance 可用，那么它也会自动为 CacheManager 重用，除非指定了 spring.cache.jcache.config 属性。 89 | 90 | 有两种方法可以自定义底层 javax.cache.cacheManager： 91 | 92 | （1）通过设置 spring.cache.cache-names 属性，可以在启动时创建缓存。如果定义了自定义 javax.cache.configuration.Configuration bean，则使用它来自定义缓存。 93 | 94 | （2）使用 CacheManager 的引用调用 org.springframework.boot.autoconfigure.cache.JCacheManagerCustomizer bean 以进行完全定制。 95 | 96 | 提示：如果定义了一个标准的 javax.cache.CacheManager bean，它将自动包装在抽象所期望的 org.springframework.cache.CacheManager 实现中。不会对其应用进一步的自定义。 97 | 98 | ### 33.1.3、EhCache 2.x 99 | 100 | 如果可以在类路径的根目录中找到名为 EhCache.xml 的文件，则使用 EhCache 2.x。如果找到 EhCache 2.x，则使用 spring-boot-starter-cache “Starter”提供的 EhCacheCacheManager 来引导缓存管理器。还可以提供另一个配置文件，如下面示例所示： 101 | 102 | spring.cache.ehcache.config=classpath:config/another-config.xml 103 | 104 | ### 33.1.4、Hazelcast 105 | 106 | Spring Boot [一般支持 Hazelcast](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-hazelcast.html)。如果 HazelcastInstance 已经自动配置，它将自动包装在 CacheManager 中。 107 | 108 | ### 33.1.5、Infinispan 109 | 110 | [Infinispan](https://infinispan.org/) 没有默认的配置文件位置，因此必须显式指定它。否则，将使用默认引导。 111 | 112 | spring.cache.infinispan.config=infinispan.xml 113 | 114 | 通过设置 spring.cache.cache-names 属性，可以在启动时创建缓存。如果定义了自定义 ConfigurationBuilder bean，它将用于自定义缓存。 115 | 116 | 注释：Infinispan 在 Spring Boot 中的支持仅限于嵌入式模式，是相当基础的。如果你想要更多的选择，你应该使用官方的 Infinispan Spring Boot starter。请参阅 [Infinispan 的文档](https://github.com/infinispan/infinispan-spring-boot)以了解更多详细信息。 117 | 118 | ### 33.1.6、Couchbase 119 | 120 | 如果 Couchbase Java 客户端和 couchbase-spring-cache 实现可用并且 Couchbase 已配置，则 CouchbaseCacheManager 将自动配置。还可以通过设置 spring.cache.cache-names 属性在启动时创建其他缓存。这些缓存在自动配置的 Bucket 上操作。还可以使用自定义程序在另一个 Bucket 上创建其他缓存。假设你需要“main” Bucket 上的两个缓存（cache1和cache2）和“another” Bucket 上的一个（cache3）缓存（自定义生存时间为2秒）。你可以通过配置创建前两个缓存，如下所示： 121 | 122 | spring.cache.cache-names=cache1,cache2 123 | 124 | 你可以通过配置创建前两个缓存，如下所示： 125 | ``` 126 | @Configuration 127 | public class CouchbaseCacheConfiguration { 128 | 129 | private final Cluster cluster; 130 | 131 | public CouchbaseCacheConfiguration(Cluster cluster) { 132 | this.cluster = cluster; 133 | } 134 | 135 | @Bean 136 | public Bucket anotherBucket() { 137 | return this.cluster.openBucket("another", "secret"); 138 | } 139 | 140 | @Bean 141 | public CacheManagerCustomizer cacheManagerCustomizer() { 142 | return c -> { 143 | c.prepareCache("cache3", CacheBuilder.newInstance(anotherBucket()) 144 | .withExpiration(2)); 145 | }; 146 | } 147 | 148 | } 149 | ``` 150 | 此示例配置重用通过自动配置创建的 Cluster。 151 | 152 | ### 33.1.7、Redis 153 | 154 | 如果 Redis 可用并已配置，则会自动配置 RedisCacheManager。可以通过设置 spring.cache.cache-names 属性在启动时创建其他缓存，可以使用 spring.cache.redis.* 属性配置缓存默认值。例如，以下配置创建的 cache1 和 cache2 缓存的生存时间为 10 分钟： 155 | 156 | spring.cache.cache-names=cache1,cache2 157 | spring.cache.redis.time-to-live=600000 158 | 159 | 注释：默认情况下，会添加一个键前缀，以便如果两个单独的缓存使用同一个键，则 Redis 没有重叠的键，并且不能返回无效值。如果创建自己的 RedisCacheManager，强烈建议保持启用此设置。 160 | 161 | 提示：你可以通过添加自己的 RedisCacheConfiguration @Bean 来完全控制配置。如果你希望自定义序列化策略，则这可能非常有用。 162 | 163 | ### 33.1.8、Caffeine 164 | 165 | Caffeine 是对 Guava 缓存的 Java 8 重写，取代了对 Guava 的支持。如果存在 Caffeine，则会自动配置 CaffeineCacheManager（由 spring-boot-starter-cache “Starter” 提供）。通过设置 spring.cache.cache-names 属性，可以在启动时创建缓存，并且可以通过以下方式之一进行自定义（按指定顺序）: 166 | 167 | （1）由 spring.cache.caffine.spec 定义的缓存规范 168 | （2）定义了一个 com.github.benmanes.caffeine.cache.CaffeineSpec bean 169 | （3）定义了一个 com.github.benmanes.caffeine.cache.Caffeine bean 170 | 171 | 例如，以下配置创建 cache1 和 cache2 缓存，最大大小为 500，生存时间为 10 分钟： 172 | 173 | spring.cache.cache-names=cache1,cache2 174 | spring.cache.caffeine.spec=maximumSize=500,expireAfterAccess=600s 175 | 176 | 如果定义了 com.github.benmanes.caffine.cache.CacheLoader bean，它将自动关联到 CaffeineCacheManager。由于 CacheLoader 将与缓存管理器管理的所有缓存关联，因此必须将其定义为 CacheLoader。自动配置忽略任何其他泛型类型。 177 | 178 | ### 33.1.9、Simple 179 | 180 | 如果找不到其他提供器，则配置一个使用 ConcurrentHashMap 作为缓存存储的简单实现。如果应用程序中不存在缓存库，则这是默认设置。默认情况下，将根据需要创建缓存，但可以通过设置 cache-names 属性来限制可用缓存的列表。例如，如果只需要 cache1 和 cache2 缓存，请按如下所示设置 cache-names 属性： 181 | 182 | spring.cache.cache-names=cache1,cache2 183 | 184 | 如果这样做，并且应用程序使用未列出的缓存，则当需要缓存时，它将在运行时失败，但不会在启动时失败。这与使用未声明的缓存时“真实”缓存提供器的行为类似。 185 | 186 | ### 33.1.10、None 187 | 188 | 当 @EnableCaching 出现在你的配置中时，也需要一个合适的缓存配置。如果需要在某些环境中完全禁用缓存，请强制将缓存类型设置为 none 以使用 no-op 实现，如下面示例所示： 189 | 190 | spring.cache.type=none 191 | -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/35、使用RestTemplate调用REST服务.md: -------------------------------------------------------------------------------- 1 | # 35、使用 RestTemplate 调用 REST 服务 2 | 3 | 如果需要从应用程序调用远程 REST 服务，可以使用 Spring 框架的 RestTemplate 类。由于 RestTemplate 实例通常需要在使用之前进行自定义，因此 Spring Boot 不提供任何单个自动配置的 RestTemplate bean。然而，它确实自动配置了一个 RestTemplateBuilder，它可以在需要时用于创建 RestTemplate 实例。自动配置的 RestTemplateBuilder 确保合理的 HttpMessageConverters 应用于 RestTemplate 实例。 4 | 5 | 以下代码展示了一个典型示例: 6 | ``` 7 | @Service 8 | public class MyService { 9 | 10 | private final RestTemplate restTemplate; 11 | 12 | public MyService(RestTemplateBuilder restTemplateBuilder) { 13 | this.restTemplate = restTemplateBuilder.build(); 14 | } 15 | 16 | public Details someRestCall(String name) { 17 | return this.restTemplate.getForObject("/{name}/details", Details.class, name); 18 | } 19 | 20 | } 21 | ``` 22 | 提示：RestTemplateBuilder 包括许多可用于快速配置 RestTemplate 的有用方法。例如，要添加基本身份验证支持，你可以使用 builder.basicAuthentication("user", "password").build()。 23 | 24 | ## 35.1、RestTemplate 自定义 25 | 26 | 有三种主要的 RestTemplate 自定义方法，这基本上取决于你希望如何应用自定义。 27 | 28 | 要使任何自定义的范围尽可能缩小，请注入自动配置的 RestTemplateBuilder，然后根据需要调用其方法。每个方法调用都会返回一个新的 RestTemplateBuilder 实例，因此自定义项只会影响该生成器的使用。 29 | 30 | 要进行应用范围的附加定制，请使用 RestTemplateCustomizer bean。所有此类 bean 都将自动注册到自动配置的 RestTemplateBuilder 中，并应用于使用它构建的任何模板。 31 | 32 | 以下示例显示一个自定义程序，该自定义程序为除 192.168.0.5 以外的所有主机配置代理的使用： 33 | ``` 34 | static class ProxyCustomizer implements RestTemplateCustomizer { 35 | 36 | @Override 37 | public void customize(RestTemplate restTemplate) { 38 | HttpHost proxy = new HttpHost("proxy.example.com"); 39 | HttpClient httpClient = HttpClientBuilder.create().setRoutePlanner(new DefaultProxyRoutePlanner(proxy) { 40 | 41 | @Override 42 | public HttpHost determineProxy(HttpHost target, HttpRequest request, HttpContext context) 43 | throws HttpException { 44 | if (target.getHostName().equals("192.168.0.5")) { 45 | return null; 46 | } 47 | return super.determineProxy(target, request, context); 48 | } 49 | 50 | }).build(); 51 | restTemplate.setRequestFactory(new HttpComponentsClientHttpRequestFactory(httpClient)); 52 | } 53 | 54 | } 55 | ``` 56 | 最后，最极端的 (很少使用的) 选项是创建你自己的 RestTemplateBuilder bean。这样做可以关闭 RestTemplateBuilder 的自动配置，并防止使用任何 RestTemplateCustomizer bean。 -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/36、使用WebClient调用REST服务.md: -------------------------------------------------------------------------------- 1 | # 36、使用 WebClient 调用 REST 服务 2 | 3 | 如果你的类路径上有 Spring WebFlux，你也可以选择使用 WebClient 调用远程 REST 服务。与 RestTemplate 相比，该客户端具有更多函数式感觉，并且完全是反应式的。你可以在 [Spring Framework 文档的专用部分](https://docs.spring.io/spring/docs/5.1.8.RELEASE/spring-framework-reference/web-reactive.html#webflux-client)了解有关 WebClient 的更多信息。 4 | 5 | Spring Boot 为你创建并预配置 WebClient.Builder; 强烈建议将其注入组件并使用它创建 WebClient 实例。Spring Boot 正在配置该构建器以共享 HTTP 资源，以与服务器相同的方式表示编解码器设置 (请参见 [WebFlux HTTP 编解码器自动配置](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-developing-web-applications.html#boot-features-webflux-httpcodecs))，等等。 6 | 7 | 以下代码展示了一个典型示例: 8 | ``` 9 | @Service 10 | public class MyService { 11 | 12 | private final WebClient webClient; 13 | 14 | public MyService(WebClient.Builder webClientBuilder) { 15 | this.webClient = webClientBuilder.baseUrl("https://example.org").build(); 16 | } 17 | 18 | public Mono
someRestCall(String name) { 19 | return this.webClient.get().uri("/{name}/details", name) 20 | .retrieve().bodyToMono(Details.class); 21 | } 22 | 23 | } 24 | ``` 25 | ## 36.1、WebClient 运行时 26 | 27 | 根据应用程序类路径上可用的库，Spring Boot 将自动检测用于驱动 WebClient 的 ClientHttpConnector。目前，支持 Reactor Netty 和 Jetty RS 客户端。 28 | 29 | spring-boot-starter-webflux 默认依赖于 io.projectreactor.netty:reactor-netty，它同时提供服务器和客户端实现。如果你选择使用 Jetty 作为一个反应式服务器，那么你应该添加对 Jetty Reactive HTTP 客户端库 org.eclipse.jetty:jetty-reactive-httpclient 的依赖。对服务器和客户端使用相同的技术有其优点，因为它将在客户端和服务器之间自动共享 HTTP 资源。 30 | 31 | 开发者可以通过提供自定义 JettyResourceFactory 或 ReactorResourceFactory bean 来覆盖 Jetty 或 Reactor Netty 的资源配置-这将应用于客户端和服务器。 32 | 33 | 如果你希望为客户端覆盖该选择，则可以定义自己的 ClientHttpConnector bean 并完全控制客户端配置。 34 | 你可以在 [Spring Framework 参考文档中了解有关 WebClient 配置选项](https://docs.spring.io/spring/docs/5.1.8.RELEASE/spring-framework-reference/web-reactive.html#webflux-client-builder)的更多信息。 35 | 36 | ## 36.2、WebClient 定制 37 | 38 | WebClient 定制有三种主要方法，具体情况基本上取决于你希望如何应用定制。 39 | 40 | 要尽可能缩小任何自定义的范围，请注入自动配置的 WebClient.Builder，然后按需调用其方法。WebClient.Builder 实例是有状态的: 构建器上的任何更改都会反映在随后使用它创建的所有客户端中。如果要使用同一构建器创建多个客户端，还可以考虑使用 WebClient.builder other=builder.clone(); 克隆该构建器。 41 | 42 | 要对所有 WebClient.Builder 实例进行应用程序范围的附加自定义，可以声明 WebClientCustomizer bean 并在注入点本地更改 WebClient.Builder。 43 | 44 | 最后，你可以返回到原始 API 并使用 WebClient.create()。在这种情况下，不会应用自动配置或 WebClientCustomizer。 45 | -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/37、验证.md: -------------------------------------------------------------------------------- 1 | # 37、验证 2 | 3 | 只要类路径上有 JSR-303 的实现 (如 Hibernate 验证器)，Bean Validation 1.1 支持的方法验证功能就会自动启用。这使得 bean 方法可以用 javax.validation 约束来注解它们的参数和/或它们的返回值。带有此类带注解的方法的目标类需要在类型级别上使用 @Validated 注解进行注解，以便对其方法进行内联约束注解的搜索。 4 | 5 | 例如，以下服务触发第一个参数的验证，确保其大小在 8 到 10 之间: 6 | ``` 7 | @Service 8 | @Validated 9 | public class MyBean { 10 | 11 | public Archive findByCodeAndAuthor(@Size(min = 8, max = 10) String code, 12 | Author author) { 13 | ... 14 | } 15 | 16 | } 17 | ``` -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/38、发送电子邮件.md: -------------------------------------------------------------------------------- 1 | # 38、发送电子邮件 2 | 3 | Spring Framework 通过使用 JavaMailSender 接口为发送电子邮件提供了一个简单的抽象，Spring Boot 为它提供了自动配置以及一个 starter 模块。 4 | 5 | 提示：请参阅[参考文档](https://docs.spring.io/spring/docs/5.1.8.RELEASE/spring-framework-reference/integration.html#mail)，了解如何使用 JavaMailSender 的详细说明。 6 | 7 | 如果 spring.mail.host 和相关库 (由 spring-boot-starter-mail 定义) 可用，则会创建默认的 JavaMailSender（如果不存在）。可以通过 spring.mail 命名空间中的配置项进一步自定义发件人。有关更多详细信息，请参见 [MailProperties](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/mail/MailProperties.java)。 8 | 9 | 特别是，某些默认超时值是无限的，你可能希望更改它以避免线程被无响应的邮件服务器阻塞，如下面示例所示： 10 | 11 | spring.mail.properties.mail.smtp.connectiontimeout=5000 12 | spring.mail.properties.mail.smtp.timeout=3000 13 | spring.mail.properties.mail.smtp.writetimeout=5000 14 | 15 | 也可以使用 JNDI 的现有 Session 配置 JavaMailSender： 16 | 17 | spring.mail.jndi-name=mail/Session 18 | 19 | 当设置 jndi-name 时，它优先于所有其他与 Session 相关的设置。 20 | -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/39、使用JTA的分布式事务.md: -------------------------------------------------------------------------------- 1 | # 39、使用 JTA 的分布式事务 2 | 3 | Spring Boot 通过使用 Atomikos 或 Bitronix 嵌入式事务管理器，支持跨多个 XA 资源的分布式 JTA 事务。部署到合适的 Java EE 应用服务器时，也支持 JTA 事务。 4 | 5 | 检测到 JTA 环境时，Spring 的 JtaTransactionManager 用于管理事务。已升级自动配置的 JMS 、数据源和 JPA bean 以支持 XA 事务。你可以使用标准的 Spring 习惯用法，如 @Transaction，来参与分布式事务。如果你在 JTA 环境中并且仍然希望使用本地事务，则可以将 spring.jta.enabled 属性设置为 false 以禁用 JTA 自动配置。 6 | 7 | ## 39.1、使用 Atomikos 事务管理器 8 | 9 | Atomikos 是一个流行的开源事务管理器，可以嵌入到你的 Spring Boot 应用程序中。你可以使用 spring-boot-starter-jta-atomikos Starter 拉入适当的 Atomikos 库。Spring Boot 自动配置 Atomikos，并确保将适当的依赖设置应用于你的 Spring bean，以获得正确的启动和关闭顺序。 10 | 11 | 默认情况下，Atomikos 事务日志会写入应用程序主目录（应用程序 jar 文件所在的目录）中的 transaction-logs 目录。通过在 application.properties 文件中设置 spring.jta.log-dir 属性，可以自定义此目录的位置。以 spring.jta.atomikos.properties 为开始的属性也可以用于自定义 Atomikos UserTransactionServiceImp。有关完整的详细信息，请参阅 AtomikosProperties Javadoc。 12 | 13 | 注释：为了确保多个事务管理器可以安全地协调相同的资源管理器，必须使用唯一的 ID 配置每个 Atomikos 实例。默认情况下，此 ID 是运行 Atomikos 的计算机的 IP 地址。为了确保生产中的唯一性，你应该为应用程序的每个实例，将 spring.jta.transaction-manager-id 属性配置为不同的值。 14 | 15 | ## 39.2、使用 Bitronix 事务管理器 16 | 17 | Bitronix 是一个流行的开源 JTA 事务管理器实现。你可以使用 spring-boot-starter-jta-bitronix starter 将适当的 Bitronix 依赖项添加到项目中。与 Atomikos 一样，Spring Boot 会自动配置 Bitronix 并对你的 bean 进行后处理，以确保启动和关闭顺序是正确的。 18 | 19 | 默认情况下，Bitronix 事务日志文件（part1.btm 和 part2.btm）将写入应用程序主目录中的 transaction-logs 目录。可以通过设置 spring.jta.log-dir 属性来自定义此目录的位置。以 spring.jta.bitronix.properties 为开始的属性也绑定到 bitronix.tm.Configuration bean，允许完全自定义。有关详细信息，请参阅 [Bitronix 文档](https://github.com/bitronix/btm/wiki/Transaction-manager-configuration)。 20 | 21 | 注释：为了确保多个事务管理器可以安全地协调相同的资源管理器，必须使用唯一的 ID 配置每个 Bitronix 实例。默认情况下，此 ID 是运行 Bitronix 的计算机的 IP 地址。为了确保生产中的唯一性，你应该为应用程序的每个实例，将 spring.jta.transaction-manager-id 属性配置为不同的值。 22 | 23 | ## 39.3、使用 Java EE 托管事务管理器 24 | 25 | 如果将 Spring Boot 应用程序打包为 war 或 ear 文件并将其部署到 Java EE 应用程序服务器，则可以使用应用程序服务器的内置事务管理器。Spring Boot 尝试通过查看常见的 JNDI 位置（java: comp/UserTransaction，java: comp/TransactionManager，等等）来自动配置事务管理器。如果使用应用程序服务器提供的事务服务，通常还需要确保所有资源都由服务器管理并通过 JNDI 公开。Spring Boot 尝试通过在 JNDI 路径（java:/JmsXA 或 java:/XAConnectionFactory）查找 ConnectionFactory 来自动配置 JMS，你可以使用 [spring.datasource.jndi-name 属性](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-sql.html#boot-features-connecting-to-a-jndi-datasource)来配置数据源。 26 | 27 | ## 39.4、混合 XA 和 Non-XA JMS 连接 28 | 29 | 使用 JTA 时，主 JMS ConnectionFactory bean 是 XA 感知的，并参与分布式事务。在某些情况下，你可能希望使用非 XA ConnectionFactory 来处理某些 JMS 消息。例如，你的 JMS 处理逻辑可能需要比 XA 超时更长的时间。 30 | 31 | 如果要使用非 XA ConnectionFactory，可以注入 nonXaJmsConnectionFactory bean 而不是 @Primary jmsConnectionFactory bean。为了保持一致性，jmsConnectionFactory bean 也通过使用 bean 别名 xaJmsConnectionFactory 来提供。 32 | 33 | 以下示例说明如何注入 ConnectionFactory 实例： 34 | ``` 35 | // Inject the primary (XA aware) ConnectionFactory 36 | @Autowired 37 | private ConnectionFactory defaultConnectionFactory; 38 | 39 | // Inject the XA aware ConnectionFactory (uses the alias and injects the same as above) 40 | @Autowired 41 | @Qualifier("xaJmsConnectionFactory") 42 | private ConnectionFactory xaConnectionFactory; 43 | 44 | // Inject the non-XA aware ConnectionFactory 45 | @Autowired 46 | @Qualifier("nonXaJmsConnectionFactory") 47 | private ConnectionFactory nonXaConnectionFactory; 48 | ``` 49 | ## 39.5、支持其他的嵌入式事务管理器 50 | 51 | XAConnectionFactoryWrapper 和 XADataSourceWrapper 接口可用于支持其他的嵌入式事务管理器。这些接口负责包装 XAConnectionFactory 和 XADataSource bean，并将它们作为常规 ConnectionFactory 和 DataSource bean 公开，这些 bean 透明地注册到分布式事务中。DataSource 和 JMS 自动配置使用 JTA 变体，前提是你在 ApplicationContext 中注册了 JtaTransactionManager bean 和适当的 XA 包装 bean。 52 | 53 | BitronixXAConnectionFactoryWrapper 和 BitronixXADataSourceWrapper 提供了如何编写 XA 包装器的好例子。 -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/40、Hazelcast.md: -------------------------------------------------------------------------------- 1 | # 40、Hazelcast 2 | 3 | 如果 Hazelcast 位于类路径上，并且找到了合适的配置，则 Spring Boot 会自动配置可以在应用程序中注入的 HazelcastInstance。 4 | 5 | 如果定义 com.hazelcast.config.Config bean，Spring Boot 会使用它。如果你的配置定义了实例名称，则 Spring Boot 会尝试查找现有实例，而不是创建新实例。 6 | 7 | 你还可以通过配置指定要使用的 hazelcast.xml 配置文件，如下面示例所示： 8 | 9 | spring.hazelcast.config=classpath:config/my-hazelcast.xml 10 | 11 | 否则，Spring Boot 会尝试从工作目录或类路径的根目录中的默认位置: hazelcast.xml 中查找 Hazelcast 配置。我们还检查是否设置了 hazelcast.config 系统属性。有关更多详细信息，请参见 [Hazelcast 文档](https://docs.hazelcast.org/docs/latest/manual/html-single/)。 12 | 13 | 如果类路径上存在 hazelcast-client，则 Spring Boot 首先通过检查以下配置选项来尝试创建客户端： 14 | 15 | （1）com.hazelcast.client.config.ClientConfig bean 的存在。 16 | （2）由 spring.hazelcast.config 属性定义的配置文件。 17 | （3）hazelcast.client.config 系统属性的存在。 18 | （4）工作目录或类路径根目录中的 hazelcast-client.xml。 19 | 20 | Spring Boot 还具有对 Hazelcast 的显式缓存支持。如果启用缓存，HazelcastInstance 将自动包装在 CacheManager 实现中。 21 | -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/41、Quartz调度器.md: -------------------------------------------------------------------------------- 1 | # 41、Quartz 调度器 2 | 3 | Spring Boot 为使用 Quartz 调度程序提供了多种便利，包括 spring-boot-starter-quartz “Starter”。如果 Quartz 可用，则会自动配置 Scheduler (通过 SchedulerFactoryBean 抽象)。 4 | 5 | 以下类型的 bean 将自动获取并与 Scheduler 关联： 6 | 7 | （1）JobDetail：定义特定的 Job。可以使用 JobBuilder API 构建 JobDetail 实例。 8 | （2）Calendar 9 | （3）Trigger：定义何时触发特定 job。 10 | 11 | 默认情况下，使用内存中的 JobStore。但是，如果应用程序中有可用的 DataSource bean，并且相应地配置了 spring.quartz.job-store-type 属性，则可以配置基于 JDBC 的存储，如下面示例所示： 12 | 13 | spring.quartz.job-store-type=jdbc 14 | 15 | 使用 JDBC 存储时，可以在启动时初始化模式（schema），如下面示例所示： 16 | 17 | spring.quartz.jdbc.initialize-schema=always 18 | 19 | 警告：默认情况下，通过使用 Quartz 库提供的标准脚本检测和初始化数据库。这些脚本删除现有表，并在每次重新启动时删除所有触发器。还可以通过设置 spring.quartz.jdbc.schema 属性来提供自定义脚本。 20 | 21 | 要让 Quartz 使用应用程序主 DataSource 以外的 DataSource，请声明一个 DataSource bean，用 @QuartzDataSource 注解其 @Bean 方法。这样做可以确保 SchedulerFactoryBean 和模式初始化都使用 Quartz 特定的 DataSource。 22 | 23 | 默认情况下，由配置创建的 job 不会覆盖已从持久 job 存储读取的已注册 job。要启用覆盖现有 job 定义，请设置 spring.quartz.overwrite-existing-jobs 属性。 24 | 25 | Quartz 调度器配置可以使用 spring.quartz 属性和 SchedulerFactoryBeanCustomizer bean 进行自定义，后者允许编程方式的 SchedulerFactoryBean 自定义。高级 Quartz 配置属性可以使用 spring.quartz.properties.* 自定义。 26 | 27 | 注释：特别是，Executor bean 不与调度器相关联，因为 Quartz 提供了一种通过 spring.quartz.properties 配置调度器的方法。如果你需要自定义任务执行器，请考虑实现 SchedulerFactoryBeanCustomizer。 28 | 29 | job 可以定义 setter 来注入数据映射属性。常规 bean 也可以以类似的方式注入，如下面示例所示： 30 | ``` 31 | public class SampleJob extends QuartzJobBean { 32 | 33 | private MyService myService; 34 | 35 | private String name; 36 | 37 | // Inject "MyService" bean 38 | public void setMyService(MyService myService) { ... } 39 | 40 | // Inject the "name" job data property 41 | public void setName(String name) { ... } 42 | 43 | @Override 44 | protected void executeInternal(JobExecutionContext context) 45 | throws JobExecutionException { 46 | ... 47 | } 48 | 49 | } 50 | ``` -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/42、任务执行与调度.md: -------------------------------------------------------------------------------- 1 | # 42、任务执行与调度 2 | 3 | 在上下文中没有 Executor bean 的情况下，Spring Boot 会自动配置 ThreadPoolTaskExecutor，并使用合理的默认值，这些默认值可以自动关联到异步任务执行（@EnableAsync）和 Spring MVC 异步请求处理。 4 | 5 | 提示： 6 | 7 | 如果在上下文中定义了自定义 Executor，则常规任务执行（即 @Enablesync）将透明地使用它，但不会配置 Spring MVC 支持，因为它需要 AsyncTaskExecutor 实现（名为 applicationTaskExecutor）。根据目标安排，你可以将 Executor 更改为 ThreadPoolTaskExecutor，或者同时定义 ThreadPoolTaskExecutor 和包装自定义 Executor 的 AsyncConfigurer。 8 | 9 | 自动配置的 TaskExecutorBuilder 允许你轻松创建实例，以重现默认情况下自动配置的功能。 10 | 11 | 线程池使用 8 个核心线程，它们可以根据负载增长和收缩。可以使用 spring.task.execution 命名空间对这些默认设置进行微调，如下面示例所示： 12 | 13 | spring.task.execution.pool.max-threads=16 14 | spring.task.execution.pool.queue-capacity=100 15 | spring.task.execution.pool.keep-alive=10s 16 | 17 | 这会将线程池更改为使用有界队列，以便当队列已满（100 个任务）时，线程池最多增加到 16 个线程。当线程空闲 10 秒（而不是默认情况下的 60 秒），回收线程时，线程池的收缩更为剧烈。 18 | 19 | 如果需要将 ThreadPoolTaskScheduler 与计划的任务执行关联（@EnableScheduling），也可以自动配置前者。默认情况下，线程池使用一个线程，这些设置可以使用 spring.task.scheduling 命名空间进行微调。 20 | 21 | 如果需要创建自定义执行程序或调度程序，则在上下文中可以使用 TaskExecutorBuilder bean 和 taskschedule erbuilder bean。 22 | -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/43、Spring集成.md: -------------------------------------------------------------------------------- 1 | # 43、Spring 集成 2 | 3 | Spring Boot 为使用 Spring Integration 提供了多种便利，包括 spring-boot-starter-ntegration “Starter”。Spring Integration 提供了消息传递和其他传输 (如 HTTP 、 TCP 等) 的抽象。如果你的类路径上有 Spring Integration，则它将通过 @EnableIntegration 注解初始化。 4 | 5 | Spring Boot 还配置了一些由其他 Spring Integration 模块触发的功能。如果 spring-integration-jmx 也在类路径上，则通过 JMX 发布消息处理统计信息。如果 spring-integration-jdbc 可用，则可以在启动时创建默认数据库模式（schema），如下面的行所示： 6 | 7 | spring.integration.jdbc.initialize-schema=always 8 | 9 | 有关更多详细信息，请参见 [IntegrationAutoConfiguration](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/integration/IntegrationAutoConfiguration.java) 和 [IntegrationProperties](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/integration/IntegrationProperties.java) 类。 10 | 11 | 默认情况下，如果存在 Micrometer meterRegistry bean，则 Spring Integration 度量将由 Micrometer 管理。如果你希望使用旧的 Spring Integration 度量，请将 DefaultMetricsFactory bean 添加到应用程序上下文。 12 | 13 | -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/44、Spring会话.md: -------------------------------------------------------------------------------- 1 | # 44、Spring 会话 2 | 3 | Spring Boot 为各种数据存储提供 Spring Session 自动配置。在构建 Servlet web 应用程序时，可以自动配置以下存储： 4 | 5 | （1）JDBC 6 | （2）Redis 7 | （3）Hazelcast 8 | （4）MongoDB 9 | 10 | 构建反应式 web 应用程序时，可以自动配置以下存储： 11 | 12 | （1）Redis 13 | （2）MongoDB 14 | 15 | 如果类路径上存在单个 Spring Session 模块，则 Spring Boot 会自动使用该存储实现。如果你有多个实现，则必须选择要用于存储会话的 StoreType。例如，要将 JDBC 用作后端存储，你可以按如下方式配置应用程序： 16 | 17 | spring.session.store-type=jdbc 18 | 19 | 提示：通过将 store-type 设置为 none，可以禁用 Spring Session。 20 | 21 | 每个存储的都有特定的附加设置。例如，可以为 JDBC 存储定制表的名称，如下面示例所示： 22 | 23 | spring.session.jdbc.table-name=SESSIONS 24 | 25 | 要设置会话的超时，可以使用 spring.session.timeout 属性。如果未设置该属性，则自动配置会返回到 server.servlet.session.timeout 的值。 26 | -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/45、JMX的监控和管理.md: -------------------------------------------------------------------------------- 1 | # 45、JMX 的监控和管理 2 | 3 | Java 管理扩展 (JMX) 提供了一种标准机制来监控和管理应用程序。Spring Boot 将最合适的 MBeanServer 公开为 ID 为 mbeanServer 的 bean。你的任何使用 Spring JMX 注解 （@ManagedResource 、 @ManagedAttribute 或 @ManagedOperation）进行注解的 bean 都将暴露给它。 4 | 5 | 如果你的平台提供了一个标准的 MBeanServer，那么 Spring Boot 将使用它，并且在必要时默认为 VM MBeanServer。如果所有这些都失败了，将创建一个新的 MBeanServer。 6 | 7 | 有关更多详细信息，请参阅 [JmxAutoConfiguration](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jmx/JmxAutoConfiguration.java) 类。 8 | -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/47、WebSockets.md: -------------------------------------------------------------------------------- 1 | # 47、WebSockets 2 | 3 | Spring Boot 为嵌入式 Tomcat、Jetty 和 Undertow 提供 WebSockets 自动配置。如果你将一个 war 文件部署到一个独立的容器中，Spring Boot 假设该容器负责其 WebSocket 支持的配置。 4 | 5 | Spring Framework 为可以通过 spring-boot-starter-websocket 模块轻松访问的 MVC web 应用程序提供了[丰富的 WebSocket 支持](https://docs.spring.io/spring/docs/5.1.8.RELEASE/spring-framework-reference/web.html#websocket)。 6 | 7 | WebSocket 支持也可用于[反应式 web 应用程序](https://docs.spring.io/spring/docs/5.1.8.RELEASE/spring-framework-reference/web-reactive.html#webflux-websocket)，需要在 spring-boot-starter-webflux 中包含 WebSocket API： 8 | ``` 9 | 10 | javax.websocket 11 | javax.websocket-api 12 | 13 | ``` -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/48、Web服务.md: -------------------------------------------------------------------------------- 1 | # 48、Web 服务 2 | 3 | Spring Boot 提供 Web 服务自动配置，因此你只需定义端点即可。 4 | 5 | 使用 spring-boot-starter-webservices 模块可以轻松访问 [Spring Web 服务功能](https://docs.spring.io/spring-ws/docs/3.0.7.RELEASE/reference/)。 6 | 7 | 可以分别为你的 WSDLs 和 XSDs 自动创建 SimpleWsdl11Definition 和 SimpleXsdSchema bean。为此，配置它们的位置，如下面示例所示： 8 | 9 | spring.webservices.wsdl-locations=classpath:/wsdl 10 | 11 | ## 48.1、使用 WebServiceTemplate 调用 Web 服务 12 | 13 | 如果需要从应用程序调用远程 Web 服务，可以使用 [WebServiceTemplate](https://docs.spring.io/spring-ws/docs/3.0.7.RELEASE/reference/#client-web-service-template) 类。由于 WebServiceTemplate 实例通常需要在使用之前进行自定义，因此 Spring Boot 不提供任何单个自动配置的 WebServiceTemplate bean。然而，它确实自动配置了一个 WebServiceTemplateBuilder，它可以在需要时用于创建 WebServiceTemplate 实例。 14 | 15 | 以下代码展示了一个典型示例： 16 | ``` 17 | @Service 18 | public class MyService { 19 | 20 | private final WebServiceTemplate webServiceTemplate; 21 | 22 | public MyService(WebServiceTemplateBuilder webServiceTemplateBuilder) { 23 | this.webServiceTemplate = webServiceTemplateBuilder.build(); 24 | } 25 | 26 | public DetailsResp someWsCall(DetailsReq detailsReq) { 27 | return (DetailsResp) this.webServiceTemplate.marshalSendAndReceive(detailsReq, new SoapActionCallback(ACTION)); 28 | 29 | } 30 | 31 | } 32 | ``` 33 | 默认情况下，WebServiceTemplateBuilder 使用类路径上可用的 HTTP 客户端库来检测合适的基于 HTTP 的 WebServiceMessageSender。你还可以自定义读取和连接超时，如下所示： 34 | ``` 35 | @Bean 36 | public WebServiceTemplate webServiceTemplate(WebServiceTemplateBuilder builder) { 37 | return builder.messageSenders(new HttpWebServiceMessageSenderBuilder() 38 | .setConnectTimeout(5000).setReadTimeout(2000).build()).build(); 39 | } 40 | ``` -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/49、创建你自己的自动配置.md: -------------------------------------------------------------------------------- 1 | # 49、创建你自己的自动配置 2 | 3 | 如果你在一家开发共享库的公司工作，或者你在一个开源或商业库工作，你可能想要开发你自己的自动配置。自动配置类可以捆绑在外部 jars 中，并且仍然可以通过 Spring Boot 获取。 4 | 5 | 自动配置可以与提供自动配置代码以及你将与之一起使用的典型库的“starter”相关联。我们首先介绍你需要了解的内容，以构建你自己的自动配置，然后我们继续介绍[创建自定义 starter 所需的典型步骤](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-developing-auto-configuration.html#boot-features-custom-starter)。 6 | 7 | 提示：演示项目可用于展示如何逐步创建 starter。 8 | 9 | ## 49.1、了解自动配置的 Beans 10 | 11 | 在 hood（引擎盖）下，自动配置是用标准的 @Configuration 类实现的。附加的 @Conditional 注解用于约束何时应用自动配置。通常，自动配置类使用 @ConditionalOnClass 和 @ConditionalOnMissingBean 注解。这将确保只有在找到相关类并且尚未声明自己的 @Configuration 时，才应用自动配置。 12 | 13 | 你可以浏览 spring-boot-autoconfigure 的源代码，以查看 Spring 提供的 @Configuration 类（请参阅 META-INF/spring.factories 文件）。 14 | 15 | ## 49.2、定位自动配置候选项 16 | 17 | Spring Boot 检查发布的 jar 中是否存在 META-INF/spring.factories 文件。该文件应在 EnableAutoConfiguration 键下列出你的配置类，如下面示例所示： 18 | 19 | org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ 20 | com.mycorp.libx.autoconfigure.LibXAutoConfiguration,\ 21 | com.mycorp.libx.autoconfigure.LibXWebAutoConfiguration 22 | 23 | 注释：只有这样才能加载自动配置。确保它们是在特定的包空间中定义的，并且永远不是组件扫描的目标。此外，自动配置类不应启用组件扫描来查找其他组件。应该改为使用特定的 @Imports。 24 | 25 | 如果需要按特定顺序应用配置，则可以使用 @AutoConfigureAfter 或 @AutoConfigureBefore 注解。例如，如果提供特定于 web 的配置，则可能需要在 WebMvcAutoConfiguration 之后应用类。 26 | 27 | 如果你想排序某些不应该相互直接了解的自动配置，也可以使用 @AutoConfigureOrder。该注解与常规的 @Order 注解具有相同的语义，但为自动配置类提供了专用的顺序。 28 | 29 | ## 49.3、条件注解 30 | 31 | 你几乎总是希望在自动配置类中包含一个或多个 @Conditional 注解。@ConditionalOnMissingBean 注解是一个常见的示例，用于允许开发者在对默认值不满意时重写自动配置。 32 | 33 | Spring Boot 包含许多 @Conditional 注解，你可以通过注解 @Configuration 类或单个 @Bean 方法在自己的代码中重用这些注解。这些注解包括： 34 | 35 | 49.3.1、Class 条件 36 | 49.3.2、Bean 条件 37 | 49.3.3、Property 条件 38 | 49.3.4、Resource 条件 39 | 49.3.5、Web 应用程序条件 40 | 49.3.6、SpEl 表达式条件 41 | 42 | ### 49.3.1、Class 条件 43 | 44 | @ConditionalOnClass 和 @ConditionalOnMissingClass 注解允许 @Configuration 类基于特定类的存在或不存在而被包含。由于注解元数据是通过使用 ASM 解析的，因此可以使用 value 属性来引用实际的类，即使该类可能不会实际出现在正在运行的应用程序类路径上。如果希望使用字符串值指定类名，也可以使用 name 属性。 45 | 46 | 这种机制对 @Bean 方法的应用方式不同，该方法的返回类型通常是条件的目标：在方法上的条件应用之前，JVM 将加载类和可能处理的方法引用，如果类不存在，这些引用将失败。 47 | 48 | 要处理此场景，可以使用单独的 @Configuration 类来隔离条件，如下面示例所示： 49 | ``` 50 | @Configuration 51 | // Some conditions 52 | public class MyAutoConfiguration { 53 | 54 | // Auto-configured beans 55 | 56 | @Configuration 57 | @ConditionalOnClass(EmbeddedAcmeService.class) 58 | static class EmbeddedConfiguration { 59 | 60 | @Bean 61 | @ConditionalOnMissingBean 62 | public EmbeddedAcmeService embeddedAcmeService() { ... } 63 | 64 | } 65 | 66 | } 67 | ``` 68 | 提示：如果使用 @ConditionalOnClass 或 @ConditionalOnMissingClass 作为元注解的一部分来组成自己的组合注解，则必须使用 name 作为在这种情况下不处理的类的引用。 69 | 70 | ### 49.3.2、Bean 条件 71 | 72 | @ConditionalOnBean 和 @ConditionalOnMissingBean 注解允许根据特定 bean 的存在或不存在来包含 bean。可以使用 value 属性按类型指定 bean，或使用 name 指定 bean。search 属性允许你限制在搜索 bean 时应考虑的 ApplicationContext 层次结构。 73 | 74 | 当放置在 @Bean 方法上时，目标类型默认为该方法的返回类型，如下面示例所示： 75 | ``` 76 | @Configuration 77 | public class MyAutoConfiguration { 78 | 79 | @Bean 80 | @ConditionalOnMissingBean 81 | public MyService myService() { ... } 82 | 83 | } 84 | ``` 85 | 在前面的示例中，如果 ApplicationContext 中没有包含 MyService 类型的 bean，则将创建 myService bean。 86 | 87 | 提示：你需要非常小心添加 bean 定义的顺序，因为这些条件是基于目前为止处理的内容进行评估的。出于这个原因，我们建议在自动配置类上只使用 @ConditionalOnBean 和 @ConditionalOnMissingBean 注解（因为在添加任何用户定义的 bean 定义后，这些注解都保证加载）。 88 | 89 | 注释：@ConditionalOnBean 和 @ConditionalOnMissingBean 不阻止创建 @Configuration 类。在类级别使用这些条件和用注解标记每个包含的 @Bean 方法之间的唯一区别是，如果条件不匹配，前者会阻止将 @Configuration 类注册为 bean。 90 | 91 | ### 49.3.3、Property 条件 92 | 93 | @ConditionalOnProperty 注解允许基于 Spring Environment 属性包含配置。使用 prefix 和 name 属性指定应检查的属性。默认情况下，任何存在且不等于 false 的属性都是匹配的。你还可以使用 havingValue 和 matchIfMissing 属性创建更高级的检查。 94 | 95 | ### 49.3.4、Resource 条件 96 | 97 | @ConditionalOnResource 注解只允许在存在特定资源时包含配置。可以使用常见的 Spring 约定来指定资源，如下面示例所示：file:/home/user/test.dat。 98 | 99 | ### 49.3.5、Web 应用程序条件 100 | 101 | @ConditionalOnWebApplication 和 @Conditionalonotwebapplication 注解允许根据应用程序是否为“web 应用程序”来包括配置。web 应用程序是使用 Spring WebApplicationContext、定义会话作用域或具有 StandardServletEnvironment 的任何应用程序。 102 | 103 | ### 49.3.6、SpEl 表达式条件 104 | 105 | @ConditionalOnExpression 注解允许根据 SpEL 表达式的结果包含配置。 106 | 107 | ## 49.4、测试你的自动配置 108 | 109 | 自动配置可能受到许多因素的影响：用户配置（@Bean 定义和 Environment 自定义）、条件评估（特定库的存在）和其他因素。具体来说，每个测试都应该创建一个定义良好的 ApplicationContext，它表示这些定制的组合。ApplicationContextRunner 提供了一个实现这一点的好方法。 110 | 111 | ApplicationContextRunner 通常定义为测试类的一个字段，用于收集基本的公共配置。以下示例确保始终调用 UserServiceAutoConfiguration： 112 | ``` 113 | private final ApplicationContextRunner contextRunner = new ApplicationContextRunner() 114 | .withConfiguration(AutoConfigurations.of(UserServiceAutoConfiguration.class)); 115 | ``` 116 | 提示：如果必须定义多个自动配置，则无需对其声明进行排序，因为它们的调用顺序与运行应用程序时完全相同。 117 | 118 | 每个测试都可以使用运行器来表示特定的用例。例如，下面的示例调用用户配置（UserConfiguration）并检查自动配置是否正确后退。调用 run 提供了一个可与 Assert4J 一起使用的回调上下文。 119 | ``` 120 | @Test 121 | public void defaultServiceBacksOff() { 122 | this.contextRunner.withUserConfiguration(UserConfiguration.class).run((context) -> { 123 | assertThat(context).hasSingleBean(UserService.class); 124 | assertThat(context.getBean(UserService.class)) 125 | .isSameAs(context.getBean(UserConfiguration.class).myUserService()); 126 | }); 127 | } 128 | 129 | @Configuration 130 | static class UserConfiguration { 131 | 132 | @Bean 133 | public UserService myUserService() { 134 | return new UserService("mine"); 135 | } 136 | 137 | } 138 | ``` 139 | 也可以轻松地自定义 Environment，如下面示例所示： 140 | ``` 141 | @Test 142 | public void serviceNameCanBeConfigured() { 143 | this.contextRunner.withPropertyValues("user.name=test123").run((context) -> { 144 | assertThat(context).hasSingleBean(UserService.class); 145 | assertThat(context.getBean(UserService.class).getName()).isEqualTo("test123"); 146 | }); 147 | } 148 | ``` 149 | 该运行器还可用于显示 ConditionEvaluationReport。该报告可以在 INFO 或 DEBUG 级别打印。下面的示例演示如何使用 ConditionEvaluationReportLoggingListener 在自动配置测试中打印报表。 150 | ``` 151 | @Test 152 | public void autoConfigTest { 153 | ConditionEvaluationReportLoggingListener initializer = new ConditionEvaluationReportLoggingListener( 154 | LogLevel.INFO); 155 | ApplicationContextRunner contextRunner = new ApplicationContextRunner() 156 | .withInitializer(initializer).run((context) -> { 157 | // Do something... 158 | }); 159 | } 160 | ``` 161 | ### 49.4.1、模拟 Web 上下文 162 | 163 | 如果需要测试仅在 Servlet 或 反应式 web 应用程序上下文中运行的自动配置，请分别使用 WebApplicationContextRunner 或 ReactiveWebApplicationContextRunner。 164 | 165 | ### 49.4.2、覆盖 Classpath 166 | 167 | 也可以测试当特定类和/或包在运行时不存在时会发生什么。Spring Boot 附带一个 FilteredClassLoader，可以很容易地被运行器使用。在以下示例中，我们断言，如果不存在 UserService，则会正确禁用自动配置： 168 | ``` 169 | @Test 170 | public void serviceIsIgnoredIfLibraryIsNotPresent() { 171 | this.contextRunner.withClassLoader(new FilteredClassLoader(UserService.class)) 172 | .run((context) -> assertThat(context).doesNotHaveBean("userService")); 173 | } 174 | ``` 175 | ## 49.5、创建自己的 Starter 176 | 177 | 库的完整 Spring Boot starter 可能包含以下组件： 178 | 179 | （1）包含自动配置代码的 autoconfigure 模块。 180 | 181 | （2）提供对 autoconfigure 模块、库和任何其他通常有用的依赖项的依赖的 starter 模块。简而言之，添加 starter 应该提供开始使用该库所需的一切。 182 | 183 | 提示：如果不需要将自动配置代码和依赖项管理分离开来，那么可以将它们合并到一个模块中。 184 | 185 | ### 49.5.1、命名 186 | 187 | 你应该确保为 starter 提供正确的名称空间。不要用 spring-boot 启动模块名，即使使用不同的 Maven groupId。我们未来可能会为你自动配置的东西提供官方支持。 188 | 189 | 根据经验，你应该在 starter 后面命名一个组合模块。例如, 假设您正在为 “acme” 创建 starter，并且你将自动配置模块命名为 acme-spring-boot-autoconfigure 和 starter acme-spring-boot-starter。如果你只有一个将两者结合在一起的模块，请将其命名为 acme-spring-boot-starter。 190 | 191 | 此外，如果你的 starter 提供配置键，请为它们使用唯一的命名空间。特别是，不要在 Spring Boot 使用的命名空间 (如 server、management、 spring 等) 中包含你的键。如果你使用相同的命名空间，我们可能会在将来以破坏你的模块的方式修改这些命名空间。 192 | 193 | 确保[触发元数据生成](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/configuration-metadata.html#configuration-metadata-annotation-processor)，以便你的键也可以使用 IDE 帮助。你可能要查看生成元数据 (meta-inf/spring-configuration-metadata.json) ，以确保键正确记录。 194 | 195 | ### 49.5.2、autoconfigure 模块 196 | 197 | autoconfigure 模块包含开始使用库所需的一切。它还可能包含配置键定义（如 @ConfigurationProperties）和任何回调接口，这些接口可用于进一步自定义组件的初始化方式。 198 | 199 | 提示：你应该将库的依赖项标记为可选，以便可以更轻松地在项目中包含 autoconfigure 模块。如果这样做，则默认情况下不提供库，并且 Spring Boot 会退出。 200 | 201 | Spring Boot 使用注解处理器采集元数据文件（META-INF/spring-autoconfigure-metadata.properties）中自动配置的条件。如果该文件存在，它将用于急切地过滤不匹配的自动配置，这将提高启动时间。建议在包含自动配置的模块中添加以下依赖项： 202 | ``` 203 | 204 | org.springframework.boot 205 | spring-boot-autoconfigure-processor 206 | true 207 | 208 | ``` 209 | 对于 Gradle 4.5 和更早版本，应该在 compileOnly 配置中声明依赖项，如下面示例所示： 210 | ``` 211 | dependencies { 212 | compileOnly "org.springframework.boot:spring-boot-autoconfigure-processor" 213 | } 214 | ``` 215 | 对于 Gradle4.6 及更高版本，应该在 annotationProcessor 配置中声明依赖项，如下面示例所示： 216 | ``` 217 | dependencies { 218 | annotationProcessor "org.springframework.boot:spring-boot-autoconfigure-processor" 219 | } 220 | ``` 221 | ### 49.5.3、Starter 模块 222 | 223 | starter 实际上是一个空 jar。它的唯一目的是提供使用库所必要的依赖项。你可以把它看作是开始需要做的事情的一种固执己见的观点。 224 | 225 | 不要对添加了 starter 的项目做出假设。如果你正在自动配置的库通常需要其他 starter，请也提及它们。如果可选依赖项的数量很高，提供一组合适的默认依赖项可能会很困难，因为你应该避免包含对库的典型使用不必要的依赖项。换句话说，你不应该包括可选的依赖项。 226 | 227 | 注释：无论哪种方式，starter 都必须直接或间接地引用核心 Spring Boot starter（spring-boot-starter）（即，如果 starter 依赖于另一个 starter，则无需添加）。如果一个项目只使用你的自定义 starter 创建，那么 Spring Boot 的核心功能将受到核心 starter 的支持。 228 | -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/50、Kotlin支持.md: -------------------------------------------------------------------------------- 1 | # 50、Kotlin 支持 2 | 3 | Kotlin 是一种针对 JVM（和其他平台）的静态类型语言，它允许编写简洁而优雅的代码，同时提供与用 Java 编写的现有库的互操作性。 4 | 5 | Spring Boot 通过利用其他 Spring 项目（如 Spring Framework、 Spring Data 和 Reactor） 中的支持来提供 Kotlin 支持。有关更多信息，请参见 [Spring Framework Kotlin 支持文档](https://docs.spring.io/spring/docs/5.1.8.RELEASE/spring-framework-reference/languages.html#kotlin)。 6 | 7 | 从 Spring Boot 和 Kotlin 开始的最简单的方法是遵循这个全面的教程。你可以通过 start.spring.io 创建新的 Kotlin 项目。如果你需要支持，请随时加入 Kotlin Slack 的 #spring 频道，或者在 Stack Overflow 上询问 spring 和 kotlin 标签的问题。 8 | 9 | ## 50.1、要求 10 | 11 | Spring Boot 支持 Kotlin 1.2.x。要使用 Kotlin，org.jetbrains.kotlin:kotlin-stdlib 和 org.jetbrains.kotlin:kotlin-reflect 必须出现在类路径上。也可以使用 kotlin-stdlib 变体 kotlin-stdlib-jdk7 和 kotlin-stdlib-jdk8。 12 | 13 | 由于 Kotlin 类是默认的 final 类，你可能需要配置 kotlin-spring 插件，以便自动打开 Spring 注解类，以便它们可以被代理。 14 | 15 | 在 Kotlin 中序列化/反序列化 JSON 数据需要 Jackson 的 Kotlin 模块。在类路径上找到时，它会自动注册。如果 Jackson 和 Kotlin 存在，但 Jackson Kotlin 模块不存在，则会记录一条警告消息。 16 | 17 | 提示：如果在 start.spring.io 上引导 Kotlin 项目，则默认提供这些依赖项和插件。 18 | 19 | ## 50.2、空安全 20 | 21 | Kotlin 的一个关键特性是空安全性。它在编译时处理空值，而不是将问题推迟到运行时并遇到 NullPointerException。这有助于消除常见的错误源，而不必像 Optional 那样支付包装器的成本。Kotlin 还允许使用函数式构造，其值可以为空，如 Kotlin 中的空安全性综合指南所述。 22 | 23 | 尽管 Java 不允许在其类型系统中表达空安全性，但 Spring Framework、Spring Data 和 Reactor 现在通过工具友好的注解为其 API 提供空安全性。默认情况下，Kotlin 中使用的 Java APIs 中的类型被识别为可以放宽空检查的平台类型。Kotlin 对 JSR 305 注解的支持结合可空性注解为 Kotlin 中的相关 Spring API 提供了空安全性。 24 | 25 | JSR 305 检查可以通过添加带有以下选项的 -Xjsr305 编译器标志来配置：-Xjsr305={strict | warn | ignore}。默认行为与 -Xjsr305=warn 相同。strict 值要求在从 Spring API 推断的 Kotlin 类型中考虑空安全性，但应在使用时知道 Spring API 可空性声明可能会在较小的版本之间演变，并且将来可能会添加更多的检查。 26 | 27 | 警告：还不支持泛型类型参数、可变参数 和数组元素的可空性。有关最新信息，请参阅 SPR-15942。还要注意，Spring Boot 自己的 API [还没有注解](https://github.com/spring-projects/spring-boot/issues/10712)。 28 | 29 | ## 50.3、Kotlin API 30 | 31 | ## 50.3.1、runApplication 32 | 33 | Spring Boot 提供了一种惯用的方法来运行带有 runApplication(*args) 的应用程序，如下面示例所示： 34 | ``` 35 | import org.springframework.boot.autoconfigure.SpringBootApplication 36 | import org.springframework.boot.runApplication 37 | 38 | @SpringBootApplication 39 | class MyApplication 40 | 41 | fun main(args: Array) { 42 | runApplication(*args) 43 | } 44 | ``` 45 | 这是 SpringApplication.run(MyApplication::class.java, *args) 的一个嵌入式替代品。它还允许自定义应用程序，如下面示例所示： 46 | ``` 47 | runApplication(*args) { 48 | setBannerMode(OFF) 49 | } 50 | ``` 51 | ## 50.3.2、扩展 52 | 53 | Kotlin 扩展提供了用附加功能扩展现有类的能力。Spring Boot Kotlin API 利用这些扩展为现有 API 添加新的 Kotlin 特有的便利性。 54 | 55 | 提供了 TestRestTemplate 扩展，类似于 Spring Framework 中用于 RestOperations 的 Spring Framework 提供的扩展。除此之外，这些扩展使得利用 Kotlin 具体化类型参数成为可能。 56 | 57 | ## 50.4、依赖管理 58 | 59 | 为了避免在类路径上混合不同版本的 Kotlin 依赖项，提供了以下 Kotlin 依赖项的依赖项管理： 60 | 61 | kotlin-reflect 62 | kotlin-runtime 63 | kotlin-stdlib 64 | kotlin-stdlib-jdk7 65 | kotlin-stdlib-jdk8 66 | kotlin-stdlib-jre7 67 | kotlin-stdlib-jre8 68 | 69 | 使用 Maven，可以通过 kotlin.version 属性自定义 Kotlin 版本，并为 kotlin-maven-plugin 提供插件管理。使用 Gradle，Spring Boot 插件会自动将 kotlin.version 与 Kotlin 插件的版本对齐。 70 | 71 | ## 50.5、@ConfigurationProperties 72 | 73 | @ConfigurationProperties 当前仅适用于 lateinit 或可为空的 var 属性（建议使用前者），因为[尚不支持](https://github.com/spring-projects/spring-boot/issues/8762)由构造函数初始化的不可变类。 74 | ``` 75 | @ConfigurationProperties("example.kotlin") 76 | class KotlinExampleProperties { 77 | 78 | lateinit var name: String 79 | 80 | lateinit var description: String 81 | 82 | val myService = MyService() 83 | 84 | class MyService { 85 | 86 | lateinit var apiToken: String 87 | 88 | lateinit var uri: URI 89 | 90 | } 91 | 92 | } 93 | ``` 94 | 提示：要使用注解处理器生成你自己的元数据，应使用 spring-boot-configuration-processor 依赖项配置 kapt。 95 | 96 | ## 50.6、测试 97 | 98 | 虽然可以使用 JUnit 4（spring-boot-starter-test 提供的默认值）来测试 Kotlin 代码，但建议使用 JUnit 5。JUnit 5 使测试类可以被实例化一次，并可重复用于该类的所有测试。这使得在非静态方法上使用 @BeforeAll 和 @AfterAll 注解成为可能，这对于 Kotlin 来说是一个很好的选择。 99 | 100 | 要使用 JUnit 5，请从 spring-boot-starter-test 中排除 junit:junit 依赖项，添加 JUnit 5 依赖项，并相应地配置 Maven 或 Gradle 插件。有关更多详细信息，请参见 JUnit 5 文档。你还需要将测试实例生命周期切换为 “每类”。 101 | 102 | 为了模拟 Kotlin 类，建议使用 MockK。如果你需要与 Mockito 特定的 @MockBean 和 @SpyBean 注解等效的 Mockk，则可以使用提供类似 @MockBean 和 @SpykBean 注解的 SpringMockK。 103 | 104 | ## 50.7、资源 105 | 106 | ## 50.7.1、延伸阅读 107 | 108 | （1）[Kotlin 语言参考](https://kotlinlang.org/docs/reference/) 109 | 110 | （2）[Kotlin Slack（配有专用 #spring 频道）](https://slack.kotlinlang.org/) 111 | 112 | （3）[带 spring 和 kotlin 标签的 Stackoverflow](https://stackoverflow.com/questions/tagged/spring+kotlin) 113 | 114 | （4）[在浏览器中尝试 Kotlin](https://try.kotlinlang.org/) 115 | 116 | （5）[Kotlin 博客](https://blog.jetbrains.com/kotlin/) 117 | 118 | （6）[棒极了的 Kotlin](https://kotlin.link/) 119 | 120 | （7）[教程：使用 Spring Boot 和 Kotlin 构建 web 应用程序](https://spring.io/guides/tutorials/spring-boot-kotlin/) 121 | 122 | （8）[使用 Kotlin 开发 Spring Boot 应用程序](https://spring.io/blog/2016/02/15/developing-spring-boot-applications-with-kotlin) 123 | 124 | （9）[带有 Kotlin 、 Spring Boot 和 PostgreSQL 的地理空间信使](https://spring.io/blog/2016/03/20/a-geospatial-messenger-with-kotlin-spring-boot-and-postgresql) 125 | 126 | （10）[在 Spring Framework 5.0 中引入 Kotlin 支持](https://spring.io/blog/2017/01/04/introducing-kotlin-support-in-spring-framework-5-0) 127 | 128 | （11）[Spring Framework 5 Kotlin APIs，函数式方式](https://spring.io/blog/2017/08/01/spring-framework-5-kotlin-apis-the-functional-way) 129 | 130 | ## 50.7.2、示例 131 | 132 | （1）[spring-boot-kotlin-demo](https://github.com/sdeleuze/spring-boot-kotlin-demo)：常规 Spring Boot + Spring Data JPA 项目 133 | 134 | （2）[mixit](https://github.com/mixitconf/mixit)：Spring Boot 2 + WebFlux + Reactive Spring Data MongoDB 135 | 136 | （3）[spring-kotlin-fullstack](https://github.com/sdeleuze/spring-kotlin-fullstack)：WebFlux Kotlin 全栈示例，其中 Kotlin2js 用于前端，而不是 JavaScript 或 TypeScript 137 | 138 | （4）[spring-petclinic-kotlin](https://github.com/spring-petclinic/spring-petclinic-kotlin)：Kotlin 版本的 Spring PetClinic 示例应用程序 139 | 140 | （5）[spring-kotlin-deepdive](https://github.com/sdeleuze/spring-kotlin-deepdive)：Boot 1.0 + Java 到 Boot 2.0 + Kotlin 的逐步迁移 -------------------------------------------------------------------------------- /spring-boot/reference/04SpringBoot功能/51、延伸阅读.md: -------------------------------------------------------------------------------- 1 | # 51、延伸阅读 2 | 3 | 如果你想了解本节中讨论的任何类的更多信息，可以查看 [Spring Boot API 文档](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/api)，也可以[直接浏览源代码](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE)。如果你有具体问题，请查看[操作指南](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/howto.html)部分。 4 | 5 | 如果你对 Spring Boot 的核心功能感到满意，你可以继续阅读有关[生产就绪功能的内容](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/production-ready.html)。 6 | -------------------------------------------------------------------------------- /spring-boot/reference/05SpringBootActuator：生产就绪功能/52、启用生产就绪功能.md: -------------------------------------------------------------------------------- 1 | # 第五部分：Spring Boot Actuator：生产就绪功能 2 | 3 | Spring Boot 包含许多附加功能，可帮助你在将应用程序推送到生产环境时监视和管理应用程序。你可以选择使用 HTTP 端点或 JMX 来管理和监控你的应用程序。审计、运行状况和度量收集也可以自动应用于你的应用程序。 4 | 5 | # 52、启用生产就绪功能 6 | 7 | spring-boot-actuator 模块提供了Spring Boot 的所有生产就绪功能。启用这些功能的最简单方法是添加一个 spring-boot-starter-actuator “Starter”依赖项。 8 | 9 | Actuator 的定义 10 | 11 | Actuator 是指用于移动或控制某物的机械装置的制造术语。Actuator 可以从一个小的变化中产生大量的运动。 12 | 13 | 要将 Actuator 添加到基于 Maven 的项目中，请添加以下“Starter”依赖项： 14 | ``` 15 | 16 | 17 | org.springframework.boot 18 | spring-boot-starter-actuator 19 | 20 | 21 | ``` 22 | 对于 Gradle，使用以下声明： 23 | ``` 24 | dependencies { 25 | compile("org.springframework.boot:spring-boot-starter-actuator") 26 | } 27 | ``` -------------------------------------------------------------------------------- /spring-boot/reference/05SpringBootActuator：生产就绪功能/54、通过HTTP进行监控和管理.md: -------------------------------------------------------------------------------- 1 | # 54、通过 HTTP 进行监控和管理 2 | 3 | 如果你正在开发 web 应用程序，Spring Boot Actuator 会自动配置所有启用的端点，以便通过 HTTP 公开。默认约定是使用前缀 /actuator 和端点 id 一起作为 URL 路径。例如，health 被公开为 /actuator/health。提示：Spring MVC、Spring WebFlux 和 Jersey 原生支持 Actuator。 4 | 5 | ## 54.1、自定义管理端点路径 6 | 7 | 有时，为管理端点自定义前缀是很有用的。例如，你的应用程序可能已经将 /actuator 用于其他目的。你可以使用 management.endpoints.web.base-path 属性更改管理端点的前缀，如下面示例所示： 8 | 9 | management.endpoints.web.base-path=/manage 10 | 11 | 前面的 application.properties 示例将端点从 /actuator/{id} 更改为 /manage/{id}（例如 /manage/info）。 12 | 13 | 注释：如果管理端口未配置为使用其他 HTTP 端口公开端点，则 management.endpoints.web.base-path 相对于 server.servlet.context-path。如果配置了 management.server.port，则 management.endpoints.web.base-path 相对于 management.server.servlet.context-path。 14 | 15 | 如果要将端点映射到不同的路径，可以使用 management.endpoints.web.path-mapping 属性。 16 | 17 | 以下示例将 /actuator/health 重新映射到 /healthcheck： 18 | 19 | **application.properties** 20 | 21 | management.endpoints.web.base-path=/ 22 | management.endpoints.web.path-mapping.health=healthcheck 23 | 24 | ## 54.2、自定义管理服务器端口 25 | 26 | 使用默认 HTTP 端口公开管理端点对于基于云的部署是明智的选择。但是，如果你的应用程序在你自己的数据中心内运行，你可能更喜欢使用不同的 HTTP 端口来公开端点。 27 | 28 | 你可以设置 management.server.port 属性来更改 HTTP 端口，如下面示例所示： 29 | 30 | management.server.port=8081 31 | 32 | 注释：在 Cloud Foundry 上，默认情况下，应用程序仅在端口 8080 上接收 HTTP 和 TCP 路由的请求。如果你想在 Cloud Foundry 上使用自定义管理端口，则需要明确设置应用程序的路由，以便将流量转发到自定义端口。 33 | 34 | ## 54.3、配置特定于管理的 SSL 35 | 36 | 当配置为使用自定义端口时，也可以使用各种 management.server.ssl.* 属性来配置带有 SSL 的管理服务器。例如，这样做可以使管理服务器通过 HTTP 可用，而主应用程序使用 HTTPS，如下面的属性设置所示： 37 | 38 | server.port=8443 39 | server.ssl.enabled=true 40 | server.ssl.key-store=classpath:store.jks 41 | server.ssl.key-password=secret 42 | management.server.port=8080 43 | management.server.ssl.enabled=false 44 | 45 | 或者，主服务器和管理服务器都可以使用 SSL，但使用不同的密钥存储，如下所示： 46 | 47 | server.port=8443 48 | server.ssl.enabled=true 49 | server.ssl.key-store=classpath:main.jks 50 | server.ssl.key-password=secret 51 | management.server.port=8080 52 | management.server.ssl.enabled=true 53 | management.server.ssl.key-store=classpath:management.jks 54 | management.server.ssl.key-password=secret 55 | 56 | ## 54.4、自定义管理服务器地址 57 | 58 | 通过设置 management.server.address 属性，可以自定义管理端点可用的地址。如果你只想在内部或面向 ops 的网络上监听，或者只想监听来自 localhost 的连接，则这样做非常有用。 59 | 60 | 注释：只有当端口与主服务器端口不同时，才能监听其他地址。 61 | 62 | 以下示例 application.properties 不允许远程管理连接： 63 | 64 | management.server.port=8081 65 | management.server.address=127.0.0.1 66 | 67 | ## 54.5、禁用 HTTP 端点 68 | 69 | 如果不想通过 HTTP 公开端点，可以将管理端口设置为 -1，如下面示例所示： 70 | 71 | management.server.port=-1 72 | 73 | 这也可以使用 management.endpoints.web.exposure.exclude 属性来实现，如下面示例所示： 74 | 75 | management.endpoints.web.exposure.exclude=* 76 | 77 | 78 | -------------------------------------------------------------------------------- /spring-boot/reference/05SpringBootActuator：生产就绪功能/55、通过JMX进行监控和管理.md: -------------------------------------------------------------------------------- 1 | # 55、通过 JMX 进行监控和管理 2 | 3 | Java 管理扩展（JMX）提供了一种标准机制来监控和管理应用程序。默认情况下，Spring Boot 将管理端点公开为 org.springframework.boot 域下的 JMX MBeans。 4 | 5 | ## 55.1、自定义 MBean 名称 6 | 7 | MBean 的名称通常由端点的 id 生成。例如，health 端点公开为 org.springframework.boot:type=Endpoint,name=Health。 8 | 9 | 如果应用程序包含多个 Spring ApplicationContext，则可能会发现名称冲突。要解决此问题，可以将 spring.jmx.unique-names 属性设置为 true，以便 MBean 名称始终是唯一的。 10 | 11 | 你还可以自定义端点在其下公开的 JMX 域。以下设置显示了在 application.properties 中执行此操作的示例： 12 | 13 | spring.jmx.unique-names=true 14 | management.endpoints.jmx.domain=com.example.myapp 15 | 16 | ## 55.2、禁用 JMX 端点 17 | 18 | 如果不想通过 JMX 公开端点，可以将 management.endpoints.jmx.exposure.exclude 属性设置为 *，如下面示例所示： 19 | 20 | management.endpoints.jmx.exposure.exclude=* 21 | 22 | ## 55.3、通过 HTTP 将 Jolokia 用于 JMX 23 | 24 | Jolokia 是一个 JMX-HTTP 桥，它提供了一种访问 JMX bean 的替代方法。要使用 Jolokia，请包含对 org.jolokia:jolokia-core 的依赖。例如，使用 Maven，你可以添加以下依赖项： 25 | ```xml 26 | 27 | org.jolokia 28 | jolokia-core 29 | 30 | ``` 31 | 然后，可以通过将 Jolokia 或 * 添加到 management.endpoints.web.exposure.include 属性中来公开 Jolokia 端点。然后可以在管理 HTTP 服务器上使用 /actuator/jolokia 访问它。 32 | 33 | ### 55.3.1、自定义 Jolokia 34 | 35 | Jolokia 有许多设置，传统上你可以通过设置 servlet 参数来配置这些设置。使用 Spring Boot，你可以使用 application.properties 文件。为此，请使用 management.endpoint.jolokia.config. 作为参数的前缀，如下面示例所示： 36 | 37 | management.endpoint.jolokia.config.debug=true 38 | 39 | ### 55.3.2、禁用 Jolokia 40 | 41 | 如果使用 Jolokia 但不希望 Spring Boot 对其进行配置，请将 management.endpoint.Jolokia.enabled 属性设置为 false，如下所示： 42 | 43 | management.endpoint.jolokia.enabled=false 44 | 45 | 46 | -------------------------------------------------------------------------------- /spring-boot/reference/05SpringBootActuator：生产就绪功能/56、日志器.md: -------------------------------------------------------------------------------- 1 | # 56、日志器 2 | 3 | Spring Boot Actuator 包括在运行时查看和配置应用程序日志级别的功能。你可以查看整个列表或单个日志器的配置，该配置由明确配置的日志级别以及日志框架给它的有效日志级别组成。这些级别可以是： 4 | 5 | TRACE 6 | DEBUG 7 | INFO 8 | WARN 9 | ERROR 10 | FATAL 11 | OFF 12 | null 13 | 14 | null 表示没有显式配置。 15 | 16 | ## 56.1、配置日志器 17 | 18 | 要配置给定的日志器，请将部分实体 POST 到资源的 URI，如下面示例所示： 19 | ``` 20 | { 21 | "configuredLevel": "DEBUG" 22 | } 23 | ``` 24 | 提示：要“重置”日志器的特定级别（并改用默认配置），可以传递 null 值作为 configuredLevel。 25 | -------------------------------------------------------------------------------- /spring-boot/reference/05SpringBootActuator：生产就绪功能/58、审计.md: -------------------------------------------------------------------------------- 1 | # 58、审计 2 | 3 | 一旦 Spring Security 投入使用，Spring Boot Actuator 就有了一个灵活的审计框架，可以发布事件（默认情况下，“认证成功”、“失败”和“拒绝访问”异常）。此功能对于报告和实现基于身份验证失败的锁定策略非常有用。要自定义已发布的安全事件，可以提供自己的 AbstractAuthenticationAuditListener 和 AbstractAuthorizationAuditListener 实现。 4 | 5 | 你还可以为自己的业务事件使用审计服务。为此，请将现有的 AuditEventRepository 注入到你自己的组件中并直接使用该组件，或者使用 Spring ApplicationEventPublisher 发布 AuditApplicationEvent（通过实现 ApplicationEventPublisherAware）。 -------------------------------------------------------------------------------- /spring-boot/reference/05SpringBootActuator：生产就绪功能/59、HTTP跟踪.md: -------------------------------------------------------------------------------- 1 | # 59、HTTP 跟踪 2 | 3 | 对所有 HTTP 请求自动启用跟踪。你可以查看 httptrace 端点并获取有关最近 100 个请求-响应交换的基本信息。 4 | 5 | ## 59.1、自定义 HTTP 跟踪 6 | 7 | 要自定义每个跟踪中包含的项，请使用 management.trace.http.include 配置属性。对于高级定制，请考虑注册你自己的 HttpExchangeTracer 实现。 8 | 9 | 默认情况下，使用 InMemoryHttpTraceRepository 存储最近 100 个请求-响应交换的跟踪。如果需要扩展容量，可以定义自己的 InMemoryHttpTraceRepository bean 实例。你还可以创建自己的替代的 HttpTraceRepository 实现。 10 | -------------------------------------------------------------------------------- /spring-boot/reference/05SpringBootActuator：生产就绪功能/60、进程监控.md: -------------------------------------------------------------------------------- 1 | # 60、进程监控 2 | 3 | 在 spring-boot 模块中，你可以找到两个类来创建通常对进程监控有用的文件： 4 | 5 | （1）ApplicationPidFileWriter 创建一个包含应用程序 PID 的文件（默认情况下，在应用程序目录中，文件名为 application.pid）。 6 | 7 | （2）WebServerPortFileWriter 创建一个文件（或多个文件），其中包含正在运行的 web 服务器的端口（默认情况下，在应用程序目录中，文件名为 application.port）。 8 | 9 | 默认情况下，这些写入程序未激活，但你可以启用： 10 | 11 | （1）[通过扩展配置](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/production-ready-process-monitoring.html#production-ready-process-monitoring-configuration) 12 | 13 | （2）[第 60.2 节：以编程方式](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/production-ready-process-monitoring.html#production-ready-process-monitoring-programmatically) 14 | 15 | ## 60.1、扩展配置 16 | 17 | 在 META-INF/spring.factories 文件中，可以激活编写 PID 文件的监听器，如下面示例所示： 18 | 19 | org.springframework.context.ApplicationListener=\ 20 | org.springframework.boot.context.ApplicationPidFileWriter,\ 21 | org.springframework.boot.web.context.WebServerPortFileWriter 22 | 23 | ## 60.2、以编程方式 24 | 25 | 还可以通过调用 SpringApplication.addListeners(…) 方法并传递适当的 Writer 对象来激活监听器。此方法还允许你自定义 Writer 构造函数中的文件名和路径。 -------------------------------------------------------------------------------- /spring-boot/reference/05SpringBootActuator：生产就绪功能/61、CloudFoundry支持.md: -------------------------------------------------------------------------------- 1 | # 61、Cloud Foundry 支持 2 | 3 | Spring Boot 的 actuator 模块包括在部署到兼容的 Cloud Foundry 实例时激活的其他支持。/cloudfoundryapplication 路径提供了通往所有 @Endpoint bean 的另一种安全路由。 4 | 5 | 扩展支持使 Cloud Foundry 管理 UI（例如你可以用来查看已部署的应用程序的 web 应用程序）能够使用 Spring Boot actuator 信息进行增强。例如，应用程序状态页面可能包含完整的运行状况信息，而不是典型的 “正在运行” 或 “已停止” 状态。 6 | 7 | 注释：普通用户无法直接访问 /cloudfundryapplication 路径。为了使用端点，必须与请求一起传递有效的 UAA token。 8 | 9 | ## 61.1、禁用扩展的 Cloud Foundry Actuator 支持 10 | 11 | 如果要完全禁用 /cloudfoundryapplication 端点，可以将以下设置添加到 application.properties 文件中： 12 | 13 | application.properties 14 | 15 | management.cloudfoundry.enabled=false 16 | 17 | ## 61.2、Cloud Foundry 自签名证书 18 | 19 | 默认情况下，/cloudfoundryapplication 端点的安全验证对各种 Cloud Foundry 服务进行 SSL 调用。如果你的 Cloud Foundry UAA 或 Cloud Controller 服务使用自签名证书，则需要设置以下属性： 20 | 21 | application.properties 22 | 23 | management.cloudfoundry.skip-ssl-validation=true 24 | 25 | ## 61.3、自定义上下文路径 26 | 27 | 如果服务器的上下文路径已配置为 / 以外的任何内容，则 Cloud Foundry 端点在应用程序的根目录将不可用。例如，如果 server.servlet.context-path=/app，则 Cloud Foundry 端点将在/app/cloudfoundry dryapplication/* 上可用。 28 | 29 | 如果你希望 Cloud Foundry 端点始终在/cloudfoundryapplication/* 上可用，无论服务器的上下文路径如何，则你需要在应用程序中明确配置它。配置将根据使用中的 web 服务器而有所不同。对于 Tomcat，可以添加以下配置： 30 | ```java 31 | @Bean 32 | public TomcatServletWebServerFactory servletWebServerFactory() { 33 | return new TomcatServletWebServerFactory() { 34 | 35 | @Override 36 | protected void prepareContext(Host host, ServletContextInitializer[] initializers) { 37 | super.prepareContext(host, initializers); 38 | StandardContext child = new StandardContext(); 39 | child.addLifecycleListener(new Tomcat.FixContextListener()); 40 | child.setPath("/cloudfoundryapplication"); 41 | ServletContainerInitializer initializer = getServletContextInitializer(getContextPath()); 42 | child.addServletContainerInitializer(initializer, Collections.emptySet()); 43 | child.setCrossContext(true); 44 | host.addChild(child); 45 | } 46 | 47 | }; 48 | } 49 | 50 | private ServletContainerInitializer getServletContextInitializer(String contextPath) { 51 | return (c, context) -> { 52 | Servlet servlet = new GenericServlet() { 53 | 54 | @Override 55 | public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { 56 | ServletContext context = req.getServletContext().getContext(contextPath); 57 | context.getRequestDispatcher("/cloudfoundryapplication").forward(req, res); 58 | } 59 | 60 | }; 61 | context.addServlet("cloudfoundry", servlet).addMapping("/*"); 62 | }; 63 | } 64 | ``` -------------------------------------------------------------------------------- /spring-boot/reference/05SpringBootActuator：生产就绪功能/62、延伸阅读.md: -------------------------------------------------------------------------------- 1 | 62、延伸阅读 2 | 3 | 如果你想了解本章讨论的一些概念，可以查看 actuator [示例应用程序](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-samples)。你可能还想了解一些绘图工具，比如 [Graphite](https://graphite.wikidot.com/)。 4 | 5 | 否则，你可以继续阅读有关[部署选项](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/deployment.html)的内容，或者直接跳到有关 Spring Boot [构建工具插件](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/build-tool-plugins.html)的深入信息。 6 | -------------------------------------------------------------------------------- /spring-boot/reference/06部署SpringBoot应用程序/64、安装SpringBoot应用程序.md: -------------------------------------------------------------------------------- 1 | # 64、安装 Spring Boot 应用程序 2 | 3 | 除了使用 java -jar 运行 Spring Boot 应用程序外，还可以为 Unix 系统生成完全可执行的应用程序。一个完全可执行的 jar 可以像任何其他可执行二进制文件一样执行，也可以[用 init.d 或 systemd 注册](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/deployment-install.html#deployment-service)。这使得在常见的生产环境中安装和管理 Spring Boot 应用程序变得非常容易。 4 | 5 | 警告：完全可执行的 jar 通过在文件前面嵌入额外的脚本来工作。目前，一些工具不接受这种格式，因此你可能并不总是能够使用这种技术。例如，jar -xf 可能会默默地无法提取已完全可执行的 jar 或 war。建议仅当你打算直接执行 jar 或 war 时，才使其完全可执行，而不是使用 java -jar 运行它或将其部署到 servlet 容器中。 6 | 7 | 要使用 Maven 创建 “完全可执行” 的 jar，请使用以下插件配置： 8 | ```xml 9 | 10 | org.springframework.boot 11 | spring-boot-maven-plugin 12 | 13 | true 14 | 15 | 16 | ``` 17 | 下面的示例展示了等效的 Gradle 配置： 18 | ``` 19 | bootJar { 20 | launchScript() 21 | } 22 | ``` 23 | 然后可以通过键入 ./my-application.jar（其中 my-application 是工件的名称）来运行应用程序。包含 jar 的目录用作应用程序的工作目录。 24 | 25 | ## 64.1、支持的操作系统 26 | 27 | 默认脚本支持大多数 Linux 发行版，并在 CentOS 和 Ubuntu 上进行了测试。其他平台，如 OS X 和 FreeBSD，需要使用自定义的 embeddedLaunchScript。 28 | 29 | ## 64.2、Unix/Linux 服务 30 | 31 | 通过使用 init.d 或 systemd，Spring Boot 应用程序可以很容易地作为 Unix/Linux 服务启动。 32 | 33 | ### 64.2.1、作为 init.d 服务安装（系统 V） 34 | 35 | 如果已配置 Spring Boot 的 Maven 或 Gradle 插件来生成完全可执行的 jar，并且不使用自定义的 embeddedLaunchScript，那么你的应用程序可以用作 init.d 服务。为此，将 jar 符号连接到 init.d，以支持标准的 start、stop、restart 和 status 命令。 36 | 37 | 脚本支持以下功能： 38 | 39 | （1）以拥有 jar 文件的用户身份启动服务 40 | （2）使用 /var/run//.PID 跟踪应用程序的 PID 41 | （3）将控制台日志写入 /var/log/.log 42 | 43 | 假设你在 /var/myapp 中安装了 Spring Boot 应用程序，要将 Spring Boot 应用程序安装为 init.d 服务，请创建符号连接，如下所示： 44 | 45 | $ sudo ln -s /var/myapp/myapp.jar /etc/init.d/myapp 46 | 47 | 安装后，你可以以通常的方式启动和停止服务。例如，在基于 Debian 的系统上，你可以使用以下命令启动它： 48 | 49 | $ service myapp start 50 | 51 | 提示：如果应用程序无法启动，请检查写入 /var/log/.log 的日志文件中的错误。 52 | 53 | 你还可以使用标准操作系统工具将应用程序标记为自动启动。例如，在 Debian 上，你可以使用以下命令： 54 | 55 | $ update-rc.d myapp defaults 56 | 57 | **保护 init.d 服务** 58 | 59 | 注释：以下是一组关于如何保护作为 init.d 服务运行的 Spring Boot 应用程序的指南。它并不是一个详尽的列表，列出了为了强化应用程序及其运行环境而应该做的所有事情。 60 | 61 | 当以 root 身份执行时，就像使用 root 启动 init.d 服务时一样，默认可执行脚本以拥有 jar 文件的用户身份运行应用程序。你永远不应该以 root 用户身份运行 Spring Boot 应用程序，因此你的应用程序的 jar 文件永远不应该由 root 用户拥有。相反，创建一个特定的用户来运行你的应用程序，并使用 chown 使其成为 jar 文件的所有者，如下面示例所示： 62 | 63 | $ chown bootapp:bootapp your-app.jar 64 | 65 | 在这种情况下，默认可执行脚本以 bootapp 用户的身份运行应用程序。 66 | 67 | 提示：为了减少应用程序的用户帐户被泄露的可能性，你应该考虑阻止它使用登录外壳。例如，你可以将帐户的 shell 设置为 /usr/sbin/nologin。 68 | 69 | 你还应该采取措施防止修改应用程序的 jar 文件。首先，配置其权限，使其无法写入，只能由其所有者读取或执行，如下面示例所示： 70 | 71 | $ chmod 500 your-app.jar 72 | 73 | 第二，如果你的应用程序或运行它的帐户受到损害，你还应该采取措施限制损害。如果攻击者确实获得了访问权限，他们可以使 jar 文件可写并更改其内容。防止这种情况的一种方法是使用 chattr 使其不可变，如下例所示： 74 | 75 | sudo chattr +i your-app.jar 76 | 77 | 这将阻止任何用户（包括 root 用户）修改 jar。 78 | 79 | 如果使用 root 来控制应用程序的服务，并且使用 .conf 文件自定义其启动，则 root 用户将读取并计算 .conf 文件。应相应地加以保护。使用 chmod 使文件只能由所有者读取，并使用 chown 使 root 成为所有者，如下例所示： 80 | 81 | $ chmod 400 your-app.conf 82 | $ sudo chown root:root your-app.conf 83 | 84 | ### 64.2.2、作为 systemd 服务安装 85 | 86 | systemd 是 System V init 系统的后继者，现在被许多现代 Linux 发行版使用。尽管可以继续在 systemd 中使用 init.d 脚本，但也可以通过使用 systemd “服务” 脚本启动 Spring Boot 应用程序。 87 | 88 | 假设你在 /var/myapp 中安装了一个 Spring Boot 应用程序，要将 Spring Boot 应用程序作为 systemd 服务安装，请创建一个名为 myapp.service 的脚本并将其放置在 /etc/systemd/system 目录中。以下脚本提供了一个示例： 89 | ``` 90 | [Unit] 91 | Description=myapp 92 | After=syslog.target 93 | 94 | [Service] 95 | User=myapp 96 | ExecStart=/var/myapp/myapp.jar 97 | SuccessExitStatus=143 98 | 99 | [Install] 100 | WantedBy=multi-user.target 101 | ``` 102 | 重要的：请记住更改应用程序的 Description、User 和 ExecStart 字段。 103 | 104 | 注释：ExecStart 字段不声明脚本操作命令，这意味着默认情况下使用 run 命令。 105 | 106 | 注意，与作为 init.d 服务运行不同，运行应用程序的用户、PID 文件和控制台日志文件由 systemd 本身管理，因此必须使用“service”脚本中的适当字段进行配置。有关更多详细信息，请参阅[服务单元配置手册页](https://www.freedesktop.org/software/systemd/man/systemd.service.html)。 107 | 108 | 要将应用程序标记为在系统启动时自动启动，请使用以下命令： 109 | 110 | $ systemctl enable myapp.service 111 | 112 | 有关更多详细信息，请参阅 man systemctl。 113 | 114 | ### 64.2.3、自定义启动脚本 115 | 116 | Maven 或 Gradle 插件编写的默认嵌入式启动脚本可以通过多种方式进行自定义。对于大多数人来说，使用默认脚本以及一些自定义通常就足够了。如果你发现你不能定制你需要的东西，使用 embeddedLaunchScript 选项来完全编写你自己的文件。 117 | 118 | **编写启动脚本时自定义它** 119 | 120 | 当开始脚本被写入 jar 文件时，定制它的元素通常是有意义的。例如，init.d 脚本可以提供 “描述”。因为你知道前面的描述（并且它不需要改变），所以你最好在生成 jar 时提供它。 121 | 122 | 要自定义编写的元素，请使用 Spring Boot Maven 插件的 embeddedLaunchScriptProperties 选项或 [Spring Boot Gradle 插件的 launchScript 的 properties 属性](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/gradle-plugin/reference/html/#packaging-executable-configuring-launch-script)。 123 | 124 | 默认脚本支持以下属性替换： 125 | 126 | |名称 |描述 |Gradle 默认 |Maven 默认| 127 | |---|---|---|---| 128 | |mode |脚本模式。 |auto |auto| 129 | |initInfoProvides |“INIT INFO” 的 Provides 部分。 |${task.baseName} |${project.artifactId}| 130 | |initInfoRequiredStart |“INIT INFO” 的 Required-Start 部分。 |$remote_fs $syslog $network |$remote_fs $syslog $network| 131 | |initInfoRequiredStop |“INIT INFO” 的 Required-Stop 部分。 |$remote_fs $syslog $network |$remote_fs $syslog $network| 132 | |initInfoDefaultStart |“INIT INFO” 的 Default-Start 部分。 |2 3 4 5 |2 3 4 5| 133 | |initInfoDefaultStop |“INIT INFO” 的 Default-Stop 部分。 |0 1 6 |0 1 6| 134 | |initInfoShortDescription |“INIT INFO” 的 Short-Description 部分。 |${project.description} 单行版本（返回到 ${task.baseName}） |${project.name}| 135 | |initInfoDescription |“INIT INFO” 的 Description 部分。 |${project.description}（返回到 ${task.baseName}） |${project.description}（返回到 ${project.name}）| 136 | |initInfoChkconfig |“INIT INFO” 的 chkconfig 部分 |2345 99 01 |2345 99 01| 137 | |confFolder |CONF_FOLDER 的默认值 |包含 jar 的文件夹 |包含 jar 的文件夹| 138 | |inlinedConfScript |对应该内联在默认启动脚本中的文件脚本的引用。这可以用于在加载任何外部配置文件之前设置环境变量，例如 JAVA_OPTS。||| 139 | |logFolder |LOG_FOLDER 的默认值。仅对 init.d |服务有效 | | 140 | |logFilename |LOG_FILENAME 的默认值。仅对 init.d |服务有效 | | 141 | |pidFolder |PID_FOLDER 的默认值。仅对 init.d |服务有效 | | 142 | |pidFilename |PID_FOLDER 中 PID 文件名称的默认值。仅对 init.d |服务有效 | | 143 | |useStartStopDaemon |是否应该使用 start-stop-daemon 命令（当它可用时）来控制进程 |true |true| 144 | |stopWaitTime |STOP_WAIT_TIME 的默认值（秒）。仅对 init.d 服务有效 |60 |60| 145 | 146 | **在运行时自定义脚本** 147 | 148 | 对于编写 jar 后需要自定义的脚本项，可以使用环境变量或配置文件。 149 | 150 | 默认脚本支持以下环境属性： 151 | 152 | |变量 |描述| 153 | |---|---| 154 | |MODE |操作的“模式”。默认值取决于 jar 的构建方式，但通常是 auto 的（这意味着它试图通过检查它是否是名为 init.d 的目录中的符号连接来猜测它是否是 init 脚本）。你可以显式地将其设置为 service，以便 stop | start | status | restart 命令可以工作，或者希望在前台运行脚本时，则使用 run。| 155 | |USE_START_STOP_DAEMON |是否应使用 start-stop-daemon 命令来控制进程（如果可用）。默认为 true。| 156 | |PID_FOLDER |pid 文件夹的根名称（默认情况下为 /var/run）。| 157 | |LOG_FOLDER |放置日志文件的文件夹的名称（默认情况下为 /var/log）。| 158 | |CONF_FOLDER |从中读取 .conf 文件的文件夹的名称（默认情况下与 jar-file 同一个文件夹）。| 159 | |LOG_FILENAME |LOG_FOLDER 中日志文件的名称（默认为 .log）。| 160 | |APP_NAME |应用程序的名称。如果 jar 是从符号连接运行的，脚本将猜测应用程序名称。如果它不是符号连接，或者你想显式设置应用程序名称，这可能很有用。| 161 | |RUN_ARGS |要传递给程序（Spring Boot 应用程序）的参数。| 162 | |JAVA_HOME |java 可执行文件的位置在默认情况下是通过使用 PATH 来发现的，但是如果在 $JAVA_HOME/bin/java 处有一个可执行文件，你可以显式地设置它。| 163 | |JAVA_OPTS |启动 JVM 时传递给其的选项。| 164 | |JARFILE |jar 文件的显式位置，以防脚本用于启动一个实际上没有嵌入的 jar。| 165 | |DEBUG |如果不为空，则在 shell 进程上设置 -x 标志，以便于查看脚本中的逻辑。| 166 | |STOP_WAIT_TIME |在强制关闭之前停止应用程序时等待的时间（以秒为单位，默认为 60）。| 167 | 168 | 注释：PID_FOLDER、LOG_FOLDER 和 LOG_FILENAME 变量仅对 init.d 服务有效。对于 systemd，使用 “服务” 脚本进行等效的自定义。有关详细信息，请参阅[服务单元配置手册页](https://www.freedesktop.org/software/systemd/man/systemd.service.html)。 169 | 170 | 除了 JARFILE 和 APP_NAME 之外，可以使用 .conf 文件配置上一节中列出的设置。该文件应该在 jar 文件旁边，并且具有相同的名称，但后缀是 .conf 而不是 .jar。例如，名为 /var/myapp/myapp.jar 的 jar 使用名为 /var/myapp/myapp.conf 的配置文件，如下例所示： 171 | ``` 172 | myapp.conf 173 | 174 | JAVA_OPTS=-Xmx1024M 175 | LOG_FOLDER=/custom/log/folder 176 | ``` 177 | 提示：如果你不喜欢将配置文件放在 jar 文件旁边，可以设置 CONF_FOLDER 环境变量来自定义配置文件的位置。 178 | 179 | 要了解如何适当地保护此文件，请参阅[保护 init.d 服务的指南](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/deployment-install.html#deployment-initd-service-securing)。 180 | 181 | ## 64.3、Microsoft Windows 服务 182 | 183 | 使用 [winsw](https://github.com/kohsuke/winsw) 可以将 Spring Boot 应用程序作为 Windows 服务启动。 184 | 185 | [单独维护的示例](https://github.com/snicoll-scratches/spring-boot-daemon)，逐步地描述了如何为 Spring Boot 应用程序创建 Windows 服务。 186 | -------------------------------------------------------------------------------- /spring-boot/reference/06部署SpringBoot应用程序/65、延伸阅读.md: -------------------------------------------------------------------------------- 1 | # 65、延伸阅读 2 | 3 | 查看 [Cloud Foundry](https://www.cloudfoundry.org/)、 [Heroku](https://www.heroku.com/)、 [OpenShift](https://www.openshift.com/) 和 [Boxfuse](https://boxfuse.com/) 网站，了解有关 PaaS 可以提供的各种功能的更多信息。这些只是四个最受欢迎的 Java PaaS 提供商。由于 Spring Boot 非常适合基于云的部署，因此你也可以自由考虑其他提供商。 4 | 5 | 下一节将介绍 [Spring Boot CLI](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/cli.html)，或者你可以直接阅读有关[构建工具插件的内容](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/build-tool-plugins.html)。 6 | -------------------------------------------------------------------------------- /spring-boot/reference/07SpringBootCLI/66、安装CLI.md: -------------------------------------------------------------------------------- 1 | # 第七部分：Spring Boot CLI 2 | 3 | Spring Boot CLI 是一个命令行工具，如果你想快速开发 Spring 应用程序，可以使用它。它可以让你运行 Groovy 脚本，这意味着你有一个熟悉的类似 Java 的语法，无需太多的样板代码。你还可以引导一个新项目或为其编写自己的命令。 4 | 5 | # 66、安装 CLI 6 | 7 | Spring Boot CLI（命令行界面）可以使用 SDKMAN!（SDK 管理器）手动安装，如果你是 OSX 用户，则可以使用 Homebrew 或 MacPorts 手动安装。有关全面的安装说明，请参阅 “入门” 部分中的[第 10.2 节：安装 Spring Boot CLI](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/getting-started-installing-spring-boot.html#getting-started-installing-the-cli)。 8 | -------------------------------------------------------------------------------- /spring-boot/reference/07SpringBootCLI/67、使用CLI.md: -------------------------------------------------------------------------------- 1 | # 67、使用 CLI 2 | 3 | 安装 CLI 后，你可以通过键入 spring 并在命令行按 Enter 键来运行它。如果运行 spring 时没有任何参数，将显示一个简单的帮助屏幕，如下所示： 4 | 5 | $ spring 6 | usage: spring [--help] [--version] 7 | [] 8 | 9 | Available commands are: 10 | 11 | run [options] [--] [args] 12 | Run a spring groovy script 13 | 14 | ... more command help is shown here 15 | 16 | 你可以键入 spring help 以获取有关任何受支持命令的更多详细信息，如下面示例所示： 17 | 18 | $ spring help run 19 | spring run - Run a spring groovy script 20 | 21 | usage: spring run [options] [--] [args] 22 | 23 | Option Description 24 | ------ ----------- 25 | --autoconfigure [Boolean] Add autoconfigure compiler 26 | transformations (default: true) 27 | --classpath, -cp Additional classpath entries 28 | -e, --edit Open the file with the default system 29 | editor 30 | --no-guess-dependencies Do not attempt to guess dependencies 31 | --no-guess-imports Do not attempt to guess imports 32 | -q, --quiet Quiet logging 33 | -v, --verbose Verbose logging of dependency 34 | resolution 35 | --watch Watch the specified file for changes 36 | 37 | version 命令提供了一种快速方法来检查你使用的是哪个版本的 Spring Boot，如下所示： 38 | 39 | $ spring version 40 | Spring CLI v2.1.6.RELEASE 41 | 42 | ## 67.1、使用 CLI 运行应用程序 43 | 44 | 你可以使用 run 命令编译和运行 Groovy 源代码。Spring Boot CLI 是完全独立的，因此你不需要任何外部 Groovy 安装。 45 | 46 | 以下示例显示了一个用 Groovy 编写的“hello world” web 应用程序： 47 | 48 | **hello.groovy** 49 | ``` 50 | @RestController 51 | class WebApplication { 52 | 53 | @RequestMapping("/") 54 | String home() { 55 | "Hello World!" 56 | } 57 | 58 | } 59 | ``` 60 | 要编译并运行应用程序，请键入以下命令： 61 | 62 | $ spring run hello.groovy 63 | 64 | 要将命令行参数传递给应用程序，请使用 -- 将命令与“spring”命令参数分开，如下面示例所示： 65 | 66 | $ spring run hello.groovy -- --server.port=9000 67 | 68 | 要设置 JVM 命令行参数，可以使用 JAVA_OPTS 环境变量，如下面示例所示： 69 | 70 | $ JAVA_OPTS=-Xmx1024m spring run hello.groovy 71 | 72 | 注释：在 Microsoft Windows 上设置 JAVA_OPTS 时，请确保引用整个指令，例如设置 “JAVA_OPTS =-Xms256m-Xmx2048m”。这样做可以确保值被正确地传递给进程。 73 | 74 | ### 67.1.1、推断的“抓取”依赖关系 75 | 76 | 标准 Groovy 包括一个 @Grab 注解，它允许你声明对第三方库的依赖。这种有用的技术允许 Groovy 以与 Maven 或 Gradle 相同的方式下载 jar，但不需要你使用构建工具。 77 | 78 | Spring Boot 进一步扩展了这种技术，并试图根据你的代码推断出要 “抓取” 哪些库。例如，由于前面显示的 WebApplication 代码使用 @RestController 注解，Spring Boot 抓取 “Tomcat” 和 “Spring MVC”。 79 | 80 | 以下项用作“抓取提示”： 81 | 82 | |项目 |抓取| 83 | |---|---| 84 | |JdbcTemplate, NamedParameterJdbcTemplate, DataSource |JDBC 应用程序。| 85 | |@EnableJms |JMS 应用程序。| 86 | |@EnableCaching |缓存抽象。| 87 | |@Test |JUnit| 88 | |@EnableRabbit |RabbitMQ| 89 | |extends Specification |Spock 测试。| 90 | |@EnableBatchProcessing |Spring Batch| 91 | |@MessageEndpoint @EnableIntegration |Spring Integration| 92 | |@Controller @RestController @EnableWebMvc |Spring MVC + Embedded Tomcat| 93 | |@EnableWebSecurity |Spring Security| 94 | |@EnableTransactionManagement |Spring Transaction Management| 95 | 96 | 提示：请参阅 Spring Boot CLI 源代码中 [CompilerAutoConfiguration](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-cli/src/main/java/org/springframework/boot/cli/compiler/CompilerAutoConfiguration.java) 的子类，以确切了解如何应用自定义。 97 | 98 | ### 67.1.2、推导的“抓取”坐标 99 | 100 | Spring Boot 扩展了 Groovy 的标准 @Grab 支持，允许你指定一个不带组或版本的依赖项（例如，@Grab('freemarker')）。这样做会参考 Spring Boot 的默认依赖元数据来推断工件的组和版本。 101 | 102 | 注释：默认元数据与你使用的 CLI 版本相关联。只有当你移动到新版本的 CLI 时，它才会更改，这使你可以控制依赖项的版本何时可能更改。在[附录](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/appendix-dependency-versions.html)中可以找到显示默认元数据中包含的依赖项及其版本的表。 103 | 104 | ### 67.1.3、默认导入语句 105 | 106 | 为了帮助减少 Groovy 代码的大小，会自动包含几个 import 语句。请注意上面的示例如何引用 @Component、 @RestController 和 @RequestMapping，而不需要使用完全限定的名称或 import 语句。 107 | 108 | 提示：许多 Spring 注解无需使用 import 语句即可工作。尝试运行你的应用程序，以查看在添加导入之前失败的内容。 109 | 110 | ### 67.1.4、自动主方法 111 | 112 | 与等效的 Java 应用程序不同，Groovy 脚本不需要包含 public static void main(String[] args) 方法。系统会自动创建一个 SpringApplication，并将编译后的代码作为源代码。 113 | 114 | ### 67.1.5、自定义依赖项管理 115 | 116 | 默认情况下，CLI 在解析 @Grab 依赖项时使用 spring-boot-dependencies 中声明的依赖项管理。其他依赖项管理（覆盖默认依赖项管理）可以通过使用 @DependencyManagementBom 注解进行配置。注解的值应指定一个或多个 Maven BOMs 的坐标（groupId:artifactId:version）。 117 | 118 | 例如，考虑以下声明： 119 | 120 | @DependencyManagementBom("com.example.custom-bom:1.0.0") 121 | 122 | 前面的声明在 com/example/custom-versions/1.0.0/ 下的 Maven 存储库中获取 custom-bom-1.0.0.pom。 123 | 124 | 当你指定多个 BOMs 时，它们将按照你声明它们的顺序应用，如下面示例所示： 125 | 126 | @DependencyManagementBom(["com.example.custom-bom:1.0.0", 127 | "com.example.another-bom:1.0.0"]) 128 | 129 | 上述示例表明，another-bom 中的依赖项管理覆盖了 custom-bom 中的依赖项管理。 130 | 131 | 你可以在任何可以使用 @Grab 的地方使用 @DependencyManagementBom。但是，为了确保依赖项管理的顺序一致，你最多可以在应用程序中使用 @DependencyManagementBom 一次。依赖项管理的一个有用的来源（它是 Spring Boot 依赖项管理的超集）是 Spring IO 平台，你可以将其包含在以下行中： 132 | 133 | @DependencyManagementBom('io.spring.platform:platform-bom:1.1.2.RELEASE') 134 | 135 | ## 67.2、具有多个源文件的应用程序 136 | 137 | 你可以将 “shell globbing” 与接受文件输入的所有命令一起使用。这样做可以使用单个目录中的多个文件，如下面示例所示： 138 | 139 | $ spring run *.groovy 140 | 141 | ## 67.3、打包应用程序 142 | 143 | 你可以使用 jar 命令将应用程序打包到一个独立的可执行 jar 文件中，如下面示例所示： 144 | 145 | $ spring jar my-app.jar *.groovy 146 | 147 | 生成的 jar 包含编译应用程序生成的类和应用程序的所有依赖项，以便可以使用 java -jar 运行它。jar 文件还包含来自应用程序类路径的条目。你可以通过使用 --include 和 --exclude 来添加和删除 jar 的显式路径。两者都是逗号分隔的，并且都接受“+”和“-”形式的前缀，以表示它们应该从默认值中删除。默认包括如下： 148 | 149 | public/**, resources/**, static/**, templates/**, META-INF/**, * 150 | 151 | 默认排除如下： 152 | 153 | .*, repository/**, build/**, target/**, **/*.jar, **/*.groovy 154 | 155 | 在命令行上键入 spring help jar 以获取更多信息。 156 | 157 | ## 67.4、初始化新项目 158 | 159 | init 命令允许你使用 start.spring.io 创建新项目，而无需离开 shell，如下面示例所示： 160 | 161 | $ spring init --dependencies=web,data-jpa my-project 162 | Using service at https://start.spring.io 163 | Project extracted to '/Users/developer/example/my-project' 164 | 165 | 前面的示例使用基于 Maven 的项目创建了一个 my-project 目录，该项目使用 spring-boot-starter-web 和 spring-boot-starter-data-jpa。你可以使用 --list 标志列出服务的功能，如下面示例所示： 166 | 167 | $ spring init --list 168 | ======================================= 169 | Capabilities of https://start.spring.io 170 | ======================================= 171 | 172 | Available dependencies: 173 | ----------------------- 174 | actuator - Actuator: Production ready features to help you monitor and manage your application 175 | ... 176 | web - Web: Support for full-stack web development, including Tomcat and spring-webmvc 177 | websocket - Websocket: Support for WebSocket development 178 | ws - WS: Support for Spring Web Services 179 | 180 | Available project types: 181 | ------------------------ 182 | gradle-build - Gradle Config [format:build, build:gradle] 183 | gradle-project - Gradle Project [format:project, build:gradle] 184 | maven-build - Maven POM [format:build, build:maven] 185 | maven-project - Maven Project [format:project, build:maven] (default) 186 | 187 | ... 188 | 189 | init 命令支持许多选项。有关更多详细信息，请参见 help 输出。例如，以下命令创建一个使用 Java 8 和 war 打包的 Gradle 项目： 190 | 191 | $ spring init --build=gradle --java-version=1.8 --dependencies=websocket --packaging=war sample-app.zip 192 | Using service at https://start.spring.io 193 | Content saved to 'sample-app.zip' 194 | 195 | ## 67.5、使用嵌入式 Shell 196 | 197 | Spring Boot 包括 BASH 和 zsh shell 的命令行完成脚本。如果你不使用这些 shell 中的任何一个 (也许你是 Windows 用户)，则可以使用 shell 命令启动集成 shell，如下面示例所示： 198 | 199 | $ spring shell 200 | Spring Boot (v2.1.6.RELEASE) 201 | Hit TAB to complete. Type \'help' and hit RETURN for help, and \'exit' to quit. 202 | 203 | 从嵌入式 shell 内部，你可以直接运行其他命令： 204 | 205 | $ version 206 | Spring CLI v2.1.6.RELEASE 207 | 208 | 嵌入式 shell 支持 ANSI 颜色输出以及 tab 完成。如果需要运行本机命令，可以使用 ! 前缀。要退出嵌入式 shell，请按 ctrl-c。 209 | 210 | ## 67.6、向 CLI 添加扩展 211 | 212 | 你可以使用 install 命令向 CLI 添加扩展。该命令采用格式为 group:artifact:version 的一组或多组工件坐标，如下面示例所示： 213 | 214 | $ spring install com.example:spring-boot-cli-extension:1.0.0.RELEASE 215 | 216 | 除了安装由你提供的坐标标识的工件之外，还安装了所有工件的依赖项。 217 | 218 | 要卸载依赖项，请使用 uninstall 命令。与 install 命令一样，它采用 group:artifact:version 格式的一组或多组工件坐标，如下面示例所示： 219 | 220 | $ spring uninstall com.example:spring-boot-cli-extension:1.0.0.RELEASE 221 | 222 | 它卸载由你提供的坐标及其依赖项标识的工件。 223 | 224 | 要卸载所有其他依赖项，可以使用 --all 选项，如下面示例所示： 225 | 226 | $ spring uninstall --all -------------------------------------------------------------------------------- /spring-boot/reference/07SpringBootCLI/68、使用GroovyBeansDSL开发应用程序.md: -------------------------------------------------------------------------------- 1 | # 68、使用 Groovy Beans DSL 开发应用程序 2 | 3 | Spring Framework 4.0 对 beans{} “DSL”（从 Grails 借用）具有本机支持，并且你可以使用相同的格式在 Groovy 应用程序脚本中嵌入 bean 定义。这有时是包含中间件声明等外部功能的好方法，如下面示例所示： 4 | ``` 5 | @Configuration 6 | class Application implements CommandLineRunner { 7 | 8 | @Autowired 9 | SharedService service 10 | 11 | @Override 12 | void run(String... args) { 13 | println service.message 14 | } 15 | 16 | } 17 | 18 | import my.company.SharedService 19 | 20 | beans { 21 | service(SharedService) { 22 | message = "Hello World" 23 | } 24 | } 25 | ``` 26 | 你可以将类声明与 beans{} 混合在同一个文件中，只要它们保持在顶层，或者，如果你愿意，可以将 beans DSL 放在一个单独的文件中。 27 | -------------------------------------------------------------------------------- /spring-boot/reference/07SpringBootCLI/69、使用settings.xml配置CLI.md: -------------------------------------------------------------------------------- 1 | # 69、使用 settings.xml 配置 CLI 2 | 3 | Spring Boot CLI 使用 Aether（Maven 的依赖项解析引擎）来解析依赖项。CLI 使用在 ~/.m2/settings.xml 中找到的 Maven 配置来配置 Aether。CLI 遵守以下配置设置： 4 | 5 | Offline 6 | Mirrors 7 | Servers 8 | Proxies 9 | Profiles 10 | Activation 11 | Repositories 12 | Active profiles 13 | 14 | 有关更多信息，请参见 [Maven 的设置文档](https://maven.apache.org/settings.html)。 15 | -------------------------------------------------------------------------------- /spring-boot/reference/07SpringBootCLI/70、延伸阅读.md: -------------------------------------------------------------------------------- 1 | # 70、延伸阅读 2 | 3 | GitHub 存储库中有一些[示例 groovy 脚本](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-cli/samples)，你可以使用它们来试用 Spring Boot CLI。在整个[源代码](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-cli/src/main/java/org/springframework/boot/cli)中也有大量的 Javadoc。 4 | 5 | 如果你发现你达到了 CLI 工具的极限，你可能想看看如何将你的应用程序转换成一个完整的 Gradle 或 Maven 构建的 “Groovy 项目”。下一节将介绍 Spring Boot 的 “[构建工具插件](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/build-tool-plugins.html)”，你可以将其与 Gradle 或 Maven 一起使用。 6 | -------------------------------------------------------------------------------- /spring-boot/reference/08构建工具插件/71、SpringBootMaven插件.md: -------------------------------------------------------------------------------- 1 | # 第八部分：构建工具插件 2 | 3 | Spring Boot 为 Maven 和 Gradle 提供构建工具插件。插件提供了多种功能，包括可执行 jar 的打包。本节提供了有关这两个插件的更多详细信息，以及你需要扩展不受支持的构建系统时的一些帮助。如果你刚刚开始，你可能想先从 “第三部分：使用 Spring Boot ”中阅读第 13 章：构建系统。 4 | 5 | # 71、Spring Boot Maven 插件 6 | 7 | [Spring Boot Maven 插件](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/maven-plugin)在 Maven 中提供 Spring Boot 支持，让你打包可执行 jar 或 war 归档文件并 “就地” 运行应用程序。要使用它，你必须使用 Maven 3.2（或更高版本）。 8 | 9 | 注释：有关完整的插件文档，请参见[Spring Boot Maven 插件网站](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/maven-plugin) 。 10 | 11 | ## 71.1、包括插件 12 | 13 | 要使用 Spring Boot Maven Plugin，请在 pom.xml 的 plugins 部分包含适当的 XML，如下面示例所示： 14 | ``` 15 | 16 | 18 | 4.0.0 19 | 20 | 21 | 22 | 23 | org.springframework.boot 24 | spring-boot-maven-plugin 25 | 2.1.6.RELEASE 26 | 27 | 28 | 29 | repackage 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | ``` 38 | 前面的配置重新打包了在 Maven 生命周期的 package 阶段构建的 jar 或 war。以下示例展示了重新打包的 jar 以及 target 目录中的原始 jar： 39 | 40 | $ mvn package 41 | $ ls target/*.jar 42 | target/myproject-1.0.0.jar target/myproject-1.0.0.jar.original 43 | 44 | 如果不包括 <execution/> 配置，如前一个示例所示，则可以单独运行插件（但仅当同时使用包目标时），如下面示例所示： 45 | 46 | $ mvn package spring-boot:repackage 47 | $ ls target/*.jar 48 | target/myproject-1.0.0.jar target/myproject-1.0.0.jar.original 49 | 50 | 如果使用里程碑或快照版本，还需要添加适当的 pluginRepository 元素，如以下列表所示： 51 | ``` 52 | 53 | 54 | spring-snapshots 55 | https://repo.spring.io/snapshot 56 | 57 | 58 | spring-milestones 59 | https://repo.spring.io/milestone 60 | 61 | 62 | ``` 63 | ## 71.2、打包可执行 Jar 和 War 文件 64 | 65 | 一旦 spring-boot-maven-plugin 包含在你的 pom.xml 中，它会自动尝试重写归档文件，通过使用 spring-boot:repackage 目标使它们可执行。你应该通过使用通常的打包元素配置项目以构建 jar 或 war（视情况而定），如下例所示： 66 | ``` 67 | 68 | 70 | 71 | jar 72 | 73 | 74 | ``` 75 | 在 package 阶段，Spring Boot 增强了你现有的归档文件。你要启动的主类可以通过使用配置选项或以通常的方式向清单添加 Main-Class 来指定。如果你没有指定主类，该插件将搜索具有 public static void main(String[] args) 方法的类。 76 | 77 | 要生成和运行项目工件，可以键入以下内容： 78 | 79 | $ mvn package 80 | $ java -jar target/mymodule-0.0.1-SNAPSHOT.jar 81 | 82 | 要构建一个可执行且可部署到外部容器中的 war 文件，你需要将嵌入式容器依赖项标记为“provided”，如下面示例所示： 83 | ``` 84 | 85 | 87 | 88 | war 89 | 90 | 91 | 92 | org.springframework.boot 93 | spring-boot-starter-web 94 | 95 | 96 | org.springframework.boot 97 | spring-boot-starter-tomcat 98 | provided 99 | 100 | 101 | 102 | 103 | ``` 104 | 提示：有关如何创建可部署的 war 文件的更多详细信息，请参见[第 92.1 节：创建可部署的 War 文件 ](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/howto-traditional-deployment.html#howto-create-a-deployable-war-file)。 105 | 106 | [插件信息页面](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/maven-plugin)提供了高级配置选项和示例。 -------------------------------------------------------------------------------- /spring-boot/reference/08构建工具插件/72、SpringBootGradle插件.md: -------------------------------------------------------------------------------- 1 | # 72、Spring Boot Gradle 插件 2 | 3 | Spring Boot Gradle Plugin 在 Gradle 中提供了 Spring Boot 支持，允许你打包可执行 jar 或 war 归档文件，运行 Spring Boot 应用程序，并使用 spring-boot-dependencies 提供的依赖项管理。它需要 Gradle 4.4 或更高版本。请参考插件的文档以了解更多信息： 4 | 5 | （1）参考（[HTML](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/gradle-plugin/reference/html)和[PDF](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/gradle-plugin/reference/pdf/spring-boot-gradle-plugin-reference.pdf)） 6 | 7 | （2）[API](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/gradle-plugin/api) 8 | -------------------------------------------------------------------------------- /spring-boot/reference/08构建工具插件/73、SpringBootAntLib模块.md: -------------------------------------------------------------------------------- 1 | # 73、Spring Boot AntLib 模块 2 | 3 | Spring Boot AntLib 模块为 Apache Ant 提供基本的 Spring Boot 支持。你可以使用该模块创建可执行 jar。要使用该模块，你需要在 build.xml 中声明一个额外的 spring-boot 命名空间，如下面示例所示： 4 | ``` 5 | 8 | ... 9 | 10 | ``` 11 | 你需要记住使用 -lib 选项启动 Ant，如以下示例所示： 12 | 13 | $ ant -lib 14 | 15 | 提示：“使用 Spring Boot” 部分包括一个更完整的[使用 Apache Ant 和 spring-boot-antlib 的示例](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/using-boot-build-systems.html#using-boot-ant)。 16 | 17 | ## 73.1、Spring Boot Ant 任务 18 | 19 | 一旦声明了 spring-boot-antlib 名称空间，就可以执行以下附加任务： 20 | 21 | （1）[第 73.1.1 节：spring-boot:exejar](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/build-tool-plugins-antlib.html#spring-boot-ant-exejar) 22 | 23 | （2）[第 73.2 节：spring-boot:findmainclass](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/build-tool-plugins-antlib.html#spring-boot-ant-findmainclass) 24 | 25 | ### 73.1.1、spring-boot:exejar 26 | 27 | 你可以使用 exejar 任务创建一个 Spring Boot 可执行 jar。任务支持以下属性： 28 | 29 | |属性 |描述 |必须| 30 | |---|---|---| 31 | |destfile |要创建的目标 jar 文件 |Yes| 32 | |classes |Java 类文件的根目录 |Yes| 33 | |start-class |要运行的主应用程序类 |No（默认值是找到的第一个声明主方法的类）| 34 | 35 | 以下嵌套元素可与任务一起使用： 36 | 37 | |元素 |描述| 38 | |---|---| 39 | |resources |描述一组资源的一个或多个资源集合，这些资源应添加到创建的 jar 文件的内容中。| 40 | |lib |一个或多个资源集合，应添加到构成应用程序的运行时依赖类路径的 jar 库集中。| 41 | 42 | ### 73.1.2、例子 43 | 44 | 本节展示了 Ant 任务的两个示例。 45 | 46 | **指定 start-class** 47 | ``` 48 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | ``` 58 | **检测 start-class** 59 | ``` 60 | 61 | 62 | 63 | 64 | 65 | ``` 66 | ## 73.2、spring-boot:findmainclass 67 | 68 | exejar 在内部使用 findmainclass 任务来定位声明 main 的类。如有必要，你也可以在构建中直接使用此任务。支持以下属性： 69 | 70 | |属性 |描述 |必要| 71 | |---|---|---| 72 | |classesroot |Java 类文件的根目录 |Yes（除非指定了 mainclass）| 73 | |mainclass |可用于短路（short-circuit）主类搜索 |No| 74 | |property |应使用结果设置的 Ant 属性 |No（如果未指定，将记录结果）| 75 | 76 | ### 73.2.1、例子 77 | 78 | 本节包含使用 findmainclass 的三个示例。 79 | 80 | **查找和记录** 81 | 82 | 83 | 84 | **查找和设置** 85 | 86 | 87 | 88 | **覆盖与设置** 89 | 90 | 91 | -------------------------------------------------------------------------------- /spring-boot/reference/08构建工具插件/74、支持的其他构建系统.md: -------------------------------------------------------------------------------- 1 | # 74、支持的其他构建系统 2 | 3 | 如果你想使用 Maven 、 Gradle 或 Ant 以外的构建工具，你可能需要开发你自己的插件。可执行 jar 需要遵循特定的格式，并且某些条目需要以未压缩的形式写入（有关详细信息，请参见附录中的 “[可执行 jar 格式](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/executable-jar.html)” 部分）。 4 | 5 | Spring Boot Maven 和 Gradle 插件都使用 spring-boot-loader-tools 来实际生成 jar。如果需要，你可以直接使用此库。 6 | 7 | ## 74.1、重新打包归档文件 8 | 9 | 要重新打包现有存档，使其成为独立的可执行的归档文件，请使用 org.springframework.boot.loader.tools.Repackager。Repackager 类接受一个引用现有 jar 或 war 归档文件的构造函数参数。使用两个可用的 repackage() 方法之一替换原始文件或写入新目标。在重新打包程序运行之前，还可以在其上配置各种设置。 10 | 11 | ## 74.2、嵌套库 12 | 13 | 重新打包存档文件时，可以使用 org.springframework.boot.loader.tools.Libraries 接口包含对依赖项文件的引用。我们不提供任何具体的库实现，因为它们通常是特定于构建系统的。 14 | 15 | 如果归档文件已包含库，则可以使用 libraries.NONE。 16 | 17 | ## 74.3、查找主类 18 | 19 | 如果不使用 Repackager.setMainClass() 指定主类，则重新打包器（repackager）使用 ASM 读取类文件，并尝试找到具有 public static void main(String[] args) 方法的合适类。如果发现多个候选，则引发异常。 20 | 21 | ## 74.4、重新打包实现的示例 22 | 23 | 以下示例展示了一个典型的重新打包实现： 24 | ``` 25 | Repackager repackager = new Repackager(sourceJarFile); 26 | repackager.setBackupSource(false); 27 | repackager.repackage(new Libraries() { 28 | @Override 29 | public void doWithLibraries(LibraryCallback callback) throws IOException { 30 | // Build system specific implementation, callback for each dependency 31 | // callback.library(new Library(nestedFile, LibraryScope.COMPILE)); 32 | } 33 | }); 34 | ``` -------------------------------------------------------------------------------- /spring-boot/reference/08构建工具插件/75、延伸阅读.md: -------------------------------------------------------------------------------- 1 | # 75、延伸阅读 2 | 3 | 如果你对构建工具插件的工作方式感兴趣，可以查看 GitHub 上的 [spring-boot-tools](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-tools) 模块。[附录](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/executable-jar.html)中介绍了可执行 jar 格式的更多技术细节。 4 | 5 | 如果你有与构建相关的特定问题，可以查看[操作指南](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/howto.html)。 -------------------------------------------------------------------------------- /spring-boot/reference/09操作指南/76、SpringBoot应用程序.md: -------------------------------------------------------------------------------- 1 | # 第九部分：操作指南 2 | 3 | 本节提供了一些常见的 “我该怎么做……” 问题的答案，这些问题在使用 Spring Boot 时经常出现。它的覆盖面并不详尽，但它确实覆盖了很多。 4 | 5 | 如果你有一个我们这里没有涉及的具体问题，你可能想看看 stackoverflow.com，看看是否有人已经提供了答案。这也是一个提出新问题的好地方（请使用 spring-boot 标签）。 6 | 7 | 我们也非常乐意扩展这个部分。如果你想添加操作指南，请向我们发送[拉取请求](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE)。 8 | 9 | # 76、Spring Boot 应用程序 10 | 11 | 本节包含与 Spring Boot 应用程序直接相关的主题。 12 | 13 | ## 76.1、创建自己的 FailureAnalyzer 14 | 15 | FailureAnalyzer 是一种很好的方法，可以在启动时拦截异常并将其转换为可读的消息，并包装在 FailureAnalysis 中。Spring Boot 为应用程序上下文相关的异常、 JSR-303 验证等提供了这样的分析器。你也可以创建自己的。 16 | 17 | AbstractFailureAnalyzer 是 FailureAnalyzer 的一个方便的扩展，它检查要处理的异常中是否存在指定的异常类型。你可以在此基础上进行扩展，以便你的实现只有在异常实际存在时才有机会处理它。无论出于何种原因，如果你无法处理异常，请返回 null 以使另一个实现有机会处理异常。 18 | 19 | FailureAnalyzer 实现必须在 META-INF/spring.factories 中注册。以下示例注册 ProjectConstraintViolationFailureAnalyzer： 20 | 21 | org.springframework.boot.diagnostics.FailureAnalyzer=\ 22 | com.example.ProjectConstraintViolationFailureAnalyzer 23 | 24 | 注释：如果你需要访问 BeanFactory 或 Environment，那么 FailureAnalyzer 可以简单地分别实现 BeanFactoryAware 或 EnvironmentAware。 25 | 26 | ## 76.2、自动配置故障排除 27 | 28 | Spring Boot 自动配置会尽最大努力 “做正确的事情”，但有时会失败，而且很难说出原因。 29 | 30 | 在任何 Spring Boot ApplicationContext 中都有一个非常有用的 ConditionEvaluationReport。如果启用 DEBUG 日志输出，你可以看到它。如果你使用 spring-boot-actuator（请参阅 [Actuator 章节](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/howto-spring-boot-application.html)），还有一个 conditions 端点以 JSON 呈现报告。使用该端点调试应用程序，并查看 Spring Boot 在运行时添加了哪些功能（以及哪些功能尚未添加）。 31 | 32 | 通过查看源代码和 Javadoc，可以回答更多的问题。阅读代码时，请记住以下经验法则： 33 | 34 | （1）查找名为 \*AutoConfiguration 的类并阅读它们的源代码。特别注意 @Conditional\* 注解，以找出它们启用的功能以及何时启用。将 --debug 添加到命令行或系统属性 -Ddebug，以在控制台上获取应用程序中做出的所有自动配置决策的日志。在正在运行的 Actuator 应用程序中，查看 conditions 端点（/actuator/conditions 或 JMX 等效项）以获取相同的信息。 35 | 36 | （2）查找 @ConfigurationProperties 类（如 ServerProperties）并从中读取可用的外部配置选项。@ConfigurationProperties 注解有一个 name 属性，用作外部属性的前缀。因此，ServerProperties 具有 prefix=“server”，其配置属性为 server.port、server.address 和其他。在正在运行的 Actuator 应用程序中，查看 configprops 端点。 37 | 38 | （3）查找 Binder 上的 bind 方法的用途，以轻松的方式将配置值显式地拉出 Environment。它经常与前缀一起使用。 39 | 40 | （4）查找直接绑定到 Environment 的 @Value 注解。 41 | 42 | （5）查找 @ConditionalOnExpression 注解，它根据 SpEL 表达式打开和关闭功能，通常使用从 Environment 中解析的占位符进行评估。 43 | 44 | ## 76.3、在 Environment 或 ApplicationContext 启动之前自定义它 45 | 46 | SpringApplication 有 ApplicationListeners 和 ApplicationContextInitializers，用于将自定义应用于上下文或环境。Spring Boot 从 META-INF/spring.factories 加载了许多这样的自定义项供内部使用。有多种方法可以注册其他自定义设置： 47 | 48 | （1）在运行 SpringApplication 之前，通过在 SpringApplication 上调用 addListeners 和 addInitializers 方法，以编程方式，针对每个应用程序。 49 | 50 | （2）通过设置 context.initializer.classes 或 context.listener.classes 属性，以声明方式，针对每个应用程序。 51 | 52 | （3）声明性地，对于所有应用程序，通过添加一个 META-INF/spring.factories 并打包一个应用程序都将其用作库的 jar 文件。 53 | 54 | SpringApplication 将一些特殊的 ApplicationEvents 发送给监听器（有些甚至在创建上下文之前），然后为 ApplicationContext 发布的事件注册监听器。有关完整列表，请参阅“Spring Boot功能”部分中的第 23.5 节：应用程序事件和监听器。 55 | 56 | 也可以在使用 EnvironmentPostProcessor 刷新应用程序上下文之前自定义 Environment。每个实现都应该在 META-INF/spring.factories 中注册，如下面示例所示： 57 | 58 | org.springframework.boot.env.EnvironmentPostProcessor=com.example.YourEnvironmentPostProcessor 59 | 60 | 该实现可以加载任意文件并将其添加到 Environment 中。例如，以下示例从类路径加载 YAML 配置文件： 61 | ``` 62 | public class EnvironmentPostProcessorExample implements EnvironmentPostProcessor { 63 | 64 | private final YamlPropertySourceLoader loader = new YamlPropertySourceLoader(); 65 | 66 | @Override 67 | public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) { 68 | Resource path = new ClassPathResource("com/example/myapp/config.yml"); 69 | PropertySource propertySource = loadYaml(path); 70 | environment.getPropertySources().addLast(propertySource); 71 | } 72 | 73 | private PropertySource loadYaml(Resource path) { 74 | if (!path.exists()) { 75 | throw new IllegalArgumentException("Resource " + path + " does not exist"); 76 | } 77 | try { 78 | return this.loader.load("custom-resource", path).get(0); 79 | } 80 | catch (IOException ex) { 81 | throw new IllegalStateException("Failed to load yaml configuration from " + path, ex); 82 | } 83 | } 84 | 85 | } 86 | ``` 87 | 提示：该 Environment 已经准备好了默认情况下 Spring Boot 加载的所有常用属性源。因此，可以从环境中获取文件的位置。前面的示例将 custom-resource 属性源添加到列表的末尾，以便在任何常见的其他位置定义的键具有优先权。自定义实现可以定义另一个顺序。 88 | 89 | 注意：虽然在 @SpringBootApplication 上使用 @PropertySource 似乎是在 Environment 中加载自定义资源的一种方便简便的方法，但我们不推荐它，因为 Spring Boot 在刷新 ApplicationContext 之前准备 Environment。用 @PropertySource 定义的任何键加载太晚，无法对自动配置产生任何影响。 90 | 91 | ## 76.4、构建 ApplicationContext 层次结构（添加父上下文或根上下文） 92 | 93 | 你可以使用 ApplicationBuilder 类创建父/子 ApplicationContext 层次结构。有关更多信息，请参见 “Spring Boot 功能” 部分中的第 23.4 节： Fluent 构建器 API。 94 | 95 | ## 76.5、创建非 web 应用程序 96 | 97 | 并非所有 Spring 应用程序都必须是 web 应用程序 (或 web 服务)。如果您想在 main 方法中执行一些代码，但也要引导 Spring 应用程序来设置要使用的基础设施，则可以使用 Spring Boot 的 SpringApplication 功能。SpringApplication 会更改其 ApplicationContext 类，这取决于它是否认为需要 web 应用程序。你可以做的第一件事是将与服务器相关的依赖项（如 servlet API）从类路径中去掉。如果不能这样做（例如，从同一代码库运行两个应用程序），则可以在 SpringApplication 实例上显式调用 setWebApplicationType(WebApplicationType.NONE) 或设置 applicationContextClass 属性（通过 Java API 或使用外部属性）。要作为业务逻辑运行的应用程序代码可以作为 CommandLineRunner 来实现，并作为 @Bean 定义放入上下文中。 98 | -------------------------------------------------------------------------------- /spring-boot/reference/09操作指南/77、属性和配置.md: -------------------------------------------------------------------------------- 1 | # 77、属性和配置 2 | 3 | 本节包含有关设置和读取属性与配置设置以及它们与 Spring Boot 应用程序交互的主题。 4 | 5 | ## 77.1、在构建时自动展开属性 6 | 7 | 你可以使用现有的构建配置自动扩展它们，而不是对项目的构建配置中指定的一些属性进行硬编码。这在 Maven 和 Gradle 中都是可能的。 8 | 9 | ### 77.1.1、使用 Maven 自动扩展属性 10 | 11 | 你可以使用资源过滤从 Maven 项目中自动展开属性。如果使用 spring-boot-starter-parent，则可以使用 @..@ 占位符引用 Maven 的 “项目属性”，如下面示例所示： 12 | 13 | app.encoding=@project.build.sourceEncoding@ 14 | app.java.version=@java.version@ 15 | 16 | 注释：只有生产配置以这种方式进行过滤（换句话说，不会对 src/test/resources 应用过滤）。 17 | 18 | 提示：如果启用 addResources 标志，spring-boot:run 目标可以将 src/main/resources 直接添加到类路径（用于热重新加载）。这样做会规避资源过滤和此功能。相反，你可以使用 exec:java 目标或自定义插件的配置。有关更多详细信息，请参见[插件使用页面](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/maven-plugin/usage.html)。 19 | 20 | 如果不使用 starter 父级，则需要在 pom.xml 的 元素中包含以下元素： 21 | ``` 22 | 23 | 24 | src/main/resources 25 | true 26 | 27 | 28 | ``` 29 | 你还需要在 <plugins/> 中包含以下元素： 30 | ``` 31 | 32 | org.apache.maven.plugins 33 | maven-resources-plugin 34 | 2.7 35 | 36 | 37 | @ 38 | 39 | false 40 | 41 | 42 | ``` 43 | 注释：如果在配置中使用标准 Spring 占位符（如 ${placeholder}），则 useDefaultDelimiters 属性非常重要。如果该属性未设置为 false，则这些属性可能会被构建扩展。 44 | 45 | ### 77.1.2、使用 Gradle 自动扩展属性 46 | 47 | 你可以通过配置 Java 插件的 processResources 任务来自动扩展 Gradle 项目中的属性，如下面示例所示： 48 | ``` 49 | processResources { 50 | expand(project.properties) 51 | } 52 | ``` 53 | 然后，你可以使用占位符引用 Gradle 项目的属性，如下面示例所示： 54 | ``` 55 | app.name=${name} 56 | app.description=${description} 57 | ``` 58 | >注释 59 | > 60 | >Gradle 的 expand 方法使用 Groovy 的 SimpleTemplateEngine，它转换 ${..} tokens。${..} 样式与 Spring 自己的属性占位符机制冲突。要将 Spring 属性占位符与自动扩展一起使用，请按如下方式转义 Spring 属性占位符：\\${..}。 61 | 62 | ## 77.2、外部化 SpringApplication 的配置 63 | 64 | SpringApplication 具有 bean 属性（主要是 setters），因此你可以在创建应用程序时使用其 Java API 来修改其行为。或者，你可以通过在 spring.main.* 中设置属性来外部化配置。例如，在 application.properties 中，可能有以下设置： 65 | ``` 66 | spring.main.web-application-type=none 67 | spring.main.banner-mode=off 68 | ``` 69 | 然后，在启动时不会打印 Spring Boot 横幅，应用程序也不会启动嵌入式 web 服务器。 70 | 71 | 在外部配置中定义的属性将覆盖用 Java API 指定的值，但用于创建 ApplicationContext 的源除外。考虑以下应用： 72 | ``` 73 | new SpringApplicationBuilder() 74 | .bannerMode(Banner.Mode.OFF) 75 | .sources(demo.MyApp.class) 76 | .run(args); 77 | ``` 78 | 现在考虑以下配置： 79 | ``` 80 | spring.main.sources=com.acme.Config,com.acme.ExtraConfig 81 | spring.main.banner-mode=console 82 | ``` 83 | 实际应用程序现在显示横幅（由配置覆盖），并使用 ApplicationContext 的三个源（按以下顺序）：demo.MyApp、com.acme.Config 和 com.acme.ExtraConfig。 84 | 85 | ## 77.3、更改应用程序外部属性的位置 86 | 87 | 默认情况下，来自不同源的属性按定义的顺序添加到 Spring Environment 中（具体顺序请参见“Spring Boot 功能”部分中的[第 24 章：外部化配置](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-external-config.html)）。 88 | 89 | 增加和修改此顺序的一个好方法是将 @PropertySource 注解添加到你的应用程序源中。传递给 SpringApplication 静态便利方法的类和使用 setSources() 添加的类将被检查，以查看它们是否具有 @PropertySources。如果它们这样做了，那么这些属性就会尽早添加到环境中，以便在 ApplicationContext 生命周期的所有阶段中使用。以这种方式添加的属性的优先级低于使用默认位置（如 application.properties）、系统属性、环境变量或命令行添加的任何属性。 90 | 91 | 还可以提供以下系统属性（或环境变量）来更改行为： 92 | 93 | （1）spring.config.name（SPRING_CONFIG_NAME）：默认为 application 作为文件名的根。 94 | 95 | （2）spring.config.location（SPRING_CONFIG_LOCATION）：要加载的文件（例如类路径资源或 URL）。为此文档设置了一个单独的 Environment 属性源，它可以由系统属性、环境变量或命令行重写。 96 | 97 | 无论你在环境中设置了什么，Spring Boot 始终加载如上所述的 application.properties。默认情况下，如果使用 YAML，则扩展名为 “.yml” 的文件也会添加到列表中。 98 | 99 | Spring Boot 记录在 DEBUG 级别加载的配置文件以及在 TRACE 级别未找到的候选文件。 100 | 101 | 有关更多详细信息，请参见 [ConfigFileApplicationListener](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot/src/main/java/org/springframework/boot/context/config/ConfigFileApplicationListener.java)。 102 | 103 | ## 77.4、使用“短”命令行参数 104 | 105 | 有些人喜欢（例如）使用 --port=9000 而不是 --server.port=9000 在命令行上设置配置属性。可以通过在 application.properties 中使用占位符来启用此行为，如下面示例所示： 106 | 107 | server.port=${port:8080} 108 | 109 | 提示：如果从 spring-boot-starter-parent POM 继承，则 maven-resources-plugins 的默认过滤器 token 已从 ${*} 更改为 @（即 @maven.token@ 而不是 ${maven.token}），以防止与 Spring 风格的占位符冲突。如果你已经直接为 application.properties 启用了 Maven 过滤，你可能还需要更改默认过滤器 token 以使用[其他分隔符](https://maven.apache.org/plugins/maven-resources-plugin/resources-mojo.html#delimiters)。 110 | 111 | 注释：在这种特定情况下，端口绑定在 PaaS 环境中工作，例如 Heroku 或 Cloud Foundry。在这两个平台中，PORT 环境变量是自动设置的，Spring 可以绑定到 Environment 属性的大写同义词。 112 | 113 | ## 77.5、将 YAML 用于外部属性 114 | 115 | YAML 是 JSON 的超集，因此是一种方便的语法，用于以分层格式存储外部属性，如下例所示： 116 | ``` 117 | spring: 118 | application: 119 | name: cruncher 120 | datasource: 121 | driverClassName: com.mysql.jdbc.Driver 122 | url: jdbc:mysql://localhost/test 123 | server: 124 | port: 9000 125 | ``` 126 | 创建一个名为 application.yml 的文件，并将其放在类路径的根目录中。然后将 snakeyaml 添加到你的依赖项中（如果你使用 spring-boot-starter，则已经包含 Maven 坐标 org.yaml:snakeyaml）。YAML 文件被解析为 Java 映射 Map（像 JSON 对象），Spring Boot 将映射展平，使其深度为一级，并且具有以句点（.）分隔的键，因为许多人习惯于使用 Java 中的属性文件。 127 | 128 | 上面的示例 YAML 对应于以下 application.properties 文件： 129 | 130 | spring.application.name=cruncher 131 | spring.datasource.driverClassName=com.mysql.jdbc.Driver 132 | spring.datasource.url=jdbc:mysql://localhost/test 133 | server.port=9000 134 | 135 | 有关 YAML 的更多信息，请参见“Spring Boot 功能”部分中的[第 24.7 节：使用 YAML 而不是属性](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-external-config.html#boot-features-external-config-yaml)。 136 | 137 | ## 77.6、设置活动的 Spring 配置文件 138 | 139 | Spring Environment 对此有一个 API，但是你通常会设置一个系统属性（spring.profiles.active）或一个 OS（操作系统）环境变量（SPRING_PROFILES_ACTIVE）。此外，你可以使用 -D 参数启动应用程序（记得将其放在主类或 jar 存档之前），如下所示： 140 | 141 | $ java -jar -Dspring.profiles.active=production demo-0.0.1-SNAPSHOT.jar 142 | 143 | 在 Spring Boot 中，你还可以在 application.properties 中设置活动配置文件，如下面示例所示： 144 | 145 | spring.profiles.active=production 146 | 147 | 以这种方式设置的值将被系统属性或环境变量设置替换，但不会被 SpringApplicationBuilder.profiles() 方法替换。因此，后一个 Java API 可以用来在不改变默认值的情况下增加配置文件。 148 | 149 | 有关更多信息，请参见“Spring Boot 功能”部分中的[第 25 章：配置文件](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-profiles.html)。 150 | 151 | ## 77.7、根据 Environment 更改配置 152 | 153 | YAML 文件实际上是由 --- 行分隔的一系列文档，每个文档被分别解析为一个展开的映射。 154 | 155 | 如果 YAML 文档包含 spring.profiles 键，则 profiles 值（以逗号分隔的 profiles 列表）将被输入到 Spring Environment.acceptsProfiles() 方法中。如果这些 profiles 中的任何一个处于活动状态，则该文档将包含在最终合并中（否则不包含），如以下示例所示： 156 | ``` 157 | server: 158 | port: 9000 159 | --- 160 | 161 | spring: 162 | profiles: development 163 | server: 164 | port: 9001 165 | 166 | --- 167 | 168 | spring: 169 | profiles: production 170 | server: 171 | port: 0 172 | ``` 173 | 在上面的示例中，默认端口为 9000。但是，如果名为“development”的 Spring profile 处于活动状态，则端口为 9001。如果“production”处于活动状态，则端口为 0。 174 | 175 | 注释：YAML 文档按照遇到它们的顺序进行合并。后面的值覆盖前面的值。 176 | 177 | 要对属性文件执行同样的操作，可以使用 application-${profile}.properties 指定特定于 profile 的值。 178 | 179 | ## 77.8、发现外部属性的内置选项 180 | 181 | Spring Boot 在运行时将 application.properties（或 .yml 文件和其他位置）的外部属性绑定到应用程序中。在一个位置没有（而且技术上不可能）所有受支持属性的详尽列表，因为贡献可能来自类路径上的其他 jar 文件。 182 | 183 | 具有 Actuator 功能的运行应用程序有一个 configprops 端点，该端点显示通过 @ConfigurationProperties 可用的所有绑定和可绑定属性。 184 | 185 | 附录包括一个 application.properties 示例，其中列出了 Spring Boot 支持的最常见属性。最终列表来自搜索 @ConfigurationProperties 和 @Value 注解的源代码以及 Binder 的偶尔使用。有关加载属性的确切顺序的更多信息，请参见[第 24 章：外部化配置](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-external-config.html)。 186 | -------------------------------------------------------------------------------- /spring-boot/reference/09操作指南/79、SpringMVC.md: -------------------------------------------------------------------------------- 1 | # 79、Spring MVC 2 | 3 | Spring Boot 有许多包括 Spring MVC 的 starters。请注意，一些 starters 包含了对 Spring MVC 的依赖，而不是直接包含它。本节回答有关 Spring MVC 和 Spring Boot 的常见问题。 4 | 5 | ## 79.1、编写 JSON REST 服务 6 | 7 | 默认情况下，只要 Jackson2 在类路径上，Spring Boot 应用程序中的任何 Spring @RestController 都应该呈现 JSON 响应，如下面示例所示： 8 | ``` 9 | @RestController 10 | public class MyController { 11 | 12 | @RequestMapping("/thing") 13 | public MyThing thing() { 14 | return new MyThing(); 15 | } 16 | 17 | } 18 | ``` 19 | 只要 MyThing 可以被 Jackson2 序列化（对于普通的 POJO 或 Groovy 对象为 true），那么 localhost:8080/thing 默认提供它的 JSON 表示。请注意，在浏览器中，有时可能会看到 XML 响应，因为浏览器倾向于发送更喜欢 XML 的 accept 头。 20 | 21 | ## 79.2、编写 XML REST 服务 22 | 23 | 如果类路径上有 Jackson XML 扩展（jackson-dataformat-xml），则可以使用它来呈现 XML 响应。我们用于 JSON 的前一个示例可以工作。要使用 Jackson XML 渲染器，请将以下依赖项添加到项目中： 24 | ``` 25 | 26 | com.fasterxml.jackson.dataformat 27 | jackson-dataformat-xml 28 | 29 | ``` 30 | 如果 Jackson 的 XML 扩展不可用，并且 JAXB 可用，则可以使用附加要求来呈现 XML，即 MyThing 被注解为 @XmlRootElement，如下面示例所示： 31 | ``` 32 | @XmlRootElement 33 | public class MyThing { 34 | private String name; 35 | // .. getters and setters 36 | } 37 | ``` 38 | JAXB 只在 Java 8 中是现成的。如果你使用的是最新的 Java 版本，请将以下依赖项添加到项目中： 39 | ``` 40 | 41 | org.glassfish.jaxb 42 | jaxb-runtime 43 | 44 | ``` 45 | 注释：要让服务器呈现 XML 而不是 JSON，你可能必须发送 Accept: text/xml 头（或使用浏览器）。 46 | 47 | ## 79.3、自定义 Jackson ObjectMapper 48 | 49 | Spring MVC（客户端和服务器端）使用 HttpMessageConverters 在 HTTP 交换中协商内容转换。如果 Jackson 在类路径上，你已经获得了 Jackson2ObjectMapperBuilder 提供的默认转换器，该转换器的实例将为你自动配置。 50 | 51 | ObjectMapper（或 Jackson XML 转换器的 XmlMapper）实例（默认创建）具有以下自定义属性： 52 | 53 | （1）禁用 MapperFeature.DEFAULT_VIEW_INCLUSION 54 | （2）禁用 DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES 55 | （3）禁用 SerializationFeature.WRITE_DATES_AS_TIMESTAMPS 56 | 57 | Spring Boot 还具有一些功能，可以更轻松地自定义此行为。 58 | 59 | 可以使用环境配置 ObjectMapper 和 XmlMapper 实例。Jackson 提供了一系列简单的开/关功能，可用于配置其处理的各个方面。在映射到环境中的属性的六个枚举 (在 Jackson 中) 中描述了这些功能： 60 | 61 | |枚举 |属性 |值| 62 | |---|---|---| 63 | |com.fasterxml.jackson.databind.DeserializationFeature |spring.jackson.deserialization. |true, false| 64 | |com.fasterxml.jackson.core.JsonGenerator.Feature |spring.jackson.generator. |true, false| 65 | |com.fasterxml.jackson.databind.MapperFeature |spring.jackson.mapper. |true, false| 66 | |com.fasterxml.jackson.core.JsonParser.Feature |spring.jackson.parser. |true, false| 67 | |com.fasterxml.jackson.databind.SerializationFeature |spring.jackson.serialization. |true, false| 68 | |com.fasterxml.jackson.annotation.JsonInclude.Include |spring.jackson.default-property-inclusion |always, non_null, non_absent, non_default, non_empty| 69 | 70 | 例如，要启用漂亮的打印，请设置 spring.jackson.serialization.indent_output=true。注意，由于使用了[松散绑定](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-external-config.html#boot-features-external-config-relaxed-binding)，indent_output 的情况不必与相应的枚举常量的情况相匹配，即 INDENT_OUTPUT。 71 | 72 | 此基于环境的配置应用于自动配置的 Jackson2ObjectMapperBuilder bean，并应用于使用构建器创建的任何映射器，包括自动配置的 ObjectMapper bean。 73 | 74 | 上下文的 Jackson2ObjectMapperBuilder 可以由一个或多个 Jackson2ObjectMapperBuilderCustomizer bean 自定义。可以排序这样的定制器 bean（Boot 自己的定制器的排序为 0），允许在 Boot 定制之前和之后应用额外的定制。 75 | 76 | com.fasterxml.jackson.databind.Module 类型的任何 bean 都会自动注册到自动配置的 Jackson2ObjectMapperBuilder，并应用于它创建的任何 ObjectMapper 实例。这为向应用程序添加新功能时贡献自定义模块提供了全局机制。 77 | 78 | 如果要完全替换默认 ObjectMapper，请定义该类型的 @Bean 并将其标记为 @Primary，或者，如果你更喜欢基于构建器的方法，则定义 Jackson2ObjectMapperBuilder @Bean。请注意，在任何一种情况下，这样做都会禁用 ObjectMapper 的所有自动配置。 79 | 80 | 如果你提供任何 MappingJackson2HttpMessageConverter 类型的 @Beans，它们将替换 MVC 配置中的默认值。此外，还提供了一个 HttpMessageConverters 类型的便利 bean（如果使用默认的 MVC 配置，则始终可用）。它有一些有用的方法来访问默认和用户增强的消息转换器。 81 | 82 | 有关更多详细信息，请参见第 79.4 节：自定义 @ResponseBody 渲染部分和 WebMvcAutoConfiguration 源代码。 83 | 84 | ## 79.4、自定义 @ResponseBody 呈现 85 | 86 | Spring 使用 HttpMessageConverters 呈现 @ResponseBody（或来自 @RestController 的响应）。你可以通过在 Spring Boot 上下文中添加适当类型的 bean 来贡献其他转换器。如果你添加的 bean 属于默认情况下会包含的类型（例如 JSON 转换的 MappingJackson2HttpMessageConverter），它将替换默认值。提供了一个 HttpMessageConverters 类型的便利 bean，如果你使用默认的 MVC 配置，它总是可用的。它有一些有用的方法来访问默认和用户增强的消息转换器（例如，如果你想将它们手动注入自定义 RestTemplate，它可能会很有用）。 87 | 88 | 与普通的 MVC 使用一样，你提供的任何 WebMvcConfigurer bean 也可以通过覆盖 configureMessageConverters 方法来贡献转换器。但是，与普通 MVC 不同，你只能提供所需的其他转换器（因为 Spring Boot 使用相同的机制来提供其默认值）。最后，如果你通过提供自己的 @EnableWebMvc 配置来选择退出 Spring Boot 默认 MVC 配置，则可以完全控制并通过使用 WebMvcConfigurationSupport 中的 getMessageConverters 手动执行所有操作。 89 | 90 | 有关更多详细信息，请参见 [WebMvcAutoConfiguration](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/web/servlet/WebMvcAutoConfiguration.java) 源代码。 91 | 92 | ## 79.5、处理 Multipart File 上传 93 | 94 | Spring Boot 包含 Servlet 3 javax.servlet.http.Part API 来支持上传文件。默认情况下，Spring Boot 配置 Spring MVC，在单个请求中每个文件的最大大小为 1MB，文件数据的最大大小为 10MB。通过使用 MultipartProperties 类中公开的属性，你可以重写这些值、存储中间数据的位置（例如，到 /tmp 目录）和刷新到磁盘的数据的阈值。例如，如果要指定文件无限制，请将 spring.servlet.multipart.max-file-size 属性设置为 -1。 95 | 96 | 当你希望在 Spring MVC 控制器处理程序方法中将多部分编码的文件数据作为 MultipartFile 类型的 @RequestParam 注解参数接收时，多部分支持非常有用。 97 | 98 | 有关更多详细信息，请参见 [MultipartAutoConfiguration](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/web/servlet/MultipartAutoConfiguration.java) 源。 99 | 100 | 注释：建议使用容器内置的支持进行多部分上传，而不是引入额外的依赖项，如 Apache Commons 文件上传。 101 | 102 | ## 79.6、关闭 Spring MVC DispatcherServlet 103 | 104 | 默认情况下，所有内容都是从应用程序的根目录（/）提供的。如果希望映射到其他路径，可以按如下方式配置一个路径： 105 | 106 | spring.mvc.servlet.path=/acme 107 | 108 | 如果你有额外的 servlets，你可以为每一个声明一个 Servlet 或 ServletRegistrationBean 类型的 @Bean，Spring Boot 会透明地将它们注册到容器中。因为 servlets 是以这种方式注册的，所以它们可以映射到 DispatcherServlet 的子上下文，而无需调用它。 109 | 110 | 自己配置 DispatcherServlet 是不寻常的，但是如果你真的需要这样做，必须提供一个 DispatcherServletPath 类型的 @Bean 来提供自定义 DispatcherServlet 的路径。 111 | 112 | ## 79.7、关闭默认 MVC 配置 113 | 114 | 完全控制 MVC 配置的最简单方法是使用 @EnableWebMvc 注解提供你自己的 @Configuration。这样做会使所有 MVC 配置都掌握在你的手中。 115 | 116 | ## 79.8、定制 ViewResolvers 117 | 118 | ViewResolver 是 Spring MVC 的核心组件，将 @Controller 中的视图名称转换为实际的 View 实现。请注意，ViewResolvers 主要用于 UI 应用程序，而不是 REST 风格的服务（View 不用于呈现 @ResponseBody）。ViewResolver 有许多实现可供选择，Spring 本身并不认为应该使用哪些实现。另一方面，Spring Boot 为你安装一个或两个，这取决于它在类路径和应用程序上下文中找到的内容。DispatcherServlet 使用它在应用程序上下文中找到的所有解析器，依次尝试每个解析器，直到得到结果，因此，如果你添加自己的解析器，你必须知道顺序以及你的解析器被添加到哪个位置。 119 | 120 | WebMvcAutoConfiguration 将以下 ViewResolver 添加到上下文中： 121 | 122 | （1）名为 defaultViewResolver 的 InternalResourceViewResolver。它定位可以使用 DefaultServlet 呈现的物理资源（包括静态资源和 JSP 页面，如果你使用它们的话）。它对视图名称应用前缀和后缀，然后在 servlet 上下文中查找具有该路径的物理资源（默认值均为空，但可通过 spring.mvc.view.prefix 和 spring.mvc.view.suffix 访问外部配置）。你可以通过提供相同类型的 bean 来重写它。 123 | 124 | （2）名为 beanNameViewResolver 的 BeanNameViewResolver。这是视图解析器链的一个有用成员，它可以提取与正在解析的 View 同名的所有 bean。没有必要覆盖或替换它。 125 | 126 | （3）只有当实际存在类型为 View 的 bean 时，才会添加名为 viewResolver 的 ContentNegotiatingViewResolver。这是一个主解析器，委托给所有其他解析器，并试图找到与客户端发送的 “Accept” HTTP 头的匹配。有一个关于 ContentNegotiatingViewResolver 的有用博客，你可能想学习它以了解更多信息，你也可以查看源代码以获取详细信息。你可以通过定义一个名为 viewResolver 的 bean 来关闭自动配置的 ContentNegotiatingViewResolver。 127 | 128 | （4）如果使用 Thymeleaf，则还有一个名为 thymeleafViewResolver 的 ThymeleafViewResolver。它通过在视图名称周围加上前缀和后缀来查找资源。前缀是 spring.thymeleaf.prefix，后缀是 spring.thymeleaf.suffix。前缀和后缀的值分别默认为 classpath:/templates/ 和 .html。你可以通过提供同名的 bean 来重写 ThymeleafViewResolver。 129 | 130 | （5）如果使用 FreeMarker，则还有一个名为 freeMarkerViewResolver 的 FreeMarkerViewResolver。它在加载器路径（外部化为spring.freemarker.templateLoaderPath，默认值为 classpath:/templates/）中查找资源，方法是用前缀和后缀包围视图名称。前缀外部化为 spring.freemarker.prefix，后缀外部化为 spring.freemarker.suffix。前缀和后缀的默认值分别为空和 .ftl。通过提供同名的bean，可以重写FreeMarkerViewResolver。 131 | 132 | （6）如果你使用 Groovy 模板（实际上，如果 groovy-templates 在你的类路径上），那么你还有一个名为 groovyMarkupViewResolver 的 GroovyMarkupViewResolver。它通过在视图名周围加上前缀和后缀（外部化为 spring.groovy.template.prefix 和 spring.groovy.template.suffix）来查找加载器路径中的资源。前缀和后缀的默认值分别为 classpath:/templates/ 和 .tpl。你可以通过提供同名的 bean 来重写 GroovyMarkupViewResolver。 133 | 134 | 有关详细信息，请参见以下部分： 135 | 136 | （1）[WebMvcAutoConfiguration](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/web/servlet/WebMvcAutoConfiguration.java) 137 | 138 | （2）[ThymeleafAutoConfiguration](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/thymeleaf/ThymeleafAutoConfiguration.java) 139 | 140 | （3）[FreeMarkerAutoConfiguration](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/freemarker/FreeMarkerAutoConfiguration.java) 141 | 142 | （4）[GroovyTemplateAutoConfiguration](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/groovy/template/GroovyTemplateAutoConfiguration.java) 143 | -------------------------------------------------------------------------------- /spring-boot/reference/09操作指南/80、使用SpringSecurity进行测试.md: -------------------------------------------------------------------------------- 1 | # 80、使用 Spring Security 进行测试 2 | 3 | Spring Security 为作为特定用户运行测试提供支持。例如，下面代码段中的测试将与具有 ADMIN 角色的经过身份验证的用户一起运行。 4 | ``` 5 | @Test 6 | @WithMockUser(roles="ADMIN") 7 | public void requestProtectedUrlWithUser() throws Exception { 8 | mvc 9 | .perform(get("/")) 10 | ... 11 | } 12 | ``` 13 | Spring Security 提供了与 Spring MVC Test 的全面集成，这也可以在使用 @WebMvcTest 切片和 MockMvc 测试控制器时使用。 14 | 15 | 有关 Spring Security 测试支持的其他详细信息，请参阅 Spring Security 的[参考文档](https://docs.spring.io/spring-security/site/docs/current/reference/htmlsingle/#test)。 -------------------------------------------------------------------------------- /spring-boot/reference/09操作指南/81、Jersey.md: -------------------------------------------------------------------------------- 1 | # 81、Jersey 2 | 3 | ## 81.1、使用 Spring Security 保护 Jersey 端点 4 | 5 | Spring Security 可用于保护基于 Jersey 的 web 应用程序，其方式与用于保护基于 Spring MVC 的 web 应用程序的方式大致相同。但是，如果要将 Spring Security 的方法级安全性与 Jersey 一起使用，则必须将 Jersey 配置为使用 setStatus(int) 而不是 sendError(int)。这防止了 Jersey 在 Spring Security 有机会向客户端报告身份验证或授权失败之前提交响应。 6 | 7 | 必须在应用程序的 ResourceConfig bean 上将 jersey.config.server.response.setStatusOverSendError 属性设置为 true，如下面示例所示： 8 | ``` 9 | @Component 10 | public class JerseyConfig extends ResourceConfig { 11 | 12 | public JerseyConfig() { 13 | register(Endpoint.class); 14 | setProperties(Collections.singletonMap("jersey.config.server.response.setStatusOverSendError", true)); 15 | } 16 | 17 | } 18 | ``` -------------------------------------------------------------------------------- /spring-boot/reference/09操作指南/82、HTTP 客户端.md: -------------------------------------------------------------------------------- 1 | # 82、HTTP 客户端 2 | 3 | Spring Boot 提供了许多与 HTTP 客户端一起使用的 starters。本节回答与使用它们相关的问题。 4 | 5 | ## 82.1、配置 RestTemplate 以使用代理 6 | 7 | 如[第 35.1 节：RestTemplate 定制](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-resttemplate.html#boot-features-resttemplate-customization)中所述，你可以使用 RestTemplateCustomizer 和 RestTemplateBuilder 来构建定制的 RestTemplate。这是创建配置为使用代理的 RestTemplate 的推荐方法。 8 | 9 | 代理配置的确切细节取决于正在使用的底层客户端请求工厂。以下示例使用 HttpClient 配置 HttpComponentsClientRequestFactory，该 HttpClient 为除 192.168.0.5 之外的所有主机使用代理： 10 | ``` 11 | static class ProxyCustomizer implements RestTemplateCustomizer { 12 | 13 | @Override 14 | public void customize(RestTemplate restTemplate) { 15 | HttpHost proxy = new HttpHost("proxy.example.com"); 16 | HttpClient httpClient = HttpClientBuilder.create().setRoutePlanner(new DefaultProxyRoutePlanner(proxy) { 17 | 18 | @Override 19 | public HttpHost determineProxy(HttpHost target, HttpRequest request, HttpContext context) 20 | throws HttpException { 21 | if (target.getHostName().equals("192.168.0.5")) { 22 | return null; 23 | } 24 | return super.determineProxy(target, request, context); 25 | } 26 | 27 | }).build(); 28 | restTemplate.setRequestFactory(new HttpComponentsClientHttpRequestFactory(httpClient)); 29 | } 30 | 31 | } 32 | ``` -------------------------------------------------------------------------------- /spring-boot/reference/09操作指南/83、日志.md: -------------------------------------------------------------------------------- 1 | # 83、日志 2 | 3 | Spring Boot 没有强制日志依赖项，除了 Commons Logging API，它通常由 Spring Framework 的 spring-jcl 模块提供。要使用 Logback，你需要在类路径中包含它和 spring-jcl。最简单的方法是通过 starters，它们都依赖于 spring-boot-starter-logging。对于 web 应用程序，你只需要 spring-boot-starter-web，因为它传递依赖于日志 starter。如果你使用 Maven，以下依赖项会为你添加日志： 4 | ``` 5 | 6 | org.springframework.boot 7 | spring-boot-starter-web 8 | 9 | ``` 10 | Spring Boot 有一个 LoggingSystem 抽象，它试图根据类路径的内容配置日志。如果可以使用 Logback，则它是首选。 11 | 12 | 如果你需要对日志进行的唯一更改是设置各种日志器的级别，则可以使用“logging.level”前缀在 application.properties 中进行设置，如下面示例所示： 13 | 14 | logging.level.org.springframework.web=DEBUG 15 | logging.level.org.hibernate=ERROR 16 | 17 | 你还可以使用“logging.file”设置要向其写入日志的文件的位置（除了控制台）。 18 | 19 | 要配置日志系统更细粒度的设置，需要使用相关 LoggingSystem 支持的本地配置格式。默认情况下，Spring Boot 从系统的默认位置（例如 Logback 的 classpath:logback.xml）获取本地配置，但是你可以使用“logging.config”属性设置配置文件的位置。 20 | 21 | ## 83.1、为日志配置 Logback 22 | 23 | 如果将 logback.xml 放在类路径的根目录中，则会从那里（或从 logback-spring.xml 中，以利用 Boot 提供的模板功能）获取它。Spring Boot 提供了一个默认的基本配置，如果你想设置级别，可以包括它，如下面示例所示： 24 | ``` 25 | 26 | 27 | 28 | 29 | 30 | ``` 31 | 如果查看 spring-boot jar 中的 base.xml，可以看到它使用了一些有用的系统属性，而 LoggingSystem 负责为你创建这些属性： 32 | 33 | （1）${PID}：当前进程 ID。 34 | （2）${LOG_FILE}：是否在 Boot 的外部配置中设置了 logging.file。 35 | （3）${LOG_PATH}：是否在 Boot 的外部配置中设置了 logging.path（表示日志文件所在的目录）。 36 | （4）${LOG_EXCEPTION_CONVERSION_WORD}：是否在 Boot 的外部配置中设置了 logging.exception-conversion-word。 37 | 38 | Spring Boot 还通过使用自定义 Logback 转换器在控制台 (但不在日志文件中) 上提供了一些不错的 ANSI 颜色终端输出。有关详细信息，请参阅默认 base.xml 配置。 39 | 40 | 如果 Groovy 在类路径上，你也应该能够使用 logback.groovy 配置 Logback。如果存在，则优先选择此设置。 41 | 42 | ### 83.1.1、只为文件输出配置 Logback 43 | 44 | 如果要禁用控制台日志并仅将输出写入文件，则需要一个自定义 logback-spring.xml，该文件导入 file-appender.xml，而不是 console-appender.xml，如下面示例所示： 45 | ``` 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | ``` 56 | 你还需要将 logging.file 添加到 application.properties 中，如下面示例所示： 57 | 58 | logging.file=myapplication.log 59 | 60 | ## 83.2、为日志配置 Log4j 61 | 62 | 如果 [Log4j 2](https://logging.apache.org/log4j/2.x) 位于类路径上，则 Spring Boot 支持它进行日志配置。如果你使用 starters 来组装依赖项，则必须排除 Logback，然后包含 log4j 2。如果不使用 starters，除了 Log4j 2 之外，还需要提供（至少）spring-jcl。 63 | 64 | 最简单的路径可能是通过 starters，尽管它需要对 exclude 进行一些调整。下面的示例展示了如何在 Maven 中设置 starters： 65 | ``` 66 | 67 | org.springframework.boot 68 | spring-boot-starter-web 69 | 70 | 71 | org.springframework.boot 72 | spring-boot-starter 73 | 74 | 75 | org.springframework.boot 76 | spring-boot-starter-logging 77 | 78 | 79 | 80 | 81 | org.springframework.boot 82 | spring-boot-starter-log4j2 83 | 84 | ``` 85 | 下面的示例展示了在 Gradle 中设置 starters 的一种方法： 86 | ``` 87 | dependencies { 88 | compile 'org.springframework.boot:spring-boot-starter-web' 89 | compile 'org.springframework.boot:spring-boot-starter-log4j2' 90 | } 91 | 92 | configurations { 93 | all { 94 | exclude group: 'org.springframework.boot', module: 'spring-boot-starter-logging' 95 | } 96 | } 97 | ``` 98 | 注释：Log4j starters 将常见日志需求的依赖项聚集在一起（例如让 Tomcat 使用 java.util.Log，但使用 Log4j 2 配置输出）。有关更多详细信息，请参见 [Actuator Log4j 2](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-samples/spring-boot-sample-actuator-log4j2) 示例，并查看其运行情况。 99 | 100 | 注释：要确保将使用 java.util.logging 执行的调试日志路由到 Log4j 2，请通过将 java.util.logging.manager 系统属性设置为 org.apache.logging.log4j.jul.LogManager 来配置其 [JDK 日志适配器](https://logging.apache.org/log4j/2.0/log4j-jul/index.html)。 101 | 102 | ### 83.2.1、使用 YAML 或 JSON 配置 Log4j 2 103 | 104 | 除了默认的 XML 配置格式，Log4j 2 还支持 YAML 和 JSON 配置文件。要将 Log4j 2 配置为使用替代的配置文件格式，请将适当的依赖项添加到类路径，并将配置文件命名为与所选文件格式匹配，如下面示例所示： 105 | 106 | |格式 |依赖项 |文件名称| 107 | |---|---|---| 108 | |YAML |com.fasterxml.jackson.core:jackson-databind com.fasterxml.jackson.dataformat:jackson-dataformat-yaml |log4j2.yaml log4j2.yml| 109 | |JSON |com.fasterxml.jackson.core:jackson-databind |log4j2.json log4j2.jsn| -------------------------------------------------------------------------------- /spring-boot/reference/09操作指南/85、数据库初始化.md: -------------------------------------------------------------------------------- 1 | # 85、数据库初始化 2 | 3 | 根据堆栈的不同，可以以不同的方式初始化 SQL 数据库。当然，如果数据库是一个独立的进程，你也可以手动执行此操作。建议使用单一的 schema 生成机制。 4 | 5 | ## 85.1、使用 JPA 初始化数据库 6 | 7 | JPA 具有生成 DDL 的功能，这些功能可以设置为在启动时对数据库运行。这由两个外部属性控制： 8 | 9 | （1）spring.jpa.generate-ddl（boolean）打开和关闭该特性，并且与供应商无关。 10 | 11 | （2）spring.jpa.hibernate.ddl-auto（enum）是一个 Hibernate 功能，它以更细粒度的方式控制行为。本指南稍后将更详细地介绍此功能。 12 | 13 | ## 85.2、使用 Hibernate 初始化数据库 14 | 15 | 你可以显式设置 spring.jp a.hibernate.ddl-auto，并且标准的 Hibernate 属性值为 none、validate、update、create 和 create-drop。Spring Boot 根据它是否认为你的数据库已嵌入，为你选择一个默认值。如果未检测到 schema 管理器或在所有其他情况下都是 none，则默认为 create-drop。通过查看连接类型来检测嵌入式数据库。hsqldb、 h2 和 derby 是嵌入的，其他则不是。从内存中切换到 “真实” 数据库时要小心，不要对新平台中的表和数据的存在做出假设。您要么必须显式设置 ddl-auto，要么使用其他机制之一初始化数据库。 16 | 17 | 注释：你可以通过启用 org.hibernate.SQL 日志器来输出 schema 创建。如果启用[调试模式](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-logging.html#boot-features-logging-console-output)，将自动完成此操作。 18 | 19 | 此外，如果 Hibernate 从头开始创建 schema（即，如果 ddl-auto 属性设置为 create 或 create-drop），则在启动时将执行类路径根目录中名为 import.sql 的文件。这对于演示和测试很有用，如果你很小心的话，但是这可能不是你想要在生产中的类路径上的东西。这是一个 Hibernate 功能（与 Spring 无关）。 20 | 21 | ## 85.3、初始化数据库 22 | 23 | Spring Boot 可以自动创建 DataSource 的 schema（DDL 脚本）并初始化它（DML 脚本）。它分别从标准根类路径位置：schema.sql 和data.sql 加载 SQL。此外，Spring Boot 处理 schema-${platform}.sql 和 data-${platform}.sql 文件（如果存在），其中 platform 是 spring.datasource.platform 的值。这允许你在必要时切换到特定于数据库的脚本。例如，你可以选择将其设置为数据库的供应商名称（hsqldb、h2、oracle、mysql、postgresql 等）。 24 | 25 | >注释： 26 | > 27 | >Spring Boot 自动创建嵌入 DataSource 的 schema。可以使用 spring.datasource.initialization-mode 属性自定义此行为。例如，如果要始终初始化 DataSource，而不管其类型如何： 28 | > 29 | > spring.datasource.initialization-mode=always 30 | 31 | 默认情况下，Spring Boot 启用 Spring JDBC 初始化器的 fail-fast 功能。这意味着，如果脚本导致异常，应用程序将无法启动。你可以通过设置 spring.datasource.continue-on-error 来调整该行为。 32 | 33 | 注释：在基于 JPA 的应用程序中，你可以选择让 Hibernate 创建 schema 或使用 schema.sql，但不能同时使用这两种方法。如果你使用 schema.sql，请确保禁用 spring.jpa.hibernate.ddl-auto。 34 | 35 | ## 85.4、初始化 Spring Batch 数据库 36 | 37 | 如果你使用 Spring Batch，则它就预先打包了用于大多数流行数据库平台的 SQL 初始化脚本。Spring Boot 可以检测你的数据库类型，并在启动时执行这些脚本。如果使用嵌入式数据库，默认情况下会发生这种情况。你还可以为任何数据库类型启用它，如下面示例所示： 38 | 39 | spring.batch.initialize-schema=always 40 | 41 | 还可以通过设置 spring.batch.initialize-schema=never 显式关闭初始化。 42 | 43 | ## 85.5、使用更高级别的数据库迁移工具 44 | 45 | Spring Boot 支持两个更高级的迁移工具：Flyway 和 Liquibase。 46 | 47 | ### 85.5.1、在启动时执行 Flyway 数据库迁移 48 | 49 | 要在启动时自动运行 Flyway 数据库迁移，请将 org.flywaydb:flyway-core 添加到你的类路径中。 50 | 51 | 迁移是 V<VERSION>__<NAME>.sql 格式的脚本（带有 <VERSION> 下划线分隔的版本，如 1 或 2_1）。默认情况下，它们位于名为 classpath:db/migration 的文件夹中，但你可以通过设置 spring.flyway.locations 来修改该位置。这是一个逗号分隔的一个或多个 classpath: 或 filesystem: 位置的列表。例如，以下配置将在默认类路径位置和 /opt/migration 目录中搜索脚本： 52 | 53 | spring.flyway.locations=classpath:db/migration,filesystem:/opt/migration 54 | 55 | 你还可以添加一个特殊的 {vendor} 占位符来使用特定于供应商的脚本。假设如下： 56 | 57 | spring.flyway.locations=classpath:db/migration/{vendor} 58 | 59 | 前面的配置没有使用 db/migration，而是根据数据库的类型设置要使用的文件夹（例如：MySQL 的 db/migration/mysql）。支持的数据库列表在 [DatabaseDriver](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot/src/main/java/org/springframework/boot/jdbc/DatabaseDriver.java) 中可用。 60 | 61 | [FlywayProperties](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/flyway/FlywayProperties.java) 提供了 Flyway 的大部分设置和一小部分附加属性，可用于禁用迁移或关闭位置检查。如果你需要对配置进行更多控制，请考虑注册 FlywayConfigurationCustomizer bean。 62 | 63 | Spring Boot 调用 Flyway.migration() 来执行数据库迁移。如果你想要更多的控制，则提供一个实现 [FlywayMigrationStrategy](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/flyway/FlywayMigrationStrategy.java) 的 @Bean。 64 | 65 | Flyway 支持 SQL 和 Java 回调。要使用基于 SQL 的回调，请将回调脚本放在 classpath:db/migration 文件夹中。要使用基于 Java 的回调，请创建一个或多个实现 Callback 的 bean。任何此类 beans 都会自动注册到 Flyway。它们可以通过使用 @Order 或实现 Ordered 进行排序。实现已弃用的 FlywayCallback 接口的 bean 也可以被检测到，但是它们不能与 Callback bean 一起使用。 66 | 67 | 默认情况下，Flyway 会在你的上下文中自动提供（@Primary）DataSource，并将其用于迁移。如果你想使用不同的 DataSource，可以创建一个，并将其 @Bean 标记为 @FlywayDataSource。如果你这样做并且想要两个数据源，请记住创建另一个并将其标记为 @Primary。或者，你可以通过在外部属性中设置 spring.flyway.[url,user,password] 来使用 Flyway 的本机 DataSource。设置 spring.flyway.url 或 spring.flyway.user 足以使 Flyway 使用自己的 DataSource。如果尚未设置三个属性中的任何一个，将使用其等效的 spring.datasource 属性的值。 68 | 69 | 有一个 [Flyway 示例](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-samples/spring-boot-sample-flyway)，以便你可以看到如何设置。 70 | 71 | 你还可以使用 Flyway 为特定场景提供数据。例如，你可以在 src/test/resources 中放置特定于测试的迁移，并且它们仅在应用程序开始进行测试时运行。此外，你可以使用特定于 profile 的配置来自定义 spring.flyway.locations，以便仅在特定 profile 处于活动状态时才能运行某些迁移。例如，在 application-dev.properties 中，你可以指定以下设置： 72 | 73 | spring.flyway.locations=classpath:/db/migration,classpath:/dev/db/migration 74 | 75 | 使用该设置，dev/db/migration 中的迁移仅在 dev profile 处于活动状态时运行。 76 | 77 | ### 85.5.2、启动时执行 Liquibase 数据库迁移 78 | 79 | 要在启动时自动运行 Liquibase 数据库迁移，请将 org.liquibase:liquibase-core 添加到你的类路径中。 80 | 81 | 默认情况下，主更改日志是从 db/changelog/db.changelog-master.yaml 中读取的，但是你可以通过设置 spring.liquibase.change-log 来更改位置。除了 YAML，Liquibase 还支持 JSON、 XML 和 SQL 更改日志格式。 82 | 83 | 默认情况下，Liquibase 会在你的上下文中自动提供（@Primary）DataSource，并将其用于迁移。如果你想使用不同的 DataSource，可以创建一个，并将其 @Bean 标记为 @LiquibaseDataSource。如果你这样做并且想要两个数据源，请记住创建另一个并将其标记为 @Primary。或者，你可以通过在外部属性中设置 spring.liquibase.[url,user,password] 来使用 Liquibase 的本机 DataSource。设置 spring.liquibase.url 或 spring.liquibase.user 足以使 Liquibase 使用自己的 DataSource。如果尚未设置三个属性中的任何一个，将使用其等效的 spring.datasource 属性的值。 84 | 85 | 有关可用设置（如上下文、默认 schema 和其他）的详细信息，请参见 [LiquibaseProperties](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/liquibase/LiquibaseProperties.java)。 86 | 87 | 有一个 [Liquibase](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-samples/spring-boot-sample-liquibase) 示例，以便你可以看到如何设置。 88 | -------------------------------------------------------------------------------- /spring-boot/reference/09操作指南/86、消息传递.md: -------------------------------------------------------------------------------- 1 | # 86、消息传递 2 | 3 | Spring Boot 提供了许多包含消息传递的 starters。本节回答了在 Spring Boot 中使用消息传递时出现的问题。 4 | 5 | ## 86.1、禁用事务 JMS 会话 6 | 7 | 如果你的 JMS 代理不支持事务处理会话，则必须完全禁用事务的支持。如果你创建自己的 JmsListenerContainerFactory，则无事可做，因为默认情况下它不能被处理。如果要使用 DefaultJmsListenerContainerFactoryConfigurer 重用 Spring Boot 的默认值，可以禁用事务会话，如下所示： 8 | ``` 9 | @Bean 10 | public DefaultJmsListenerContainerFactory jmsListenerContainerFactory( 11 | ConnectionFactory connectionFactory, 12 | DefaultJmsListenerContainerFactoryConfigurer configurer) { 13 | DefaultJmsListenerContainerFactory listenerFactory = 14 | new DefaultJmsListenerContainerFactory(); 15 | configurer.configure(listenerFactory, connectionFactory); 16 | listenerFactory.setTransactionManager(null); 17 | listenerFactory.setSessionTransacted(false); 18 | return listenerFactory; 19 | } 20 | ``` 21 | 前面的示例覆盖默认工厂，它应该应用于应用程序定义的任何其他工厂（如果有）。 -------------------------------------------------------------------------------- /spring-boot/reference/09操作指南/87、批处理应用程序.md: -------------------------------------------------------------------------------- 1 | # 87、批处理应用程序 2 | 3 | 本节回答了在 Spring Boot 中使用 Spring Batch 时出现的问题。 4 | 5 | 注释：默认情况下，批处理应用程序需要一个 DataSource 来存储作业详细信息。如果你想偏离这一点，你需要实现 BatchConfigurer。有关更多详细信息，请参见 [@EnableBatchProcessing 的 Javadoc](https://docs.spring.io/spring-batch/apidocs/org/springframework/batch/core/configuration/annotation/EnableBatchProcessing.html)。 6 | 7 | 有关 Spring Batch 的更多信息，请参见 [Spring Batch 项目页面](https://projects.spring.io/spring-batch/)。 8 | 9 | ## 87.1、在启动时执行 Spring Batch 作业 10 | 11 | 通过在上下文中的某个位置添加 @EnableBatchProcessing（来自 Spring Batch）来启用 Spring Batch 自动配置。 12 | 13 | 默认情况下，它在启动时执行应用程序上下文中的所有作业（有关详细信息，请参见 [JobLauncherCommandLineRunner](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/batch/JobLauncherCommandLineRunner.java)）。你可以通过指定 spring.batch.job.names（以逗号分隔的作业名称模式列表）来缩小到一个或多个特定作业。 14 | 15 | 提示：与[在 Environment 中设置属性](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-external-config.html#boot-features-external-config-command-line-args)的命令行选项参数不同（即以 -- 开头，例如 --my-property=value），必须在命令行上指定作业参数而不使用破折号（例如 jobParam=value）。 16 | 17 | 如果应用程序上下文包含 JobRegistry，spring.batch.job.names 中的作业将在注册表中查找，而不是从上下文自动获取。这是一个更复杂系统的常见模式，多个作业在子上下文中定义并集中注册。 18 | 19 | 有关更多详细信息，请参见 [BatchAutoConfiguration](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/batch/BatchAutoConfiguration.java) 和 [@EnableBatchProcessing](https://github.com/spring-projects/spring-batch/blob/master/spring-batch-core/src/main/java/org/springframework/batch/core/configuration/annotation/EnableBatchProcessing.java)。 20 | -------------------------------------------------------------------------------- /spring-boot/reference/09操作指南/88、Actuator.md: -------------------------------------------------------------------------------- 1 | # 88、Actuator 2 | 3 | Spring Boot 包括 Spring Boot Actuator。本节回答了在使用过程中经常出现的问题。 4 | 5 | ## 88.1、更改 Actuator 端点的 HTTP 端口或地址 6 | 7 | 在独立应用程序中，Actuator HTTP 端口默认为与主 HTTP 端口相同。要使应用程序监听其他端口，请设置外部属性：management.server.port。要监听完全不同的网络地址（例如，当你有用于管理的内部网络和用于用户应用程序的外部网络时），还可以将 management.server.address 设置为服务器可以绑定到的有效 IP 地址。 8 | 9 | 有关更多详细信息，请参见 [ManagementServerProperties](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/web/server/ManagementServerProperties.java) 源代码和 “生产就绪功能” 部分中的[第 54.2 节：自定义管理服务器端口](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/production-ready-monitoring.html#production-ready-customizing-management-server-port)。 10 | 11 | ## 88.2、自定义“whitelabel”错误页 12 | 13 | Spring Boot 安装一个“whitelabel”错误页面，如果遇到服务器错误，你可以在浏览器客户端中看到该页面（使用 JSON 和其他媒体类型的机器客户端应该会看到一个带有恰当的错误代码的合理响应）。 14 | 15 | 注释：设置 server.error.whitelabel.enabled=false 以关闭默认错误页。这样做可以恢复你正在使用的 servlet 容器的默认值。请注意，Spring Boot 仍然试图解析错误视图，因此你可能应该添加自己的错误页面，而不是完全禁用它。 16 | 17 | 自行覆盖错误页面取决于你使用的模板技术。例如，如果你使用 Thymeleaf，则可以添加 error.html 模板。如果使用 FreeMarker，则可以添加 error.ftl 模板。通常，你需要一个以 error 名称解析的 View，或者一个处理 /error 路径的 @Controller。如果你没有替换了一些默认配置，则你应该在 ApplicationContext 中找到一个 BeanNameViewResolver，因此，名为 error 的 @Bean 将是一种处理那的简单方法。有关更多选项，请参见 [ErrorMvcAutoConfiguration](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/web/servlet/error/ErrorMvcAutoConfiguration.java)。 18 | 19 | 有关如何在 servlet 容器中注册处理器的详细信息，请参见“[错误处理](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/boot-features-developing-web-applications.html#boot-features-error-handling)”一节。 20 | 21 | ## 88.3、清除敏感值 22 | 23 | env 和 configprops 端点返回的信息可能有些敏感，因此默认情况下匹配特定模式的键会被清理（即，它们的值被 ***** 替换）。 24 | 25 | Spring Boot 对这些键使用合理的默认值：例如，任何以“password”、“secret”、“key”或“token”结尾的键都会被清除。也可以改用正则表达式，例如 \*credentials.\* 来清理将单词 credentials 作为键的一部分的任何键。 26 | 27 | 可以分别使用 management.endpoint.env.keys-to-sanitize 和 management.endpoint.configprops.keys-to-sanitize 自定义要使用的模式。 -------------------------------------------------------------------------------- /spring-boot/reference/09操作指南/89、安全.md: -------------------------------------------------------------------------------- 1 | # 89、安全 2 | 3 | 本节讨论使用 Spring Boot 时的安全性问题，包括在 Spring Boot 中使用 Spring Security 时出现的问题。 4 | 5 | 有关 Spring Security 的更多信息，请参见 [Spring Security 项目页面](https://projects.spring.io/spring-security/)。 6 | 7 | ## 89.1、关闭 Spring Boot 安全配置 8 | 9 | 如果你在应用程序中使用 WebSecurityConfigurerAdapter 定义 @Configuration，它将关闭 Spring Boot 中的默认 webapp 安全设置。 10 | 11 | ## 89.2、更改 UserDetailsService 并添加用户帐户 12 | 13 | 如果提供一个类型为 AuthenticationManager、AuthenticationProvider 或 UserDetailsService 的 @Bean，则不会创建 InMemoryUserDetailsManager 的默认 @Bean，因此，你可以使用 Spring Security 的完整功能集（例如，[各种身份验证选项](https://docs.spring.io/spring-security/site/docs/current/reference/htmlsingle/#jc-authentication)）。 14 | 15 | 添加用户帐户的最简单方法是提供你自己的 UserDetailsService bean。 16 | 17 | ## 89.3、在代理服务器后面运行时启用 HTTPS 18 | 19 | 对于任何应用程序来说，确保所有主要端点仅通过 HTTPS 可用是一项重要的工作。如果你使用 Tomcat 作为 servlet 容器，那么 Spring Boot 会在检测到某些环境设置时自动添加 Tomcat 自己的 RemoteIpValve，并且你应该能够依靠 HttpServletRequest 来报告它是否安全（甚至在处理真正的 SSL 终止的代理服务器的下游）。标准行为由某些请求头（x-forwarded-for 和 x-forwarded-proto）的存在或不存在决定，其名称是常规的，因此它应该适用于大多数前端代理。你可以通过向 application.properties 添加一些条目来打开阀门，如下面示例所示： 20 | 21 | server.tomcat.remote-ip-header=x-forwarded-for 22 | server.tomcat.protocol-header=x-forwarded-proto 23 | 24 | 这些属性中的任何一个的存在都会打开阀门。或者，你可以通过添加 TomcatServletWebServerFactory bean 来添加 RemoteIpValve。 25 | 26 | 要将 Spring Security 配置为要求所有（或某些）请求使用安全通道，请考虑添加你自己的 WebSecurityConfigurerAdapter，该类添加以下 HttpSecurity 配置： 27 | ``` 28 | @Configuration 29 | public class SslWebSecurityConfigurerAdapter extends WebSecurityConfigurerAdapter { 30 | 31 | @Override 32 | protected void configure(HttpSecurity http) throws Exception { 33 | // Customize the application security 34 | http.requiresChannel().anyRequest().requiresSecure(); 35 | } 36 | 37 | } 38 | ``` -------------------------------------------------------------------------------- /spring-boot/reference/09操作指南/90、热交换.md: -------------------------------------------------------------------------------- 1 | # 90、热交换 2 | 3 | Spring Boot 支持热交换。本节回答关于它如何工作的问题。 4 | 5 | ## 90.1、重新加载静态内容 6 | 7 | 热重新加载有几种选择。推荐的方法是使用 spring-boot-devtools，因为它提供了额外的开发时特性，例如，支持快速应用程序重启和 LiveReload，以及合理的开发时配置（例如模板缓存）。Devtools 通过监视类路径的更改来工作。这意味着必须 “构建” 静态资源更改才能使更改生效。默认情况下，当你保存更改时，这将在 Eclipse 中自动发生。在 IntelliJ IDEA 中，Make Project 命令触发必要的构建。由于[默认的重新启动排除](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/using-boot-devtools.html#using-boot-devtools-restart-exclude)，对静态资源的更改不会触发应用程序的重新启动。然而，它们确实触发了实时重新加载。 8 | 9 | 或者，在 IDE 中运行（特别是在调试时）是一种很好的开发方法（所有现代 IDE 都允许重新加载静态资源，通常也允许热交换 Java 类更改）。 10 | 11 | 最后，可以配置 [Maven 和 Gradle 插件](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/build-tool-plugins.html)（参见 addResources 属性）以支持从命令行运行，并直接从源代码重新加载静态文件。如果使用更高级的工具编写代码，则可以将其用于外部 css/js 编译器进程。 12 | 13 | ## 90.2、重新加载模板而不重新启动容器 14 | 15 | Spring Boot 支持的大多数模板技术都包含一个禁用缓存的配置选项（本文档稍后介绍）。如果你使用 spring-boot-devtools 模块，这些属性将在开发时自动为你配置。 16 | 17 | ### 90.2.1、Thymeleaf 模板 18 | 19 | 如果使用 Thymeleaf，请将 spring.thymeleaf.cache 设置为 false。有关其他 Thymeleaf 的自定义选项，请参见 [ThymeleafAutoConfiguration](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/thymeleaf/ThymeleafAutoConfiguration.java)。 20 | 21 | ### 90.2.2、FreeMarker 模板 22 | 23 | 如果使用 FreeMarker，请将 spring.freemarker.cache 设置为 false。有关其他 FreeMarker 的自定义选项，请参见 [FreeMarkerAutoConfiguration](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/freemarker/FreeMarkerAutoConfiguration.java)。 24 | 25 | ### 90.2.3、Groovy 模板 26 | 27 | 如果使用 Groovy 模板，请将 spring.groovy.template.cache 设置为 false。有关其他 Groovy 的自定义选项，请参见 [GroovyTemplateAutoConfiguration](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/groovy/template/GroovyTemplateAutoConfiguration.java)。 28 | 29 | ## 90.3、快速应用程序重新启动 30 | 31 | spring-boot-devtools 模块包括对自动应用程序重启的支持。虽然不像 JRebel 等技术那样快，但它通常比 “冷启动” 要快得多。在研究本文档后面讨论的一些更复杂的重新加载选项之前，你可能应该尝试一下。 32 | 33 | 有关更多详细信息，请参见[第 20 章：开发者工具](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/using-boot-devtools.html)。 34 | 35 | ## 90.4、重新加载 Java 类而不重新启动容器 36 | 37 | 许多现代 IDEs（Eclipse、IDEA和其他）支持字节码的热交换。因此，如果你所做的更改不影响类或方法签名，则它应该干净地重新加载，而不会产生任何副作用。 38 | -------------------------------------------------------------------------------- /spring-boot/reference/09操作指南/91、构建.md: -------------------------------------------------------------------------------- 1 | # 91、构建 2 | 3 | Spring Boot 包括 Maven 和 Gradle 的构建插件。本节回答有关这些插件的常见问题。 4 | 5 | ## 91.1、生成构建信息 6 | 7 | Maven 插件和 Gradle 插件都允许生成包含项目坐标、名称和版本的构建信息。还可以将插件配置为通过配置添加其他属性。当存在这样的文件时，Spring Boot 会自动配置 BuildProperties bean。 8 | 9 | 要使用 Maven 生成构建信息，请为 build-info 目标添加一个执行，如下面示例所示： 10 | ``` 11 | 12 | 13 | 14 | org.springframework.boot 15 | spring-boot-maven-plugin 16 | 2.1.6.RELEASE 17 | 18 | 19 | 20 | build-info 21 | 22 | 23 | 24 | 25 | 26 | 27 | ``` 28 | 提示：有关更多详细信息，请参见 [Spring Boot Maven 插件文档](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/maven-plugin)。 29 | 30 | 以下示例用 Gradle 做了同样的事情： 31 | ``` 32 | springBoot { 33 | buildInfo() 34 | } 35 | ``` 36 | 提示：有关更多详细信息，请参见 [Spring Boot Gradle 插件文档](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/gradle-plugin/reference/html/#integrating-with-actuator-build-info)。 37 | 38 | ## 91.2、生成 Git 信息 39 | 40 | Maven 和 Gradle 都允许生成一个 git.properties 文件，其中包含有关项目构建时 git 源代码存储库状态的信息。 41 | 42 | 对于 Maven 用户，spring-boot-starter-parent POM 包含一个预配置的插件来生成 git.properties 文件。要使用它，请在 POM 中添加以下声明： 43 | ``` 44 | 45 | 46 | 47 | pl.project13.maven 48 | git-commit-id-plugin 49 | 50 | 51 | 52 | ``` 53 | Gradle 用户可以通过使用 gradle-git-properties 插件获得相同的结果，如下面示例所示： 54 | ``` 55 | plugins { 56 | id "com.gorylenko.gradle-git-properties" version "1.5.1" 57 | } 58 | ``` 59 | 提示：git.properties 中的提交时间应该与以下格式匹配：yyyy-MM-dd’T’HH:mm:ssZ。这是上述两个插件的默认格式。使用这种格式可以将时间解析为 Date，当序列化为 JSON 时，其格式将由 Jackson 的日期序列化配置设置控制。 60 | 61 | ## 91.3、自定义依赖项版本 62 | 63 | 如果你使用直接或间接从 spring-boot-dependencies 继承的 Maven 构建（例如，spring-boot-starter-parent）但是要覆盖特定的第三方依赖项，可以添加适当的 元素。浏览 spring-boot-dependencies POM 以获取完整的属性列表。例如，要选择不同的 slf4j 版本，你需要添加以下属性： 64 | ``` 65 | 66 | 1.7.5 67 | 68 | ``` 69 | 注释：只有当 Maven 项目从 spring-boot-dependencies（直接或间接）时，这样做才有效。如果使用 import 在自己的 dependencyManagement 部分中添加了 spring-boot-dependencies，则必须自己重新定义工件，而不是重写属性。 70 | 71 | 警告：每个 Spring Boot 版本都是针对这组特定的第三方依赖项进行设计和测试的。重写版本可能会导致兼容性问题。 72 | 73 | 要覆盖 Gradle 中的依赖项版本，请参见 Gradle 插件文档的[这一部分](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/gradle-plugin/reference/html/#managing-dependencies-customizing)。 74 | 75 | ## 91.4、使用 Maven 创建可执行 JAR 76 | 77 | spring-boot-maven-plugin 可用于创建可执行的 “胖” JAR。如果你使用 spring-boot-starter-parent POM，则可以声明该插件，并且你的 jar 将按如下方式重新打包： 78 | ``` 79 | 80 | 81 | 82 | org.springframework.boot 83 | spring-boot-maven-plugin 84 | 85 | 86 | 87 | ``` 88 | 如果不使用父 POM，则仍然可以使用插件。但是，还必须添加 <executions> 部分，如下所示： 89 | ``` 90 | 91 | 92 | 93 | org.springframework.boot 94 | spring-boot-maven-plugin 95 | 2.1.6.RELEASE 96 | 97 | 98 | 99 | repackage 100 | 101 | 102 | 103 | 104 | 105 | 106 | ``` 107 | 有关完整的使用细节，请参阅[插件文档](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/maven-plugin/usage.html)。 108 | 109 | ## 91.5、使用 Spring Boot 应用程序作为依赖项 110 | 111 | 像 war 文件，Spring Boot 应用程序不打算用作依赖项。如果你的应用程序包含要与其他项目共享的类，建议的方法是将该代码移动到一个单独的模块中。然后，你的应用程序和其他项目可以依赖该单独的模块。 112 | 113 | 如果你不能按照上面的建议重新排列你的代码，Spring Boot 的 Maven 和 Gradle 插件必须被配置为生成一个单独的工件，它适合用作依赖项。可执行存档不能用作依赖项，因为可执行 jar 格式将应用程序类打包在 BOOT-INF/classes 中。这意味着当可执行 jar 用作依赖项时，找不到它们。 114 | 115 | 为了产生两个工件，一个可以用作依赖项，另一个是可执行的，必须指定一个分类器。此分类器应用于可执行的归档文件的名称，保留默认归档文件作为依赖项使用。 116 | 117 | 要在 Maven 中配置 exec 的分类器，可以使用以下配置： 118 | ``` 119 | 120 | 121 | 122 | org.springframework.boot 123 | spring-boot-maven-plugin 124 | 125 | exec 126 | 127 | 128 | 129 | 130 | ``` 131 | ## 91.6、在运行可执行 Jar 时提取特定库 132 | 133 | 可执行 jar 中的大多数嵌套库不需要解包就可以运行。然而，某些库可能有问题。例如，JRuby 包含其自己的嵌套 jar 支持，它假定 jruby-complete.jar 始终以其自身的权限作为文件直接可用。 134 | 135 | 为了处理任何有问题的库，你可以标记特定的嵌套 jar 应该在可执行 jar 第一次运行时自动解压缩。这种嵌套的 jar 写在 java.io.tmpdir 系统属性标识的临时目录下。 136 | 137 | 警告：应注意确保你的操作系统已配置，以便它不会删除在应用程序仍在运行时已解压缩到临时目录的 jar。 138 | 139 | 例如，为了指示应该使用 Maven 插件标记 JRuby 以进行解包，你可以添加以下配置： 140 | ``` 141 | 142 | 143 | 144 | org.springframework.boot 145 | spring-boot-maven-plugin 146 | 147 | 148 | 149 | org.jruby 150 | jruby-complete 151 | 152 | 153 | 154 | 155 | 156 | 157 | ``` 158 | ## 91.7、创建具有排除项的不可执行 JAR 159 | 160 | 通常，如果你有一个可执行和一个不可执行的 jar 作为两个独立的构建产品，可执行版本有额外的配置文件，这些文件在库 jar 中是不需要的。例如，application.yml 配置文件可能被排除在不可执行的 JAR 之外。 161 | 162 | 在 Maven 中，可执行 jar 必须是主要工件，你可以为库添加一个分类 jar，如下所示： 163 | ``` 164 | 165 | 166 | 167 | org.springframework.boot 168 | spring-boot-maven-plugin 169 | 170 | 171 | maven-jar-plugin 172 | 173 | 174 | lib 175 | package 176 | 177 | jar 178 | 179 | 180 | lib 181 | 182 | application.yml 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | ``` 191 | ## 91.8、远程调试使用 Maven 启动的 Spring Boot 应用程序 192 | 193 | 要将远程调试器附加到使用 Maven 启动的 Spring Boot 应用程序，可以使用 [maven 插件](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/maven-plugin)的 jvmArguments 属性。 194 | 195 | 有关详细信息，请参见[此示例](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/maven-plugin/examples/run-debug.html)。 196 | 197 | ## 91.9、不使用 spring-boot-antlib 从 Ant 构建可执行的归档文件 198 | 199 | 要使用 Ant 构建，你需要获取依赖项，编译，然后创建一个 jar 或 war 归档文件。要使其可执行，你可以使用 spring-boot-antlib 模块，也可以按照以下说明操作： 200 | 201 | （1）如果你正在构建一个 jar，请将应用程序的类和资源打包在嵌套的 BOOT-INF/classes 目录中。如果你正在构建一个 war，请像往常一样将应用程序的类打包在嵌套的 WEB-INF/classes 目录中。 202 | 203 | （2）将运行时依赖项添加到 jar 的嵌套 BOOT-INF/lib 目录或 war 的 WEB-INF/lib 目录中。记住不要压缩归档文件中的条目。 204 | 205 | （3）将 provided（嵌入式容器）依赖项添加到 jar 的嵌套 BOOT-INF/lib 目录或 war 的 WEB-INF/lib-provided 目录中。记住不要压缩归档文件中的条目。 206 | 207 | （4）在归档文件的根目录中添加 spring-boot-loader 类（以便 Main-Class 可用）。 208 | 209 | （5）使用适当的启动器（例如 jar 文件的 JarLauncher）作为清单中的 Main-Class 属性，并通过设置 Start-Class 属性将它主要需要的其他属性指定为清单条目。 210 | 211 | 下面的示例展示如何使用 Ant 构建可执行的归档文件： 212 | ``` 213 | 214 | 215 | 216 | 217 | 218 | 219 | 220 | 221 | 222 | 223 | 224 | 225 | 226 | 227 | 228 | 229 | 230 | 231 | 232 | 233 | 234 | ``` 235 | Ant 示例有一个 build.xml 文件，其中包含一个 manual 任务，如果你使用以下命令运行它，该任务应该可以工作： 236 | 237 | $ ant -lib clean manual 238 | 239 | 然后可以使用以下命令运行应用程序： 240 | 241 | $ java -jar target/*.jar -------------------------------------------------------------------------------- /spring-boot/reference/09操作指南/92、传统部署.md: -------------------------------------------------------------------------------- 1 | # 92、传统部署 2 | 3 | Spring Boot 支持传统部署以及更现代的部署形式。本节回答有关传统部署的常见问题。 4 | 5 | ## 92.1、创建可部署的 War 文件 6 | 7 | 警告：因为 Spring WebFlux 并不严格依赖于 Servlet API，并且应用程序默认部署在嵌入式 Reactor Netty 服务器上，所以 WebFlux 应用程序不支持 War 部署。 8 | 9 | 生成可部署的 war 文件的第一步是提供一个 SpringBootServletInitializer 子类并覆盖其 configure 方法。这样做可以利用 Spring Framework 的 Servlet 3.0 支持，并允许你在 servlet 容器启动应用程序时配置应用程序。通常，你应该更新应用程序的主类以扩展 SpringBootServletInitializer，如下面示例所示： 10 | ``` 11 | @SpringBootApplication 12 | public class Application extends SpringBootServletInitializer { 13 | 14 | @Override 15 | protected SpringApplicationBuilder configure(SpringApplicationBuilder application) { 16 | return application.sources(Application.class); 17 | } 18 | 19 | public static void main(String[] args) { 20 | SpringApplication.run(Application.class, args); 21 | } 22 | 23 | } 24 | ``` 25 | 下一步是更新构建配置，以便项目生成 war 文件而不是 jar 文件。如果你使用 Maven 和 spring-boot-starter-parent（为你配置 Maven 的 war 插件)，你需要做的就是修改 pom.xml 以将 packaging 更改为 war，如下： 26 | 27 | war 28 | 29 | 如果使用 Gradle，则需要修改 build.gradle 以将 war 插件应用于项目，如下所示： 30 | 31 | apply plugin: 'war' 32 | 33 | 该过程的最后一步是确保嵌入式 servlet 容器不会干扰 war 文件部署到的 servlet 容器。为此，你需要将嵌入式 servlet 容器依赖项标记为已提供。 34 | 35 | 如果使用 Maven，下面的示例将 servlet 容器（在本例中是 Tomcat）标记为已提供： 36 | ``` 37 | 38 | 39 | 40 | org.springframework.boot 41 | spring-boot-starter-tomcat 42 | provided 43 | 44 | 45 | 46 | ``` 47 | 如果使用 Gradle，下面的示例将 servlet 容器（在本例中是 Tomcat）标记为已提供： 48 | ``` 49 | dependencies { 50 | // … 51 | providedRuntime 'org.springframework.boot:spring-boot-starter-tomcat' 52 | // … 53 | } 54 | ``` 55 | 提示：providedRuntime 优于 Gradle 的 compileOnly 配置。除其他限制外，compileOnly 依赖项不在测试的类路径上，因此任何基于 web 的集成测试都失败。 56 | 57 | 如果使用 Spring Boot 构建工具，将嵌入式 servlet 容器依赖项标记为 provided，会生成一个可执行 war 文件，其中提供的依赖项打包在 lib-provided 目录中。这意味着，除了可以部署到 servlet 容器之外，你还可以通过在命令行中使用 java -jar 来运行应用程序。[](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/build-tool-plugins.html) 58 | 59 | 提示：请看一看 Spring Boot 的示例应用程序，它是[基于 Maven 的前面描述的配置示例](https://github.com/spring-projects/spring-boot/tree/v2.1.6.RELEASE/spring-boot-samples/spring-boot-sample-traditional/pom.xml)。 60 | 61 | ## 92.2、将现有应用程序转换为 Spring Boot 62 | 63 | 对于非 web 应用程序，将现有的 Spring 应用程序转换为 Spring Boot 应用程序应该很容易。为此，请放弃创建 ApplicationContext 的代码，并将其替换为对 SpringApplication 或 SpringApplicationBuilder 的调用。Spring MVC web 应用程序通常可以首先创建可部署的 war 应用程序，然后将其迁移到可执行的 war 或 jar。请参阅[将 jar 转换为 war 的入门指南](https://spring.io/guides/gs/convert-jar-to-war/)。 64 | 65 | 要通过扩展 SpringBootServletInitializer（例如，在名为 Application 的类中）并添加 Spring Boot @SpringBootApplication 注解来创建可部署的 war，请使用类似于以下示例中所示的代码： 66 | ``` 67 | @SpringBootApplication 68 | public class Application extends SpringBootServletInitializer { 69 | 70 | @Override 71 | protected SpringApplicationBuilder configure(SpringApplicationBuilder application) { 72 | // Customize the application or call application.sources(...) to add sources 73 | // Since our example is itself a @Configuration class (via @SpringBootApplication) 74 | // we actually don't need to override this method. 75 | return application; 76 | } 77 | 78 | } 79 | ``` 80 | 记住，无论你在 sources 中放入什么，都只是一个 Spring ApplicationContext。正常情况下，任何已经起作用的东西都应该在这里起作用。可能有一些 bean 可以在以后删除，并让 Spring Boot 为它们提供自己的默认值，但是在需要这样做之前，应该可以得到一些有用的东西。 81 | 82 | 静态资源可以移动到类路径根目录中的 /public（/static、/resources 或 /META-INF/resources）。这同样适用于messages.properties（Spring Boot 自动在类路径的根目录中检测到）。 83 | 84 | Spring DispatcherServlet 和 Spring Security 的常规用法不需要进一步更改。如果应用程序中有其他功能（例如，使用其他 servlet 或过滤器），则可能需要向 Application 上下文添加一些配置，方法是替换 web.xml 中的这些元素，如下所示： 85 | 86 | （1）Servlet 或 ServletRegistrationBean 类型的 @Bean 将该 bean 安装在容器中，就好像它是 web.xml 中的 <servlet/> 和<servlet-mapping/>。 87 | 88 | （2）Filter 或 FilterRegistrationBean 类型的 @Bean 的行为类似（作为 <ilter/> 和 <filter-mapping/>）。 89 | 90 | （3）XML 文件中的 ApplicationContext 可以通过应用程序中的 @ImportResource 添加。或者，已经大量使用注解配置的简单情况可以在几行中重新创建为 @Bean 定义。 91 | 92 | 一旦 war 文件工作，你可以通过向 Application 添加一个 main 方法来使其可执行，如下面示例所示： 93 | ``` 94 | public static void main(String[] args) { 95 | SpringApplication.run(Application.class, args); 96 | } 97 | ``` 98 | >注释： 99 | > 100 | >如果你打算以 war 或可执行应用程序的形式启动你的应用程序，你需要在一个方法中共享构建器的自定义设置，该方法既可用于 SpringBootServletInitializer 回调，也可用于类似以下内容的类中的 main 方法： 101 | >``` 102 | >@SpringBootApplication 103 | >public class Application extends SpringBootServletInitializer { 104 | > 105 | > @Override 106 | > protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) { 107 | > return configureApplication(builder); 108 | > } 109 | > 110 | > public static void main(String[] args) { 111 | > configureApplication(new SpringApplicationBuilder()).run(args); 112 | > } 113 | > 114 | > private static SpringApplicationBuilder configureApplication(SpringApplicationBuilder builder) { 115 | > return builder.sources(Application.class).bannerMode(Banner.Mode.OFF); 116 | > } 117 | > 118 | >} 119 | >``` 120 | 应用程序可以分为多个类别： 121 | 122 | （1）Servlet 3.0 + 没有 web.xml 的应用程序。 123 | （2）具有 web.xml 的应用程序。 124 | （3）具有上下文层次结构的应用程序。 125 | （4）没有上下文层次结构的应用程序。 126 | 127 | 所有这些都应该易于转变，但每一个都可能需要稍微不同的技术。 128 | 129 | 如果 Servlet 3.0+ 应用程序已经使用了 Spring Servlet 3.0+ 初始化器支持类，那么它们可能很容易转换。通常，来自现有 WebApplicationInitializer 的所有代码都可以移动到 SpringBootServletInitializer 中。如果现有应用程序有多个 ApplicationContext（例如，如果它使用 AbstractDispatcherServletInitializer），则可以将所有上下文源合并到单个 SpringApplication 中。你可能会遇到的主要复杂情况是，如果合并不起作用，你需要维护上下文层次结构。有关示例，请参阅有关构建层次结构的条目。包含 web 特定功能的现有父上下文通常需要被分解，以便所有 ServletContextAware 组件都在子上下文中。[](https://docs.spring.io/spring-boot/docs/2.1.6.RELEASE/reference/html/howto-spring-boot-application.html#howto-build-an-application-context-hierarchy) 130 | 131 | 尚未成为 Spring 应用程序的应用程序可能可转换为 Spring Boot 应用程序，前面提到的指南可能会有所帮助。但是，你可能还会遇到问题。在这种情况下，我们建议[用 spring-boot 的标签在 Stack Overflow 上询问问题](https://stackoverflow.com/questions/tagged/spring-boot)。 132 | 133 | ## 92.3、向 WebLogic 部署 WAR 134 | 135 | 要将 Spring Boot 应用程序部署到 WebLogic，必须确保 servlet 初始化器直接实现 WebApplicationInitializer（即使是从已经实现它的基类继承）。 136 | 137 | WebLogic 的典型初始化器应类似于以下示例： 138 | ``` 139 | import org.springframework.boot.autoconfigure.SpringBootApplication; 140 | import org.springframework.boot.web.servlet.support.SpringBootServletInitializer; 141 | import org.springframework.web.WebApplicationInitializer; 142 | 143 | @SpringBootApplication 144 | public class MyApplication extends SpringBootServletInitializer implements WebApplicationInitializer { 145 | 146 | } 147 | ``` 148 | 如果你使用 Logback，你还需要告诉 WebLogic 更喜欢打包版本，而不是服务器预装的版本。你可以通过添加包含以下内容的 WEB-INF/weblogic.xml 文件来执行此操作： 149 | ``` 150 | 151 | 158 | 159 | 160 | org.slf4j 161 | 162 | 163 | 164 | ``` 165 | ## 92.4、用 Jedis 代替 Lettuce 166 | 167 | 默认情况下，Spring Boot starter（spring-boot-starter-data-redis）使用 [Lettuce](https://github.com/lettuce-io/lettuce-core/)。你需要排除该依赖项，并包含 [Jedis](https://github.com/xetorthio/jedis/) 依赖项。Spring Boot 管理这些依赖项，以帮助使此过程尽可能简单。 168 | 169 | 下面的示例展示如何在 Maven 中执行此操作： 170 | ``` 171 | 172 | org.springframework.boot 173 | spring-boot-starter-data-redis 174 | 175 | 176 | io.lettuce 177 | lettuce-core 178 | 179 | 180 | 181 | 182 | redis.clients 183 | jedis 184 | 185 | ``` 186 | 下面的示例展示如何在 Gradle 中执行此操作： 187 | ``` 188 | configurations { 189 | compile.exclude module: "lettuce" 190 | } 191 | 192 | dependencies { 193 | compile("redis.clients:jedis") 194 | // ... 195 | } 196 | ``` -------------------------------------------------------------------------------- /spring-boot/reference/10附录/D、测试自动配置注解.md: -------------------------------------------------------------------------------- 1 | # D、测试自动配置注解 2 | 3 | 下表列出了可用于测试应用程序切片的各种 @… Test 注解以及默认情况下它们导入的自动配置： 4 | 5 | |测试切片 |导入的自动配置| 6 | |---|---| 7 | |@DataJdbcTest |org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration org.springframework.boot.test.autoconfigure.jdbc.TestDatabaseAutoConfiguration| 8 | |@DataJpaTest |org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration org.springframework.boot.test.autoconfigure.jdbc.TestDatabaseAutoConfiguration org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManagerAutoConfiguration| 9 | |@DataLdapTest |org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration| 10 | |@DataMongoTest |org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration org.springframework.boot.autoconfigure.data.mongo.MongoReactiveDataAutoConfiguration org.springframework.boot.autoconfigure.data.mongo.MongoReactiveRepositoriesAutoConfiguration org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration org.springframework.boot.autoconfigure.mongo.MongoReactiveAutoConfiguration org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration| 11 | |@DataNeo4jTest |org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration| 12 | |@DataRedisTest |org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration| 13 | |@JdbcTest |org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration org.springframework.boot.test.autoconfigure.jdbc.TestDatabaseAutoConfiguration| 14 | |@JooqTest |org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration| 15 | |@JsonTest |org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration org.springframework.boot.autoconfigure.jsonb.JsonbAutoConfiguration org.springframework.boot.test.autoconfigure.json.JsonTestersAutoConfiguration| 16 | |@RestClientTest |org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration org.springframework.boot.autoconfigure.http.codec.CodecsAutoConfiguration org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration org.springframework.boot.autoconfigure.jsonb.JsonbAutoConfiguration org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration org.springframework.boot.autoconfigure.web.reactive.function.client.WebClientAutoConfiguration org.springframework.boot.test.autoconfigure.web.client.MockRestServiceServerAutoConfiguration org.springframework.boot.test.autoconfigure.web.client.WebClientRestTemplateAutoConfiguration| 17 | |@WebFluxTest |org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration org.springframework.boot.autoconfigure.http.codec.CodecsAutoConfiguration org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration org.springframework.boot.autoconfigure.jsonb.JsonbAutoConfiguration org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration org.springframework.boot.autoconfigure.security.reactive.ReactiveSecurityAutoConfiguration org.springframework.boot.autoconfigure.security.reactive.ReactiveUserDetailsServiceAutoConfiguration org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration org.springframework.boot.autoconfigure.web.reactive.error.ErrorWebFluxAutoConfiguration org.springframework.boot.test.autoconfigure.web.reactive.WebTestClientAutoConfiguration| 18 | |@WebMvcTest |org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration org.springframework.boot.autoconfigure.jsonb.JsonbAutoConfiguration org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration org.springframework.boot.test.autoconfigure.web.servlet.MockMvcAutoConfiguration org.springframework.boot.test.autoconfigure.web.servlet.MockMvcSecurityAutoConfiguration org.springframework.boot.test.autoconfigure.web.servlet.MockMvcWebClientAutoConfiguration org.springframework.boot.test.autoconfigure.web.servlet.MockMvcWebDriverAutoConfiguration| -------------------------------------------------------------------------------- /spring-boot/reference/10附录/E、可执行Jar格式.md: -------------------------------------------------------------------------------- 1 | # E、可执行 Jar 格式 2 | 3 | spring-boot-loader 模块允许 Spring Boot 支持可执行 jar 和 war 文件。如果你使用 Maven 插件或 Gradle 插件，可执行的 jar 会自动生成，你通常不需要知道它们是如何工作的细节。 4 | 5 | 如果你需要从不同的构建系统创建可执行 jar，或者如果你只是对底层技术感到好奇，本节提供了一些背景。 6 | 7 | ## E.1、嵌套 JARs 8 | 9 | Java 没有提供任何标准的方式来加载嵌套的 jar 文件（即，本身包含在 jar 中的 jar 文件）。如果你需要分发一个独立的应用程序，而无需解包即可从命令行运行，这可能是有问题的。 10 | 11 | 为了解决这个问题，许多开发者使用“shaded” jars。shaded jar 将所有 jars 的所有类打包成一个“uber jar”。shaded jar 的问题是很难看到哪些库实际上在你的应用程序中。如果在多个 jar 中使用相同的文件名（但内容不同），也可能会有问题。Spring Boot 采用了一种不同的方法，可以让你直接嵌套 jars。 12 | 13 | ### E.1.1、可执行 Jar 文件结构 14 | 15 | 与 Spring Boot Loader 兼容的 jar 文件应按以下方式构建： 16 | 17 | example.jar 18 | | 19 | +-META-INF 20 | | +-MANIFEST.MF 21 | +-org 22 | | +-springframework 23 | | +-boot 24 | | +-loader 25 | | +- 26 | +-BOOT-INF 27 | +-classes 28 | | +-mycompany 29 | | +-project 30 | | +-YourClasses.class 31 | +-lib 32 | +-dependency1.jar 33 | +-dependency2.jar 34 | 35 | 应用程序类应该放在嵌套的 BOOT-INF/classes 目录中。依赖项应该放在嵌套的 BOOT-INF/lib 目录中。 36 | 37 | ### E.1.2、可执行 War 文件结构 38 | 39 | 与 Spring Boot Loader 兼容的 war 文件应按以下方式构建： 40 | 41 | example.war 42 | | 43 | +-META-INF 44 | | +-MANIFEST.MF 45 | +-org 46 | | +-springframework 47 | | +-boot 48 | | +-loader 49 | | +- 50 | +-WEB-INF 51 | +-classes 52 | | +-com 53 | | +-mycompany 54 | | +-project 55 | | +-YourClasses.class 56 | +-lib 57 | | +-dependency1.jar 58 | | +-dependency2.jar 59 | +-lib-provided 60 | +-servlet-api.jar 61 | +-dependency3.jar 62 | 63 | 依赖项应放在嵌套的 WEB-INF/lib 目录中。运行嵌入式时需要但部署到传统 web 容器时不需要的任何依赖项都应该放在 WEB-INF/lib-provided 中。 64 | 65 | ## E.2、Spring Boot 的 JarFile 类 66 | 67 | 用于支持加载嵌套 jar 的核心类是 org.springframework.boot.loader.jar.JarFile。它允许你从标准 jar 文件或嵌套的子 jar 数据加载 jar 内容。首次加载时，每个 JarEntry 的位置将映射到外部 jar 的物理文件偏移量，如下面示例所示： 68 | 69 | myapp.jar 70 | +-------------------+-------------------------+ 71 | | /BOOT-INF/classes | /BOOT-INF/lib/mylib.jar | 72 | |+-----------------+||+-----------+----------+| 73 | || A.class ||| B.class | C.class || 74 | |+-----------------+||+-----------+----------+| 75 | +-------------------+-------------------------+ 76 | ^ ^ ^ 77 | 0063 3452 3980 78 | 79 | 上面的示例展示了如何在 myapp.jar 中的 /BOOT-INF/classes 中的 0063 位置找到 A.class。嵌套 jar 中的 B.class 实际上可以在 myapp.jar 中的 3452 位置找到，而 C.class 位于 3980 位置。 80 | 81 | 有了这些信息，我们可以通过寻找外部 jar 的适当部分来加载特定的嵌套条目。我们不需要解压缩归档文件，也不需要将所有输入数据读入内存。 82 | 83 | ### E.2.1、与标准 Java JarFile 的兼容性 84 | 85 | Spring Boot Loader 努力保持与现有代码和库兼容。org.springframework.boot.loader.jar.JarFile 继承自 java.util.jar.JarFile，应该作为一个替换项。getURL() 方法返回一个 URL，该 URL 打开一个与 java.net.JarURLConnection 兼容的连接，并且可以与 Java 的 URLClassLoader 一起使用。 86 | 87 | ## E.3、启动可执行 Jars 88 | 89 | org.springframework.boot.loader.Launcher 类是一个特殊的引导类，用作可执行 jar 的主要入口点。它是 jar 文件中的实际 Main-Class，用于设置适当的 URLClassLoader 并最终调用 main() 方法。 90 | 91 | 有三个启动器子类（JarLauncher、WarLauncher 和 PropertiesLauncher）。它们的目的是从目录（与类路径上的显式文件相反）中的嵌套 jar 文件或 war 文件加载资源 （.class 文件等）。在 JarLauncher 和 WarLauncher 的情况下，嵌套路径是固定的。JarLauncher 在 BOOT-INF/lib/ 中查找，而 WarLauncher 在 WEB-INF/lib/ 和 WEB-INF/lib-provided/ 中查找。如果需要更多，可以在这些位置添加额外的 jars。默认情况下，PropertiesLauncher 在应用程序归档文件的 BOOT-INF/lib/ 中查找，但你可以通过在 loader.properties 中设置名为 LOADER_PATH 或 loader.path 的环境变量（这是归档文件中目录、归档文件或目录的逗号分隔列表）来添加其他位置。 92 | 93 | ### E.3.1、启动器清单 94 | 95 | 你需要指定适当的 Launcher 作为 META-INF/MANIFEST.MF 的 Main-Class 属性。要启动的实际类（即包含 main 方法的类）应在 Start-Class 属性中指定。 96 | 97 | 以下示例展示可执行 jar 文件的典型 MANIFEST.MF： 98 | 99 | Main-Class: org.springframework.boot.loader.JarLauncher 100 | Start-Class: com.mycompany.project.MyApplication 101 | 102 | 对于 war 文件，如下所示： 103 | 104 | Main-Class: org.springframework.boot.loader.WarLauncher 105 | Start-Class: com.mycompany.project.MyApplication 106 | 107 | 注释：不需要在清单文件中指定 Class-Path 项。类路径是从嵌套的 jar 中推导出来的。 108 | 109 | ### E.3.2、Exploded 归档文件 110 | 111 | 某些 PaaS 实现可能会选择在运行之前解压缩归档文件。例如，Cloud Foundry 以这种方式运行。你可以通过启动相应的启动器来运行解压缩的归档文件，如下所示： 112 | 113 | $ unzip -q myapp.jar 114 | $ java org.springframework.boot.loader.JarLauncher 115 | 116 | ## E.4、PropertiesLauncher 的功能 117 | 118 | PropertiesLauncher 有一些特殊功能，可以使用外部属性（系统属性、环境变量、清单条目或 loader.properties）启用。下表描述了这些属性： 119 | 120 | |键 |用途| 121 | |---|---| 122 | |loader.path |逗号分隔的类路径，例如：lib、${HOME}/app/lib。前面的条目优先，就像 javac 命令行上的常规 -classpath 一样。| 123 | |loader.home |用于解析 loader.path 中的相对路径。例如，给定 loader.path=lib，则 ${loader.home}/lib 是一个类路径位置（以及该目录中的所有 jar 文件）。此属性也用于定位 loader.properties 文件，如以下示例 /opt/app 中，它默认为 ${user.dir}。| 124 | |loader.args |主方法的默认参数（空格分隔）。| 125 | |loader.main |要启动的主类的名称（例如：com.app.Application）。| 126 | |loader.config.name |属性文件的名称（例如，launcher）它默认为 loader。| 127 | |loader.config.location |属性文件的路径（例如，classpath:loader.properties）。默认为 loader.properties。| 128 | |loader.system |布尔标志表示所有属性都应该添加到系统属性中，默认为 false。| 129 | 130 | 当指定为环境变量或清单项时，应使用以下名称： 131 | 132 | |键 |清单项 |环境变量| 133 | |---|---|---| 134 | |loader.path |Loader-Path |LOADER_PATH| 135 | |loader.home |Loader-Home |LOADER_HOME| 136 | |loader.args |Loader-Args |LOADER_ARGS| 137 | |loader.main |Start-Class |LOADER_MAIN| 138 | |loader.config.location |Loader-Config-Location |LOADER_CONFIG_LOCATION| 139 | |loader.system |Loader-System |LOADER_SYSTEM| 140 | 141 | 提示：构建插件会在构建 fat jar 时自动将 Main-Class 属性移动到 Start-Class。如果使用它，请使用 Main-class 属性并省略 Start-Class 来指定要启动的类的名称。 142 | 143 | 以下规则适用于和 PropertiesLauncher 一起使用： 144 | 145 | （1）在 loader.home 中搜索 loader.properties，然后在类路径的根目录中搜索，然后在类路径 /BOOT-INF/classes 中搜索。使用具有该名称的文件存在的第一个位置。 146 | （2）仅当未指定 loader.config.location 时，loader.home 才是其他属性文件（覆盖默认值）的目录位置。 147 | （3）loader.path 可以包含目录（递归扫描 jar 和 zip 文件）、归档文件路径、存档中扫描 jar 文件的目录（例如：dependencies.jar!/lib）或通配符模式（用于默认的 JVM 行为）。归档文件路径可以相对于 loader.home 或文件系统中带有 jar:file: 前缀的任何位置。 148 | （4）loader.path（如果为空）默认为 BOOT-INF/lib（表示本地目录或嵌套目录（如果从归档文件运行））。因此，当没有提供额外的配置时，PropertiesLauncher 的行为与 JarLauncher 相同。 149 | （5）无法使用 loader.path 配置 loader.properties 的位置（启动 PropertiesLauncher 时用于搜索后者的类路径是 JVM 类路径）。 150 | （6）占位符替换是在使用前从系统和环境变量加上属性文件本身对所有值进行的。 151 | （7）属性的搜索顺序（在多个地方查找是有意义的）是环境变量、系统属性、loader.properties、分解的归档文件清单和归档文件清单。 152 | 153 | ## E.5、可执行 Jar 的限制 154 | 155 | 使用 Spring Boot Loader 打包的应用程序时，需要考虑以下限制： 156 | 157 | （1）Zip 条目压缩：嵌套 jar 的 ZipEntry 必须使用 ZipEntry.STORED 方法保存。这是必需的，以便我们可以直接查找嵌套 jar 中的单个内容。嵌套 jar 文件本身的内容仍然可以压缩，就像外部 jar 中的任何其他条目也可以压缩一样。 158 | 159 | （2）系统类加载器: 启动的应用程序在加载类时应该使用 Thread.getContextClassLoader()（大多数库和框架默认都这样做）。尝试用 ClassLoader.getSystemClassLoader() 加载嵌套的 jar 类失败。java.util.Logging 始终使用系统类加载器。因此，你应该考虑不同的日志实现。 160 | 161 | ## E.6、备选的单个 Jar 解决方案 162 | 163 | 如果上述限制意味着你不能使用 Spring Boot Loader，请考虑以下替代方案： 164 | 165 | （1）[Maven Shade Plugin](https://maven.apache.org/plugins/maven-shade-plugin/) 166 | 167 | （2）[JarClassLoader](http://www.jdotsoft.com/JarClassLoader.php) 168 | 169 | （3）[OneJar](https://sourceforge.net/projects/one-jar/) 170 | 171 | （4）[Gradle Shadow Plugin](https://imperceptiblethoughts.com/shadow/) 172 | -------------------------------------------------------------------------------- /spring-boot/src/main/java/cn/jijicai/springboot/Example.java: -------------------------------------------------------------------------------- 1 | package cn.jijicai.springboot; 2 | 3 | import org.springframework.boot.SpringApplication; 4 | import org.springframework.boot.autoconfigure.EnableAutoConfiguration; 5 | import org.springframework.web.bind.annotation.RequestMapping; 6 | import org.springframework.web.bind.annotation.RestController; 7 | 8 | @RestController 9 | @EnableAutoConfiguration 10 | public class Example { 11 | 12 | @RequestMapping("/") 13 | String home(){ 14 | return "Hello World!"; 15 | } 16 | 17 | public static void main(String[] args){ 18 | SpringApplication.run(Example.class,args); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /spring-boot/src/main/java/cn/jijicai/springboot/MyConfiguration.java: -------------------------------------------------------------------------------- 1 | package cn.jijicai.springboot; 2 | 3 | import org.springframework.context.annotation.ComponentScan; 4 | import org.springframework.context.annotation.Configuration; 5 | import org.springframework.context.annotation.Import; 6 | import org.springframework.context.annotation.ImportResource; 7 | 8 | @Configuration 9 | //@Import("") 10 | //@ComponentScan 11 | //@ImportResource 12 | public class MyConfiguration { 13 | } 14 | -------------------------------------------------------------------------------- /spring-boot/src/main/resources/banner.txt: -------------------------------------------------------------------------------- 1 | ${Ansi.NAME} ${AnsiColor.NAME} 2 | 3 | ${spring-boot.version} -------------------------------------------------------------------------------- /spring-framework/reference/00Spring框架文档/00、Spring框架文档.md: -------------------------------------------------------------------------------- 1 | # Spring Framework 文档 2 | 3 | **版本 5.2.4.RELEASE** 4 | 5 | 更新内容、升级说明、支持的版本和其他主题，独立于发布节奏，它们在项目的 [Github Wiki](https://github.com/spring-projects/spring-framework/wiki) 上进行外部维护。 6 | 7 | ||| 8 | |---|---| 9 | |[概述](https://docs.spring.io/spring/docs/5.2.4.RELEASE/spring-framework-reference/overview.html#overview) |历史、设计理念、反馈、入门。| 10 | |[核心](https://docs.spring.io/spring/docs/5.2.4.RELEASE/spring-framework-reference/core.html#spring-core) |IoC 容器、事件、资源、 i18n 、验证、数据绑定、类型转换、 SpEL 、 AOP。| 11 | |[测试](https://docs.spring.io/spring/docs/5.2.4.RELEASE/spring-framework-reference/testing.html#testing) |模拟对象、 TestContext 框架、 Spring MVC 测试、 WebTestClient。| 12 | |[数据访问](https://docs.spring.io/spring/docs/5.2.4.RELEASE/spring-framework-reference/data-access.html#spring-data-tier) |事务、 DAO 支持、 JDBC 、 O/R 映射、 XML 编组。| 13 | |[Web Servlet](https://docs.spring.io/spring/docs/5.2.4.RELEASE/spring-framework-reference/web.html#spring-web) |Spring MVC、WebSocket、SockJS、STOMP 消息。| 14 | |[Web Reactive](https://docs.spring.io/spring/docs/5.2.4.RELEASE/spring-framework-reference/web-reactive.html#spring-webflux) |Spring WebFlux、WebClient、WebSocket。| 15 | |[集成](https://docs.spring.io/spring/docs/5.2.4.RELEASE/spring-framework-reference/integration.html#spring-integration) |远程处理、JMS、JCA、JMX、电子邮件、任务、调度、缓存。| 16 | |[语言](https://docs.spring.io/spring/docs/5.2.4.RELEASE/spring-framework-reference/languages.html#languages) |Kotlin、Groovy、动态语言。| 17 | 18 | 19 | Rod Johnson、Juergen Hoeller、Keith Donald、Colin Sampaleanu、Rob Harrop、Thomas Risberg、Alef Arendsen、Darren Davison、Dmitriy Kopylenko、Mark Pollack、Thierry Templier、Erwin Vervaet、Portia Tung、Ben Hale、Adrian Colyer、John Lewis、Costin Leau、Mark Fisher、Sam Brannen、Ramnivas Laddad、Arjen Poutsma、Chris Beams、Tareq Abedrabbo、Andy Clement、Dave Syer、Oliver Gierke、Rossen Stoyanchev、Phillip Webb、Rob Winch、Brian Clozel、Stephane Nicoll、Sebastien Deleuze、Jay Bryant 20 | 21 | 版权 ©2002-2019 Pivotal，股份有限公司（Inc）。保留所有权利。 22 | 23 | 本文档的副本可以供你自己使用并分发给他人，前提是你不对此类副本收取任何费用，并且每份副本都包含本版权声明, 无论是印刷还是电子发行。 24 | 25 | **版本 5.2.4.RELEASE** 26 | 27 | 最后更新时间:2020-02-25 16:33:34 UTC 28 | -------------------------------------------------------------------------------- /spring-framework/reference/01概述/01、Spring框架概述.md: -------------------------------------------------------------------------------- 1 | # Spring 框架概述 2 | 3 | Spring 使创建 Java 企业应用程序变得容易。它提供了在企业环境中使用 Java 语言所需的一切，并支持作为 JVM 上的替代语言的 Groovy 和 Kotlin, 并具有根据应用程序需求创建多种体系结构的灵活性。从 Spring Framework 5.1 开始，Spring 需要 JDK 8 + (Java SE 8 +)，并为 JDK 11 LTS 提供开箱即用的支持。建议使用 Java SE 8 update 60 作为 Java 8 的最低补丁版本，但通常建议使用最近的补丁版本。 4 | 5 | Spring 支持广泛的应用场景。在大型企业中，应用程序通常存在很长时间，并且必须在 JDK 和应用服务器上运行，其升级周期超出了开发者的控制范围。其他的可以作为单个 jar 运行，并嵌入服务器，可能在云环境中。然而，其他可能是不需要服务器的独立应用程序 (如批处理或集成工作负载)。 6 | 7 | Spring 是开源的。它有一个庞大而活跃的社区，根据不同的现实世界用例提供持续的反馈。这帮助 Spring 在很长一段时间内成功进化。 8 | 9 | # 1、我们所说的“Spring” 10 | 11 | 术语 “Spring” 在不同的上下文中意味着不同的东西。它可以用来指代 Spring Framework 项目本身，这就是它全部开始的地方。随着时间的推移，其他 Spring 项目已经建立在 Spring Framework 之上。大多数情况下，当人们说 “Spring” 时，他们指的是整个项目家族。本参考文档侧重于基础: Spring Framework 本身。 12 | 13 | Spring Framework 分为几个模块。应用程序可以选择他们需要的模块。核心是核心容器的模块，包括配置模型和依赖注入机制。除此之外，Spring Framework 还为不同的应用程序体系结构提供基础支持，包括消息传递、事务数据和持久性以及 web。它还包括基于 Servlet 的 Spring MVC web 框架和并行的 Spring WebFlux 反应式 web 框架。 14 | 15 | 关于模块的说明：Spring 的框架 jars 允许部署到 JDK 9 的模块路径（“Jigsaw”）。为了在支持 Jigsaw 的应用程序中使用，Spring Framework 5 jars 附带了“Automatic Module Name”清单条目，这些条目定义了独立于 jar 工件名（jar 遵循与“-”而不是“.”相同的命名模式，例如“spring-core”和“spring-context”）的稳定的语言级模块名（“spring.core”、“spring.context”等）。当然，Spring 的框架 jars 在 JDK 8 和 9+ 的类路径上仍然运行良好。 16 | 17 | # 2、Spring 和 Spring 框架的历史 18 | 19 | Spring 作为对早期 J2EE 规范复杂性的回应，于 2003年诞生。虽然有些人认为 Java EE 和 Spring 是竞争对手，但 Spring 实际上是对 Java EE 的补充。Spring 编程模型不包含 Java EE 平台规范; 相反，它与 EE umbrella 中精心挑选的各个规范集成： 20 | 21 | （1）[Servlet API (JSR 340)](https://jcp.org/en/jsr/detail?id=340) 22 | 23 | （2）[WebSocket API (JSR 356)](https://www.jcp.org/en/jsr/detail?id=356) 24 | 25 | （3）[Concurrency Utilities (JSR 236)](https://www.jcp.org/en/jsr/detail?id=236) 26 | 27 | （4）[JSON Binding API (JSR 367)](https://jcp.org/en/jsr/detail?id=367) 28 | 29 | （5）[Bean Validation (JSR 303)](https://jcp.org/en/jsr/detail?id=303) 30 | 31 | （6）[JPA (JSR 338)](https://jcp.org/en/jsr/detail?id=338) 32 | 33 | （7）[JMS (JSR 914)](https://jcp.org/en/jsr/detail?id=914) 34 | 35 | （8）以及 JTA/JCA 事务协调设置 (如有必要)。 36 | 37 | Spring Framework 还支持依赖注入（JSR 330）和公共注释（JSR 250）规范，应用程序开发者可以选择使用这些规范，而不是 Spring Framework 提供的特定于 Spring 的机制。 38 | 39 | 从 Spring Framework 5.0 开始，Spring 至少要求 Java EE 7 级别 (例如：Servlet 3.1+、JPA 2.1+) -- 同时在运行时提供与 Java EE 8 级别的更新 API 的开箱即用集成 (例如：Servlet 4.0、JSON 绑定 API) 在运行时遇到。这使 Spring 与例如 Tomcat 8 和 9 、 WebSphere 9 和 JBoss EAP 7 完全兼容。 40 | 41 | 随着时间的推移，Java EE 在应用程序开发中的作用已经发生了变化。在早期的 Java EE 和 Spring 中，创建应用程序是为了部署到应用服务器。今天，在 Spring Boot 的帮助下，应用程序以一种 devops 和云友好的方式创建，Servlet 容器嵌入并进行了简单的更改。从 Spring Framework 5 开始，WebFlux 应用程序甚至不直接使用 Servlet API，并且可以在不是 Servlet 容器的服务器 (如 Netty) 上运行。 42 | 43 | Spring 继续创新和发展。除了 Spring 框架，还有其他项目，如 Spring Boot 、 Spring Security 、 Spring Data 、 Spring Cloud 、 Spring Batch 等。重要的是要记住，每个项目都有自己的源代码存储库、问题跟踪器和发布节奏。有关 Spring 项目的完整列表，请参见 spring.io/projects。 44 | 45 | # 3、设计理念 46 | 47 | 当你学习一个框架时，不仅要知道它做了什么，还要知道它遵循了什么原则。以下是 Spring Framework 的指导原则： 48 | 49 | （1）在每个级别提供选择。Spring 允许你尽可能晚地推迟设计决策。例如，你可以通过配置切换持久性提供程序，而无需更改代码。对于许多其他基础设施问题以及与第三方 APIs 的集成也是如此。 50 | 51 | （2）适应不同的视角。Spring 拥抱灵活性，对事情应该如何做并不固执己见。它支持多种不同视角的应用需求。 52 | 53 | （3）保持强大的向后兼容性。Spring 的进化已经被精心管理，以迫使版本之间很少有突破性的变化。Spring 支持精心选择的一系列 JDK 版本和第三方库，以便于维护依赖于Spring的应用程序和库。 54 | 55 | （4）关心 API 设计。Spring 团队花了大量的精力和时间来制作直观的 API，这些 API 可以在很多版本和很多年中使用。 56 | 57 | （5）为代码质量设定高标准。Spring 框架非常强调有意义的、当前的和精确的 javadoc。这是少数几个可以声明干净的代码结构而包之间没有循环依赖关系的项目之一。 58 | 59 | # 4、反馈和贡献 60 | 61 | 对于如何回答（how-to）问题或诊断或调试问题，我们建议使用 StackOverflow，我们有一个问题页面，列出了建议使用的标签。如果你相当确定 Spring Framework 中存在问题或想要建议一个功能，请使用 [GitHub Issues](https://github.com/spring-projects/spring-framework/issues)。 62 | 63 | 如果你有解决方案或建议的修复方案，可以在 Github 上提交 pull 请求。但是，请记住，对于除了最琐碎的问题之外的所有问题，我们都希望在问题跟踪器中提交一张罚单，在那里进行讨论，并留下记录以供将来参考。 64 | 65 | 有关更多详细信息，请参见 [CONTRIBUTING](https://github.com/spring-projects/spring-framework/blob/master/CONTRIBUTING.md) 的顶级项目页面中的指导原则。 66 | 67 | # 5、开始 68 | 69 | 如果你刚刚开始使用 Spring，你可能希望通过创建一个基于 [Spring Boot](https://projects.spring.io/spring-boot/) 的应用程序来开始使用 Spring Framework。Spring Boot 提供了一种快速 (自以为是) 的方法来创建基于 Spring 的生产就绪应用程序。它基于 Spring Framework，支持约定而不是配置，旨在让你尽快启动并运行。 70 | 71 | 你可以使用 start.spring.io 生成基本项目或遵循 “入门” 指南之一，例如入门构建 RESTful Web 服务。这些指南不仅更容易消化，而且非常注重任务，而且大多数都基于 Spring Boot。它们还涵盖了 Spring 产品组合中的其他项目，你在解决特定问题时可能需要考虑这些项目。 72 | --------------------------------------------------------------------------------