Part I.Spring Boot文檔

本節簡要介紹Spring Boot參考文檔

1.關於這個文檔

Spring參考文檔可以通過如下三種途徑獲得：

注：考慮到大家翻牆問題，我準備了一份PDF，通過百度雲盤分享的方式。

2.獲得幫助

如果您在使用Spring Boot中遇到困難，我們希望能夠提供幫助：

嘗試使用How to文檔。它們提供常規的解決方法。
學習Spring的基礎知識，Spring Boot建立在它們之上。查閱Spring.io網站獲取豐富的資料。
在StackOverflow提問，我們監視Spring-Boot爲標籤的問題。
在github.com/spring-projects/spring-boot/issues上報告錯誤。

3.第一步

如果您正在開始使用Spring Boot或“Spring”，請從以下主題開始：

從頭開始：概覽| 要求| 安裝
教程：第1部分| 第2部分
運行您的示例：第1部分| 第2部分

4.使用Spring Boot

準備好真正開始使用Spring Boot？我們涵蓋如下知識：

5.學習Spring Boot特性

需要更多關於Spring Boot核心功能的細節？以下內容適合您：

6.轉向生產

當你準備把你的Spring Boot應用程序投入生產時，我們有一些你可能會喜歡的技巧：

管理端點：概覽|定製
連接選項：HTTP |JMX
監測：指標| 審計| 追蹤| 處理

7.高級主題

最後，我們有更多高級用戶的一些話題：

Spring Boot應用程序部署：雲部署| OS服務
構建工具插件：Maven |gradle
附錄：應用程序屬性| 自動配置類| 可執行的jars

Part II.入門

如果您正在開始使用Spring Boot，或者一般情況下使用“Spring”，請先閱讀本節。它回答了基本的“什麼？”，“如何？”和“爲什麼？”的問題。它包括一個Spring Boot的介紹，以及安裝說明。然後，我們將引導您構建您的第一個Spring Boot應用程序，並討論一些核心原則。

8.介紹Spring Boot

Spring Boot使您可以輕鬆創建可以運行的獨立的，生產級的基於Spring的應用程序。我們對Spring平臺和第三方庫有一個自己的看法，這樣你就可以用最小的麻煩開始。大多數Spring Boot應用程序只需要很少的Spring配置。

您可以使用Spring Boot來創建可以使用java -jar或更傳統的war部署啓動的Java應用程序。我們還提供了一個運行“春天腳本”的命令行工具。

我們的主要目標是：

爲所有Spring開發提供一個更快，更廣泛的入門體驗。
開箱即用，但是隨着需求開始偏離默認值，快速退出。
提供大量項目（如嵌入式服務器，安全性，指標，運行狀況檢查和外部配置）通用的一系列非功能性功能。
絕對不會生成代碼，也不需要XML配置。

9.系統要求

Spring Boot 2.0.0.BUILD-SNAPSHOT需要Java 8和Spring Framework 5.0.2.RELEASE或更高版本。爲Maven 3.2+和Gradle 4提供了明確的構建支持。

9.1.Servlet容器

開箱即用支持以下嵌入式servlet容器：

名字	Servlet版本
Tomcat 8.5	3.1
Jetty 9.4	3.1
Undertow 1.3	3.1

您也可以將Spring Boot應用程序部署到任何與Servlet 3.0+兼容的容器。

10.安裝Spring Boot

Spring Boot可以與“經典”的Java開發工具一起使用，也可以作爲命令行工具安裝。無論哪種方式，您都需要Java SDK v1.8或更高版本。在開始之前，您應該使用以下命令檢查當前的Java安裝版本：

$ java -version

如果您對Java開發不熟悉，或者想要嘗試Spring Boot，則可能需要先嚐試Spring Boot CLI（命令行界面），否則請閱讀“經典”安裝說明。

10.1 Java開發人員的安裝說明

您可以像使用任何標準Java庫一樣使用Spring Boot。爲此，請在類路徑中包含相應的spring-boot - *.jar文件。 Spring Boot不需要任何特殊的工具集成，因此您可以使用任何IDE或文本編輯器。此外，Spring Boot應用程序沒有什麼特別之處，所以您可以像運行其他任何Java程序一樣運行和調試Spring Boot應用程序。

儘管您可以複製Spring Boot 的jar包，但我們通常建議您使用支持依賴管理的構建工具（如Maven或Gradle）。

10.1.1 Maven安裝

Spring Boot與Apache Maven 3.2或更高版本兼容。如果您還沒有安裝Maven，可以按照https://maven.apache.org/上的說明進行操作。

注：在許多操作系統上，Maven可以安裝一個包管理器。如果您使用OSX Homebrew，請嘗試brew install maven。 Ubuntu用戶可以運行sudo apt-get install maven。具有Chocolatey的Windows用戶可以從提升（管理員）提示符運行choco install maven。

Spring Boot依賴使用org.springframework.boot groupId。通常，您的Maven POM文件從spring-boot-starter-parent項目繼承，並將依賴關係聲明爲一個或多個“Starter”。 Spring Boot還提供了一個可選的Maven插件來創建可執行的jar文件。

以下列表顯示了一個典型的pom.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>myproject</artifactId>
    <version>0.0.1-SNAPSHOT</version>

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

    <!-- Add typical dependencies for a web application -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <!-- Package as an executable jar -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <!-- Add Spring repositories -->
    <!-- (you don't need this if you are using a .RELEASE version) -->
    <repositories>
        <repository>
            <id>spring-snapshots</id>
            <url>http://repo.spring.io/snapshot</url>
            <snapshots><enabled>true</enabled></snapshots>
        </repository>
        <repository>
            <id>spring-milestones</id>
            <url>http://repo.spring.io/milestone</url>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>spring-snapshots</id>
            <url>http://repo.spring.io/snapshot</url>
        </pluginRepository>
        <pluginRepository>
            <id>spring-milestones</id>
            <url>http://repo.spring.io/milestone</url>
        </pluginRepository>
    </pluginRepositories>
</project>

注：有時您可能需要從不同的父POM繼承，或者您可能不喜歡我們的默認設置在這些情況下，請參見第13.2.2節“使用不帶父項的Spring Boot”，以獲得使用import scope的替代解決方案。

10.1.2 Gradle安裝

Spring Boot與Gradle 4兼容。如果您沒有安裝Gradle，您可以按照www.gradle.org上的說明進行操作。

Spring Boot依賴可以通過使用org.springframework.boot組聲明，Spring Boot提供了一個有用的Gradle插件，可以用來簡化依賴聲明和創建可執行的jar。

Gradle Wrapper
當您需要構建項目時，Gradle Wrapper提供了一個“獲取”Gradle的好方法。這是一個小腳本和庫，與代碼一起提交來引導構建過程。有關詳細信息，請參閱docs.gradle.org/4.2.1/userguide/gradle_wrapper.html。

以下示例顯示了一個典型的build.gradle文件：

buildscript {
    repositories {
        jcenter()
        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'
apply plugin: 'io.spring.dependency-management'

jar {
    baseName = 'myproject'
    version =  '0.0.1-SNAPSHOT'
}

repositories {
    jcenter()
    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")
}

10.2安裝Spring Boot CLI

Spring Boot CLI（命令行界面）是一個命令行工具，您可以使用它來快速使用Spring進行原型開發。它可以讓你運行Groovy腳本，這意味着你有一個熟悉的類Java語法，沒有太多的樣板代碼。

您不需要使用CLI來與Spring Boot一起工作，但這絕對是讓Spring應用程序起飛的最快捷方式。

10.2.1手動安裝

您可以從Spring軟件存儲庫下載Spring CLI發行版：

最前沿的分佈式快照也是可用的。

下載之後，請按照解壓縮歸檔中的INSTALL.txt說明進行操作。總之，在.zip文件的bin /目錄中有一個spring腳本（用於Windows的spring.bat）。或者，您可以使用帶有.jar文件的java -jar（該腳本可以幫助您確保正確設置類路徑）。

10.2.2使用SDKMAN安裝！

SDKMAN！（軟件開發工具包管理器）可用於管理各種二進制SDK的多個版本，包括Groovy和Spring Boot CLI。獲取SDKMAN！從sdkman.io安裝Spring Boot並使用以下命令：

$ sdk install springboot
$ spring --version
Spring Boot v2.0.0.BUILD-SNAPSHOT

如果您正在開發CLI的功能，並希望輕鬆訪問您構建的版本，請使用以下命令：

$ sdk install springboot dev /path/to/spring-boot/spring-boot-cli/target/spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin/spring-2.0.0.BUILD-SNAPSHOT/
$ sdk default springboot dev
$ spring --version
Spring CLI v2.0.0.BUILD-SNAPSHOT

前面的說明安裝了一個名爲dev實例的spring的本地實例。它指向你的目標構建位置，所以每當你重建Spring Boot時，spring都是最新的。

您可以通過運行以下命令來查看它：

$ sdk ls springboot

================================================================================
Available Springboot Versions
================================================================================
> + dev
* 2.0.0.BUILD-SNAPSHOT

================================================================================
+ - local version
* - installed
> - currently in use
================================================================================

10.2.3 OSX Homebrew安裝

如果您在Mac上並使用Homebrew，則可以使用以下命令來安裝Spring Boot CLI：
Homebrew 安裝 spring 到 /usr/local/bin.

注：如果您沒有看到該公式，那麼您的brew的安裝可能會過期。在這種情況下，運行brew更新並重試。

10.2.4 MacPorts安裝

如果您在Mac上並使用MacPorts，則可以使用以下命令安裝Spring Boot CLI：

$ sudo port install spring-boot-cli

10.2.5命令行完成

Spring Boot CLI包含爲BASH和zsh shell提供命令完成的腳本。您可以在任何shell中獲取腳本（也稱爲spring），或者將其放入您的個人或系統範圍的bash完成初始化中。在Debian系統上，系統範圍的腳本在/ shell-completion / bash中，當一個新的shell啓動時，該目錄中的所有腳本都會被執行。例如，如果您使用SDKMAN！安裝了手動腳本，請使用以下命令：

$ . ~/.sdkman/candidates/springboot/current/shell-completion/bash/spring
$ spring <HIT TAB HERE>
  grab  help  jar  run  test  version

注：如果使用Homebrew或MacPorts安裝Spring Boot CLI，則命令行完成腳本會自動註冊您的shell。

10.2.6快速啓動Spring CLI示例

您可以使用以下Web應用程序來測試您的安裝。首先，創建一個名爲app.groovy的文件，如下所示：

@RestController
class ThisWillActuallyRun {

    @RequestMapping("/")
    String home() {
        "Hello World!"
    }

}

然後從shell中運行它，如下所示：

$ spring run app.groovy

注：由於依賴的庫需要下載，第一次運行會比較慢。

打開 localhost:8080在您喜歡的瀏覽器中. 您將看到如下輸出:

Hello World!

10.3從較早版本的Spring Boot升級

如果您是從早期版本的Spring Boot進行升級，請查看項目wiki上託管的“發行說明”。您會發現升級說明以及每個版本的“新功能”和“值得注意”功能列表。

要升級現有的CLI安裝，請使用相應的package manager命令（例如，brew升級），或者如果您手動安裝了CLI，請按照標準說明記住更新PATH環境變量以刪除任何舊的引用。

11.開發你的第一個Spring Boot應用程序

本節介紹如何開發一個簡單的“Hello World！”Web應用程序，該應用程序突出了Spring Boot的一些主要功能。我們使用Maven來構建這個項目，因爲大多數IDE都支持它。

注：spring.io網站包含許多使用Spring Boot的“入門指南”。如果您需要解決特定問題，請先在那裏查看。
您可以通過轉到start.spring.io並從依賴關係搜索器中選擇“Web”起始器來快速執行以下步驟。這樣做會產生一個新的項目結構，以便您可以立即開始編碼。查看Spring Initializr文檔以獲取更多詳細信息。

在開始之前，請打開終端並運行以下命令以確保您已安裝了Java和Maven的有效版本：

$ java -version
java version "1.8.0_102"
Java(TM) SE Runtime Environment (build 1.8.0_102-b14)
Java HotSpot(TM) 64-Bit Server VM (build 25.102-b14, mixed mode)

$ mvn -v
Apache Maven 3.3.9 (bb52d8502b132ec0a5a3f4c09453c07478323dc5; 2015-11-10T16:41:47+00:00)
Maven home: /usr/local/Cellar/maven/3.3.9/libexec
Java version: 1.8.0_102, vendor: Oracle Corporation

此示例需要在其自己的文件夾中創建。後續的說明假定你已經創建了一個合適的文件夾，並且它是你的“當前目錄”。(windows環境下提供Path路徑即可)

11.1創建POM

我們需要從創建一個Maven pom.xml文件開始。 pom.xml是用來構建項目的配方。打開你最喜歡的文本編輯器並添加以下內容：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>myproject</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.BUILD-SNAPSHOT</version>
    </parent>

    <!-- Additional lines to be added here... -->

    <!-- (you don't need this if you are using a .RELEASE version) -->
    <repositories>
        <repository>
            <id>spring-snapshots</id>
            <url>http://repo.spring.io/snapshot</url>
            <snapshots><enabled>true</enabled></snapshots>
        </repository>
        <repository>
            <id>spring-milestones</id>
            <url>http://repo.spring.io/milestone</url>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>spring-snapshots</id>
            <url>http://repo.spring.io/snapshot</url>
        </pluginRepository>
        <pluginRepository>
            <id>spring-milestones</id>
            <url>http://repo.spring.io/milestone</url>
        </pluginRepository>
    </pluginRepositories>
</project>

上面的列表應該給你一個工作構建。你可以通過運行mvn軟件包來測試它（現在，你可以忽略“jar將是空的 - 沒有內容被標記爲包含！”警告）。

注：此時，您可以將項目導入IDE（大多數現代Java IDE包含對Maven的內置支持）。爲了簡單起見，我們繼續在這個例子中使用純文本編輯器。

11.2添加類路徑依賴關係

Spring Boot提供了許多“入門”，可以讓您將jar添加到類路徑中。我們的示例應用程序已經在POM的父節點中使用了spring-boot-starter-parent。 spring-boot-starter-parent是一個特別的啓動器，提供了有用的Maven默認值。它還提供了一個依賴管理部分，以便您可以省略版本標記以獲得“有福”的依賴關係。

其他“Starter”提供了在開發特定類型的應用程序時可能需要的依賴關係。由於我們正在開發一個Web應用程序，因此我們添加了一個spring-boot-starter-web依賴項。在此之前，我們可以通過運行以下命令來查看我們目前的狀態：

$ mvn dependency:tree

[INFO] com.example:myproject:jar:0.0.1-SNAPSHOT

mvn依賴項：tree命令打印項目依賴項的樹形表示。你可以看到spring-boot-starter-parent本身不提供依賴關係。要添加必要的依賴關係，請編輯您的pom.xml，並在父節點下方添加spring-boot-starter-web依賴項：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

如果再次運行mvn dependency：tree，則會看到現在有很多附加依賴項，包括Tomcat Web服務器和Spring Boot本身。

11.3編寫代碼

爲了完成我們的應用程序，我們需要創建一個Java文件。默認情況下，Maven從src / main / java編譯源代碼，因此您需要創建該文件夾結構，然後添加名爲src / main / java / Example.java的文件以包含以下代碼：

import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.web.bind.annotation.*;

@RestController
@EnableAutoConfiguration
public class Example {

    @RequestMapping("/")
    String home() {
        return "Hello World!";
    }

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

}

雖然這裏沒有太多的代碼，但還是有很多重要的事在裏頭。我們將在接下來的幾節中介紹一些重要的部分。

11.3.1 @RestController和@RequestMapping註解

我們的Example類的第一個註解是@RestController。這被稱爲stereotype註解。它爲閱讀代碼的人提供了線索，對於Spring來說，這個類扮演着特定的角色。在這種情況下，我們的類是一個web @Controller，所以Spring在處理傳入的Web請求時會考慮它。

@RequestMapping註解提供了“路由”信息。它告訴Spring，任何帶有/ path的HTTP請求都應該映射到home方法。@RestController註解告訴Spring將結果字符串直接返回給調用者。

注：stereotype含義:
表示類型或方法在整體架構中的角色（在概念層面而不是實施層面）。

@RestController和@RequestMapping註解是Spring MVC註解（它們不是Spring Boot特有的）。有關更多詳細信息，請參閱Spring參考資料中的MVC部分。

11.3.2 @EnableAutoConfiguration註解

第二個類級註解是@EnableAutoConfiguration。這個註解告訴Spring Boot根據你添加的jar依賴來“猜測”你將如何配置Spring。由於spring-boot-starter-web添加了Tomcat和Spring MVC，所以自動配置會假定你正在開發一個Web應用程序並相應地設置Spring。

入門和自動配置
自動配置旨在與“啓動器”配合使用，但這兩個概念並不直接相關。您可以自由選擇和選擇初學者之外的jar依賴項，並且Spring Boot將盡其所能地自動配置您的應用程序。

11.3.3 “main” 方法

我們的應用程序的最後一部分是主方法。這只是一個遵循Java約定的應用程序入口點的標準方法。我們的主要方法通過調用run來委託Spring Boot的SpringApplication類。 SpringApplication將引導我們的應用程序，從Spring開始，它將啓動自動配置的Tomcat Web服務器。我們需要將Example.class作爲參數傳遞給run方法，以告知SpringApplication是Spring的主要組件。 args數組也被傳遞以暴露任何命令行參數。

11.4運行示例

在這一點上我們的應用程序應該工作由於我們使用了spring-boot-starter-parent POM，所以我們有一個有用的運行目標，我們可以使用它來啓動應用程序。鍵入mvn spring-boot：從根項目目錄運行以啓動應用程序：

$ mvn spring-boot:run

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v1.5.9.RELEASE)
....... . . .
....... . . . (log output here)
....... . . .
........ Started Example in 2.222 seconds (JVM running for 6.514)

如果你打開一個web瀏覽器到localhost：8080你應該看到下面的輸出：

Hello World!

要正常退出應用程序點擊ctrl-c。

11.5創建一個可執行的jar

讓我們通過創建一個完全獨立的可執行jar文件來完成我們的例子，我們可以在生產環境中運行它。可執行jar（有時也稱爲“fat jars”）是包含您編譯的類以及您的代碼需要運行的所有jar依賴項的歸檔文件。

可執行的jar和Java

Java不提供任何標準的方式來加載嵌套的jar文件（即jar文件本身包含在jar中）。 如果您正在分發自包含的應用程序，這可能會有問題。

爲了解決這個問題，許多開發者使用“超級”罐子。 超級罐子只是將所有罐子裏的所有類打包成一個單一的檔案。 這種方法的問題在於，很難在應用程序中看到實際使用的庫。 如果在多個罐子中使用相同的文件名（但是具有不同的內容），則也可能是有問題的。

Spring Boot採用了不同的方法，可以直接嵌入jar。

要創建一個可執行的jar文件，我們需要將spring-boot-maven-plugin添加到我們的pom.xml。在依賴關係部分下面插入以下幾行：

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

注：spring-boot-starter-parent POM包含配置來綁定重新打包目標。如果您不使用父POM，則需要自行聲明此配置。有關詳細信息，請參閱插件文檔。

保存你的pom.xml並從命令行運行mvn包：

$ mvn package

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building myproject 0.0.1-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] .... ..
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ myproject ---
[INFO] Building jar: /Users/developer/example/spring-boot-example/target/myproject-0.0.1-SNAPSHOT.jar
[INFO]
[INFO] --- spring-boot-maven-plugin:1.5.9.RELEASE:repackage (default) @ myproject ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

如果您查看目標目錄，則應該看到myproject-0.0.1-SNAPSHOT.jar。該文件大小應該在10 MB左右。如果你想查閱裏面的內容，你可以使用jar tvf：

$ jar tvf target/myproject-0.0.1-SNAPSHOT.jar

您還應該在目標目錄中看到一個名爲myproject-0.0.1-SNAPSHOT.jar.original的小得多的文件。這是Maven在被Spring Boot重新包裝之前創建的原始jar文件。

要運行該應用程序，請使用java -jar命令：

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

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v1.5.9.RELEASE)
....... . . .
....... . . . (log output here)
....... . . .
........ Started Example in 2.536 seconds (JVM running for 2.864)

像以前一樣，要優雅地退出應用程序點擊ctrl-c。

12.接下來讀什麼

希望本節爲您提供了一些Spring Boot的基礎知識，並幫助您編寫自己的應用程序。如果您是面向任務的開發人員，則可能需要跳至spring.io，並查看一些入門指南，以解決具體的“如何使用Spring”問題; 我們也有Spring Boot特定的操作指南文檔。

Spring Boot版本庫也有一些你可以運行的樣本。樣本獨立於代碼的其餘部分（也就是說，您不需要構建其餘的代碼來運行或使用樣本）。

否則，下一個邏輯步驟是閱讀第三部分“使用Spring Boot”。如果你真的不耐煩，也可以跳過來閱讀Spring Boot的特性。

Part III. 使用Spring Boot

本節將更詳細地介紹如何使用Spring Boot。它涵蓋了構建系統，自動配置以及如何運行應用程序等主題。我們還介紹了一些Spring Boot的最佳實踐。儘管Spring Boot沒有什麼特別的地方（它只是你可以使用的另一個庫），但是有一些建議，如果遵循這些建議，將使開發過程變得更容易一些。

如果您剛剛開始使用Spring Boot，則可能需要先閱讀入門指南，然後再深入本節。

13.建立系統

強烈建議您選擇支持依賴管理的構建系統，並且可以使用發佈到“Maven Central”存儲庫的工件。我們建議您選擇Maven或Gradle。 Spring Boot可以與其他構建系統（例如Ant）一起工作，但是它們不會得到特別好的支持。

13.1依賴管理

Spring Boot的每個發行版都提供了一個支持的依賴列表。在實踐中，您不需要爲構建配置中的任何這些依賴項提供一個版本，因爲Spring Boot正在爲您進行管理。當您升級Spring Boot本身時，這些依賴關係也將以一致的方式升級。

注：如果您覺得有必要，您仍然可以指定一個版本並覆蓋Spring Boot的建議。

助手列表包含您可以使用Spring Boot的所有Sping模塊以及第三方庫的精選列表。該列表可以作爲標準物料清單（spring-boot-dependencies）提供，也可以爲Maven和Gradle提供額外的專用支持。

注：Spring Boot的每個版本都與Spring Framework的基礎版本相關聯，因此我們強烈建議您不要自行指定其版本。

13.2 Maven

Maven用戶可以從spring-boot-starter-parent項目繼承，以獲得合理的默認值。父項目提供以下功能：

Java 1.6作爲默認的編譯器級別。
UTF-8源碼編譯。
依賴管理部分，允許您省略繼承自Spring-Boot-dependencies POM的通用依賴項的標記。明智的資源過濾。
明智的插件配置（(exec plugin, surefire, Git commit ID, shade）。
對application.properties和application.yml進行明智的資源過濾，包括特定於配置文件的文件（例如application-foo.properties和application-foo.yml）

最後一點：因爲默認配置文件接受Spring樣式佔位符（$ {…}），Maven過濾被改爲使用@ .. @佔位符（你可以用Maven屬性resource.delimiter覆蓋）。

13.2.1繼承初始父項

要將項目配置爲從spring-boot-starter-parent繼承，只需設置父項：

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

注：您應該只需要在此依賴項上指定Spring Boot版本號。如果您導入更多的啓動器，則可以安全地省略版本號。

通過該設置，您還可以通過在自己的項目中重寫屬性來覆蓋各個依賴項。例如，要升級到另一個Spring Data發行版，您需要將以下內容添加到您的pom.xml中。

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

注：檢查spring-boot-dependencies pom支持的屬性列表。

13.2.2使用沒有父POM的Spring Boot

不是每個人都喜歡從spring-boot-starter-parent POM繼承。你可能有你自己的企業標準，你需要使用，或者你可能只是喜歡顯式聲明所有的Maven配置。

如果您不想使用spring-boot-starter-parent，則仍然可以通過使用scope = import dependency來保留依賴項管理的好處：

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

如上所述，該設置不允許您使用屬性覆蓋單個依賴項。爲了達到同樣的結果，你需要在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>1.5.9.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

注：在上面的例子中，我們指定了一個BOM，但是任何依賴類型都可以被覆蓋。

13.2.3更改Java版本

spring-boot-starter-parent選擇相當保守的Java兼容性。如果您想遵循我們的建議並使用較新的Java版本，則可以添加一個java.version屬性：

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

13.2.4使用Spring Boot Maven插件

Spring Boot包含一個Maven插件，可以將項目打包爲可執行的jar文件。如果你想使用它，請將插件添加到部分：

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

注：如果你使用Spring Boot的啓動父POM，只需要添加插件，除非你想改變在父代中定義的設置，否則不需要進行配置。

13.3 Gradle

Gradle用戶可以在他們的依賴項部分直接導入’starters’。與Maven不同的是，沒有“超級父母”可以導入來共享某些配置。

repositories {
    jcenter()
}

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

spring-boot-gradle-plugin也是可用的，並提供了創建可執行的jar和從源代碼運行項目的任務。它還提供依賴性管理，除其他功能外，還允許您省略由Spring Boot管理的任何依賴項的版本號：

plugins {
    id 'org.springframework.boot' version '1.5.9.RELEASE'
    id 'java'
}


repositories {
    jcenter()
}

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

13.4Ant

可以使用Apache Ant + Ivy構建Spring Boot項目。 spring-boot-antlib“AntLib”模塊也可以幫助Ant創建可執行的jar文件。

爲了聲明依賴關係，一個典型的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>

一個典型的`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.5.9.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>

注：如果您不想使用spring-boot-antlib模塊，請參見第84.10節“從Ant構建不使用spring-boot-antlib的可執行文件”。

13.5起動

啓動器是一套方便的依賴描述符，可以包含在應用程序中。您可以獲得所需的所有Spring及相關技術的一站式服務，無需搜索示例代碼，也不需要粘貼依賴關係描述符。例如，如果你想開始使用Spring和JPA來訪問數據庫，只需在你的項目中加入spring-boot-starter-data-jpa依賴項，你就可以開始了。

初學者包含很多依賴項，您需要快速啓動並運行一個項目，並使用一組支持的傳遞依賴項。

命名原則

所有官方首發者都遵循類似的命名模式; spring-boot-starter-，其中是特定類型的應用程序。這種命名結構旨在幫助您找到啓動器。許多IDE中的Maven集成允許您按名稱搜索依賴項。例如，安裝適當的Eclipse或STS插件後，只需在POM編輯器中點擊ctrl-space並鍵入“spring-boot-starter”即可獲得完整列表。

正如創建自己的啓動器部分中所解釋的，第三方啓動器不應該以spring-boot開始，因爲它是爲官方的Spring Boot工件保留的。 acme的第三方初學者通常被命名爲acme-spring-boot-starter。

以下應用程序啓動程序由Spring Boot在org.springframework.boot組下提供：

表13.1。 Spring Boot應用程序啓動器(鏈接實在太多 ,下次再補)

項目名	描述	Pom
spring-boot-starter	Core starter, including auto-configuration support, logging and YAML	Pom
spring-boot-starter-activemq	Starter for JMS messaging using Apache ActiveMQ	Pom
spring-boot-starter-amqp	Starter for using Spring AMQP and Rabbit MQ	Pom
spring-boot-starter-aop	Starter for aspect-oriented programming with Spring AOP and AspectJ	Pom
spring-boot-starter-artemis	Starter for JMS messaging using Apache Artemis	Pom
spring-boot-starter-batch	Starter for using Spring Batch	Pom
spring-boot-starter-cache	Starter for using Spring Framework’s caching support	Pom
spring-boot-starter-cloud-connectors	Starter for using Spring Cloud Connectors which simplifies connecting to services in cloud platforms like Cloud Foundry and Heroku	Pom
spring-boot-starter-data-cassandra	Starter for using Cassandra distributed database and Spring Data Cassandra	Pom
zebra stripes	Starter for using Cassandra distributed database and Spring Data Cassandra	Pom
spring-boot-starter-data-couchbase	Starter for using Couchbase document-oriented database and Spring Data Couchbase	Pom
spring-boot-starter-data-elasticsearch	Starter for using Elasticsearch search and analytics engine and Spring Data Elasticsearch	Pom
spring-boot-starter-data-gemfire	Starter for using GemFire distributed data store and Spring Data GemFire	Pom
spring-boot-starter-data-jpa	Starter for using Spring Data JPA with Hibernate	Pom
spring-boot-starter-data-ldap	Starter for using Spring Data LDAP	Pom
spring-boot-starter-data-mongodb	Starter for using MongoDB document-oriented database and Spring Data MongoDB	Pom
spring-boot-starter-data-neo4j	Starter for using Neo4j graph database and Spring Data Neo4j	Pom
spring-boot-starter-data-redis	Starter for using Redis key-value data store with Spring Data Redis and the Jedis client	Pom
spring-boot-starter-data-rest	Starter for exposing Spring Data repositories over REST using Spring Data REST	Pom
spring-boot-starter-data-solr	Starter for using the Apache Solr search platform with Spring Data Solr	Pom
spring-boot-starter-freemarker	Starter for building MVC web applications using FreeMarker views	Pom
spring-boot-starter-groovy-templates	Starter for building MVC web applications using Groovy Templates views	Pom
spring-boot-starter-hateoas	Starter for building hypermedia-based RESTful web application with Spring MVC and Spring HATEOAS	Pom
spring-boot-starter-integration	Starter for using Spring Integration	Pom
spring-boot-starter-jdbc	Starter for using JDBC with the Tomcat JDBC connection pool	Pom
spring-boot-starter-jersey	Starter for building RESTful web applications using JAX-RS and Jersey. An alternative to spring-boot-starter-web	Pom
spring-boot-starter-jooq	Starter for using jOOQ to access SQL databases. An alternative to spring-boot-starter-data-jpa or spring-boot-starter-jdbc	Pom
spring-boot-starter-jta-atomikos	Starter for JTA transactions using Atomikos	Pom
spring-boot-starter-jta-bitronix	Starter for JTA transactions using Bitronix	Pom
spring-boot-starter-jta-narayana	Spring Boot Narayana JTA Starter	Pom
spring-boot-starter-mail	Starter for using Java Mail and Spring Framework’s email sending support	Pom
spring-boot-starter-mobile	Starter for building web applications using Spring Mobile	Pom
spring-boot-starter-mustache	Starter for building MVC web applications using Mustache views	Pom
spring-boot-starter-security	Starter for using Spring Security	Pom
spring-boot-starter-social-facebook	Starter for using Spring Social Facebook	Pom
spring-boot-starter-social-linkedin	Stater for using Spring Social LinkedIn	Pom
spring-boot-starter-social-twitter	Starter for using Spring Social Twitter	Pom
spring-boot-starter-test	Starter for testing Spring Boot applications with libraries including JUnit, Hamcrest and Mockito	Pom
spring-boot-starter-thymeleaf	Starter for building MVC web applications using Thymeleaf views	Pom
spring-boot-starter-validation	Starter for using Java Bean Validation with Hibernate Validator	Pom
spring-boot-starter-web	Starter for building web, including RESTful, applications using Spring MVC. Uses Tomcat as the default embedded container	Pom
spring-boot-starter-web-services	Starter for using Spring Web Services	Pom
spring-boot-starter-websocket	Starter for building WebSocket applications using Spring Framework’s WebSocket support	Pom

除了應用程序啓動器之外，還可以使用以下啓動器來添加生產準備功能：

表13.2。 Spring Boot生產啓動器

項目名	描述	Pom
spring-boot-starter-actuator	Starter for using Spring Boot’s Actuator which provides production ready features to help you monitor and manage your application	Pom
spring-boot-starter-remote-shell	Starter for using the CRaSH remote shell to monitor and manage your application over SSH. Deprecated since 1.5	Pom

最後，Spring Boot還包括一些可以用來排除或交換特定技術方面的入門知識：

項目名	描述	Pom
spring-boot-starter-jetty	Starter for using Jetty as the embedded servlet container. An alternative to spring-boot-starter-tomcat	Pom
spring-boot-starter-log4j2	Starter for using Log4j2 for logging. An alternative to spring-boot-starter-logging	Pom
spring-boot-starter-logging	Starter for logging using Logback. Default logging starter	Pom
spring-boot-starter-tomcat	Starter for using Tomcat as the embedded servlet container. Default servlet container starter used by spring-boot-starter-web	Pom
spring-boot-starter-undertow	Starter for using Undertow as the embedded servlet container. An alternative to spring-boot-starter-tomcat	Pom

注:有關其他社區貢獻者的列表，請參閱GitHub上的spring-boot-starters模塊中的README文件。

14.構建你的代碼

Spring Boot不需要任何特定的代碼佈局，但是，有一些最佳實踐可以提供幫助。

14.1使用“默認”軟件包

當一個類不包含包聲明時，它被認爲是在“默認包”中。通常不鼓勵使用“默認軟件包”，應該避免使用“默認軟件包”。對於使用@ComponentScan，@EntityScan或@SpringBootApplication註解的Spring Boot應用程序來說，這可能會導致特定的問題，因爲每個jar的每個類都將被讀取。

注：我們建議您遵循Java推薦的軟件包命名約定，並使用反向域名（例如，com.example.project）。

14.2找到主應用程序類

我們通常建議您將主應用程序類放在其他類的根包中。 @EnableAutoConfiguration註解通常放在主類上，它隱式地爲某些項目定義了一個基本的“搜索包”。例如，如果您正在編寫JPA應用程序，則@EnableAutoConfiguration註解類的包將用於搜索@Entity項目。

使用根包也允許使用@ComponentScan註解而不需要指定basePackage屬性。如果您的主類位於根包中，也可以使用@SpringBootApplication註解。

這是一個典型的佈局：

com
 +- example
     +- myproject
         +- Application.java
         |
         +- domain
         |   +- Customer.java
         |   +- CustomerRepository.java
         |
         +- service
         |   +- CustomerService.java
         |
         +- web
             +- CustomerController.java

Application.java文件將聲明main方法以及基本的@Configuration。

package com.example.myproject;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application {

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

}

15.配置類

Spring Boot支持基於Java的配置。雖然可以使用XML源調用SpringApplication.run（），但我們通常建議您的主要來源是@Configuration類。通常，定義main方法的類也是主要@Configuration的一個好候選。

注：在互聯網上已經發布了許多使用XML配置的Spring配置示例。如果可能，請始終嘗試使用基於Java的等效配置。搜索啓用*註解可以是一個很好的起點。

15.1導入其他配置類

你不需要把所有的@Configuration放到一個類中。 @Import註解可用於導入其他配置類。或者，您可以使用@ComponentScan自動獲取所有Spring組件，包括@Configuration類。

15.2導入XML配置

如果您必須使用基於XML的配置，我們建議您仍以@Configuration類開頭。然後您可以使用額外的@ImportResource註解來加載XML配置文件。

16.自動配置

Spring Boot自動配置會嘗試根據您添加的jar依賴項自動配置您的Spring應用程序。例如，如果HSQLDB在您的類路徑中，並且您沒有手動配置任何數據庫連接Bean，則Spring Boot會自動配置內存數據庫。

您需要通過將@EnableAutoConfiguration或@SpringBootApplication註解添加到其中一個@Configuration類來選擇自動配置。

注：您應該只添加一個@EnableAutoConfiguration註解。我們通常建議您將其添加到您的主@Configuration類。

16.1逐漸更換自動配置

自動配置是非侵入式的。在任何時候，您都可以開始定義自己的配置來替換自動配置的特定部分。例如，如果添加您自己的DataSource Bean，則默認的嵌入式數據庫支持會被取消。

如果您需要了解當前正在應用的自動配置，以及爲什麼使用–debug開關啓動您的應用程序。這樣做可以啓用調試日誌以選擇核心記錄器，並將條件報告記錄到控制檯。

16.2禁用特定的自動配置類

如果您發現不需要的特定自動配置類正在應用，則可以使用@EnableAutoConfiguration的exclude屬性來禁用它們，如以下示例所示：

import org.springframework.boot.autoconfigure.*;
import org.springframework.boot.autoconfigure.jdbc.*;
import org.springframework.context.annotation.*;

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

如果類不在類路徑中，則可以使用註解的excludeName屬性，並指定完全限定的名稱。最後，您還可以使用spring.autoconfigure.exclude屬性來控制要排除的自動配置類的列表。

注：您可以在註解級別和通過使用屬性來定義排除。

17.Spirng bean和依賴注入

您可以自由使用任何標準的Spring框架技術來定義您的bean及其注入的依賴關係。爲了簡單起見，我們經常發現使用@ComponentScan（查找你的bean）和使用@Autowired（做構造函數注入）。

如果按上面的建議構建代碼（在根包中查找應用程序類），則可以添加@ComponentScan而不帶任何參數。所有的應用程序組件（@Component，@Service，@Repository，@Controller等）都會自動註冊爲Spring Beans。

以下示例顯示了一個@Service Bean，它使用構造函數注入來獲取所需的RiskAssessor bean：

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，如下例所示：

@Service
public class DatabaseAccountService implements AccountService {

    private final RiskAssessor riskAssessor;

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

    // ...

注：注意如何使用構造函數注入讓riskAssessor字段被標記爲final，表明它不能被隨後改變。

18.使用@SpringBootApplication註解

許多Spring Boot開發人員總是使用@Configuration，@EnableAutoConfiguration和@ComponentScan註解其主類。由於這些註釋經常一起使用（特別是如果您遵循以上最佳實踐），Spring Boot提供了一種方便的@SpringBootApplication替代方法。

@SpringBootApplication註釋等同於使用@Configuration，@EnableAutoConfiguration和@ComponentScan及其默認屬性，如以下示例所示：

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

}

注：@SpringBootApplication還提供別名來自定義@EnableAutoConfiguration和@ComponentScan的屬性。

19.運行您的應用程序

將應用程序封裝爲jar並使用嵌入式HTTP服務器的最大優點之一是，您可以像運行其他應用程序一樣運行應用程序。調試Spring Boot應用程序也很容易。您不需要任何特殊的IDE插件或擴展。

注：本節僅介紹基於jar的包裝。如果您選擇將應用程序打包爲war文件，則應參考您的服務器和IDE文檔。

19.1從IDE運行

您可以從IDE運行Spring Boot應用程序作爲一個簡單的Java應用程序。但是，您首先需要導入您的項目。導入步驟取決於您的IDE和構建系統。大多數IDE可以直接導入Maven項目。例如，Eclipse用戶可以從File菜單中選擇Import …→Existing Maven Projects。

如果不能直接將項目導入IDE，則可以使用構建插件生成IDE元數據。 Maven包含Eclipse和IDEA的插件。 Gradle爲各種IDE提供插件。

提示:如果您意外運行兩次Web應用程序，則會看到“端口已被使用”錯誤。 STS用戶可以使用“重新啓動”按鈕而不是“運行”按鈕來確保關閉任何現有的實例。

19.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.jar

19.3使用Maven插件

Spring Boot Maven插件包含一個可用於快速編譯和運行應用程序的運行目標。應用程序以分解形式運行，就像在IDE中一樣。

$ mvn spring-boot:run

您可能還想使用MAVEN_OPTS操作系統環境變量，如以下示例所示：

$ export MAVEN_OPTS=-Xmx1024m

19.4使用Gradle插件

Spring Boot Gradle插件還包含一個bootRun任務，可用於以分解形式運行您的應用程序。無論何時應用org.springframework.boot和java插件，都會添加bootRun任務，並顯示在以下示例中：

$ gradle bootRun

您可能還想使用JAVA_OPTS操作系統環境變量，如以下示例所示：

$ export JAVA_OPTS=-Xmx1024m

19.5熱插拔

由於Spring Boot應用程序只是普通的Java應用程序，所以JVM熱插拔應該是開箱即用的。 JVM熱插拔在可以替換的字節碼方面有一定的侷限性。對於更完整的解決方案，可以使用JRebel。

spring-boot-devtools模塊還包括對快速應用程序重新啓動的支持。有關詳細信息，請參閱下面的第20章開發人員工具部分以及熱插拔“操作方法”。

20.開發工具

Spring Boot包含一組額外的工具，可以使應用程序開發體驗更愉快。 spring-boot-devtools模塊可以包含在任何項目中以提供額外的開發時間功能。要包含devtools支持，請將模塊依賴關係添加到您的構建中，如Maven和Gradle的以下列表所示：

Maven

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

Gradle

dependencies {
    compile("org.springframework.boot:spring-boot-devtools")
}

注意：運行完整打包的應用程序時，開發人員工具會自動禁用如果您的應用程序是使用java -jar啓動的，或者是從特定的類加載器啓動的，那麼它就被認爲是“生產應用程序”。將依賴關係標記爲可選項是一種最佳實踐，可以防止devtools通過項目傳遞到其他模塊。 Gradle不支持可選的依賴關係，因此您可能需要查看propdeps-plugin。

提示：重新打包的archives 在默認情況下不包含devtools。如果要使用某個遠程devtools功能，則需要禁用excludeDevtools構建屬性以包含它。該屬性支持Maven和Gradle插件。

20.1屬性默認值

Spring Boot支持的一些庫使用緩存來提高性能。例如，模板引擎緩存已編譯的模板以避免重複解析模板文件。此外，Spring MVC可以在服務靜態資源時將HTTP緩存頭添加到響應中。

雖然緩存在生產中非常有益，但是在開發過程中可能會起到反作用，使您無法看到您在應用程序中所做的更改。爲此，spring-boot-devtools默認禁用緩存選項。

緩存選項通常由您的application.properties文件中的設置進行配置。例如，Thymeleaf提供了spring.thymeleaf.cache屬性。 spring-boot-devtools模塊不需要手動設置這些屬性，而是自動應用合理的開發時間配置。

注意:有關由devtools應用的屬性的完整列表，請參閱DevToolsPropertyDefaultsPostProcessor。

20.2自動重啓

當類路徑上的文件發生變化時，使用spring-boot-devtools的應用程序會自動重啓。在IDE中工作時，這可能是一個有用的功能，因爲它爲代碼更改提供了一個非常快速的反饋循環。默認情況下，監視指向文件夾的類路徑上的任何條目以進行更改。請注意，某些資源（如靜態資產和視圖模板）不需要重新啓動應用程序。

觸發重啓

由於DevTools監視類路徑資源，觸發重啓的唯一方法是更新類路徑。 導致類路徑更新的方式取決於您使用的IDE。 在Eclipse中，保存修改後的文件將導致類路徑更新並觸發重啓。 在IntelliJ IDEA中，構建項目（Build - > Make Project）具有相同的效果。

注意:只要分叉被啓用，你也可以使用受支持的構建插件（Maven和Gradle）來啓動你的應用程序，因爲DevTools需要一個獨立的應用程序類加載器才能正常運行。默認情況下，當Gradle和Maven檢測到類路徑上的DevTools時，它們會這樣做。

提示:與LiveReload一起使用時，自動重新啓動的效果非常好。有關詳細信息，請參閱LiveReload部分。如果使用JRebel，則自動重新啓動將被禁用，以支持動態類重新加載。其他devtools功能（如LiveReload和屬性覆蓋）仍然可以使用。

注意：DevTools依靠應用程序上下文的關閉hook在重新啓動期間關閉它。如果您禁用了關閉hook（SpringApplication.setRegisterShutdownHook（false）），它將無法正常工作。

注意:當確定類路徑上的條目在更改時會觸發重新啓動時，DevTools會自動忽略名爲spring-boot，spring-boot-devtools，spring-boot-autoconfigure，spring-boot-actuator和spring-boot-starter的項目。

注意：DevTools需要自定義ApplicationContext使用的ResourceLoader。如果你的應用程序已經提供了一個，它將被包裝。不支持直接覆蓋ApplicationContext上的getResource方法。

重新啓動vs重新加載

Spring Boot提供的重啓技術通過使用兩個類加載器來工作。 不改變的類（例如來自第三方jar的類）被加載到基類加載器中。 您正在開發的類將加載到重啓類加載器中。 當應用程序重新啓動時，重啓classloader被丟棄，並創建一個新的。 這種方法意味着應用程序重新啓動通常比“冷啓動”快得多，因爲基類加載器已經可用並且已經被填充了。

如果您發現重新啓動對於您的應用程序來說不夠快，或者遇到類加載問題，則可以考慮從ZeroTurnaround中重新加載技術，例如JRebel。 這些工作通過重寫類，因爲他們被加載，使他們更容易重新加載。

20.2.1記錄條件評估中的變化

默認情況下，每次重新啓動應用程序時，都會記錄顯示條件評估增量的報告。該報告顯示了對應用程序的自動配置進行的更改，例如添加或刪除Bean以及設置配置屬性。

要禁用報告的記錄，請設置以下屬性：

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

20.2.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.additional-exclude屬性。

20.2.3觀察其他路徑

您可能希望在更改不在類路徑中的文件時重新啓動或重新加載應用程序。爲此，請使用spring.devtools.restart.additional-paths屬性來配置其他路徑以監視更改。您可以使用上述的spring.devtools.restart.exclude屬性來控制額外路徑下的更改是觸發完全重新啓動還是實時重新加載。

20.2.4禁用重啓

如果您不想使用重新啓動功能，則可以使用spring.devtools.restart.enabled屬性將其禁用。在大多數情況下，您可以在application.properties中設置此屬性（這樣做仍會初始化重新啓動類加載器，但不會監視文件更改）。

如果您需要完全禁用重新啓動支持（例如，因爲它不適用於特定的庫），則需要在調用SpringApplication.run（…）之前將spring.devtools.restart.enabled System屬性設置爲false，如以下示例所示：

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

20.2.5使用觸發文件

如果您在IDE中工作，並嘗試連續更改文件，則可能只希望在特定時間觸發重新啓動。爲此，您可以使用“觸發文件”，這是一個特殊的文件，當您想要實際觸發重新啓動檢查時，該文件必須被修改。只更改文件會觸發檢查，只有Devtools檢測到必須執行某些操作時纔會重新啓動。觸發器文件可以手動更新或使用IDE插件。

要使用觸發器文件，請將spring.devtools.restart.trigger-file屬性設置爲觸發器文件的路徑。

提示：您可能希望將spring.devtools.restart.trigger-file設置爲全局設置，以便所有項目的行爲方式相同。

20.2.6自定義重啓類加載器

如上面的重新啓動vs重新加載部分所述，重新啓動功能是通過使用兩個類加載器來實現的。對於大多數應用程序來說，這種方法運行良好但是，有時會導致類加載問題。

默認情況下，IDE中的任何打開的項目都會加載“restart”類加載器，而任何常規的.jar文件都會加載“base”類加載器。如果您使用多模塊項目，而不是每個模塊都導入到IDE中，則可能需要自定義。爲此，您可以創建一個META-INF / spring-devtools.properties文件。

spring-devtools.properties文件可以包含前綴爲restart.exclude和restart.include的屬性。 include元素是應該被拉入到“重啓”類加載器中的項目，排除元素是應該被下推到“基本”類加載器中的項目。該屬性的值是應用於類路徑的正則表達式模式，如以下示例所示：

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

注意:所有的 property keys 必須是唯一的。只要屬性以restart.include開頭。或restart.exclude。都已經被考慮了。

注意：所有類路徑中的META-INF / spring-devtools.properties都將被加載。您可以將文件打包到項目中，也可以打包到項目使用的庫中。

21.打包您的應用

可執行的jar可用於生產部署。由於它們是獨立的，因此它們也非常適合基於雲的部署。

對於額外的“生產準備”功能，例如運行狀況，審計和公制REST或JMX端點，請考慮添加Spring boot執行器。有關詳細信息，請參閱第五部分“執行器：生產就緒功能”。

22.下一步閱讀什麼

您現在應該瞭解如何使用Spring Boot以及您應遵循的一些最佳實踐。您現在可以繼續深入瞭解特定的Spring Boot功能，或者可以跳過並閱讀Spring Boot的“生產準備”部分。

Part IV Spring Boot功能

本節將深入探討Spring Boot的細節。在這裏，您可以瞭解您可能想要使用和定製的關鍵功能。如果您還沒有這樣做，您可能需要閱讀“第二部分”，入門指南“”和“第三部分”，使用Spring Boot“”部分，以便您具備良好的基礎知識。

23. SpringApplication

SpringApplication類提供了一種方便的方式來引導從main（）方法啓動的Spring應用程序。在許多情況下，您可以委託給靜態的SpringApplication.run方法，如下例所示：

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

當您的應用程序啓動時，您應該看到類似於以下輸出的內容：

 .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::   v2.0.0.BUILD-SNAPSHOT

2013-07-31 00:08:16.117  INFO 56603 --- [           main] o.s.b.s.app.SampleApplication            : Starting SampleApplication v0.1.0 on mycomputer with PID 56603 (/apps/myapp.jar started by pwebb)
2013-07-31 00:08:16.166  INFO 56603 --- [           main] ationConfigServletWebServerApplicationContext : Refreshing org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@6e5a8246: startup date [Wed Jul 31 00:08:16 PDT 2013]; root of context hierarchy
2014-03-04 13:09:54.912  INFO 41370 --- [           main] .t.TomcatServletWebServerFactory : Server initialized with port: 8080
2014-03-04 13:09:56.501  INFO 41370 --- [           main] o.s.b.s.app.SampleApplication            : Started SampleApplication in 2.992 seconds (JVM running for 3.658)

默認情況下，會顯示INFO日誌消息，其中包括一些相關的啓動詳細信息，例如啓動應用程序的用戶。

23.1啓動失敗

如果您的應用程序無法啓動，已註冊的FailureAnalyzers將有機會提供專門的錯誤消息和具體操作來解決問題。例如，如果在端口8080上啓動Web應用程序，並且該端口已被使用，則應該看到類似於以下消息的內容：

***************************
APPLICATION FAILED TO START
***************************

Description:

Embedded servlet container failed to start. Port 8080 was already in use.

Action:

Identify and stop the process that's listening on port 8080 or configure this application to listen on another port.

注：Spring Boot提供了大量的錯誤分析實現，您可以添加自己的。

如果沒有故障分析儀能夠處理異常情況，您仍然可以顯示完整的情況報告，以更好地瞭解出了什麼問題。爲此，您需要爲org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener啓用調試屬性或啓用DEBUG日誌記錄。

例如，如果使用java -jar運行應用程序，則可以按如下所示啓用調試屬性：

$ java -jar myproject-0.0.1-SNAPSHOT.jar --debug

23.2自定義橫幅

啓動時打印的橫幅可以通過將banner.txt文件添加到類路徑中或通過將spring.banner.location屬性設置爲此類文件的位置來更改。如果文件的編碼不是UTF-8，可以設置spring.banner.charset。除了文本文件之外，還可以將banner.gif，banner.jpg或banner.png圖像文件添加到您的類路徑或設置spring.banner.image.location屬性。圖像被轉換成ASCII藝術表現形式，並打印在任何文字橫幅上方。

在您的banner.txt文件中，您可以使用以下任何佔位符：

變量	說明
${application.version}	在MANIFEST.MF中聲明的應用程序的版本號。例如，Implementation-Version：1.0打印爲1.0。
${application.formatted-version}	您的應用程序的版本號，如MANIFEST.MF中所聲明的，並進行格式化以顯示（用括號括起來並以v作爲前綴）。例如（v1.0）。
${spring-boot.version}	您正在使用的Spring Boot版本。例如2.0.0.BUILD-SNAPSHOT。
${spring-boot.formatted-version}	您正在使用的Spring Boot版本，格式化爲顯示（用括號括起來並以v作爲前綴）。例如（v2.0.0.BUILD-SNAPSHOT）。
${application.title}	在MANIFEST.MF中聲明的應用程序的標題。例如Implementation-Title：MyApp被打印爲MyApp。

提示：如果要以編程方式生成橫幅，則可以使用SpringApplication.setBanner（…）方法。使用org.springframework.boot.Banner接口並實現自己的printBanner（）方法。

288/5000
您還可以使用spring.main.banner-mode屬性來確定橫幅是否必須在System.out（控制檯）上打印，發送到配置的記錄器（日誌），還是根本不生成（關閉）。

打印的橫幅在以下名稱下注冊爲singleton bean：springBootBanner。

注：YAML映射爲false，因此如果要禁用應用程序中的橫幅，請務必添加引號。

spring:

main:

banner-mode: “off”

23.3定製SpringApplication

如果SpringApplication默認不符合您的喜好，您可以創建一個本地實例並對其進行自定義。例如，要關閉橫幅，你可以寫：

public static void main(String[] args) {
    SpringApplication app = new SpringApplication(MySpringConfiguration.class);
    app.setBannerMode(Banner.Mode.OFF);
    app.run(args);
}

注：傳遞給SpringApplication的構造函數參數是spring bean的配置源。在大多數情況下，它們都是對@Configuration類的引用，但也可能是對XML配置的引用或應該掃描的包。

也可以通過使用application.properties文件來配置SpringApplication。有關詳細信息，請參閱第24章，外部化配置。

有關配置選項的完整列表，請參閱SpringApplication Javadoc。

23.4 Fluent Builder API(流利的建造者API模式)

如果您需要構建一個ApplicationContext層次結構（具有父/子關係的多個上下文），或者您只需要使用“流利”構建器API，則可以使用SpringApplicationBuilder。

SpringApplicationBuilder允許將多個方法調用鏈接在一起，幷包含可以創建層次結構的父級和子級方法，如以下示例所示：

new SpringApplicationBuilder()
        .sources(Parent.class)
        .child(Application.class)
        .bannerMode(Banner.Mode.OFF)
        .run(args);

注：創建ApplicationContext層次結構時有一些限制。例如，Web組件必須包含在子上下文中，並且父環境和子環境都使用相同的環境。有關完整的細節，請參閱SpringApplicationBuilder Javadoc。

23.5應用程序事件和監聽器

除了通常的Spring框架事件，比如ContextRefreshedEvent，SpringApplication還會發送一些附加的應用程序事件。

注：有些事件實際上是在創建ApplicationContext之前觸發的，因此您不能將這些監聽器註冊爲@Bean。您可以使用SpringApplication.addListeners（…）或SpringApplicationBuilder.listeners（…）方法註冊它們。

如果您希望自動註冊這些偵聽器，無論創建應用程序的方式如何，都可以將META-INF / spring.factories文件添加到您的項目中，並使用org.springframework.context引用您的偵聽器。 ApplicationListener鍵，如以下示例所示：

org.springframework.context.ApplicationListener= com.example.project.MyListener

應用程序事件按照以下順序發送，就像您的應用程序運行一樣：

ApplicationStartingEvent在運行開始時發送，除了註冊監聽器和初始化器之外的任何處理之前。
當在上下文中使用的環境是已知的但在創建上下文之前發送ApplicationEnvironmentPreparedEvent。
ApplicationPreparedEvent在刷新開始之前，但在bean定義加載之後發送。
在刷新之後發送ApplicationReadyEvent並處理任何相關的回調，以指示應用程序已準備好爲請求提供服務。
如果啓動時出現異常，則發送ApplicationFailedEvent。

注：您不需要經常使用應用程序事件，但可以方便地知道它們存在。在內部，Spring Boot使用事件來處理各種任務。

應用程序事件是通過使用Spring框架的事件發佈機制發送的。這種機制的一部分確保發佈給子上下文中監聽器的事件也發佈給任何祖先上下文中的監聽器。因此，如果您的應用程序使用SpringApplication實例的層次結構，則偵聽器可能會收到同一類型應用程序事件的多個實例。

爲了讓你的監聽器區分上下文的事件和後代上下文的事件，它應該請求它的應用上下文被注入，然後比較注入的上下文和事件的上下文。上下文可以通過實現ApplicationContextAware來注入，或者如果偵聽器是一個bean，可以通過使用@Autowired注入。

23.6 Web環境

SpringApplication試圖代表你創建正確類型的ApplicationContext。默認情況下，使用AnnotationConfigApplicationContext或AnnotationConfigServletWebServerApplicationContext，具體取決於您是否正在開發Web應用程序。

用來確定“網絡環境”的算法相當簡單（它基於幾個類的存在）。如果您需要覆蓋默認值，可以使用setWebEnvironment（boolean webEnvironment）。

也可以通過調用setApplicationContextClass（…）來完全控制ApplicationContext類型。

提示：在JUnit測試中使用SpringApplication時，通常需要調用setWebEnvironment（false）。

23.7訪問應用程序參數

如果您需要訪問傳遞給SpringApplication.run（…）的應用程序參數，則可以注入一個org.springframework.boot.ApplicationArguments bean。 ApplicationArguments接口提供對原始String []參數以及解析的選項和非選項參數的訪問，如以下示例所示：

import org.springframework.boot.*
import org.springframework.beans.factory.annotation.*
import org.springframework.stereotype.*

@Component
public class MyBean {

    @Autowired
    public MyBean(ApplicationArguments args) {
        boolean debug = args.containsOption("debug");
        List<String> files = args.getNonOptionArgs();
        // if run with "--debug logfile.txt" debug=true, files=["logfile.txt"]
    }

}

提示:Spring Boot還向Spring環境註冊了一個CommandLinePropertySource。這使您可以通過使用@Value註釋來注入單個應用程序參數。

23.8使用ApplicationRunner或CommandLineRunner

如果你需要在SpringApplication啓動後運行一些特定的代碼，你可以實現ApplicationRunner或者CommandLineRunner接口。兩個接口都以相同的方式工作，並提供了一個單一的運行方法，這是在SpringApplication.run（…）完成之前調用的。

CommandLineRunner接口作爲一個簡單的字符串數組提供對應用程序參數的訪問，而ApplicationRunner使用前面討論的ApplicationArguments接口。

import org.springframework.boot.*
import org.springframework.stereotype.*

@Component
public class MyBean implements CommandLineRunner {

    public void run(String... args) {
        // Do something...
    }

}

您還可以實現org.springframework.core.Ordered接口或使用org.springframework.core.annotation.Order註釋，如果定義了多個CommandLineRunner或ApplicationRunner bean，則必須按特定順序調用它們。

23.9應用退出

每個SpringApplication都會向JVM註冊一個關閉鉤子，以確保ApplicationContext在退出時正常關閉。所有標準的Spring生命週期回調（比如DisposableBean接口或者@PreDestroy註解）都可以使用。

另外，如果在調用SpringApplication.exit（）時想要返回特定的退出代碼，bean可以實現org.springframework.boot.ExitCodeGenerator接口。然後可以將此退出代碼傳遞給System.exit（）以將其作爲狀態代碼返回，如以下示例所示：

@SpringBootApplication
public class ExitCodeApplication {

    @Bean
    public ExitCodeGenerator exitCodeGenerator() {
        return () -> 42;
    }

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

}

另外，ExitCodeGenerator接口可能由異常實現。遇到這樣的異常時，Spring Boot會返回實現的getExitCode（）方法提供的退出代碼。

23.10管理員功能

通過指定spring.application.admin.enabled屬性，可以爲應用程序啓用與管理相關的功能。這暴露了平臺MBeanServer上的SpringApplicationAdminMXBean。您可以使用此功能遠程管理您的Spring Boot應用程序。此功能對於任何服務包裝器實現也可能是有用的。

提示：如果您想知道應用程序在哪個HTTP端口上運行，請使用local.server.port的key獲取該屬性。

24.外部化配置

Spring Boot允許您將配置外部化，以便在不同的環境中使用相同的應用程序代碼。您可以使用屬性文件，YAML文件，環境變量和命令行參數來外部化配置。屬性值可以通過使用@Value註解直接注入到bean中，通過Spring的Environment抽象來訪問，或者通過@ConfigurationProperties綁定到結構化對象。

Spring Boot使用了一個非常特殊的PropertySource命令，該命令旨在允許明智的重寫值。屬性按以下順序考慮：

在主目錄上開發Devtools全局設置屬性（當devtools處於活動狀態時〜/ .spring-boot-devtools.properties）。
在你的測試中使用@TestPropertySource註解。
在你的測試中@ SpringBootTest＃屬性註解屬性。
命令行參數。
來自SPRING_APPLICATION_JSON的屬性（嵌入在環境變量或系統屬性中的內聯JSON）。
ServletConfig初始化參數。
ServletContext初始化參數。
來自java：comp / env的JNDI屬性。
Java系統屬性（System.getProperties（））。
OS環境變量。
一個RandomValuePropertySource只具有隨機的屬性*。
打包jar（application- {profile} .properties和YAML變體）之外的特定於配置文件的應用程序屬性。
打包在您的jar（application- {profile} .properties和YAML變體）中的特定於配置文件的應用程序屬性。
應用程序屬性在打包的jar之外（application.properties和YAML變體）。
打包在jar中的應用程序屬性（application.properties和YAML變體）。
@Configuration類的@PropertySource註釋。
默認屬性（使用SpringApplication.setDefaultProperties指定）。

爲了提供一個具體的例子，假設你開發了一個使用name屬性的@Component，如下例所示：

import org.springframework.stereotype.*
import org.springframework.beans.factory.annotation.*

@Component
public class MyBean {

    @Value("${name}")
    private String name;

    // ...

}

在您的應用程序類路徑中（例如，在您的jar中），您可以擁有一個application.properties文件，該文件爲名稱提供了一個合理的默認屬性值。在新環境中運行時，可以在jar外部提供一個application.properties文件來覆蓋該名稱。對於一次性測試，您可以使用特定的命令行開關（例如，java -jar app.jar –name =“Spring”）啓動。

提示：可以使用環境變量在命令行上提供SPRING_APPLICATION_JSON屬性。例如，您可以在UN * X shell中使用以下行：

$ SPRING_APPLICATION_JSON =’{“acme”：{“name”：“test”}}’java -jar myapp.jar
在前面的例子中，Spring結束了acme.name = test。您也可以在System屬性中將spring提供爲spring.application.json，如下例所示：

$ java -Dspring.application.json =’{“name”：“test”}’-jar myapp.jar
您還可以使用命令行參數提供JSON，如以下示例所示：

$ java -jar myapp.jar –spring.application.json =’{“name”：“test”}’
您還可以將JSON作爲JNDI變量提供，如下所示：java：comp / env / spring.application.json。

24.1配置隨機值

RandomValuePropertySource用於注入隨機值（例如，注入祕密或測試用例）。它可以產生整數，長整數，uuids或字符串，如下例所示：

my.secret=${random.value}
my.number=${random.int}
my.bignumber=${random.long}
my.uuid=${random.uuid}
my.number.less.than.ten=${random.int(10)}
my.number.in.range=${random.int[1024,65536]}

ndom.int *語法是OPEN值（，max）CLOSE其中OPEN，CLOSE是任何字符和值，max是整數。如果提供最大值，則值是最小值，最大值是最大值（不包括）。

24.2訪問命令行屬性

默認情況下，SpringApplication將任何命令行選項參數（即以“ - ”開頭的參數，例如–server.port = 9000）轉換爲屬性並將其添加到Spring環境。如前所述，命令行屬性總是優先於其他屬性源。

如果您不希望將命令行屬性添加到環境中，則可以使用SpringApplication.setAddCommandLineProperties（false）將其禁用。

24.3應用程序屬性文件

SpringApplication從以下位置的application.properties文件加載屬性，並將它們添加到Spring環境中：

當前目錄的A / config子目錄。
當前目錄
一個classpath / config包
類路徑根

該列表按優先順序排列（在列表中較高的位置定義的屬性將覆蓋在較低位置定義的屬性）。

注:您也可以使用YAML（’.yml’）文件替代“.properties”。

如果您不喜歡application.properties作爲配置文件名，則可以通過指定一個spring.config.name環境屬性來切換到另一個文件名。您還可以使用spring.config.location環境屬性（逗號分隔的目錄位置或文件路徑列表）引用顯式位置。以下示例顯示如何指定不同的文件名稱：

$ java -jar myproject.jar --spring.config.name=myproject

以下示例顯示如何指定兩個位置：

$ java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties

警告：
spring.config.name和spring.config.location很早就用來確定哪些文件必須被加載，所以它們必須被定義爲環境屬性（通常是OS環境變量，系統屬性或命令行參數）。

如果spring.config.location包含目錄（而不是文件），則它們應該以/結尾（並且在運行時加載在加載之前從spring.config.name生成的名稱，包括配置文件特定的文件名）。在spring.config.location中指定的文件原樣使用，不支持特定於配置文件的變體，並被特定於配置文件的特性覆蓋。

配置位置按相反順序搜索。默認情況下，配置的位置是classpath：/，classpath：/ config /，file：./，file：./ config /。結果搜索順序如下：

file:./config/
file:./
classpath:/config/
classpath:/

當使用spring.config.location配置自定義配置位置時，它們會替換默認位置。例如，如果使用值classpath：/ custom-config /，file：./ custom-config /配置了spring.config.location，則搜索順序如下所示：

file:./custom-config/
classpath:custom-config/

或者，使用spring.config.additional-location配置自定義配置位置時，除了默認位置以外，還會使用它們。在默認位置之前搜索其他位置。例如，如果配置了classpath：/ custom-config /，file：./ custom-config /的額外位置，則搜索順序如下所示：

file:./custom-config/
classpath:custom-config/
file:./config/
file:./
classpath:/config/
classpath:/

這種搜索順序使您可以在一個配置文件中指定默認值，然後在另一個配置文件中有選擇地覆蓋這些值您可以在其中一個默認位置爲application.properties中的應用程序提供默認值（或者使用spring.config.name選擇的其他基本名稱）。這些默認值可以在運行時被置於其中一個自定義位置的不同文件覆蓋。

注：如果使用環境變量而非系統屬性，則大多數操作系統不允許使用句點分隔的鍵名稱，但可以使用下劃線（例如，SPRING_CONFIG_NAME而不是spring.config.name）。

注：如果您的應用程序在容器中運行，則可以使用JNDI屬性（在java：comp / env中）或servlet上下文初始化參數，而不是使用環境變量或系統屬性。

24.4配置文件特定的屬性

除了application.properties文件外，還可以使用命名約定application- {profile} .properties來定義配置文件特定的屬性。如果沒有設置活動配置文件，環境會有一組默認的配置文件（默認爲[默認]）。換句話說，如果沒有顯式激活配置文件，則會加載來自application-default.properties的屬性。

特定於配置文件的屬性是從標準application.properties的相同位置加載的，配置文件特定的文件總是覆蓋非特定的文件，而不管配置文件特定的文件位於打包的jar內還是外部。

如果指定了多個配置文件，則應用最後一個贏取策略。例如，由spring.profiles.active屬性指定的配置文件將添加到通過SpringApplication API配置的配置文件之後，因此優先。

注：如果您在spring.config.location中指定了任何文件，則不考慮這些文件的特定於配置文件的變體。如果您還想使用配置文件特定的屬性，請使用spring.config.location中的目錄

24.5屬性中有佔位符

application.properties中的值在使用時會通過現有環境進行過濾，因此您可以返回到以前定義的值（例如，從System properties）。

app.name=MyApp
app.description=${app.name}

提示：您也可以使用這種技術來創建現有Spring Boot屬性的“簡短”變體。有關詳細信息，請參見第73.4節“使用簡短的”命令行參數“”。

24.6使用YAML而不是屬性

YAML是JSON的一個超集，因此，它是用於指定分層配置數據的非常方便的格式。 SpringApplication類自動支持YAML作爲屬性的替代方法，只要在類路徑中有SnakeYAML庫。

注:如果您使用“Starter”，則SnakeYAML由spring-boot-starter自動提供。

24.6.1加載YAML

Spring框架提供了兩個方便的類，可以用來加載YAML文檔。 YamlPropertiesFactoryBean將YAML作爲屬性加載，YamlMapFactoryBean將YAML作爲Map加載。

例如，請考慮以下YAML文檔：

environments:
    dev:
        url: http://dev.example.com
        name: Developer Setup
    prod:
        url: http://another.example.com
        name: My Cool App

面的例子將被轉換成以下屬性：

environments.dev.url=http://dev.example.com
environments.dev.name=Developer Setup
environments.prod.url=http://another.example.com
environments.prod.name=My Cool App

YAML列表被表示爲帶有[index]解引用的屬性鍵。例如，考慮下面的YAML：

my:
servers:
    - dev.example.com
    - another.example.com

前面的例子將被轉換成這些屬性：

my.servers[0]=dev.example.com
my.servers[1]=another.example.com

要通過使用Spring DataBinder實用程序（這是@ConfigurationProperties所做的）綁定到這樣的屬性，您需要在java.util.List（或Set）類型的目標Bean中擁有一個屬性，並且您需要提供一個setter 或者用一個可變的值初始化它。例如，以下示例綁定到以前顯示的屬性：

@ConfigurationProperties(prefix="my")
public class Config {

    private List<String> servers = new ArrayList<String>();

    public List<String> getServers() {
        return this.servers;
    }
}

注：當列表配置在多個地方時，通過替換整個列表覆蓋工作。在前面的例子中，當my.servers在幾個地方被重新定義時，來自PropertySource的整個列表具有更高的優先級，將覆蓋該列表的任何其他配置。逗號分隔列表和yaml列表都可以用來完全覆蓋列表的內容。

24.6.2在Spring環境中將YAML作爲屬性公開

YamlPropertySourceLoader類可以用來在Spring環境中將YAML作爲一個PropertySource公開。這樣做可以讓您使用帶有佔位符語法的@Value註釋來訪問YAML屬性。

24.6.3多配置文件YAML文件

您可以通過使用spring.profiles鍵來指定多個配置文件特定的YAML文檔在單個文件中，以指示文檔何時適用，如以下示例所示：

server:
    address: 192.168.1.100
---
spring:
    profiles: development
server:
    address: 127.0.0.1
---
spring:
    profiles: production
server:
    address: 192.168.1.120

在前面的示例中，如果開發配置文件處於活動狀態，則server.address屬性爲127.0.0.1。同樣，如果生產配置文件處於活動狀態，則server.address屬性爲192.168.1.120。如果開發和生產配置文件未啓用，則屬性值爲192.168.1.100。

如果應用程序上下文啓動時沒有顯式激活，則激活默認配置文件。所以，在下面的YAML中，我們爲spring.security.user.password設置了一個只在“默認”配置文件中可用的值：


server:
  port: 8000
---
spring:
  profiles: default
  security:
    user:
      password: weak

而在以下示例中，由於密碼未附加到任何配置文件，因此始終設置密碼，必須根據需要在所有其他配置文件中明確重置該密碼：


server:
  port: 8000
spring:
  security:
    user:
      password: weak

通過使用“spring.profiles”元素指定的spring配置文件可以有選擇地使用！字符。如果爲單個文檔指定了否定配置文件和非否定配置文件，則至少有一個非否定配置文件必須匹配，且否定配置文件可能不匹配。

24.6.4 YAML的缺點
YAML文件不能使用@PropertySource註解加載。所以，如果您需要以這種方式加載值，則需要使用屬性文件。

24.6.5合併YAML列表
正如我們上面看到的，任何YAML內容最終都會轉換爲屬性。當通過配置文件重寫“列表”屬性時，該過程可能是違反直覺的。

例如，假設名稱和描述屬性默認爲空的MyPojo對象。以下示例公開了AcmeProperties中的MyPojo列表：

@ConfigurationProperties("acme")
public class AcmeProperties {

    private final List<MyPojo> list = new ArrayList<>();

    public List<MyPojo> getList() {
        return this.list;
    }

}

考慮以下配置：

acme:
  list:
    - name: my name
      description: my description
---
spring:
  profiles: dev
acme:
  list:
       - name: my another name

如果dev配置文件不活動，AcmeProperties.list包含一個如上定義的MyPojo條目。如果啓用配置文件但是，列表仍然只包含一個條目（名稱爲“我的另一個名稱”和描述爲空）。此配置不會將第二個MyPojo實例添加到列表中，並且不合並這些項目。

當在多個配置文件中指定一個集合時，將使用具有最高優先級（只有那個）的集合：

acme:
  list:
    - name: my name
      description: my description
    - name: another name
      description: another description
---
spring:
  profiles: dev
acme:
  list:
     - name: my another name

在前面的示例中，如果dev配置文件處於活動狀態，則AcmeProperties.list包含一個MyPojo條目（名稱爲“我的另一個名稱”，空描述）。

24.7類型安全的配置屬性

使用@Value（“$ {property}”）註釋來注入配置屬性有時會非常麻煩，特別是如果您使用多個屬性或者您的數據是分層的。 Spring Boot提供了另一種使用屬性的方法，可以讓強類型的bean管理和驗證應用程序的配置，如以下示例所示：

package com.example;

import java.net.InetAddress;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties("acme")
public class AcmeProperties {

    private boolean enabled;

    private InetAddress remoteAddress;

    private final Security security = new Security();

    public boolean isEnabled() { ... }

    public void setEnabled(boolean enabled) { ... }

    public InetAddress getRemoteAddress() { ... }

    public void setRemoteAddress(InetAddress remoteAddress) { ... }

    public Security getSecurity() { ... }

    public static class Security {

        private String username;

        private String password;

        private List<String> roles = new ArrayList<>(Collections.singleton("USER"));

        public String getUsername() { ... }

        public void setUsername(String username) { ... }

        public String getPassword() { ... }

        public void setPassword(String password) { ... }

        public List<String> getRoles() { ... }

        public void setRoles(List<String> roles) { ... }

    }
}

前面的POJO定義了以下屬性：

acme.enabled，默認爲false。
acme.remote-address，可以從String強制類型。
acme.security.username，帶有嵌套的“安全”對象，其名稱由屬性的名稱確定。特別是，返回類型沒有在那裏使用，可能是SecurityProperties。
acme.security.password。
acme.security.roles，帶有一個String的集合。

注：getters和setter通常是強制的，因爲綁定是通過標準的Java Beans屬性描述符來完成的，就像在Spring MVC中一樣。在以下情況下，可能會忽略setter：

地圖，只要它們被初始化，需要一個getter，但不一定是一個setter，因爲它們可以被綁定器改變。
集合和數組可以通過索引（通常使用YAML）或使用單個逗號分隔值（屬性）來訪問。在後一種情況下，二傳手是強制性的。我們建議始終爲這種類型添加一個setter。如果初始化一個集合，確保它不是不可變的（如前面的例子）。
如果嵌套的POJO屬性被初始化（如上例中的Security域），則不需要setter。如果您希望活頁夾使用其默認構造函數即時創建實例，則需要一個setter。
有些人使用Project Lombok來自動添加getter和setter。確保Lombok不會爲這種類型生成任何特定的構造函數，因爲它被容器自動使用來實例化對象。

提示：另請參閱@Value和@ConfigurationProperties之間的區別。

您還需要列出要在@EnableConfigurationProperties註釋中註冊的屬性類：

@Configuration
@EnableConfigurationProperties(AcmeProperties.class)
public class MyConfiguration {
}

Spring Boot文檔翻譯

目錄