使用 Spring Boot

1. 构建系统

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

1.1. 依赖管理

Spring Boot 的每个版本都提供了它支持的依赖项的精选列表。实际上，你不需要在构建配置中为这些依赖项中的任何一个提供版本，因为 Spring Boot 会为你管理。当您升级 Spring Boot 本身时，这些依赖项也会以一致的方式升级。spring-doc.cn

如果需要，您仍然可以指定版本并覆盖 Spring Boot 的建议。

精选列表包含可与 Spring Boot 一起使用的所有 Spring 模块，以及第三方库的精炼列表。该列表作为标准的物料清单（）提供，可与 Maven 和 Gradle 一起使用。spring-boot-dependenciesspring-doc.cn

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

1.2. Maven 插件

要了解如何将 Spring Boot 与 Maven 一起使用，请参阅 Spring Boot 的 Maven 插件的文档：spring-doc.cn

参考资料（HTML 和 PDF）)spring-doc.cn
应用程序接口 spring-doc.cn

1.3. Gradle

要了解如何将 Spring Boot 与 Gradle 一起使用，请参阅 Spring Boot 的 Gradle 插件的文档：spring-doc.cn

参考资料（HTML 和 PDF）)spring-doc.cn
应用程序接口 spring-doc.cn

1.4. Ant

可以使用 Apache Ant+Ivy 构建 Spring Boot 项目。 “AntLib” 模块也可用于帮助 Ant 创建可执行的 jar。spring-boot-antlibspring-doc.cn

要声明依赖项，典型文件类似于以下示例：ivy.xmlspring-doc.cn

<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.xmlspring-doc.cn

<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.12" />

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

如果您不想使用该模块，请参阅howto.html “How-to” 。spring-boot-antlib

1.5. Starters

Starters 是一组方便的依赖项描述符，您可以将其包含在应用程序中。您可以获得所需的所有 Spring 和相关技术的一站式商店，而无需搜索示例代码和复制粘贴依赖项描述符。例如，如果您想开始使用 Spring 和 JPA 进行数据库访问，请在项目中包含依赖项。spring-boot-starter-data-jpaspring-doc.cn

Starter 包含许多依赖项，您需要这些依赖项才能快速启动和运行项目，并具有一组一致、受支持的托管传递依赖项。spring-doc.cn

名称中的内容

所有官方Starters都遵循类似的命名模式;，其中是特定类型的应用程序。此命名结构旨在在您需要查找Starters时提供帮助。许多 IDE 中的 Maven 集成允许您按名称搜索依赖项。例如，安装了适当的 Eclipse 或 Spring Tools 插件后，您可以在 POM 编辑器中按 “spring-boot-starter” 并键入 “spring-boot-starter” 以获取完整列表。spring-boot-starter-**ctrl-spacespring-doc.cn

如“创建自己的 Starter”部分所述，第三方 Starters 不应以开头，因为它是为官方 Spring Boot 工件保留的。相反，第三方Starters通常以项目名称开头。例如，名为的第三方初学者项目通常命名为。spring-bootthirdpartyprojectthirdpartyproject-spring-boot-starterspring-doc.cn

Spring Boot 在该组下提供了以下应用程序Starters：org.springframework.bootspring-doc.cn

表 1.Spring Boot 应用程序Starters
名字	描述
`spring-boot-starter`spring-doc.cn	核心Starters，包括自动配置支持、日志记录和 YAMLspring-doc.cn
`spring-boot-starter-activemq`spring-doc.cn	使用 Apache ActiveMQ 的 Starter for JMS 消息传递spring-doc.cn
`spring-boot-starter-amqp`spring-doc.cn	使用 Spring AMQP 和 Rabbit MQ 的入门spring-doc.cn
`spring-boot-starter-aop`spring-doc.cn	使用 Spring AOP 和 AspectJ 进行面向方面编程的入门spring-doc.cn
`spring-boot-starter-artemis`spring-doc.cn	使用 Apache Artemis 的 Starter for JMS 消息传递spring-doc.cn
`spring-boot-starter-batch`spring-doc.cn	使用 Spring Batch 的 Starterspring-doc.cn
`spring-boot-starter-cache`spring-doc.cn	使用 Spring Framework 的缓存支持的 Starterspring-doc.cn
`spring-boot-starter-data-cassandra`spring-doc.cn	使用 Cassandra 分布式数据库和 Spring Data Cassandra 的入门spring-doc.cn
`spring-boot-starter-data-cassandra-reactive`spring-doc.cn	使用 Cassandra 分布式数据库和 Spring Data Cassandra Reactive 的入门spring-doc.cn
`spring-boot-starter-data-couchbase`spring-doc.cn	使用 Couchbase 面向文档的数据库和 Spring Data Couchbase 的入门spring-doc.cn
`spring-boot-starter-data-couchbase-reactive`spring-doc.cn	使用 Couchbase 面向文档的数据库和 Spring Data Couchbase Reactive 的入门spring-doc.cn
`spring-boot-starter-data-elasticsearch`spring-doc.cn	使用 Elasticsearch 搜索和分析引擎和 Spring Data Elasticsearch 的入门版spring-doc.cn
`spring-boot-starter-data-jdbc`spring-doc.cn	使用 Spring Data JDBC 的初学者spring-doc.cn
`spring-boot-starter-data-jpa`spring-doc.cn	将 Spring Data JPA 与 Hibernate 结合使用的入门spring-doc.cn
`spring-boot-starter-data-ldap`spring-doc.cn	使用 Spring Data LDAP 的入门spring-doc.cn
`spring-boot-starter-data-mongodb`spring-doc.cn	使用 MongoDB 面向文档的数据库和 Spring Data MongoDB 的入门spring-doc.cn
`spring-boot-starter-data-mongodb-reactive`spring-doc.cn	使用 MongoDB 面向文档的数据库和 Spring Data MongoDB Reactive 的入门spring-doc.cn
`spring-boot-starter-data-neo4j`spring-doc.cn	使用 Neo4j 图形数据库和 Spring Data Neo4j 的入门spring-doc.cn
`spring-boot-starter-data-r2dbc`spring-doc.cn	使用 Spring Data R2DBC 的Startersspring-doc.cn
`spring-boot-starter-data-redis`spring-doc.cn	将 Redis 键值数据存储与 Spring Data Redis 和 Lettuce 客户端结合使用的入门spring-doc.cn
`spring-boot-starter-data-redis-reactive`spring-doc.cn	将 Redis 键值数据存储与 Spring Data Redis 反应式和 Lettuce 客户端一起使用的入门spring-doc.cn
`spring-boot-starter-data-rest`spring-doc.cn	使用 Spring Data REST 和 Spring MVC 通过 REST 公开 Spring Data 存储库的入门spring-doc.cn
`spring-boot-starter-freemarker`spring-doc.cn	使用 FreeMarker 视图构建 MVC Web 应用程序的入门spring-doc.cn
`spring-boot-starter-graphql`spring-doc.cn	使用 Spring GraphQL 构建 GraphQL 应用程序的入门spring-doc.cn
`spring-boot-starter-groovy-templates`spring-doc.cn	使用 Groovy Templates 视图构建 MVC Web 应用程序的 Starterspring-doc.cn
`spring-boot-starter-hateoas`spring-doc.cn	使用 Spring MVC 和 Spring HATEOAS 构建基于超媒体的 RESTful Web 应用程序的入门spring-doc.cn
`spring-boot-starter-integration`spring-doc.cn	使用 Spring 集成的 Starterspring-doc.cn
`spring-boot-starter-jdbc`spring-doc.cn	将 JDBC 与 HikariCP 连接池一起使用的入门spring-doc.cn
`spring-boot-starter-jersey`spring-doc.cn	使用 JAX-RS 和 Jersey 构建 RESTful Web 应用程序的入门工具。`spring-boot-starter-web` 的替代方案spring-doc.cn
`spring-boot-starter-jooq`spring-doc.cn	使用 jOOQ 通过 JDBC 访问 SQL 数据库的入门工具。`spring-boot-starter-data-jpa` 或 `spring-boot-starter-jdbc` 的替代方案spring-doc.cn
`spring-boot-starter-json`spring-doc.cn	用于读取和写入 json 的 Starterspring-doc.cn
`spring-boot-starter-mail`spring-doc.cn	使用 Java Mail 和 Spring Framework 的电子邮件发送支持的入门spring-doc.cn
`spring-boot-starter-mustache`spring-doc.cn	使用 Mustache 视图构建 Web 应用程序的入门spring-doc.cn
`spring-boot-starter-oauth2-authorization-server`spring-doc.cn	使用 Spring Authorization Server 功能的入门spring-doc.cn
`spring-boot-starter-oauth2-client`spring-doc.cn	使用 Spring Security 的 OAuth2/OpenID Connect 客户端功能的入门spring-doc.cn
`spring-boot-starter-oauth2-resource-server`spring-doc.cn	使用 Spring Security 的 OAuth2 资源服务器功能的入门spring-doc.cn
`spring-boot-starter-quartz`spring-doc.cn	使用 Quartz 调度程序的入门spring-doc.cn
`spring-boot-starter-rsocket`spring-doc.cn	用于构建 RSocket 客户端和服务器的 Starterspring-doc.cn
`spring-boot-starter-security`spring-doc.cn	使用 Spring Security 的 Starterspring-doc.cn
`spring-boot-starter-test`spring-doc.cn	用于使用 JUnit Jupiter、Hamcrest 和 Mockito 等库测试 Spring Boot 应用程序的 Starterspring-doc.cn
`spring-boot-starter-thymeleaf`spring-doc.cn	使用 Thymeleaf 视图构建 MVC Web 应用程序的入门spring-doc.cn
`spring-boot-starter-validation`spring-doc.cn	将 Java Bean 验证与 Hibernate 验证器结合使用的入门spring-doc.cn
`spring-boot-starter-web`spring-doc.cn	使用 Spring MVC 构建 Web（包括 RESTful）应用程序的入门工具。使用 Tomcat 作为默认嵌入式容器spring-doc.cn
`spring-boot-starter-web-services`spring-doc.cn	使用 Spring Web 服务的入门spring-doc.cn
`spring-boot-starter-webflux`spring-doc.cn	使用 Spring Framework 的反应式 Web 支持构建 WebFlux 应用程序的入门spring-doc.cn
`spring-boot-starter-websocket`spring-doc.cn	使用 Spring Framework 的 MVC WebSocket 支持构建 WebSocket 应用程序的入门工具spring-doc.cn

除了应用程序Starters之外，以下Starters还可用于添加生产就绪功能：spring-doc.cn

表 2.Spring Boot 生产Starters
名字	描述
`spring-boot-starter-actuator`spring-doc.cn	使用 Spring Boot 的 Actuator 的 Starter，它提供生产就绪功能来帮助您监控和管理应用程序spring-doc.cn

最后，Spring Boot 还包括以下Starters，如果你想排除或交换特定的技术方面，可以使用这些Starters：spring-doc.cn

表 3.Spring Boot 技术Starters
名字	描述
`spring-boot-starter-jetty`spring-doc.cn	使用 Jetty 作为嵌入式 servlet 容器的入门工具。`spring-boot-starter-tomcat` 的替代方案spring-doc.cn
`spring-boot-starter-log4j2`spring-doc.cn	使用 Log4j2 进行日志记录的入门。`spring-boot-starter-logging` 的替代方案spring-doc.cn
`spring-boot-starter-logging`spring-doc.cn	使用 Logback 进行日志记录的Starters。默认日志记录Startersspring-doc.cn
`spring-boot-starter-reactor-netty`spring-doc.cn	使用 Reactor Netty 作为嵌入式反应式 HTTP 服务器的Starters。spring-doc.cn
`spring-boot-starter-tomcat`spring-doc.cn	使用 Tomcat 作为嵌入式 servlet 容器的入门工具。`spring-boot-starter-web` 使用的默认 servlet 容器Startersspring-doc.cn
`spring-boot-starter-undertow`spring-doc.cn	使用 Undertow 作为嵌入式 servlet 容器的入门工具。`spring-boot-starter-tomcat` 的替代方案spring-doc.cn

要了解如何交换技术方面，请参阅交换 Web 服务器和日志记录系统的操作文档。spring-doc.cn

有关其他社区贡献的启动程序的列表，请参阅 GitHub 上模块中的 README 文件。spring-boot-starters

2. 构建代码

Spring Boot 不需要任何特定的代码布局即可工作。但是，有一些最佳实践会有所帮助。spring-doc.cn

2.1. 使用 “default” 软件包

当一个类不包含声明时，它被视为位于 “default package” 中。通常不建议使用 “default package” 并且应该避免使用。对于使用、、或 Comments 的 Spring Boot 应用程序，它可能会导致特定问题，因为每个 jar 中的每个类都会被读取。package@ComponentScan@ConfigurationPropertiesScan@EntityScan@SpringBootApplicationspring-doc.cn

我们建议您遵循 Java 建议的包命名约定，并使用反向域名（例如）。com.example.project

2.2. 找到 Main Application 类

我们通常建议您将主应用程序类放在其他类上方的根包中。 @SpringBootApplication 注解通常放在你的主类上，它隐式地定义了某些项目的基本 “搜索包”。例如，如果您正在编写 JPA 应用程序，则使用带注释的类的包来搜索项目。使用根包还允许组件扫描仅应用于您的项目。@SpringBootApplication@Entityspring-doc.cn

如果您不想使用，则它导入的和注释定义了该行为，因此您也可以改用这些 Comments。@SpringBootApplication@EnableAutoConfiguration@ComponentScan

下面的清单显示了一个典型的布局：spring-doc.cn

com
 +- example
     +- myapplication
         +- MyApplication.java
         |
         +- customer
         |   +- Customer.java
         |   +- CustomerController.java
         |   +- CustomerService.java
         |   +- CustomerRepository.java
         |
         +- order
             +- Order.java
             +- OrderController.java
             +- OrderService.java
             +- OrderRepository.java

该文件将声明该方法以及基本，如下所示：MyApplication.javamain@SpringBootApplicationspring-doc.cn

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

import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication

@SpringBootApplication
class MyApplication

fun main(args: Array<String>) {
    runApplication<MyApplication>(*args)
}

3. 配置类

Spring Boot 支持基于 Java 的配置。尽管可以与 XML 源一起使用，但我们通常建议主源为单个类。通常，定义方法的类是 primary 的良好候选者。SpringApplication@Configurationmain@Configurationspring-doc.cn

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

3.1. 导入其他 Configuration 类

你不需要把所有的东西都放在一个类中。该 annotation 可用于导入其他 configuration classes。或者，你可以使用 to 自动获取所有 Spring 组件，包括 classes。@Configuration@Import@ComponentScan@Configurationspring-doc.cn

3.2. 导入 XML 配置

如果您绝对必须使用基于 XML 的配置，我们建议您仍然从 class 开始。然后，您可以使用注释来加载 XML 配置文件。@Configuration@ImportResourcespring-doc.cn

4. 自动配置

Spring Boot 自动配置会尝试根据您添加的 jar 依赖项自动配置 Spring 应用程序。例如，如果在你的 Classpath 上，并且你没有手动配置任何数据库连接 bean，那么 Spring Boot 会自动配置内存数据库。HSQLDBspring-doc.cn

您需要通过向其中一个类添加 or 注解来选择自动配置。@EnableAutoConfiguration@SpringBootApplication@Configurationspring-doc.cn

您应该只添加一个或注释。我们通常建议您仅将其中一个添加到主类中。@SpringBootApplication@EnableAutoConfiguration@Configuration

4.1. 逐步替换自动配置

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

如果您需要了解当前正在应用的自动配置以及原因，请使用开关启动您的应用程序。这样做会为选定的核心记录器启用调试日志，并将条件报告记录到控制台。--debugspring-doc.cn

4.2. 禁用特定的 Auto-configuration 类

如果您发现正在应用不需要的特定自动配置类，则可以使用 exclude 属性 of 来禁用它们，如以下示例所示：@SpringBootApplicationspring-doc.cn

Java

import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;

@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })
public class MyApplication {

}

Kotlin

import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

@SpringBootApplication(exclude = [DataSourceAutoConfiguration::class])
class MyApplication

如果类不在 Classpath 上，则可以使用 Comments 的属性并指定完全限定名称。如果您更喜欢使用而不是，并且也可以使用。最后，您还可以使用 property 控制要排除的自动配置类的列表。excludeName@EnableAutoConfiguration@SpringBootApplicationexcludeexcludeNamespring.autoconfigure.excludespring-doc.cn

您可以在注释级别定义排除项，也可以使用 property 定义排除项。

即使自动配置类是，类中被视为公共 API 的唯一方面是可用于禁用自动配置的类的名称。这些类的实际内容（例如嵌套配置类或 bean 方法）仅供内部使用，我们不建议直接使用它们。public

4.3. 自动配置软件包

自动配置包是各种自动配置的功能在扫描实体和 Spring Data 存储库等内容时默认查找的包。注释（直接或通过其存在 on ）确定默认的自动配置包。可以使用 annotation 配置其他软件包。@EnableAutoConfiguration@SpringBootApplication@AutoConfigurationPackagespring-doc.cn

5. Spring Bean 和依赖注入

您可以自由使用任何标准的 Spring Framework 技术来定义 bean 及其注入的依赖项。我们通常建议使用构造函数注入来连接依赖项并查找 bean。@ComponentScanspring-doc.cn

如果按照上述建议构建代码（将应用程序类放在 top 包中），则可以在没有任何参数的情况下添加代码，也可以使用隐式包含它的 Comments。您的所有应用程序组件（、和其他组件）都将自动注册为 Spring Bean。@ComponentScan@SpringBootApplication@Component@Service@Repository@Controllerspring-doc.cn

下面的示例展示了一个使用构造函数注入来获取所需 Bean 的 Bean：@ServiceRiskAssessorspring-doc.cn

Java

import org.springframework.stereotype.Service;

@Service
public class MyAccountService implements AccountService {

    private final RiskAssessor riskAssessor;

    public MyAccountService(RiskAssessor riskAssessor) {
        this.riskAssessor = riskAssessor;
    }

    // ...

}

Kotlin

import org.springframework.stereotype.Service

@Service
class MyAccountService(private val riskAssessor: RiskAssessor) : AccountService

如果一个 bean 有多个构造函数，则需要标记你希望 Spring 使用的构造函数：@Autowiredspring-doc.cn

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

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
    }

    // ...

}

请注意，使用构造函数注入如何让字段被标记为，这表示它随后无法更改。riskAssessorfinal

6. 使用 @SpringBootApplication 注释

许多 Spring Boot 开发人员喜欢他们的应用程序使用自动配置、组件扫描，并能够在他们的“应用程序类”上定义额外的配置。单个 annotation 可用于启用这三个功能，即：@SpringBootApplicationspring-doc.cn

@EnableAutoConfiguration：启用 Spring Boot 的自动配置机制spring-doc.cn
@ComponentScan：在应用程序所在的包上启用 Scan（请参阅最佳实践@Component)spring-doc.cn
@SpringBootConfiguration：启用在上下文中注册额外的 bean 或导入额外的配置类。 Spring 标准的替代方案，有助于在集成测试中进行配置检测。@Configurationspring-doc.cn

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

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

这些功能都不是必需的，您可以选择用它启用的任何功能替换此单个注释。例如，您可能不想在应用程序中使用 component scan 或 configuration properties scan：spring-doc.cn

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

import org.springframework.boot.SpringBootConfiguration
import org.springframework.boot.autoconfigure.EnableAutoConfiguration
import org.springframework.boot.docs.using.structuringyourcode.locatingthemainclass.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)
}

在此示例中，与任何其他 Spring Boot 应用程序一样，只是不会自动检测 -annotated 类和 -annotated 类，并且显式导入用户定义的 bean（请参阅）。MyApplication@Component@ConfigurationProperties@Importspring-doc.cn

7. 运行应用程序

将应用程序打包为 jar 并使用嵌入式 HTTP 服务器的最大优势之一是，您可以像运行任何其他应用程序一样运行应用程序。该示例适用于调试 Spring Boot 应用程序。您不需要任何特殊的 IDE 插件或扩展。spring-doc.cn

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

7.1. 从 IDE 运行

您可以从 IDE 将 Spring Boot 应用程序作为 Java 应用程序运行。但是，您首先需要导入您的项目。导入步骤因 IDE 和生成系统而异。大多数 IDE 可以直接导入 Maven 项目。例如，Eclipse 用户可以从菜单中选择 →。Import…Existing Maven ProjectsFilespring-doc.cn

如果您无法直接将项目导入 IDE，则可以使用构建插件生成 IDE 元数据。 Maven 包括用于 Eclipse 和 IDEA 的插件。 Gradle 为各种 IDE 提供插件。spring-doc.cn

如果您不小心将 Web 应用程序运行了两次，则会看到“Port already in use”错误。 Spring Tools 用户可以使用 button 而不是 button 来确保关闭任何现有实例。RelaunchRun

7.2. 作为打包应用程序运行

如果使用 Spring Boot Maven 或 Gradle 插件创建可执行 jar，则可以使用运行应用程序，如以下示例所示：java -jarspring-doc.cn

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

还可以在启用远程调试支持的情况下运行打包的应用程序。这样做可以将调试器附加到打包的应用程序，如以下示例所示：spring-doc.cn

$ java -agentlib:jdwp=server=y,transport=dt_socket,address=8000,suspend=n \
       -jar target/myapplication-0.0.1-SNAPSHOT.jar

7.3. 使用 Maven 插件

Spring Boot Maven 插件包括一个可用于快速编译和运行应用程序的目标。应用程序以松散形式运行，就像它们在 IDE 中一样。以下示例显示了用于运行 Spring Boot 应用程序的典型 Maven 命令：runspring-doc.cn

$ mvn spring-boot:run

您可能还希望使用 os 环境变量，如以下示例所示：MAVEN_OPTSspring-doc.cn

$ export MAVEN_OPTS=-Xmx1024m

7.4. 使用 Gradle 插件

Spring Boot Gradle 插件还包括一个任务，可用于以爆炸形式运行应用程序。每当您应用 and 插件时，都会添加该任务，如以下示例所示：bootRunbootRunorg.springframework.bootjavaspring-doc.cn

$ gradle bootRun

您可能还希望使用 os 环境变量，如以下示例所示：JAVA_OPTSspring-doc.cn

$ export JAVA_OPTS=-Xmx1024m

7.5. 热插拔

由于 Spring Boot 应用程序是普通的 Java 应用程序，因此 JVM 热交换应该开箱即用。 JVM 热插拔在某种程度上受到它可以替换的字节码的限制。对于更完整的解决方案，可以使用 JRebel。spring-doc.cn

该模块还包括对应用程序快速重启的支持。有关详细信息，请参阅热插拔 “How-to”。spring-boot-devtoolsspring-doc.cn

8. 开发者工具

Spring Boot 包含一组额外的工具，这些工具可以使应用程序开发体验更加愉快。该模块可以包含在任何项目中，以提供其他开发时功能。要包含 devtools 支持，请将模块依赖项添加到您的构建中，如以下 Maven 和 Gradle 清单所示：spring-boot-devtoolsspring-doc.cn

Maven 系列

<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")
}

Devtools 可能会导致类加载问题，尤其是在多模块项目中。诊断类加载问题介绍了如何诊断和解决这些问题。

在运行完全打包的应用程序时，会自动禁用开发人员工具。如果您的应用程序是从特殊类加载器启动的，或者它是从特殊类加载器启动的，则它被视为“生产应用程序”。您可以使用 system 属性控制此行为。要启用 devtools，而不考虑用于启动应用程序的类加载器，请设置 system 属性。在运行 devtools 存在安全风险的生产环境中，不得执行此操作。要禁用 devtools，请排除依赖项或设置 system 属性。java -jarspring.devtools.restart.enabled-Dspring.devtools.restart.enabled=true-Dspring.devtools.restart.enabled=false

在 Maven 中将依赖项标记为可选或在 Gradle 中使用配置（如上所示）可以防止 devtools 被传递到使用您项目的其他模块。developmentOnly

默认情况下，重新打包的存档不包含 devtools。如果你想使用某个远程 devtools 功能，你需要包含它。使用 Maven 插件时，请将属性设置为。使用 Gradle 插件时，请配置任务的 Classpath 以包含 developmentOnly 配置。excludeDevtoolsfalse

8.1. 诊断类加载问题

如 Restart vs Reload 部分所述，重新启动功能是使用两个类加载器实现的。对于大多数应用程序，此方法效果很好。但是，它有时会导致类加载问题，尤其是在多模块项目中。spring-doc.cn

要诊断类加载问题是否确实是由 devtools 及其两个类加载器引起的，请尝试禁用 restart。如果这解决了您的问题，请自定义重新启动类加载器以包含整个项目。spring-doc.cn

8.2. 属性默认值

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

虽然缓存在生产中非常有益，但在开发过程中可能会适得其反，阻止您看到刚刚在应用程序中所做的更改。因此，spring-boot-devtools默认禁用缓存选项。spring-doc.cn

缓存选项通常由文件中的设置配置。例如，Thymeleaf 提供了 property 。无需手动设置这些属性，该模块会自动应用合理的开发时配置。application.propertiesspring.thymeleaf.cachespring-boot-devtoolsspring-doc.cn

下表列出了应用的所有属性：spring-doc.cn

名字默认值

名字	默认值
`server.error.include-binding-errors`spring-doc.cn	`always`spring-doc.cn
`server.error.include-message`spring-doc.cn	`always`spring-doc.cn
`server.error.include-stacktrace`spring-doc.cn	`always`spring-doc.cn
`server.servlet.jsp.init-parameters.development`spring-doc.cn	`true`spring-doc.cn
`server.servlet.session.persistent`spring-doc.cn	`true`spring-doc.cn
`spring.docker.compose.readiness.wait`spring-doc.cn	`only-if-started`spring-doc.cn
`spring.freemarker.cache`spring-doc.cn	`false`spring-doc.cn
`spring.graphql.graphiql.enabled`spring-doc.cn	`true`spring-doc.cn
`spring.groovy.template.cache`spring-doc.cn	`false`spring-doc.cn
`spring.h2.console.enabled`spring-doc.cn	`true`spring-doc.cn
`spring.mustache.servlet.cache`spring-doc.cn	`false`spring-doc.cn
`spring.mvc.log-resolved-exception`spring-doc.cn	`true`spring-doc.cn
`spring.reactor.netty.shutdown-quiet-period`spring-doc.cn	`0s`spring-doc.cn
`spring.template.provider.cache`spring-doc.cn	`false`spring-doc.cn
`spring.thymeleaf.cache`spring-doc.cn	`false`spring-doc.cn
`spring.web.resources.cache.period`spring-doc.cn	`0`spring-doc.cn
`spring.web.resources.chain.cache`spring-doc.cn	`false`spring-doc.cn

server.error.include-binding-errorsspring-doc.cn

alwaysspring-doc.cn

server.error.include-messagespring-doc.cn

alwaysspring-doc.cn

server.error.include-stacktracespring-doc.cn

alwaysspring-doc.cn

server.servlet.jsp.init-parameters.developmentspring-doc.cn

truespring-doc.cn

server.servlet.session.persistentspring-doc.cn

truespring-doc.cn

spring.docker.compose.readiness.waitspring-doc.cn

only-if-startedspring-doc.cn

spring.freemarker.cachespring-doc.cn

falsespring-doc.cn

spring.graphql.graphiql.enabledspring-doc.cn

truespring-doc.cn

spring.groovy.template.cachespring-doc.cn

falsespring-doc.cn

spring.h2.console.enabledspring-doc.cn

truespring-doc.cn

spring.mustache.servlet.cachespring-doc.cn

falsespring-doc.cn

spring.mvc.log-resolved-exceptionspring-doc.cn

truespring-doc.cn

spring.reactor.netty.shutdown-quiet-periodspring-doc.cn

0sspring-doc.cn

spring.template.provider.cachespring-doc.cn

falsespring-doc.cn

spring.thymeleaf.cachespring-doc.cn

falsespring-doc.cn

spring.web.resources.cache.periodspring-doc.cn

0spring-doc.cn

spring.web.resources.chain.cachespring-doc.cn

falsespring-doc.cn

如果不希望应用属性默认值，则可以在 .spring.devtools.add-propertiesfalseapplication.properties

由于在开发 Spring MVC 和 Spring WebFlux 应用程序时需要有关 Web 请求的更多信息，因此开发人员工具建议您为日志记录组启用日志记录。这将为您提供有关传入请求、哪个处理程序正在处理该请求、响应结果和其他详细信息的信息。如果您希望记录所有请求详细信息（包括潜在的敏感信息），则可以打开 or 配置属性。DEBUGwebspring.mvc.log-request-detailsspring.codec.log-request-detailsspring-doc.cn

8.3. 自动重启

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

触发重启

当 DevTools 监控 Classpath 资源时，触发重启的唯一方法是更新 Classpath。无论您使用的是 IDE 还是其中一个构建插件，都必须重新编译修改后的文件以触发重启。更新 Classpath 的方式取决于您使用的工具：spring-doc.cn

在 Eclipse 中，保存修改后的文件会导致 Classpath 更新并触发重新启动。spring-doc.cn
在 IntelliJ IDEA 中，构建项目（）具有相同的效果。Build +→+ Build Projectspring-doc.cn
如果使用构建插件，则为 Maven 或 Gradle 运行将触发重启。mvn compilegradle buildspring-doc.cn

如果要使用构建插件通过 Maven 或 Gradle 重新启动，则必须将设置保留为。如果禁用 forking，则不会创建 devtools 使用的隔离应用程序类加载器，并且重启将无法正常运行。forkingenabled

与 LiveReload 一起使用时，自动重启效果非常好。有关详细信息，请参阅 LiveReload 部分。如果使用 JRebel，则禁用自动重启，以支持动态类重新加载。其他 devtools 功能（例如 LiveReload 和属性覆盖）仍然可以使用。

DevTools 依赖于应用程序上下文的 shutdown 钩子在重启期间关闭它。如果你禁用了 shutdown hook （），它就无法正常工作。SpringApplication.setRegisterShutdownHook(false)

DevTools 需要自定义 . 如果您的应用程序已经提供了一个，那么它将被包装。不支持直接覆盖上的方法。ResourceLoaderApplicationContextgetResourceApplicationContext

使用 AspectJ 编织时不支持自动重启。

重启 vs 重新加载

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

如果您发现重新启动对于您的应用程序来说不够快，或者您遇到了类加载问题，您可以考虑从 ZeroTurnaround 重新加载 JRebel 等技术。这些通过在加载时重写类来使它们更适合重新加载。spring-doc.cn

8.3.1. 在 Condition Evaluation 中记录变化

默认情况下，每次应用程序重新启动时，都会记录一个显示条件评估增量的报告。该报告显示在您进行更改（例如添加或删除 Bean 以及设置配置属性）时对应用程序的自动配置的更改。spring-doc.cn

要禁用报表的日志记录，请设置以下属性：spring-doc.cn

性能

spring.devtools.restart.log-condition-evaluation-delta=false

Yaml

spring:
  devtools:
    restart:
      log-condition-evaluation-delta: false

8.3.2. 排除资源

某些资源在更改时不一定需要触发重启。例如，可以就地编辑 Thymeleaf 模板。默认情况下，更改、、、、或中的资源不会触发重新启动，但会触发实时重新加载。如果要自定义这些排除项，可以使用 property 。例如，若要仅排除，您将设置以下属性：/META-INF/maven/META-INF/resources/resources/static/public/templatesspring.devtools.restart.exclude/static/publicspring-doc.cn

性能

spring.devtools.restart.exclude=static/**,public/**

Yaml

spring:
  devtools:
    restart:
      exclude: "static/**,public/**"

如果要保留这些默认值并添加其他排除项，请改用该属性。spring.devtools.restart.additional-exclude

8.3.3. 监视其他路径

您可能希望在更改不在 Classpath 上的文件时重新启动或重新加载应用程序。为此，请使用该属性配置其他路径以监视更改。您可以使用前面描述的属性来控制其他路径下的更改是触发完全重新启动还是实时重新加载。spring.devtools.restart.additional-pathsspring.devtools.restart.excludespring-doc.cn

8.3.4. 禁用重启

如果不想使用重新启动功能，可以使用属性 . 在大多数情况下，你可以在你的（这样做仍然会初始化重启 classloader，但它不会监视文件更改）。spring.devtools.restart.enabledapplication.propertiesspring-doc.cn

如果需要完全禁用重新启动支持（例如，因为它不适用于特定库），则需要将属性设置为 before calling ，如以下示例所示：spring.devtools.restart.enabledSystemfalseSpringApplication.run(…)spring-doc.cn

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

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)
    }

}

8.3.5. 使用 Trigger 文件

如果使用持续编译更改文件的 IDE，则可能更愿意仅在特定时间触发重启。为此，您可以使用 “trigger file”，这是一个特殊文件，当您想要实际触发重启检查时必须对其进行修改。spring-doc.cn

对文件的任何更新都会触发检查，但只有在 Devtools 检测到它有事情要做时，才会真正发生重启。

要使用触发器文件，请将 property 设置为触发器文件的名称（不包括任何路径）。触发器文件必须出现在 Classpath 上的某个位置。spring.devtools.restart.trigger-filespring-doc.cn

例如，如果您有一个具有以下结构的项目：spring-doc.cn

src
+- main
   +- resources
      +- .reloadtrigger

那么您的财产将是：trigger-filespring-doc.cn

性能

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

Yaml

spring:
  devtools:
    restart:
      trigger-file: ".reloadtrigger"

现在，只有在更新时才会重新启动。src/main/resources/.reloadtriggerspring-doc.cn

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

某些 IDE 具有无需手动更新触发器文件的功能。Spring Tools for Eclipse 和 IntelliJ IDEA（旗舰版）都有这样的支持。使用 Spring Tools，您可以使用控制台视图中的 “reload” 按钮（只要您的名称为）。对于 IntelliJ IDEA，您可以按照其文档中的说明进行操作。trigger-file.reloadtriggerspring-doc.cn

8.3.6. 自定义重启类加载器

如前面的 Restart vs Reload 部分所述，重新启动功能是使用两个类加载器实现的。如果这会导致问题，您可以使用 system 属性来诊断问题，如果应用程序在关闭 restart 的情况下工作，则可能需要自定义哪个类加载器加载的内容。spring.devtools.restart.enabledspring-doc.cn

默认情况下，IDE 中任何打开的项目都使用 “restart” 类加载器加载，任何常规文件都使用 “base” 类加载器加载。如果使用 or ，情况也是如此：包含 your 的项目使用 “restart” 类加载器加载，其他所有内容都使用 “base” 类加载器加载。当您启动应用程序时，类路径将打印在控制台上，这有助于识别任何有问题的条目。反射式使用的类，尤其是 Comments，可以在启动时在使用它们的应用程序类之前加载到父（固定）类加载器中，这可能会导致应用程序中的 Spring 无法检测到它们。.jarmvn spring-boot:rungradle bootRun@SpringBootApplicationspring-doc.cn

你可以通过创建一个文件来指示 Spring Boot 使用不同的类加载器加载项目的各个部分。该文件可以包含前缀为和的属性。元素是应该被拉入 “restart” 类加载器中的项，元素是应该被下推到 “base” 类加载器中的项。该属性的值是应用于启动时传递给 JVM 的 Classpath 的正则表达式模式。下面是一个示例，其中排除了一些本地类文件，并且重新启动类加载器中包含了一些额外的库：META-INF/spring-devtools.propertiesspring-devtools.propertiesrestart.excluderestart.includeincludeexcludespring-doc.cn

性能

restart.exclude.companycommonlibs=/mycorp-common-[\\w\\d-\\.]/(build|bin|out|target)/
restart.include.projectcommon=/mycorp-myproj-[\\w\\d-\\.]+\\.jar

Yaml

restart:
  exclude:
    companycommonlibs: "/mycorp-common-[\\w\\d-\\.]/(build|bin|out|target)/"
  include:
    projectcommon: "/mycorp-myproj-[\\w\\d-\\.]+\\.jar"

所有属性键都必须是唯一的。只要属性以或 Consider 开头。restart.include.restart.exclude.

加载 Classpath 中的所有内容。您可以将文件打包到项目内部，也可以打包到项目使用的库中。系统属性不能使用，只能使用属性文件。META-INF/spring-devtools.properties

8.3.7. 已知限制

重新启动功能不适用于使用标准 . 如果需要反序列化数据，则可能需要将 Spring 的与 .ObjectInputStreamConfigurableObjectInputStreamThread.currentThread().getContextClassLoader()spring-doc.cn

不幸的是，一些第三方库在没有考虑上下文类加载器的情况下进行反序列化。如果您发现此类问题，则需要与原作者请求修复。spring-doc.cn

8.4. LiveReload

该模块包括一个嵌入式 LiveReload 服务器，该服务器可用于在更改资源时触发浏览器刷新。 LiveReload 浏览器扩展可免费用于 Chrome、Firefox 和 Safari。您可以通过在所选浏览器的市场或商店中搜索“LiveReload”来找到这些扩展。spring-boot-devtoolsspring-doc.cn

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

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

要在文件更改时触发 LiveReload，必须启用 Automatic Restart。

8.5. 全局设置

您可以通过将以下任何文件添加到目录来配置全局 devtools 设置：$HOME/.config/spring-bootspring-doc.cn

spring-boot-devtools.propertiesspring-doc.cn
spring-boot-devtools.yamlspring-doc.cn
spring-boot-devtools.ymlspring-doc.cn

添加到这些文件的任何属性都适用于计算机上使用 devtools 的所有 Spring Boot 应用程序。例如，要将 restart 配置为始终使用触发器文件，请将以下属性添加到文件中：spring-boot-devtoolsspring-doc.cn

性能

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

Yaml

spring:
  devtools:
    restart:
      trigger-file: ".reloadtrigger"

默认情况下，是用户的主目录。要自定义此位置，请设置环境变量或 system 属性。$HOMESPRING_DEVTOOLS_HOMEspring.devtools.homespring-doc.cn

如果在中找不到 devtools 配置文件，则搜索目录的根目录以查找是否存在文件。这允许您将 devtools 全局配置与位于不支持该位置的较旧版本 Spring Boot 上的应用程序共享。$HOME/.config/spring-boot$HOME.spring-boot-devtools.properties$HOME/.config/spring-boot

devtools properties/yaml 文件中不支持配置文件。spring-doc.cn

激活的任何配置文件都不会影响特定于配置文件的配置文件的加载。不支持 YAML 和 Properties 文件中的配置文件特定文件名（形式）和文档。.spring-boot-devtools.propertiesspring-boot-devtools-<profile>.propertiesspring.config.activate.on-profilespring-doc.cn

8.5.1. 配置文件系统 Watcher

FileSystemWatcher 的工作原理是以一定的时间间隔轮询类更改，然后等待预定义的静默期以确保没有更多更改。由于 Spring Boot 完全依赖于 IDE 来编译文件并将其复制到 Spring Boot 可以读取文件的位置，因此您可能会发现有时当 devtools 重新启动应用程序时，某些更改不会反映出来。如果您经常观察到此类问题，请尝试将 and 参数增加到适合您的开发环境的值：spring.devtools.restart.poll-intervalspring.devtools.restart.quiet-periodspring-doc.cn

性能

spring.devtools.restart.poll-interval=2s
spring.devtools.restart.quiet-period=1s

Yaml

spring:
  devtools:
    restart:
      poll-interval: "2s"
      quiet-period: "1s"

现在，每 2 秒轮询一次受监视的 Classpath 目录以查找更改，并保持 1 秒的静默期以确保没有其他类更改。spring-doc.cn

8.6. 远程应用程序

Spring Boot 开发人员工具不仅限于本地开发。在远程运行应用程序时，您还可以使用多项功能。远程支持是可选的，因为启用远程支持可能会带来安全风险。仅当在受信任的网络上运行时或使用 SSL 进行保护时，才应启用它。如果这两个选项都不可用，则不应使用 DevTools 的远程支持。您永远不应在生产部署中启用支持。spring-doc.cn

要启用它，您需要确保它包含在重新打包的存档中，如下面的清单所示：devtoolsspring-doc.cn

<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.secretspring-doc.cn

远程 devtools 支持分两部分提供：接受连接的服务器端终端节点和您在 IDE 中运行的客户端应用程序。设置该属性时，将自动启用服务器组件。必须手动启动 client 组件。spring.devtools.remote.secretspring-doc.cn

Spring WebFlux 应用程序不支持远程 devtools。

8.6.1. 运行远程客户端应用程序

远程客户端应用程序设计为从 IDE 中运行。您需要使用与连接到的远程项目相同的 Classpath 运行。应用程序的单个必需参数是它连接到的远程 URL。org.springframework.boot.devtools.RemoteSpringApplicationspring-doc.cn

例如，如果您正在使用 Eclipse 或 Spring Tools，并且您有一个名为 Cloud Foundry 的项目，并且已将其部署到 Cloud Foundry，则可以执行以下操作：my-appspring-doc.cn

从菜单中选择。Run Configurations…Runspring-doc.cn
创建新的 “launch configuration”。Java Applicationspring-doc.cn
浏览项目。my-appspring-doc.cn
用作主类。org.springframework.boot.devtools.RemoteSpringApplicationspring-doc.cn
添加到（或任何您的远程 URL）。https://myapp.cfapps.ioProgram argumentsspring-doc.cn

正在运行的远程客户端可能类似于以下清单：spring-doc.cn

  .   ____          _                                              __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _          ___               _      \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` |        | _ \___ _ __  ___| |_ ___ \ \ \ \
 \\/  ___)| |_)| | | | | || (_| []::::::[]   / -_) '  \/ _ \  _/ -_) ) ) ) )
  '  |____| .__|_| |_|_| |_\__, |        |_|_\___|_|_|_\___/\__\___|/ / / /
 =========|_|==============|___/===================================/_/_/_/
 :: Spring Boot Remote ::  (v3.1.12)

2024-05-23T07:27:59.155Z  INFO 110159 --- [           main] o.s.b.devtools.RemoteSpringApplication   : Starting RemoteSpringApplication v3.1.12 using Java 17.0.11 with PID 110159 (/Users/myuser/.m2/repository/org/springframework/boot/spring-boot-devtools/3.1.12/spring-boot-devtools-3.1.12.jar started by myuser in /opt/apps/)
2024-05-23T07:27:59.169Z  INFO 110159 --- [           main] o.s.b.devtools.RemoteSpringApplication   : No active profile set, falling back to 1 default profile: "default"
2024-05-23T07:28:00.096Z  INFO 110159 --- [           main] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729
2024-05-23T07:28:00.165Z  INFO 110159 --- [           main] o.s.b.devtools.RemoteSpringApplication   : Started RemoteSpringApplication in 2.128 seconds (process running for 3.092)

因为远程客户端使用与真实应用程序相同的 Classpath，所以它可以直接读取应用程序属性。这是读取属性并将其传递给服务器进行身份验证的方式。spring.devtools.remote.secret

始终建议用作连接协议，以便对流量进行加密并且无法拦截密码。https://

如果需要使用代理访问远程应用程序，请配置 and 属性。spring.devtools.remote.proxy.hostspring.devtools.remote.proxy.port

8.6.2. 远程更新

远程客户端以与本地重启相同的方式监视应用程序 Classpath 的更改。任何更新的资源都会推送到远程应用程序，并（如果需要）触发重启。如果您迭代使用本地没有的云服务的功能，这可能会很有帮助。通常，远程更新和重启比完整的重新生成和部署周期要快得多。spring-doc.cn

在较慢的开发环境中，可能会出现 Mand period 不够的情况，并且 classes 中的更改可能会被拆分为多个批次。在上传第一批类更改后，服务器将重新启动。无法将下一个批次发送到应用程序，因为服务器正在重新启动。spring-doc.cn

这通常表现为日志中有关无法上传某些类的警告，以及随后的重试。但也可能导致应用程序代码不一致，以及在上传第一批更改后无法重新启动。如果您经常观察到此类问题，请尝试将 and 参数增加到适合您的开发环境的值。有关配置这些属性的信息，请参阅配置文件系统监控器部分。RemoteSpringApplicationspring.devtools.restart.poll-intervalspring.devtools.restart.quiet-periodspring-doc.cn

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

9. 打包应用程序以进行生产

可执行 jar 可用于生产部署。由于它们是独立的，因此它们也非常适合基于云的部署。spring-doc.cn

对于其他“生产就绪”功能，例如运行状况、审核和度量 REST 或 JMX 端点，请考虑添加 . 有关详细信息，请参阅 actuator.html。spring-boot-actuatorspring-doc.cn

10. 接下来要读什么

现在，您应该了解如何使用 Spring Boot 以及应遵循的一些最佳实践。您现在可以继续深入了解特定的 Spring Boot 功能，也可以跳过并阅读 Spring Boot 的“生产就绪”方面。spring-doc.cn