Spring Boot中文文檔（官方文檔翻譯基於1.5.2.RELEASE）

時間 2019-11-15

標籤 spring boot 中文文檔官方翻譯基於 1.5.2.release release 欄目 Spring 简体版

原文原文鏈接

做者：Phillip Webb, Dave Syer, Josh Long, Stéphane Nicoll, Rob Winch, Andy Wilkinson, Marcel Overdijk, Christian Dupuis, Sébastien Deleuze, Michael Simonscss

翻譯：geekidentityhtml

持續更新： http://blog.geekidentity.com/spring/spring_boot_translation/java

1.5.2.RELEASEgit

轉自： http://blog.csdn.net/qq_36348557/article/details/69396589程序員

Part I. Spring Boot 文檔

本節簡要介紹了Spring Boot文檔，是整個文檔的參考指南。您能夠完整閱讀本參考指南，或者若是您不感興趣的話能夠跳過該部分。github

1. 關於文檔

Spring Boot參考指南能夠以 html，pdf 和 epub 文檔的形式獲取。最新版本的文檔可在 http://docs.spring.io/spring-boot/docs/current/reference 中找到。web

2. 得到幫助

若是使用 Spring Boot 時遇到問題，能夠在下面獲取幫助：
* 嘗試 How-to’s - 這裏爲最多見的問題提供解決方案。
* 瞭解Spring的基礎知識 - Spring Boot創建在許多其餘Spring項目上，請查看 spring.io 網站以獲取其餘項目的參考文檔。若是您剛剛開始使用Spring，請閱讀這個指南。
* 在stackoverflow上提問題 - 咱們會一塊兒關注 stackoverflow.com 上有spring-boot標籤的問題。
* 在Github上報告bug。redis

Spring Boot 全部的東西都是開源的，包括文檔！若是您發現文檔有問題; 或者若是你想改進他們，歡迎參與。算法

3. 第一步

若是你剛剛開始使用 Spring Boot，或剛剛開始使用「Spring」，請從這裏開始！
* 從頭開始：概述 | 要求 | 安裝
* 教程：Part 1 | Part 2
* 運行你的例子：Part 1 | Part 2

4. 使用 Spring Boot

構建系統: Maven | Gradle | Ant | Starters
最佳作法：代碼結構 | @Configuration | @EnableAutoConfiguration | Beans 和依賴注入
運行代碼：IDE | Packaged | Maven | Gradle
打包應用程序： Production jars
Spring Boot CLI：使用CLI

5. 瞭解Spring Boot功能

須要有關Spring Boots核心功能的更多細節？請看這裏

核心功能: SpringApplication | External Configuration | Profiles | Logging
Web 應用: MVC | Embedded Containers
數據處理: SQL | NO-SQL
消息處理: Overview | JMS
測試: Overview | Boot Applications | Utils
擴展: Auto-configuration | @Conditions

6. 轉移到生產環境

當您準備好將Spring Boot 應用程序放到生產環境時，咱們有一些您可能會喜歡的技巧！

部署 Spring Boot 應用程序: Cloud Deployment | OS Service
構建工具插件：Maven | Gradle
附錄: Application Properties | 自動配置類 | 可執行 Jars

Part II. 入門指南

若是你剛剛開始使用Spring Boot，這是你的一部份內容！在這裏咱們將會回答一些基本的what?」, 「how?」和「why?」的問題。在這裏你會找到一個詳細的介紹Spring Boot和安裝說明。而後，咱們將構建咱們的第一個Spring Boot應用程序，並討論一些核心原則。

8. Spring Boot 介紹

Spring Boot能夠基於Spring輕鬆建立能夠「運行」的、獨立的、生產級的應用程序。對Spring平臺和第三方類庫咱們有一個本身見解，因此你最開始的時候不要感到奇怪。大多數Spring Boot應用程序須要不多的Spring配置。

您可使用Spring Boot建立可使用java -jar或傳統 war 包部署啓動的Java應用程序。咱們還提供一個運行「spring腳本」的命令行工具。

咱們的主要目標是：
* 爲全部的Spring開發者提供一個更快，更普遍接受的入門體驗。
* Be opinionated out of the box, but get out of the way quickly as requirements start to diverge from the defaults.
* 提供大量項目中常見的一系列非功能特徵（例如嵌入式服務器，安全性，指標，運行情況檢查，外部化配置）。
* 絕對沒有代碼生成，也不須要XML配置。

9. 系統要求

默認狀況下，Spring Boot 1.5.2.RELEASE須要Java 7和Spring Framework 4.3.7.RELEASE或更高版本。您能夠進行一些其餘配置在Java 6上使用Spring Boot。有關詳細信息，請參見第84.11節「如何使用Java 6」。爲Maven（3.2+）和Gradle 2（2.9或更高版本）和3提供了顯式構建支持。

雖然您能夠在Java 6或7上使用 Spring Boot，但咱們一般推薦Java 8。

9.1 Servlet容器

如下嵌入式servlet容器能夠直接使用：

名稱	Servlet 版本	Java 版本
Tomcat 8	3.1	Java 7+
Tomcat 7	3.0	Java 6+
Jetty 9.3	3.1	Java 8+
Jetty 9.2	3.1	Java 7+
Jetty 8	3.0	Java 6+
Undertow 1.3	3.1	Java 7+

您還能夠將Spring Boot應用程序部署到任何兼容Servlet 3.0+ 的容器中。

10. 安裝 Spring Boot

Spring Boot能夠與「經典(classic)」Java開發工具一塊兒使用或做爲命令行工具安裝。不管如何，您將須要Java SDK v1.6或更高版本。在開始以前檢查當前的Java安裝：

$ java -version

若是您是Java開發的新手，或者您只想嘗試一下 Spring Boot，您可能須要首先嚐試使用 Spring Boot CLI，若是想正式使用Spring Boot，請閱讀「經典(classic)」安裝說明。

雖然Spring Boot 與Java 1.6兼容，但咱們建議使用最新版本的Java。

10.1 Java開發程序員安裝說明

Spring Boot的使用方式與標準Java庫的使用相同，只需在類路徑中包含適當的spring-boot-*.jar文件。Spring Boot不須要任何特殊的集成工具，因此可使用任何IDE或文本編輯器進行開發；而且Spring Boot 應用程序沒有什麼特殊的地方，所以您能夠像其餘Java程序同樣運行和調試。雖然您能夠直接複製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。

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>1.5.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)的替代解決方案。

10.1.2 Gradle 安裝

Spring Boot 兼容 Gradle 2（2.9或更高版本）和Gradle 3。若是您還沒有安裝Gradle，您能夠按照 http://www.gradle.org/ 上的說明進行操做。

可使用org.springframework.boot 組(group)聲明Spring Boot 的依賴項。一般，您的項目將聲明一個或多個「啓動器(Starters)」的依賴。Spring Boot提供了一個有用的Gradle插件，可用於簡化依賴關係聲明和建立可執行 jar包。

Gradle Wrapper

當您須要構建項目時，Gradle Wrapper提供了一種「獲取(obtaining)」Gradle的更好的方式。它是一個小腳本和庫，它與代碼一塊兒引導構建過程。有關詳細信息，請參閱 https://docs.gradle.org/2.14.1/userguide/gradle_wrapper.html 。

典型的 build.gradle 文件：

plugins {
    id 'org.springframework.boot' version '1.5.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") }

10.2 安裝Spring Boot CLI

Spring Boot CLI是一個命令行工具，若是要使用Spring快速原型(quickly prototype)，可使用它。它容許您運行Groovy腳本，這意味着會有您熟悉的相似Java的語法，沒有太多的樣板代碼(boilerplate code)。

您也沒必要要經過CLI來使用Spring Boot，但它絕對是開始Spring應用程序最快方法。

10.2.1 手動安裝

您能夠從Spring軟件版本庫下載Spring CLI發行版：

各發布版本的快照。

下載完成後，請按照解壓縮後文件中的INSTALL.txt的說明進行操做。總而言之：在.zip文件的bin/目錄中有一個spring腳本（Windows的spring.bat），或者你可使用java -jar（腳本能夠幫助您確保類路徑設置正確）。

10.2.2 使用SDKMAN!安裝

SDKMAN!（軟件開發套件管理器）可用於管理各類二進制SDK的多個版本，包括Groovy和Spring Boot CLI。從http://sdkman.io/獲取SDKMAN！並安裝Spring Boot。

$ sdk install springboot $ spring --version Spring Boot v1.5.2.RELEASE

若是您正在開發CLI的功能，並但願輕鬆訪問剛建立的版本，請遵循如下額外說明。

$ sdk install springboot dev /path/to/spring-boot/spring-boot-cli/target/spring-boot-cli-1.5.2.RELEASE-bin/spring-1.5.2.RELEASE/ $ sdk default springboot dev $ spring --version Spring CLI v1.5.2.RELEASE

這將安裝一個稱爲dev的spring的本地實例(instance)。它指向您構建位置的target，因此每次重建(rebuild)Spring Boot時，Spring 將是最新的。

你能夠看到：

$ sdk ls springboot

================================================================================
Available Springboot Versions
================================================================================
> + dev
* 1.5.2.RELEASE ================================================================================ + - local version * - installed > - currently in use ================================================================================

10.2.3 OSX Homebrew 安裝

若是您在Mac上使用 Homebrew，安裝Spring Boot CLI 只須要下面命令：

$ brew tap pivotal/tap $ brew install springboot

Homebrew會將Spring 安裝到 /usr/local/bin。

若是您沒有看到公式(formula)，您的安裝可能會過時。只需執行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

由於下載依賴的庫，首次運行應用程序須要一些時間，。後續運行將會更快。

在瀏覽器中打開 http://localhost:8080 ，您應該會看到如下輸出：

Hello World!

10.3 從早期版本的Spring Boot升級

若是您從早期版本的 Spring Boot 升級，請檢查項目wiki上託管的「發行說明」。您將找到升級說明以及每一個版本的「新的和值得注意的」功能的列表。

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

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

讓咱們在Java中開發一個簡單的「Hello World！」Web應用程序，突顯Spring Boot一些主要的功能。咱們將使用Maven構建該項目，由於大多數IDE支持它。

https://spring.io/ 包含許多使用Spring Boot的「入門指南」。若是您正在尋求解決一些具體問題; 能夠先看一下那裏。

您能夠在 https://start.spring.io/ 的依賴關係搜索器中選擇Web啓動器來快速完成如下步驟。
這會自動生成一個新的項目結構，方便您當即開始編碼。查看文檔瞭解更多詳細信息。

在開始以前，打開終端來檢查您是否安裝了有效的Java和Maven版本。

$ java -version java version "1.7.0_51" Java(TM) SE Runtime Environment (build 1.7.0_51-b13) Java HotSpot(TM) 64-Bit Server VM (build 24.51-b03, mixed mode) $ mvn -v Apache Maven 3.2.3 (33f8c3e1027c3ddde99d3cdebad2656a31e8fdf4; 2014-08-11T13:58:10-07:00) Maven home: /Users/user/tools/apache-maven-3.1.1 Java version: 1.7.0_51, vendor: Oracle Corporation

這個示例須要在其本身的文件夾中建立。後面咱們假設您在當前目錄已經建立了一個正確的文件夾。

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>1.5.2.RELEASE</version> </parent> <!-- Additional lines to be added here... --> </project>

這應該給你一個工做構建(working build)，你能夠經過運行 mvn package 進行測試（你能夠暫時忽略警告：「jar will be empty - no content was marked for inclusion!」）。

如今，您能夠將項目導入到IDE中（最新的Java IDE內置對Maven的支持）。爲了簡單起見，這個示例咱們繼續使用純文本編輯器。

11.2 添加類路徑依賴關係

Spring Boot提供了一些「啓動器(Starters)」，能夠方便地將jar添加到類路徑中。咱們的示例應用程序已經在POM的父部分使用了spring-boot-starter-parent。spring-boot-starter-parent是一個特殊啓動器，提供一些Maven的默認值。它還提供依賴管理 dependency-management 標籤，以便您能夠省略子模塊依賴關係的版本標籤。

其餘「啓動器(Starters)」只是提供您在開發特定類型的應用程序時可能須要的依賴關係。因爲咱們正在開發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並在 parent 下添加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.stereotype.*; 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 annotation。它爲人們閱讀代碼提供了一些提示，對於Spring來講，這個類具備特定的做用。在這裏，咱們的類是一個web @Controller，因此Spring在處理傳入的Web請求時會考慮這個類。

@RequestMapping註解提供「路由」信息。告訴Spring，任何具備路徑「/」的HTTP請求都應映射到home方法。 @RestController註解告訴Spring將生成的字符串直接返回給調用者。

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

11.3.2 @EnableAutoConfiguration註解

第二個類級別的註釋是@EnableAutoConfiguration。這個註解告訴 Spring Boot 根據您添加的jar依賴關係來「猜(guess)」你將如何配置Spring。因爲spring-boot-starter-web添加了Tomcat和Spring MVC，自動配置將假定您正在開發Web應用程序並相應地配置Spring。

啓動器和自動配置

自動配置旨在與「起動器」配合使用，但兩個概念並不直接相關。您能夠自由選擇啓動器以外的jar依賴項，Spring Boot仍然會自動配置您的應用程序。

11.3.3 「main」方法

咱們的應用程序的最後一部分是main()方法。這只是一個遵循Java慣例的應用程序入口點的標準方法。咱們的main()方法經過調用run()委託(delegates)給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.2.RELEASE) ....... . . . ....... . . . (log output here) ....... . . . ........ Started Example in 2.222 seconds (JVM running for 6.514)

若是你用瀏覽器打開 http://localhost:8080 你應該看到如下輸出：

Hello World!

ctrl-c 正常(gracefully)退出應用程序。

11.5 建立可執行的jar

讓咱們完成咱們的例子，建立一個徹底自包含的可執行jar文件，咱們能夠在生產環境中運行。可執行的jar（有時稱爲「fat jars」）是包含編譯的類以及代碼運行所須要的全部jar包依賴的歸檔(archives)。

可執行jar和Java

Java不提供任何標準的方法來加載嵌套的jar文件（即自己包含在jar中的jar文件）。若是您正在尋找能夠發佈自包含的應用程序，這多是有問題的。
爲了解決這個問題，許多開發人員使用「uber」 jars。一個uber jar簡單地將全部類、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標籤配置。若是您不使用該父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:1.5.2.RELEASE:repackage (default) @ myproject --- [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------

若是你看看target目錄，你應該看到myproject-0.0.1-SNAPSHOT.jar。該文件的大小約爲10 MB。若是你想查看裏面，可使用jar tvf：

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

您還應該在target目錄中看到一個名爲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.2.RELEASE) ....... . . . ....... . . . (log output here) ....... . . . ........ Started Example in 2.536 seconds (JVM running for 2.864)

像以前同樣，ctrl+c正常退出應用程序。

12. 接下來應該讀什麼

但願本節能爲您提供一些Spring Boot基礎知識，並讓您準備編寫本身的應用程序。若是你是一個面向具體任務的開發人員，你可能想跳過 https://spring.io/ ，看看一些解決具體的「如何用Spring」問題的入門指南; 咱們還有Spring Boot-specific How-to參考文檔。

Spring Boot庫還有一大堆能夠運行的示例。示例與代碼的其他部分是獨立的（這樣您不須要構建多餘的代碼來運行或使用示例）。

下一個是第三部分「使用 Spring Boot」。若是你真的沒有這個耐心，也能夠跳過去閱讀Spring Boot功能。

Part III. 使用 Spring Boot

本部分將詳細介紹如何使用Spring Boot。這部分涵蓋諸如構建系統，自動配置以及如何運行應用程序等主題。咱們還介紹了一些Spring Boot的最佳實踐(best practices)。雖然Spring Boot沒有什麼特殊之處（它只是一個可使用的庫），可是有一些建議可讓您的開發過程更容易一些。

若是您剛剛開始使用Spring Boot，那麼在深刻本部分以前，您應該閱讀入門指南。

13. 構建系統

強烈建議您選擇一個支持依賴管理並可使用「Maven Central」存儲庫的構建系統。咱們建議您選擇Maven或Gradle。 Spring Boot 能夠與其餘構建系統（例如 Ant ）配合使用，可是它們不會獲得很好的支持。

13.1 依賴管理

每一個版本的Spring Boot提供了一個它所支持的依賴關係列表。實際上，您不須要爲構建配置文件中的這些依賴關係提供版本，由於Spring Boot會爲您進行管理這些依賴的版本。當您升級Spring Boot自己時，這些依賴關係也將以一致的進行升級。

若是您以爲有必要，您仍然能夠指定一個版本並覆蓋Spring Boot建議的版本。

管理的列表中包含可使用Spring Boot的全部Spring模塊以及第三方庫的精簡列表。該列表可做爲標準的物料(Materials)清單（spring-boot-dependencies）使用，而且還提供了對 Maven 和 Gradle 的額外支持。

Spring Boot的每一個版本與Spring Framework的基本版本相關聯，所以咱們強烈建議您不要本身指定其版本。

13.2 Maven

Maven用戶能夠從 spring-boot-starter-parent-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 繼承啓動器parent

要將項目配置爲繼承spring-boot-starter-parent，只需設置標籤以下：

<!-- Inherit defaults from Spring Boot --> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.2.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依賴來保持依賴管理（但不能進行插件管理）的好處：

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

該設置不容許您使用如13.2.1 所述的屬性來覆蓋單個依賴關係。要實現相同的結果，您須要在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.2.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啓動器 parent pom，則只須要添加這個插件，除非您要更改parent中定義的設置，不然不須要進行配置。

13.3 Gradle

Gradle用戶能夠直接在其依賴關係部分導入「啓動器」。不像Maven，沒有「超級父」導入來共享一些配置。

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

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

plugins {
    id 'org.springframework.boot' version '1.5.2.RELEASE' id 'java' } repositories { jcenter() } dependencies { compile("org.springframework.boot:spring-boot-starter-web") testCompile("org.springframework.boot:spring-boot-starter-test") }

13.4 Ant

可使用Apache Ant + Ivy構建Spring Boot項目。 spring-boot-antlib「AntLib」模塊也可用於幫助Ant建立可執行文件。

要聲明依賴關係，典型的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.3.0.BUILD-SNAPSHOT" /> <target name="resolve" description="--> retrieve dependencies with ivy"> <ivy:retrieve pattern="lib/[conf]/[artifact]-[type]-[revision].[ext]" /> </target> <target name="classpaths" depends="resolve"> <path id="compile.classpath"> <fileset dir="lib/compile" includes="*.jar" /> </path> </target> <target name="init" depends="classpaths"> <mkdir dir="build/classes" /> </target> <target name="compile" depends="init" description="compile"> <javac srcdir="src/main/java" destdir="build/classes" classpathref="compile.classpath" /> </target> <target name="build" depends="compile"> <spring-boot:exejar destfile="build/myapp.jar" classes="build/classes"> <spring-boot:lib> <fileset dir="lib/runtime" /> </spring-boot:lib> </spring-boot:exejar> </target> </project>

請參見第84.10節「從Ant構建可執行存檔，而不使用spring-boot-antlib」若是不想使用spring-boot-antlib模塊，請參閱「操做方法」。

13.5 啓動器

啓動器是一組方便的依賴關係描述符，能夠包含在應用程序中。您能夠得到所需的全部Spring和相關技術的一站式服務，無需經過示例代碼搜索和複製粘貼依賴配置。例如，若是要開始使用Spring和JPA進行數據庫訪問，那麼只需在項目中包含spring-boot-starter-data-jpa依賴關係便可。

啓動器包含許多依賴關係，包括您須要使項目快速啓動並運行，並具備一致的受支持的依賴傳遞關係。

What’s in a name

全部正式起動器都遵循相似的命名模式： spring-boot-starter- * ，其中 * 是特定類型的應用程序。這個命名結構旨在幫助你快速找到一個啓動器。許多IDE中的Maven插件容許您按名稱搜索依賴項。例如，安裝Eclipse或STS的Maven插件後，您能夠簡單地在POM編輯器中點擊 Dependency Hierarchy，並在filter輸入「spring-boot-starter」來獲取完整的列表。
如建立本身的啓動器部分所述，第三方啓動程序不該該從Spring-boot開始，由於它是爲正式的Spring Boot artifacts 保留的。 acme 的第三方啓動器一般被命名爲acme-spring-boot-starter。

Spring Boot在org.springframework.boot組下提供瞭如下應用程序啓動器：

表13.1. Spring Boot應用程序啓動器

名稱	描述	Pom
spring-boot-starter-thymeleaf	使用Thymeleaf視圖構建MVC Web應用程序的啓動器	Pom
spring-boot-starter-data-couchbase	使用Couchbase面向文檔的數據庫和Spring Data Couchbase的啓動器	Pom
spring-boot-starter-artemis	使用Apache Artemis的JMS啓動器	Pom
spring-boot-starter-web-services	Spring Web Services 啓動器	Pom
spring-boot-starter-mail	Java Mail和Spring Framework的電子郵件發送支持的啓動器	Pom
spring-boot-starter-data-redis	Redis key-value 數據存儲與Spring Data Redis和Jedis客戶端啓動器	Pom
spring-boot-starter-web	使用Spring MVC構建Web，包括RESTful應用程序。使用Tomcat做爲默認的嵌入式容器的啓動器	Pom
spring-boot-starter-data-gemfire	使用GemFire分佈式數據存儲和Spring Data GemFire的啓動器	Pom
spring-boot-starter-activemq	使用Apache ActiveMQ的JMS啓動器	Pom
spring-boot-starter-data-elasticsearch	使用Elasticsearch搜索和分析引擎和Spring Data Elasticsearch的啓動器	Pom
spring-boot-starter-integration	Spring Integration 啓動器	Pom
spring-boot-starter-test	使用JUnit，Hamcrest和Mockito的庫測試Spring Boot應用程序的啓動器	Pom
spring-boot-starter-jdbc	使用JDBC與Tomcat JDBC鏈接池的啓動器	Pom
spring-boot-starter-mobile	使用Spring Mobile構建Web應用程序的啓動器	Pom
spring-boot-starter-validation	使用Java Bean Validation 與Hibernate Validator的啓動器	Pom
spring-boot-starter-hateoas	使用Spring MVC和Spring HATEOAS構建基於超媒體的RESTful Web應用程序的啓動器	Pom
spring-boot-starter-jersey	使用JAX-RS和Jersey構建RESTful Web應用程序的啓動器。spring-boot-starter-web的替代方案	Pom
spring-boot-starter-data-neo4j	使用Neo4j圖數據庫和Spring Data Neo4j的啓動器	Pom
spring-boot-starter-data-ldap	使用Spring Data LDAP的啓動器	Pom
spring-boot-starter-websocket	使用Spring Framework的WebSocket支持構建WebSocket應用程序的啓動器	Pom
spring-boot-starter-aop	使用Spring AOP和AspectJ進行面向切面編程的啓動器	Pom
spring-boot-starter-amqp	使用Spring AMQP和Rabbit MQ的啓動器	Pom
spring-boot-starter-data-cassandra	使用Cassandra分佈式數據庫和Spring Data Cassandra的啓動器	Pom
spring-boot-starter-social-facebook	使用Spring Social Facebook 的啓動器	Pom
spring-boot-starter-jta-atomikos	使用Atomikos的JTA事務的啓動器	Pom
spring-boot-starter-security	使用Spring Security的啓動器	Pom
spring-boot-starter-mustache	使用Mustache視圖構建MVC Web應用程序的啓動器	Pom
spring-boot-starter-data-jpa	使用Spring數據JPA與Hibernate的啓動器	Pom
spring-boot-starter	核心啓動器，包括自動配置支持，日誌記錄和YAML	Pom
spring-boot-starter-groovy-templates	使用Groovy模板視圖構建MVC Web應用程序的啓動器	Pom
spring-boot-starter-freemarker	使用FreeMarker視圖構建MVC Web應用程序的啓動器	Pom
spring-boot-starter-batch	使用Spring Batch的啓動器	Pom
spring-boot-starter-social-linkedin	使用Spring Social LinkedIn的啓動器	Pom
spring-boot-starter-cache	使用Spring Framework緩存支持的啓動器	Pom
spring-boot-starter-data-solr	使用Apache Solr搜索平臺與Spring Data Solr的啓動器	Pom
spring-boot-starter-data-mongodb	使用MongoDB面向文檔的數據庫和Spring Data MongoDB的啓動器	Pom
spring-boot-starter-jooq	使用jOOQ訪問SQL數據庫的啓動器。 spring-boot-starter-data-jpa或spring-boot-starter-jdbc的替代方案	Pom
spring-boot-starter-jta-narayana	Spring Boot Narayana JTA 啓動器	Pom
spring-boot-starter-cloud-connectors	使用Spring Cloud鏈接器，簡化了與Cloud Foundry和Heroku等雲平臺中的服務鏈接的啓動器	Pom
spring-boot-starter-jta-bitronix	使用Bitronix進行JTA 事務的啓動器	Pom
spring-boot-starter-social-twitter	使用Spring Social Twitter的啓動器	Pom
spring-boot-starter-data-rest	經過使用Spring Data REST在REST上暴露Spring數據庫的啓動器	Pom

除了應用程序啓動器，如下啓動器可用於添加生產準備(production ready)功能：

表13.2 Spring Boot生產環境啓動器

名稱	描述	Pom
spring-boot-starter-actuator	使用Spring Boot Actuator提供生產準備功能，可幫助您監控和管理應用程序的啓動器	Pom
spring-boot-starter-remote-shell	使用CRaSH遠程shell經過SSH監視和管理您的應用程序的啓動器。自1.5以來已棄用	Pom

最後，Spring Boot還包括一些啓動器，若是要排除或替換特定的技術，可使用它們：

名稱	描述	Pom
spring-boot-starter-undertow	使用Undertow做爲嵌入式servlet容器的啓動器。 spring-boot-starter-tomcat的替代方案	Pom
spring-boot-starter-jetty	使用Jetty做爲嵌入式servlet容器的啓動器。 spring-boot-starter-tomcat的替代方案	Pom
spring-boot-starter-logging	使用Logback進行日誌記錄的啓動器。默認的日誌啓動器	Pom
spring-boot-starter-tomcat	使用Tomcat做爲嵌入式servlet容器的啓動器。 spring-boot-starter-web的默認servlet容器啓動器	Pom
spring-boot-starter-log4j2	使用Log4j2進行日誌記錄的啓動器。 spring-boot-start-logging的替代方法	Pom

有關社區貢獻的更多啓動器的列表，請參閱GitHub上的spring-boot-startters模塊中的README文件。

14. 構建代碼

Spring Boot不須要任何特定的代碼組織結構，可是有一些最佳實踐能夠幫助您。

14.1 不要使用「default」包

當類不包括包聲明時，它被認爲是在「默認包」中。一般不鼓勵使用「默認包」，並應該避免使用。對於使用@ComponentScan，@EntityScan或@SpringBootApplication註解的Spring Boot應用程序，可能會有一些特殊的問題，由於每一個jar的每一個類都將被讀取。

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

14.2 查找主應用程序類

咱們一般建議您將應用程序主類放到其餘類之上的根包(root package)中。 @EnableAutoConfiguration註解一般放置在您的主類上，它隱式定義了某些項目的基本「搜索包」。例如，若是您正在編寫JPA應用程序，則@EnableAutoConfiguration註解類的包將用於搜索@Entity項。

使用根包(root package)還可使用@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()，但咱們一般建議您的主source是@Configuration類。一般，定義main方法的類也是做爲主要的@Configuration一個很好的選擇。

許多使用XML配置的Spring示例已經在網上發佈。若是可能的話咱們建議始終嘗試使用等效的基於Java的配置。搜索 enable* 註解能夠是一個很好的起點。

15.1 導入其餘配置類

您不須要將全部的@Configuration放在一個類中。 @Import註解可用於導入其餘配置類。或者，您可使用@ComponentScan自動掃描全部Spring組件，包括@Configuration類。

15.2 導入XML配置

若是您必須使用基於XML的配置，咱們建議您仍然從@Configuration類開始。而後，您可使用的@ImportResource註釋來加載XML配置文件。

16. 自動配置

Spring Boot 會根據您添加的jar依賴關係自動配置您的Spring應用程序。例如，若是HSQLDB在您的類路徑上，而且您沒有手動配置任何數據庫鏈接bean，那麼咱們將自動配置內存數據庫。

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

您應該只添加一個@EnableAutoConfiguration註解。咱們一般建議您將其添加到主@Configuration類中。

16.1逐漸取代自動配置

自動配置是非侵入式的，您能夠隨時定義本身的配置來替換自動配置。例如，若是您添加本身的 DataSource bean，則默認的嵌入式數據庫支持將會退回。

若是您須要瞭解當前有哪些自動配置，以及爲何，請使用–debug開關啓動應用程序。這將啓用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 { }

若是類不在classpath路徑上，則可使用註釋的excludeName屬性，並指定全限定名(fully qualified name)。最後，您還能夠經過spring.autoconfigure.exclude屬性控制要排除的自動配置類列表。

註解和使用屬性(property)定義均可以指定要排除的自動配置類。

17. Spring Beans 和依賴注入

您能夠自由使用任何標準的Spring Framework技術來定義您的bean及其依賴注入關係。爲了簡單起見，咱們發現使用@ComponentScan搜索bean，結合@Autowired構造函數(constructor)注入效果很好。

若是您按照上述建議（將應用程序類放在根包(root package)中）構建代碼，則可使用
@ComponentScan而不使用任何參數。全部應用程序組件（@Component，@Service，@Repository，@Controller等）將自動註冊爲Spring Bean。

如下是一個@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.myproject; 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應用程序，您將看到「Port already in use」中的錯誤。使用STS用戶可使用從新啓動按鈕而不是運行以確保任何現有實例已關閉。

19.2 做爲已打包應用程序運行

若是您使用Spring Boot 的 Maven或Gradle插件建立可執行jar，則可使用java -jar運行應用程序。例如：

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

也能夠啓用遠程調試支持運行打包的應用程序。這容許您將調試器添加到打包的應用程序中：

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

19.3 使用 Maven 插件

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

$ mvn spring-boot:run

您可能還須要使用一些有用的操做系統環境變量：

$ export MAVEN_OPTS=-Xmx1024m -XX:MaxPermSize=128M

19.4 使用Gradle插件

Spring Boot Gradlet插件還包括一個bootRun任務，可用於以exploded 形式運行應用程序。每當導入spring-boot-gradle-plugin時，都會添加bootRun任務：

$ gradle bootRun

您可能還想使用這個有用的操做系統環境變量：

$ export JAVA_OPTS=-Xmx1024m -XX:MaxPermSize=128M

19.5 熱插拔

因爲Spring Boot應用程序只是純Java應用程序，因此JVM熱插拔應該是開箱即用的。 JVM熱插拔在必定程度上受到可替代的字節碼的限制，更完整的解決方案，可使用 JRebel 或者 Spring Loaded 項目。 spring-boot-devtools模塊還支持快速從新啓動應用程序。

有關詳細信息，請參閱第20章「開發人員工具」部分和熱插拔「操做方法」。

20. 開發工具

Spring Boot包括一組額外的工具，可使應用程序開發體驗更加愉快。 spring-boot-devtools模塊能夠包含在任何項目中，以提供額外的開發時功能。要包含devtools支持，只需將模塊依賴關係添加到您的構建中：

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啓動的，或者是使用特殊的類加載器啓動，那麼它將會被認爲是「生產環境的應用程序」。將開發工具依賴關係標記爲可選(optional)是一種最佳作法，能夠防止使用項目將devtools傳遞性地應用於其餘模塊。 Gradle不支持開箱即用的可選依賴項，所以您可能但願在此期間查看propdeps-plugin。

從新打包的jar包默認狀況下不包含devtools。若是要使用某些遠程devtools功能，您須要禁用excludeDevtools 構建下的屬性以包含devtools。該屬性支持Maven和Gradle插件。

20.1 屬性默認值

Spring Boots支持的幾個庫使用緩存來提升性能。例如，模板引擎將緩存編譯的模板，以免重複解析模板文件。此外，Spring MVC能夠在返回靜態資源時向響應中添加HTTP緩存頭。

雖然緩存在生產中很是有益，但它在開發過程當中可能會產生反效果，從而阻止您看到剛剛在應用程序中進行的更改。所以，spring-boot-devtools將默認禁用這些緩存選項。

緩存選項一般由您的application.properties文件中的設置配置。例如，Thymeleaf提供了spring.thymeleaf.cache屬性。 spring-boot-devtools模塊不須要手動設置這些屬性，而是自動應用更加合理的開發時(development-time)配置。

有關應用的屬性的完整列表，請參閱 DevToolsPropertyDefaultsPostProcessor。

20.2 自動重啓

使用spring-boot-devtools的應用程序將在類路徑上的文件發生更改時自動從新啓動。這在IDE中開發時多是一個有用的功能，由於它爲代碼更改提供了很是快的反饋循環。默認狀況下，將監視指向文件夾的類路徑上的任何條目。請注意，某些資源（如靜態資源和視圖模板）不須要從新啓動應用程序。

觸發重啓

當DevTools監視類路徑資源時，觸發從新啓動的惟一方法是更新類路徑中的文件時。致使類路徑更新的方式取決於您正在使用的IDE。在Eclipse中，保存修改的文件將致使類路徑被更新並觸發從新啓動。在IntelliJ IDEA中，構建項目（Build→Make Project）將具備相同的效果。

只要 forking 被啓用，您也能夠經過支持的構建插件（即Maven和Gradle）啓動應用程序，由於DevTools須要一個單獨的應用程序類加載器才能正常運行。Gradle和Maven默認狀況下在類路徑上檢DevTools。

自動重啓當與LiveReload一塊兒使用時工做很是好。詳見下文。若是您使用JRebel，自動重啓將被禁用，有利於動態類從新加載。其餘devtools功能仍然可使用（如LiveReload和屬性覆蓋）。

DevTools依賴於應用程序上下文的關閉鉤子，以在從新啓動期間關閉它。若是禁用了關閉掛鉤（SpringApplication.setRegisterShutdownHook（false）），DevTools將沒法正常工做。

當判斷類路徑中的項目是否會在更改時觸發從新啓動時，DevTools會自動忽略名爲spring-boot，spring-boot-devtools，spring-boot-autoconfigure，spring-boot-actuator和spring-boot-start的項目。

從新啓動(Restart) vs 從新加載(Reload)

Spring Boot提供的從新啓動技術使用兩個類加載器。不會改的類（例如，來自第三方的jar）被加載到基類加載器中。您正在開發的類被加載到從新啓動(restart)類加載器中。當應用程序從新啓動時，從新啓動類加載器將被丟棄，並建立一個新的類加載器。這種方法意味着應用程序從新啓動一般比「冷啓動」快得多，由於基類加載器已經可使用。

若是發現從新啓動對應用程序不夠快，或遇到類加載問題，您能夠考慮來自ZeroTurnaround的JRebel等從新加載技術。這些工做經過在加載類時重寫(rewriting)類，使其更適合從新加載。 Spring Loaded提供了另外一個選項，可是它在不少框架上不支持，而且不支持商用。

20.2.1 排除資源

在類路徑下，某些資源在更改時不必定須要觸發從新啓動。例如，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.2 監視額外的路徑

有時當您對不在類路徑中的文件進行更改時，須要從新啓動或從新加載應用程序。爲此，請使用spring.devtools.restart.additional-paths屬性來配置其餘路徑以監視更改。您可使用[上述](described above)的spring.devtools.restart.exclude屬性來控制附加路徑下的更改是否會觸發徹底從新啓動或只是實時從新加載。

20.2.3 禁用重啓

若是不想使用從新啓動功能，可使用spring.devtools.restart.enabled屬性來禁用它。在大多數狀況下，您能夠在application.properties中設置此項（這仍將初始化從新啓動類加載器，但不會監視文件更改）。

例如，若是您須要徹底禁用從新啓動支持，由於它在一些特定庫中不能正常運行，則須要在調用SpringApplication.run（…）以前設置System屬性。例如：

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

20.2.4 使用觸發文件

若是您使用IDE工具編寫代碼，更改文件，則您可能但願僅在特定時間觸發從新啓動。爲此，您可使用「觸發文件」，這是一個特殊文件，當您要實際觸發從新啓動檢查時，必須修改它。更改文件只會觸發檢查，只有在Devtools檢測到它必須執行某些操做時纔會從新啓動。觸發文件能夠手動更新，也能夠經過IDE插件更新。

要使用觸發器文件，請使用spring.devtools.restart.trigger-file屬性。

您可能但願將spring.devtools.restart.trigger-file設置爲全局設置，以使全部項目的行爲方式相同。

20.2.5 自定義從新啓動類加載器

如上面的 Restart vs Reload 部分所述，從新啓動功能是經過使用兩個類加載器實現的。對於大多數應用程序，此方法運行良好，但有時可能會致使類加載問題。

默認狀況下，IDE中的任何打開的項目將使用「從新啓動」類加載器加載，任何常規.jar文件將使用「base」類加載器加載。若是您在多模塊項目上工做，而不是每一個模塊都導入到IDE中，則可能須要自定義事件。爲此，您能夠建立一個META-INF / spring-devtools.properties文件。

spring-devtools.properties文件能夠包含restart.exclude 和 restart.include.prefixed屬性。 include元素是應該被拉入「從新啓動(restart)」類加載器的項目，排除元素是應該向下推入「基本(base)」類加載器的項目。屬性的值是將應用於類路徑的正則表達式模式。

例如：

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

全部屬性鍵必須是惟一的。只要一個屬性從restart.include. 或restart.exclude. 開始，將被考慮。

將加載類路徑中的全部META-INF/spring-devtools.properties。您能夠在項目中打包文件，或者在項目所使用的庫中打包文件。

20.2.6 已知的限制

從新啓動功能對於使用標準ObjectInputStream反序列化的對象無效。若是須要反序列化數據，可能須要使用Spring的ConfigurableObjectInputStream與Thread.currentThread()。getContextClassLoader()組合使用。

不幸的是，幾個第三方庫在不考慮上下文類加載器的狀況下反序列化。若是您發現這樣的問題，您須要向原始做者請求修復。

20.3 LiveReload

spring-boot-devtools模塊包括一個嵌入式LiveReload服務器，能夠在資源更改時用於觸發瀏覽器刷新。 LiveReload瀏覽器擴展程序能夠從 http://livereload.com 免費獲取Chrome，Firefox和Safari的插件。

若是您不想在應用程序運行時啓動LiveReload服務器，則能夠將spring.devtools.livereload.enabled屬性設置爲false。

一次只能運行一個LiveReload服務器。開始應用程序以前，請確保沒有其餘LiveReload服務器正在運行。若是從IDE啓動多個應用程序，則只有第一個應用程序將支持LiveReload。

20.4 全局設置

您能夠經過向 $HOME 文件夾添加名爲.spring-boot-devtools.properties的文件來配置全局devtools設置（請注意文件名以「.」開頭）。添加到此文件的任何屬性將適用於您的計算機上使用devtools的全部Spring Boot應用程序。例如，要配置從新啓動以始終使用觸發器文件，您能夠添加如下內容：

~/.spring-boot-devtools.properties.

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

20.5遠程應用

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.secret屬性設置時，服務器組件將自動啓用。客戶端組件必須手動啓動。

20.5.1 運行遠程客戶端應用程序

遠程客戶端應用程序旨在從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添加到程序參數（或任何遠程URL）中。

運行的遠程客戶端將以下所示：

.   ____          _                                              __ _ _
 /\\ / ___'_ __ _ _(_)_ __ __ _ ___ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | | _ \___ _ __ ___| |_ ___ \ \ \ \ \\/ ___)| |_)| | | | | || (_| []::::::[] / -_) ' \/ _ \ _/ -_) ) ) ) ) ' |____| .__|_| |_|_| |_\__, | |_|_\___|_|_|_\___/\__\___|/ / / / =========|_|==============|___/===================================/_/_/_/ :: Spring Boot Remote :: 1.5.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屬性。

20.5.2 遠程更新

遠程客戶端將以與本地相同的方式監視應用程序類路徑的更改。任何更新的資源將被推送到遠程應用程序，而且（若是須要的話）觸發從新啓動。若是您正在迭代使用您當地沒有的雲服務的功能，這可能會很是有用。一般，遠程更新和從新啓動比徹底重建和部署週期要快得多。

僅在遠程客戶端運行時才監視文件。若是在啓動遠程客戶端以前更改文件，則不會將其推送到遠程服務器。

20.5.3 遠程調試隧道

在遠程應用程序診斷問題時，Java遠程調試很是有用。不幸的是，當您的應用程序部署在數據中心以外時，並不老是可以進行遠程調試。若是您正在使用基於容器的技術（如Docker），遠程調試也可能難以設置。

爲了幫助解決這些限制，devtools支持基於HTTP隧道的傳輸遠程調試傳輸。遠程客戶端在端口8000上提供本地服務器，您能夠鏈接遠程調試器。創建鏈接後，經過HTTP將調試數據發送到遠程應用程序。若是要使用其餘端口，可使用spring.devtools.remote.debug.local-port屬性更改。

您須要確保遠程應用程序啓用遠程調試啓用。一般能夠經過配置JAVA_OPTS來實現。例如，使用Cloud Foundry，您能夠將如下內容添加到manifest.yml中：

--- env: JAVA_OPTS: "-Xdebug -Xrunjdwp:server=y,transport=dt_socket,suspend=n"

請注意，您不須要將 address=NNNN 選項傳遞給-Xrunjdwp。若是省略Java將隨機選擇一個的空閒端口。

經過網絡調試遠程服務可能很慢，您可能須要在IDE中增長超時時間。例如，在Eclipse中，您能夠從Preferences…中選擇Java→Debug ，並將Debugger timeout (ms)更改成更合適的值（大多數狀況下，60000能夠正常工做）。

當使用IntelliJ IDEA的遠程調試隧道時，必須將全部調試斷點配置爲掛起線程而不是掛起VM。默認狀況下，IntelliJ IDEA中的斷點會掛起整個VM，而不是僅掛起觸發斷點的線程。這會致使掛起管理遠程調試通道的線程等沒必要要的反作用，致使調試會話凍結。當使用IntelliJ IDEA的遠程調試隧道時，應將全部斷點配置爲掛起線程而不是VM。有關詳細信息，請參閱IDEA-165769。

21. 包裝您的應用程序到生產環境

可執行的jar可用於生產部署。因爲它們是相互獨立的，它們也很是適合基於雲的部署。

對於其餘「生產環境準備」功能，如健康，審計和metric REST或JMX端點; 考慮添加spring-boot-actuator。有關詳細信息，請參見第V部分「Spring Boot Actuator：生產環境準備功能」。

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 :: v1.5.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] ationConfigEmbeddedWebApplicationContext : Refreshing org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@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.TomcatEmbeddedServletContainerFactory : 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 級別log消息，包括用戶啓動應用程序一些相關的啓動細節。

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提供了衆多的FailureAnalyzer實現，您能夠很是容易地添加本身的實現。

若是沒有故障分析器(analyzers)可以處理異常，您仍然能夠顯示完整的自動配置報告，以更好地瞭解出現的問題。爲此，您須要啓用debug屬性或啓用org.springframework.boot.autoconfigure.logging.AutoConfigurationReportLoggingInitializer的DEBUG日誌。

例如，若是使用java -jar運行應用程序，則能夠按以下方式啓用 debug：

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

能夠經過在您的類路徑中添加一個 banner.txt 文件，或者將banner.location設置到banner文件的位置來更改啓動時打印的banner。若是文件有一些不經常使用的編碼，你能夠設置banner.charset（默認爲UTF-8）。除了文本文件，您還能夠將banner.gif，banner.jpg或banner.png圖像文件添加到您的類路徑中，或者設置一個banner.image.location屬性。圖像將被轉換成ASCII藝術表現，並打印在任何文字banner上方。

您能夠在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版本。例如1.5.2.RELEASE。
${spring-boot.formatted-version}	您正在使用格式化顯示的Spring Boot版本（用括號括起來，以v爲前綴）。例如（v1.5.2.RELEASE）。
	其中NAME是ANSI轉義碼的名稱。有關詳細信息，請參閱 AnsiPropertySource。
${application.title}	您的應用程序的標題在MANIFEST.MF中聲明。例如Implementation-Title：MyApp打印爲MyApp。

若是要以編程方式生成banner，則可使用SpringApplication.setBanner()方法。使用org.springframework.boot.Banner 如接口，並實現本身的printBanner() 方法。

您還可使用spring.main.banner-mode屬性來決定是否必須在System.out（控制檯）上打印banner，使用配置的logger（log）或不打印（off）。

23.3 定製SpringApplication

若是SpringApplication默認值不符合您的想法，您能夠建立本地實例並進行自定義。例如，關閉banner：

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 流式構建 API

若是您須要構建一個ApplicationContext層次結構（具備父/子關係的多個上下文），或者若是您只想使用「流式（fluent）」構建器API，則可使用SpringApplicationBuilder。

SpringApplicationBuilder容許您鏈式調用多個方法，幷包括容許您建立層次結構的父和子方法。

例如：

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

建立ApplicationContext層次結構時有一些限制，例如 Web組件必須包含在子上下文中，而且相同的環境將用於父和子上下文。有關詳細信息，請參閱SpringApplicationBuilder Javadoc。

23.5 Application events and listeners

除了常見的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在運行開始時發送，但在註冊偵聽器和註冊初始化器以後。
當已經知道要使用的上下文(context)環境，並在context建立以前，將發送ApplicationEnvironmentPreparedEvent。
ApplicationPreparedEvent在啓動刷新(refresh)以前發送，但在加載了bean定義以後。
ApplicationReadyEvent在刷新以後被髮送，而且處理了任何相關的回調以指示應用程序準備好服務請求。
若是啓動時發生異常，則發送ApplicationFailedEvent。

通常您不須要使用應用程序事件，但能夠方便地知道它們存在。在內部，Spring Boot使用事件來處理各類任務。

23.6 Web 環境

SpringApplication將嘗試表明您建立正確類型的ApplicationContext。默認狀況下，將使用AnnotationConfigApplicationContext或AnnotationConfigEmbeddedWebApplicationContext，具體取決於您是否正在開發Web應用程序。

用於肯定「Web環境」的算法是至關簡單的（基於幾個類的存在）。若是須要覆蓋默認值，可使用setWebEnvironment（boolean webEnvironment）。

也能夠經過調用setApplicationContextClass() 對ApplicationContext徹底控制。

在JUnit測試中使用SpringApplication時，一般須要調用setWebEnvironment()

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 Environment 註冊一個CommandLinePropertySource。這容許您也使用@Value註解注入應用程序參數。

23.8 使用ApplicationRunner或CommandLineRunner

SpringApplication啓動時若是您須要運行一些特定的代碼，就能夠實現ApplicationRunner或CommandLineRunner接口。兩個接口都以相同的方式工做，並提供一個單獨的運行方法，這將在SpringApplication.run（…）完成以前調用。

CommandLineRunner接口提供對應用程序參數的訪問（簡單的字符串數組），而ApplicationRunner使用上述的ApplicationArguments接口。

@Component public class MyBean implements CommandLineRunner { public void run(String... args) { // Do something... } }

若是定義了若干CommandLineRunner或ApplicationRunner bean，這些bean必須按特定順序調用，您能夠實現org.springframework.core.Ordered接口，也可使用org.springframework.core.annotation.Order註解。

23.9 Application exit

每一個SpringApplication將註冊一個JVM關閉鉤子，以確保ApplicationContext在退出時正常關閉。可使用全部標準的Spring生命週期回調（例如DisposableBean接口或@PreDestroy註釋）。

另外，若是但願在應用程序結束時返回特定的退出代碼，那麼bean能夠實現org.springframework.boot.ExitCodeGenerator接口。

23.10 管理功能

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

若是您想知道應用程序在哪一個HTTP端口上運行，請使用local.server.port鍵獲取該屬性。

啓用此功能時請當心，由於MBean公開了關閉應用程序的方法。

24. 外部配置

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

Spring Boot使用很是特別的PropertySource命令，旨在容許合理地覆蓋值。屬性按如下順序選擇：

在您的HOME目錄設置的Devtools全局屬性（~/.spring-boot-devtools.properties）。
單元測試中的 @TestPropertySource 註解。
單元測試中的 @SpringBootTest#properties 註解屬性
命令行參數。
SPRING_APPLICATION_JSON 中的屬性值（內嵌JSON嵌入到環境變量或系統屬性中）。
ServletConfig 初始化參數。
ServletContext 初始化參數。
來自 java:comp/env 的JNDI屬性。
Java系統屬性（System.getProperties()）。
操做系統環境變量。
RandomValuePropertySource，只有隨機的屬性 random.* 中。
jar包外面的 Profile-specific application properties （application- {profile} .properties和YAML變體）
jar包內的 Profile-specific application properties （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，它爲 name 屬性提供了默認屬性值。在新環境中運行時，能夠在您的jar外部提供一個application.properties來覆蓋 name 屬性; 對於一次性測試，您可使用特定的命令行開關啓動（例如，java -jar app.jar –name=」Spring」）。

SPRING_APPLICATION_JSON屬性能夠在命令行中提供一個環境變量。例如在UN*X shell中：

$ SPRING_APPLICATION_JSON='{"foo":{"bar":"spam"}}' java -jar myapp.jar

在本例中，您將在Spring環境中使用foo.bar = spam。您也能夠在系統變量中將JSON做爲spring.application.json提供：

$ java -Dspring.application.json='{"foo":"bar"}' -jar myapp.jar

或命令行參數：

$ java -jar myapp.jar --spring.application.json='{"foo":"bar"}'

或做爲JNDI變量 java:comp/env/spring.application.json 。

24.1 配置隨機值

RandomValuePropertySource可用於注入隨機值（例如，進入祕密或測試用例）。它能夠產生整數，長整數，uuid或字符串，例如

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是任何字符和值，max是整數。若是提供max，則值爲最小值，max爲最大值（獨佔）。

24.2 訪問命令行屬性

默認狀況下，SpringApplication將任何命令行選項參數（以’– ‘開頭，例如–server.port=9000）轉換爲屬性，並將其添加到Spring環境中。如上所述，命令行屬性始終優先於其餘屬性來源。

若是不但願將命令行屬性添加到環境中，可使用SpringApplication.setAddCommandLineProperties(false)禁用它們。

24.3 應用程序屬性文件

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

當前目錄的/config子目錄
當前目錄
classpath中/config包
classpath root路徑

該列表按優先級從高到低排序。

也能夠使用YAML（’.yml’）文件替代「.properties」。

若是您不喜歡application.properties做爲配置文件名，能夠經過指定一個spring.config.name Spring environment屬性來切換到另外一個。您還可使用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 env，system屬性或命令行參數）。

若是spring.config.location包含目錄（而不是文件），那麼它們應該以/結尾（並將在加載以前附加從spring.config.name生成的名稱，包括profile-specific的文件名）。在spring.config.location中指定的文件按原樣使用，不支持特定於配置文件的變體，而且將被任何特定於配置文件的屬性覆蓋。

默認的搜索路徑 classpath:,classpath:/config,file:,file:config/ 始終會被搜索，無論spring.config.location的值如何。該搜索路徑從優先級排序從低到高（file:config/最高）。若是您指定本身的位置，則它們優先於全部默認位置，並使用相同的從最低到最高優先級排序。這樣，您能夠在application.properties（或使用spring.config.name選擇的任何其餘基礎名稱）中爲應用程序設置默認值，並在運行時使用不一樣的文件覆蓋它，並保留默認值。

若是您使用環境(environment)變量而不是系統屬性，大多數操做系統不容許使用句點分隔(period-separated)的鍵名稱，但可使用下劃線（例如，SPRING_CONFIG_NAME，而不是spring.config.name）

若是您運行在容器中，則可使用JNDI屬性（在 java:comp/env 中）或servlet上下文初始化參數，而不是環境變量或系統屬性。

24.4 指定配置(Profile-specific)的屬性

除了application.properties文件外，還可使用命名約定application- {profile} .properties定義的特定配置文件。環境具備一組默認配置文件，若是沒有設置活動配置文件（即，若是沒有顯式激活配置文件，則加載了來自application-default.properties的屬性）。

指定配置文件（Profile-specific）的屬性從與標準application.properties相同的位置加載，特定配置( profile-specific)文件始終覆蓋非特定文件，而無論特定配置文件是否在打包的jar內部或外部。

若是指定了幾個配置文件，則應用最後一個配置。例如，由spring.profiles.active屬性指定的配置文件在經過SpringApplication API配置的配置以後添加，所以優先級高。

若是您在spring.config.location中指定了任何文件，則不會考慮這些特定配置(profile-specific)文件的變體。若是您還想使用特定配置(profile-specific)文件的屬性，請使用spring.config.location中的目錄。

24.5 properties 文件中的佔位符

application.properties中的值在使用時經過已有的環境進行過濾，以便您能夠引用以前定義的值（例如，從系統屬性）。

app.name=MyApp app.description=${app.name} is a Spring Boot application

您也可使用此技術建立現有Spring Boot屬性的「簡寫「。有關詳細信息，請參見第72.4節「使用」短命令行參數「how-to」。

24.6 使用YAML替代 Properties

YAML是JSON的超集，所以這是分層配置數據一種很是方便的格式，。每當您的類路徑中都有SnakeYAML庫時，SpringApplication類將自動支持YAML做爲 properties 的替代方法。

若是您使用「Starters」，SnakeYAML將經過spring-boot-starter自動提供。

24.6.1 加載 YAML

Spring Framework提供了兩個方便的類，可用於加載YAML文檔。 YamlPropertiesFactoryBean將YAML做爲Properties加載，YamlMapFactoryBean將YAML做爲Map加載。

例如，下面YAML文檔：

environments: dev: url: http://dev.bar.com name: Developer Setup prod: url: http://foo.bar.com name: My Cool App

將轉化爲屬性：

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

YAML列表表示爲具備[index] dereferencers的屬性鍵，例如YAML：

my: servers: - dev.bar.com - foo.bar.com

將轉化爲屬性：

my.servers[0]=dev.bar.com my.servers[1]=foo.bar.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; } }

24.6.2 將YAML做爲Spring環境中的屬性文件

可使用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。若是開發和生產配置文件未啓用，則該屬性的值將爲192.168.1.100。

若是應用程序上下文啓動時沒有顯式激活，默認配置文件將被激活。因此在這個YAML中，咱們爲security.user.password設置一個僅在「默認」配置文件中可用的值：

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

使用「spring.profiles」元素指定的Spring profiles 以選擇使用！ 字符。若是爲單個文檔指定了否認和非否認的配置文件，則至少有一個非否認配置文件必須匹配，沒有否認配置文件可能匹配。

24.6.4 YAML的缺點

YAML文件沒法經過@PropertySource註解加載。所以，在須要以這種方式加載值的狀況下，須要使用properties文件。

24.6.5 合併YAML列表

如上所述，任何YAML內容最終都會轉換爲屬性。當經過配置文件覆蓋「列表」屬性時，該過程可能比較直觀。

例如，假設名稱和描述屬性默認爲空的MyPojo對象。讓咱們從FooProperties中公開MyPojo的列表：

@ConfigurationProperties("foo") public class FooProperties { private final List<MyPojo> list = new ArrayList<>(); public List<MyPojo> getList() { return this.list; } }

類比如下配置：

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

若是dev配置沒有激活，FooProperties.list將包含一個如上定義的MyPojo條目。若是啓用了配置文件，列表仍將包含一個條目（名稱爲「my another name」，description=null）。此配置不會將第二個MyPojo實例添加到列表中，而且不會將項目合併。

當在多個配置文件中指定集合時，使用具備最高優先級的集合（而且僅使用該配置文件）：

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

在上面的示例中，考慮到dev配置文件處於激活狀態，FooProperties.list將包含一個MyPojo條目（名稱爲「my another name」和description=null）。

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("foo") public class FooProperties { 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定義瞭如下屬性：

foo.enabled，默認爲false
foo.remote-address，具備能夠從String強轉的類型
foo.security.username，具備內置的「安全性(security)」，其名稱由屬性名稱決定。特別是返回類型並無被使用，多是SecurityProperties
foo.security.password
foo.security.roles，一個String集合

Getters和setter方法一般是必需要有的，由於綁定是經過標準的Java Beans屬性描述符，就像在Spring MVC中同樣。在某些狀況下可能會省略setter方法：

Map 只要它們被初始化，須要一個getter，但不必定是一個setter，由於它們能夠被binder修改。
集合和數組能夠經過索引（一般使用YAML）或使用單個逗號分隔值（Properties中）來訪問。在後一種狀況下，setter方法是強制性的。咱們建議老是爲這樣的類型添加一個設置器。若是您初始化集合，請確保它不是不可變的（如上例所示）
若是已初始化嵌套POJO屬性（如上例中的Security字段），則不須要setter方法。若是您但願binder使用其默認構造函數即時建立實例，則須要一個setter。

有些人使用Project Lombok自動添加getter和setter。確保Lombok不會爲這種類型生成任何特定的構造函數，由於構造函將被容器自動用於實例化對象。

另請參閱@Value和@ConfigurationProperties之間的不一樣。

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

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

當@ConfigurationProperties bean以這種方式註冊時，該bean將具備常規名稱：<prefix> - <fqn>，其中是@ConfigurationProperties註解中指定的環境密鑰前綴，是bean的全名(fully qualified name)。若是註解不提供任何前綴，則僅使用該bean的全名。上面示例中的bean名稱將是foo-com.example.FooProperties。

即便上述配置將爲FooProperties建立一個常規bean，咱們建議@ConfigurationProperties僅處理環境，特別是不從上下文中注入其餘bean。話雖如此，@EnableConfigurationProperties註釋也會自動應用於您的項目，以便使用@ConfigurationProperties註釋的任何現有的bean都將從環境配置。您能夠經過確保FooProperties已是一個bean來快速上面的MyConfiguration

@Component
@ConfigurationProperties(prefix="foo") public class FooProperties { // ... see above }

這種配置方式與SpringApplication外部的YAML配置至關：

# application.yml

foo:
    remote-address: 192.168.1.1
    security:
        username: foo
        roles:
          - USER - ADMIN # additional configuration as required

要使用@ConfigurationProperties bean，您能夠像其餘任何bean同樣注入它們。

@Service public class MyService { private final FooProperties properties; @Autowired public MyService(FooProperties properties) { this.properties = properties; } //... @PostConstruct public void openConnection() { Server server = new Server(this.properties.getRemoteAddress()); // ... } }

使用@ConfigurationProperties還能夠生成IDE能夠爲本身的密鑰提供自動完成的元數據文件，有關詳細信息，請參見附錄B，配置元數據附錄。

24.7.1第三方配置

除了使用@ConfigurationProperties來註解類，還能夠在public @Bean方法中使用它。當您但願將屬性綁定到不受控制的第三方組件時，這可能特別有用。

@ConfigurationProperties(prefix = "bar") @Bean public BarComponent barComponent() { ... }

使用 bar 前綴定義的任何屬性將以與上述FooProperties示例相似的方式映射到該BarComponent bean。

24.7.2 寬鬆的綁定

Spring Boot使用一些寬鬆的規則將環境屬性綁定到@ConfigurationProperties bean，所以不須要在Environment屬性名稱和bean屬性名稱之間進行徹底匹配。經常使用的例子是這樣有用的：虛分離（例如上下文路徑綁定到contextPath）和大寫（例如PORT綁定到端口）環境屬性。

例如，給定如下@ConfigurationProperties類：

@ConfigurationProperties(prefix="person") public class OwnerProperties { private String firstName; public String getFirstName() { return this.firstName; } public void setFirstName(String firstName) { this.firstName = firstName; } }

可使用如下屬性名稱：

表格 24.1. relaxed binding

Property	Note
person.firstName	標準駱峯命名法。
person.first-name	虛線符號，推薦用於.properties和.yml文件。
person.first_name	下劃線符號，用於.properties和.yml文件的替代格式。
PERSON_FIRST_NAME	大寫格式推薦使用系統環境變量時。

24.7.3屬性轉換

當Spring綁定到@ConfigurationProperties bean時，Spring將嘗試將外部應用程序屬性強制爲正確的類型。若是須要自定義類型轉換，您能夠提供ConversionService bean（使用bean id conversionService）或自定義屬性編輯器（經過CustomEditorConfigurer bean）或自定義轉換器（使用註釋爲@ConfigurationPropertiesBinding的bean定義）。

因爲在應用程序生命週期期間很是早請求此Bean，請確保限制ConversionService正在使用的依賴關係。一般，您須要的任何依賴關係可能沒法在建立時徹底初始化。若是配置密鑰強制不須要，只需依賴使用@ConfigurationPropertiesBinding限定的自定義轉換器，就能夠重命名自定義ConversionService。

24.7.4 @ConfigurationProperties驗證

當Spring的@Validated註釋解時，Spring Boot將嘗試驗證@ConfigurationProperties類。您能夠直接在配置類上使用JSR-303 javax.validation約束註釋。只需確保您的類路徑中符合JSR-303實現，而後在您的字段中添加約束註釋：

@ConfigurationProperties(prefix="foo") @Validated public class FooProperties { @NotNull private InetAddress remoteAddress; // ... getters and setters }

爲了驗證嵌套屬性的值，您必須將關聯字段註釋爲@Valid以觸發其驗證。例如，基於上述FooProperties示例：

@ConfigurationProperties(prefix="connection") @Validated public class FooProperties { @NotNull private InetAddress remoteAddress; @Valid private final Security security = new Security(); // ... getters and setters public static class Security { @NotEmpty public String username; // ... getters and setters } }

您還能夠經過建立名爲configurationPropertiesValidator的bean定義來添加自定義的Spring Validator。 @Bean方法應聲明爲static。配置屬性驗證器在應用程序的生命週期早期建立，並聲明@Bean方法，由於static容許建立bean，而無需實例化@Configuration類。這避免了早期實例化可能引發的任何問題。這裏有一個屬性驗證的例子，因此你能夠看到如何設置。

spring-boot-actuator模塊包括一個暴露全部@ConfigurationProperties bean的端點。只需將您的Web瀏覽器指向/configprops 或使用等效的JMX端點。請參閱生產就緒功能細節。

24.7.5 @ConfigurationProperties 對比 @Value

@Value是核心容器功能，它不提供與類型安全配置屬性相同的功能。下表總結了@ConfigurationProperties和@Value支持的功能：

功能	@ConfigurationProperties	@Value
Relaxed binding	Yes	No
Meta-data support	Yes	No
SpEL evaluation	No	Yes

若是您爲本身的組件定義了一組配置密鑰，咱們建議您將其分組到使用@ConfigurationProperties註釋的POJO中。還請注意，因爲@Value不支持寬鬆的綁定，若是您須要使用環境變量提供值，那麼它不是一個很好的選擇。

最後，當您能夠在@Value中編寫一個Spel表達式時，這些表達式不會從應用程序屬性文件中處理。

25. 配置文件(Profiles)

Spring 配置文件提供了將應用程序配置隔離的方法，使其僅在某些環境中可用。任何@Component或@Configuration均可以使用@Profile進行標記，以限制其在何時加載：

@Configuration
@Profile("production") public class ProductionConfiguration { // ... }

通常，您可使用spring.profiles.active Environment屬性來指定哪些配置文件處於激活狀態。您能夠以任何方式指定屬性，例如，您能夠將其包含在您的application.properties中：

spring.profiles.active=dev,hsqldb

或者使用命令行--spring.profiles.active=dev,hsqldb在命令行中指定。

25.1添加激活配置文件

spring.profiles.active屬性遵循與其餘屬性相同的優先級規則，PropertySource最高。這意味着您能夠在application.properties中指定活動配置文件，而後使用命令行開關替換它們。

有時，將特定於配置文件的屬性添加到激活的配置文件而不是替換它們是有用的。 spring.profiles.include屬性可用於無條件添加激活配置文件。 SpringApplication入口點還具備用於設置其餘配置文件的Java API（即，在由spring.profiles.active屬性激活的那些配置文件之上）：請參閱setAdditionalProfiles()方法。

例如，當使用開關 -spring.profiles.active=prod 運行具備如下屬性的應用程序時，proddb和prodmq配置文件也將被激活：

--- my.property: fromyamlfile --- spring.profiles: prod spring.profiles.include:  - proddb  - prodmq

請記住，能夠在YAML文檔中定義spring.profiles屬性，以肯定此特定文檔什麼時候包含在配置中。有關詳細信息，請參見第72.7節「根據環境更改配置」。

25.2 以編程方式設置配置文件

您能夠經過在應用程序運行以前調用SpringApplication.setAdditionalProfiles(…)以編程方式設置激活配置文件。也可使用Spring的ConfigurableEnvironment接口激活配置文件。

25.3 配置文件指定的配置文件

經過@ConfigurationProperties引用的application.properties（或application.yml）和文件的配置文件特定變體都被視爲加載文件。有關詳細信息，請參見第24.4節指定配置(Profile-specific)的屬性」。

26. 日誌

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。

Spring Boot中文文檔（官方文檔翻譯 基於1.5.2.RELEASE）