登錄
註冊
寫文章
首頁
下載APP
Spring Boot 2 官方指導手冊譯文
Hsinwong
關注
讚賞支持
Spring Boot 2 官方指導手冊譯文
1
2018.05.11 11:44:54
字數 18289
閱讀 8299
入門
介紹 Spring Boot
Spring Boot 使您可以輕鬆地創建獨立的、生產級的基於 Spring 的應用程序，您可以運行這些應用程序。我們對 Spring 平臺和第三方庫採取了固執己見的觀點，這樣您就可以輕鬆地開始，不被瑣事所困擾。大多數 Spring Boot 應用程序都需要很少的 Spring 配置。
您可以使用 Spring Boot 來創建 Java 應用程序，這些應用程序可以通過使用 java -jar 或更傳統的 war 部署來啓動。我們還提供了一個運行“spring 腳本”的命令行工具。
我們的主要目標是：
爲所有 Spring 開發提供一種快速而廣泛的入門體驗。
要固執己見地拆箱即用，但當需求開始偏離默認值時，迅速退出。
提供一系列非功能特性，這些特性在大型項目中是常見的（例如嵌入式服務器、安全、指標、健康檢查和外部化配置）。
絕對沒有代碼生成，也不需要 XML 配置。
系統要求
Spring Boot 2.0.2.RELEASE 需要 Java 8（或 9）和 Spring Framework 5.0.6.RELEASE（或更高）。爲 Maven 3.2+ 和 Gradle 4 提供了顯式構建支持。
Servlet 容器
Spring Boot 支持以下嵌入式 servlet 容器：
名稱
Servlet 版本
Tomcat 8.5
3.1
Jetty 9.4
3.1
Undertow 1.4
3.1
您還可以將 Spring Boot 應用程序部署到任何 Servlet 3.1+ 兼容的容器中。
安裝 Spring Boot
Maven 安裝
Spring Boot 與 Apache Maven 3.2 或以上兼容。如果您沒有安裝 Maven，則可以按照 maven.apache.org 的指示操作。
Spring Boot 依賴關係使用 org.springframework.boot groupId。 通常，你的 Maven POM 文件繼承自 spring-boot-starter-parent 項目，並向一個或多個啓動器聲明依賴關係。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.2.RELEASE</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>
</project>
spring-boot-starter-parent 是使用 Spring Boot 的一個很好的方式，但它可能並不總是合適的。有時，你需要繼承自一個不同的父 POM，或者你可能不喜歡我們的默認設置。在那些情況下，查看 第 13.2.2 節：“使用不包含父 POM 的 Spring Boot” 瞭解使用 import scope 的替代解決方案。
Gradle 安裝
Spring Boot 與 Gradle 4 兼容。如果您還沒有安裝 Gradle，您可以按照 gradle.org 上的說明進行操作。
Spring Boot 依賴關係可以使用 org.springframework.boot group 聲明。通常，你的項目向一個或多個啓動器聲明依賴關係。Spring Boot 提供了一個有用的 Gradle 插件，它可以用來簡化依賴項聲明並創建可執行的 jar。
Gradle Wrapper
當您需要構建一個項目時，Gradle Wrapper 提供了一種“獲取”Gradle 的好方法。它是一個小腳本和庫，您可以在代碼旁邊提交，以引導構建過程。有關詳細信息，請參閱 docs.gradle.org/4.2.1/userguide/gradle_wrapper.html。
下面的示例顯示一個典型的 build.gradle 文件：
plugins {
id 'org.springframework.boot' version '2.0.2.RELEASE'
id 'java'
}
jar {
baseName = 'myproject'
version = '0.0.1-SNAPSHOT'
}
repositories {
jcenter()
}
dependencies {
compile("org.springframework.boot:spring-boot-starter-web")
testCompile("org.springframework.boot:spring-boot-starter-test")
}
從 Spring Boot 的一個早期的版本升級
如果您正在從早期的 Spring Boot 版本升級，請檢查提供詳細的升級說明的“遷移指南”。還要檢查發行說明，以獲得每個版本的“新的和值得注意的”特性。
開發你的第一個 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
此示例需要在其自己的文件夾中創建。隨後的指令假設您已經創建了一個合適的文件夾，並且它是您當前的目錄。
創建 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.2.RELEASE</version>
</parent>
<!-- Additional lines to be added here... -->
</project>
前面的清單應該給您一個生效的構建。您可以通過運行 mvn package 來測試它（現在，您可以忽略“jar will be empty - no content was marked for inclusion!”警告）。
此時，您可以將項目導入到 IDE 中（大多數現代 Java IDE 都包含對 Maven 的內置支持）。爲了簡單起見，我們繼續使用這個示例的純文本編輯器。
添加類路徑依賴項
Spring Boot 提供了一些“啓動器”讓你可以添加 jar 到你的類路徑。我們的示例應用程序已經在 POM 的 parent 部分使用了 spring-boot-starter-parent。spring-boot-starter-parent 是一個特殊的啓動器，它提供了有用的 Maven 默認值。它還提供了一個 dependency-management 部分，以便對於“有福的”依賴項你可以省略版本標記。
其它“啓動器”提供在開發特定類型的應用程序時可能需要的依賴項。由於我們正在開發一個 web 應用程序，所以我們添加了一個 spring-boot-starter-web 依賴項。在此之前，我們可以通過運行以下命令查看當前所擁有的內容：
$ mvn dependency:tree
[INFO] com.example:myproject:jar:0.0.1-SNAPSHOT
mvn dependency:tree 命令打印你的項目依賴項的樹型表示。您可以看到 spring-boot-starter-parent 本身不提供依賴項。要添加必要的依賴項，請編輯 pom.xml 並將 spring-boot-starter-web 依賴項立即添加到 parent 部分下方：
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
如果你再次運行 mvn dependency:tree，您可以看到現在有許多額外的依賴項，包括 Tomcat web 服務器和 Spring Boot 本身。
編寫你的代碼
要完成我們的應用程序，我們需要創建一個 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);
}
}
雖然這裏沒有多少代碼，但仍有很多工作要做。我們將在接下來的幾節中討論重要的部分。
@RestController 和 @RequestMapping 註解
在我們的示例類上的第一個註解是 @RestController。這被稱爲構造型註解。它爲閱讀代碼的人們提供了一些提示，並且爲 Spring 提供了一個特定的角色。在本例中，我們的類是一個web @Controller，所以 Spring 在處理傳入 web 請求時考慮它。
@RequestMapping 註解提供了“路由”信息。它告訴 Spring，任何帶有 / 路徑的 HTTP 請求都應該映射到 home 方法。@RestController 註解告訴 Spring 將生成的字符串直接呈現給調用者。
@RestController 和 @RequestMapping 註解是 Spring MVC 註解。（它們不是特定於 Spring Boot 的。）有關更多詳細信息，請參見 Spring 參考文檔中的 MVC 部分。
@EnableAutoConfiguration 註解
第二個類級別註解是 @EnableAutoConfiguration。這個註解告訴 Spring Boot 去“猜測”您想如何配置 Spring，這基於您添加的 jar 依賴項。因爲 spring-boot-starter-web 添加了 Tomcat 和 Spring MVC，所以自動配置假設您正在開發一個 web 應用程序，並相應地設置 Spring。
啓動器和自動配置
自動配置被設計成與“啓動器”很好地工作，但是這兩個概念並沒有直接關聯。您可以自由地選擇除啓動器之外的 jar 依賴項。Spring Boot 仍然盡力地自動配置您的應用程序。
main 方法
我們的應用程序的最後一部分是 main 方法。這只是遵循應用程序入口點的 Java 約定的標準方法。通過調用 run，我們的 main 方法委託給 Spring Boot 的 SpringApplication 類。SpringApplication 引導我們的應用程序啓動 Spring，而 Spring 又啓動了自動配置的 Tomcat web 服務器。我們需要傳遞 Example.class 作爲 run 方法的參數，以告訴 SpringApplication 它是主要的 Spring 組件。args 數組也被傳遞，以暴露任何命令行參數。
運行這個示例
此時，您的應用程序應該可以工作了。因爲您使用了 spring-boot-starter-parent POM，所以您有一個有用的 run 目標，您可以使用它來啓動應用程序。 在根項目目錄鍵入 mvn spring-boot:run 以啓動應用程序。您應該會看到類似如下的輸出：
$ mvn spring-boot:run
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v2.0.2.RELEASE)
....... . . .
....... . . . (log output here)
....... . . .
........ Started Example in 2.222 seconds (JVM running for 6.514)
如果你打開一個瀏覽器，訪問 http://localhost:8080/，你應該會看見如下輸出：
Hello World!
要優雅地退出應用程序，按 ctrl-c。
創建一個可執行的 jar
我們通過創建一個可以在生產中運行的完全自包含的可執行 jar 文件來完成我們的示例。可執行 jar（有時稱爲“fat jars”）是包含您的編譯類的存檔文件，以及您的代碼需要運行所需的所有 jar 依賴項。
可執行的 jar 和 Java
Java 沒有提供加載嵌套 jar 文件的標準方法（jar 文件本身包含在一個 jar 中）。如果您希望分發一個自包含的應用程序，這可能會有問題。
爲了解決這個問題，許多開發人員使用“uber”jar。一個 uber jar 將所有應用程序依賴項的所有類打包成一個歸檔文件。這種方法的問題在於，很難看到應用程序中有哪些庫。如果在多個 jar 中使用相同的文件名（但使用不同的內容），也會有問題。
Spring Boot 採用了一種不同的方法，讓您可以直接嵌套 jar。
要創建一個可執行 jar，我們需要將 spring-boot-maven-plugin 添加到我們的 pom.xml 中。要做到這一點，請在 dependencies 部分下面插入以下幾行：
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
spring-boot-starter-parent POM 包含 <executions> 配置以綁定 repackage 目標。如果您不使用父 POM，您需要自己聲明這個配置。有關詳細信息，請參見插件文檔。
保存你的 pom.xml 並在命令行運行 mvn package，如下所示：
$ 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:2.0.2.RELEASE:repackage (default) @ myproject ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
如果你查看 target 目錄內部，你應該會看到 myproject-0.0.1-SNAPSHOT.jar，這個文件應該差不多 10MB 大小。如果你想偷看裏面的內容，你可以使用 jar tvf，如下所示：
$ jar tvf target/myproject-0.0.1-SNAPSHOT.jar
你應該也會看見一個更小的名爲 myproject-0.0.1-SNAPSHOT.jar.original 的文件在 target 目錄下。這是在 Spring Boot 重新打包之前，Maven 創建的初始 jar 文件 。
要運行該應用程序，使用 java -jar 命令，如下所示：
$ java -jar target/myproject-0.0.1-SNAPSHOT.jar
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v2.0.2.RELEASE)
....... . . .
....... . . . (log output here)
....... . . .
........ Started Example in 2.536 seconds (JVM running for 2.864)
像前面一樣，要退出該應用程序，按 ctrl-c。
下一步該讀什麼
希望這一節提供了一些 Spring Boot 基礎知識，並幫助您編寫自己的應用程序。如果您是面向任務的開發人員，您可能想跳到 spring.io 並查看一些入門指南來解決具體的“我如何用 Spring 實現它？”問題。我們還有 Spring Boot 特有的“如何做”參考文檔。
Spring Boot 存儲庫也有一些您可以運行的示例。這些示例與代碼的其餘部分無關（也就是說，您不需要構建其餘的代碼來運行或使用示例）。
否則，下一個邏輯步驟是閱讀 第三部分：“使用 Spring Boot”。如果你真的很不耐煩，你也可以跳過，讀一下 Spring Boot 特性。
使用 Spring Boot
本節將詳細討論如何使用 Spring Boot。它涵蓋了諸如構建系統、自動配置以及如何運行應用程序等主題。我們還介紹了一些 Spring Boot 最佳實踐。儘管 Spring Boot 沒有什麼特別之處（它只是您可以使用的另一個庫），但是有一些建議，在接下來的時候，使您的開發過程更容易一些。
如果您開始使用 Spring Boot，那麼您應該在深入這一節之前閱讀入門指南。
構建系統
強烈建議您選擇一個支持依賴管理的構建系統，並且可以使用發佈到“Maven Central”存儲庫的工件。我們建議您選擇 Maven 或 Gradle。可以讓 Spring Boot 與其他構建系統（例如 Ant）一起工作，但是它們並不是特別受支持。
依賴管理
Spring Boot 的每一個版本都提供了它所支持的一個被整理的依賴項列表。實際上，在構建配置中，您不需要爲這些依賴項提供一個版本，因爲 Spring Boot 爲您管理這些依賴項。當您升級 Spring Boot 本身時，這些依賴項也會以一致的方式升級。
如果需要，您仍然可以指定一個版本並覆蓋 Spring Boot 的建議。
策劃列表包含了 Spring Boot 可以使用的所有 spring 模塊以及第三方庫的改進列表。這個列表可以作爲一個標準的材料清單（spring-boot-dependencies），可以適用於 Maven 和 Gradle。
Spring Boot 的每個版本都與 Spring 框架的一個基本版本相關聯。我們強烈建議您不要指定它的版本。
Maven
Maven 用戶可以從 spring-boot-starter-parent 項目繼承來獲得合理的默認值。父項目提供了以下特性：
Java 1.8 作爲默認編譯等級
UTF-8 源碼編碼
一個依賴管理部分，繼承自 spring-boot-dependencies pom，管理通用依賴項的版本。這個依賴管理允許你在自己的 pom 中使用這些依賴項時省略 <version> 標籤
明智的資源過濾
明智的插件配置（exec plugin、Git commit ID 和 shade）
明智的用於 application.properties 和 application.yml 的包含特定 profile 文件的資源過濾（比如：application-dev.properties 和 application-dev.yml）
注意，由於 application.properties 和 application.yml 文件接受 Spring 風格的佔位符 ${…}，Maven 過濾被更改爲使用 @..@ 佔位符。（你可以通過設置一個名爲 resource.delimiter 的 Maven 屬性來覆蓋它。）
繼承父啓動器
要配置你的項目繼承自 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.2.RELEASE</version>
</parent>
您應該僅在此依賴項上指定 Spring Boot 版本號。如果您導入額外的啓動器，您可以安全地省略版本號。
通過這種設置，您還可以通過在自己的項目中覆蓋一個屬性來覆蓋單個依賴項。例如，要升級到另一個 Spring Data release train，您需要將以下內容添加到您的 pom.xml：
<properties>
<spring-data-releasetrain.version>Fowler-SR2</spring-data-releasetrain.version>
</properties>
檢查 spring-boot-dependencies pom 獲取支持的屬性列表。
使用沒有父 POM 的 Spring Boot
不是每個人都喜歡繼承自 spring-boot-starter-parent POM。您可能有您自己的企業標準父類，您需要使用它們，或者您可能傾向於顯式地聲明所有的 Maven 配置。
如果你不想使用 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.2.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
前面的示例設置不允許您使用屬性來覆蓋單個依賴項，如上所述。要實現相同的結果，您需要在 spring-boot-dependencies 條目之前在您的項目的依賴項管理中添加一個條目。例如，要升級到另一個 Spring Data release train，您可以將以下元素添加到您的 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>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.0.2.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
在前面的示例中，我們指定了一個 BOM，但是任何依賴類型都可以以相同的方式被覆蓋。
使用 Spring Boot Maven 插件
Spring Boot 包含了一個 Maven 插件可以將項目打包成一個可執行的 jar。如果你想使用它，添加該插件到你的 <plugins> 部分，如下示例所示：
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
如果你使用 Spring Boot 啓動器父 pom，你只需要添加該插件。沒有其它需要配置的東西，除非你想修改父 pom 中定義的設置。
Gradle
要了解搭配 Gradle 來使用 Spring Boot，請參考 Spring Boot 的 Gradle 插件文檔：
參考手冊（HTML 和 PDF）
API
啓動器
啓動器是一組方便的依賴關係描述符，您可以在應用程序中包括這些描述符。您可以獲取爲所有 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 工件預留的。相反，第三方啓動器通常以項目的名稱開始。例如，一個名爲 thirdpartyproject 的第三方啓動項目通常會被命名爲 thirdpartyproject-spring-boot-starter。
下面列舉的應用程序啓動器，由 Spring Boot 提供，位於 org.springframework.boot group 下：
名稱
描述
Pom
spring-boot-starter
核心啓動器，保留自動配置支持、日誌和 YAML
Pom
spring-boot-starter-activemq
用於使用 Apache ActiveMQ 進行 JMS 消息傳遞
Pom
spring-boot-starter-amqp
用於使用 Spring AMQP 和 Rabbit MQ
Pom
spring-boot-starter-aop
用於使用 Spring AOP 和 AspectJ 進行面向切面編程
Pom
spring-boot-starter-artemis
用於使用 Apache Artemis 進行 JMS 消息傳遞
Pom
spring-boot-starter-batch
用於使用 Spring Batch
Pom
spring-boot-starter-cache
用於使用 Spring Framework 的緩存支持
Pom
spring-boot-starter-cloud-connectors
用於使用 Spring Cloud Connectors，它簡化了與雲平臺裏的服務的連接，如 Cloud Foundry 和 Heroku
Pom
spring-boot-starter-data-cassandra
用於使用 Cassandra 分佈式數據庫和 Spring Data Cassandra
Pom
spring-boot-starter-data-cassandra-reactive
用於使用 Cassandra 分佈式數據庫和 Spring Data Cassandra Reactive
Pom
spring-boot-starter-data-couchbase
用於使用 Couchbase 面向文檔型數據庫和 Spring Data Couchbase
Pom
spring-boot-starter-data-couchbase-reactive
用於使用 Couchbase 面向文檔型數據庫和 Spring Data Couchbase Reactive
Pom
spring-boot-starter-data-elasticsearch
用於使用 Elasticsearch 搜索分析引擎和 Spring Data Elasticsearch
Pom
spring-boot-starter-data-jpa
用於使用基於 Hibernate 的 Spring Data JPA
Pom
spring-boot-starter-data-ldap
用於使用 Spring Data LDAP
Pom
spring-boot-starter-data-mongodb
用於使用 MongoDB 面向文檔型數據庫和 Spring Data MongoDB
Pom
spring-boot-starter-data-mongodb-reactive
用於使用 MongoDB 面向文檔型數據庫和 Spring Data MongoDB Reactive
Pom
spring-boot-starter-data-neo4j
用於使用 Neo4j 圖形數據庫和 Spring Data Neo4j
Pom
spring-boot-starter-data-redis
用於使用 Redis 鍵值對數據存儲，以及 Spring Data Redis 和 Lettuce 客戶端
Pom
spring-boot-starter-data-redis-reactive
用於使用 Redis 鍵值對數據存儲，以及 Spring Data Redis reactive 和 Lettuce 客戶端
Pom
spring-boot-starter-data-rest
用於使用 Spring Data Rest 通過 REST 暴露 Spring Data 倉庫
Pom
spring-boot-starter-data-solr
用於使用 Apache Solr 搜索平臺以及 Spring Data Solr
Pom
spring-boot-starter-freemarker
用於使用 FreeMarker 視圖構建 MVC web 應用程序
Pom
spring-boot-starter-groovy-templates
用於使用 Groovy Templates 視圖構建 MVC web 應用程序
Pom
spring-boot-starter-hateoas
用於構建基於超媒體的 RESTful web 應用程序，使用 Spring MVC 和 Spring HATEOAS
Pom
spring-boot-starter-integration
用於使用 Spring Integration
Pom
spring-boot-starter-jdbc
用於使用 JDBC 以及 HikariCP 連接池
Pom
spring-boot-starter-jersey
用於構建 RESTful web 應用程序，使用 JAX-RS 和 Jersey。spring-boot-starter-web 的另一種選擇。
Pom
spring-boot-starter-jooq
用於使用 jOOQ 訪問 SQL 數據庫。spring-boot-starter-data-jpa 或 spring-boot-starter-jdbc 的另一種選擇。
Pom
spring-boot-starter-json
用於讀寫 json
Pom
spring-boot-starter-jta-atomikos
用於使用 Atomikos JTA 事務
Pom
spring-boot-starter-jta-bitronix
用於使用 Bitronix JTA 事務
Pom
spring-boot-starter-jta-narayana
用於使用 Narayana JTA 事務
Pom
spring-boot-starter-mail
用於使用 Java Mail 和 Spring Framework 的 email 發送支持
Pom
spring-boot-starter-mustache
用於使用 Mustache 視圖構建 web 應用程序
Pom
spring-boot-starter-quartz
用於使用 Quartz 調度程序
Pom
spring-boot-starter-security
用於使用 Spring Security
Pom
spring-boot-starter-test
用於測試 Spring Boot 應用程序，包括 JUnit、Hamcrest 和 Mockito 庫
Pom
spring-boot-starter-thymeleaf
用於使用 Thymeleaf 視圖構建 MVC web 應用程序
Pom
spring-boot-starter-validation
用於使用基於 Hibernate Validator 的 Java Bean 校驗程序
Pom
spring-boot-starter-web
用於構建 web，包括 RESTful 和使用 Spring MVC 的應用程序。使用 Tomcat 作爲默認內置容器
Pom
spring-boot-starter-web-services
用於使用 Spring Web Services
Pom
spring-boot-starter-webflux
用於構建 WebFlux 應用程序，使用 Spring Framework 的 Reactive Web 支持
Pom
spring-boot-starter-websocket
用於構建 WebSocket 應用程序，使用 Spring Framework 的 WebSocket 支持
Pom
除了應用程序啓動器之外，下面的啓動器還可以用於添加生產就緒特性：
名稱
描述
Pom
spring-boot-starter-actuator
用於使用 Spring Boot 的 Actuator 提供生產就緒特性，幫助您監視和管理應用程序
Pom
最後，Spring Boot 還包括以下啓動器，如果您想要排除或交換特定的技術方面，可以使用：
名稱
描述
Pom
spring-boot-starter-jetty
用於使用 Jetty 作爲內置 servlet 容器。spring-boot-starter-tomcat 的另一種選擇。
Pom
spring-boot-starter-log4j2
用於使用 Log4j2 記錄日誌。spring-boot-starter-logging 的另一種選擇。
Pom
spring-boot-starter-logging
用於logging 使用 Logback. Default logging starter
Pom
spring-boot-starter-reactor-netty
用於使用 Reactor Netty 作爲內置響應式 HTTP 服務器。
Pom
spring-boot-starter-tomcat
用於使用 Tomcat 作爲內置 servlet 容器。spring-boot-starter-web 使用的默認 servlet 容器啓動器。
Pom
spring-boot-starter-undertow
用於使用 Undertow 作爲內置 servlet 容器。spring-boot-starter-tomcat 的另一種選擇。
Pom
有關附加社區貢獻的啓動器列表，請參閱 Github 上的 spring-boot-starters 模塊中的自述文件。
組織你的代碼
Spring Boot 不需要任何特定的代碼佈局來工作。然而，有一些最佳實踐可以提供幫助。
使用“default”包
當一個類不包含包聲明時，它被認爲是在“default 包”中。使用“default 包”通常是不鼓勵的，應該避免使用。它可能會導致使用 @ComponentScan、@EntityScan 或 @SpringBootApplication 註解的 Spring Boot 應用程序的特定問題，因爲每個 jar 的每個類都被讀取。
我們建議您遵循 Java 推薦的包命名約定，並使用一個反向的域名（例如，com.example.project）。
定位主應用程序類
我們通常建議您在其他類之上的根包中定位主應用程序類。@SpringBootApplication 註解通常放在主類上，它隱式地爲某些項定義了一個基本的“搜索包”。例如，如果您正在編寫一個 JPA 應用程序，則使用 @SpringBootApplication 註解類的包來搜索 @Entity 項。使用根包也允許組件掃描只應用於您的項目。
如果您不想使用 @SpringBootApplication，那麼 @EnableAutoConfiguration 和 @ComponentScan 註解將定義該行爲，因此您也可以使用它。
下面的清單展示了一個典型的佈局：
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，如下所示：
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 的配置。雖然可以使用 XML 源碼的 SpringApplication，但是我們通常建議您的主源是一個 @Configuration 類。通常，定義主方法的類是一個很好的候選者，作爲主要的 @Configuration。
許多 Spring 配置示例已經在 Internet 上發佈，它們使用 XML 配置。如果可能，始終嘗試使用等效的基於 Java 的配置。搜索 Enable* 註解可能是一個很好的起點。
導入附加的配置類
你不需要把你所有的 @Configuration 放入單一的類中。@Import 註解可用來導入附加的配置類。替代地，你可以使用 @ComponentScan 自動拾取所有的 Spring 組件，包括 @Configuration 類。
導入 XML 配置
如果你必須使用基於 XML 的配置，我們推薦你仍然從 @Configuration 類開始。你可以使用 @ImportResource 註解加載 XML 配置文件。
自動配置
Spring Boot 自動配置嘗試根據您添加的 jar 依賴項自動配置 Spring 應用程序。例如，如果 HSQLDB 在您的類路徑上，並且您沒有手動配置任何數據庫連接 bean，那麼 Spring Boot 將自動配置內存數據庫。
通過將 @EnableAutoConfiguration 或 @SpringBootApplication 註解添加到您的一個 @Configuration 類中，您需要選擇加入到自動配置（原文：You need to opt-in to auto-configuration）。
您應該只添加一個 @SpringBootApplication 或 @EnableAutoConfiguration 註解。我們通常建議只在主 @Configuration 類中添加其中一個。
逐步取代自動配置
自動配置是非侵入性的。在任何時候，您都可以開始定義自己的配置來替換自動配置的特定部分。例如，如果您添加了自己的 DataSource bean，默認的嵌入式數據庫支持就會被取代。
如果您需要了解當前正在應用的自動配置，以及爲什麼。使用 --debug 開關啓動應用程序。這樣做可以爲一些核心日誌記錄器開始調試日誌，並將條件報告記錄到控制檯。
禁用特定的自動配置類
如果你發現你不想應用的特定自動配置類，你可以使用 @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 property 來控制需要排除的自動配置類的列表。
你可以同時使用註解級別和 property 定義排除項。
Spring Bean 和依賴注入
您可以自由使用任何標準 Spring 框架技術來定義 bean 及其注入的依賴項。爲了簡單起見，我們經常發現使用 @ComponentScan（找到您的 bean）和使用 @Autowired（進行構造函數注入）工作得很好。
如果按照上面建議的方式構造代碼（在根包中定位應用程序類），可以不帶任何參數添加 @ComponentScan。所有應用程序組件（@Component、@Service、@Repository、@Controller 等）都自動註冊爲 Spring bean。
下面的示例顯示了使用構造函數注入來獲得所需的 RiskAssessor Bean 的 @Service 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，表示它不能在之後被修改。
使用 @SpringBootApplication 註解
許多 Spring Boot 開發者喜歡在他們的應用中使用自動配置、組件掃描，並且能夠在他們的“application class”上定義額外配置。單個 @SpringBootApplication 註解即可以用來開啓上述三個特性，即：
@EnableAutoConfiguration：開啓 Spring Boot 的自動配置機制
@ComponentScan：在應用程序的包上開啓 @Component 掃描（查看最佳實踐）
@Configuration：允許在上下文註冊額外的 bean，或者導入額外的配置類
@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 的屬性。
這些特性都不是強制性的，您可以選擇用它支持的任何特性來替換這個註解。例如，您可能不想在應用程序中使用組件掃描：
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);
}
}
在本例中，應用程序和其他 Spring Boot 應用程序一樣，只是沒有自動檢測到 @Component 註解的類，而用戶定義的 bean 是顯式導入的（參見 @Import）。
運行你的應用程序
將您的應用程序打包爲 jar 並使用嵌入式 HTTP 服務器的最大優點之一是，您可以像對待其他應用程序一樣運行應用程序。調試 Spring Boot 應用程序也很簡單。您不需要任何特殊的 IDE 插件或擴展。
本節只討論基於 jar 的打包。如果您選擇將應用程序打包爲 war 文件，則應該參考服務器和 IDE 文檔。
從 IDE 運行
您可以從 IDE 運行 Spring Boot 應用程序，作爲簡單的 Java 應用程序。但是，您首先需要導入您的項目。導入步驟取決於您的 IDE 和構建系統。大多數 IDE 可以直接導入 Maven 項目。例如，Eclipse 用戶可以選擇 File 菜單的 Import… → Existing Maven Projects。
如果不能直接將項目導入到 IDE 中，那麼可以使用構建插件生成 IDE 元數據。Maven 包含 Eclipse 和 IDEA 的插件。Gradle 提供各種 IDE 的插件。
如果您不小心運行了兩次 web 應用程序，您會看到一個“Port already in use”錯誤。STS 用戶可以使用 Relaunch 按鈕而不是 Run 按鈕來確保任何現有實例都已關閉。
作爲打包應用程序運行
如果您使用 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
使用 Maven 插件
Spring Boot Maven 插件包含一個 run 目標，可以用來快速編譯和啓動你的應用程序。應用程序以展開的方式運行，正如它們在你的 IDE 中所做的那樣。下面的示例顯示一個典型的 Maven 命令來運行 Spring Boot 應用程序：
$ mvn spring-boot:run
您可能還希望使用 MAVEN_OPTS 操作系統環境變量，如下例所示：
$ export MAVEN_OPTS=-Xmx1024m
使用 Gradle 插件
Spring Boot Gradle 插件還包括一個 bootRun 任務，它可以用來以一個展開的形式運行您的應用程序。當您應用 org.springframework.boot 和 java 插件時，將添加 bootRun 任務。如下例所示：
$ gradle bootRun
您可能還想使用 JAVA_OPTS 操作系統環境變量，如下例所示：
$ export JAVA_OPTS=-Xmx1024m
熱交換
由於 Spring Boot 應用程序只是普通的 Java 應用程序，所以 JVM 熱交換應該可以開箱即用。JVM 熱交換在一定程度上限制了它可以替換的字節碼。對於更完整的解決方案，可以使用 JRebel。
spring-boot-devtools 模塊還包括對快速應用程序重啓的支持。查看本章後面的開發者工具部分和如何做熱交換獲取詳細信息。
開發者工具
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 啓動的，或者是從一個特殊的類加載器開始的，那麼它就被認爲是一個“生產應用程序”。在 Maven 中將依賴項標記爲 optional 或 在 Gradle 使用 compileOnly 中是一種最佳實踐，它可以防止 devtools 被傳遞到其他使用您的項目的模塊中。
默認情況下，重新打包的存檔不包含 devtools。如果您想要使用某個遠程 devtools 特性，您需要禁用 excludeDevtools 構建屬性來包含它。該屬性同時支持 Maven 和 Gradle 插件。
屬性默認值
Spring Boot 所支持的幾個庫都使用緩存來提高性能。例如，模板引擎緩存已編譯的模板以避免重複解析模板文件。另外，Spring MVC 可以在服務靜態資源時添加 HTTP 緩存頭信息。
雖然緩存在生產中非常有益，但在開發過程中可能會產生相反的效果，使您無法看到您在應用程序中所做的更改。出於這個原因，spring-boot-devtools 在默認情況下禁用了緩存選項。
緩存選項通常在你的 application.properties 文件中配置。例如，Thymeleaf 提供了 spring.thymeleaf.cache 屬性。spring-boot-devtools 模塊不需要手動設置這些屬性，而是自動應用合理的開發時配置。
有關 devtools 應用的屬性的完整列表，請參見 DevToolsPropertyDefaultsPostProcessor。
自動重啓
使用 spring-boot-devtools 的應用程序在類路徑更改時自動重新啓動。當在 IDE 中工作時，這可能是一個有用的特性，因爲它爲代碼更改提供了非常快速的反饋循環。默認情況下，指向一個文件夾的類路徑上的任何條目都會被監控以進行更改。請注意，某些資源（如靜態資產和視圖模板）不需要重新啓動應用程序。
觸發重啓
當 DevTools 監視類路徑資源時，觸發重啓的惟一方法是更新類路徑。您導致要更新的類路徑的方式取決於您使用的 IDE。在 Eclipse 中，保存修改後的文件會導致類路徑被更新並觸發重新啓動。在 IntelliJ IDEA 中，構建項目（Build -> Build Project）具有相同的效果。
只要啓用了 forking，您就可以使用支持的構建插件（Maven 和 Gradle）來啓動應用程序，因爲 DevTools 需要一個獨立的應用程序類加載器才能正常運行。默認情況下，Gradle 和 Maven 在類路徑上檢測 DevTools 時是這樣做的。
當與 LiveReload 一起使用時，自動重啓非常有效。詳情請參閱 LiveReload 一節。如果您使用 JRebel，自動重新啓動將被禁用，以支持動態類重載。其他 devtools 特性（如 LiveReload 和 property overrides）仍然可以使用。
DevTools 依賴於應用程序上下文的關閉鉤子在重新啓動時關閉它。如果您已經禁用了關閉鉤子（SpringApplication.setRegisterShutdownHook(false)），那麼它將無法正常工作。
當決定是否在類路徑上的條目發生更改時觸發重新啓動時，DevTools 會自動忽略名爲 spring-boot、spring-boot-devtools、spring-boot-autoconfigure、spring-boot-actuator 和 spring-boot-starter 的項目。
DevTools 需要自定義 ApplicationContext 所使用的 ResourceLoader。如果您的應用程序已經提供了一個，那麼它將被打包。不支持在 ApplicationContext 上直接覆蓋 getResource 方法。
重啓和重新加載
Spring Boot 提供的重啓技術使用兩個類加載器。不改變的類（例如，來自第三方 jar 的類）被加載到一個基類加載器中。正在積極開發的類被加載到重啓類加載器中。當應用程序重新啓動時，重啓類加載器將被丟棄，並創建一個新的類加載器。這種方法意味着應用程序重新啓動通常要比“冷啓動”快得多，因爲基類加載器已經可用並填充了。
如果您發現重新啓動對應用程序不夠快，或者遇到了類加載問題，那麼您可以考慮重新加載技術，例如從 ZeroTurnaround 轉向 JRebel。這些工作通過重寫類，使它們更適合重載。
記錄狀態評估的變化（Logging changes in condition evaluation）
默認情況下，每次應用程序重新啓動時，都會記錄顯示狀態評估增量的報告。報告顯示了在進行更改（如添加或刪除 bean 和設置配置屬性）時對應用程序的自動配置的更改。
若要禁用報告的日誌記錄，請設置以下屬性：
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 可以這樣設置：
spring.devtools.restart.exclude=static/**,public/**
如果你想要保留默認設置並添加額外的排除項，使用 spring.devtools.restart.additional-exclude 替代它。
觀察附加路徑
你可能希望當你對不在類路徑上的文件進行更改時，重新啓動或加載你的應用程序。要這樣，使用 spring.devtools.restart.additional-paths 屬性配置要觀察變化的附加路徑。您可以使用上面提到的 spring.devtools.restart.exclude 屬性來控制在附加路徑下的更改是否會觸發完全重啓或 live reload。
禁用重啓
如果您不想使用重啓功能，您可以使用 spring.devtools.restart.enabled 屬性禁用它。在大多數情況下，您可以在 application.properties 中設置此屬性（這樣做仍然初始化重啓類加載器，但它不觀察文件的更改）。
如果您需要完全禁用重新啓動支持（例如，因爲它不能與特定的庫一起工作），那麼您需要設置 spring.devtools.restart.enabled 系統屬性爲 false，然後調用 SpringApplication.run(…)，如下例所示：
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 屬性設置爲觸發器文件的路徑。
您可能想要設置 spring.devtools.restart.trigger-file 作爲全局設置，以便所有的項目都以相同的方式運行。
自定義重啓類加載器
如前所述，在“重啓和重新加載”部分中，重新啓動功能是通過使用兩個類加載器實現的。對於大多數應用程序來說，這種方法運行良好。然而，它有時會導致類加載問題。
默認情況下，IDE 中的任何開放項目都包含“重啓”類加載器，任何常規的 .jar 文件都裝載了“基礎”類加載器。如果您在一個多模塊項目中工作，而不是每個模塊都導入到您的 IDE 中，您可能需要定製一些東西。爲此，您可以創建一個 META-INF/spring-devtools.properties 文件。
spring-devtools.properties 文件可以包含以 restart.exclude 和 restart.include 爲前綴的屬性。include 元素是應該被拉到“重啓”類加載器中的項，而 exclude 元素則是應該被推入“基礎”類加載器的項。屬性的值是應用於類路徑的正則表達式模式，如下例所示：
restart.exclude.companycommonlibs=/mycorp-common-[\\w-]+\.jar
restart.include.projectcommon=/mycorp-myproj-[\\w-]+\.jar
所有屬性的鍵必須是唯一的。只有屬性以 restart.include. 或 restart.exclude. 開頭，它纔會被考慮。
所有類路徑的 META-INF/spring-devtools.properties 都會被加載。您可以在項目中或項目使用的庫中打包文件。
已知侷限性
通過使用標準 ObjectInputStream 來反序列化的對象，重新啓動功能不會很好地工作。如果需要反序列化數據，可能需要使用 Spring 的 ConfigurableObjectInputStream 和 Thread.currentThread().getcontextclassloader()。
不幸的是，一些第三方庫在不考慮上下文類加載器的情況下反序列化。如果您發現這樣的問題，您需要向原始作者請求修復。
LiveReload
spring-boot-devtools 模塊包含一個嵌入式的 LiveReload 服務器，當資源被更改時，它可以用來觸發瀏覽器刷新。LiveReload 瀏覽器擴展可以從 livereload.com 免費提供給 Chrome、Firefox 和 Safari。
如果您不想在應用程序運行時啓動 LiveReload 服務器，則可以設置 spring.devtools.livereload.enabled 屬性爲 false。
您一次只能運行一個 LiveReload 服務器。在啓動應用程序之前，確保沒有其他的 LiveReload 服務器在運行。如果您在 IDE 中啓動多個應用程序，那麼只有第一個應用程序得到了 LiveReload 的支持。
全局設置
您可以通過添加名爲 .spring-boot-devtools.properties 的文件到 $HOME 文件夾（注意文件名以“.”開頭）來配置全局 devtools 設置。添加到該文件的任何屬性都適用於使用 devtools 的機器上的所有 Spring Boot 應用程序。例如，要配置重新啓動以始終使用觸發器文件，您需要添加以下屬性：
~/.spring-boot-devtools.properties.
spring.devtools.reload.trigger-file=.reloadtrigger
遠程應用程序
Spring Boot 開發者工具並不侷限於本地開發。在遠程運行應用程序時，還可以使用幾個特性。遠程支持是可選的。要啓用它，您需要確保將 devtools 包含在重新打包的歸檔文件中，如下面的清單所示：
<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 屬性，如下示例所示：
spring.devtools.remote.secret=mysecret
在遠程應用程序上啓用 spring-boot-devtools 是一種安全風險。您不應該在生產部署上啓用支持。
遠程 devtools 支持分兩部分提供：一個服務器端端點接受連接，一個客戶端應用程序在 IDE 中運行。當 spring.devtools.remote.remote.secret 屬性被設置時，服務器組件自動啓用。客戶端組件必須手動啓動。
運行遠程客戶端應用程序
遠程客戶端應用程序被設計爲從 IDE 中運行。你需要運行 org.springframework.boot.devtools.RemoteSpringApplication，使用你鏈接的遠程項目相同的類路徑。應用程序的唯一必需參數是它連接的遠程 URL。
例如，如果您正在使用 Eclipse 或 STS，並且您有一個名爲 my-app 的項目，您已經部署到 Cloud Foundry，那麼您將執行以下操作：
選擇 Run 菜單的 Run Configurations…
創建一個新的 Java Application “launch configuration”
瀏覽 my-app 項目
使用 org.springframework.boot.devtools.RemoteSpringApplication 作爲主類
添加 https://myapp.cfapps.io 到 Program arguments（或者你的任何遠程 URL）
運行中的遠程客戶端可能類似於如下列表：
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ ___ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | | _ \___ _ __ ___| |_ ___ \ \ \ \
\\/ ___)| |_)| | | | | || (_| []::::::[] / -_) ' \/ _ \ _/ -_) ) ) ) )
' |____| .__|_| |_|_| |_\__, | |_|_\___|_|_|_\___/\__\___|/ / / /
=========|_|==============|___/===================================/_/_/_/
:: Spring Boot Remote :: 2.0.2.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.springframework.context.annotation.AnnotationConfigApplicationContext@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)
因爲遠程客戶端使用與實際應用程序相同的類路徑，它可以直接讀取實際應用程序屬性。這是 spring.devtools.remote.secret 屬性被讀取並傳遞給服務器進行身份驗證的方法。
使用 https:// 作爲連接協議總是明智的，這樣就可以加密傳輸並不能截獲密碼。
如果需要使用代理訪問遠程應用程序，配置 spring.devtools.remote.proxy.host 和 spring.devtools.remote.proxy.port 屬性。
遠程更新
遠程客戶端監控您的應用程序類路徑，以與本地重啓相同的方式進行更改。任何更新的資源都被推送到遠程應用程序，並且（如果需要的話）觸發重啓。如果您在一個使用不本地化的雲服務的特性上進行迭代，這將是很有幫助的。一般來說，遠程更新和重新啓動比完整的重建和部署週期要快得多。
只在遠程客戶端運行時監視文件。如果在啓動遠程客戶端之前更改一個文件，則不會將其推送到遠程服務器。
打包用於生產環境的應用程序
可執行 jar 可以用於生產部署。由於它們是自包含的，所以它們也非常適合基於雲的部署。
對於額外的“生產就緒”特性，如健康、審計和度量 REST 或 JMX 端點，考慮添加 spring-boot-actuator。查看 Spring Boot Actuator：生產就緒特性獲取詳細信息。
下一步該讀什麼
現在您應該瞭解如何使用 Spring Boot 和您應該遵循的一些最佳實踐。現在，您可以深入瞭解特定的 Spring Boot 特性，或者您可以跳過，閱讀 Spring Boot 的“生產就緒”方面的內容。
Spring Boot 特性
本節將深入介紹 Spring Boot 的詳細信息。在這裏，您可以瞭解您可能想要使用和定製的關鍵特性。如果您還沒有這樣做，您可能希望閱讀“入門”和“使用 Spring Boot”部分，這樣您就有了良好基礎。
SpringApplication
SpringApplication 類提供了一種方便的方法來引導從 main() 方法開始的 Spring 應用程序。在許多情況下，您可以委託給靜態 SpringApplication.run 方法，如下例所示：
public static void main(String[] args) {
SpringApplication.run(MySpringConfiguration.class, args);
}
當你的應用程序啓動時，你應該看到類似於如下輸出：
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: v2.0.2.RELEASE
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 日誌消息，包括一些相關的啓動細節，比如啓動應用程序的用戶。如果您需要一個除 INFO 之外的日誌級別，您可以設置它，如日誌級別。
啓動失敗
如果您的應用程序啓動失敗，註冊的 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 提供了大量的 FailureAnalyzer 實現，您可以添加自己的。
如果沒有故障分析器能夠處理異常，您仍然可以顯示完整的情況報告，以便更好地理解錯誤。要做到這一點，您需要啓用 debug 屬性或爲 org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener 啓用 DEBUG 日誌記錄。
例如，如果您正在使用 java -jar 運行您的應用程序，您可以使調試屬性如下：
$ java -jar myproject-0.0.1-SNAPSHOT.jar --debug
定製橫幅
可以通過向類路徑中添加 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.2.RELEASE。
${spring-boot.formatted-version}
你使用的 Spring Boot 版本，格式化顯示（被括號包裹，用 v 作前綴）。比如 (v2.0.2.RELEASE)。
${Ansi.NAME}（或 ${AnsiColor.NAME}, ${AnsiBackground.NAME}, ${AnsiStyle.NAME}）
其中 NAME 是 ANSI 轉義代碼的名稱。查看 AnsiPropertySource 獲取詳細信息。
${application.title}
你的應用程序的標題，如 MANIFEST.MF 中聲明的。比如 Implementation-Title: MyApp 打印爲 MyApp。
如果您想以編程的方式生成橫幅，則可以使用 SpringApplication.setBanner(…) 方法。使用 org.springframework.boot.Banner 接口並實現您自己的 printBanner() 方法。
你也可以使用 spring.main.banner-mode 屬性決定橫幅是否打印在 System.out（console） 上、發送到配置的日誌記錄器（log）、完全不產生（off）。
在以下名稱中，打印的橫幅被註冊爲一個單例 bean：springBootBanner。
YAML 映射 off 到 false，所以如果您想要禁用應用程序中的橫幅，請確保添加引號，如下例所示：
spring:
main:
banner-mode: "off"
定製 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。查看外部化配置以獲取詳細信息。
有關配置選項的完整列表，查看 SpringApplication Javadoc。
Fluent 風格構建器 API
如果您需要構建 ApplicationContext 層次結構（包含父/子關係的多個上下文），或者您更喜歡使用“fluent”構建器 API，那麼您可以使用 SpringApplicationBuilder。
SpringApplicationBuilder 允許您將多個方法調用鏈接在一起，幷包含讓您創建層次結構的 parent 和 child 方法，如下例所示：
new SpringApplicationBuilder()
.sources(Parent.class)
.child(Application.class)
.bannerMode(Banner.Mode.OFF)
.run(args);
在創建 ApplicationContext 層次結構時，有一些限制。例如，Web 組件必須包含在子上下文內，並且在父和子上下文環境中都使用相同的 Environment。請參閱 SpringApplicationBuilder Javadoc 瞭解詳細信息。
應用程序事件和監聽器
除了通常的 Spring Framework 事件（比如 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，當 Environment 被使用時，在上下文被創建之前被髮送。
ApplicationPreparedEvent，在刷新之前發送，但是在加載 bean 定義之後。
ApplicationStartedEvent，在調用上下文之後發送，但是在調用任何應用程序和命令行運行程序之前。
ApplicationReadyEvent，在調用任何應用程序和命令行運行程序後發送。它表明應用程序已經準備好服務請求。
ApplicationFailedEvent，如果啓動時出現異常，則發送。
您通常不需要使用應用程序事件，但是知道它們的存在是很方便的。在內部，Spring Boot 使用事件來處理各種任務。
使用 Spring Framework 的事件發佈機制發送應用程序事件。該機制的一部分確保在子環境中發佈給偵聽器的事件也會在任何祖先上下文中被髮布給偵聽器。因此，如果您的應用程序使用了 SpringApplication 實例的層次結構，那麼偵聽器可能會接收到相同類型的應用程序事件的多個實例。
爲了讓您的偵聽器區分事件的上下文和派生上下文的事件，它應該請求將其應用程序上下文注入，然後將注入的上下文與事件上下文進行比較。可以通過實現 ApplicationContextAware 或，如果偵聽器是 bean，通過使用 @Autowired 來注入上下文。
Web 環境
SpringApplication 試圖爲您創建合適的 ApplicationContext 類型。用於確定 WebEnvironmentType 的算法相當簡單：
如果 Spring MVC 存在，則使用 AnnotationConfigServletWebServerApplicationContext
如果 Spring MVC 不存在，Spring WebFlux 是存在的，那麼就使用一個 AnnotationConfigReactiveWebServerApplicationContext
否則，使用 AnnotationConfigApplicationContext
這意味着如果您使用 Spring MVC 和來自 Spring WebFlux 的新 WebClient 在相同的應用程序中，Spring MVC 將在默認情況下使用。您可以通過調用 setWebApplicationType(WebApplicationType) 來輕鬆覆蓋它。
還可以完全控制調用 setApplicationContextClass(…) 所使用的 ApplicationContext 類型。
在 JUnit 測試中使用 SpringApplication 時，通常需要調用 setWebApplicationType(WebApplicationType.NONE)。
訪問應用程序參數
如果您需要訪問傳遞到 SpringApplication.run(…) 的應用程序參數，您可以注入一個 org.springframework.boot.ApplicationArguments bean。ApplicationArguments 接口提供了對原始 String[] 參數以及解析 option 和 non-option 參數的訪問，如下例所示：
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 Environment 中註冊一個 CommandLinePropertySource。這允許您使用 @Value 註解注入單個應用程序參數。
使用 ApplicationRunner 或 CommandLineRunner
如果您需要在 SpringApplication 啓動之後運行一些特定的代碼，您可以實現 ApplicationRunner 或 CommandLineRunner 接口。兩個接口都以相同的方式工作，並提供了一個單獨的運行方法，在 SpringApplication.run(…) 完成之前調用。
CommandLineRunner 接口提供對應用程序參數的訪問作爲一個簡單的字符串數組，而 ApplicationRunner 使用前面討論的 ApplicationArguments 接口。下面的示例展示了一個使用 run 方法的 CommandLineRunner：
import org.springframework.boot.*;
import org.springframework.stereotype.*;
@Component
public class MyBean implements CommandLineRunner {
public void run(String... args) {
// Do something...
}
}
如果定義了多個 CommandLineRunner 或 ApplicationRunner bean，必須以特定的順序調用它們，那麼您可以額外地實現 org.springframework.core.Ordered 接口或使用 org.springframework.core.annotation.Order 註解。
應用程序退出
每個 SpringApplication 都向 JVM 註冊一個關閉鉤子，以確保 ApplicationContext 在退出時優雅地關閉。可以使用所有標準的 Spring 生命週期回調函數（如 DisposableBean bean 接口或 @PreDestroy 註解）。
此外，bean 可以實現 org.springframework.boot.ExitCodeGenerator 接口，如果希望當 SpringApplication.exit() 被調用時，返回特定的退出代碼。然後可以將此退出代碼傳遞給 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() 方法提供的退出代碼。
管理員特性
通過指定 spring.application.admin.enabled 屬性，可以爲應用程序啓用與 admin 相關的特性。這將在平臺 MBeanServer 上公開 SpringApplicationAdminMXBean。您可以使用該特性遠程管理您的 Spring Boot 應用程序。這個特性還可以用於任何服務包裝器實現。
如果您想知道應用程序正在運行哪個 HTTP 端口，請使用 local.server.port 的鍵獲取該屬性。
謹慎
在啓用該特性時要注意，因爲 MBean 公開了關閉應用程序的方法。
外部化配置（Externalized Configuration）
Spring Boot 允許您外部化您的配置，這樣您就可以在不同的環境中使用相同的應用程序代碼。您可以使用 properties 文件、YAML 文件、環境變量和命令行參數來外部化配置。屬性值可以通過使用 @Value 註解直接注入到您的 bean 中，通過 Spring 的 Environment 抽象訪問，或者通過 @ConfigurationProperties 綁定到結構化對象。
Spring Boot 使用一種非常特殊的 PropertySource 命令，該命令旨在允許對值進行合理的覆蓋。屬性按以下順序考慮：
主目錄上的 Devtools 全局設置屬性（~/.spring-boot-devtools.properties，當 devtools 激活時）
測試上的 @TestPropertySource 註解
測試上的 @SpringBootTest#properties 註解
命令行參數
來自 SPRING_APPLICATION_JSON 的屬性（嵌入在環境變量或系統屬性中的內聯 JSON）
ServletConfig 初始化參數
ServletContext 初始化參數
來自 java:comp/env 的 JNDI 屬性
Java 系統屬性（System.getProperties()）
OS 環境變量
RandomValuePropertySource，只在 random.* 中的屬性
指定 Profile 的應用程序 properties，在打包好的 jar 之外（application-{profile}.properties 和 YAML variants）
指定 Profile 的應用程序 properties，打包在 jar 中（application-{profile}.properties 和 YAML variants）
應用程序屬性，在打包好的 jar 之外（application.properties 和 YAML variants）
應用程序屬性，打包在 jar 中（application.properties 和 YAML variants）
@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 文件，爲 name 提供一個合理的默認屬性值。在新環境中運行時，可以在您的 jar 之外提供 application.properties 文件，以覆蓋 name。對於一次性測試，您可以使用特定的命令行開關啓動（例如，java -jar app.jar --name="Spring"）。
SPRING_APPLICATION_JSON 屬性可以在命令行上提供環境變量。例如：你可以在 UN*X shell 中使用如下行：
$ SPRING_APPLICATION_JSON='{"acme":{"name":"test"}}' java -jar myapp.jar
在前面的示例中，您在 Spring Environment 中最終得到了 acme.name=test。您也可以提供 JSON 如 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。
配置隨機值
RandomValuePropertySource 用於注入隨機值（例如，在機密或測試用例中）。它可以生成 integer、long、uuid 或 string，如下面的示例所示：
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]}
random.int* 語法是 OPEN value (,max) CLOSE，其中 OPEN,CLOSE 爲任意字符、value,max 爲 integer。如果 max 被提供，value 便是最小值、max 便是最大值（不包含）。
訪問命令行屬性
在默認情況下，SpringApplication 會轉換任何命令行選項參數（也就是說，參數以 -- 開始，如 --server.port=9000）到一個屬性，並將它們添加到 Spring Environment 中。如前所述，命令行屬性總是優先於其他屬性源。
如果您不希望將命令行屬性添加到 Environment 中，您可以使用 SpringApplication.setAddCommandLineProperties(false) 禁用它們。
應用程序屬性文件
SpringApplication 從以下位置的 application.properties 文件加載屬性，並將它們添加到Spring Environment：
當前目錄的 /config 子目錄
當前目錄
類路徑的 /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 生成的名稱，包括特定於 profile 的文件名)。spring.config.location 中指定的文件是按原樣使用的，不支持特定於 profile 的變體，並且被任何特定於 profile 的屬性覆蓋。
配置位置按相反順序搜索。默認情況下，配置的位置是 classpath:/,classpath:/config/,file:./,file:./config/。由此產生的搜索順序如下：
file:./config/
file:./
classpath:/config/
classpath:/
當自定義配置位置使用 spring.config.location 配置時，它們替換默認的位置。例如，如果 spring.config.location 配置爲值：classpath:/custom-config/,file:./custom-config/，搜索順序如下：
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 中選擇的其他 basename）。這些默認值可以在運行時被定製的位置中放置的一個不同的文件重寫。
如果您使用環境變量而不是系統屬性，大多數操作系統都不允許使用句號分隔的鍵名，但是您可以使用下劃線（例如，SPRING_CONFIG_NAME 而不是 spring.config.name）。
如果應用程序在容器中運行，那麼可以使用 JNDI 屬性（在 java:comp/env 中）或 servlet 上下文初始化參數，而不是環境變量或系統屬性。
特定於 Profile 屬性
除了 application.properties 文件，特定於 profile 的屬性也可以通過使用以下命名約定來定義：application-{profile}.properties。Environment 中有一組默認 profile（默認情況下是 [default]），如果沒有設置激活的 profile，則使用默認 profile。換句話說，如果沒有顯式地激活 profile，那麼就會加載 application-default.properties。
特定於 profile 的屬性從相同的位置加載到標準 application.properties 中，特定於 profile的文件總是覆蓋非特定的文件，無論特定於 profile 的文件是否在您的打包 jar 內或外部。
如果指定了多個 profile，則應用最後的策略。例如，spring.profiles.active 屬性指定的 profile，在通過 SpringApplication API 配置後，被添加，因此優先。
如果您在 spring.config.location 中指定了任何文件，這些文件特定於 profile 的變體不會被考慮。如果您還想使用特定於 profile 的屬性，使用在 spring.config.location 中的目錄。
屬性中的佔位符
在 application.properties 中的值在使用時通過現有 Environment 進行過濾，因此您可以引用之前定義的值（例如，從系統屬性）。
app.name=MyApp
app.description=${app.name} is a Spring Boot application
您還可以使用此技術創建存在於 Spring Boot 屬性中的“短”變體。請參閱使用“短”命令行參數來獲取詳細信息。
使用 YAML 代替 Properties
YAML 是 JSON 的超集，因此，它是一種用於指定分層配置數據的方便格式。當您的類路徑上有 SnakeYAML 庫時，SpringApplication 類會自動支持 YAML 作爲屬性的替代品。
如果你使用“啓動器”，SnakeYAML 是由 spring-boot-starter 自動提供的。
加載 YAML
Spring 框架提供了兩個方便的類，可以用來加載 YAML 文檔。YamlPropertiesFactoryBean 將 YAML 加載爲 Properties，而 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 Boot 的 Binder 工具（這是 @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;
}
}
在 Spring Environment 中暴露 YAML 作爲 Properties
YamlPropertySourceLoader 類可以用於在 Spring Environment 中將 YAML 作爲 PropertySource 公開。這樣做可以讓您使用帶有佔位符語法的 @Value 註解來訪問 YAML 屬性。
多 profile 的 YAML 文檔
您可以使用 spring.profiles 鍵在單個文件中指定多個特定於 profile 的 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
在前面的示例中，如果 development profile 是激活的，則 server.address 屬性是 127.0.0.1。類似地，如果 production profile 是激活的，則 server.address 屬性是 192.168.1.120。如果未啓用 development 和 production profile，則該屬性的值爲 192.168.1.100。
如果在應用程序上下文啓動時沒有顯式激活，則會激活默認 profile。因此，在接下來的 YAML 中，我們爲 spring.security.user.password 設置了一個值，僅在 “default” profile 中可用：
server:
port: 8000
---
spring:
profiles: default
security:
user:
password: weak
然而，在下面的例子中，密碼總是被設置，因爲它沒有附加到任何 profile，而且必須在必要時顯式地重置所有其他 profile：
server:
port: 8000
spring:
security:
user:
password: weak
使用 spring.profiles 元素指定的 Spring profile 可以選擇性地使用 ! 字符否定。如果爲單個文檔指定了否定和非否定的 profile，那麼至少有一個非否定的 profile 必須匹配，並且沒有任何被否定的 profile 可能匹配。
YAML 缺陷
YAML 文件不能通過使用 @PropertySource 註解來加載。因此，在需要以這種方式加載值的情況下，需要使用 properties 文件。
類型安全的配置屬性
使用 @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，使用嵌套的“security”對象，其名稱由屬性的名稱決定。特別是，返回類型在那裏沒有使用，並且可能是 SecurityProperties
acme.security.password
acme.security.roles，String 集合
getter 和 setter 通常是強制的，因爲綁定是通過標準的 Java bean 屬性描述符，就像在 Spring MVC 中一樣。在下列情況下，可以省略 setter：
Map，只要它們被初始化，就需要一個 getter，但不一定需要 setter，因爲它們可以由綁定器進行更改。
可以通過索引（通常是 YAML）或使用單個逗號分隔值（屬性）來訪問集合和數組。在後一種情況下，setter 是強制的。我們建議總是爲這種類型添加一個 setter。如果您初始化一個集合，請確保它不是不可變的（就像前面的例子）。
如果嵌套的 POJO 屬性被初始化（比如前面示例中的 Security 字段），則不需要 setter。如果您希望綁定器使用它的默認構造函數來動態創建實例，那麼您需要一個 setter。
有些人使用項目 Lombok 自動添加 getter 和 setter。確保 Lombok 不會爲這種類型生成任何特定的構造函數，因爲它是由容器自動使用來實例化對象的。
最後，只考慮標準的 Java Bean 屬性，不支持對靜態屬性的綁定。
也可參考 @Value 和 @ConfigurationProperties 的區別。
您還需要列出在 @EnableConfigurationProperties 註解中註冊的屬性類，如下例所示：
@Configuration
@EnableConfigurationProperties(AcmeProperties.class)
public class MyConfiguration {
}
當 @ConfigurationProperties bean 以這種方式註冊時，bean 有一個常規名稱： <prefix>-<fqn>，其中 <prefix> 是 @ConfigurationProperties 註解中指定的環境鍵前綴，<fqn> 是 bean 的完全限定名稱。如果註解沒有提供任何前綴，則只使用 bean 的完全限定名。
上面示例中的 bean 名稱是 acme-com.example.AcmeProperties。
即使前面的配置爲 AcmeProperties 創建了一個常規 bean，我們建議 @ConfigurationProperties 只處理環境，特別是不從上下文注入其他 bean。已經說過，@EnableConfigurationProperties 註解也會自動地應用到您的項目中，這樣就可以從 Environment 中配置任何帶有 @ConfigurationProperties 的現有 bean。您可以通過確保 AcmeProperties 已經是一個 bean 來快捷地進行 MyConfiguration，如下面的示例所示：
@Component
@ConfigurationProperties(prefix="acme")
public class AcmeProperties {
// ... see the preceding example
}
這種類型的配置與 SpringApplication 外部 YAML 配置特別有效，如下例所示：
# application.yml
acme:
remote-address: 192.168.1.1
security:
username: admin
roles:
- USER
- ADMIN
# additional configuration as required
要使用 @ConfigurationProperties bean，您可以像其他 bean 一樣注入它們，如下例所示：
@Service
public class MyService {
private final AcmeProperties properties;
@Autowired
public MyService(AcmeProperties properties) {
this.properties = properties;
}
//...
@PostConstruct
public void openConnection() {
Server server = new Server(this.properties.getRemoteAddress());
// ...
}
}
使用 @ConfigurationProperties 還可以生成可以被 IDE 使用的 metadata 文件，爲您自己的鍵提供自動完成。詳見附錄 B 配置 Metadata。
第三方配置
除了使用 @ConfigurationProperties 來註解一個類之外，還可以在 public @Bean 方法上使用它。當您希望將屬性綁定到控件之外的第三方組件時，這樣做尤其有用。
要從 Environment 屬性配置 bean，請將 @ConfigurationProperties 添加到它的 bean 註冊，如下例所示：
@ConfigurationProperties(prefix = "another")
@Bean
public AnotherComponent anotherComponent() {
...
}
用 another 前綴定義的任何屬性都被映射到與前面的 AcmeProperties 示例類似的 AnotherComponent bean。
鬆散綁定
Spring Boot 使用一些鬆散的規則將 Environment 屬性綁定到 @ConfigurationProperties bean，因此 Environment 屬性名和 bean 屬性名之間不需要精確匹配。常見的示例中，這是有用的，其中包括短橫線分隔的環境屬性（例如，context-path 綁定到 contextPath），以及大寫的環境屬性（例如，PORT 綁定到 port）。
例如，考慮以下 @ConfigurationProperties 類：
@ConfigurationProperties(prefix="acme.my-project.person")
public class OwnerProperties {
private String firstName;
public String getFirstName() {
return this.firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
}
在前面的示例中，可以使用以下屬性名稱：
屬性
註釋
acme.my-project.person.first-name
Kebab 風格，推薦使用在 .properties 和 .yml 文件中
acme.myProject.person.firstName
標準駝峯語法
acme.my_project.person.first_name
下劃線符號，使用在 .properties 和 .yml 文件中的替代格式
ACME_MYPROJECT_PERSON_FIRSTNAME
大寫格式，推薦系統環境變量使用
註解的 prefix 必須是 kebab 風格（小寫字母、- 分隔，如 acme.my-project.person）。
屬性源
簡單的
List
Properties Files
Camel case、kebab case 或 underscore notation
Standard list syntax using [ ] or comma-separated values
YAML Files
Camel case、kebab case 或 underscore notation
Standard YAML list syntax or comma-separated values
Environment Variables
使用下劃線作爲定界符的大寫格式。_ 不應該在屬性名稱中使用
Numeric values surrounded by underscores, such as MY_ACME_1_OTHER = my.acme[1].other
System properties
Camel case、kebab case 或 underscore notation
Standard list syntax using [ ] or comma-separated values
85人點贊
後臺開發
Hsinwong
擁有3鑽 (約0.57元)
關注
"小禮物走一走，來簡書關注我"