Route-nice
0%

SpringBoot官方文档翻译-使用SpringBoot

发表于 更新于 分类于 Disqus：

使用SpringBoot

本节将详细介绍如何使用 Spring Boot。它涵盖了诸如构建系统，自动配置以及如何运行应用程序之类的主题。我们还将介绍一些 Spring Boot 最佳实践。尽管 Spring Boot 并没有什么特别的地方(它只是另一个可以使用的库)，但是有一些建议可以使您的开发过程更轻松一些。

如果您是从 Spring Boot 开始的，那么在进入本节之前，您应该阅读 Getting Started指南

系统构建

强烈建议您选择一个支持dependency management并且可以使用发布到“ Maven Central”存储库的工件的构建系统。我们建议您选择 Maven 或 Gradle。可以使 Spring Boot 与其他构建系统(例如，Ant)一起使用，但是它们并没有得到很好的支持。

依赖性管理

Spring Boot的每个版本都提供了它所支持的依赖项的列表。实际上，您不需要为构建配置中的所有这些依赖项提供版本，因为 Spring Boot 会为您管理版本。当您升级 Spring Boot 本身时，这些依赖项也会以一致的方式升级。

Note

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

精选列表包含可与 Spring Boot 一起使用的所有 spring 模块以及经过改进的第三方库列表。该列表作为标准物料 Lists(Spring 引导相关性)可用，可以与Maven和Gradle一起使用。

Warning

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

Maven

要了解如何使用Spring Boot与Maven，请参考Spring Boot的Maven插件文档:Maven

Gradle

Spring Boot Gradle插件在Gradle中提供了Spring Boot支持，允许您打包可执行的jar或war文件，运行Spring Boot应用程序，并使用spring-boot-dependencies提供的依赖管理。它需要6级(6.3级或更高)。Gradle 5.6。x也被支持，但是这个支持不被支持，将在将来的版本中被删除。请参考插件的文档来了解更多:

Ant

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

要声明依赖关系，典型的ivy.xml文件看起来类似于以下示例：

1
2
3
4
5
6
7
8
9
10
11
<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类似于以下示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
<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="2.1.1.RELEASE" />

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

Tip

如果您不想使用spring-boot-antlib模块，请参阅 第 91.9 节“不使用 spring-boot-antlib 从 Ant 构建可执行存档”“操作方法”。

Starters

Starter 程序是一组方便的依赖项描述符，您可以在应用程序中包括它们。您可以获得所需的所有Spring和相关技术的一站式服务，而无需遍历示例代码和复制粘贴依赖描述符的加载。例如，如果要开始使用 Spring 和 JPA 进行数据库访问，请在项目中包括spring-boot-starter-data-jpa依赖项。

Starter 程序包含许多启动项目并快速运行所需的依赖项，并且具有一组受支持的受管传递性依赖项。

What’s in a name

所有“官方”Starter 者都遵循类似的命名方式； spring-boot-starter-*，其中*是特定类型的应用程序。这种命名结构旨在在您需要寻找 Starter 者时提供帮助。许多 IDE 中的 Maven 集成使您可以按名称搜索依赖项。例如，在安装了适当的 Eclipse 或 STS 插件的情况下，您可以在 POM 编辑器中按ctrl-space并键入“ spring-boot-starter”以获取完整列表。

如“ 创建自己的 Starter”部分中所述，第三方启动程序不应以spring-boot开头，因为它是为官方 Spring Boot 工件保留的。而是，第三方启动程序通常以项目名称开头。例如，一个名为thirdpartyproject的第三方启动程序项目通常会被命名为thirdpartyproject-spring-boot-starter。

Spring Boot 在org.springframework.boot组下提供了以下应用程序启动器：

表 13.1. Spring Boot 应用程序启动器

Name Description Pom
spring-boot-starter 核心 Starter 工具，包括自动配置支持，日志记录和 YAML Pom
spring-boot-starter-activemq 使用 Apache ActiveMQ 的 JMS 消息传递 Starter Pom
spring-boot-starter-amqp 使用 Spring AMQP 和 Rabbit MQ 的 Starter Pom
spring-boot-starter-aop 使用 Spring AOP 和 AspectJ 进行面向方面编程的 Starter Pom
spring-boot-starter-artemis 使用 Apache Artemis 的 JMS 消息传递 Starter Pom
spring-boot-starter-batch 使用 Spring Batch 的 Starter Pom
spring-boot-starter-cache 使用 Spring Framework 的缓存支持的 Starter 者 Pom
spring-boot-starter-cloud-connectors 使用 Spring Cloud Connectors 的 Starter 程序，可简化与 Cloud Foundry 和 Heroku 等云平台中服务的连接 Pom
spring-boot-starter-data-cassandra 使用 Cassandra 分布式数据库和 Spring Data Cassandra 的 Starter Pom
spring-boot-starter-data-cassandra-reactive 使用 Cassandra 分布式数据库和 Spring Data Cassandra Reactive 的 Starter Pom
spring-boot-starter-data-couchbase 使用 Couchbase 面向文档的数据库和 Spring Data Couchbase 的 Starter Pom
spring-boot-starter-data-couchbase-reactive 使用 Couchbase 面向文档的数据库和 Spring Data Couchbase Reactive 的 Starter Pom
spring-boot-starter-data-elasticsearch 使用 Elasticsearch 搜索和分析引擎以及 Spring Data Elasticsearch 的 Starter 者 Pom
spring-boot-starter-data-jdbc 使用 Spring Data JDBC 的 Starter Pom
spring-boot-starter-data-jpa 将 Spring Data JPA 与 Hibernate 结合使用的 Starter Pom
spring-boot-starter-data-ldap 使用 Spring Data LDAP 的 Starter Pom
spring-boot-starter-data-mongodb 使用 MongoDB 面向文档的数据库和 Spring Data MongoDB 的 Starter Pom
spring-boot-starter-data-mongodb-reactive 使用 MongoDB 面向文档的数据库和 Spring Data MongoDB Reactive 的 Starter Pom
spring-boot-starter-data-neo4j 使用 Neo4j 图形数据库和 Spring Data Neo4j 的 Starter Pom
spring-boot-starter-data-redis 使用 Redis 键值数据存储与 Spring Data Redis 和 Lettuce Client 端的 Starter Pom
spring-boot-starter-data-redis-reactive 将 Redis 键值数据存储与 Spring Data Redis Reacting 和 Lettuce Client 端一起使用的 Starter Pom
spring-boot-starter-data-rest 使用 Spring Data REST 在 REST 上公开 Spring Data 存储库的 Starter Pom
spring-boot-starter-data-solr 结合使用 Apache Solr 搜索平台和 Spring Data Solr 的 Starter 者 Pom
spring-boot-starter-freemarker 使用 FreeMarker 视图构建 MVC Web 应用程序的 Starter Pom
spring-boot-starter-groovy-templates 使用 Groovy 模板视图构建 MVC Web 应用程序的 Starter Pom
spring-boot-starter-hateoas 使用 Spring MVC 和 Spring HATEOAS 构建基于超媒体的 RESTful Web 应用程序的 Starter 者 Pom
spring-boot-starter-integration 使用 Spring Integration 的 Starter Pom
spring-boot-starter-jdbc 结合使用 JDBC 和 HikariCP 连接池的 Starter Pom
spring-boot-starter-jersey 使用 JAX-RS 和 Jersey 构建 RESTful Web 应用程序的 Starter。 spring-boot-starter-web的替代品 Pom
spring-boot-starter-jooq 使用 jOOQ 访问 SQL 数据库的 Starter。替代spring-boot-starter-data-jpa或spring-boot-starter-jdbc Pom
spring-boot-starter-json 读写 JSON Starter Pom
spring-boot-starter-jta-atomikos 使用 Atomikos 的 JTATransactionStarter Pom
spring-boot-starter-jta-bitronix 使用 Bitronix 的 JTATransactionStarter Pom
spring-boot-starter-mail 开始使用 Java Mail 和 Spring Framework 的电子邮件发送支持 Pom
spring-boot-starter-mustache 使用 Mustache 视图构建 Web 应用程序的 Starter Pom
spring-boot-starter-oauth2-client 使用 Spring Security 的 OAuth2/OpenID Connect Client 端功能的 Starter Pom
spring-boot-starter-oauth2-resource-server 使用 Spring Security 的 OAuth2 资源服务器功能的 Starter Pom
spring-boot-starter-quartz Starter 使用 Quartz Scheduler Pom
spring-boot-starter-security 使用 Spring Security 的 Starter Pom
spring-boot-starter-test 用于使用包括 JUnit，Hamcrest 和 Mockito 在内的库测试 Spring Boot 应用程序的 Starter 程序 Pom
spring-boot-starter-thymeleaf 使用 Thymeleaf 视图构建 MVC Web 应用程序的 Starter Pom
spring-boot-starter-validation 通过 Hibernate Validator 使用 Java Bean 验证的 Starter Pom
spring-boot-starter-web 使用 Spring MVC 构建 Web(包括 RESTful)应用程序的 Starter 者。使用 Tomcat 作为默认的嵌入式容器 Pom
spring-boot-starter-web-services 使用 Spring Web Services 的 Starter Pom
spring-boot-starter-webflux 使用 Spring Framework 的反应式 Web 支持构建 WebFlux 应用程序的 Starter 者 Pom
spring-boot-starter-websocket 使用 Spring Framework 的 WebSocket 支持构建 WebSocket 应用程序的 Starter Pom

除应用程序启动程序外，以下启动程序还可用于添加 production ready 功能：

表 13.2 Spring Boot 生产启动器

Name Description Pom
spring-boot-starter-actuator 使用 Spring Boot 的 Actuator 的 Starter 程序，它提供了生产就绪功能，可帮助您监视和 Management 应用程序 Pom

最后，Spring Boot 还包括以下启动程序，如果您想排除或交换特定的技术方面，可以使用这些启动程序：

表 13.3 Spring Boot 技术 Starter

Name Description Pom
spring-boot-starter-jetty 使用 Jetty 作为嵌入式 servlet 容器的 Starter 者。 spring-boot-starter-tomcat的替代品 Pom
spring-boot-starter-log4j2 使用 Log4j2 进行日志记录的启动器。 spring-boot-starter-logging的替代品 Pom
spring-boot-starter-logging 使用 Logback 进行日志记录的启动器。默认记录启动器 Pom
spring-boot-starter-reactor-netty 使用 Reactor Netty 作为嵌入式反应式 HTTP 服务器的 Starter 者。 Pom
spring-boot-starter-tomcat 使用 Tomcat 作为嵌入式 servlet 容器的 Starter。 spring-boot-starter-web使用的默认 servlet 容器启动器 Pom
spring-boot-starter-undertow 使用 Undertow 作为嵌入式 servlet 容器的 Starter。 spring-boot-starter-tomcat的替代品 Pom

Tip

有关其他社区贡献的 Starter 者的列表，请参阅 GitHub spring-boot-starters模块中的README file。

构建代码

Spring Boot 不需要任何特定的代码布局即可工作。但是，有一些最佳实践可以帮助您。

使用”default”软件包

当一个类不包含package声明时，它将被视为在“默认包”中。通常不建议使用“默认程序包”，应避免使用。对于使用@ComponentScan，@EntityScan或@SpringBootApplication注解的 Spring Boot 应用程序，这可能会导致特定的问题，因为每个 jar 中的每个类都会被读取。

Tip

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

查找主应用程序类

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

Tip

如果您不想使用@SpringBootApplication，则导入的@EnableAutoConfiguration和@ComponentScan注解将定义该行为，因此也可以使用它。

以下 Lists 显示了典型的布局：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
com
 +- example
     +- myapplication
         +- Application.java
         |
         +- customer
         |   +- Customer.java
         |   +- CustomerController.java
         |   +- CustomerService.java
         |   +- CustomerRepository.java
         |
         +- order
             +- Order.java
             +- OrderController.java
             +- OrderService.java
             +- OrderRepository.java

Application.java文件将声明main方法以及基本的@SpringBootApplication，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.example.myapplication;

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

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

配置类

Spring Boot 支持基于 Java 的配置。尽管可以将SpringApplication与 XML 源一起使用，但是我们通常建议您的主要源为单个@Configuration类。通常，定义main方法的类是主要@Configuration的不错的选择。

Tip

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

导入其他配置类

您无需将所有@Configuration都放在一个类中。 @Import注解可用于导入其他配置类。另外，您可以使用@ComponentScan自动拾取所有 Spring 组件，包括@Configuration类。

导入 XML 配置

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

自动配置

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

您需要通过向@Configuration类之一添加@EnableAutoConfiguration或`@SpringBootApplication注解来选择自动配置。

Tip

您只能添加一个@SpringBootApplication或@EnableAutoConfiguration注解。通常，我们建议您仅其中一个添加到主要的@Configuration类中。

逐步取代自动配置

自动配置是非侵入性的。在任何时候，您都可以开始定义自己的配置，以替换自动配置的特定部分。例如，如果您添加自己的DataSource bean，则默认的嵌入式数据库支持将退出。

如果您需要找出当前正在应用的自动配置以及原因，请使用--debug开关启动您的应用程序。这样做可以启用调试日志以供选择核心 Logger，并将条件报告记录到控制台。

禁用特定的自动配置类

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

1
2
3
4
5
6
7
8
import org.springframework.boot.autoconfigure.*;
import org.springframework.boot.autoconfigure.jdbc.*;
import org.springframework.context.annotation.*;

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

如果该类不在 Classpath 中，则可以使用注解的excludeName属性，并指定完全限定的名称。最后，您还可以使用spring.autoconfigure.exclude属性来控制要排除的自动配置类的列表。

Tip

您可以在 Comments 级别和使用属性来定义排除项。

SpringBean和依赖注入

您可以自由使用任何标准的 Spring Framework 技术来定义 bean 及其注入的依赖项。为简单起见，我们经常发现使用@ComponentScan(查找您的 bean)和使用@Autowired(进行构造函数注入)效果很好。

如果按照上面的建议构造代码(将应用程序类放在根包中)，则可以添加@ComponentScan而没有任何参数。您的所有应用程序组件(@Component，@Service，@Repository，@Controller等)都会自动注册为 Spring Bean。

以下示例显示了一个@Service Bean，它使用构造函数注入来获取所需的RiskAssessor bean：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.example.service;

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

@Service
public class DatabaseAccountService implements AccountService {

    private final RiskAssessor riskAssessor;

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

    // ...

}

如果 bean 具有一个构造函数，则可以省略@Autowired，如以下示例所示：

1
2
3
4
5
6
7
8
9
10
11
12
@Service
public class DatabaseAccountService implements AccountService {

    private final RiskAssessor riskAssessor;

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

    // ...

}

Tip

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

使用SpringBootApplication注解

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

  • @EnableAutoConfiguration：启用Spring Boot 的自动配置机制
  • @ComponentScan：对应用程序所在的软件包启用@Component扫描(请参见最佳做法
  • @Configuration：允许在上下文中注册额外的 bean 或导入其他配置类

@SpringBootApplication注解等效于将@Configuration，@EnableAutoConfiguration和@ComponentScan及其默认属性一起使用，如以下示例所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.example.myapplication;

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

@SpringBootApplication // same as @Configuration @EnableAutoConfiguration @ComponentScan
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

Note

@SpringBootApplication还提供别名以自定义@EnableAutoConfiguration和@ComponentScan的属性。

Note

这些功能都不是强制性的，您可以选择用它启用的任何功能替换此单个注解。例如，您可能不想在应用程序中使用组件扫描：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.example.myapplication;

import org.springframework.boot.SpringApplication;
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@EnableAutoConfiguration
@Import({ MyConfig.class, MyAnotherConfig.class })
public class Application {

    public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
    }

}

在此示例中，Application就像其他任何 Spring Boot 应用程序一样，除了不会自动检测到@Component注解的类并且显式导入用户定义的 Bean(请参阅@Import)。

运行您的应用程序

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

Note

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

从IDE运行

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

如果您不能直接将项目导入到 IDE 中，则可以使用构建插件来生成 IDE 元数据。 Maven 包括Eclipse和IDEA的插件。 Gradle 提供了various IDEs的插件。

Tip

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

作为打包的应用程序运行

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

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

也可以在启用了远程调试支持的情况下运行打包的应用程序。这样做使您可以将调试器附加到打包的应用程序，如以下示例所示：

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

使用Maven插件

Spring Boot Maven 插件包含一个run目标，可用于快速编译和运行您的应用程序。应用程序以爆炸形式运行，就像在 IDE 中一样。以下示例显示了运行 Spring Boot 应用程序的典型 Maven 命令：

1
$ mvn spring-boot:run

您可能还想使用MAVEN_OPTSos 环境变量，如以下示例所示：

1
$ export MAVEN_OPTS=-Xmx1024m

使用Gradle插件

Spring Boot Gradle 插件还包括一个bootRun任务，可用于以爆炸形式运行您的应用程序。每当您应用org.springframework.boot和java插件时，便会添加bootRun任务，并在以下示例中显示：

1
$ gradle bootRun

您可能还想使用JAVA_OPTSos 环境变量，如以下示例所示：

1
$ export JAVA_OPTS=-Xmx1024m

热插拔

由于 Spring Boot 应用程序只是普通的 Java 应用程序，因此 JVM 热交换应该可以立即使用。 JVM 热插拔在一定程度上受到它可以替换的字节码的限制。要获得更完整的解决方案，可以使用JRebel。

spring-boot-devtools模块还包括对应用程序快速重启的支持。有关详细信息，请参见本章后面的第 20 章，开发人员工具部分和热插拔“操作方法”。

开发者工具

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

Maven.

1
2
3
4
5
6
7
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

Gradle.

1
2
3
4
5
6
7
8
9
configurations {
    developmentOnly
    runtimeClasspath {
        extendsFrom developmentOnly
    }
}
dependencies {
    developmentOnly("org.springframework.boot:spring-boot-devtools")
}

Note

运行完全打包的应用程序时，将自动禁用开发人员工具。如果您的应用程序是从java -jar启动的，或者是从特殊的类加载器启动的，则将其视为“生产应用程序”。在 Maven 中将依赖项标记为可选，或在 Gradle 中使用自定义的“ developmentOnly”配置(如上所示)是一种最佳实践，它可以防止将 devtools 过渡地应用到使用项目的其他模块。

Tip

重新打包的存档默认情况下不包含 devtools。如果要使用某些远程 devtools 功能，则需要禁用excludeDevtools build 属性以包括它。 Maven 和 Gradle 插件均支持该属性。

属性默认值

Spring Boot 支持的一些库使用缓存来提高性能。例如，template engines缓存已编译的模板，以避免重复分析模板文件。而且，Spring MVC 可以在提供静态资源时向响应添加 HTTP 缓存 Headers。

虽然缓存在生产中非常有益，但在开发过程中可能适得其反，从而使您无法看到刚刚在应用程序中所做的更改。因此，默认情况下，spring-boot-devtools 禁用缓存选项。

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

由于在开发 Spring MVC 和 Spring WebFlux 应用程序时需要有关 Web 请求的更多信息，因此开发人员工具将为web日志记录组启用DEBUG日志记录。这将为您提供有关传入请求，正在处理的处理程序，响应结果等的信息。如果您希望记录所有请求详细信息(包括潜在的敏感信息)，则可以打开spring.http.log-request-details配置属性。

Note

如果您不希望应用属性默认值，则可以在application.properties中将spring.devtools.add-properties设置为false。

Tip

有关 devtools 应用的属性的完整列表，请参见DevToolsPropertyDefaultsPostProcessor。

自动重启

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

Triggering a restart

当 DevTools 监视 Classpath 资源时，触发重启的唯一方法是更新 Classpath。导致 Classpath 更新的方式取决于您使用的 IDE。在 Eclipse 中，保存修改后的文件将导致 Classpath 被更新并触发重新启动。在 IntelliJ IDEA 中，构建项目(Build -> Build Project)具有相同的效果。

Note

只要启用了分叉，您还可以使用受支持的构建插件(Maven 和 Gradle)来启动应用程序，因为 DevTools 需要隔离的应用程序类加载器才能正常运行。默认情况下，Gradle 和 Maven 在 Classpath 上检测到 DevTools 时会这样做。

Tip

与 LiveReload 一起使用时，自动重新启动效果很好。 请参阅“ LiveReload”部分了解详情。如果使用 JRebel，则禁用自动重新启动，而有利于动态类重新加载。仍可以使用其他 devtools 功能(例如 LiveReload 和属性替代)。

Note

DevTools 依靠应用程序上下文的关闭钩子在重新启动期间将其关闭。如果禁用了关机钩子(SpringApplication.setRegisterShutdownHook(false))，它将无法正常工作。

Note

在确定 Classpath 上的条目是否应在更改后触发重新启动时，DevTools 会自动忽略名为spring-boot，spring-boot-devtools，spring-boot-autoconfigure，spring-boot-actuator和spring-boot-starter的项目。

Note

DevTools 需要自定义ApplicationContext使用的ResourceLoader。如果您的应用程序已经提供了，它将被包装。不支持在ApplicationContext上直接覆盖getResource方法。

Restart vs Reload

Spring Boot 提供的重启技术通过使用两个类加载器来工作。不变的类(例如，来自第三方 jar 的类)将被加载到 base 类加载器中。您正在积极开发的类将加载到 restart 类加载器中。重新启动应用程序后，将丢弃 restart 类加载器，并创建一个新的类加载器。这种方法意味着应用程序的重启通常比“冷启动”要快得多，因为 base 类加载器已经可用并已填充。

如果您发现重新启动对于应用程序而言不够快，或者遇到类加载问题，则可以考虑从 ZeroTurnaround 重新加载诸如JRebel之类的技术。这些方法通过在加载类时重写类来使其更易于重新加载。

记录条件评估中的更改

默认情况下，每次应用程序重新启动时，都会记录一个报告，其中显示了条件评估增量。该报告显示了在进行更改(例如添加或删除 bean 以及设置配置属性)时对应用程序自动配置的更改。

要禁用报告的日志记录，请设置以下属性：

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

排除资源

某些资源在更改时不一定需要触发重新启动。例如，Thymeleaf 模板可以就地编辑。默认情况下，更改/META-INF/maven，/META-INF/resources，/resources，/static，/public或/templates中的资源不会触发重新启动，但会触发live reload。如果要自定义这些排除项，则可以使用spring.devtools.restart.exclude属性。例如，要仅排除/static和/public，则可以设置以下属性：

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

Tip

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

注意其他路径

当您对不在 Classpath 上的文件进行更改时，您可能希望重新启动或重新加载应用程序。为此，使用spring.devtools.restart.additional-paths属性配置其他路径以监视更改。您可以使用spring.devtools.restart.exclude属性described earlier来控制其他路径下的更改是触发完全重启还是live reload。

禁用重启

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

如果您需要完全禁用重启支持(例如，因为它不适用于特定的库)，则需要在调用SpringApplication.run(…)之前将spring.devtools.restart.enabled System属性设置为false，如以下示例所示：

1
2
3
4
public static void main(String[] args) {
    System.setProperty("spring.devtools.restart.enabled", "false");
    SpringApplication.run(MyApp.class, args);
}

使用触发文件

如果使用持续编译更改文件的 IDE，则可能更喜欢仅在特定时间触发重新启动。为此，可以使用“触发文件”，这是一个特殊文件，当您要实际触发重新启动检查时必须对其进行修改。更改文件只会触发检查，并且仅在 Devtools 检测到必须执行某些操作时才会重新启动。可以手动或使用 IDE 插件来更新触发文件。

要使用触发文件，请将spring.devtools.restart.trigger-file属性设置为触发文件的路径。

Tip

您可能希望将spring.devtools.restart.trigger-file设置为global setting，以便所有项目的行为都相同。

自定义重启类加载器

如前面的重新启动与重新加载部分所述，重新启动功能是通过使用两个类加载器实现的。对于大多数应用程序，此方法效果很好。但是，有时可能会导致类加载问题。

默认情况下，IDE 中的任何打开的项目都将使用“重新启动”类加载器加载，而任何常规的.jar文件都将使用“基本”类加载器加载。如果您在多模块项目上工作，并且并非每个模块都导入到 IDE 中，则可能需要自定义内容。为此，您可以创建一个META-INF/spring-devtools.properties文件。

spring-devtools.properties文件可以包含以restart.exclude和restart.include为前缀的属性。 include元素是应上拉到“重新启动”类加载器中的项目，而exclude元素是应下推到“基本”类加载器中的项目。该属性的值是一个应用于 Classpath 的正则表达式模式，如以下示例所示：

1
2
restart.exclude.companycommonlibs=/mycorp-common-[\\w-]+\.jar
restart.include.projectcommon=/mycorp-myproj-[\\w-]+\.jar

Note

所有属性键都必须是唯一的。只要属性以restart.include.或restart.exclude.开头，它就会被考虑。

Tip

Classpath 中的所有META-INF/spring-devtools.properties都已加载。您可以将文件打包在项目内部或项目使用的库中。

已知限制

重新启动功能不适用于使用标准ObjectInputStream反序列化的对象。如果需要反序列化数据，则可能需要结合使用Spring的ConfigurableObjectInputStream和Thread.currentThread().getContextClassLoader()。

不幸的是，一些第三方库在不考虑上下文类加载器的情况下反序列化。如果发现这样的问题，则需要向原始作者请求修复。

LiveReload

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

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

Note

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

全局设置

您可以通过将名为.spring-boot-devtools.properties的文件添加到$HOME文件夹中来配置全局 devtools 设置(请注意，文件名以“.”开头)。添加到该文件的所有属性都适用于您机器上所有使用 devtools 的 Spring Boot 应用程序。例如，要将重新启动配置为始终使用trigger file，则应添加以下属性：

~/.spring-boot-devtools.properties.

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

Note

在.spring-boot-devtools.properties中激活的配置文件不会影响特定于配置文件的配置文件的加载。

远程应用程序

Spring Boot 开发人员工具不仅限于本地开发。远程运行应用程序时，您还可以使用多种功能。选择加入远程支持。要启用它，您需要确保重新打包的 Files 中包含devtools，如以下 Lists 所示：

1
2
3
4
5
6
7
8
9
10
11
<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属性。与任何重要的密码或机密文件一样，该值应该是惟一的、强的，以便不能被猜测或强制使用。

1
spring.devtools.remote.secret=mysecret

远程 devtools 支持分为两部分：接受连接的服务器端端点和在 IDE 中运行的 Client 端应用程序。设置spring.devtools.remote.secret属性后，将自动启用服务器组件。Client 端组件必须手动启动。

运行远程Client端应用程序

远程 Client 端应用程序旨在在您的 IDE 中运行。您需要使用与您连接到的远程项目相同的 Classpath 来运行org.springframework.boot.devtools.RemoteSpringApplication。应用程序的单个必需参数是它连接到的远程 URL。

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

  • 从Run菜单中选择Run Configurations…。
  • 创建一个新的Java Application“启动配置”。
  • 浏览my-app项目。
  • 使用org.springframework.boot.devtools.RemoteSpringApplication作为主要类。
  • 将https://myapp.cfapps.io添加到Program arguments(或任何远程 URL)。

正在运行的远程 Client 端可能类似于以下 Lists：

1
2
3
4
5
6
7
8
9
10
11
12
13
.   ____          _                                              __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _          ___               _      \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` |        | _ \___ _ __  ___| |_ ___ \ \ \ \
 \\/  ___)| |_)| | | | | || (_| []::::::[]   / -_) '  \/ _ \  _/ -_) ) ) ) )
  '  |____| .__|_| |_|_| |_\__, |        |_|_\___|_|_|_\___/\__\___|/ / / /
 =========|_|==============|___/===================================/_/_/_/
 :: Spring Boot Remote :: 2.1.1.RELEASE

2015-06-10 18:25:06.632  INFO 14938 --- [           main] o.s.b.devtools.RemoteSpringApplication   : Starting RemoteSpringApplication on pwmbp with PID 14938 (/Users/pwebb/projects/spring-boot/code/spring-boot-devtools/target/classes started by pwebb in /Users/pwebb/projects/spring-boot/code/spring-boot-samples/spring-boot-sample-devtools)
2015-06-10 18:25:06.671  INFO 14938 --- [           main] s.c.a.AnnotationConfigApplicationContext : Refreshing org.spring[emailprotected]2a17b7b6: startup date [Wed Jun 10 18:25:06 PDT 2015]; root of context hierarchy
2015-06-10 18:25:07.043  WARN 14938 --- [           main] o.s.b.d.r.c.RemoteClientConfiguration    : The connection to http://localhost:8080 is insecure. You should use a URL starting with 'https://'.
2015-06-10 18:25:07.074  INFO 14938 --- [           main] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729
2015-06-10 18:25:07.130  INFO 14938 --- [           main] o.s.b.devtools.RemoteSpringApplication   : Started RemoteSpringApplication in 0.74 seconds (JVM running for 1.105)

Note

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

Tip

始终建议使用https://作为连接协议，以便对通信进行加密并且不能截获密码。

Tip

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

远程更新

远程 Client 端以与local restart相同的方式监视应用程序 Classpath 中的更改。任何更新的资源都被推送到远程应用程序，并且(如果需要)触发重新启动。如果您迭代使用本地没有的云服务的功能，这将很有帮助。通常，远程更新和重新启动比完整的重建和部署周期要快得多。

Note

仅在远程 Client 端正在运行时监视文件。如果在启动远程 Client 端之前更改文件，则不会将其推送到远程服务器。

为生产环境打包Application

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

对于其他“生产准备就绪”功能，例如运行状况，审核和度量 REST 或 JMX 端点，请考虑添加spring-boot-actuator。有关详细信息，请参见 第五部分，“ Spring Boot Actuator：可用于生产的功能”。

接下来要读什么

现在，您应该了解如何使用 Spring Boot 以及应遵循的一些最佳实践。现在，您可以 continue 深入了解特定的 Spring Boot 功能，或者可以跳过并阅读有关 Spring Boot 的“ production ready”方面的信息。