Spring-Boot官方文档翻译，初次翻译，如有错误，请留言指正。仅供学习
本帖最后由 xiaoqing307 于 2023-6-30 16:48 编辑 当你刚开始接触Spring Boot或者通用的Spring，请阅读此章节。本章节会解答Spring Boot的简单问题，包括什么是Spring Boot、如何使用Spring Boot、为什么使用Spring Boot。本章节包括Spring Boot的介绍和安装说明。然后我们将带领您创建第一个Spring Boot应用，然后讨论一些核心原理，随着我们学习。
## 4.1 Spring Boot介绍
Spring Boot会帮助你创建一个可运行的、独立的、产品级别的Spring基础应用。我们集成了Spring和第三方类包，这样你能快速方便入门使用。大部分Spring Boot应用仅需要简单的配置。
你可以使用Spring Boot创建Java应用，通过`java -jar`或者其他传统方式启动。
我们的主要目标是：
- 给所有的Spring开发者提供一个快速可用的入门操作经验；
- 默认配置支持开箱即用；
- 提供一些非功能性但对于大型项目是常见的属性，比如嵌入式服务、安全、性能监控、健康检查、外部配置；
- 绝对没有代码生成（当不是需要镜像复制时）和不需要进行XML配置。
## 4.2 系统需求
Spring Boot 3.1.0-SNAPSHOT需要Java 17版本及以上兼容Java 19，Spring框架需要6.05及以上。
构建工具版本要求如下：
| 构建工具 | 版本 |
| -------- | ----------------------- |
| Maven | 3.5+ |
| Gradl | 7.x (7.5 以上) 或者 8.x |
### 4.2.1 Servlet服务器
Spring Boot内置了以下版本的Servlet容器：
| 名称 | Servlet版本 |
| ----------------------------------- | ----------- |
| tomcat10.0 | 5.0 |
| Jetty 11.0 | 5.1 |
| Undertow 2.2 (Jakarta EE 9 variant) | 5.0 |
您还可以将Spring Boot应用程序部署到任何Servlet 5.0+兼容容器中。
### 4.2.2 GraalVM本机映像
Spring Boot应用可以通过GraalVM22.3(或以上版本)制作成一个本地映像文件。
可以使用本机构建工具Gradle/MMaven插件或由GraalVM提供的本机映像工具创建映像。您还可以使用本地映像Paketo构建包创建本地映像。
以下版本支持：
| 名称 | 版本 |
| ------------------ | ------ |
| GraalVM Community| 22.3 |
| Native Build Tools | 0.9.20 |
## 4.3 安装Spring Boot
我们可以使用传统的Java开发工具或者命令行来安装Spring Boot.不过无论哪种方式，都需要Java SDK v17或更高的版本。在开始前，你需要用以下的命令来检查你当前Java的安装版本：
```shell
$ java -version
```
如果你对Java开发工具不熟悉或者你想尝试使用Spring Boot,你可以优先考虑使用Spring Boot CLI(命令行接口)。否则，请阅读传统的安装介绍。
### 4.3.1 Java开发人员的安装介绍
您可以像使用任何标准Java库一样使用Spring Boot。这样操作，把相应的spring-boot-*.jar文件放到类路径中。Spring Boot不需要任何特殊工具集成，因此您可以使用任何IDE或文本编辑器。同时，Spring Boot应用程序没有什么特别之处，因此您可以像运行任何其他Java程序一样运行和调试Spring引导应用程序。
尽管你可以直接复制Spring Boot jar包，但我们通常建议你使用支持的依赖管理工具（比如Maven或者Gradle）来安装。
#### Maven安装方式
Spring Boot 适配于Apache Maven 3.5或以上的版本。如果你还没有安装Maven,你可以参照(https://maven.apache.org/)的说明。
**提示：** 在许多操作系统上，Maven可以与软件包管理器一起安装。如果您使用OSX Homebrew，请尝试`brew install maven`。Ubuntu用户可以运行`sudo apt-get install maven`。使用(https://chocolatey.org/) Windows用户可以从提升（管理员）提示符运行`choco install maven`。
Spring Boot 依赖时，group id 设置为 org.springframework.boot。通常，你的Maven POM文件继承自spring-boot-starter-parent项目，并声明对一个或多个“Starters”的依赖关系。Spring Boot还提供了一个可选的 Maven插件来创建可执行jar。
更多详细的maven配置可以参照Maven插件配置章节；
#### Gradle安装方式
Spring Boot 适配于 Gradle 7.x 版本（7.5或以上）和 8.x版本。如果你还没有安装装Gradle，你可以参照(https://gradle.org)上的说明。
Spring Boot依赖可以通过设置group为org.springframework.boot。通常，你的项目由一个或者多个starter依赖组成。Spring Boot提供了非常有用的Gradle插件用来配置依赖和生成可运行的jar包。
Gradle Wapper
Gradle Wapper提供了一个很好的方法获取Gradle，在你需要使用Gradle构建一个项目时。它是一个很小的脚本和库，你可以和你的代码分别单独提交构建项目时。详细配置参考文档 (https://docs.gradle.org/current/userguide/gradle_wrapper.html);
### 4.3.2 SpringBoot 命令行接口安装方式
Spring Boot命令行接口是一个命令行工具，你可以用它来快速构建Spring。
你不需要使用命令行接口来创建Spring Boot。但它是一个快速创建Spring应用方法，当你没有IDE的时候。
#### 手动安装
你可以从Spring软件库里下载一个文件，spring-boot-cli-*-bin.zip 或者 spring-boot-cli-*-bin.tar.gz。
下载完成后，解压缩。然后根据解压文件夹中的INSTALL.txt介绍来操作。总的来说，你可以使用在压缩包的bin文件夹下的Spirng脚本，或者你可以使用java -jar来启动jar包（这个脚本可以帮助你确classpath配置无误），
#### 使用 SDKMAN!安装
SDKMAN! （软件开发包管理器）可以用来管理多个版本的二进制SDK。包括 Groovy和Spring Boot命令行接口。你可以从 (https://sdkman.io/)上获取，然后使用以下命令安装Spring Boot：
```
$ sdk install springboot
$ spring --version
Spring Boot v1.5.9.RELEASE
```
如果你正在开发CLI 功能，并希望够能轻松地访问刚创建的版本，请参照以下指令：
```
$ sdk install springboot dev /path/to/spring-boot/spring-boot-cli/target/spring-bootcli-3.1.0-SNAPSHOT-bin/spring-3.1.0-SNAPSHOT/
$ sdk default springboot dev
$ spring --version
Spring CLI v3.1.0-SNAPSHOT
```
前面的操作介绍可以帮你创建一个名叫dev的本地Spring Boot实例，它指向你的目标构建位置，因此每次重新构建 Spring Boot 时，spring 都是最新的。你可以通过以下命令来查看：
```
$ sdk ls springboot
================================================================================
Available Springboot Versions
================================================================================
> + dev
* 3.1.0-SNAPSHOT
================================================================================
+ - local version
* - installed
> - currently in use
================================================================================
```
#### 使用OSX Homebrew安装
如果你的电脑是mac系统，然后使用Homebrew，你可以使用一下命令来安装Spring Boot CLI:
```
$ brew tap spring-io/tap
$ brew install spring-boot
```
Homebrew将把Spring安装在/usr/local/bin下。
注意：如果你找不到brew命令，可能你的Homebrew已经过期，执行 brew update然后再重试。
#### 使用MacPorts安装
如果你的电脑是mac系统，然后你使用MacPorts，你可以使用以下命令：
```
$ sudo port install spring-boot-cli
```
#### CLI安装完成
Spring Boot CLI提供了BASH和zsh两种命令行安装脚本。你可以在任何shell中执行这个脚本（也可以称呼Spring）或者放在你个人或者系统范围内的bash中完成初始化。在 Debian 系统上，系统范围的脚本位于 `/shell-completion/bash` 中，当新的 shell 启动时，该目录中的所有脚本将被执行。要手动运行脚本, 例如：您已经使用 SDKMAN! 安装了。
```
$ . ~/.sdkman/candidates/springboot/current/shell-completion/bash/spring
$ spring <HIT TAB HERE>
grabhelpjarruntestversion
```
注意：如果您使用 Homebrew 或者 MacPorts 安装了 Spring Boot CLI，命令行完成脚本将自动注册到您的 shell 中。
#### 使用Windows Scoop安装
如果你的电脑是windows系统，然后你使用Scoop，你可以使用以下命令来安装：
```
> scoop bucket add extras
> scoop install springboot
```
Scoop将spring安装到~/scoop/apps/springboot/current/bin目录下。
注意：如果你看不到Scoop命令，你的Scoop可能过期了，你需要重新安装，然后再重试。
## 4.4 开发你的第一个SpringBoot应用
这个章节描述了怎么去创建一个简单的"Hello World"网页应用。我们可以使用一些Spring Boot主要特性，由于大部分IDE都支持Maven,我们将用Maven构建项目。
注意：(https://spring.io/)网站上有很多使用SpringBoot的入门介绍。如果你需要解决具体问题，你可以先从上面去找找有没有现成的。
你可以从(https://start.spring.io/)中选择指定的依赖来快速构建一个项目。你可以查看使用指导获取详细操作指南。
在开始之前，打开命令行运行以下脚本，确保你安装了有效的Java和Maven:
```
$ java -version
openjdk version "17.0.4.1" 2022-08-12 LTS
OpenJDK Runtime Environment (build 17.0.4.1+1-LTS)
OpenJDK 64-Bit Server VM (build 17.0.4.1+1-LTS, mixed mode, sharing)
```
```
$ mvn -v
Apache Maven 3.8.5 (3599d3414f046de2324203b78ddcf9b5e4388aa0)
Maven home: usr/Users/developer/tools/maven/3.8.5
Java version: 17.0.4.1, vendor: BellSoft, runtime:
/Users/developer/sdkman/candidates/java/17.0.4.1-librca
```
注意：这个示例需要在你自己的目录下创建，后续说明都是建立在这个目录已创建的前提下，然后这个就是你的当前目录。
### 4.4.1 创建 POM文件
开始，我们需要通过创建一个Maven的pom.xml文件。pom文件是构建我们项目的配方文件。打开你最喜欢的文本编辑器，复制以下内容进去：
```xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>myproject</artifactId>
<version>0.0.1-SNAPSHOT</version>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.1.0-SNAPSHOT</version>
</parent>
<!-- Additional lines to be added here... -->
<!-- (you only need this if you are using a milestone or snapshot version) -->
<repositories>
<repository>
<id>spring-snapshots</id>
<url>https://repo.spring.io/snapshot</url>
<snapshots><enabled>true</enabled></snapshots>
</repository>
<repository>
<id>spring-milestones</id>
<url>https://repo.spring.io/milestone</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>spring-snapshots</id>
<url>https://repo.spring.io/snapshot</url>
</pluginRepository>
<pluginRepository>
<id>spring-milestones</id>
<url>https://repo.spring.io/milestone</url>
</pluginRepository>
</pluginRepositories>
</project>
```
前面操作会给你创建一个工作版本，你可以运行mvn package来测试它（目前，我们先忽略掉jar包为空的告警）。
### 4.4.2 添加classPath依赖
Spring Boot提供了很多的starters，帮你将快捷的将jar包添加到你的classpath目录中。我们的测试项目使用了spring-boot-starter-parent在POM文件的parent部分。spring-boot-starter-parent是一种特殊的starter，帮我们提供一些有用的默认Maven配置。它还提供了依赖管理功能，你可以忽略这些依赖的版本（version）标签。
其他的starts提供了我们在开发特定应用所需要的一些依赖，由于我们在开发一个网页应用，我们添加了spring-boot-starter-web依赖。在这之前我们通过下面命令查看下我们目前有哪些依赖：
```shell
$ mvn dependency:tree
com.example:myproject:jar:0.0.1-SNAPSHOT
```
mvn dependency:tree将以树形结构打印项目的依赖，你可以发现spring-boot-starter-parent本身没有提供任何的依赖。我们在parent下方编辑添加我们项目需要的依赖spring-boot-starter-web。
```xml
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
```
如果我们再次运行mvn dependency:tree，我们将看到很多附加的依赖，包括tomcat web服务器和Spring Boot本身。
### 4.4.3 编写代码
要完成我们应用，我们需要创建一个简单的Java文件。默认情况下，Maven从 src/main/java下编译代码，所以你需要在项目结构中创建对应目录，然后添加一个src/main/java/MyApplication.java包含以下代码：
java
```java
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@SpringBootApplication
public class MyApplication {
@RequestMapping("/")
String home() {
return "Hello World!";
}
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
```
Kotlin
```kotlin
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RestController
@RestController
@SpringBootApplication
class MyApplication {
@RequestMapping("/")
fun home() = "Hello World!"
}
fun main(args: Array<String>) {
runApplication<MyApplication>(*args)
}
```
虽然这里我们没有写太多代码，但是有好多事情在进行着。我们通过下面章节来查看里面的重要部分。
####@RestController和@RequestMapping注解
在我们的MyApplication类中第一个注解是 @RestController。这是一个stereotype注解。它给代码阅读者一个提示。对于Spring而言，这个类扮演了一个重要的角色。在这个示例中，我们的类是一个网页@controller，所以当一个网页请求过来时，Spring会考虑这个。
@RequestMapping提供了一个路由信息。它告诉Spring任何路径为'/'的http请求都要映射到home方法上。@RestController告诉Spring直接返回一个字符串给请求者。
提示： @RestController 和@RequestMapping是SpringMVC的注解（不是Spring Boot特有的）。可以看MVC模块在Spring介绍文档中查看更详细的信息。
#### @SpringBootApplication注解
@SpringBootApplication是第二个类级别的注解。它是一个meta注解。它包含了 @SpringBootConfiguration, @EnableAutoConfiguration 和 @ComponentScan三个注解。在这些注解里面我们最感兴趣的是@EnableAutoConfiguration。@EnableAutoConfiguration告诉Spring Boot根据你添加的依赖jar包来自动配置一些你可能需要的配置。由于 `spring-boot-starter-web` 添加了 Tomcat 和 Spring MVC，自动配置将假定您要开发 web 应用并相应设置了 Spring。
starters和自动配置。自动配置虽然设计的目的是用来跟starters配置使用，但是两者没有直接的绑定关系。你可以自由选择需要依赖的jar包。Spring Boot仍然会自动配置你的应用程序。
#### main方法
我们应用最后的部分是main方法。这是一个标准的方法，根据Java定义的应用入口。我们的main方法作为Spring Boot的应用来启动入口。Spring应用关联我们的的应用，当我们启动Spring时，自动启动自动配置的tomcat网页服务器。我们需要将 MyApplication.class 作为一个参数传递给 run 方法来告知 SpringApplication，它是 Spring 主组件。同时还传递 args 数组以暴露所有命令行参数。
### 4.4.4 运行示例
这时，我们的应用可以运行起来了。由于你使用了spring-boot-starter-parent POM。你可以使用一个非常有效run命令来启动应用。在应用的根目录运行 mvn spring-boot:run来启动应用，你应该可以看到类似下面的输出内容：
```shell
$ mvn spring-boot:run
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v3.1.0-SNAPSHOT)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.906 seconds (process running for 6.514)
```
如果你在浏览器中运行(http://localhost:8080/),你应该可以看到下面这样输出：
```tex
Hello World!
```
你可以使用Ctrl+C来优雅的停止应用。
### 4.4.5 生成可执行的jar包
我们通过生成一个可以在生产环境运行的完全自包含的jar包来完成我们的实例。可执行的jar包（又被称为 臃肿的jar）是包含了编译后的所有的class文件和所有使用到的依赖的jar。
可执行jar包和Java
Java没有提供一个标准的方法来加载嵌套的jar文件（jar文件中嵌套包含其他的jar文件）。如果你需要生成一个只包含自己的应用，这是一个问题。
为了解决这个问题，好多开发者使用了uber jar，这个jar包包含了所有依赖jar中使用了的class文件，然后整理到一个单一文件中。这样就比较困难的去查看你的应用用到了哪些类。同时，如果应用用使用了多个jar包中的相同名称的文件（内容不同），这也将是一个问题。
Spring Boot采取了一个不一样的解决方案，就是让你可以直接使用嵌套jar文件。
我们需要在pom.xml文件中添加spring-boot-maven-plugin来生成可执行的jar包。我们需要将以下内容添加到依赖部分下面：
```xml
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
```
注意： spring-boot-starter-parent包含了`<executions>` 配置，用于绑定 `repackage` 。如果你没有使用父 POM，您需要自己声明此配置。有关详细的信息，请参阅[插件文档](https://docs.spring.io/spring-boot/docs/2.0.0.RELEASE/maven-plugin/usage.html)。
保存你的pom.xml文件，然后在命令行中运行mvn package，如下：
```shell
$ mvn package
Scanning for projects...
------------------------------------------------------------------------
Building myproject 0.0.1-SNAPSHOT
------------------------------------------------------------------------
.... ..
--- maven-jar-plugin:2.4:jar (default-jar) @ myproject ---
Building jar: /Users/developer/example/spring-boot-example/target/myproject0.0.1-SNAPSHOT.jar
--- spring-boot-maven-plugin:3.1.0-SNAPSHOT:repackage (default) @ myproject ---
------------------------------------------------------------------------
BUILD SUCCESS
------------------------------------------------------------------------
```
你在target目录下应该能够找到 myproject-0.0.1-SNAPSHOT.jar。这个文件大于在10MB大小左右。如果你想查看jar包里的详细信息，你可以使用jar tvf。像下面这样：
```shell
$ jar tvf target/myproject-0.0.1-SNAPSHOT.jar
```
你应该还会在 `target` 目录中看到一个名为 `myproject-0.0.1-SNAPSHOT.jar.original` 的较小文件。这是在 Spring Boot 重新打包之前由 Maven 所创建的原始 jar 文件。
使用 `java -jar` 命令运行该应用：
```shell
$ java -jar target/myproject-0.0.1-SNAPSHOT.jar
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v3.1.0-SNAPSHOT)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 2.536 seconds (process running for 2.864)
```
跟前面一样，通过ctrl+c来停止应用。
## 4.5 下一步
希望通过这章节的学习，你可以在你写的项目中学习到Spring Boot的一些基础信息。如果你是一个目标很明确的开发人员，你可能想要跳过Spring.io，通过一些入门介绍解决你的具体问题“怎么去使用Spring开发”。这类问题我们也有入门指南。接下来将介绍使用Spring Boot开发的，如果你实在忍受不了，你可以跳过，然后直接阅读Spring Boot 特性。
这个章节将更详细的介绍怎么使用Spring Boot。它包含这些主题：构建系统，自动配置和怎么运行你的应用。我们也会介绍一些Spring Boot最好的实践。尽管Spring Boot没有什么特殊的地方(它只是您可以使用的另一个库)，但有一些建议，如果你遵循这些建议，将会使你的开发更加容易。
如果你刚开始使用Spring Boot,你在阅读这个章节前，最好先阅读下入门介绍章节。
## 6.1 构建系统
强烈建议你选择一款支持依赖管理和能够使用发布到Maven中央仓库的构建系统。我们建议你选择Maven或者Gradle。其他构建系统（比如Ant）也可以用来构建Spring Boot，但是那些不是特别很好的支持。
### 6.1.1 依赖管理
每一个Spring Boot版本都提供了所支持的依赖列表。在使用时，你不需要在你的配置文件中为这些依赖提供版本。Spring Boot帮你管理了那些依赖版本。当你更新Spring Boot时，相关的依赖也会更新到对应的版本。
注意：如果你需要的话，你可以使用一个依赖版本去覆盖Spring Boot推荐的依赖版本。
### 6.1.2 Maven
要学习如何使用Spring Boot和Maven，请阅读Spring Boot的Maven插件文档：
- 参考文档（(https://docs.spring.io/spring-boot/docs/3.1.0-SNAPSHOT/maven-plugin/reference/htmlsingle/)和(https://docs.spring.io/spring-boot/docs/3.1.0-SNAPSHOT/maven-plugin/reference/pdf/spring-boot-maven-plugin-reference.pdf)）
- (https://docs.spring.io/spring-boot/docs/3.1.0-SNAPSHOT/maven-plugin/api/org/springframework/boot/maven/package-summary.html)
### 6.1.3 Gradle
要学习如何使用Spring Boot和Gradle，请阅读Spring Boot的Gradle插件文档：
- 参考文档（(https://docs.spring.io/spring-boot/docs/3.1.0-SNAPSHOT/gradle-plugin/reference/htmlsingle/)和(https://docs.spring.io/spring-boot/docs/3.1.0-SNAPSHOT/gradle-plugin/reference/pdf/spring-boot-gradle-plugin-reference.pdf)）
- (https://docs.spring.io/spring-boot/docs/3.1.0-SNAPSHOT/gradle-plugin/api/org/springframework/boot/gradle/package-summary.html)
### 6.1.4 Ant
我们也可以用Apache Ant+Ivy来构建Spring Boot项目。spring-boot-antlib “AntLib”模块还可以帮忙Ant生成可执行jar包。
要声明依赖关系，可以参照下面的模板配置：
```xml
<ivy-module version="2.0">
<info organisation="org.springframework.boot" module="spring-boot-sample-ant" />
<configurations>
<conf name="compile" description="everything needed to compile this module" />
<conf name="runtime" extends="compile" description="everything needed to run
this module" />
</configurations>
<dependencies>
<dependency org="org.springframework.boot" name="spring-boot-starter"
rev="${spring-boot.version}" conf="compile" />
</dependencies>
</ivy-module>
```
一个标准的构建配置文件build.xml如下：
```xml
<project
xmlns:ivy="antlib:org.apache.ivy.ant"
xmlns:spring-boot="antlib:org.springframework.boot.ant"
name="myapp" default="build">
<property name="spring-boot.version" value="3.1.0-SNAPSHOT" />
<target name="resolve" description="--> retrieve dependencies with ivy">
<ivy:retrieve pattern="lib//--." />
</target>
<target name="classpaths" depends="resolve">
<path id="compile.classpath">
<fileset dir="lib/compile" includes="*.jar" />
</path>
</target>
<target name="init" depends="classpaths">
<mkdir dir="build/classes" />
</target>
<target name="compile" depends="init" description="compile">
<javac srcdir="src/main/java" destdir="build/classes"
classpathref="compile.classpath" />
</target>
<target name="build" depends="compile">
<spring-boot:exejar destfile="build/myapp.jar" classes="build/classes">
<spring-boot:lib>
<fileset dir="lib/runtime" />
</spring-boot:lib>
</spring-boot:exejar>
</target>
</project>
```
提示：如果你不想使用spring-boot-antlib模块，你可以参照()
### 6.1.5 starters
Starters是一组方便的依赖配置集合，你可以在应用项目中包含它。你可以一站式的获取需要的Spring和相关技术，不需要你从其他的项目中去复制依赖配置信息。比如如果你需要创建一个Spring Boot项目和使用JPA连接数据库，可以在你的项目中配置spring-boot-starter-data-jpa依赖。
Starters 包含许多你需要的可以使项目快速启动和运行的依赖项，并具有一组一致的、受支持的托管传递依赖项。
所有的官方starters都使用了一个类似的命名模式：spring-boot-starter-*。其中\*代表项目的特定类型。这种命名方式帮助你准确找到需要的starter。许多IDE中的依赖集合模块，你可以通过名字搜索依赖。安装了合适的 Eclipse 或 Spring Tools 插件后，您可以在 POM 编辑器中按 ctrl-space 并输入“Spring -boot-starter”来获得完整的列表。
如"创建你自己的starter"章节介绍的一样，第三方的starters命名不能以spring-boot开头，spring-boot开头是代表了这是一个官方的starter。第三方starter命名最好以项目的名称开头。比如，一个叫thirdpartyproject的第三方starter项目通常命名为thirdpartyproject-spring-boot-starter。
下面的 starters 是由 Spring Boot 在 org.springframework.boot 组下提供的:
表1： Spring Boot application starters
| 标题 | 描述 |
| ------------------------------------------- | ------------------------------------------------------------ |
| spring-boot-starter | 核心starter，包含自动配置支持、日志记录和配置文件YAML |
| spring-boot-starter-amqp | 使用Spring AMQP和Rabbit MQ的starter |
| spring-boot-starter-aop | 使用Spring AOP和AspectJ的starter |
| spring-boot-starter-artemis | 使用Apache Artemis的进行JMS消息传递的starter |
| spring-boot-starter-batch | 使用Spring Batch的starter |
| spring-boot-starter-cache | 使用 Spring 框架的缓存支持的 starter |
| spring-boot-starter-data-cassandra | 使用Cassandra分布式数据库和Spring Data Cassandra的starter |
| spring-boot-starter-data-cassandra-reactive | 使用Cassandra 分布式数据库和Spring Data Cassandra Reactive的starter |
| spring-boot-starter-data-couchbase | 使用Couchbase文档型数据库和Spring Data Couchbase的Starter |
| spring-boot-starter-data-couchbase-reactive | 使用Couchbase文档型数据库和Spring Data Couchbase Reactive的Starter |
| spring-boot-starter-data-elasticsearch | 使用Elasticsearch搜索和分析引擎和Spring Data Elasticsearch的starter |
| spring-boot-starter-data-jdbc | 使用Spring Data JDBC的starter |
| spring-boot-starter-data-jpa | 使用Spring Data Hibernate Java持久化Api的starter |
| spring-boot-starter-data-ldap | 使用Spring Data LDAP的starter |
| spring-boot-starter-data-mongodb | 使用MongoDB文档型数据库和Spring Data MongoDB的starter |
| spring-boot-starter-data-mongodb-reactive | 使用MongoDB文档型数据库和Spring Data MongoDB Reactive的starter |
| spring-boot-starter-data-neo4j | 使用Neo4j 图表数据库和Spring Data Neo4j的starter |
| spring-boot-starter-data-r2dbc | 使用Spring Data R2DBC的starter |
| spring-boot-starter-data-redis | 使用Redis键值数据存储和Spring Data Redis和Lettuce客户端的starter |
| spring-boot-starter-data-redis-reactive | 使用Redis键值数据存储和Spring Data Redis Reactive和Lettuce客户端的starter |
| spring-boot-starter-data-rest | 使用Spring Data REST通过REST请求获取Spring Data仓库数据的starter |
| spring-boot-starter-freemarker | 使用FreeMarker视图创建MVC网页应用的starter |
| spring-boot-starter-graphql | 构建使用了Spring GraphQL的GraphQL应用的starter |
| spring-boot-starter-groovy-templates | 使用Groovy模板视图创建MVC网页应用的starter |
| spring-boot-starter-hateoas | 构建基于图形的RESTful网页请求的应用，集成了pring MVC和Spring HATEOAS |
| spring-boot-starter-integration | 使用Spring Integration的starter |
| spring-boot-starter-jdbc | 使用JDBC和HikariCP连接池的starter |
| spring-boot-starter-jersey | 创建使用JAX-RS和Jersey的RESTful网页应用的starter。spring-boot-starter-web的替代方案 |
| spring-boot-starter-jooq | 使用jOOQ通过JDBC连接SQL数据.是spring-boot-starter-data-jpa或者spring-boot-starter-jdbc的替代方案 |
| spring-boot-starter-json | 读写json的starter |
| spring-boot-starter-mail | 支持发送Java Mail和Spring框架email的starter |
| spring-boot-starter-mustache | 使用Mustache视图构建网页应用的starter |
| spring-boot-starter-oauth2-client | 使用Spring安全模块的OAuth2/OpenID Connect 连接客户端的starter |
| spring-boot-starter-oauth2-resource-server| 使用Spring Security的OAuth2资源服务的starter |
| spring-boot-starter-quartz | 使用Quartz计划任务的starter |
| spring-boot-starter-rsocket | 构建RSocket客户端和服务端的starter |
| spring-boot-starter-security | 使用Spring安全框架的starter |
| spring-boot-starter-test | 构建包含JUnit Jupiter、Hamcrest和Mockito测试模块的Spring Boot应用的starter |
| spring-boot-starter-thymeleaf | 使用Thymeleaf视图构建MVC网页应用的starter |
| spring-boot-starter-validation | 使用Java实体校验和Hibernate校验的starter |
| spring-boot-starter-web | 构建使用tomcat作为默认内嵌容器的包含RESTful的网页应用的starter |
| spring-boot-starter-web-services | 使用Spring网页服务的starter |
| spring-boot-starter-webflux | 使用Spring框架的响应式Web支持构建WebFlux应用的starter |
| spring-boot-starter-websocket | 使用Spring框架的WebSocket支持来构建WebSocket应用的starter |
除了上面这些starters，下面这些starters可以在我们发布生产级别的应用时使用：
表2： Spring Boot production starters
| 名称 | 描述 |
| ---------------------------- | ------------------------------------------------------------ |
| spring-boot-starter-actuator | 使用 Spring Boot’s Actuator，它提供了生产准备功能，以帮助您监视和管理您的应用程序。 |
最后，Spring Boot也包含下面这些starter，当你需要扩展或者替换特定的技术框架是可以使用：
表3: SpringBoot 技术 starters
| 名称 | 描述 |
| --------------------------------- | ------------------------------------------------------------ |
| spring-boot-starter-jetty | 使用 Jetty 作为嵌入式 servlet 容器的starter。可以替代 spring-boot-starter-tomcat |
| spring-boot-starter-log4j2 | 使用 Log4j2 进行日志记录的 starter，可以替代spring-boot-starter-logging |
| spring-boot-starter-logging | 使用 Logback 进行日志记录的 starter，默认的日志 starter |
| spring-boot-starter-reactor-netty | 使用 Reactor Netty 作为嵌入式响应式 HTTP 服务器的 starter。|
| spring-boot-starter-tomcat | 使用 Tomcat 作为嵌入式 servlet 容器的 starter。默认的 servlet 容器启动器由 spring-boot-starter-web 使用。 |
| spring-boot-starter-undertow | 使用 Undertow 作为嵌入式 servlet 容器的 starter。可以替代 spring-boot-starter-tomcat |
如果想了解如何使用这些替换技术，请阅读网页服务器和日志系统相关文档
提示：有关社区贡献的其他 starters 列表，请参阅 GitHub 上 spring-boot-starter 模块中的 (https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-starters/README.adoc)。
## 6.2 构建你的代码
Spring Boot 没有要求特定的代码布局才能运行。然而，有一些最佳实践是对我们是很有帮助的。
### 6.2.1 避免使用默认的包
当一个类没有在任何包下时，这个类会被认为是放在默认包下。通常不鼓励使用默认包，它可能引起一些特殊的问题当我们使用@ComponentScan、
@ConfigurationPropertiesScan、@EntityScan或@SpringBootApplication注解时，由于这样每个包下的每个类都会被读取到。
提示：我们建议你使用Jave推荐的包命名格式，包名为域名的反向(比如com.example.project)
### 6.2.2 主应用文件的位置
我们通常建议你将主应用放在包的根目录下相对其他的class文件。 @SpringBootApplication注解通常放在主应用class上面。它已经悄悄定义了默认的扫描包路径。比如你正在开发一个JPA应用，@SpringBootApplication注解标注的类所在的包作为@Entity对象查找的目录。使用根目录同时允许组件仅扫描你的应用。
提示：如果你不想使用 @SpringBootApplication，你也可以使用@EnableAutoConfiguration 和 @ComponentScan 它们来替代。
下面列表是一个标准项目的文件布局：
```
com
+- example
+- myapplication
+- MyApplication.java
|
+- customer
| +- Customer.java
| +- CustomerController.java
| +- CustomerService.java
| +- CustomerRepository.java
|
+- order
+- Order.java
+- OrderController.java
+- OrderService.java
+- OrderRepository.java
```
MyApplication.java 文件将声明 mian 方法，以及基本的 @SpringBootApplication，如下所示:
Java
```java
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
```
Kotlin
```kotlin
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
@SpringBootApplication
class MyApplication
fun main(args: Array<String>) {
runApplication<MyApplication>(*args)
}
```
## 6.3 配置类
Boot支持基于Java的配置。尽管我们可以在Spring应用中使用XML配置文件。我们通常建议你主要的配置信息作为一个单独@Configuration类。通常定义了main方法的主类最适合添加@Configuration注解。
提示：尽管互联网上好多已有的spring配置样例都是使用了XML配置。如果可以的话，尽量尝试使用基于Java的配置。寻找可用的注解是一个很好的开始。
### 6.3.1 添加额外的配置类
你不需要将所有你的配置放在一个单一类中，@Import注解可以用来引入额外的配置类。或者，你可以使用@ComponentScan注解来自动获取所有的Spring组件，包括含有@Configuration注解的类
### 6.3.2 添加xml配置文件
如果你确实需要使用基于xml的配置。我们建议你使用@Configuration注解类开始，然后使用@ImportResource注解加载xml配置文件。
## 6.4 自动装配
Spring Boot自动装配功能尝试根据你添加的依赖jar包自动配置你的Spring应用。比如你在项目中引入了HSQLDB，并且没有手动配置任何数据库连接beans，然后Spring Boot自动配置内存中的数据库。
你需要选择添加@EnableAutoConfiguration注解或者@SpringBootApplication 注解在你的@Configuration类上来实现自动配置功能。
提示：我们通常建议@SpringBootApplication和@SpringBootApplication两个注解选择一个在你的@Configuration类上即可。
### 6.4.1逐渐替换自动配置
自动配置是非入侵性的。在任何时候，你都可以定义你自己的配置来替换自动配置的特定部分。比如，如果你添加了你自己的数据源bean，默认内嵌的数据源支持就会靠后。
如果你需要找出当前项目使用了那些自动配置信息和为什么使用这些自动配置信息。使用调试模式启动你的应用，这样你可以在启动日志中看到相关配置信息。
### 6.4.2 禁用特定的自动配置类
如果你发现某个特定的自动配置类你不想使用的被加载了。你可以配置@SpringBootApplication的exclude属性来禁用他们。如下面示例：
Java
```java
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })
public class MyApplication {
}
```
Kotlin
```kotlin
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
@SpringBootApplication(exclude = )
class MyApplication
```
如果自动配置类不在classpath中，你可以配置excludeName属性来禁用它。如果你喜欢使用@EnableAutoConfiguration超过@SpringBootApplication，exclude和excludeName同样有效。最后，你也可以使用spring.autoconfigure.exclude属性来控制要排除的自动配置类列表。
提示：你可以通过使用属性在注解级别上配置来定义排除的配置信息。
注意：尽管自动配置类是公共的，被认为是公共API的类的唯一方面是类名可用于禁用自动配置。这些类的实际内容，比如嵌套的配置类或者bean方法仅提供内部使用的，我们不建议直接使用他们。
## 6.5 Spring beans和依赖注入
你可以自由使用任何标准的Spring Framework技术来定义你的bean及其注入的依赖项。我们通常建议使用构造函数注入来连接依赖项，并使用@ComponentScan来查找bean。
如果你按照前面建议的代码布局（将你的应用class放在包的顶级目录下）来构建代码时，你可以添加@ComponentScan不需要配置任何参数或者直接使用 @SpringBootApplication，它包含@ComponentScan。所有你应用中的组件（@Component、 @Service、 @Repository、
@Controller等等）会被自动注册成Spring Beans。
下面这些样例展示了@Service Bean中通过构造函数去注入一个需要的RiskAssessorbean:
Java
```Java
import org.springframework.stereotype.Service;
@Service
public class MyAccountService implements AccountService {
private final RiskAssessor riskAssessor;
public MyAccountService(RiskAssessor riskAssessor) {
this.riskAssessor = riskAssessor;
}
// ...
}
```
Kotlin
```kotlin
import org.springframework.stereotype.Service
@Service
class MyAccountService(private val riskAssessor: RiskAssessor) : AccountService
```
如果一个bean类中有多个构造函数，你需要使用@Autowired来标注一个你想Spring使用的构造函数。
Java
```Java
import java.io.PrintStream;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class MyAccountService implements AccountService {
private final RiskAssessor riskAssessor;
private final PrintStream out;
@Autowired
public MyAccountService(RiskAssessor riskAssessor) {
this.riskAssessor = riskAssessor;
this.out = System.out;
}
public MyAccountService(RiskAssessor riskAssessor, PrintStream out) {
this.riskAssessor = riskAssessor;
this.out = out;
}
// ...
}
```
Kotlin
```kotlin
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Service
import java.io.PrintStream
@Service
class MyAccountService : AccountService {
private val riskAssessor: RiskAssessor
private val out: PrintStream
@Autowired
constructor(riskAssessor: RiskAssessor) {
this.riskAssessor = riskAssessor
out = System.out
}
constructor(riskAssessor: RiskAssessor, out: PrintStream) {
this.riskAssessor = riskAssessor
this.out = out
}
// ...
}
```
注意：使用构造函数注入时，riskAssessor字段被标记为 final，表明它不能随意更改
## 6.6 使用@SpringBootApplication注解
许多Spring Boot开发者喜欢他们的应用中使用了自动配置，组件扫描和能够额外配置文件在他们的application类上。一个@SpringBootApplication注解可以用来启动这三个特性：
- @EnableAutoConfiguration: 启用Spring Boot的自动装配机制；
- @ComponentScan: 启用对application所在的包下的@Component组件扫描
- @SpringBootConfiguration: 允许在上下文中注册额外的 bean 或导入额外的配置类。是Spring的标准@Configuration注解的替代方案，这样在集成测试时可以适配不同的配置信息。
Java
```Java
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
// Same as @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
```
Kotlin
```kotlin
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
// same as @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan
@SpringBootApplication
class MyApplication
fun main(args: Array<String>) {
runApplication<MyApplication>(*args)
}
```
注意：@SpringBootApplication 还提供了别名来自定义 @EnableAutoConfiguration 和 @ComponentScan 的属性。
这些特性都不是强制性的，你可以选择其他的特性启用来替换这个单独的注解，比如你可能不想使用组件扫描或者配置信息扫描在你的应用中：
Java
```java
import org.springframework.boot.SpringApplication;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Import;
@SpringBootConfiguration(proxyBeanMethods = false)
@EnableAutoConfiguration
@Import({ SomeConfiguration.class, AnotherConfiguration.class })
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
```
Kotlin
```kotlin
import org.springframework.boot.SpringBootConfiguration
import org.springframework.boot.autoconfigure.EnableAutoConfiguration
import
org.springframework.boot.docs.using.structuringyourcode.locatingthemainc
lass.MyApplication
import org.springframework.boot.runApplication
import org.springframework.context.annotation.Import
@SpringBootConfiguration(proxyBeanMethods = false)
@EnableAutoConfiguration
@Import(SomeConfiguration::class, AnotherConfiguration::class)
class MyApplication
fun main(args: Array<String>) {
runApplication<MyApplication>(*args)
}
```
在这个样例中，MyApplication和其他的Spring Boot应用一样，除了@component注释的类和@configuration注释的类没有自动扫描，直接引入需要的类。(参照@Import注解)
## 6.7 运行你的应用
把你的应用打包成jar并内嵌HTTP服务容器的最大的优点是你可以运行你的应用和其他普通应用一样。这个示例适用于调试Spring Boot应用。你不需要其他特殊的IDE插件和扩展。
注意: 本章节仅涉及将你的应用打包成jar包，如果需要打包成war包，请参考你的服务器和IDE文档。
### 6.7.1 在IDE中运行
你可以在你的IDE中像运行一个Java应用程序一样运行一个Spring Boot应用。然而，你第一步要做的是引入你的项目。引入步骤跟你的IDE和构建系统关联比较大。大部分的IDE都能直接引入Maven项目。比如，Eclipse用户可以选择在File菜单中引入...->已存在的Maven项目。
如果你不能在你的IDE中直接引入项目，你可以使用构建插件生成IDE元数据。Eclipse和IDEA都有Maven插件。Gradle为大部分IDE提供了插件。
提示：如果你不小心重复运行了一个网页应用两次，你会看到"端口被占用"的报错。Spring Tools用户可以使用Relaunch按钮而不是Run按钮来确保关闭任何现有的实例。
### 6.7.2 运行一个已打包的应用
如果你使用Spring Boot的Maven或者Gradle插件生成了一个可执行的jar包，你可以运行你的应用使用命令 java -jar,如下面示例：
```shell
$ java -jar target/myapplication-0.0.1-SNAPSHOT.jar
```
还可以运行一个开启远程调试模式的打包应用，这样你就可以将你打包的应用带上一个调试器，像下面这样配置:
```shell
$ java -Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n -jar target/myapplication-0.0.1-SNAPSHOT.jar
```
### 6.7.3 使用Maven插件
Maven插件包含一个run指令，它可以用来快速编译和运行你的应用。应用以快速形式运行，跟他们在IDE中运行一样。下面示例展示一个标准的Maven命令去运行一个Spring Boot应用：
```shell
$ mvn spring-boot:run
```
你可能也想使用MAVEN_OPTS来配置系统环境变量，你可以参照下面示例：
```shell
$ export MAVEN_OPTS=-Xmx1024m
```
### 6.7.4 使用Gradle插件
Spring Boot Gradle插件同样包含了一个bootRun任务，它用来以快速形式运行你的应用。当你运用org.springframework.boot和Java插件时，bootRun任务会自动添加进来。使用参照下面示例：
```shell
$ gradle bootRun
```
你可能也想使用JAVA_OPTS设置系统环境变量，使用如下示例：
```shell
$ export JAVA_OPTS=-Xmx1024m
```
### 6.7.5热拔插
由于Spring Boot应用程序也是一个普通的Java应用程序，因此JVM热插拔是可以开箱即用JVM 热插拔在可替换字节码方面有所限制。想要更完整的解决方案，可以使用 JRebel。
spring-boot-devtools木块也包含对应用快速重启的支持。详细操作查看热部署"How-to"章节。
## 6.8 开发者工具
Spring Boot包含一个额外的工具组，它可以使你的开发体验更愉快。spring-boot-devtools模块可以添加到任何项目中来提供额外的开发特性。要使用开发支持，你需要在构建时添加相关依赖配置，Maven和Gradle配置如下：
Maven
```xml
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
```
Gradle
```
dependencies {
developmentOnly("org.springframework.boot:spring-boot-devtools")
}
```
警告：开发工具在某些特定的多模块项目中可能会引起类加载问题。类加载问题诊断章节解释了如何去诊断和解决这些问题。
注意：当运行一个完全打包的应用时，开发者工具会自动失效。如果你的项目使用java -jar命令启动或者通过一个特殊的类加载器启动，这个应用会被认为是一个“生产级别应用”。你可以通过设置spring.devtools.restart.enabled来控制它。不考虑你应用的类加载方式，设置系统属性-Dspring.devtools.restart.enabled=true来开启开发者工具。生产环境上，通常不允许启用开发者工具，因为这是一个严重的安全问题。通过移除相关依赖或者设置系统属性-Dspring.devtools.restart.enabled=false来禁用开发者工具。
提示：在Maven中将依赖标记为可选，或者在Gradle（参照上面)中使用developmentOnly配置来防止开发者工具传递应用于使用项目的其他模块。
提示：重新打包的归档文件默认不包含 devtools。如果您想使用某个远程devtools特性，则需要包含它。当使用Maven插件时，将excludeDevtools属性设置为false。当使用Gradle插件时，配置任务的类路径以包含developmentOnly配置。
### 6.8.1 诊断类加载问题
像前面重启和重新加载章节描述的的那样，重新启动功能使用了两个类加载器。对于大部分的应用来说，这个几乎都能正常运行。然而，有的时间会引起类加载问题，特别是一些多模块项目。
尝试禁止重启来诊断是否由开发者工具和两个加载类引起类加载问题。如果这个能解决你的问题，定制你的重启加载类在你整个项目中。
### 6.8.2 默认属性
Spring Boot支持的一些库使用缓存来提高性能。比如，模板引擎缓存了编译好的模板，避免重复解析模板文件。同时，Spring MVC可以在提供静态资源服务时的响应信息上添加HTTP缓存信息。
虽然缓存在生产中非常有用，但是在开发工程中会引起相反的作用。让你无法看到刚刚在应用中的修改内容。由于这个原因，spring-boot-devtools默认禁止缓存选项。
缓存选项通常在你的项目application.properties配置文件中进行配置。比如，Thymeleaf提供了spring.thymeleaf.cache属性配置。spring-boot-devtools模块不需要手动设置这些属性，而是自动应用合理的开发时间配置。
下面列表中这些数据是默认被配置的：
| 名称 | 默认值 |
| ---------------------------------------------- | ------ |
| server.error.include-binding-errors | always |
| server.error.include-message | always |
| server.error.include-stacktrace | always |
| server.servlet.jsp.init-parameters.development | true |
| server.servlet.session.persistent | true |
| spring.freemarker.cache | false|
| spring.graphql.graphiql.enabled | true |
| spring.groovy.template.cache | false|
| spring.h2.console.enabled | true |
| spring.mustache.servlet.cache | false|
| spring.mvc.log-resolved-exception | true |
| spring.reactor.netty.shutdown-quiet-period | 0s |
| spring.template.provider.cache | false|
| spring.thymeleaf.cache | false|
| spring.web.resources.cache.period | 0 |
| spring.web.resources.chain.cache | false|
注意：如果你不想使用默认属性，可以在你项目的application.properties中设置spring.devtools.add-properties为false。
由于你在开发Spring MVC和Spring WebFlux项目时，需要获取更多的网页请求信息。开发者工具建议你设置网页日志为DEBUG级别。它会提供你请求相关信息、哪个进程在处理、响应结果等等。如果你想要完整的请求详细日志（包括潜在的敏感信息），你可以开启spring.mvc.log-request-details或者spring.codec.log-request-details配置属性。
### 6.8.3 自动重启
使用了spring-boot-devtools的应用会自动重启，当classpath下的文件发生变更时。当你使用IDE开发时，这是一个非常有用的特性。当代码修改后，他会给你一个非常快速的更新。默认情况，classpath下任何文件都会被监控是否修改。注意，某些资源文件，比如静态资源和页面模板，这些文件修改，其实不需要重启应用。
由于DevTools监控classpath下的资源，更新classpath是唯一的触发重启的方法。无论你使用IDE开发还是使用构建插件。变更的文件重新编译会触发重启。更新classpath的方法取决于你使用哪个工具：
- Eclipse，保存一个变更的文件会更新classpath然后触发重启。
- IntelliJ IDEA，构建项目可以有同样的效果。
- 使用构建插件，运行Maven的mvn compile命令或者Gradle的gradle build命令也会触发重启。
注意：如果你使用构建插件重启Maven或者Gradle，必须设置forking为可用状态。如果设置为禁用，devtools使用的唯一应用类加载器不会被生成，重启也无法运行。
提示：当与LiveReload一起使用时，自动重启会工作的很好。详情请阅读LiveReload章节。如果你与JRebel一起使用，将禁用自动重新启动，以支持动态类重新加载。其他的devtools特性（比如LiveReload和属性覆盖）仍然可以使用。
注意：DevTools依赖应用上下文的shutdown钩子，在重启过程中。如果你禁用了Shutdown钩子（SpringApplication.setRegisterShutdownHook(false)），DevTools也不能正常工作。
注意：DevTools需要去自定义使用应用上下文的资源加载器。如果你的应用已经提供了一个，它将被包裹。直接重载getResource方法在应用上下文中是不支持的。
警告：当使用AspectJ weaving时，自动重启是不支持的。
#### 重载和重启
Spring Boot提供的重启技术通过使用两个类加载器来工作。没有变更的class（比如，那些来自第三方jar包的）会被加载到一个基础的类加载器。你开发的的class会被加载到一个重新启动的类加载器中。当应用重新启动完，重启类加载器会被丢弃，然后重新生成一个新的类加载器。这种方法意味着应用自动重启比冷加载更快速，由于基础的类加载器已经是可用并填充的。
如果你发现应用的重启速度不是足够的快或者你遇到类加载entire，需要考虑重新加载技术比如ZeroTurnaround的JRebel。它们的工作原理是在装入类时重写类，使它们更易于重新装入。
#### 状态评估中的日志变化
默认情况下，每次重启你的应用，展示状态评估的报告会被记录下来。报告展示了你应用自动配置的变更，比如添加或者移除bean和设置配置属性。
如果要禁止日志记录报告，参照下面这些属性配置：
配置文件
```
spring.devtools.restart.log-condition-evaluation-delta=false
```
yaml
```yaml
spring:
devtools:
restart:
log-condition-evaluation-delta: false
```
#### 不包括的资源
一些资源文件变更是不需要触发重启的。比如Thymeleaf的模板文件可以实时编辑。默认情况下变更/META-INF/maven、
/META-INF/resources、 /resources、 /static、 /public、 或者 /templates这些目录下的资源文件是不会触发重启的，但是会触发实时加载。如果你想自定义不触发重启的目录。你可以设置spring.devtools.restart.exclude属性。比如你想只排除/static和/public，可以参照下面这样配置：
配置文件
```
spring.devtools.restart.exclude=static/**,public/**
```
yaml
```yaml
spring:
devtools:
restart:
exclude: "static/**,public/**"
```
提示：如果你想在原有默认的基础上添加额外的排除项，使用spring.devtools.restart.additional-exclude属性替代。
#### 监控额外的路径
当你想要classpath外的文件变更触发应用重启或者重新加载。你可以使用spring.devtools.restart.additional-paths属性来配置需要新增监视变更的目录。你可以使用spring.devtools.restart.exclude属性来控制附加路径下的更改是触发完全重新启动还是实时重新加载。
#### 禁用重启
如果你不想使用重启特性。你可以通过设置spring.devtools.restart.enabled属性来禁用它。大部分情况下，你可以设置属性在application.properties文件中（这样做仍然初始化重新启动类加载器，但它不会监视文件更改）。
如果你需要完全禁用重启支持（比如,由于你使用了特殊的库导致这个无法工作），你需要去设置spring.devtools.restart.enabled系统属性为false在调用SpringApplication.run(…)之前，可以参照下面这些样例：
Java
```java
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
System.setProperty("spring.devtools.restart.enabled", "false");
SpringApplication.run(MyApplication.class, args);
}
}
```
Kotlin
```kotlin
import org.springframework.boot.SpringApplication
import org.springframework.boot.autoconfigure.SpringBootApplication
@SpringBootApplication
object MyApplication {
@JvmStatic
fun main(args: Array<String>) {
System.setProperty("spring.devtools.restart.enabled", "false")
SpringApplication.run(MyApplication::class.java, *args)
}
}
```
#### 使用触发器文件
如果你使用IDE开发，持续编译变更的文件，你可能更喜欢在特定的时间触发重启。因此，你可以使用一个触发文件，这是一个特殊的文件，当你希望实际触发重新启动检查时，需要修改该文件。
注意：任何文件更新都会触发检查，但是只有Devtools检测到需要做一些事情时才会真正发生重启。
要使用触发器文件，请将 spring.devtools.restart.trigger-file 属性设置为您的触发器文件的名称(不包括任何路径)。触发器文件必须出现在classpath中的某个位置。
例如，如果你有一个具有以下结构的项目:
```
src
+- main
+- resources
+- .reloadtrigger
```
然后你的触发文件配置需要像这样：
配置文件
```properties
spring.devtools.restart.trigger-file=.reloadtrigger
```
yaml
```yaml
spring:
devtools:
restart:
trigger-file: ".reloadtrigger"
```
当src/main/resources/.reloadtrigger文件发生变更时，重新启动才会被发生。
注意：你可能需要设置spring.devtools.restart.trigger-file作为一个全局设置，这样你所有的项目都会使用这个配置。
一些IDE工具提供了特性帮助你手动更新你的触发文件。Eclipse和 IntelliJ IDEA(Ultimate Edition)的Spring Tools都有这些支持。使用 Spring Tools，您可以在控制台视图中使用 “reload” 按钮(只要您的触发器文件名为.reloadtrigger)。对于 IntelliJ IDEA，您可以按照其文档中的说明操作。
#### 自定义重启类加载器
就像前面重启和重载章节描述的纳言给，重启功能是通过两个类加载器来实现的。如果类加载器引起问题，你可能需要自定义哪些类使用哪个类加载器加载。
默认情况下，IDE 中任何打开的项目都是用 “重启” 类加载器加载的，任何常规的 .jar 文件都是用 “基础” 类加载器加载的。如果你使用mvn spring-boot:run或者gradle bootRun:命令运行项目，包含@SpringBootApplication的项目试试用“重启”类加载器加载的，其他的是使用“基础”类加载器。
你可以创建一个 META-INF/spring-devtools.properties 文件去指导Spring Boot去加载你项目的哪些内容使用哪个类加载器。spring-devtools.properties文件可以包含以restart.exclude.和 restart.include.为前缀的属性。include元素是代表哪些使用“重启”类加载器加载，exclude元素代表哪些使用“基础”类加载器加载。属性值是一个应用到 classpath 的正则表达式，如下面示例：
配置文件
```properties
restart.exclude.companycommonlibs=/mycorp-common-[\\w\\d-\\.]+\\.jar
restart.include.projectcommon=/mycorp-myproj-[\\w\\d-\\.]+\\.jar
```
yaml
```yaml
restart:
exclude:
companycommonlibs: "/mycorp-common-[\\w\\d-\\.]+\\.jar"
include:
projectcommon: "/mycorp-myproj-[\\w\\d-\\.]+\\.jar"
```
注意：所有属性的键值都必须是唯一的，只要属性是以restart.include.或者restart.exclude.开头，都会被考虑。
提示：classpath下的所有META-INF/spring-devtools.properties文件将被加载，你可以将它们打包进工程或者类库中为项目所用。
#### 已知的限制
重新启动功能对使用标准ObjectInputStream反序列化的对象无效。如果需要反序列化数据，可能需要使用Spring的ConfigurableObjectInputStream配合 Thread.currentThread().getContextClassLoader()。
遗憾的是，一些第三方类库在没有考虑上下文类加载器的情况下使用了反序列化。您如果遇到此问题，需要向原作者提交修复请求。
### 6.8.4 LiveReload
spring-boot-devtools木块包含了一个内嵌的LiveReload服务器，当资源变更时，触发浏览器刷新。在livereload.com上提供了针对Chrome, Firefox和Safari的免费可用的LiveReload浏览器器扩展。
如果你不想在你应用运行时启动LiveReload服务器，你可以设置spring.devtools.livereload.enabled属性为false。
注意：你一次只能运行一个LiveReload服务器，在启动你的应用之前，确认没有其他的LiveReload服务器在运行。如果你在IDE中启动了多个应用，只有第一个启动的应用有LiveReload支持。
警告：要在文件更改时触发 LiveReload，必须启用自动重启。
### 6.8.5 全局设置
你可以通过添加下面这些文件到$HOME/.config/spring-boot目录下，来配置全局的devtools设置：
1. spring-boot-devtools.properties
2. spring-boot-devtools.yaml
3. spring-boot-devtools.yml
添加到这些文件中的任何属性都适用于您机器上使用 devtools 的所有 Spring Boot 应用程序。比如，要将重启配置为总是使用触发器文件，你需要在 spring-boot-devtools文件中添加以下属性:
配置文件
```properties
spring.devtools.restart.trigger-file=.reloadtrigger
```
Yaml
```yaml
spring:
devtools:
restart:
trigger-file: ".reloadtrigger"
```
默认情况下，$HOME是指用户的home目录。通过设置SPRING_DEVTOOLS_HOME或者系统属性spring.devtools.home来自定义home所在位置。
注意：如果devtools配置文件没有在$HOME/.config/spring-boot目录下，会在$HOME的根目录下搜索.spring-boot-devtools.properties文件。允许你对那些不支持$HOME/.config/spring-boot的较老版本的Spring Boot项目共享devtools全局配置信息。
注意：在devtools的properties或者yaml文件中不支持Profiles。在.spring-boot-devtools.properties配置文件中的任何profiles属性都不会随着加载的profile-specific配置文件而变化。Profile specific文件名称（spring-boot-devtools-<profile>.properties这样的形式的）和spring.config.activate.on-profile
documents属性在YAML文件和配置文件种都不支持。
#### 配置文件系统监控
FileSystemWatcher通过定时轮询检查class文件是否变更，并等待一段预先设置的时间来确保没有任何新增的更新来实现的。由于Spring Boot信赖IDE去编译文件并将文件复制到Spring Boot可以阅读到的地方，你可以发现有的时候当devtools重启应用后，有的代码修改了，但是没生效。如果你发现这样的问题经常发生。尝试增加spring.devtools.restart.poll-interval属性值和spring.devtools.restart.quiet-period属性值去适配你的开发环境：
配置文件
```properties
spring.devtools.restart.poll-interval=2s
spring.devtools.restart.quiet-period=1s
```
Yaml
```yaml
spring:
devtools:
restart:
poll-interval: "2s"
quiet-period: "1s"
```
当前的监控classpath路径的逻辑是每2秒轮询检查一次是否变更，并等待1秒，确保没有新的class变更。
### 6.8.6远程应用程序
Spring Boo开发者工具不仅仅是在本地环境使用。当应用在远程运行时，你也可以使用一些特性。远程支持是可选的，因为可能存在安全风险。只有当运行在一个信任的网络中或者使用了SSL才应该启用它。如果两个条件你一个都不满足，你应该不使用DevTool的远程支持。你应该在任何的生产环境中都不开启远程支持。
要启用它，你需要去确保devtools包含在重新打包的归档文件中，如下所示：
```xml
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<excludeDevtools>false</excludeDevtools>
</configuration>
</plugin>
</plugins>
</build> <build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<excludeDevtools>false</excludeDevtools>
</configuration>
</plugin>
</plugins>
</build>
```
然后你需要去设置spring.devtools.remote.secret属性。像其他重要的密码和秘密一样，这个值需要设置为唯一的和非常牢固的，比如不能被被人猜到或者使用暴力破解出来。
远程支持devtools包含两个部分：一个需要接受连接的服务端端点和一个运行在你IDE上的客户端应用。当配置了spring.devtools.remote.secret属性后，服务端部分会自动开启。客户端部分需要手动开启。
注意：Spring WebFlux应用是不支持devtools的远程模式的。
#### 运行远程客户端应用
远程客户端应用被设计出来在你的IDE中运行。你需要使用和你连接的远程项目一样的classpath来运行org.springframework.boot.devtools.RemoteSpringApplication。这个应用需要的参数是要连接的远程URL;
比如，如果你使用的是Eclipse或者Spring Tools，有一个已经部署到Cloud Foundry上名字叫my-app的项目，你需要按照下面的操作进行：
- 在Run菜单中选择Run Configurations。
- 创建一个新的Java应用"启动配置"。
- 浏览my-app项目。
- 使用org.springframework.boot.devtools.RemoteSpringApplication作为主类。
- 添加https://myapp.cfapps.io到你的Program参数中（或者其他的你远程的URL地址）。
一个正在运行的远程客户端可能有类似下面的命令行输出：
```shell
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ ___ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | | _ \___ _ __ ___| |_ ___ \ \ \ \
\\/ ___)| |_)| | | | | || (_| []::::::[] / -_) ' \/ _ \ _/ -_) ) ) ) )
' |____| .__|_| |_|_| |_\__, | |_|_\___|_|_|_\___/\__\___|/ / / /
=========|_|==============|___/===================================/_/_/_/
:: Spring Boot Remote :: (v3.1.0-SNAPSHOT)
2023-03-09T16:13:05.614Z INFO 599 --- [ main]
o.s.b.devtools.RemoteSpringApplication : Starting RemoteSpringApplication v3.1.0-
SNAPSHOT using Java 17.0.6 with PID 599
(/Users/myuser/.m2/repository/org/springframework/boot/spring-boot-devtools/3.1.0-
SNAPSHOT/spring-boot-devtools-3.1.0-SNAPSHOT.jar started by myuser in /opt/apps/)
2023-03-09T16:13:05.619Z INFO 599 --- [ main]
o.s.b.devtools.RemoteSpringApplication : No active profile set, falling back to 1
default profile: "default"
2023-03-09T16:13:05.904Z INFO 599 --- [ main]
o.s.b.d.a.OptionalLiveReloadServer : LiveReload server is running on port 35729
2023-03-09T16:13:05.942Z INFO 599 --- [ main]
o.s.b.devtools.RemoteSpringApplication : Started RemoteSpringApplication in 0.738
seconds (process running for 1.295)
```
注意：因为远程客户端使用了和真实应用同样的classpath，远程应用可以直接读取真实应用的应用配置信息。
这就是spring.devtools.remote.secret被读取并传递给服务器的验证方式。
提示：通常建议你使用https://作为连接协议，这样的话通信是加密的，密码不会被拦截。
提示：如果你需要使用代{过}{滤}理来访问远程应用，需要配置spring.devtools.remote.proxy.host和spring.devtools.remote.proxy.port属性。
#### 远程更新
远程客户端像本地重启使用通用的方法监控你应用的classpath变化。任何远程应用的资源文件更新，（如果需要）都会触发重启。如果你在使用云服务迭代一个特性，而本地没有时，将非常有用。通常，远程更新和重启比一个完整重新构建和部署周期更快。
在一个较慢的开发环境中，可能发生这样的情况，冷静等待时间不充足，class类中的更改可能会分批进行，服务在第一批class变更更新后就重启了，由于应用正在重启，洗衣批的更新不能发送到应用中。这样通常在RemoteSpringApplication的日志中有关于失败更新某些class类的警告，和随后的重启。这也可能会导致应用代码不一致，和第一批次变更的代码更新后重启吃白。如果你经常发现这样的问题，尝试增加spring.devtools.restart.poll-interval和spring.devtools.restart.quiet-period属性的值去适配你的开发环境，详细参照文件系统监控章节对这些属性的介绍。
注意：只要当远程客户端运行时，文件才会被监控。如果你在远程客户端启动前变更文件，这是不会被推送到远程服务器上的。
## 6.9 打包生产环境的应用包
可执行的jar包可以用来作为生产环境部署，由于是独立一个，它们也可以完美适用于云部署。
像添加一些生产环境需要的特性，比如健康检测、auditing、metric Rest或者JMX终端。考虑添加spring-boot-actuator，详情见生产环境准备特性章节。
## 6.10下一步
你现在应该理解怎么去使用SpringBoot和一些你需要参照的优秀实践。你现在可以去更深入的学习Spring Boot的特性。或者你可以直接跳过，然后阅读Spring Boot的生产环境准备方面内容。
大牛，谢谢分享！辛苦了！ mark 方便以后学习 楼主太牛了，可以提供一个服务接口吗？ iYoutudou 发表于 2023-6-27 19:52
楼主太牛了，可以提供一个服务接口吗？
这只是篇学习记录，没有什么服务接口哦
页:
[1]