文章作者：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.

這一節(jié)將會講述關(guān)于應(yīng)該如何使用Spring Boot的更多細(xì)節(jié)。它包括許多主題例如構(gòu)建系統(tǒng)，自動配置和怎么運行自己的應(yīng)用。我們也講述一些Spring Boot的最佳實踐。雖然沒有關(guān)于Spring Boot非常特別的東西（它只是另一個你可以使用的庫），但接下來的一些建議可以讓你的開發(fā)過程更容易一點。

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

如果你剛開始學(xué)習(xí)Spring Boot，在學(xué)習(xí)這節(jié)之前你可能應(yīng)該先閱讀一下『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.

強(qiáng)烈建議你選擇一個支持依賴管理的構(gòu)建系統(tǒng)，構(gòu)建系統(tǒng)可以使用發(fā)布在『Maven Central』倉庫中的工件。我們建議你選擇Maven或Gradle。Spring Boot可能也可以與其它的構(gòu)建系統(tǒng)進(jìn)行協(xié)作（例如Ant），但不能特別好的支持其它的構(gòu)建系統(tǒng)。

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的每一次發(fā)布都會提供它支持的依賴列表。實際應(yīng)用時，在你的構(gòu)建配置中不需要提供這些依賴的版本，因為Spring Boot會幫你進(jìn)行管理。當(dāng)你升級Spring Boot時，這些依賴也會隨之進(jìn)行升級。

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模塊，也包含了第三方庫的精制列表。這個列表可以當(dāng)做一個標(biāo)準(zhǔn)可用的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的每一次發(fā)布都是與Spring框架的基本版本相關(guān)的，因此我們強(qiáng)烈建議你在自己使用時不要指定它的版本。

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工程來獲得合理的默認(rèn)配置。父工程提供了下面的特性：

• Java 1.6作為默認(rèn)的編譯級別。

• UTF-8源碼編碼。

• 依賴管理部分，對于常用的依賴允許你忽略<version>標(biāo)簽，從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).

最后一點：由于默認(rèn)配置文件采用Spring風(fēng)格的占位符(${…?})，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，簡單的設(shè)置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.

你應(yīng)該只需要在這個依賴中指定Spring Boot的版本號。如果你導(dǎo)入額外的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.

有了這個設(shè)置，你也可以通過在你的工程中重寫一個屬性來覆蓋單獨的依賴。例如，為了升級另一個Spring Data的發(fā)布版本，你將需要在你的pom.xml中添加以下內(nèi)容：

<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的。你也可以有需要使用的公司的標(biāo)準(zhǔn)父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.

這個設(shè)置不允許你使用上面闡述的屬性來重寫單獨的依賴。為了取得同樣的效果，你需要在spring-boot-dependencies入口之前在工程的dependencyManagement中的添加一個入口。為了升級另一個Spring Data的發(fā)布版本，你將需要在你的pom.xml中添加以下內(nèi)容：

<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選擇了相當(dāng)保守的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插件，這個插件可以將工程打包為一個可執(zhí)行的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中的定義的設(shè)置。

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部分導(dǎo)入starters。不像Maven，這兒不能導(dǎo)入“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也可用，并提供了從源碼創(chuàng)建可執(zhí)行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來創(chuàng)建一個Spring Boot項目是可能的。spring-boot-antlib “AntLib”模塊也可以用來幫助Ant創(chuàng)建可執(zhí)行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小節(jié)，“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.

啟動器是一系列你可以包含進(jìn)自己應(yīng)用中的實用依賴描述符。你可以得到所有Spring和你需要的相關(guān)技術(shù)的一站式服務(wù)，不需要有搜索樣例代碼和拷貝粘貼依賴描述符的負(fù)擔(dān)。例如，如果你想開始使用Spring和JPA來進(jìn)行數(shù)據(jù)庫鏈接，只需要在你的工程中包含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.

啟動器包含許多你需要啟動并快速運行一個工程的依賴，并持續(xù)支持一系列傳遞管理的依賴。

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-*，*是應(yīng)用的特性類型。這個命名結(jié)構(gòu)用來在你需要時幫助你發(fā)現(xiàn)一個啟動器。Maven在許多IDEs中進(jìn)行了集成，允許你通過名字來搜索依賴。例如，安裝了合適的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.

正如在創(chuàng)建你自己的啟動器部分講述的那樣，第三方啟動器不應(yīng)該與spring-boot一起啟動，因為它是預(yù)留給官方Spring Boot構(gòu)建的。acme的第三方啟動器通過命名為acme-spring-boot-starter。

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

下面的應(yīng)用啟動器由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:

除了應(yīng)用啟動器之外，下面的啟動器可以用來添加產(chǎn)品準(zhǔn)備功能：

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:

最后，如果你想排除或交換特定的技術(shù)方面，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.

對于額外的社區(qū)共享的啟動器，請看GitHub上the spring-boot-starters模塊的README file。