文章作者：Tyan
博客：noahsnail.com | CSDN | 简书

Part III. Using Spring Boot

This section goes into more detail about how you should use Spring Boot. It covers topics such as build systems, auto-configuration and how to run your applications. We also cover some Spring Boot best practices. Although there is nothing particularly special about Spring Boot (it is just another library that you can consume), there are a few recommendations that, when followed, will make your development process just a little easier.

这一节将会讲述关于应该如何使用Spring Boot的更多细节。它包括许多主题例如构建系统，自动配置和怎么运行自己的应用。我们也讲述一些Spring Boot的最佳实践。虽然没有关于Spring Boot非常特别的东西（它只是另一个你可以使用的库），但接下来的一些建议可以让你的开发过程更容易一点。

If you’re just starting out with Spring Boot, you should probably read the Getting Started guide before diving into this section.

如果你刚开始学习Spring Boot，在学习这节之前你可能应该先阅读一下『Getting Started』部分。

13. Build systems

It is strongly recommended that you choose a build system that supports dependency management, and one that can consume artifacts published to the “Maven Central” repository. We would recommend that you choose Maven or Gradle. It is possible to get Spring Boot to work with other build systems (Ant for example), but they will not be particularly well supported.

强烈建议你选择一个支持依赖管理的构建系统，构建系统可以使用发布在『Maven Central』仓库中的工件。我们建议你选择Maven或Gradle。Spring Boot可能也可以与其它的构建系统进行协作（例如Ant），但不能特别好的支持其它的构建系统。

13.1 Dependency management

Each release of Spring Boot provides a curated list of dependencies it supports. In practice, you do not need to provide a version for any of these dependencies in your build configuration as Spring Boot is managing that for you. When you upgrade Spring Boot itself, these dependencies will be upgraded as well in a consistent way.

Spring Boot的每一次发布都会提供它支持的依赖列表。实际应用时，在你的构建配置中不需要提供这些依赖的版本，因为Spring Boot会帮你进行管理。当你升级Spring Boot时，这些依赖也会随之进行升级。

You can still specify a version and override Spring Boot’s recommendations if you feel that’s necessary.

如果有必要的话，你仍可以指定版本并覆盖Spring Boot的推荐。

The curated list contains all the spring modules that you can use with Spring Boot as well as a refined list of third party libraries. The list is available as a standard Bills of Materials (spring-boot-dependencies) and additional dedicated support for Maven and Gradle are available as well.

这个列表包含了所有你在Spring Boot中可以使用的Spring模块，也包含了第三方库的精制列表。这个列表可以当做一个标准可用的Bills of Materials (spring-boot-dependencies)，也额外的专门支持Maven和Gradle可用。

Each release of Spring Boot is associated with a base version of the Spring Framework so we highly recommend you to not specify its version on your own.

Spring Boot的每一次发布都是与Spring框架的基本版本相关的，因此我们强烈建议你在自己使用时不要指定它的版本。

13.2 Maven

Maven users can inherit from the spring-boot-starter-parent project to obtain sensible defaults. The parent project provides the following features:

• Java 1.6 as the default compiler level.

• UTF-8 source encoding.

• A Dependency Management section, allowing you to omit <version> tags for common dependencies, inherited from the spring-boot-dependencies POM.

• Sensible resource filtering.

• Sensible plugin configuration (exec plugin, surefire, Git commit ID, shade).

• Sensible resource filtering for application.properties and application.yml including profile-specific files (e.g. application-foo.properties and application-foo.yml)

Maven用户可以继承spring-boot-starter-parent工程来获得合理的默认配置。父工程提供了下面的特性：

• Java 1.6作为默认的编译级别。

• UTF-8源码编码。

• 依赖管理部分，对于常用的依赖允许你忽略<version>标签，从spring-boot-dependencies继承POM。

• 合理的资源过滤。

• 合理的插件配置（exec plugin, surefire, Git commit ID, shade）。

• 对包括特定配置文件的application.properties和application.yml的合理资源过滤（例如，application-foo.properties和application-foo.yml）。

On the last point: since the default config files accept Spring style placeholders (${…​}) the Maven filtering is changed to use @..@ placeholders (you can override that with a Maven property resource.delimiter).

最后一点：由于默认配置文件采用Spring风格的占位符(${…​})，Maven过滤改成了使用@..@占位符（你可以使用Maven属性resource.delimiter来覆盖）。

13.2.1 Inheriting the starter parent

To configure your project to inherit from the spring-boot-starter-parent simply set the parent:

为了配置你的工程继承spring-boot-starter-parent，简单的设置parent：

<!-- Inherit defaults from Spring Boot -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.0.BUILD-SNAPSHOT</version>
</parent>

You should only need to specify the Spring Boot version number on this dependency. If you import additional starters, you can safely omit the version number.

你应该只需要在这个依赖中指定Spring Boot的版本号。如果你导入额外的starters，你可以安全的忽略这个版本号。

With that setup, you can also override individual dependencies by overriding a property in your own project. For instance, to upgrade to another Spring Data release train you’d add the following to your pom.xml.

有了这个设置，你也可以通过在你的工程中重写一个属性来覆盖单独的依赖。例如，为了升级另一个Spring Data的发布版本，你将需要在你的pom.xml中添加以下内容：

<properties>
    <spring-data-releasetrain.version>Fowler-SR2</spring-data-releasetrain.version>
</properties>

Check the spring-boot-dependencies pom for a list of supported properties.

检查spring-boot-dependencies pom支持的属性清单。

13.2.2 Using Spring Boot without the parent POM

Not everyone likes inheriting from the spring-boot-starter-parent POM. You may have your own corporate standard parent that you need to use, or you may just prefer to explicitly declare all your Maven configuration.

不是每个人都喜欢继承spring-boot-starter-parent POM的。你也可以有需要使用的公司的标准父POM，或者你可能更喜欢显式的声明你所有的Maven配置。

If you don’t want to use the spring-boot-starter-parent, you can still keep the benefit of the dependency management (but not the plugin management) by using a scope=import dependency:

如果你不想使用spring-boot-starter-parent，但你仍要保留依赖管理的好处（不是插件管理），你可以使用scope=import依赖：

<dependencyManagement>
     <dependencies>
        <dependency>
            <!-- Import dependency management from Spring Boot -->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.0.0.BUILD-SNAPSHOT</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

That setup does not allow you to override individual dependencies using a property as explained above. To achieve the same result, you’d need to add an entry in the dependencyManagement of your project before the spring-boot-dependencies entry. For instance, to upgrade to another Spring Data release train you’d add the following to your pom.xml.

这个设置不允许你使用上面阐述的属性来重写单独的依赖。为了取得同样的效果，你需要在spring-boot-dependencies入口之前在工程的dependencyManagement中的添加一个入口。为了升级另一个Spring Data的发布版本，你将需要在你的pom.xml中添加以下内容：

<dependencyManagement>
    <dependencies>
        <!-- Override Spring Data release train provided by Spring Boot -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-releasetrain</artifactId>
            <version>Fowler-SR2</version>
            <scope>import</scope>
            <type>pom</type>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.0.0.BUILD-SNAPSHOT</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

In the example above, we specify a BOM but any dependency type can be overridden that way.

在上面的例子中，我们指定了一个POM但任何依赖类型都可以被重写。

13.2.3 Changing the Java version

The spring-boot-starter-parent chooses fairly conservative Java compatibility. If you want to follow our recommendation and use a later Java version you can add a java.version property:

spring-boot-starter-parent选择了相当保守的Java兼容性。如果你想听从我们的建议，使用更新的Java版本，你可以添加java.version属性。

<properties>
    <java.version>1.8</java.version>
</properties>

13.2.4 Using the Spring Boot Maven plugin

Spring Boot includes a Maven plugin that can package the project as an executable jar. Add the plugin to your <plugins> section if you want to use it:

Spring Boot包含了一个Maven插件，这个插件可以将工程打包为一个可执行的jar包。如果你向使用它的话，将它添加到你的<plugins>部分：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

If you use the Spring Boot starter parent pom, you only need to add the plugin, there is no need for to configure it unless you want to change the settings defined in the parent.

如果你想使用Spring Boot的starter parent pom，你只需要添加这个插件，不需要配置它，除非你想更改父POM中的定义的设置。

13.3 Gradle

Gradle users can directly import starters in their dependencies section. Unlike Maven, there is no “super parent” to import to share some configuration.

Gradle用户可以直接在它们的dependencies部分导入starters。不像Maven，这儿不能导入“super parent”来共享一些配置。

apply plugin: 'java'

repositories {
    maven { url "http://repo.spring.io/snapshot" }
    maven { url "http://repo.spring.io/milestone" }
}

dependencies {
    compile("org.springframework.boot:spring-boot-starter-web:2.0.0.BUILD-SNAPSHOT")
}

The spring-boot-gradle-plugin is also available and provides tasks to create executable jars and run projects from source. It also provides dependency management that, among other capabilities, allows you to omit the version number for any dependencies that are managed by Spring Boot:

spring-boot-gradle-plugin也可用，并提供了从源码创建可执行jars和运行项目的功能。它也提供了依赖管理，在其它的兼容性之间，允许你忽略任何Spring Boot管理的依赖的版本号：

buildscript {
    repositories {
        maven { url "http://repo.spring.io/snapshot" }
        maven { url "http://repo.spring.io/milestone" }
    }

    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:2.0.0.BUILD-SNAPSHOT")
    }
}

apply plugin: 'java'
apply plugin: 'org.springframework.boot'

repositories {
    maven { url "http://repo.spring.io/snapshot" }
    maven { url "http://repo.spring.io/milestone" }
}

dependencies {
    compile("org.springframework.boot:spring-boot-starter-web")
    testCompile("org.springframework.boot:spring-boot-starter-test")
}

13.4 Ant

It is possible to build a Spring Boot project using Apache Ant+Ivy. The spring-boot-antlib “AntLib” module is also available to help Ant create executable jars.

使用Apache Ant+Ivy来创建一个Spring Boot项目是可能的。spring-boot-antlib “AntLib”模块也可以用来帮助Ant创建可执行jars。

To declare dependencies a typical ivy.xml file will look something like this:

为了声明依赖，一个典型的ivy.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>

A typical build.xml will look like this:

一个典型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="1.3.0.BUILD-SNAPSHOT" />

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

See the Section 79.10, “Build an executable archive from Ant without using spring-boot-antlib” “How-to” if you don’t want to use the spring-boot-antlib module.

如果你不想使用spring-boot-antlib模块，请看79.10小节，“Build an executable archive from Ant without using spring-boot-antlib” “How-to”。

13.5 Starters

Starters are a set of convenient dependency descriptors that you can include in your application. You get a one-stop-shop for all the Spring and related technology that you need, without having to hunt through sample code and copy paste loads of dependency descriptors. For example, if you want to get started using Spring and JPA for database access, just include the spring-boot-starter-data-jpa dependency in your project, and you are good to go.

启动器是一系列你可以包含进自己应用中的实用依赖描述符。你可以得到所有Spring和你需要的相关技术的一站式服务，不需要有搜索样例代码和拷贝粘贴依赖描述符的负担。例如，如果你想开始使用Spring和JPA来进行数据库链接，只需要在你的工程中包含spring-boot-starter-data-jpa依赖，你便可以很好的前行了。

The starters contain a lot of the dependencies that you need to get a project up and running quickly and with a consistent, supported set of managed transitive dependencies.

启动器包含许多你需要启动并快速运行一个工程的依赖，并持续支持一系列传递管理的依赖。

What’s in a name

All official starters follow a similar naming pattern; spring-boot-starter-*, where * is a particular type of application. This naming structure is intended to help when you need to find a starter. The Maven integration in many IDEs allow you to search dependencies by name. For example, with the appropriate Eclipse or STS plugin installed, you can simply hit ctrl-space in the POM editor and type “spring-boot-starter” for a complete list.

所有的官方启动器都有一个类似的命名模式：spring-boot-starter-*，*是应用的特性类型。这个命名结构用来在你需要时帮助你发现一个启动器。Maven在许多IDEs中进行了集成，允许你通过名字来搜索依赖。例如，安装了合适的Eclipse或STS插件，你可以简单的在POM编辑器中点击ctrl-space并输入“spring-boot-starter”来查找一个完整的列表。

As explained in the Creating your own starter section, third party starters should not start with spring-boot as it is reserved for official Spring Boot artifacts. A third-party starter for acme will be typically named acme-spring-boot-starter.

正如在创建你自己的启动器部分讲述的那样，第三方启动器不应该与spring-boot一起启动，因为它是预留给官方Spring Boot构建的。acme的第三方启动器通过命名为acme-spring-boot-starter。

The following application starters are provided by Spring Boot under the org.springframework.boot group:

下面的应用启动器由Spring Boot提供，在org.springframework.boot组下：

Table 13.1. Spring Boot application starters

In addition to the application starters, the following starters can be used to add production ready features:

除了应用启动器之外，下面的启动器可以用来添加产品准备功能：

Table 13.2. Spring Boot production starters

Finally, Spring Boot also includes some starters that can be used if you want to exclude or swap specific technical facets:

最后，如果你想排除或交换特定的技术方面，Spring Boot也包括一些可以使用的启动器：

Table 13.3. Spring Boot technical starters

For a list of additional community contributed starters, see the README file in the spring-boot-starters module on GitHub.

对于额外的社区共享的启动器，请看GitHub上the spring-boot-starters模块的README file。