使用 Spring Boot
1. 构建系统
强烈建议您选择支持依赖项管理并且可以使用发布到 “Maven Central” 存储库的工件的构建系统。 我们建议您选择 Maven 或 Gradle。 可以让 Spring Boot 与其他构建系统（例如 Ant）一起使用，但它们没有得到特别好的支持。
1.1. 依赖管理
Spring Boot 的每个版本都提供了它支持的依赖项的精选列表。 实际上，你不需要在构建配置中为这些依赖项中的任何一个提供版本，因为 Spring Boot 会为你管理。 当您升级 Spring Boot 本身时，这些依赖项也会以一致的方式升级。
| 如果需要，您仍然可以指定版本并覆盖 Spring Boot 的建议。 |
精选列表包含可与 Spring Boot 一起使用的所有 Spring 模块，以及第三方库的精炼列表。
该列表作为标准物料清单 （spring-boot-dependencies），该 McD 的 Git。
| Spring Boot 的每个版本都与 Spring Framework 的基本版本相关联。 我们强烈建议您不要指定其版本。 |
1.4. Ant
可以使用 Apache Ant+Ivy 构建 Spring Boot 项目。
这spring-boot-antlib“AntLib” 模块也可用于帮助 Ant 创建可执行的 jar。
要声明依赖项，典型的ivy.xmlfile 类似于以下示例：
<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如以下示例所示：
<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.0.13" />
<target name="resolve" description="--> retrieve dependencies with ivy">
<ivy:retrieve pattern="lib/[conf]/[artifact]-[type]-[revision].[ext]" />
</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模块中，请参阅 howto.html “How-to” 。 |
1.5. Starters
Starters 是一组方便的依赖项描述符，您可以将其包含在应用程序中。
您可以获得所需的所有 Spring 和相关技术的一站式商店，而无需搜索示例代码和复制粘贴依赖项描述符。
例如，如果您想开始使用 Spring 和 JPA 进行数据库访问，请包括spring-boot-starter-data-jpa依赖项。
Starter 包含许多依赖项，您需要这些依赖项才能快速启动和运行项目，并具有一组一致、受支持的托管传递依赖项。
Spring Boot 在org.springframework.boot群：
| 名字 | 描述 |
|---|---|
核心Starters，包括自动配置支持、日志记录和 YAML |
|
使用 Spring AMQP 和 Rabbit MQ 的入门 |
|
使用 Spring AOP 和 AspectJ 进行面向方面编程的入门 |
|
使用 Apache Artemis 的 Starter for JMS 消息传递 |
|
使用 Spring Batch 的 Starter |
|
使用 Spring Framework 的缓存支持的 Starter |
|
使用 Cassandra 分布式数据库和 Spring Data Cassandra 的入门 |
|
使用 Cassandra 分布式数据库和 Spring Data Cassandra Reactive 的入门 |
|
使用 Couchbase 面向文档的数据库和 Spring Data Couchbase 的入门 |
|
使用 Couchbase 面向文档的数据库和 Spring Data Couchbase Reactive 的入门 |
|
使用 Elasticsearch 搜索和分析引擎和 Spring Data Elasticsearch 的入门版 |
|
使用 Spring Data JDBC 的初学者 |
|
将 Spring Data JPA 与 Hibernate 结合使用的入门 |
|
使用 Spring Data LDAP 的入门 |
|
使用 MongoDB 面向文档的数据库和 Spring Data MongoDB 的入门 |
|
使用 MongoDB 面向文档的数据库和 Spring Data MongoDB Reactive 的入门 |
|
使用 Neo4j 图形数据库和 Spring Data Neo4j 的入门 |
|
使用 Spring Data R2DBC 的Starters |
|
将 Redis 键值数据存储与 Spring Data Redis 和 Lettuce 客户端结合使用的入门 |
|
将 Redis 键值数据存储与 Spring Data Redis 响应式和 Lettuce 客户端一起使用的入门 |
|
使用 Spring Data REST 和 Spring MVC 通过 REST 公开 Spring Data 存储库的入门 |
|
使用 FreeMarker 视图构建 MVC Web 应用程序的入门 |
|
使用 Spring GraphQL 构建 GraphQL 应用程序的入门 |
|
使用 Groovy Templates 视图构建 MVC Web 应用程序的 Starter |
|
使用 Spring MVC 和 Spring HATEOAS 构建基于超媒体的 RESTful Web 应用程序的入门 |
|
使用 Spring 集成的 Starter |
|
将 JDBC 与 HikariCP 连接池一起使用的入门 |
|
使用 JAX-RS 和 Jersey 构建 RESTful Web 应用程序的入门工具。替代 |
|
使用 jOOQ 通过 JDBC 访问 SQL 数据库的入门工具。替代 |
|
用于读取和写入 json 的 Starter |
|
使用 Java Mail 和 Spring Framework 的电子邮件发送支持的入门 |
|
使用 Mustache 视图构建 Web 应用程序的入门 |
|
使用 Spring Security 的 OAuth2/OpenID Connect 客户端功能的入门 |
|
使用 Spring Security 的 OAuth2 资源服务器功能的入门 |
|
使用 Quartz 调度程序的入门 |
|
用于构建 RSocket 客户端和服务器的 Starter |
|
使用 Spring Security 的 Starter |
|
用于使用 JUnit Jupiter、Hamcrest 和 Mockito 等库测试 Spring Boot 应用程序的 Starter |
|
使用 Thymeleaf 视图构建 MVC Web 应用程序的入门 |
|
将 Java Bean 验证与 Hibernate 验证器结合使用的入门 |
|
使用 Spring MVC 构建 Web（包括 RESTful）应用程序的入门工具。使用 Tomcat 作为默认嵌入式容器 |
|
使用 Spring Web 服务的入门 |
|
使用 Spring Framework 的响应式 Web 支持构建 WebFlux 应用程序的入门 |
|
使用 Spring Framework 的 MVC WebSocket 支持构建 WebSocket 应用程序的入门工具 |
除了应用程序Starters之外，以下Starters还可用于添加生产就绪功能：
| 名字 | 描述 |
|---|---|
使用 Spring Boot 的 Actuator 的 Starter，它提供生产就绪功能来帮助您监控和管理应用程序 |
最后，Spring Boot 还包括以下Starters，如果你想排除或交换特定的技术方面，可以使用这些Starters：
| 名字 | 描述 |
|---|---|
使用 Jetty 作为嵌入式 servlet 容器的入门工具。替代 |
|
使用 Log4j2 进行日志记录的入门。替代 |
|
使用 Logback 进行日志记录的Starters。默认日志记录Starters |
|
使用 Reactor Netty 作为嵌入式响应式 HTTP 服务器的Starters。 |
|
使用 Tomcat 作为嵌入式 servlet 容器的入门工具。默认 servlet 容器Starters由 |
|
使用 Undertow 作为嵌入式 servlet 容器的入门工具。替代 |
要了解如何交换技术方面，请参阅交换 Web 服务器和日志记录系统的作文档。
2. 构建代码
Spring Boot 不需要任何特定的代码布局即可工作。 但是，有一些最佳实践会有所帮助。
2.1. 使用 “default” 软件包
当类不包含package声明，则认为它位于 “default package” 中。
通常不建议使用 “default package” 并且应该避免使用。
它可能会导致使用@ComponentScan,@ConfigurationPropertiesScan,@EntityScan或@SpringBootApplication注解，因为每个 jar 中的每个类都会被读取。
我们建议您遵循 Java 建议的包命名约定，并使用反向域名（例如com.example.project). |
2.2. 找到 Main Application 类
我们通常建议您将主应用程序类放在其他类上方的根包中。
这@SpringBootApplication注解通常放在你的主类上，它隐式地定义了某些项目的基本 “搜索包”。
例如，如果您正在编写 JPA 应用程序，则@SpringBootApplicationannotated 类用于搜索@Entity项目。
使用根包还允许组件扫描仅应用于您的项目。
如果您不想使用@SpringBootApplication这@EnableAutoConfiguration和@ComponentScan它导入的 annotations 定义了该行为，因此您也可以改用这些 Comments。 |
下面的清单显示了一个典型的布局：
com
+- example
+- myapplication
+- MyApplication.java
|
+- customer
| +- Customer.java
| +- CustomerController.java
| +- CustomerService.java
| +- CustomerRepository.java
|
+- order
+- Order.java
+- OrderController.java
+- OrderService.java
+- OrderRepository.java
这MyApplication.javafile 将声明main方法以及基本@SpringBootApplication如下：
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
@SpringBootApplication
class MyApplication
fun main(args: Array<String>) {
runApplication<MyApplication>(*args)
}
3. 配置类
Spring Boot 支持基于 Java 的配置。
虽然可以使用SpringApplication对于 XML 源，我们通常建议将主源设置为单个@Configuration类。
通常是定义mainmethod 是一个很好的候选者作为主@Configuration.
Internet 上已经发布了许多使用 XML 配置的 Spring 配置示例。
如果可能，请始终尝试使用等效的基于 Java 的配置。
搜索Enable*注释可能是一个很好的起点。 |
4. 自动配置
Spring Boot 自动配置会尝试根据您添加的 jar 依赖项自动配置 Spring 应用程序。
例如，如果HSQLDB在你的 Classpath 上，并且你没有手动配置任何数据库连接 bean，那么 Spring Boot 会自动配置一个内存数据库。
您需要通过添加@EnableAutoConfiguration或@SpringBootApplicationannotations 添加到您的@Configuration类。
您应该只添加一个@SpringBootApplication或@EnableAutoConfiguration注解。
我们通常建议您将其中一个添加到您的主数据库@Configuration仅类。 |
4.1. 逐步替换自动配置
自动配置是非侵入性的。
您可以随时开始定义自己的配置以替换自动配置的特定部分。
例如，如果您添加自己的DataSourcebean，则默认的嵌入式数据库支持会退出。
如果您需要了解当前正在应用的自动配置以及原因，请使用--debug开关。
这样做会为选定的核心记录器启用调试日志，并将条件报告记录到控制台。
4.2. 禁用特定的 Auto-configuration 类
如果您发现正在应用您不希望的特定自动配置类，则可以使用 exclude 属性@SpringBootApplication以禁用它们，如以下示例所示：
@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })
public class MyApplication {
}
@SpringBootApplication(exclude = [DataSourceAutoConfiguration::class])
class MyApplication
如果类不在 Classpath 上，则可以使用excludeName属性，并指定完全限定名称。
如果您更喜欢使用@EnableAutoConfiguration而不是@SpringBootApplication,exclude和excludeName也可用。
最后，您还可以使用spring.autoconfigure.exclude财产。
| 您可以在注释级别定义排除项，也可以使用 property 定义排除项。 |
即使自动配置类是public，类中唯一被视为公共 API 的方面是可用于禁用自动配置的类的名称。
这些类的实际内容（例如嵌套配置类或 bean 方法）仅供内部使用，我们不建议直接使用它们。 |
5. Spring Bean 和依赖注入
您可以自由使用任何标准的 Spring Framework 技术来定义 bean 及其注入的依赖项。
我们通常建议使用构造函数注入来连接依赖项和@ComponentScan查找 Beans。
如果按照上述建议构建代码（将应用程序类放在 top 包中），则可以添加@ComponentScan不使用任何参数或使用@SpringBootApplication注解，其中隐式包含它。
您的所有应用程序组件 （@Component,@Service,@Repository,@Controller等）将自动注册为 Spring Bean。
以下示例显示了@Service使用构造函数注入来获取所需的RiskAssessor豆：
@Service
public class MyAccountService implements AccountService {
private final RiskAssessor riskAssessor;
public MyAccountService(RiskAssessor riskAssessor) {
this.riskAssessor = riskAssessor;
}
// ...
}
@Service
class MyAccountService(private val riskAssessor: RiskAssessor) : AccountService
如果一个 bean 有多个构造函数，则需要标记您希望 Spring 与之一起使用的构造函数@Autowired:
@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;
}
// ...
}
@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. 使用 @SpringBootApplication 注释
许多 Spring Boot 开发人员喜欢他们的应用程序使用自动配置、组件扫描，并能够在他们的“应用程序类”上定义额外的配置。
单个@SpringBootApplicationannotation 可以用来启用这三个功能，即：
-
@EnableAutoConfiguration：启用 Spring Boot 的自动配置机制 -
@ComponentScan：使@ComponentScan 应用程序所在的软件包（请参阅最佳实践) -
@SpringBootConfiguration：启用在上下文中注册额外的 bean 或导入额外的配置类。 Spring 标准的替代方案@Configuration这有助于在集成测试中进行配置检测。
// Same as @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
// same as @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan
@SpringBootApplication
class MyApplication
fun main(args: Array<String>) {
runApplication<MyApplication>(*args)
}
@SpringBootApplication还提供了别名来自定义@EnableAutoConfiguration和@ComponentScan. |
|
这些功能都不是必需的，您可以选择用它启用的任何功能替换此单个注释。 例如，您可能不想在应用程序中使用 component scan 或 configuration properties scan： Java
Kotlin
在此示例中， |
7. 运行应用程序
将应用程序打包为 jar 并使用嵌入式 HTTP 服务器的最大优势之一是，您可以像运行任何其他应用程序一样运行应用程序。 该示例适用于调试 Spring Boot 应用程序。 您不需要任何特殊的 IDE 插件或扩展。
| 本节仅介绍基于 jar 的打包。 如果您选择将应用程序打包为 war 文件，请参阅您的服务器和 IDE 文档。 |
7.1. 从 IDE 运行
您可以从 IDE 将 Spring Boot 应用程序作为 Java 应用程序运行。
但是，您首先需要导入您的项目。
导入步骤因 IDE 和生成系统而异。
大多数 IDE 可以直接导入 Maven 项目。
例如，Eclipse 用户可以选择Import…→Existing Maven Projects从File菜单。
如果您不小心将 Web 应用程序运行了两次，则会看到“Port already in use”错误。
Spring Tools 用户可以使用Relaunch按钮，而不是Run按钮以确保关闭任何现有实例。 |
7.2. 作为打包应用程序运行
如果使用 Spring Boot Maven 或 Gradle 插件创建可执行 jar，则可以使用java -jar，如以下示例所示：
$ java -jar target/myapplication-0.0.1-SNAPSHOT.jar还可以在启用远程调试支持的情况下运行打包的应用程序。 这样做可以将调试器附加到打包的应用程序，如以下示例所示：
$ java -Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n \
-jar target/myapplication-0.0.1-SNAPSHOT.jar7.3. 使用 Maven 插件
Spring Boot Maven 插件包括一个run目标，可用于快速编译和运行应用程序。
应用程序以松散形式运行，就像它们在 IDE 中一样。
以下示例显示了运行 Spring Boot 应用程序的典型 Maven 命令：
$ mvn spring-boot:run您可能还希望使用MAVEN_OPTS作系统环境变量，如以下示例所示：
$ export MAVEN_OPTS=-Xmx1024m7.4. 使用 Gradle 插件
Spring Boot Gradle 插件还包括一个bootRuntask 的 API 请求，该任务可用于以松散形式运行应用程序。
这bootRuntask 时，只要您应用org.springframework.boot和javaplugins 中，如以下示例所示：
$ gradle bootRun
您可能还希望使用JAVA_OPTS作系统环境变量，如以下示例所示：
$ export JAVA_OPTS=-Xmx1024m
7.5. 热插拔
由于 Spring Boot 应用程序是普通的 Java 应用程序，因此 JVM 热交换应该开箱即用。 JVM 热插拔在某种程度上受到它可以替换的字节码的限制。 对于更完整的解决方案，可以使用 JRebel。
这spring-boot-devtools模块还包括对应用程序快速重启的支持。
有关详细信息，请参阅热插拔 “How-to”。
8. 开发者工具
Spring Boot 包含一组额外的工具，这些工具可以使应用程序开发体验更加愉快。
这spring-boot-devtoolsmodule 可以包含在任何项目中，以提供额外的开发时功能。
要包含 devtools 支持，请将模块依赖项添加到您的构建中，如以下 Maven 和 Gradle 清单所示：
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>
</dependencies>dependencies {
developmentOnly("org.springframework.boot:spring-boot-devtools")
}| Devtools 可能会导致类加载问题，尤其是在多模块项目中。诊断类加载问题 介绍了如何诊断和解决这些问题。 |
在运行完全打包的应用程序时，会自动禁用开发人员工具。
如果您的应用程序是从java -jar或者，如果它是从特殊的 Classloader 启动的，则将其视为 “production application”。
您可以使用spring.devtools.restart.enabledsystem 属性。
要启用 devtools，无论使用哪种类加载器来启动应用程序，都可以将-Dspring.devtools.restart.enabled=truesystem 属性。
在运行 devtools 存在安全风险的生产环境中，不得执行此作。
要禁用 devtools，请排除依赖项或将-Dspring.devtools.restart.enabled=falsesystem 属性。 |
在 Maven 中将依赖项标记为可选，或使用developmentOnly配置（如上所示）可防止 devtools 被传递到使用您项目的其他模块。 |
默认情况下，重新打包的存档不包含 devtools。
如果你想使用某个远程 devtools 功能，你需要包含它。
使用 Maven 插件时，将excludeDevtoolsproperty 设置为false.
使用 Gradle 插件时，配置任务的 Classpath 以包含developmentOnly配置. |
8.1. 诊断类加载问题
如 Restart vs Reload 部分所述，重新启动功能是使用两个类加载器实现的。 对于大多数应用程序，此方法效果很好。 但是，它有时会导致类加载问题，尤其是在多模块项目中。
要诊断类加载问题是否确实是由 devtools 及其两个类加载器引起的，请尝试禁用 restart。 如果这解决了您的问题，请自定义重新启动类加载器以包含整个项目。
8.2. 属性默认值
Spring Boot 支持的几个库使用缓存来提高性能。 例如，模板引擎会缓存已编译的模板，以避免重复解析模板文件。 此外，Spring MVC 可以在提供静态资源时将 HTTP 缓存头添加到响应中。
虽然缓存在生产中非常有益，但在开发过程中可能会适得其反，阻止您看到刚刚在应用程序中所做的更改。 因此，spring-boot-devtools默认禁用缓存选项。
缓存选项通常由application.properties文件。
例如，Thymeleaf 提供了spring.thymeleaf.cache财产。
无需手动设置这些属性，spring-boot-devtoolsmodule 会自动应用合理的开发时配置。
下表列出了应用的所有属性：
| 名字 | 默认值 |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
如果不希望应用属性默认值，则可以设置spring.devtools.add-properties自false在application.properties. |
由于在开发 Spring MVC 和 Spring WebFlux 应用程序时需要有关 Web 请求的更多信息，因此开发人员工具建议您启用DEBUGlogging 的weblogging 组。
这将为您提供有关传入请求、哪个处理程序正在处理该请求、响应结果和其他详细信息的信息。
如果您希望记录所有请求详细信息（包括潜在的敏感信息），您可以打开spring.mvc.log-request-details或spring.codec.log-request-detailsconfiguration 属性。
8.3. 自动重启
使用spring-boot-devtools每当 Classpath 上的文件发生更改时自动重新启动。
在 IDE 中工作时，这可能是一个有用的功能，因为它为代码更改提供了一个非常快速的反馈循环。
默认情况下，将监视 Classpath 上指向目录的任何条目的更改。
请注意，某些资源（如静态资产和视图模板）不需要重新启动应用程序。
如果您使用构建插件通过 Maven 或 Gradle 重新启动，则必须将forking设置为enabled.
如果禁用 forking，则不会创建 devtools 使用的隔离应用程序类加载器，并且重启将无法正常运行。 |
| 与 LiveReload 一起使用时，自动重启效果非常好。有关详细信息，请参阅 LiveReload 部分。 如果使用 JRebel，则禁用自动重启，以支持动态类重新加载。 其他 devtools 功能（例如 LiveReload 和属性覆盖）仍然可以使用。 |
DevTools 依赖于应用程序上下文的 shutdown 钩子在重启期间关闭它。
如果您禁用了 shutdown hook （SpringApplication.setRegisterShutdownHook(false)). |
DevTools 需要自定义ResourceLoader由ApplicationContext.
如果您的应用程序已经提供了一个，那么它将被包装。
直接覆盖getResource方法上的ApplicationContext不支持。 |
| 使用 AspectJ 编织时不支持自动重启。 |
8.3.1. 在 Condition Evaluation 中记录变化
默认情况下，每次应用程序重新启动时，都会记录一个显示条件评估增量的报告。 该报告显示在您进行更改（例如添加或删除 Bean 以及设置配置属性）时对应用程序的自动配置的更改。
要禁用报表的日志记录，请设置以下属性：
spring.devtools.restart.log-condition-evaluation-delta=falsespring:
devtools:
restart:
log-condition-evaluation-delta: false8.3.2. 排除资源
某些资源在更改时不一定需要触发重启。
例如，可以就地编辑 Thymeleaf 模板。
默认情况下，将/META-INF/maven,/META-INF/resources,/resources,/static,/public或/templates不会触发重新启动，但会触发实时重新加载。
如果要自定义这些排除项，可以使用spring.devtools.restart.exclude财产。
例如，要仅排除/static和/public您将设置以下属性：
spring.devtools.restart.exclude=static/**,public/**spring:
devtools:
restart:
exclude: "static/**,public/**"如果要保留这些默认值并添加其他排除项，请使用spring.devtools.restart.additional-excludeproperty 来代替。 |
8.3.4. 禁用重启
如果您不想使用重启功能，可以使用spring.devtools.restart.enabled财产。
在大多数情况下，您可以在application.properties（这样做仍然会初始化 Restart ClassLoader，但它不会监视文件更改）。
如果需要完全禁用重启支持（例如，因为它不适用于特定库），则需要将spring.devtools.restart.enabled Systemproperty 设置为false在调用SpringApplication.run(…)，如以下示例所示：
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
System.setProperty("spring.devtools.restart.enabled", "false");
SpringApplication.run(MyApplication.class, args);
}
}
@SpringBootApplication
object MyApplication {
@JvmStatic
fun main(args: Array<String>) {
System.setProperty("spring.devtools.restart.enabled", "false")
SpringApplication.run(MyApplication::class.java, *args)
}
}
8.3.5. 使用 Trigger 文件
如果使用持续编译更改文件的 IDE，则可能更愿意仅在特定时间触发重启。 为此，您可以使用 “trigger file”，这是一个特殊文件，当您想要实际触发重启检查时必须对其进行修改。
| 对文件的任何更新都会触发检查，但只有在 Devtools 检测到它有事情要做时，才会真正发生重启。 |
要使用触发器文件，请将spring.devtools.restart.trigger-fileproperty 设置为触发器文件的名称（不包括任何路径）。
触发器文件必须出现在 Classpath 上的某个位置。
例如，如果您有一个具有以下结构的项目：
src
+- main
+- resources
+- .reloadtrigger
然后，您的trigger-fileproperty 将为：
spring.devtools.restart.trigger-file=.reloadtriggerspring:
devtools:
restart:
trigger-file: ".reloadtrigger"现在，仅当src/main/resources/.reloadtrigger已更新。
您可能希望将spring.devtools.restart.trigger-file作为全局设置，以便您的所有项目都以相同的方式运行。 |
某些 IDE 具有无需手动更新触发器文件的功能。Spring Tools for Eclipse 和 IntelliJ IDEA（旗舰版）都有这样的支持。
使用 Spring Tools，您可以使用控制台视图中的“reload”按钮（只要您的trigger-file被命名为.reloadtrigger).
对于 IntelliJ IDEA，您可以按照其文档中的说明进行作。
8.3.6. 自定义重启类加载器
如前面的 Restart vs Reload 部分所述，重新启动功能是使用两个类加载器实现的。 如果这会导致问题，您可能需要自定义哪个 Classloader 加载的内容。
默认情况下，IDE 中任何打开的项目都会加载 “restart” 类加载器，并且任何常规的.jarfile 使用 “base” 类加载器加载。
如果您使用mvn spring-boot:run或gradle bootRun：包含@SpringBootApplication使用 “restart” 类加载器加载，其他所有内容都使用 “base” 类加载器加载。
你可以通过创建一个META-INF/spring-devtools.properties文件。
这spring-devtools.propertiesfile 可以包含前缀为restart.exclude和restart.include.
这include元素是应该被拉入 “restart” 类加载器中的项，而exclude元素是应该被下推到 “base” 类加载器中的项目。
该属性的值是应用于 Classpath 的正则表达式模式，如以下示例所示：
restart.exclude.companycommonlibs=/mycorp-common-[\\w\\d-\\.]+\\.jar
restart.include.projectcommon=/mycorp-myproj-[\\w\\d-\\.]+\\.jarrestart:
exclude:
companycommonlibs: "/mycorp-common-[\\w\\d-\\.]+\\.jar"
include:
projectcommon: "/mycorp-myproj-[\\w\\d-\\.]+\\.jar"所有属性键都必须是唯一的。
只要属性以restart.include.或restart.exclude.它被考虑。 |
都META-INF/spring-devtools.properties。
您可以将文件打包到项目内部，也可以打包到项目使用的库中。 |
8.4. LiveReload
这spring-boot-devtools模块包括一个嵌入式 LiveReload 服务器，该服务器可用于在资源更改时触发浏览器刷新。
LiveReload 浏览器扩展可免费用于 Chrome、Firefox 和 Safari。
您可以通过在所选浏览器的市场或商店中搜索“LiveReload”来找到这些扩展。
如果您不想在应用程序运行时启动 LiveReload 服务器，则可以将spring.devtools.livereload.enabledproperty 设置为false.
| 您一次只能运行一个 LiveReload 服务器。 在启动应用程序之前，请确保没有其他 LiveReload 服务器正在运行。 如果从 IDE 启动多个应用程序，则只有第一个应用程序支持 LiveReload。 |
| 要在文件更改时触发 LiveReload，必须启用 Automatic Restart。 |
8.5. 全局设置
您可以通过将以下任何文件添加到$HOME/.config/spring-boot目录：
-
spring-boot-devtools.properties -
spring-boot-devtools.yaml -
spring-boot-devtools.yml
添加到这些文件的任何属性都适用于计算机上使用 devtools 的所有 Spring Boot 应用程序。
例如，要将 restart 配置为始终使用触发器文件，您可以将以下属性添加到spring-boot-devtools文件：
spring.devtools.restart.trigger-file=.reloadtriggerspring:
devtools:
restart:
trigger-file: ".reloadtrigger"默认情况下，$HOME是用户的主目录。
要自定义此位置，请将SPRING_DEVTOOLS_HOME环境变量或spring.devtools.homesystem 属性。
如果在$HOME/.config/spring-boot，则$HOME目录中是否存在.spring-boot-devtools.properties文件。
这允许您与位于不支持$HOME/.config/spring-boot位置。 |
|
devtools properties/yaml 文件中不支持配置文件。 在 |
8.5.1. 配置文件系统 Watcher
FileSystemWatcher 的工作原理是以一定的时间间隔轮询类更改，然后等待预定义的静默期以确保没有更多更改。
由于 Spring Boot 完全依赖于 IDE 来编译文件并将其复制到 Spring Boot 可以读取文件的位置，因此您可能会发现有时当 devtools 重新启动应用程序时，某些更改不会反映出来。
如果您经常观察到此类问题，请尝试增加spring.devtools.restart.poll-interval和spring.devtools.restart.quiet-periodparameters 设置为适合您的开发环境的值：
spring.devtools.restart.poll-interval=2s
spring.devtools.restart.quiet-period=1sspring:
devtools:
restart:
poll-interval: "2s"
quiet-period: "1s"现在，每 2 秒轮询一次受监视的 Classpath 目录以查找更改，并保持 1 秒的静默期以确保没有其他类更改。
8.6. 远程应用程序
Spring Boot 开发人员工具不仅限于本地开发。 在远程运行应用程序时，您还可以使用多项功能。 远程支持是可选的，因为启用远程支持可能会带来安全风险。 仅当在受信任的网络上运行时或使用 SSL 进行保护时，才应启用它。 如果这两个选项都不可用，则不应使用 DevTools 的远程支持。 您永远不应在生产部署中启用支持。
要启用它，您需要确保devtools包含在重新打包的存档中，如下面的清单所示：
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<excludeDevtools>false</excludeDevtools>
</configuration>
</plugin>
</plugins>
</build>然后你需要设置spring.devtools.remote.secret财产。
与任何重要的密码或密钥一样，该值应是唯一且强大的，以便无法猜测或暴力破解。
远程 devtools 支持分两部分提供：接受连接的服务器端终端节点和您在 IDE 中运行的客户端应用程序。
当spring.devtools.remote.secret属性。
必须手动启动 client 组件。
| Spring WebFlux 应用程序不支持远程 devtools。 |
8.6.1. 运行远程客户端应用程序
远程客户端应用程序设计为从 IDE 中运行。
您需要运行org.springframework.boot.devtools.RemoteSpringApplication的类路径与您连接到的远程项目相同。
应用程序的单个必需参数是它连接到的远程 URL。
例如，如果您使用的是 Eclipse 或 Spring Tools，并且您有一个名为my-app，您将执行以下作：
-
选择
Run Configurations…从Run菜单。 -
新建
Java Application“启动配置”。 -
浏览
my-app项目。 -
用
org.springframework.boot.devtools.RemoteSpringApplication作为主类。 -
加
https://myapp.cfapps.io到Program arguments（或任何您的远程 URL）。
正在运行的远程客户端可能类似于以下清单：
. ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ ___ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | | _ \___ _ __ ___| |_ ___ \ \ \ \ \\/ ___)| |_)| | | | | || (_| []::::::[] / -_) ' \/ _ \ _/ -_) ) ) ) ) ' |____| .__|_| |_|_| |_\__, | |_|_\___|_|_|_\___/\__\___|/ / / / =========|_|==============|___/===================================/_/_/_/ :: Spring Boot Remote :: (v3.0.13) 2023-11-23T09:04:20.386Z INFO 35386 --- [ main] o.s.b.devtools.RemoteSpringApplication : Starting RemoteSpringApplication v3.0.13 using Java 17.0.9 with PID 35386 (/Users/myuser/.m2/repository/org/springframework/boot/spring-boot-devtools/3.0.13/spring-boot-devtools-3.0.13.jar started by myuser in /opt/apps/) 2023-11-23T09:04:20.393Z INFO 35386 --- [ main] o.s.b.devtools.RemoteSpringApplication : No active profile set, falling back to 1 default profile: "default" 2023-11-23T09:04:20.794Z INFO 35386 --- [ main] o.s.b.d.a.OptionalLiveReloadServer : LiveReload server is running on port 35729 2023-11-23T09:04:20.841Z INFO 35386 --- [ main] o.s.b.devtools.RemoteSpringApplication : Started RemoteSpringApplication in 1.048 seconds (process running for 1.454)
因为远程客户端使用与真实应用程序相同的 Classpath，所以它可以直接读取应用程序属性。
这就是spring.devtools.remote.secret属性被读取并传递给服务器进行身份验证。 |
始终建议使用https://作为连接协议，以便对流量进行加密并且无法拦截密码。 |
如果需要使用代理访问远程应用程序，请配置spring.devtools.remote.proxy.host和spring.devtools.remote.proxy.port性能。 |
8.6.2. 远程更新
远程客户端以与本地重启相同的方式监视应用程序 Classpath 的更改。 任何更新的资源都会推送到远程应用程序，并 （如果需要） 触发重启。 如果您迭代使用本地没有的云服务的功能，这可能会很有帮助。 通常，远程更新和重启比完整的重新生成和部署周期要快得多。
在较慢的开发环境中，可能会出现 Mand period 不够的情况，并且 classes 中的更改可能会被拆分为多个批次。 在上传第一批类更改后，服务器将重新启动。 无法将下一个批次发送到应用程序，因为服务器正在重新启动。
这通常表现为RemoteSpringApplication有关上传某些类失败以及随后的重试的日志。
但也可能导致应用程序代码不一致，以及在上传第一批更改后无法重新启动。
如果您经常观察到此类问题，请尝试增加spring.devtools.restart.poll-interval和spring.devtools.restart.quiet-periodparameters 设置为适合您的开发环境的值。
有关配置这些属性的信息，请参阅配置文件系统监控器部分。
| 仅当远程客户端运行时，文件才会受到监控。 如果在启动远程客户端之前更改文件，则不会将其推送到远程服务器。 |
9. 打包应用程序以进行生产
可执行 jar 可用于生产部署。 由于它们是独立的，因此它们也非常适合基于云的部署。
对于其他“生产就绪”功能，例如运行状况、审计和度量 REST 或 JMX 端点，请考虑添加spring-boot-actuator.
有关详细信息，请参阅 actuator.html。
10. 接下来要读什么
现在，您应该了解如何使用 Spring Boot 以及应遵循的一些最佳实践。 您现在可以继续深入了解特定的 Spring Boot 功能，也可以跳过并阅读 Spring Boot 的“生产就绪”方面。