Spring boot參考指南
介紹
轉載自：https：//www.gitbook.com/book/qbgbook/spring-boot-reference-guide-zh/detailsjavascript
帶目錄瀏覽地址：http：//www.maoyupeng.com/spring-boot-api.htmlphp
1.Spring Boot文檔
本節提供一個Spring Boot參考文檔的簡明概述。你能夠把它做爲文檔其他部分的導航。你能夠從頭至尾依次閱讀該參考指南，或跳過你不感興趣的章節。css
1.1關於本文檔
Spring Boot參考指南有html，pdf和epub形式的文檔。在docs.spring.io/spring-boot/docs/current/reference可獲取到最新的副本。html
在對副本不收取任何費用，而且無論是打印仍是電子版每一個副本都包含版權聲明的狀況下，你能夠本身使用本文檔副本，也能夠分發給其餘人。前端
開始
若是你想從整體上對Spring Boot或Spring入門，本章節就是爲你準備的！在這裏，咱們將回答基本的「什麼？」，「怎麼樣？」和「爲何？」問題。你會發現一個溫雅的Spring Boot介紹及安裝指南。而後咱們構建第一個Spring Boot應用，並討論一些咱們須要遵循的核心原則。java
2.1 Spring Boot介紹
Spring Boot使用開發獨立的，產品級別的基於Spring的應用變得很是簡單，你只需「只是運行」。咱們爲Spring平臺及第三方庫提供開箱即用的設置，這樣你就能夠有條不亂地開始。多數Spring Boot應用須要不多的Spring配置。mysql
你能夠使用Spring Boot建立Java應用，並使用java -jar啓動它或採用傳統的war部署方式。咱們也提供了一個運行「spring腳本」的命令行工具。git
咱們主要的目標是：github
- 爲全部的春季開發提供一個從根本上更快的和普遍使用的入門經驗。
- 開箱即用，但你能夠經過不採用默認設置來擺脫這種方式。
- 提供一系列大型項目經常使用的非功能性特徵（好比，內嵌服務器，安全，指標，健康檢測，外部化配置）。
- 絕對不須要代碼生成及XML配置。
2.2系統要求
默認狀況下，Spring Boot 1.3.0.BUILD-SNAPSHOT須要Java7和Spring框架4.1.3或以上。你能夠在Java6下使用Spring Boot，不過須要添加額外配置。具體參考第73.9節「如何使用Java 6 「。構建環境明確支持的有Maven（3.2+）和Gradle（1.12+）。web
注：儘管你能夠在Java6或Java7環境下使用Spring Boot，一般咱們建議你若是可能的話就使用Java8。
2.2.1 Servlet容器
下列內嵌容器支持開箱即用（開箱即用）：
| 名稱 | Servlet的版本 | Java的版本 |
|---|---|---|
| 雄貓8 | 3.1 | Java 7+ |
| 雄貓7 | 3.0 | Java 6+ |
| 碼頭9 | 3.1 | Java 7+ |
| 碼頭8 | 3.0 | Java 6+ |
| Undertow 1.1 | 3.1 | Java 7+ |
你也能夠將Spring Boot應用部署到任何兼容Servlet 3.0+的容器。
2.3 Spring Boot安裝
Spring Boot能夠跟典型的Java開發工具一塊使用或安裝爲一個命令行工具。無論怎樣，你將須要安裝Java SDK v1.6或更高版本。在開始以前，你須要檢查下當前安裝的Java版本：
$ java -version
若是你是一個Java新手，或者你是想體驗一下Spring Boot，你可能想先嘗試Spring Boot CLI，不然繼續閱讀經典地安裝指南。
注：儘管Spring Boot兼容Java 1.6，若是可能的話，你應該考慮使用Java最新版本。
2.3.1爲Java開發者準備的安裝指南
你能夠像使用其餘任何標準Java庫那樣使用Spring Boot，只需簡單地在你的classpath下包含正確的spring-boot - * .jar文件.Spring Boot不須要集成任何特殊的工具，因此你能夠使用任何IDE或文本編輯器; Spring Boot應用也沒有什麼特殊之處，因此你能夠像任何其餘Java程序那樣運行和調試。
儘管你能夠拷貝Spring Boot jars，不過，咱們一般推薦你使用一個支持依賴管理的構建工具（好比Maven或Gradle）。
2.3.1.1 Maven安裝
Spring Boot兼容Apache Maven 3.2或更高版本。若是沒有安裝Maven，你能夠參考maven.apache.org指南。
注意：在不少操做系統上，你能夠經過一個包管理器安裝Maven。若是你是一個OSX Homebrew用戶，能夠嘗試brew install maven.Ubuntu用戶能夠運行sudo apt-get install maven。
Spring Boot依賴的groupId爲org.springframework.boot。一般你的Maven POM文件須要繼承spring-boot-starter-parent，而後聲明一個或多個「Starter POMs」依賴.Spring Boot也提供了一個用於建立可執行罐的Maven的插件。
下面是一個典型的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.3.0.BUILD-SNAPSHOT</version> </parent> <!-- Add typical dependencies for a web application --> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies> <!-- Package as an executable jar --> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> <!-- Add Spring repositories --> <!-- (you don't need this if you are using a .RELEASE version) --> <repositories> <repository> <id>spring-snapshots</id> <url>http://repo.spring.io/snapshot</url> <snapshots><enabled>true</enabled></snapshots> </repository> <repository> <id>spring-milestones</id> <url>http://repo.spring.io/milestone</url> </repository> </repositories> <pluginRepositories> <pluginRepository> <id>spring-snapshots</id> <url>http://repo.spring.io/snapshot</url> </pluginRepository> <pluginRepository> <id>spring-milestones</id> <url>http://repo.spring.io/milestone</url> </pluginRepository> </pluginRepositories> </project>
注：spring-boot-starter-parent是使用Spring Boot的一個不錯的方式，但它不老是合適的。有時你須要繼承一個不一樣的父POM，或者你可能只是不喜歡咱們的默認配置。查看部分13.1.2，「使用Spring沒有父POM的引導「獲取使用import的替代解決方案。
2.3.1.2 Gradle安裝
Spring Boot兼容Gradle 1.12或更高版本。若是沒有安裝Gradle，你能夠參考www.gradle.org上的指南。
Spring引用依賴能夠使用org.springframework.boot group來聲明。一般，你的項目將聲明一個或多個「Starter POMs」依賴.Spring Boot提供一個用於簡化依賴聲明和建立可執行jars的有用的Gradle插件。
注：當你須要構建一個項目時，Gradle Wrapper提供一個獲取Gradle的漂亮方式。它是一個伴隨你的代碼一塊提交的小腳本和庫，用於啓動構建進程。具體參考Gradle Wrapper。
下面是一個典型的的build.gradle文件：
buildscript {
repositories {
jcenter()
maven { url "http://repo.spring.io/snapshot" } maven { url "http://repo.spring.io/milestone" } } dependencies { classpath("org.springframework.boot:spring-boot-gradle-plugin:1.3.0.BUILD-SNAPSHOT") } } apply plugin: 'java' apply plugin: 'spring-boot' jar { baseName = 'myproject' version = '0.0.1-SNAPSHOT' } repositories { jcenter() maven { url "http://repo.spring.io/snapshot" } maven { url "http://repo.spring.io/milestone" } } dependencies { compile("org.springframework.boot:spring-boot-starter-web") testCompile("org.springframework.boot:spring-boot-starter-test") }
2.3.2 Spring Boot CLI安裝
Spring Boot是一個命令行工具，用於使用Spring進行快速原型搭建。它容許你運行Groovy腳本，這意味着你能夠使用類Java的語法，而且沒有那麼多的模板代碼。
你沒有必要爲了使用Spring Boot而去用CLI，但它絕對是助力Spring應用的最快方式。
2.3.2.1手動安裝
你能夠從Spring軟件倉庫下載Spring CLI分發包：
spring-boot-cli-1.3.0.BUILD-SNAPSHOT-bin.zip
spring-boot-cli-1.3.0.BUILD-SNAPSHOT-bin.tar.gz
不穩定的快照分發包也能獲取到。
下載完成後，遵循解壓後的存檔裏的INSTALL.txt操做指南進行安裝。通常而言，在.zip文件的bin /目錄下存在一個spring腳本（Windows下是spring.bat），或者使用java -jar來運行一個的.jar文件（該腳本會幫你肯定類路徑被正確設置）。
2.3.2.2使用GVM安裝
GVM（Groovy環境管理器）能夠用來管理多種不一樣版本的Groovy和Java二進制包，包括Groovy自身和Spring Boot CLI。能夠從gvmtool.net獲取gvm，並使用如下命令安裝Spring Boot：
$ gvm install springboot
$ spring --version
Spring Boot v1.3.0.BUILD-SNAPSHOT
若是你正在爲CLI開發新的特性，並想輕鬆獲取你剛構建的版本，能夠使用如下命令：
$ gvm install springboot dev /path/to/spring-boot/spring-boot-cli/target/spring-boot-cli-1.3.0.BUILD-SNAPSHOT-bin/spring-1.3.0.BUILD-SNAPSHOT/ $ gvm use springboot dev $ spring --version Spring CLI v1.3.0.BUILD-SNAPSHOT
這將會在你的gvm倉庫中安裝一個名叫dev的本地spring實例。它指向你的目標構建位置，因此每次你從新構建Spring Boot，spring將會是最新的。
你能夠經過如下命令來驗證：
$ gvm ls springboot
================================================================================
Available Springboot Versions
================================================================================
> + dev
* 1.3.0.BUILD-SNAPSHOT
================================================================================
+ - local version * - installed > - currently in use ================================================================================
2.3.2.3使用OSX Homebrew進行安裝
若是你的環境是Mac，並使用Homebrew，想要安裝Spring Boot CLI只需以下操做：
$ brew tap pivotal/tap $ brew install springboot
自制將把彈簧安裝到在/ usr / local / bin目錄下。
注：若是該方案不可用，多是由於你的brew版本太老了。你只需執行brew update並重試便可。
2.3.2.4使用MacPorts進行安裝
若是你的環境是Mac，並使用MacPorts，想要安裝Spring Boot CLI只需以下操做：
$ sudo port install spring-boot-cli
2.3.2.5命令行實現
Spring Boot CLI啓動腳本爲BASH和zsh shells提供完整的命令行實現。你能夠在任何shell中源腳本（名稱也是spring），或將它放到你我的或系統範圍的bash實現初始化中。在一個Debian系統裏，系統範圍的腳本位於/殼完成/ bash的下，當一個新的外殼啓動時該目錄下的全部腳本都被執行想要手動運行該腳本，例如，你已經使用GVM進行安裝了：
$ . ~/.gvm/springboot/current/shell-completion/bash/spring $ spring grab help jar run test version
注：若是你使用Homebrew或MacPorts安裝Spring Boot CLI，命令行實現腳本會自動註冊到你的shell。
2.3.2.6 Spring CLI示例快速入門
。下面是一個至關簡單的網絡應用，你能夠用它測試你的安裝是否成功建立一個名叫app.groovy的文件：
@RestController class ThisWillActuallyRun { @RequestMapping("/") String home() { "Hello World!" } }
而後簡單地從一個殼中運行它：
$ spring run app.groovy
注：當你首次運行該應用時將會花費一點時間，由於須要下載依賴後續運行將會快不少。
在你最喜歡的瀏覽器中打開本地主機：8080，而後你應該看到如下輸出：
Hello World!
2.3.3從Spring Boot早期版本升級
若是你正在升級一個Spring Boot早期版本，查看下放在項目wiki上的「發行說明」。你會發現每次發佈的更新指南和一個「new and noteworthy」特性列表。
想要升級一個已安裝的CLI，你須要使用合適的包管理命令（例如，brew upgrade），或若是你是手動安裝CLI，按照標準說明操做並記得更新你的PATH環境變量以移除任何老的引用。
2.3.4開發你的第一個Spring Boot應用
讓咱們使用Java開發一個簡單的「Hello World！」 web應用，來強調下Spring Boot的一些關鍵特性。咱們將使用Maven構建該項目，由於大多數IDEs都支持它。
注：spring.io網站包含不少使用Spring Boot的「入門」指南。若是你正在找特定問題的解決方案，能夠先去那瞅瞅。
在開始前，你須要打開一個終端，檢查是否安裝可用的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
注：該示例須要建立本身的文件夾後續的操做假設你已建立一個合適的文件夾，而且它是你的「當前目錄」。
2.3.5建立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.3.0.BUILD-SNAPSHOT</version> </parent> <!-- Additional lines to be added here... --> <!-- (you don't need this if you are using a .RELEASE version) --> <repositories> <repository> <id>spring-snapshots</id> <url>http://repo.spring.io/snapshot</url> <snapshots><enabled>true</enabled></snapshots> </repository> <repository> <id>spring-milestones</id> <url>http://repo.spring.io/milestone</url> </repository> </repositories> <pluginRepositories> <pluginRepository> <id>spring-snapshots</id> <url>http://repo.spring.io/snapshot</url> </pluginRepository> <pluginRepository> <id>spring-milestones</id> <url>http://repo.spring.io/milestone</url> </pluginRepository> </pluginRepositories> </project>
這會給你一個可運轉的構建，你能夠經過運行mvn package測試它（如今你能夠忽略「jar將是空的 - 沒有包含任何內容！」的警告）。
注：目前你能夠將該項目導入一個IDE（大多數現代的Java IDE都包含對Maven的內建支持）。簡單起見，咱們將繼續使用普通的文本編輯器完成該示例。
2.3.6添加類路徑依賴
Spring Boot提供不少「Starter POMs」，這可以讓你輕鬆的將jars添加到你的類路徑下。咱們的示例程序已經在POM的partent節點使用了spring-boot-starter-parent.spring-boot-starter-父母是一個特殊的啓動器，它提供了有用的Maven的默認設置。同時，它也提供了一個依賴管理節點，這樣對於」福地「依賴你能夠省略版本標記。
其餘的「Starter POMs」簡單的提供依賴，這些依賴多是你開發特定類型的應用時須要的。因爲正在開發一個網應用，咱們將添加一個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依賴：
<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies>
若是再次運行mvn dependency:tree，你將看到如今有了一些其餘依賴，包括Tomcat web服務器和Spring Boot自身。
2.3.7編寫代碼
爲了完成應用程序，咱們須要建立一個單獨的Java的文件.Maven會默認compile- 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); } }
儘管這裏沒有太多代碼，但不少事情正在發生。讓咱們分步探討重要的部分。
2.3.7.1 @RestController和@RequestMapping註解
咱們的實施例類上使用的第一個註解是@RestController。這被稱爲一個構造型（原型）註解。它爲閱讀代碼的人們提供建議。對於彈簧，該類扮演了一個特殊角色。在本示例中，咱們的類是一個web @Controller，因此當處理進來的web請求時，Spring會詢問它。
@RequestMapping註解提供路由信息。它告訴春任何來自 「/」 路徑的HTTP請求都應該被映射到家裏方法。@ RestController註解告訴春季以字符串的形式渲染結果，並直接返回給調用者。
注：@RestController和@RequestMapping註解是Spring MVC註解（它們不是Spring Boot的特定部分）。具體查看Spring參考文檔的MVC章節。
2.3.7.2 @EnableAutoConfiguration註解
第二個類級別的註解是@EnableAutoConfiguration。這個註解告訴Spring Boot根據添加的jar依賴猜想你想如何配置Spring。因爲spring-boot-starter-web添加了Tomcat和Spring MVC，因此auto-configuration將假定你正在開發一個網絡應用並相應地對彈簧進行設置。
Starter POMs和Auto-Configuration：設計自動配置的目的是更好的使用「Starter POMs」，但這兩個概念沒有直接的聯繫。你能夠自由地挑選起動器POMs之外的jar依賴，而且Spring Boot將仍舊盡最大努力去自動配置你的應用。
2.3.7.3主要方法
咱們的應用程序最後部分是主方法。這只是一個標準的方法，它遵循Java對於一個應用程序入口點的約定。咱們的主方法經過調用運行，將業務委託給了Spring Boot的SpringApplication類.SpringApplication將引導咱們的應用，啓動Spring，相應地啓動被自動配置的Tomcat web服務器。咱們須要將Example.class做爲參數傳遞給run方法來告訴SpringApplication誰是主要的Spring組件。爲了暴露任何的命令行參數，args數組也會被傳遞過去。
2.3.8運行示例
到此咱們的應用應該能夠工做了因爲使用了。spring-boot-starter-parentPOM，這樣咱們就有了一個很是有用的運行目標，咱們能夠用它啓動程序在項目根目錄下輸入。mvn spring-boot:run來啓動應用：
$ mvn spring-boot:run . ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ \\/ ___)| |_)| | | | | || (_| | ) ) ) ) ' |____| .__|_| |_|_| |_\__, | / / / / =========|_|==============|___/=/_/_/_/ :: Spring Boot :: (v1.3.0.BUILD-SNAPSHOT) ....... . . . ....... . . . (log output here) ....... . . . ........ Started Example in 2.222 seconds (JVM running for 6.514)
若是使用一個瀏覽器打開localhost:8080，你應該能夠看到如下輸出：
Hello World!
點擊ctrl-c溫雅地關閉應用程序。
2.3.9建立一個可執行jar
讓咱們經過建立一個徹底自包含的可執行jar文件來結束咱們的示例，該jar文件能夠在生產環境運行。可執行jars（有時候被成爲胖jars「fat jars」）是包含你的編譯後的類和你的代碼運行所需的依賴罐子的存檔。
可執行jars和Java：Java沒有提供任何標準的加載內封jar文件（即jar文件中還包含jar文件）的方法。若是你想發佈一個自包含的應用這就是一個問題。爲了解決該問題，不少開發者採用「共享的」罐子。一個共享的罐子簡單地未來自全部罐子的類打包進一個單獨的「超級罐子」。採用共享罐子方式的問題是很難區分在你的應用程序中能夠使用哪些庫。在多個jars中若是存在相同的文件名（但內容不同）也會是一個問題.Spring Boot採起一個不一樣的途徑，並容許你真正的內嵌罐子。
爲了建立可執行的JAR，須要將彈簧引導Maven的插件添加到咱們的pom.xml的中在依賴節點下插入如下內容：
<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>
注：spring-boot-starter-parenPOM包含用於綁定repackage目標的<executions>配置。若是你不使用parent 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.3.0.BUILD-SNAPSHOT:repackage (default) @ myproject --- [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------
若是查看目標目錄，你應該看到的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的文件。這是在Spring Boot從新打包前Maven建立的原始jar文件。
爲了運行該應用程序，能夠你使用java -jar命令：
$ java -jar target/myproject-0.0.1-SNAPSHOT.jar . ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ \\/ ___)| |_)| | | | | || (_| | ) ) ) ) ' |____| .__|_| |_|_| |_\__, | / / / / =========|_|==============|___/=/_/_/_/ :: Spring Boot :: (v1.3.0.BUILD-SNAPSHOT) ....... . . . ....... . . . (log output here) ....... . . . ........ Started Example in 2.536 seconds (JVM running for 2.864)
和之前同樣，點擊CTRL-C來溫柔地退出程序。
使用Spring Boot
春節靴子最佳實踐。儘管消費的庫），但仍有一些建議，若是你遵循的話將會讓你的開發進程更容易。
若是你剛接觸Spring Boot，那最好先讀下上一章節的入門指南。
3.1構建系統
強烈建議你選擇一個支持依賴管理，能消費發佈到Maven中央倉庫的artifacts的構建系統。咱們推薦你選擇Maven或Gradle。選擇其餘構建系統來使用Spring Boot也是可能的（好比Ant），但它們不會被很好的支持。
3.1.1 Maven
Maven的用戶能夠繼承彈簧引導啓動父項目來獲取合適的默認設置該父項目提供如下特性：
- Java 1.4。默認編譯級別爲Java 1.6
- 源碼編碼爲UTF-8
- 一個依賴管理節點，容許你省略普通依賴的<version>標籤，繼承自spring-boot-dependencies POM。
- 的合適資源過濾
- 合適的插件配置（exec插件，surefire，Git commit ID，shade）
- 針對application.properties和application.yml的資源過濾
最後一點：因爲默認配置文件接收Spring風格的佔位符（${...}），Maven過濾改用@..@佔位符（你能夠使用Maven屬性resource.delimiter來覆蓋它）。
3.1.1.1繼承父母
想配置你的項目繼承spring-boot-starter-parent只須要簡單地設置parent爲：
<!-- Inherit defaults from Spring Boot --> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.3.0.BUILD-SNAPSHOT</version> </parent>
注：你應該只須要在該依賴上指定Spring Boot版本。若是導入其餘的starters，你能夠放心的省略版本號。
3.1.1.2 使用沒有父POM的Spring Boot
不是每一個人都喜歡繼承spring-boot-starter-parent POM。你可能須要使用公司標準parent，或你可能傾向於顯式聲明全部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.3.0.BUILD-SNAPSHOT</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement>
3.1.1.3 改變java版本
spring-boot-starter-parent選擇至關保守的Java兼容策略。若是你遵循咱們的建議，使用最新的Java版本，你能夠添加一個java.version屬性：
<properties> <java.version>1.8</java.version> </properties>
3.1.1.4 使用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 starter parent pom，你只須要添加該插件而無需配置它，除非你想改變定義在partent中的設置。
3.1.2 Gradle
Gradle用戶能夠直接在它們的dependencies節點處導入」starter POMs「。跟Maven不一樣的是，這裏沒有用於導入共享配置的"超父"（super parent）。
apply plugin: 'java' repositories { jcenter() } dependencies { compile("org.springframework.boot:spring-boot-starter-web:1.3.0.BUILD-SNAPSHOT") }
spring-boot-gradle-plugin插件也是能夠使用的，它提供建立可執行jar和從source運行項目的任務。它也添加了一個ResolutionStrategy用於讓你省略經常使用依賴的版本號：
buildscript {
repositories { jcenter() }
dependencies {
classpath("org.springframework.boot:spring-boot-gradle-plugin:1.3.0.BUILD-SNAPSHOT") } } apply plugin: 'java' apply plugin: 'spring-boot' repositories { jcenter() } dependencies { compile("org.springframework.boot:spring-boot-starter-web") testCompile("org.springframework.boot:spring-boot-starter-test") }
3.1.3 Ant
使用Apache Ant構建一個Spring Boot項目是徹底可能的，然而，Spring Boot沒有爲它提供特殊的支持或插件。Ant腳本能夠使用Ivy依賴管理系統來導入starter POMs。
查看Section 73.8, 「Build an executable archive with Ant」獲取更多指導。
3.1.4 Starter POMs
Starter POMs是能夠包含到應用中的一個方便的依賴關係描述符集合。你能夠獲取全部Spring及相關技術的一站式服務，而不須要翻閱示例代碼，拷貝粘貼大量的依賴描述符。例如，若是你想使用Spring和JPA進行數據庫訪問，只須要在你的項目中包含spring-boot-starter-data-jpa依賴，而後你就能夠開始了。
該starters包含不少你搭建項目，快速運行所需的依賴，並提供一致的，管理的傳遞依賴集。
名字有什麼含義：全部的starters遵循一個類似的命名模式：spring-boot-starter-*，在這裏*是一種特殊類型的應用程序。該命名結構旨在幫你找到須要的starter。不少IDEs集成的Maven容許你經過名稱搜索依賴。例如，使用相應的Eclipse或STS插件，你能夠簡單地在POM編輯器中點擊ctrl-space，而後輸入"spring-boot-starter"能夠獲取一個完整列表。
下面的應用程序starters是Spring Boot在org.springframework.boot組下提供的：
Spring Boot application starters
| 名稱 | 描述 |
|---|---|
| spring-boot-starter | 核心Spring Boot starter，包括自動配置支持，日誌和YAML |
| spring-boot-starter-actuator | 生產準備的特性，用於幫你監控和管理應用 |
| spring-boot-starter-amqp | 對"高級消息隊列協議"的支持，經過spring-rabbit實現 |
| spring-boot-starter-aop | 對面向切面編程的支持，包括spring-aop和AspectJ |
| spring-boot-starter-batch | 對Spring Batch的支持，包括HSQLDB數據庫 |
| spring-boot-starter-cloud-connectors | 對Spring Cloud Connectors的支持，簡化在雲平臺下（例如，Cloud Foundry 和Heroku）服務的鏈接 |
| spring-boot-starter-data-elasticsearch | 對Elasticsearch搜索和分析引擎的支持，包括spring-data-elasticsearch |
| spring-boot-starter-data-gemfire | 對GemFire分佈式數據存儲的支持，包括spring-data-gemfire |
| spring-boot-starter-data-jpa | 對"Java持久化API"的支持，包括spring-data-jpa，spring-orm和Hibernate |
| spring-boot-starter-data-mongodb | 對MongoDB NOSQL數據庫的支持，包括spring-data-mongodb |
| spring-boot-starter-data-rest | 對經過REST暴露Spring Data倉庫的支持，經過spring-data-rest-webmvc實現 |
| spring-boot-starter-data-solr | 對Apache Solr搜索平臺的支持，包括spring-data-solr |
| spring-boot-starter-freemarker | 對FreeMarker模板引擎的支持 |
| spring-boot-starter-groovy-templates | 對Groovy模板引擎的支持 |
| spring-boot-starter-hateoas | 對基於HATEOAS的RESTful的服務的支持，經過彈簧HATEOAS實現 |
| 彈簧引導啓動，將hornetq | 對 「的Java消息服務API」 的支持，經過HornetQ的實現 |
| 彈簧引導啓動整合 | 對普通彈簧集成模塊的支持 |
| 彈簧引導啓動-JDBC | 對JDBC數據庫的支持 |
| 彈簧引導起動球衣 | 對澤西RESTful Web服務框架的支持 |
| 彈簧引導啓動，JTA，Atomikos公司 | 對JTA分佈式事務的支持，經過Atomikos公司實現 |
| 彈簧引導啓動，JTA，bitronix | 對JTA分佈式事務的支持，經過Bitronix實現 |
| 彈簧引導啓動郵件 | 對javax.mail的支持 |
| 彈簧引導啓動移動 | 對彈簧移動的支持 |
| 彈簧引導啓動，小鬍子 | 對鬍鬚模板引擎的支持 |
| 彈簧引導起動的Redis | 對Redis的鍵值數據存儲的支持，包括彈簧的Redis |
| 彈簧引導啓動安全 | 對春季安全的支持 |
| 彈簧引導起動社會的Facebook | 對彈簧社會的Facebook的支持 |
| 春天開機起動 - 社會 - LinkedIn | 對彈簧社會LinkedIn的支持 |
| 春天開機起動 - 社會 - 嘰嘰喳喳 | 對彈簧社會嘰嘰喳喳的支持 |
| 彈簧引導啓動測試 | 對經常使用測試依賴的支持，包括JUnit，Hamcrest和Mockito，還有spring-test模塊 |
| 彈簧引導起動thymeleaf | 對Thymeleaf模板引擎的支持，包括和春天的集成 |
| 彈簧引導起動速度 | 對速度模板引擎的支持 |
| 彈簧引導啓動的Web | 對全棧網絡開發的支持，包括Tomcat的和彈簧webmvc |
| 彈簧引導起動的WebSocket | 對WebSocket的開發的支持 |
| spring-boot-starter-ws對Spring | 網絡服務的支持 |
除了應用程序的啓動，下面的啓動器用於能夠添加生產準備的特性。
Spring Boot生產準備的啓動器
| 名稱 | 描述 |
|---|---|
| 彈簧引導起動致動器 | 添加生產準備特性，好比指標和監控 |
| 彈簧引導起動遠程 - 殼 | 添加遠程ssh shell支持 |
最後，Spring Boot包含一些可用於排除或交換具體技術方面的啓動器。
Spring Boot技術首發
| 名稱 | 描述 |
|---|---|
| 彈簧引導起動碼頭 | 導入Jetty HTTP引擎（做爲Tomcat的替代） |
| 彈簧引導起動的log4j | 對Log4J的日誌系統的支持 |
| 彈簧引導啓動日誌記錄 | 導入Spring Boot的默認日誌系統（Logback） |
| 彈簧引導起動的tomcat | 導入Spring Boot的默認HTTP引擎（Tomcat） |
| 彈簧引導起動暗流 | 導入Undertow HTTP引擎（做爲Tomcat的替代） |
注：查看GitHub上位於spring-boot-starters模塊內的README文件，能夠獲取到一個社區貢獻的其餘啓動器POM列表。
3.2組織你的代碼
Spring Boot不須要使用任何特殊的代碼結構，然而，這裏有一些有用的最佳實踐。
3.2.1使用「默認」包
當類沒有包含聲明package時，它被認爲處於default package下。一般不推薦使用default package，並應該避免使用它。由於對於使用@ComponentScan，@EntityScan或@SpringBootApplication註解的Spring Boot應用來講，來自每一個jar的類都會被讀取，這會形成必定的問題。
注：咱們建議你遵循Java的推薦的包命名規範，使用一個反轉的域名（例如com.example.project）。
3.2.2定位主應用類
咱們一般建議你將主要應用類放在位於其餘類上面的根包（root package）中。一般使用@EnableAutoConfiguration註解你的主類，而且暗地裏爲某些項定義了一個基礎「 search package」。例如，若是你正在編寫一個JPA應用，被EnableAutoConfiguration註解的類所在包將被用來搜索@Entity項。
根使用包網求容許你使用@ComponentScan註解而不須要定義一個basePackage屬性。若是主類位於根包中，也。你能夠使用@SpringBootApplication註解。
下面是一個典型的結構：
com
+- example
+- myproject
+- Application.java
| +- domain | +- Customer.java | +- CustomerRepository.java | +- service | +- CustomerService.java | +- web +- CustomerController.java
Application.java文件將聲明的主要方法，還有基本的@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); } }
3.3配置類
Spring Boot提倡基於Java的配置。儘管你能夠使用一個XML源來調用SpringApplication.run()，咱們一般建議你使用@Configuration類做爲主要源。通常定義主方法的類也是主要@Configuration的一個很好候選。
注：不少使用XML配置的春天配置示例已經被髮布到網絡上你應該老是儘量的使用基於Java的的配置搜索查看。enable*註解就是一個好的開端。
3.3.1導入其餘配置類
不須要你將全部的@Configuration放進一個單獨的類。@Import註解能夠用來導入其餘配置類。另外，也。你能夠使用@ComponentScan註解自動收集全部的彈簧組件，包括@Configuration類。
3.3.2導入XML配置
若是你絕對須要使用基於XML的配置，建議咱們仍舊你從一個@Configuration類開始。能夠你使用附加的@ImportResource註解加載XML配置文件。
3.4自動配置
Spring Boot自動配置（auto-configuration）嘗試根據你添加的jar依賴自動配置你的Spring應用。例如，若是你的類路徑下存在HSQLDB，而且你沒有手動配置任何數據庫鏈接豆，那麼咱們將自動配置一個個存型（in-內存）數據庫。
能夠你經過將@EnableAutoConfiguration或@SpringBootApplication註解添加到一個@Configuration類上來選擇自動配置。
注：你只須要添加一個@EnableAutoConfiguration。咱們註解建議你將它添加到主@Configuration類上。
3.4.1逐步替換自動配置
自動配置是非侵佔性的，任什麼時候候你均可以定義本身的配置類來替換自動配置的特定部分例如，若是你添加本身的DataSource綠豆，默認的內嵌數據庫支持將不被考慮。
若是須要找出當前應用了哪些自動配置及應用的緣由，能夠你使用--debug開關啓動應用。這將會記錄一個自動配置的報告並輸出到控制檯。
3.4.2禁用特定的自動配置
若是發現應用了你不想要的特定自動配置類，你能夠使用@EnableAutoConfiguration註解的排除屬性來禁用它們。
import org.springframework.boot.autoconfigure.*; import org.springframework.boot.autoconfigure.jdbc.*; import org.springframework.context.annotation.*; @Configuration @EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class}) public class MyConfiguration { }
3.5 Spring Beans和依賴注入
你能夠自由地使用任何標準的Spring框架技術去定義beans和它們注入的依賴。簡單起見，咱們常用@ComponentScan註解搜索beans，並結合@Autowired構造器注入。
若是使用上面建議的結構組織代碼（將應用類放到根包下），你能夠添加@ComponentScan註解而不須要任何參數。你的全部應用程序組件（@Component, @Service, @Repository, @Controller等）將被自動註冊爲Spring Beans。
下面是一個@Service Bean的示例，它使用構建器注入獲取一個須要的RiskAssessor bean。
package com.example.service; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; @Service public class DatabaseAccountService implements AccountService { private final RiskAssessor riskAssessor; @Autowired public DatabaseAccountService(RiskAssessor riskAssessor) { this.riskAssessor = riskAssessor; } // ... }
注：注意如何使用構建器注入來容許riskAssessor字段被標記爲final，這意味着riskAssessor後續是不能改變的。
3.6 使用@SpringBootApplication註解
不少Spring Boot開發者老是使用@Configuration，@EnableAutoConfiguration和@ComponentScan註解他們的main類。因爲這些註解被如此頻繁地一塊使用（特別是你遵循以上最佳實踐時），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); } }
3.7 運行應用程序
將應用打包成jar並使用一個內嵌HTTP服務器的一個最大好處是，你能夠像其餘方式那樣運行你的應用程序。調試Spring Boot應用也很簡單；你不須要任何特殊IDE或擴展。
注：本章節只覆蓋基於jar的打包，若是選擇將應用打包成war文件，你最好參考一下服務器和IDE文檔。
3.7.1 從IDE中運行
你能夠從IDE中運行Spring Boot應用，就像一個簡單的Java應用，可是，你首先須要導入項目。導入步驟跟你的IDE和構建系統有關。大多數IDEs可以直接導入Maven項目，例如Eclipse用戶能夠選擇File菜單的Import… --> Existing Maven Projects。
若是不能直接將項目導入IDE，你能夠須要使用構建系統生成IDE元數據。Maven有針對Eclipse和IDEA的插件；Gradle爲各類IDEs提供插件。
注：若是意外地運行一個web應用兩次，你將看到一個"端口已在使用中"錯誤。爲了確保任何存在的實例是關閉的，STS用戶能夠使用Relaunch按鈕而不是Run按鈕。
3.7.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
3.7.3 使用Maven插件運行
Spring Boot Maven插件包含一個run目標，它能夠用來快速編譯和運行應用程序。應用程序以一種暴露的方式運行，因爲即時"熱"加載，你能夠編輯資源。
$ mvn spring-boot:run
你可能想使用有用的操做系統環境變量：
$ export MAVEN_OPTS=-Xmx1024m -XX:MaxPermSize=128M -Djava.security.egd=file:/dev/./urandom
("egd"設置是經過爲Tomcat提供一個更快的會話keys熵源來加速Tomcat的。)
3.7.4 使用Gradle插件運行
Spring Boot Gradle插件也包含一個run目標，它能夠用來以暴露的方式運行你的應用程序。無論你何時導入spring-boot-plugin，bootRun任務老是被添加進去。
$ gradle bootRun
你可能想使用那些有用的操做系統環境變量：
$ export JAVA_OPTS=-Xmx1024m -XX:MaxPermSize=128M -Djava.security.egd=file:/dev/./urandom
3.7.5 熱交換
因爲Spring Boot應用程序只是普通的Java應用，那JVM熱交換（hot-swapping）應該能出色的工做.JVM熱交換在它能替換的字節碼上有些限制，更全面的解決方案能夠使用Spring Loaded項目或JRebel。
關於熱交換能夠參考「如何作」的相應章節。
3.8打包用於生產的應用程序
可執行罐可用於生產部署。因爲它們是自包含的，很是適合基於雲的部署。關於其餘「生產準備」的特性，好比健康監控，審計和指標REST，或JMX端點，能夠考慮添加春季啓動-actuator。具體參考第五部分，「彈簧啓動執行器：生產就緒功能」。
Spring Boot特性
4.1 SpringApplication
SpringApplication類提供了一種從主（）方法啓動春季應用的便捷方式在不少狀況下，你只需委託給SpringApplication.run這個靜態方法：
public static void main(String[] args){ SpringApplication.run(MySpringConfiguration.class, args); }
當應用啓動時，你應該會看到相似下面的東西（這是何方神獸??）：
. ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ \\/ ___)| |_)| | | | | || (_| | ) ) ) ) ' |____| .__|_| |_|_| |_\__, | / / / / =========|_|==============|___/=/_/_/_/ :: Spring Boot :: v1.2.2.BUILD-SNAPSHOT 2013-07-31 00:08:16.117 INFO 56603 --- [ main] o.s.b.s.app.SampleApplication : Starting SampleApplication v0.1.0 on mycomputer with PID 56603 (/apps/myapp.jar started by pwebb) 2013-07-31 00:08:16.166 INFO 56603 --- [ main] 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
默認狀況下會顯示INFO級別的日誌信息，包括一些相關的啓動詳情，好比啓動應用的用戶等。
4.1.1自定義Banner
經過在類路徑下添加一個banner.txt或設置banner.location來指定相應的文件能夠改變啓動過程當中打印的橫幅。若是這個文件有特殊的編碼，你能夠使用banner.encoding設置它（默認爲UTF-8 ）。
在banner.txt中能夠使用以下的變量：
| 變量 | 描述 |
|---|---|
| $ {} application.version | MANIFEST.MF中聲明的應用版本號，例如1.0 |
| $ {application.formatted版本} | MANIFEST.MF中聲明的被格式化後的應用版本號（被括號包裹且以v做爲前綴），用於顯示，例如（V1.0） |
| $ {彈簧boot.version} | 正在使用的Spring Boot版本號，例如1.2.2.BUILD-SNAPSHOT |
| $ {彈簧boot.formatted版本} | 正在使用的Spring Boot被格式化後的版本號（被括號包裹且以v做爲前綴），用於顯示，例如（v1.2.2.BUILD-SNAPSHOT） |
注：若是想以編程的方式產生一個條幅，能夠使用SpringBootApplication.setBanner（...）方法使用org.springframework.boot.Banner接口，實現你本身的printBanner（）方法。
4.1.2自定義SpringApplication
若是默認的SpringApplication不符合你的口味，你能夠建立一個本地的實例並自定義它例如，關閉旗幟你能夠這樣寫：
public static void main(String[] args){ SpringApplication app = new SpringApplication(MySpringConfiguration.class); app.setShowBanner(false); app.run(args); }
注：傳遞給SpringApplication的構造器參數是spring beans的配置源。在大多數狀況下，這些將是@Configuration類的引用，但它們也多是XML配置或要掃描包的引用。
你也能夠使用application.properties文件來配置SpringApplication。具體參考外化配置。查看配置選項的完整列表，可參考SpringApplication Javadoc。
4.1.3流暢的構建API
若是你須要建立一個分層的ApplicationContext的（多個具備父子關係的上下文），或你只是喜歡使用流暢的構建API，你能夠使用SpringApplicationBuilder.SpringApplicationBuilder容許你以鏈式方式調用多個方法，包括能夠建立層次結構的父母和孩子方法。
new SpringApplicationBuilder() .showBanner(false) .sources(Parent.class) .child(Application.class) .run(args);
注：建立ApplicationContext層次時有些限制，好比，Web組件（組件）必須包含在子上下文（子上下文）中，且相同的環境即用於父上下文也用於子上下文中。具體參考SpringApplicationBuilder javadoc
4.1.4應用事件和監聽器
除了常見的彈簧框架事件，好比ContextRefreshedEvent，一個SpringApplication也發送一些額外的應用事件。一些事件其實是在ApplicationContext中被建立前觸發的。
你能夠使用多種方式註冊事件監聽器，最普通的是使用SpringApplication.addListeners（...）方法在你的應用運行時，應用事件會如下面的次序發送：
- 在運行開始，但除了監聽器註冊和初始化之外的任何處理以前，會發送一個ApplicationStartedEvent。
- 在環境將被用於已知的上下文，但在上下文被建立前，會發送一個ApplicationEnvironmentPreparedEvent。
- 在刷新開始前，但在豆定義已被加載後，會發送一個ApplicationPreparedEvent。
- 啓動過程當中若是出現異常，會發送一個ApplicationFailedEvent。
注：你一般不須要使用應用程序事件，但知道它們的存在會很方便（在某些場合可能會使用到）。在Spring內部，Spring Boot使用事件處理各類各樣的任務。
4.1.5網絡環境
一個SpringApplication將嘗試爲你建立正確類型的ApplicationContext中。在默認狀況下，使用AnnotationConfigApplicationContext或AnnotationConfigEmbeddedWebApplicationContext取決於你正在開發的是不是網頁應用。
用於肯定一個web環境的算法至關簡單（基因而否存在某些類）。若是須要覆蓋默認行爲，你能夠使用setWebEnvironment（boolean webEnvironment）。經過調用setApplicationContextClass（...），你能夠徹底控制ApplicationContext的類型。
注：當JUnit的測試裏使用SpringApplication時，調用setWebEnvironment（假）是可取的。
4.1.6命令行啓動器
若是你想獲取原始的命令行參數，或一旦SpringApplication啓動，你須要運行一些特定的代碼，你能夠實現CommandLineRunner接口。在全部實現該接口的Spring beans上將調用run（String ... args）方法。
import org.springframework.boot.* import org.springframework.stereotype.* @Component public class MyBean implements CommandLineRunner { public void run(String... args) { // Do something... } }
若是一些CommandLineRunner beans被定義必須以特定的次序調用，你能夠額外實現org.springframework.core.Ordered接口或使用org.springframework.core.annotation.Order註解。
4.1.7申請退出
每一個SpringApplication在退出時爲了確保ApplicationContext被優雅的關閉，將會註冊一個JVM的shutdown鉤子。全部標準的Spring生命週期回調（好比，DisposableBean接口或@PreDestroy註解）都能使用。
此外，若是beans想在應用結束時返回一個特定的退出碼（exit code），能夠實現org.springframework.boot.ExitCodeGenerator接口。
4.2 外化配置
Spring Boot容許外化（externalize）你的配置，這樣你可以在不一樣的環境下使用相同的代碼。你能夠使用properties文件，YAML文件，環境變量和命令行參數來外化配置。使用@Value註解，能夠直接將屬性值注入到你的beans中，並經過Spring的Environment抽象或綁定到結構化對象來訪問。
Spring Boot使用一個很是特別的PropertySource次序來容許對值進行合理的覆蓋，須要如下面的次序考慮屬性：
- 命令行參數
- 來自於java:comp/env的JNDI屬性
- Java系統屬性（System.getProperties()）
- 操做系統環境變量
- 只有在random.*裏包含的屬性會產生一個RandomValuePropertySource
- 在打包的jar外的應用程序配置文件（application.properties，包含YAML和profile變量）
- 在打包的jar內的應用程序配置文件（application.properties，包含YAML和profile變量）
- 在@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; // ... }
你能夠將一個application.properties文件捆綁到罐子內，用來提供一個合理的默認名稱屬性值。當運行在生產環境時，能夠在罐子外提供一個application.properties文件來覆蓋名稱屬性。對於一次性的測試，你能夠使用特定的命令行開關啓動（好比，java -jar app.jar --name =「Spring」）。
4.2.1配置隨機值
RandomValuePropertySource在注入隨機值（好比，密鑰或測試用例）時頗有用它能產生整數，多頭或字符串，好比：
my.secret=${random.value}
my.number=${random.int} my.bignumber=${random.long} 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是整數。若是提供max，那麼值是最小的值，max是最大的值（不包含在內）。
4.2.2訪問命令行屬性
默認狀況下，SpringApplication將任何可選的命令行參數（以' - '開頭，好比， - server.port = 9000）轉化爲屬性，並將其添加到Spring Environment中。如上所述，命令行屬性老是優先於其餘屬性源。
若是你不想將命令行屬性添加到環境裏，你能夠使用SpringApplication.setAddCommandLineProperties（假）來禁止它們。
4.2.3應用屬性文件
SpringApplication將從如下位置加載application.properties文件，並把它們添加到Spring Environment中：
- 當前目錄下的一個/配置子目錄
- 當前目錄
- 一個類路徑下的/配置包
- 類路徑根路徑（根）
這個列表是按優先級排序的（列表中位置高的將覆蓋位置低的）。
注：你能夠使用YAML（」。YML '）文件替代' 的.properties'。
若是不喜歡將application.properties做爲配置文件名，你能夠經過指定spring.config.name環境屬性來切換其餘的名稱。你也能夠使用spring.config.location環境屬性來引用一個明確的路徑（目錄位置或文件路徑列表以逗號分割）。
$ java -jar myproject.jar --spring.config.name=myproject
//or $ java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties
若是spring.config.location包含目錄（相對於文件），那它們應該以/結尾（在加載前，spring.config.name產生的名稱將被追加到後面）。無論spring.config.location是什麼值，默認的搜索路徑類路徑：，類路徑：/配置，文件：，文件：配置/總會被使用以這種方式，你能夠在application.properties中爲應用設置默認值，而後在運行的時候使用不一樣的文件覆蓋它，同時保留默認配置。
注：若是你使用環境變量而不是系統配置，大多數操做系統不容許以句號分割（句點分隔）的鍵名稱，但你能夠使用下劃線（下劃線）代替（好比，使用SPRING_CONFIG_NAME代替spring.config.name ）若是你的應用運行在一個容器中，那麼JNDI屬性（的java：comp / env的）或小服務程序上下文初始化參數能夠用來取代環境變量或系統屬性，固然也能夠使用環境變量或系統屬性。
4.2.4特定的Profile屬性
除了application.properties文件，特定配置屬性也能經過命令慣例應用 - {輪廓}的.properties來定義。特定資料屬性從跟標準application.properties相同的路徑加載，而且特定輪廓文件會覆蓋默認的配置。
4.2.5屬性佔位符
當application.properties裏的值被使用時，它們會被存在的環境過濾，因此你可以引用先前定義的值（好比，系統屬性）。
app.name=MyApp
app.description=${app.name} is a Spring Boot application
注：你也能使用相應的技巧爲存在的Spring Boot屬性建立'短'變量，具體參考Section 63.3, 「Use ‘short’ command line arguments」。
4.2.6 使用YAML代替Properties
YAML是JSON的一個超集，也是一種方便的定義層次配置數據的格式。不管你什麼時候將SnakeYAML 庫放到classpath下，SpringApplication類都會自動支持YAML做爲properties的替換。
注：若是你使用'starter POMs'，spring-boot-starter會自動提供SnakeYAML。
4.2.6.1 加載YAML
Spring框架提供兩個便利的類用於加載YAML文檔，YamlPropertiesFactoryBean會將YAML做爲Properties來加載，YamlMapFactoryBean會將YAML做爲Map來加載。
示例：
environments:
dev:
url: http://dev.bar.com name: Developer Setup prod: url: http://foo.bar.com name: My Cool App
上面的YAML文檔會被轉化到下面的屬性中：
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]間接引用做爲屬性keys的形式，例以下面的YAML：
my: servers: - dev.bar.com - foo.bar.com
將會轉化到下面的屬性中:
my.servers[0]=dev.bar.com my.servers[1]=foo.bar.com
使用Spring DataBinder工具綁定那樣的屬性（這是@ConfigurationProperties作的事），你須要肯定目標bean中有個java.util.List或Set類型的屬性，而且須要提供一個setter或使用可變的值初始化它，好比，下面的代碼將綁定上面的屬性：
@ConfigurationProperties(prefix="my") public class Config { private List<String> servers = new ArrayList<String>(); public List<String> getServers() { return this.servers; } }
4.2.6.2 在Spring環境中使用YAML暴露屬性
YamlPropertySourceLoader類可以用於將YAML做爲一個PropertySource導出到Sprig Environment。這容許你使用熟悉的@Value註解和佔位符語法訪問YAML屬性。
4.2.6.3多配置文件YAML文檔
你能夠在單個文件中定義多個特定配置（profile-specific）的YAML文檔，並經過一個spring.profiles key標示應用的文檔。例如：
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。
4.2.6.4 YAML缺點
YAML文件不能經過@PropertySource註解加載。因此，在這種狀況下，若是須要使用@PropertySource註解的方式加載值，那就要使用的屬性文件。
4.2.7類型安全的配置屬性
使用@Value（「$ {property}」）註解注入配置屬性有時可能比較笨重，特別是須要使用多個屬性或你的數據自己有層次結構。爲了控制和校驗你的應用配置，Spring Boot提供一個容許強類型豆的替代方法來使用性質。
示例：
@Component @ConfigurationProperties(prefix="connection") public class ConnectionSettings { private String username; private InetAddress remoteAddress; // ... getters and setters }
當@EnableConfigurationProperties註解應用到你的@Configuration時，任何被@ConfigurationProperties註解的豆類將自動被環境屬性配置。這種風格的配置特別適合與SpringApplication的外部YAML配置進行配合使用。
# application.yml connection: username: admin remoteAddress: 192.168.1.1 # additional configuration as required
爲了使用@ConfigurationProperties豆，你能夠使用與其餘任何bean相同的方式注入它們。
@Service public class MyService { @Autowired private ConnectionSettings connection; //... @PostConstruct public void openConnection() { Server server = new Server(); this.connection.configure(server); } }
你能夠經過@EnableConfigurationProperties註解中直接簡單的列出屬性類來快捷的註冊@ConfigurationProperties bean的定義。
@Configuration @EnableConfigurationProperties(ConnectionSettings.class) public class MyConfiguration { }
注：使用@ConfigurationProperties可以產生可被IDEs使用的元數據文件。具體參考附錄B，配置元數據。
4.2.7.1第三方配置
正如使用@ConfigurationProperties註解一個類，你也能夠在@Bean方法上使用它。當你須要綁定屬性到不受你控制的第三方組件時，這種方式很是有用。
爲了從環境屬性配置一個豆，將@ConfigurationProperties添加到它的豆註冊過程：
@ConfigurationProperties(prefix = "foo") @Bean public FooComponent fooComponent() { ... }
和上面ConnectionSettings的示例方式相同，任何以富爲前綴的屬性定義都會被映射到FooComponent上。
4.2.7.2鬆散的綁定（輕鬆綁定）
Spring Boot使用一些寬鬆的規則用於綁定環境屬性到@ConfigurationProperties beans，因此環境屬性名和豆屬性名不須要精確匹配。常見的示例中有用的包括虛線分割（好比，context - path綁定到contextPath ）和將環境屬性轉爲大寫字母（好比，PORT綁定端口）。
示例：
@Component @ConfigurationProperties(prefix="person") public class ConnectionSettings { private String firstName; }
下面的屬性名都能用於上面的@ConfigurationProperties類：
| 屬性 | 說明 |
|---|---|
| person.firstName | 標準駝峯規則 |
| person.first名 | 虛線表示，推薦用於的.properties和.yml文件中 |
| PERSON_FIRST_NAME | 大寫形式，使用系統環境變量時推薦 |
Spring會嘗試強制外部的應用屬性在綁定到@ConfigurationProperties beans時類型是正確的。若是須要自定義類型轉換，你能夠提供一個ConversionService bean（bean id爲conversionService）或自定義屬性編輯器（經過一個CustomEditorConfigurer豆）。
4.2.7.3 @ConfigurationProperties校驗
Spring Boot將嘗試校驗外部的配置，默認使用JSR-303（若是在類路徑路徑中）。你能夠輕鬆的爲你的@ConfigurationProperties類添加JSR-303 javax.validation約束註解：
@Component @ConfigurationProperties(prefix="connection") public class ConnectionSettings { @NotNull private InetAddress remoteAddress; // ... getters and setters }
你也能夠經過建立一個叫作configurationPropertiesValidator的bean來添加自定義的Spring Validator。
注：spring-boot-actuator模塊包含一個暴露全部@ConfigurationProperties beans的端點。簡單地將你的web瀏覽器指向/ configprops或使用等效的JMX端點。具體參考生產就緒功能。
4.3配置文件
Spring Profiles提供了一種隔離應用程序配置的方式，並讓這些配置只能在特定的環境下生效。任何@Component或@Configuration都能被@Profile標記，從而限制加載它的時機。
@Configuration @Profile("production") public class ProductionConfiguration { // ... }
以正常的春天方式，你能夠使用一個spring.profiles.active的環境屬性來指定哪一個配置生效你能夠使用日常的任何方式來指定該屬性，例如，能夠將它包含到你的application.properties中：
spring.profiles.active=dev,hsqldb
或使用命令行開關：
--spring.profiles.active=dev,hsqldb
4.3.1添加激活的配置（profiles）
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
注：spring.profiles屬性能夠定義到一個YAML文檔中，用於決定何時該文檔被包含進配置中。具體參考第63.6節「根據環境改變配置」
4.3.2以編程方式設置profile
在應用運行前，你能夠經過調用SpringApplication.setAdditionalProfiles（...）方法，以編程的方式設置生效的配置。使用彈簧的ConfigurableEnvironment接口激動配置也是可行的。
4.3.3 Profile特定配置文件
application.properties（或application.yml）和經過@ConfigurationProperties引用的文件這兩種配置特定變種都被看成文件來加載的，具體參考第23.3節「特定於配置文件的屬性」。
4。5日誌
Spring Boot內部日誌系統使用的是Commons Logging，但開放底層的日誌實現。默認爲會Java Util Logging，Log4J，Log4J2和Logback提供配置。每種狀況下都會預先配置使用控制檯輸出，也能夠使用可選的文件輸出。
默認狀況下，若是你使用'Starter POM'，那麼就會使用Logback記錄日誌。爲了確保那些使用Java Util Logging，Commons Logging，Log4J或SLF4J的依賴庫可以正常工做，正確的Logback路由也被包含進來。
注：若是上面的列表看起來使人困惑，不要擔憂，Java有不少可用的日誌框架。一般，你不須要改變日誌依賴，Spring Boot默認的就能很好的工做。
4。4。1日誌格式
Spring Boot默認的日誌輸出格式以下：
2014-03-05 10:57:51.112 INFO 45469 --- [ main] org.apache.catalina.core.StandardEngine : Starting Servlet Engine: Apache Tomcat/7.0.52
2014-03-05 10:57:51.253 INFO 45469 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/] : Initializing Spring embedded WebApplicationContext
2014-03-05 10:57:51.253 INFO 45469 --- [ost-startStop-1] o.s.web.context.ContextLoader : Root WebApplicationContext: initialization completed in 1358 ms 2014-03-05 10:57:51.698 INFO 45469 --- [ost-startStop-1] o.s.b.c.e.ServletRegistrationBean : Mapping servlet: 'dispatcherServlet' to [/] 2014-03-05 10:57:51.702 INFO 45469 --- [ost-startStop-1] o.s.b.c.embedded.FilterRegistrationBean : Mapping filter: 'hiddenHttpMethodFilter' to: [/*]
輸出的節點（項目）以下：
- 日期和時間 - 精確到毫秒，且易於排序。
- 日誌級別 - 錯誤，警告，信息，調查或追蹤。
- 進程ID。
- 一個用於區分實際日誌信息開頭的---分隔符。
- 線程名 - 包括在方括號中（控制檯輸出可能會被截斷）。
- 日誌名 - 一般是源類的類名（縮寫）。
- 日誌信息。
4.4.2控制檯輸出
默認的日誌配置會在寫日誌消息時將它們回顯到控制檯。默認，ERROR, WARN和INFO級別的消息會被記錄。能夠在啓動應用時，經過--debug標識開啓控制檯的DEBUG級別日誌記錄。
$ java -jar myapp.jar --debug
若是你的終端支持ANSI，爲了增長可讀性將會使用彩色的日誌輸出。你能夠設置spring.output.ansi.enabled爲一個支持的值來覆蓋自動檢測。
4.4.3 文件輸出
默認狀況下，Spring Boot只會將日誌記錄到控制檯而不會寫進日誌文件。若是除了輸出到控制檯你還想寫入到日誌文件，那你須要設置logging.file或logging.path屬性（例如在你的application.properties中）。
下表顯示如何組合使用logging.*：
| logging.file | logging.path | 示例 | 描述 |
|---|---|---|---|
| (none) | (none) | 只記錄到控制檯 | |
| Specific file | (none) | my.log | 寫到特定的日誌文件裏，名稱能夠是一個精確的位置或相對於當前目錄 |
| (none) | Specific folder | /var/log | 寫到特定文件夾下的spring.log裏，名稱能夠是一個精確的位置或相對於當前目錄 |
日誌文件每達到10M就會被輪換（分割），和控制檯同樣，默認記錄ERROR, WARN和INFO級別的信息。
4.4.4 日誌級別
全部支持的日誌系統在Spring的Environment（例如在application.properties裏）都有經過'logging.level.*=LEVEL'（'LEVEL'是TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF中的一個）設置的日誌級別。
示例：application.properties
logging.level.org.springframework.web: DEBUG logging.level.org.hibernate: ERROR
4.4.5 自定義日誌配置
經過將適當的庫添加到classpath，能夠激活各類日誌系統。而後在classpath的根目錄(root)或經過Spring Environment的logging.config屬性指定的位置提供一個合適的配置文件來達到進一步的定製（注意因爲日誌是在ApplicationContext被建立以前初始化的，因此不可能在Spring的@Configuration文件中，經過@PropertySources控制日誌。系統屬性和日常的Spring Boot外部配置文件能正常工做）。
根據你的日誌系統，下面的文件會被加載：
| 日誌系統 | 定製 |
|---|---|
| Logback | logback.xml |
| Log4j | log4j.properties或log4j.xml |
| Log4j2 | log4j2.xml |
| JDK (Java Util Logging) | logging.properties |
爲了幫助定製一些其餘的屬性，從Spring的Envrionment轉換到系統屬性：
| Spring Environment | System Property | 評價 |
|---|---|---|
| logging.file | LOG_FILE | 若是定義，在默認的日誌配置中使用 |
| logging.path | LOG_PATH | 若是定義，在默認的日誌配置中使用 |
| PID | PID | 當前的處理進程(process)ID（若是可以被發現且尚未做爲操做系統環境變量被定義） |
全部支持的日誌系統在解析它們的配置文件時都能查詢系統屬性。具體能夠參考spring-boot.jar中的默認配置。
注：在運行可執行的jar時，Java Util Logging有類加載問題，咱們建議你儘量避免使用它。
4.5 開發web應用
Spring Boot很是適合開發web應用程序。你能夠使用內嵌的Tomcat，Jetty或Undertow輕輕鬆鬆地建立一個HTTP服務器。大多數的web應用都使用spring-boot-starter-web模塊進行快速搭建和運行。
4.5.1 Spring Web MVC 框架
Spring Web MVC框架（一般簡稱爲「Spring MVC」）是一個個「模型，視圖，控制器」的web框架.Spring MVC容許你建立特定的@Controller或@RestController beans來處理傳入的HTTP請求。使用@RequestMapping註解能夠將控制器中的方法映射到相應的HTTP請求。
示例：
@RestController @RequestMapping(value="/users") public class MyRestController { @RequestMapping(value="/{user}", method=RequestMethod.GET) public User getUser(@PathVariable Long user) { // ... } @RequestMapping(value="/{user}/customers", method=RequestMethod.GET) List<Customer> getUserCustomers(@PathVariable Long user) { // ... } @RequestMapping(value="/{user}", method=RequestMethod.DELETE) public User deleteUser(@PathVariable Long user) { // ... } }
4.5.1.1 Spring MVC自動配置
Spring Boot爲Spring MVC提供適用於多數應用的自動配置功能。在Spring默認基礎上，自動配置添加了如下特性：
- 引入ContentNegotiatingViewResolver和BeanNameViewResolver bean。
- 對靜態資源的支持，包括對WebJars的支持。
- 自動註冊Converter，GenericConverter，Formatter beans。
- 對HttpMessageConverters的支持。
- 自動註冊MessageCodeResolver。
- 對靜態的index.html的支持。
- 對自定義網站圖標的支持。
若是想全面控制Spring MVC，你能夠添加本身的@Configuration，並使用@EnableWebMvc對其註解。若是想保留Spring Boot MVC的特性，而且只是添添其餘的MVC配置（攔截器，formatters，視圖控制器等） ，你能夠添加本身的WebMvcConfigurerAdapter類型的@Bean（不使用@EnableWebMvc註解）。
4.5.1.2 HttpMessageConverters
Spring MVC使用HttpMessageConverter接口轉換HTTP請求和響應。合理的缺省值被包含的恰到好處（開箱即用），例如對象能夠自動轉換爲JSON（使用Jackson庫）或XML（若是Jackson XML擴展可用則使用它，不然使用JAXB）。字符串默認使用UTF-8編碼。
若是須要添加或自定義轉換器，你能夠使用Spring Boot的HttpMessageConverters類：
import org.springframework.boot.autoconfigure.web.HttpMessageConverters; import org.springframework.context.annotation.*; import org.springframework.http.converter.*; @Configuration public class MyConfiguration { @Bean public HttpMessageConverters customConverters() { HttpMessageConverter<?> additional = ... HttpMessageConverter<?> another = ... return new HttpMessageConverters(additional, another); } }
任何在上下文中出現的HttpMessageConverter bean將會添加到轉換器列表，你能夠經過這種方式覆蓋默認的轉換器（轉換器）。
4.5.1.3 MessageCodesResolver
Spring MVC有一個策略，用於從綁定的錯誤產生用來渲染錯誤信息的錯誤碼：MessageCodesResolver。若是設置spring.mvc.message-codes-resolver.format屬性爲PREFIX_ERROR_CODE或POSTFIX_ERROR_CODE（具體查看DefaultMessageCodesResolver.Format枚舉值），Spring Boot會爲你建立一個MessageCodesResolver。
4.5.1.4靜態內容
默認狀況下，Spring Boot從類路徑下一個叫/ static（/ public，/ resources或/ META-INF / resources）的文件夾或從ServletContext根目錄提供靜態內容。這使用了Spring MVC的ResourceHttpRequestHandler，因此你能夠經過添加本身的WebMvcConfigurerAdapter並覆寫addResourceHandlers方法來改變這個行爲（加載靜態文件）。
在一個單獨的網絡應用中，容器默認的servlet的是開啓的，若是春節決定不處理某些請求，默認的servlet的做爲一個回退（降級）將從ServletContext的根目錄加載內容。大多數時候，這不會發生（除非你修改默認的MVC配置），由於春季總可以經過的DispatcherServlet處理請求。
此外，上述標準的靜態資源位置有個例外狀況是Webjars內容。任何在/ webjars / **路徑下的資源都將從罐文件中提供，只要它們以Webjars的格式打包。
注：若是你的應用將被打包成JAR，那就不要使用的src / main / webapp的文件夾儘管該文件夾是一個共同的標準，但它僅在打包成戰爭的狀況下起做用，而且若是產生一個罈子，多數構建工具都會靜悄悄的忽略它。
4.5.1.5模板引擎
正如REST Web服務，你也能夠使用Spring MVC提供動態HTML內容.Spring MVC支持各類各樣的模板技術，包括Velocity，FreeMarker和JSPs。不少其餘的模板引擎也提供它們本身的Spring MVC集成。
Spring Boot爲如下的模板引擎提供自動配置支持：
注：若是可能的話，應該忽略的JSP，由於在內嵌的servlet的使用容器時它們存在一些已知的限制。
當你使用這些引擎的任何一種，並採用默認的配置，你的模板將會從SRC /主/資源/模板目錄下自動加載。
注：IntelliJ IDEA根據你運行應用的方式會對classpath進行不一樣的整理。在IDE裏經過主方法運行你的應用跟從Maven或Gradle或打包好的jar中運行相比會致使不一樣的順序。這可能致使Spring Boot不能從類路徑下成功地找到模板。若是遇到這個問題，你能夠在IDE裏從新對類路徑進行排序，將模塊的類和資源放到第一位。或者，你能夠配置模塊的前綴爲classpath *：/模板/，這樣會查找類路徑下的全部模板目錄。
4.5.1.6錯誤處理
Spring Boot默認提供一個/error映射用來以合適的方式處理全部的錯誤，而且它在servlet容器中註冊了一個全局的 錯誤頁面。對於機器客戶端（相對於瀏覽器而言，瀏覽器偏重於人的行爲），它會產生一個具備詳細錯誤，HTTP狀態，異常信息的JSON響應。對於瀏覽器客戶端，它會產生一個白色標籤樣式（whitelabel）的錯誤視圖，該視圖將以HTML格式顯示一樣的數據（能夠添加一個解析爲erro的View來自定義它）。爲了徹底替換默認的行爲，你能夠實現ErrorController，並註冊一個該類型的bean定義，或簡單地添加一個ErrorAttributes類型的bean以使用現存的機制，只是替換顯示的內容。
若是在某些條件下須要比較多的錯誤頁面，內嵌的servlet容器提供了一個統一的Java DSL（領域特定語言）來自定義錯誤處理。 示例：
@Bean public EmbeddedServletContainerCustomizer containerCustomizer(){ return new MyCustomizer(); } // ... private static class MyCustomizer implements EmbeddedServletContainerCustomizer { @Override public void customize(ConfigurableEmbeddedServletContainer container) { container.addErrorPages(new ErrorPage(HttpStatus.BAD_REQUEST, "/400")); } }
你也能夠使用常規的Spring MVC特性來處理錯誤，好比@ExceptionHandler方法和@ControllerAdvice。ErrorController將會撿起任何沒有處理的異常。
N.B. 若是你爲一個路徑註冊一個ErrorPage，最終被一個過濾器（Filter）處理（對於一些非Spring web框架，像Jersey和Wicket這很常見），而後過濾器須要顯式註冊爲一個ERROR分發器（dispatcher）。
@Bean public FilterRegistrationBean myFilter() { FilterRegistrationBean registration = new FilterRegistrationBean(); registration.setFilter(new MyFilter()); ... registration.setDispatcherTypes(EnumSet.allOf(DispatcherType.class)); return registration; }
注：默認的FilterRegistrationBean沒有包含ERROR分發器類型。
4.5.1.7 Spring HATEOAS
若是你正在開發一個使用超媒體的RESTful API，Spring Boot將爲Spring HATEOAS提供自動配置，這在多數應用中都工做良好。自動配置替換了對使用@EnableHypermediaSupport的需求，並註冊必定數量的beans來簡化構建基於超媒體的應用，這些beans包括一個LinkDiscoverer和配置好的用於將響應正確編排爲想要的表示的ObjectMapper。ObjectMapper能夠根據spring.jackson.*屬性或一個存在的Jackson2ObjectMapperBuilder bean進行自定義。
經過使用@EnableHypermediaSupport，你能夠控制Spring HATEOAS的配置。注意這會禁用上述的對ObjectMapper的自定義。
4.5.2 JAX-RS和Jersey
若是喜歡JAX-RS爲REST端點提供的編程模型，你能夠使用可用的實現替代Spring MVC。若是在你的應用上下文中將Jersey 1.x和Apache Celtix的Servlet或Filter註冊爲一個@Bean，那它們工做的至關好。Jersey 2.x有一些原生的Spring支持，因此咱們會在Spring Boot爲它提供自動配置支持，連同一個啓動器（starter）。
想要開始使用Jersey 2.x只須要加入spring-boot-starter-jersey依賴，而後你須要一個ResourceConfig類型的@Bean，用於註冊全部的端點（endpoints）。
@Component public class JerseyConfig extends ResourceConfig { public JerseyConfig() { register(Endpoint.class); } }
全部註冊的端點都應該被@Components和HTTP資源annotations（好比@GET）註解。
@Component @Path("/hello") public class Endpoint { @GET public String message() { return "Hello"; } }
因爲Endpoint是一個Spring組件（@Component），因此它的生命週期受Spring管理，而且你能夠使用@Autowired添加依賴及使用@Value注入外部配置。Jersey servlet將被註冊，並默認映射到/*。你能夠將@ApplicationPath添加到ResourceConfig來改變該映射。
默認狀況下，Jersey將在一個ServletRegistrationBean類型的@Bean中被設置成名稱爲jerseyServletRegistration的Servlet。經過建立本身的相同名稱的bean，你能夠禁止或覆蓋這個bean。你也能夠經過設置spring.jersey.type=filter來使用一個Filter代替Servlet（在這種狀況下，被覆蓋或替換的@Bean是jerseyFilterRegistration）。該servlet有@Order屬性，你能夠經過spring.jersey.filter.order進行設置。無論是Servlet仍是Filter註冊均可以使用spring.jersey.init.*定義一個屬性集合做爲初始化參數傳遞過去。
這裏有一個Jersey示例，你能夠查看如何設置相關事項。
4.5.3 內嵌servlet容器支持
Spring Boot支持內嵌的Tomcat, Jetty和Undertow服務器。多數開發者只須要使用合適的'Starter POM'來獲取一個徹底配置好的實例便可。默認狀況下，內嵌的服務器會在8080端口監聽HTTP請求。
4.5.3.1 Servlets和Filters
當使用內嵌的servlet容器時，你能夠直接將servlet和filter註冊爲Spring的beans。在配置期間，若是你想引用來自application.properties的值，這是很是方便的。默認狀況下，若是上下文只包含單一的Servlet，那它將被映射到根路徑（/）。在多Servlet beans的狀況下，bean的名稱將被用做路徑的前綴。過濾器會被映射到/*。
若是基於約定（convention-based）的映射不夠靈活，你能夠使用ServletRegistrationBean和FilterRegistrationBean類實現徹底的控制。若是你的bean實現了ServletContextInitializer接口，也能夠直接註冊它們。
4.5.3.2 EmbeddedWebApplicationContext
Spring Boot底層使用了一個新的ApplicationContext類型，用於對內嵌servlet容器的支持。EmbeddedWebApplicationContext是一個特殊類型的WebApplicationContext，它經過搜索一個單一的EmbeddedServletContainerFactory bean來啓動本身。一般，TomcatEmbeddedServletContainerFactory，JettyEmbeddedServletContainerFactory或UndertowEmbeddedServletContainerFactory將被自動配置。
注：你一般不須要知道這些實現類大多數應用將被自動配置，並根據你的行爲建立合適的ApplicationContext中和EmbeddedServletContainerFactory。
4.5.3.3自定義內嵌servlet容器
常見的Servlet容器設置能夠經過Spring Environment屬性進行配置。一般，你會把這些屬性定義到application.properties文件中。常見的服務器設置包括：
- server.port - 進來的HTTP請求的監聽端口號
- server.address - 綁定的接口地址
- server.sessionTimeout - session超時間
具體參考ServerProperties。
編程方式的自定義
若是須要以編程的方式配置內嵌的servlet容器，你能夠註冊一個實現EmbeddedServletContainerCustomizer接口的Spring bean.EmbeddedServletContainerCustomizer提供對ConfigurableEmbeddedServletContainer的訪問，ConfigurableEmbeddedServletContainer包含不少自定義的setter方法。
import org.springframework.boot.context.embedded.*; import org.springframework.stereotype.Component; @Component public class CustomizationBean implements EmbeddedServletContainerCustomizer { @Override public void customize(ConfigurableEmbeddedServletContainer container) { container.setPort(9000); } }
直接自定義ConfigurableEmbeddedServletContainer
若是上面的自定義手法過於受限，你能夠本身註冊TomcatEmbeddedServletContainerFactory，JettyEmbeddedServletContainerFactory或UndertowEmbeddedServletContainerFactory。
@Bean public EmbeddedServletContainerFactory servletContainer() { TomcatEmbeddedServletContainerFactory factory = new TomcatEmbeddedServletContainerFactory(); factory.setPort(9000); factory.setSessionTimeout(10, TimeUnit.MINUTES); factory.addErrorPages(new ErrorPage(HttpStatus.NOT_FOUND, "/notfound.html"); return factory; }
不少可選的配置都提供了二傳手方法，也提供了一些受保護的鉤子方法以知足你的某些特殊需求。具體參考相關文檔。
4.5.3.4 JSP的限制
在內嵌的servlet容器中運行一個Spring Boot應用時（並打包成一個可執行的存檔存檔），容器對JSP的支持有一些限制。
- tomcat的只支持戰爭的打包方式，不支持可執行的JAR。
- 內嵌的碼頭目前不支持的JSP。
- 暗潮不支持的JSP。
這裏有個JSP示例，你能夠查看如何設置相關事項。
4.6安全
若是Spring Security在classpath下，那麼web應用默認對全部的HTTP路徑（也稱爲終點，端點，表示API的具體網址）使用'basic'認證。爲了給web應用添加方法級別的保護，你能夠添加@ EnableGlobalMethodSecurity並使用想要的設置。其餘信息參考Spring Security Reference。
默認的的AuthenticationManager有一個單一的用戶（ '用戶' 的用戶名和隨機密碼會在應用啓動時以INFO日誌級別打印出來）以下：
Using default security password: 78fa095d-3f4c-48b1-ad50-e24c31d5cf35
注：若是你對日誌配置進行微調，確保org.springframework.boot.autoconfigure.security類別能記錄INFO信息，不然默認的密碼不會被打印。
你能夠經過提供security.user.password改變默認的密碼。這些和其餘有用的屬性經過SecurityProperties（以安爲爲前綴的屬性）被外部化了。
默認的安全配置（security configuration）是在SecurityAutoConfiguration和導入的類中實現的（SpringBootWebSecurityConfiguration用於web安全，AuthenticationManagerConfiguration用於與非web應用也相關的認證配置）。你能夠添加一個@EnableWebSecurity bean來完全關掉Spring Boot的默認配置。爲了對它進行自定義，你須要使用外部的屬性配置和WebSecurityConfigurerAdapter類型的beans（好比，添加基於表單的登錄）。在Spring Boot示例裏有一些安全相關的應用能夠帶你體驗常見的用例。
在一個web應用中你能獲得的基本特性以下：
一個使用內存存儲的AuthenticationManager bean和惟一的user（查看SecurityProperties.User獲取user的屬性）。
忽略（不保護）常見的靜態資源路徑（/css/, /js/, /images/**和 */favicon.ico）。
對其餘的路徑實施HTTP Basic安全保護。
安全相關的事件會發布到Spring的ApplicationEventPublisher（成功和失敗的認證，拒絕訪問）。
Spring Security提供的常見底層特性（HSTS, XSS, CSRF, 緩存）默認都被開啓。
上述全部特性都能打開和關閉，或使用外部的配置進行修改（security.）。爲了覆蓋訪問規則（access rules）而不改變其餘自動配置的特性，你能夠添加一個使用@Order(SecurityProperties.ACCESS_OVERRIDE_ORDER)註解的WebSecurityConfigurerAdapter類型的@Bean。
若是Actuator也在使用，你會發現：
即便應用路徑不受保護，被管理的路徑也會受到保護。
安全相關的事件被轉換爲AuditEvents時（審計事件），併發布給AuditService。
默認的用戶有ADMIN和USER的角色。
使用外部屬性可以修改致動器（執行器）的安全特性（management.security。*）。爲了覆蓋應用程序的訪問規則，你能夠添加一個WebSecurityConfigurerAdapter類型的@Bean。同時，若是不想覆蓋執行器的訪問規則，你能夠使用@Order（ SecurityProperties.ACCESS_OVERRIDE_ORDER）註解該豆，不然使用@Order（ManagementServerProperties.ACCESS_OVERRIDE_ORDER）註解該豆。
4.7使用sql數據庫
Spring框架爲使用SQL數據庫提供了普遍的支持。從使用JdbcTemplate直接訪問JDBC到徹底的對象關係映射技術，好比Hibernate.Spring數據提供一個額外的功能，直接從接口建立Repository實現，並使用約定從你的方法名生成查詢。
4.7.1配置DataSource
Java的的javax.sql.DataSource的接口提供了一個標準的使用數據庫鏈接的方法。傳統作法是，一個數據源使用一個URL連同相應的證書去初始化一個數據庫鏈接。
4.7.1.1對內封數據庫的支持
開發應用時使用內存數據庫是很實用的。顯而易見地，內存數據庫不須要提供持久化存儲。你不須要在應用啓動時填充數據庫，也不須要在應用結束時丟棄數據。
Spring Boot能夠自動配置的內嵌數據庫包括H2，HSQL和Derby。你不須要提供任何鏈接URL，只須要簡單的添加你想使用的內嵌數據庫依賴。
示例：典型的POM依賴以下：
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>org.hsqldb</groupId> <artifactId>hsqldb</artifactId> <scope>runtime</scope> </dependency>
注：對於自動配置的內嵌數據庫，你須要依賴彈簧JDBC在示例中，它經過彈簧引導起動數據JPA被傳遞地拉過來了。
4.7.1.2鏈接到一個生產環境數據庫
在生產環境中，數據庫鏈接能夠使用數據源池進行自動配置下面是選取一個特定實現的算法：
- 因爲Tomcat的數據源鏈接池的性能和併發，在Tomcat的可用時，咱們老是優先使用它。
- 若是HikariCP可用，咱們將使用它。
- 若是Commons DBCP可用，咱們將使用它，但在生產環境不推薦使用它。
- 最後，若是Commons DBCP2可用，咱們將使用它。
若是你使用spring-boot-starter-jdbc或spring-boot-starter-data-jpa'starter POMs'，你將會自動獲取對tomcat-jdbc的依賴。
注：其餘的鏈接池能夠手動配置。若是你定義本身的DataSource bean，自動配置不會發生。
數據源配置經過外部配置文件的spring.datasource *屬性控制示例中，你可能會在application.properties中聲明下面的片斷。：
spring.datasource.url=jdbc:mysql://localhost/test spring.datasource.username=dbuser spring.datasource.password=dbpass spring.datasource.driver-class-name=com.mysql.jdbc.Driver
其餘可選的配置能夠查看DataSourceProperties。同時注意你能夠經過spring.datasource。*配置任何DataSource實現相關的特定屬性：具體參考你使用的鏈接池實現的文檔。
注：既然Spring Boot可以從大多數數據庫的url上推斷出driver-class-name，那麼你就不須要再指定它了。對於一個將要建立的DataSource鏈接池，咱們須要可以驗證Driver是否可用，因此咱們會在作任何事情以前檢查它。好比，若是你設置spring.datasource.driverClassName=com.mysql.jdbc.Driver，而後這個類就會被加載。
4.7.1.3 鏈接到一個JNDI數據庫
若是正在將Spring Boot應用部署到一個應用服務器，你可能想要用應用服務器內建的特性來配置和管理你的DataSource，並使用JNDI訪問它。
spring.datasource.jndi-name屬性能夠用來替代spring.datasource.url，spring.datasource.username和spring.datasource.password去從一個特定的JNDI路徑訪問DataSource。好比，下面application.properties中的片斷展現瞭如何獲取JBoss定義的DataSource：
spring.datasource.jndi-name=java:jboss/datasources/customers
4.7.2 使用JdbcTemplate
Spring的JdbcTemplate和NamedParameterJdbcTemplate類是被自動配置的，你能夠在本身的beans中經過@Autowire直接注入它們。
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.stereotype.Component; @Component public class MyBean { private final JdbcTemplate jdbcTemplate; @Autowired public MyBean(JdbcTemplate jdbcTemplate) { this.jdbcTemplate = jdbcTemplate; } // ... }
4.7.3 JPA和Spring Data
Java持久化API是一個容許你將對象映射爲關係數據庫的標準技術。spring-boot-starter-data-jpa POM提供了一種快速上手的方式。它提供下列關鍵的依賴：
- Hibernate - 一個很是流行的JPA實現。
- Spring Data JPA - 讓實現基於JPA的repositories更容易。
- Spring ORMs - Spring框架的核心ORM支持。
注：咱們不想在這涉及太多關於JPA或Spring Data的細節。你能夠參考來自spring.io的指南使用JPA獲取數據，並閱讀Spring Data JPA和Hibernate的參考文檔。
4.7.3.1 實體類
傳統上，JPA實體類被定義到一個persistence.xml文件中。在Spring Boot中，這個文件不是必需的，並被'實體掃描'替代。默認狀況下，在你主（main）配置類（被@EnableAutoConfiguration或@SpringBootApplication註解的類）下的全部包都將被查找。
任何被@Entity，@Embeddable或@MappedSuperclass註解的類都將被考慮。一個普通的實體類看起來像下面這樣：
package com.example.myapp.domain; import java.io.Serializable; import javax.persistence.*; @Entity public class City implements Serializable { @Id @GeneratedValue private Long id; @Column(nullable = false) private String name; @Column(nullable = false) private String state; // ... additional members, often include @OneToMany mappings protected City() { // no-args constructor required by JPA spec // this one is protected since it shouldn't be used directly } public City(String name, String state) { this.name = name; this.country = country; } public String getName() { return this.name; } public String getState() { return this.state; } // ... etc }
注：你能夠使用@EntityScan註解自定義實體掃描路徑。具體參考Section 67.4, 「Separate @Entity definitions from Spring configuration」。
4.7.3.2 Spring Data JPA倉庫
Spring Data JPA倉庫（repositories）是用來定義訪問數據的接口。根據你的方法名，JPA查詢會被自動建立。好比，一個CityRepository接口可能聲明一個findAllByState(String state)方法，用來查找給定狀態的全部城市。
對於比較複雜的查詢，你能夠使用Spring Data的Query來註解你的方法。
Spring Data倉庫一般繼承自Repository或CrudRepository接口。若是你使用自動配置，包括在你的主配置類（被@EnableAutoConfiguration或@SpringBootApplication註解的類）的包下的倉庫將會被搜索。
下面是一個傳統的Spring Data倉庫：
package com.example.myapp.domain; import org.springframework.data.domain.*; import org.springframework.data.repository.*; public interface CityRepository extends Repository<City, Long> { Page<City> findAll(Pageable pageable); City findByNameAndCountryAllIgnoringCase(String name, String country); }
注：咱們僅僅觸及了Spring Data JPA的表面。具體查看它的參考指南。
4.7.3.2 建立和刪除JPA數據庫
默認狀況下，只有在你使用內嵌數據庫（H2, HSQL或Derby）時，JPA數據庫纔會被自動建立。你能夠使用spring.jpa.*屬性顯示的設置JPA。好比，爲了建立和刪除表你能夠將下面的配置添加到application.properties中：
spring.jpa.hibernate.ddl-auto=create-drop
注：Hibernate本身內部對建立，刪除表支持（若是你剛好記得這回事更好）的屬性是hibernate.hbm2ddl.auto。使用spring.jpa.properties.*（前綴在被添加到實體管理器以前會被剝離掉），你能夠設置Hibernate自己的屬性，好比hibernate.hbm2ddl.auto。示例：spring.jpa.properties.hibernate.globally_quoted_identifiers=true將傳遞hibernate.globally_quoted_identifiers到Hibernate實體管理器。
默認狀況下，DDL執行（或驗證）被延遲到ApplicationContext啓動。這也有一個spring.jpa.generate-ddl標識，若是Hibernate自動配置被激活，那該標識就不會被使用，由於ddl-auto設置粒度更細。
4.8 使用NoSQL技術
Spring Data提供其餘項目，用來幫你使用各類各樣的NoSQL技術，包括MongoDB, Neo4J, Elasticsearch, Solr, Redis, Gemfire, Couchbase和Cassandra。Spring Boot爲Redis, MongoDB, Elasticsearch, Solr和Gemfire提供自動配置。你能夠充分利用其餘項目，但你須要本身配置它們。具體查看projects.spring.io/spring-data中合適的參考文檔。
4.8.1 Redis
Redis是一個緩存，消息中間件及具備豐富特性的鍵值存儲系統。Spring Boot爲Jedis客戶端庫和由Spring Data Redis提供的基於Jedis客戶端的抽象提供自動配置。spring-boot-starter-redis'Starter POM'爲收集依賴提供一種便利的方式。
4.8.1.1 鏈接Redis
你能夠注入一個自動配置的RedisConnectionFactory，StringRedisTemplate或普通的跟其餘Spring Bean相同的RedisTemplate實例。默認狀況下，這個實例將嘗試使用localhost:6379鏈接Redis服務器。
@Component
public class MyBean { private StringRedisTemplate template; @Autowired public MyBean(StringRedisTemplate template) { this.template = template; } // ... }
若是你添加一個你本身的任何自動配置類型的@Bean，它將替換默認的（除了RedisTemplate的狀況，它是根據bean的名稱'redisTemplate'而不是它的類型進行排除的）。若是在classpath路徑下存在commons-pool2，默認你會得到一個鏈接池工廠。
4.8.2 MONGODB
MongoDB是一個開源的NoSQL文檔數據庫，它使用一個JSON格式的模式（schema）替換了傳統的基於表的關係數據。Spring Boot爲使用MongoDB提供了不少便利，包括spring-boot-starter-data-mongodb'Starter POM'。
4.8.2.1鏈接MongoDB數據庫
你能夠注入一個自動配置的org.springframework.data.mongodb.MongoDbFactory來訪問Mongo數據庫。默認狀況下，該實例將嘗試使用URL：mongodb：// localhost / test鏈接一個MongoDB服務器。
import org.springframework.data.mongodb.MongoDbFactory; import com.mongodb.DB; @Component public class MyBean { private final MongoDbFactory mongo; @Autowired public MyBean(MongoDbFactory mongo) { this.mongo = mongo; } // ... public void example() { DB db = mongo.getDb(); // ... } }
你能夠經過設置spring.data.mongodb.uri來改變該URL，或指定一個主機/端口好比，你可能會在你的application.properties中設置以下的屬性：
spring.data.mongodb.host=mongoserver spring.data.mongodb.port=27017
注：春天數據Mongo，你能夠注入com.mongodb.Mongo豆而不是使用MongoDbFactory。
若是想全面控制的MongoDB鏈接的創建，你也能夠聲明本身的MongoDbFactory或蒙戈，@豆。
4.8.2.2 MongoDBTemplate
Spring Data Mongo提供了一個MongoTemplate類，它的設計和Spring的JdbcTemplate很類似。正如JdbcTemplate同樣，Spring Boot會爲你自動配置一個bean，你只需簡單的注入它便可：
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.mongodb.core.MongoTemplate; import org.springframework.stereotype.Component; @Component public class MyBean { private final MongoTemplate mongoTemplate; @Autowired public MyBean(MongoTemplate mongoTemplate) { this.mongoTemplate = mongoTemplate; } // ... }
具體參考MongoOperations Javadoc。
4.8.1.3 Spring Data MongoDB倉庫
Spring Data的倉庫包括對MongoDB的支持。正如上面討論的JPA倉庫，基本的原則是查詢會自動基於你的方法名建立。
實際上，無論是Spring Data JPA仍是Spring Data MongoDB都共享相同的基礎設施。因此你能夠使用上面的JPA示例，並假設那個城市如今是一個Mongo數據類而不是JPA @Entity，它將以一樣的方式工做。
package com.example.myapp.domain; import org.springframework.data.domain.*; import org.springframework.data.repository.*; public interface CityRepository extends Repository<City, Long> { Page<City> findAll(Pageable pageable); City findByNameAndCountryAllIgnoringCase(String name, String country); }
4.8.3 Gemfire
Spring Data Gemfire爲使用Pivotal Gemfire數據管理平臺提供了方便的，Spring友好的工具.Spring Boot提供了一個用於彙集依賴的spring-boot-starter-data-gemfire'Starter POM'。目前不支持Gemfire的自動配置，但你能夠使用一個單一的註解使Spring Data倉庫支持它。
4.8.4 Solr
Apache Solr是一個搜索引擎.Spring Boot爲solr客戶端庫及Spring Data Solr提供的基於solr客戶端庫的抽象提供了基本的配置.Spring Boot提供了一個用於彙集依賴的spring-boot-starter-data -solr'Starter POM'。
4.8.4.1鏈接Solr
你能夠像其餘Spring beans同樣注入一個自動配置的SolrServer實例。默認狀況下，該實例將嘗試使用localhost：8983 / solr鏈接一個服務器。
@Component public class MyBean { private SolrServer solr; @Autowired public MyBean(SolrServer solr) { this.solr = solr; } // ... }
若是你添加一個本身的SolrServer類型的@Bean，它將會替換默認的。
4.8.4.2 Spring Data Solr倉庫
Spring Data的倉庫包括了對Apache Solr的支持。正如上面討論的JPA倉庫，基本的原則是查詢會自動基於你的方法名建立。
實際上，無論是Spring Data JPA仍是Spring Data Solr都共享相同的基礎設施。因此你能夠使用上面的JPA示例，並假設那個City如今是一個@SolrDocument類而不是JPA @Entity，它將以一樣的方式工做。
注：具體參考Spring Data Solr文檔。
4.8.5 Elasticsearch
Elastic Search是一個開源的，分佈式，實時搜索和分析引擎。Spring Boot爲Elasticsearch及Spring Data Elasticsearch提供的基於它的抽象提供了基本的配置。Spring Boot提供了一個用於彙集依賴的spring-boot-starter-data-elasticsearch'Starter POM'。
4.8.5.1 鏈接Elasticsearch
你能夠像其餘Spring beans那樣注入一個自動配置的ElasticsearchTemplate或Elasticsearch客戶端實例。默認狀況下，該實例將嘗試鏈接到一個本地內存服務器（在Elasticsearch項目中的一個NodeClient），但你能夠經過設置spring.data.elasticsearch.clusterNodes爲一個以逗號分割的host:port列表來將其切換到一個遠程服務器（好比，TransportClient）。
@Component
public class MyBean { private ElasticsearchTemplate template; @Autowired public MyBean(ElasticsearchTemplate template) { this.template = template; } // ... }
若是你添加一個你本身的ElasticsearchTemplate類型的@Bean，它將替換默認的。
4.8.5.2 Spring Data Elasticseach倉庫
Spring Data的倉庫包括了對Elasticsearch的支持。正如上面討論的JPA倉庫，基本的原則是查詢會自動基於你的方法名建立。
實際上，無論是Spring Data JPA仍是Spring Data Elasticsearch都共享相同的基礎設施。因此你能夠使用上面的JPA示例，並假設那個City如今是一個Elasticsearch @Document類而不是JPA @Entity，它將以一樣的方式工做。
注：具體參考Spring Data Elasticsearch文檔。
4.9 消息
Spring Framework框架爲集成消息系統提供了擴展（extensive）支持：從使用JmsTemplate簡化JMS API，到實現一個完整異步消息接收的底層設施。
Spring AMQP提供一個類似的用於'高級消息隊列協議'的特徵集，而且Spring Boot也爲RabbitTemplate和RabbitMQ提供了自動配置選項。
Spring Websocket提供原生的STOMP消息支持，而且Spring Boot經過starters和一些自動配置也提供了對它的支持。
4.9.1 JMS
javax.jms.ConnectionFactory接口提供了一個標準的用於建立一個javax.jms.Connection的方法，javax.jms.Connection用於和JMS代理（broker）交互。
儘管爲了使用JMS，Spring須要一個ConnectionFactory，但一般你不須要直接使用它，而是依賴於上層消息抽象（具體參考Spring框架的相關章節）。Spring Boot也會自動配置發送和接收消息須要的設施（infrastructure）。
4.9.1.1 HornetQ支持
若是在classpath下發現HornetQ，Spring Boot會自動配置ConnectionFactory。若是須要代理，將會開啓一個內嵌的，已經自動配置好的代理（除非顯式設置mode屬性）。支持的modes有：embedded（顯式聲明使用一個內嵌的代理，若是該代理在classpath下不可用將致使一個錯誤），native（使用netty傳輸協議鏈接代理）。當後者被配置，Spring Boot配置一個鏈接到一個代理的ConnectionFactory，該代理運行在使用默認配置的本地機器上。
注：若是使用彈簧引導起動HornetQ的，鏈接到一個已存在的HornetQ的實例所需的依賴都會被提供，同時還有用於集成JMS的春季基礎設施將org.hornetq：將hornetq-JMS服務器添加到你的應用中，你就能夠使用嵌入模式。
HornetQ的配置被spring.hornetq *中的外部配置屬性所控制例如，你可能在application.properties聲明如下片斷。：
spring.hornetq.mode=native spring.hornetq.host=192.168.1.210 spring.hornetq.port=9876
當內嵌代理時，你能夠選擇是否啓用持久化，而且列表中的目標都應該是可用的。這些能夠經過一個以逗號分割的列表來指定一些默認的配置項，或定義org.hornetq.jms。 server.config.JMSQueueConfiguration或org.hornetq.jms.server.config.TopicConfiguration類型的bean（s）來配置更高級的隊列和主題。具體參考HornetQProperties。
沒有涉及JNDI查找，目標是經過名字解析的，名字便可以使用HornetQ的配置中的名稱屬性，也能夠是配置中提供的名稱。
4.9.1.2 ActiveQ支持
若是發現ActiveMQ在classpath下可用，Spring Boot會配置一個ConnectionFactory。若是須要代理，將會開啓一個內嵌的，已經自動配置好的代理（只要配置中沒有指定代理URL）。
ActiveMQ的配置是經過spring.activemq *中的外部配置來控制的例如，你可能在application.properties中聲明下面的片斷。：
spring.activemq.broker-url=tcp://192.168.1.210:9876 spring.activemq.user=admin spring.activemq.password=secret
具體參考ActiveMQProperties。
默認狀況下，若是目標還不存在，ActiveMQ的將建立一個，因此目標是經過它們提供的名稱解析出來的。
4.9.1.3使用JNDI ConnectionFactory
若是你在一個應用服務器中運行你的應用，Spring Boot將嘗試使用JNDI定位一個JMS ConnectionFactory。默認狀況會檢查java：/ JmsXA和java：/ XAConnectionFactory。若是須要的話，你能夠使用spring.jms.jndi-命名屬性來指定一個替代位置。
spring.jms.jndi-name=java:/MyConnectionFactory
4.9.1.4發送消息
春天的JmsTemplate的會被自動配置，你能夠將它直接注入到你本身的豆中：
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jms.core.JmsTemplate; import org.springframework.stereotype.Component; @Component public class MyBean { private final JmsTemplate jmsTemplate; @Autowired public MyBean(JmsTemplate jmsTemplate) { this.jmsTemplate = jmsTemplate; } // ... }
注：JmsMessagingTemplate（Spring4.1新增的）也能夠使用相同的方式注入
4.9.1.5接收消息
當JMS基礎設施可以使用時，任何豆都可以被@JmsListener註解，以建立一個監聽者端點。若是沒有定義JmsListenerContainerFactory，一個默認的將會被自動配置。下面的組件在someQueue目標上建立一個監聽者端點。
@Component public class MyBean { @JmsListener(destination = "someQueue") public void processMessage(String content) { // ... } }
具體查看@EnableJms javadoc。
4.10發送郵件
Spring框架使用JavaMailSender接口爲發送郵件提供了一個簡單的抽象，而且Spring Boot也爲它提供了自動配置和一個starter模塊。具體查看JavaMailSender參考文檔。
若是spring.mail.host和相關的庫（經過彈簧引導起動郵件定義）都存在，一個默認的JavaMailSender將被建立。該發送方能夠經過spring.mail命名空間下的配置項進一步自定義，具體參考MailProperties。
4.11使用JTA處理分佈式事務
Spring Boot使用一個Atomkos或Bitronix的內嵌事務管理器來支持跨多個XA資源的分佈式JTA事務。當部署到一個恰當的J2EE應用服務器時也會支持JTA事務。
當發現一個JTA環境時，Spring Boot將使用Spring的JtaTransactionManager來管理事務。自動配置的JMS，DataSource和JPA beans將被升級以支持XA事務。你能夠使用標準的Spring idioms，好比@Transactional，來參與到一個分佈式事務中。若是你處於JTA環境裏，但仍舊想使用本地事務，你能夠將spring.jta.enabled屬性設置爲false來禁用JTA自動配置功能。
4.11.1 使用一個Atomikos事務管理器
Atomikos是一個很是流行的開源事務管理器，它能夠嵌入到你的Spring Boot應用中。你能夠使用spring-boot-starter-jta-atomikosStarter POM去獲取正確的Atomikos庫。Spring Boot會自動配置Atomikos，並將合適的depends-on應用到你的Spring Beans上，確保它們以正確的順序啓動和關閉。
默認狀況下，Atomikos事務日誌將被記錄在應用home目錄（你的應用jar文件放置的目錄）下的transaction-logs文件夾中。你能夠在application.properties文件中經過設置spring.jta.log-dir屬性來自定義該目錄。以spring.jta.開頭的屬性能用來自定義Atomikos的UserTransactionServiceIml實現。具體參考AtomikosProperties javadoc。
注：爲了確保多個事務管理器可以安全地和相應的資源管理器配合，每一個Atomikos實例必須設置一個惟一的ID。默認狀況下，該ID是Atomikos實例運行的機器上的IP地址。爲了確保生產環境中該ID的惟一性，你須要爲應用的每一個實例設置不一樣的spring.jta.transaction-manager-id屬性值。
4.11.2 使用一個Bitronix事務管理器
Bitronix是另外一個流行的開源JTA事務管理器實現。你能夠使用spring-boot-starter-jta-bitronixstarter POM爲項目添加合適的Birtronix依賴。和Atomikos相似，Spring Boot將自動配置Bitronix，並對beans進行後處理（post-process）以確保它們以正確的順序啓動和關閉。
默認狀況下，Bitronix事務日誌將被記錄到應用home目錄下的transaction-logs文件夾中。經過設置spring.jta.log-dir屬性，你能夠自定義該目錄。以spring.jta.開頭的屬性將被綁定到bitronix.tm.Configuration bean，你能夠經過這完成進一步的自定義。具體參考Bitronix文檔。
注：爲了確保多個事務管理器可以安全地和相應的資源管理器配合，每一個Bitronix實例必須設置一個惟一的ID。默認狀況下，該ID是Bitronix實例運行的機器上的IP地址。爲了確保生產環境中該ID的惟一性，你須要爲應用的每一個實例設置不一樣的spring.jta.transaction-manager-id屬性值。
4.11.3 使用一個J2EE管理的事務管理器
若是你將Spring Boot應用打包爲一個war或ear文件，並將它部署到一個J2EE的應用服務器中，那你就能使用應用服務器內建的事務管理器。Spring Boot將嘗試經過查找常見的JNDI路徑（java:comp/UserTransaction, java:comp/TransactionManager等）來自動配置一個事務管理器。若是使用應用服務器提供的事務服務，你一般須要確保全部的資源都被應用服務器管理，並經過JNDI暴露出去。Spring Boot經過查找JNDI路徑java:/JmsXA或java:/XAConnectionFactory獲取一個ConnectionFactory來自動配置JMS，而且你能夠使用spring.datasource.jndi-name屬性配置你的DataSource。
4.12 Spring集成
Spring集成提供基於消息和其餘協議的，好比HTTP，TCP等的抽象。若是Spring集成在classpath下可用，它將會經過@EnableIntegration註解被初始化。若是classpath下'spring-integration-jmx'可用，則消息處理統計分析將被經過JMX發佈出去。具體參考IntegrationAutoConfiguration類。
4.13 基於JMX的監控和管理
Java管理擴展（JMX）提供了一個標準的用於監控和管理應用的機制。默認狀況下，Spring Boot將建立一個id爲‘mbeanServer’的MBeanServer，並導出任何被Spring JMX註解（@ManagedResource,@ManagedAttribute,@ManagedOperation）的beans。具體參考JmxAutoConfiguration類。
4.14 測試
Spring Boot提供不少有用的測試應用的工具。spring-boot-starter-test POM提供Spring Test，JUnit，Hamcrest和Mockito的依賴。在spring-boot核心模塊org.springframework.boot.test包下也有不少有用的測試工具。
4.14.1 測試做用域依賴
若是使用spring-boot-starter-test ‘Starter POM’（在test做用域內），你將發現下列被提供的庫：
- Spring Test - 對Spring應用的集成測試支持
- JUnit - 事實上的(de-facto)標準，用於Java應用的單元測試。
- Hamcrest - 一個匹配對象的庫（也稱爲約束或前置條件），它容許assertThat等JUnit類型的斷言。
- Mockito - 一個Java模擬框架。
這也有一些咱們寫測試用例時常常用到的庫。若是它們不能知足你的要求，你能夠隨意添加其餘的測試用的依賴庫。
4.14.2 測試Spring應用
依賴注入最大的優勢就是它可以讓你的代碼更容易進行單元測試。你只需簡單的經過new操做符實例化對象，而不須要涉及Spring。你也能夠使用模擬對象替換真正的依賴。
你經常須要在進行單元測試後，開始集成測試（在這個過程當中只須要涉及到Spring的ApplicationContext）。在執行集成測試時，不須要部署應用或鏈接到其餘基礎設施是很是有用的。
Spring框架包含一個dedicated測試模塊，用於這樣的集成測試。你能夠直接聲明對org.springframework:spring-test的依賴，或使用spring-boot-starter-test ‘Starter POM’以透明的方式拉取它。
若是你之前沒有使用過spring-test模塊，能夠查看Spring框架參考文檔中的相關章節。
4.14.3 測試Spring Boot應用
一個Spring Boot應用只是一個Spring ApplicationContext，因此在測試它時除了正常狀況下處理一個vanilla Spring context外部不須要注意的是，若是你使用SpringApplication建立上下文，外部配置，日誌和Spring啓動的其餘特性只會在默認的上下文中起做用。
Spring Boot提供一個@SpringApplicationConfiguration註解用來替換標準的spring-test @ContextConfiguration註解。若是使用@SpringApplicationConfiguration來設置你的測試中使用的ApplicationContext，它最終將經過SpringApplication建立，而且你將獲取到Spring Boot的其餘特性。
示例以下：
@RunWith(SpringJUnit4ClassRunner.class) @SpringApplicationConfiguration(classes = SampleDataJpaApplication.class) public class CityRepositoryIntegrationTests { @Autowired CityRepository repository; // ... }
提示：上下文加載器會經過查找@WebIntegrationTest或@WebAppConfiguration註解來猜想你想測試的是不是網絡應用（例如，是否使用MockMVC，MockMVC和@WebAppConfiguration是彈簧試驗的一部分）。
若是想讓一個網絡應用啓動，並監聽它的正常的端口，你能夠使用HTTP來測試它（好比，使用RestTemplate），並使用@WebIntegrationTest註解你的測試類（或它的一個父類）。這頗有用，由於它意味着你能夠對你的應用進行全棧測試，但在一次HTTP交互後，你須要在你的測試類中注入相應的組件並使用它們斷言應用的內部狀態。
示例：
@RunWith(SpringJUnit4ClassRunner.class) @SpringApplicationConfiguration(classes = SampleDataJpaApplication.class) @WebIntegrationTest public class CityRepositoryIntegrationTests { @Autowired CityRepository repository; RestTemplate restTemplate = new TestRestTemplate(); // ... interact with the running server }
注：彈簧測試框架在每次測試時會緩存應用上下文所以，只要你的測試共享相同的配置，無論你實際運行多少測試，開啓和中止服務器只會發生一次。
你能夠爲@WebIntegrationTest添加環境變量屬性來改變應用服務器端口號，好比@WebIntegrationTest（ 「server.port：9000」）。此外，你能夠將server.port和management.port屬性設置爲0來讓你的集成測試使用隨機的端口號，例如：
@RunWith(SpringJUnit4ClassRunner.class) @SpringApplicationConfiguration(classes = MyApplication.class) @WebIntegrationTest({"server.port=0", "management.port=0"}) public class SomeIntegrationTests { // ... }
能夠查看第64.4節「在運行時發現HTTP端口」，它描述瞭如何在測試期間發現分配的實際端口。
4.14.3.1使用Spock測試Spring Boot應用
若是指望使用Spock測試一個Spring Boot應用，你應該將Spock的spock-spring模塊依賴添加到應用的構建中.spock-spring將Spring的測試框架集成到了Spock裏。
注意你不能使用上述提到的@SpringApplicationConfiguration註解，由於Spock找不到@ContextConfiguration元註解。爲了繞過該限制，你應該直接使用@ContextConfiguration註解，並使用Spring Boot特定的上下文加載器來配置它。
@ContextConfiguration(loader = SpringApplicationContextLoader.class) class ExampleSpec extends Specification { // ... }
注：上面描述的註解在斯波克中能夠使用，好比，你能夠使用@WebIntegrationTest註解你的規格以知足測試須要。
4.14.4測試工具
打包進春天啓動的一些有用的測試工具類。
4.14.4.1 ConfigFileApplicationContextInitializer
ConfigFileApplicationContextInitializer是一個ApplicationContextInitializer，能夠用來測試加載Spring Boot的application.properties文件。當不須要使用@SpringApplicationConfiguration提供的所有特性時，你能夠使用它。
@ContextConfiguration(classes = Config.class,initializers = ConfigFileApplicationContextInitializer.class)
4.14.4.2 EnvironmentTestUtils
EnvironmentTestUtils容許你快速添加屬性到一個ConfigurableEnvironment或ConfigurableApplicationContext。只需簡單的使用key = value字符串調用它：```java EnvironmentTestUtils.addEnvironment（env，「org = Spring」，「name = Boot」）;
4.14.4.3 OutputCapture
OutputCapture是一個JUnit規則，用於捕獲System.out和System.err輸出。只需簡單的將捕獲聲明爲一個@Rule，並使用toString（）斷言：
import org.junit.Rule; import org.junit.Test; import org.springframework.boot.test.OutputCapture; import static org.hamcrest.Matchers.*; import static org.junit.Assert.*; public class MyTest { @Rule public OutputCapture capture = new OutputCapture(); @Test public void testName() throws Exception { System.out.println("Hello World!"); assertThat(capture.toString(), containsString("World")); } }
4.14.4.4 TestRestTemplate
TestRestTemplate是一個方便進行集成測試的Spring RestTemplate子類。你會獲取到一個普通的模板或一個發送基本HTTP認證（使用用戶名和密碼）的模板。在任何狀況下，這些模板都表現出對測試友好：不容許重定向（這樣你能夠對響應地址進行斷言），忽略cookies（這樣模板就是無狀態的），對於服務端錯誤不會拋出異常。推薦使用Apache HTTP Client（4.3.2或更好的版本），但不強制這樣作。若是在類路徑下存在Apache HTTP Client，TestRestTemplate將以正確配置的客戶端進行響應。
public class MyTest { RestTemplate template = new TestRestTemplate(); @Test public void testRequest() throws Exception { HttpHeaders headers = template.getForEntity("http://myhost.com", String.class).getHeaders(); assertThat(headers.getLocation().toString(), containsString("myotherhost")); } }
4.15 開發自動配置和使用條件
若是你在一個開發者共享庫的公司工做，或你在從事一個開源或商業型的庫，你可能想要開發本身的auto-configuration。Auto-configuration類可以在外部的jars中綁定，並仍能被Spring Boot發現。
4.15.1 理解auto-configured beans
從底層來說，auto-configured是使用標準的@Configuration實現的類，另外的@Conditional註解用來約束在什麼狀況下使用auto-configuration。一般auto-configuration類使用@ConditionalOnClass和@ConditionalOnMissingBean註解。這是爲了確保只有在相關的類被發現，和你沒有聲明本身的@Configuration時才應用auto-configuration。
你能夠瀏覽spring-boot-autoconfigure的源碼，查看咱們提供的@Configuration類（查看META-INF/spring.factories文件）。
4.15.2 定位auto-configuration候選者
Spring Boot會檢查你發佈的jar中是否存在META-INF/spring.factories文件。該文件應該列出以EnableAutoConfiguration爲key的配置類：
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ com.mycorp.libx.autoconfigure.LibXAutoConfiguration,\ com.mycorp.libx.autoconfigure.LibXWebAutoConfiguration
若是配置須要應用特定的順序，你能夠使用@AutoConfigureAfter或@AutoConfigureBefore註解。例如，你想提供web-specific配置，你的類就須要應用在WebMvcAutoConfiguration後面。
4.15.3 Condition註解
你幾乎老是須要在你的auto-configuration類裏添加一個或更多的@Condition註解。@ConditionalOnMissingBean註解是一個常見的示例，它常常用於容許開發者覆蓋auto-configuration，若是他們不喜歡你提供的默認行爲。
Spring Boot包含不少@Conditional註解，你能夠在本身的代碼中經過註解@Configuration類或單獨的@Bean方法來重用它們。
4.15.3.1 Class條件
@ConditionalOnClass和@ConditionalOnMissingClass註解容許根據特定類是否出現來跳過配置。因爲註解元數據是使用ASM來解析的，你實際上能夠使用value屬性來引用真正的類，即便該類可能實際上並無出如今運行應用的classpath下。若是你傾向於使用一個String值來指定類名，你也能夠使用name屬性。
4.15.3.2 Bean條件
@ConditionalOnBean和@ConditionalOnMissingBean註解容許根據特定beans是否出現來跳過配置。你能夠使用value屬性來指定beans（by type），也能夠使用name來指定beans（by name）。search屬性容許你限制搜索beans時須要考慮的ApplicationContext的層次。
注：當@Configuration類被解析時@Conditional註解會被處理。Auto-configure @Configuration老是最後被解析（在全部用戶定義beans後面），然而，若是你將那些註解用到常規的@Configuration類，須要注意不能引用那些尚未建立好的bean定義。
4.15.3.3 Property條件
@ConditionalOnProperty註解容許根據一個Spring Environment屬性來決定是否包含配置。能夠使用prefix和name屬性指定要檢查的配置屬性。默認狀況下，任何存在的只要不是false的屬性都會匹配。你也能夠使用havingValue和matchIfMissing屬性建立更高級的檢測。
4.15.3.4 Resource條件
@ConditionalOnResource註解容許只有在特定資源出現時配置纔會被包含。資源能夠使用常見的Spring約定命名，例如file:/home/user/test.dat。
4.15.3.5 Web Application條件
@ConditionalOnWebApplication和@ConditionalOnNotWebApplication註解容許根據應用是否爲一個'web應用'來決定是否包含配置。一個web應用是任何使用Spring WebApplicationContext，定義一個session做用域或有一個StandardServletEnvironment的應用。
4.15.3.6 SpEL表達式條件
@ConditionalOnExpression註解容許根據SpEL表達式結果來跳過配置。
4.16 WebSockets
Spring Boot爲內嵌的Tomcat(8和7)，Jetty 9和Undertow提供WebSockets自動配置。若是你正在將一個war包部署到一個單獨的容器，Spring Boot會假設該容器會對它的WebSocket支持相關的配置負責。
Spring框架提供豐富的WebSocket支持，通過spring-boot-starter-websocket模塊能夠輕易獲取到。
Spring Boot執行器：Production-ready特性
Spring Boot包含不少其餘的特性，它們能夠幫你監控和管理髮布到生產環境的應用。你能夠選擇使用HTTP端點，JMX或遠程shell（SSH或Telnet）來管理和監控應用。審計（Auditing），健康（health）和數據採集（metrics gathering）會自動應用到你的應用。
5.1 開啓production-ready特性
spring-boot-actuator模塊提供了Spring Boot全部的production-ready特性。啓用該特性的最簡單方式就是添加對spring-boot-starter-actuator ‘Starter POM’的依賴。
執行器（Actuator）的定義：執行器是一個製造業術語，指的是用於移動或控制東西的一個機械裝置。一個很小的改變就能讓執行器產生大量的運動。
基於Maven的項目想要添加執行器只需添加下面的'starter'依賴：
<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency> </dependencies>
對於Gradle，使用下面的聲明：
dependencies {
compile("org.springframework.boot:spring-boot-starter-actuator") }
5.2 端點
執行器端點容許你監控應用及與應用進行交互。Spring Boot包含不少內置的端點，你也能夠添加本身的。例如，health端點提供了應用的基本健康信息。
端點暴露的方式取決於你採用的技術類型。大部分應用選擇HTTP監控，端點的ID映射到一個URL。例如，默認狀況下，health端點將被映射到/health。
下面的端點都是可用的：
| ID | 描述 | 敏感（Sensitive） |
|---|---|---|
| autoconfig | 顯示一個auto-configuration的報告，該報告展現全部auto-configuration候選者及它們被應用或未被應用的緣由 | true |
| beans | 顯示一個應用中全部Spring Beans的完整列表 | true |
| configprops | 顯示一個全部@ConfigurationProperties的整理列表 | true |
| dump | 執行一個線程轉儲 | true |
| env | 暴露來自Spring ConfigurableEnvironment的屬性 | true |
| health | 展現應用的健康信息（當使用一個未認證鏈接訪問時顯示一個簡單的'status'，使用認證鏈接訪問則顯示所有信息詳情） | false |
| info | 顯示任意的應用信息 | false |
| metrics | 展現當前應用的'指標'信息 | true |
| mappings | 顯示一個全部@RequestMapping路徑的整理列表 | true |
| shutdown | 容許應用以優雅的方式關閉（默認狀況下不啓用） | true |
| trace | 顯示trace信息（默認爲最新的一些HTTP請求） | true |
注：根據一個端點暴露的方式，sensitive參數可能會被用作一個安全提示。例如，在使用HTTP訪問sensitive端點時須要提供用戶名/密碼（若是沒有啓用web安全，可能會簡化爲禁止訪問該端點）。
5.2.1 自定義端點
使用Spring屬性能夠自定義端點。你能夠設置端點是否開啓（enabled），是否敏感（sensitive），甚至它的id。例如，下面的application.properties改變了敏感性和beans端點的id，也啓用了shutdown。
endpoints.beans.id=springbeans
endpoints.beans.sensitive=false endpoints.shutdown.enabled=true
注：前綴endpoints + . + name被用來惟一的標識被配置的端點。
默認狀況下，除了shutdown外的全部端點都是啓用的。若是但願指定選擇端點的啓用，你能夠使用endpoints.enabled屬性。例如，下面的配置禁用了除info外的全部端點：
endpoints.enabled=false endpoints.info.enabled=true
5.2.2 健康信息
健康信息能夠用來檢查應用的運行狀態。它常常被監控軟件用來提醒人們生產系統是否中止。health端點暴露的默認信息取決於端點是如何被訪問的。對於一個非安全，未認證的鏈接只返回一個簡單的'status'信息。對於一個安全或認證過的鏈接其餘詳細信息也會展現（具體參考Section 41.6, 「HTTP Health endpoint access restrictions」 ）。
健康信息是從你的ApplicationContext中定義的全部HealthIndicator beans收集過來的。Spring Boot包含不少auto-configured的HealthIndicators，你也能夠寫本身的。
5.2.3 安全與HealthIndicators
HealthIndicators返回的信息經常性質上有點敏感。例如，你可能不想將數據庫服務器的詳情發佈到外面。所以，在使用一個未認證的HTTP鏈接時，默認只會暴露健康狀態（health status）。若是想將全部的健康信息暴露出去，你能夠把endpoints.health.sensitive設置爲false。
爲防止'拒絕服務'攻擊，Health響應會被緩存。你能夠使用endpoints.health.time-to-live屬性改變默認的緩存時間（1000毫秒）。
5.2.3.1 自動配置的HealthIndicators
下面的HealthIndicators會被Spring Boot自動配置（在合適的時候）：
| 名稱 | 描述 |
|---|---|
| DiskSpaceHealthIndicator | 低磁盤空間檢測 |
| DataSourceHealthIndicator | 檢查是否能從DataSource獲取鏈接 |
| MongoHealthIndicator | 檢查一個Mongo數據庫是否可用（up） |
| RabbitHealthIndicator | 檢查一個Rabbit服務器是否可用（up） |
| RedisHealthIndicator | 檢查一個Redis服務器是否可用（up） |
| SolrHealthIndicator | 檢查一個Solr服務器是否可用（up） |
5.2.3.2 編寫自定義HealthIndicators
想提供自定義健康信息，你能夠註冊實現了HealthIndicator接口的Spring beans。你須要提供一個health（）方法的實現，並返回一個Health響應.Health響應須要包含一個狀態和可選的用於展現的詳情。
import org.springframework.boot.actuate.health.HealthIndicator; import org.springframework.stereotype.Component; @Component public class MyHealth implements HealthIndicator { @Override public Health health() { int errorCode = check(); // perform some specific health check if (errorCode != 0) { return Health.down().withDetail("Error Code", errorCode).build(); } return Health.up().build(); } }
除了Spring Boot預約義的Status類型，Health也能夠返回一個表明新的系統狀態的自定義狀態。在這種狀況下，須要提供一個HealthAggregator接口的自定義實現，或使用management.health.status.order屬性配置默認的實現。
例如，假設一個新的，代碼爲FATAL的狀態被用於你的一個HealthIndicator實現中爲了配置嚴重程度，你須要將下面的配置添加到應用程序屬性文件中：
management.health.status.order: DOWN, OUT_OF_SERVICE, UNKNOWN, UP
若是使用HTTP訪問健康端點，你可能想要註冊自定義的狀態，並使用HealthMvcEndpoint進行映射。例如，你能夠將FATAL映射爲HttpStatus.SERVICE_UNAVAILABLE。
5.2.4自定義應用信息
。經過設置彈簧屬性信息*，你能夠定義信息端點暴露的數據全部在信息關鍵字下的環境屬性都將被自動暴露例如，你能夠將下面的配置添加到application.properties。：
info.app.name=MyService info.app.description=My awesome service info.app.version=1.0.0
5.2.4.1在構建時期自動擴展信息屬性
你能夠使用已經存在的構建配置自動擴展信息屬性，而不是對在項目構建配置中存在的屬性進行硬編碼。這在Maven的和搖籃都是可能的。
使用Maven的自動擴展屬性
對於Maven項目，你能夠使用資源過濾來自動擴展信息屬性。若是使用spring-boot-starter-parent，你能夠經過@ .. @佔位符引用Maven的'項目屬性'。
project.artifactId=myproject
project.name=Demo
project.version=X.X.X.X
project.description=Demo project for info endpoint info.build.artifact=@project.artifactId@ info.build.name=@project.name@ info.build.description=@project.description@ info.build.version=@project.version@
注：在上面的示例中，咱們使用項目*來設置一些值以防止因爲某些緣由的Maven的資源過濾沒有開啓.Maven目標春季啓動：運行直接將的src / main /資源添加到類路徑下（出於熱加載的目的）。這就過了資源過濾和自動擴展屬性的特性。你能夠使用exec：java替換該目標或自定義插件的配置，具體參考插件使用頁面。
若是你不使用starter parent，在你的pom.xml你須要添加（處於元素內）：
<resources> <resource> <directory>src/main/resources</directory> <filtering>true</filtering> </resource> </resources>
和（處於內）：
<plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-resources-plugin</artifactId> <version>2.6</version> <configuration> <delimiters> <delimiter>@</delimiter> </delimiters> </configuration> </plugin>
使用搖籃自動擴展屬性
經過配置的Java插件的processResources任務，你也能夠自動使用來自搖籃項目的屬性擴展信息屬性。
processResources {
expand(project.properties)
}
而後你能夠經過佔位符引用搖籃項目的屬性：
info.build.name=${name} info.build.description=${description} info.build.version=${version}
5.2.4.2 Git提交信息
信息端點的另外一個有用特性是，當項目構建完成後，它能夠發佈關於你的git的源碼倉庫狀態的信息。若是在你的罐子中包含一個git.properties文件，git.branch和git.commit屬性將被加載。
對於Maven用戶，spring-boot-starter-parent POM包含一個可以產生git.properties文件的預配置插件。只須要簡單的將下面的聲明添加到你的POM中：
<build> <plugins> <plugin> <groupId>pl.project13.maven</groupId> <artifactId>git-commit-id-plugin</artifactId> </plugin> </plugins> </build>
對於搖籃用戶能夠使用一個類似的插件的gradle-git的，儘管爲了產生屬性文件可能須要稍微多點工做。
5.3基於HTTP的監控和管理
若是你正在開發一個Spring MVC應用，Spring Boot執行器自動將全部啓用的端點經過HTTP暴露出去。默認約定使用端點的id做爲URL路徑，例如，health暴露爲/ health。
5.3.1保護敏感端點
若是你的項目中添加的有Spring Security，全部經過HTTP暴露的敏感端點都會受到保護。默認狀況下會使用基本認證（basic authentication，用戶名爲user，密碼爲應用啓動時在控制檯打印的密碼）。
你能夠使用Spring屬性改變用戶名，密碼和訪問端點須要的安全角色。例如，你可能會在application.properties中添加下列配置：
security.user.name=admin security.user.password=secret management.security.role=SUPERUSER
注：若是你不使用Spring Security，那你的HTTP端點就被公開暴露，你應該慎重考慮啓用哪些端點。具體參考Section 40.1, 「Customizing endpoints」。
5.3.2 自定義管理服務器的上下文路徑
有時候將全部的管理端口劃分到一個路徑下是有用的。例如，你的應用可能已經將/info做爲他用。你能夠用management.contextPath屬性爲管理端口設置一個前綴：
management.context-path=/manage
上面的application.properties示例將把端口從/{id}改成/manage/{id}（好比，/manage/info）。
5.3.3 自定義管理服務器的端口
對於基於雲的部署，使用默認的HTTP端口暴露管理端點（endpoints）是明智的選擇。然而，若是你的應用是在本身的數據中心運行，那你可能傾向於使用一個不一樣的HTTP端口來暴露端點。
management.port屬性能夠用來改變HTTP端口：
management.port=8081
因爲你的管理端口常常被防火牆保護，不對外暴露也就不須要保護管理端點，即便你的主要應用是安全的。在這種狀況下，classpath下會存在Spring Security庫，你能夠設置下面的屬性來禁用安全管理策略（management security）：
management.security.enabled=false
（若是classpath下不存在Spring Security，那也就不須要顯示的以這種方式來禁用安全管理策略，它甚至可能會破壞應用程序。）
5.3.4 自定義管理服務器的地址
能夠你經過設置management.address屬性來定義管理端點能夠使用的地址。這在你只想監聽內部或面向生產環境的網絡，或只監聽來自本地主機的鏈接時很是有用。
下面的application.properties示例不容許遠程管理鏈接：
management.port=8081 management.address=127.0.0.1
5.3.5禁用HTTP端點
若是不想經過HTTP暴露端點，你能夠將管理端口設置爲-1： management.port=-1
5.3.6 HTTP Health端點訪問限制
經過健康端點暴露的信息根據是否爲匿名訪問而不一樣。默認狀況下，當匿名訪問時，任何有關服務器的健康詳情都被隱藏了，該端點只簡單的指示服務器是運行（上）仍是中止（下）。此外，當匿名訪問時，響應會被緩存一個可配置的時間段以防止端點被用於'拒絕服務'攻擊。endpoints.health.time-to-live屬性被用來配置緩存時間（單位爲毫秒），默認爲1000毫秒，也就是1秒。
上述的限制能夠被禁止，從而容許匿名用戶徹底訪問健康端點。想達到這個效果，將能夠endpoints.health.sensitive設爲false。
5.4基於JMX的監控和管理
Java管理擴展（JMX）提供了一種標準的監控和管理應用的機制。默認狀況下，Spring Boot在org.springframework.boot域下將管理端點暴露爲JMX MBeans。
5.4.1自定義MBean名稱
的MBean的名稱一般產生於端點的ID。例如，健康端點被暴露爲org.springframework.boot/Endpoint/HealthEndpoint。
若是你的應用包含多個Spring ApplicationContext，你會發現存在名稱衝突。爲了解決這個問題，你能夠將endpoints.jmx.uniqueNames設置爲真，這樣MBean的名稱老是惟一的。
你也能夠自定義JMX域，全部的端點都在該域下暴露。這裏有個app.properties示例：···java endpoints.jmx.domain = myapp endpoints.jmx.uniqueNames = true
5.4.2禁用JMX端點
若是不想經過JMX暴露端點，你能夠將spring.jmx.enabled屬性設置爲假：
spring.jmx.enabled=false
5.4.3使用Jolokia經過HTTP實現JMX遠程管理
Jolokia是一個JMX-HTTP橋，它提供了一種訪問JMX beans的替代方法。想要使用Jolokia，只需添加org.jolokia:jolokia-core的依賴。例如，使用Maven須要添加下面的配置：
<dependency> <groupId>org.jolokia</groupId> <artifactId>jolokia-core</artifactId> </dependency>
在你的管理HTTP上服務器能夠經過/jolokia訪問椒。
5.4.3.1自定義Jolokia
Jolokia有不少配置，傳統上通常使用servlet參數進行設置。使用Spring Boot，你能夠在application.properties中經過把參數加上jolokia.config。前綴來設置：
jolokia.config.debug=true
5.4.3.2禁用Jolokia
若是你正在使用Jolokia，但不想讓Spring Boot配置它，只須要簡單的將endpoints.jolokia.enabled屬性設置爲false：
endpoints.jolokia.enabled=false
5.4.4使用遠程shell來進行監控和管理
Spring Boot支持集成一個稱爲'CRaSH'的Java shell。你能夠在CRaSH中使用ssh或telnet命令鏈接到運行的應用。爲了啓用遠程shell支持，你只需添加spring-boot-starter-remote-shell的依賴：
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-remote-shell</artifactId> </dependency>
注：若是想使用遠程登陸訪問，還需你對添加org.crsh:crsh.shell.telnet的依賴。
5.4.4.1鏈接遠程shell
默認狀況下，遠程shell監聽端口2000以等待鏈接。默認用戶名爲user，密碼爲隨機生成的，而且在輸出日誌中會顯示。若是應用使用Spring Security，該shell默認使用相同的配置。若是不是，將使用一個簡單的認證策略，你可能會看到相似這樣的信息：
Using default password for shell access: ec03e16c-4cf4-49ee-b745-7c8255c1dd7e
Linux和OSX用戶能夠使用ssh鏈接遠程shell，Windows用戶能夠下載並安裝PuTTY。
$ ssh -p 2000 user@localhost user@localhost's password: . ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ \\/ ___)| |_)| | | | | || (_| | ) ) ) ) ' |____| .__|_| |_|_| |_\__, | / / / / =========|_|==============|___/=/_/_/_/ :: Spring Boot :: (v1.3.0.BUILD-SNAPSHOT) on myhost
輸入help能夠獲取一系列命令的幫助。Spring boot提供metrics，beans，autoconfig和endpoint命令。
5.4.4.1.1 遠程shell證書
你能夠使用shell.auth.simple.user.name和shell.auth.simple.user.password屬性配置自定義的鏈接證書。也能夠使用Spring Security的AuthenticationManager處理登陸職責。具體參考JavadocCrshAutoConfiguration和ShellProperties。
5.4.4.2 擴展遠程shell
有不少有趣的方式能夠用來擴展遠程shell。
5.4.4.2.1 遠程shell命令
你能夠使用Groovy或Java編寫其餘的shell命令（具體參考CRaSH文檔）。默認狀況下，Spring Boot會搜索如下路徑的命令：
- classpath:/commands/*
- classpath:/crash/commands/*
注：能夠經過shell.commandPathPatterns屬性改變搜索路徑。
下面是一個從src/main/resources/commands/hello.groovy加載的'hello world'命令：
package commands import org.crsh.cli.Usage import org.crsh.cli.Command class hello { @Usage("Say Hello") @Command def main(InvocationContext context) { return "Hello" } }
Spring Boot將一些額外屬性添加到了InvocationContext，你能夠在命令中訪問它們：
| 屬性名稱 | 描述 |
|---|---|
| spring.boot.version | Spring Boot的版本 |
| spring.version | Spring框架的核心版本 |
| spring.beanfactory | 獲取Spring的BeanFactory |
| spring.environment | 獲取Spring的Environment |
5.4.4.2.2 遠程shell插件
除了建立新命令，也能夠擴展CRaSH shell的其餘特性。全部繼承org.crsh.plugin.CRaSHPlugin的Spring Beans將自動註冊到shell。
具體查看CRaSH參考文檔。
5.4.5 度量指標
Spring Boot執行器包括一個支持'gauge'和'counter'級別的度量指標服務。'gauge'記錄一個單一值；'counter'記錄一個增量（增長或減小）。同時，Spring Boot提供一個PublicMetrics接口，你能夠實現它，從而暴露以上兩種機制不能記錄的指標。具體參考SystemPublicMetrics。
全部HTTP請求的指標都被自動記錄，因此若是點擊metrics端點，你可能會看到相似如下的響應：
{
"counter.status.200.root": 20, "counter.status.200.metrics": 3, "counter.status.200.star-star": 5, "counter.status.401.root": 4, "gauge.response.star-star": 6, "gauge.response.root": 2, "gauge.response.metrics": 3, "classes": 5808, "classes.loaded": 5808, "classes.unloaded": 0, "heap": 3728384, "heap.committed": 986624, "heap.init": 262144, "heap.used": 52765, "mem": 986624, "mem.free": 933858, "processors": 8, "threads": 15, "threads.daemon": 11, "threads.peak": 15, "uptime": 494836, "instance.uptime": 489782, "datasource.primary.active": 5, "datasource.primary.usage": 0.25 }
此處咱們能夠看到基本的memory，heap，class loading，processor和thread pool信息，連同一些HTTP指標。在該實例中，root('/')，/metrics URLs分別返回20次，3次HTTP 200響應。同時能夠看到root URL返回了4次HTTP 401（unauthorized）響應。雙asterix（star-star）來自於被Spring MVC /**匹配到的一個請求（一般爲一個靜態資源）。
gauge級別展現了一個請求的最後響應時間。因此，root的最後請求被響應耗時2毫秒，/metrics耗時3毫秒。
5.4.5.1 系統指標
Spring Boot暴露如下系統指標：
- 系統內存總量（mem），單位:Kb
- 空閒內存數量（mem.free），單位:Kb
- 處理器數量（processors）
- 系統正常運行時間（uptime），單位:毫秒
- 應用上下文（就是一個應用實例）正常運行時間（instance.uptime），單位:毫秒
- 系統平均負載（systemload.average）
- 堆信息（heap，heap.committed，heap.init，heap.used），單位:Kb
- 線程信息（threads，thread.peak，thead.daemon）
- 類加載信息（classes，classes.loaded，classes.unloaded）
- 垃圾收集信息（gc.xxx.count, gc.xxx.time）
5.4.5.2 數據源指標
Spring Boot會爲你應用中定義的支持的DataSource暴露如下指標：
- 最大鏈接數（datasource.xxx.max）
- 最小鏈接數（datasource.xxx.min）
- 活動鏈接數（datasource.xxx.active）
- 鏈接池的使用狀況（datasource.xxx.usage）
全部的數據源指標共用datasoure.前綴。該前綴對每一個數據源都很是合適：
- 若是是主數據源（惟一可用的數據源或存在的數據源中被@Primary標記的）前綴爲datasource.primary
- 若是數據源bean名稱以dataSource結尾，那前綴就是bean的名稱去掉dataSource的部分（例如，batchDataSource的前綴是datasource.batch）
- 其餘狀況使用bean的名稱做爲前綴
經過註冊一個自定義版本的DataSourcePublicMetrics bean，你能夠覆蓋部分或所有的默認行爲。默認狀況下，Spring Boot提供支持全部數據源的元數據；若是你喜歡的數據源剛好不被支持，你能夠添加另外的DataSourcePoolMetadataProvider beans。具體參考DataSourcePoolMetadataProvidersConfiguration。
5.4.5.3 Tomcat session指標
若是你使用Tomcat做爲內嵌的servlet容器，session指標將被自動暴露出去。 httpsessions.active和httpsessions.max提供了活動的和最大的session數量。
5.4.5.4 記錄本身的指標
想要記錄你本身的指標，只需將CounterService或GaugeService注入到你的bean中。CounterService暴露increment，decrement和reset方法；GaugeService提供一個submit方法。
下面是一個簡單的示例，它記錄了方法調用的次數：
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.actuate.metrics.CounterService; import org.springframework.stereotype.Service; @Service public class MyService { private final CounterService counterService; @Autowired public MyService(CounterService counterService) { this.counterService = counterService; } public void exampleMethod() { this.counterService.increment("services.system.myservice.invoked"); } }
注：你能夠將任何的字符串用做指標的名稱，但最好遵循所選存儲或圖技術的指南。Matt Aimonetti’s Blog中有一些好的關於圖（Graphite）的指南。
5.4.5.5 添加你本身的公共指標
想要添加額外的，每次指標端點被調用時都會從新計算的度量指標，只需簡單的註冊其餘的PublicMetrics實現bean(s)。默認狀況下，端點會聚合全部這樣的beans，經過定義本身的MetricsEndpoint能夠輕易改變這種狀況。
5.4.5.6 指標倉庫
經過綁定一個MetricRepository來實現指標服務。MetricRepository負責存儲和追溯指標信息。Spring Boot提供一個InMemoryMetricRepository和一個RedisMetricRepository（默認使用in-memory倉庫），不過你能夠編寫本身的MetricRepository。MetricRepository接口實際是MetricReader接口和MetricWriter接口的上層組合。具體參考Javadoc
沒有什麼能阻止你直接將MetricRepository的數據導入應用中的後端存儲，但咱們建議你使用默認的InMemoryMetricRepository（若是擔憂堆使用狀況，你能夠使用自定義的Map實例），而後經過一個scheduled export job填充後端倉庫（意思是先將數據保存到內存中，而後經過異步job將數據持久化到數據庫，能夠提升系統性能）。經過這種方式，你能夠將指標數據緩存到內存中，而後經過低頻率或批量導出來減小網絡擁堵。Spring Boot提供一個Exporter接口及一些幫你開始的基本實現。
5.4.5.7 Dropwizard指標
Dropwizard ‘Metrics’庫的用戶會發現Spring Boot指標被髮布到了com.codahale.metrics.MetricRegistry。當你聲明對io.dropwizard.metrics:metrics-core庫的依賴時會建立一個默認的com.codahale.metrics.MetricRegistry Spring bean；若是須要自定義，你能夠註冊本身的@Bean實例。來自於MetricRegistry的指標也是自動經過/metrics端點暴露的。
用戶能夠經過使用合適類型的指標名稱做爲前綴來建立Dropwizard指標（好比，histogram.* , meter.*）。
5.4.5.8 消息渠道集成
若是你的classpath下存在'Spring Messaging' jar，一個名爲metricsChannel的MessageChannel將被自動建立（除非已經存在一個）。此外，全部的指標更新事件做爲'messages'發佈到該渠道上。訂閱該渠道的客戶端能夠進行額外的分析或行動。
5.4.6 審計
Spring Boot執行器具備一個靈活的審計框架，一旦Spring Security處於活動狀態（默認拋出'authentication success'，'failure'和'access denied'異常），它就會發布事件。這對於報告很是有用，同時能夠基於認證失敗實現一個鎖定策略。
你也能夠使用審計服務處理本身的業務事件。爲此，你能夠將存在的AuditEventRepository注入到本身的組件，並直接使用它，或者只是簡單地經過Spring ApplicationEventPublisher發佈AuditApplicationEvent（使用ApplicationEventPublisherAware）。
5.4.7 追蹤（Tracing）
對於全部的HTTP請求Spring Boot自動啓用追蹤。你能夠查看trace端點，並獲取最近一些請求的基本信息：
[{
"timestamp": 1394343677415, "info": { "method": "GET", "path": "/trace", "headers": { "request": { "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8", "Connection": "keep-alive", "Accept-Encoding": "gzip, deflate", "User-Agent": "Mozilla/5.0 Gecko/Firefox", "Accept-Language": "en-US,en;q=0.5", "Cookie": "_ga=GA1.1.827067509.1390890128; ..." "Authorization": "Basic ...", "Host": "localhost:8080" }, "response": { "Strict-Transport-Security": "max-age=31536000 ; includeSubDomains", "X-Application-Context": "application:8080", "Content-Type": "application/json;charset=UTF-8", "status": "200" } } } },{ "timestamp": 1394343684465, ... }]
5.4.7.1 自定義追蹤
若是須要追蹤其餘的事件，你能夠將一個TraceRepository注入到你的Spring Beans中。add方法接收一個將被轉化爲JSON的Map結構，該數據將被記錄下來。
默認狀況下，使用的InMemoryTraceRepository將存儲最新的100個事件。若是須要擴展該容量，你能夠定義本身的InMemoryTraceRepository實例。若是須要，你能夠建立本身的替代TraceRepository實現。
5.4.8 進程監控
在Spring Boot執行器中，你能夠找到幾個建立有利於進程監控的文件的類：
- ApplicationPidFileWriter建立一個包含應用PID的文件（默認位於應用目錄，文件名爲application.pid）
- EmbeddedServerPortFileWriter建立一個或多個包含內嵌服務器端口的文件（默認位於應用目錄，文件名爲application.port）
默認狀況下，這些writers沒有被激活，但你能夠使用下面描述的任何方式來啓用它們。
5.4.8.1 擴展屬性
你須要激活META-INF/spring.factories文件裏的listener(s)：
org.springframework.context.ApplicationListener=\ org.springframework.boot.actuate.system.ApplicationPidFileWriter, org.springframework.boot.actuate.system.EmbeddedServerPortFileWriter
5.4.8.2 以編程方式
你也能夠經過調用SpringApplication.addListeners(…)方法來激活一個監聽器，並傳遞相應的Writer對象。該方法容許你經過Writer構造器自定義文件名和路徑。
部署到雲端
對於大多數流行雲PaaS（平臺即服務）提供商，Spring Boot的可執行jars就是爲它們準備的。這些提供商每每要求你帶上本身的容器;它們管理應用的進程（不特別針對Java應用程序），因此它們須要一些中間層來將你的應用適配到雲概念中的一個運行進程。
兩個流行的雲提供商，Heroku和Cloud Foundry，採起一個打包（'buildpack'）方法。爲了啓動你的應用程序，無論須要什麼，buildpack都會將它們打包到你的部署代碼：它多是一個JDK和一個Java的調用，也多是一個內嵌的Web服務器，或者是一個成熟的應用服務器.buildpack是可插拔的，但你最好儘量少的對它進行自定義設置。這能夠減小不受你控制的功能範圍，最小化部署和生產環境的發散。
理想狀況下，你的應用就像一個Spring Boot可執行jar，全部運行須要的東西都打包到它內部。
6.1 Cloud Foundry
若是不指定其餘打包方式，Cloud Foundry會啓用它提供的默認打包方式.Cloud Foundry的Java buildpack對Spring應用有出色的支持，包括Spring Boot。你能夠部署獨立的可執行jar應用，也能夠部署傳統的的.war形式的應用。
一旦你構建了應用（好比，使用mvn clean package）並安裝了cf命令行工具，你能夠使用下面的cf push命令（將路徑指向你編譯後的.jar）來部署應用。在發佈一個應用前，確保你已登錄CF命令行客戶端。
$ cf push acloudyspringtime -p target/demo-0.0.1-SNAPSHOT.jar
查看cf push文檔獲取更多可選項。若是相同目錄下存在manifest.yml，Cloud Foundry會使用它。
就此，比照開始上傳你的應用：
Uploading acloudyspringtime... OK
Preparing to start acloudyspringtime... OK
-----> Downloaded app package (8.9M) -----> Java Buildpack source: system -----> Downloading Open JDK 1.7.0_51 from .../x86_64/openjdk-1.7.0_51.tar.gz (1.8s) Expanding Open JDK to .java-buildpack/open_jdk (1.2s) -----> Downloading Spring Auto Reconfiguration from 0.8.7 .../auto-reconfiguration-0.8.7.jar (0.1s) -----> Uploading droplet (44M) Checking status of app 'acloudyspringtime'... 0 of 1 instances running (1 starting) ... 0 of 1 instances running (1 down) ... 0 of 1 instances running (1 starting) ... 1 of 1 instances running (1 running) App started
恭喜！應用如今處於運行狀態！
檢驗部署應用的狀態是很簡單的：
$ cf apps
Getting applications in ... OK name requested state instances memory disk urls ... acloudyspringtime started 1/1 512M 1G acloudyspringtime.cfapps.io ...
一旦Cloud Foundry意識到你的應用已經部署，你就能夠點擊給定的應用URI，此處是acloudyspringtime.cfapps.io/。
6.1.1綁定服務
默認狀況下，運行應用的元數據和服務鏈接信息被暴露爲應用的環境變量（好比，$ VCAP_SERVICES）。採用這種架構的緣由是由於Cloud Foundry多語言特性（任何語言和平臺都支持做爲buildpack） 。進程級別的環境變量是語言無關（語言不可知）的。
環境變量並不老是有利於設計最簡單的API，因此Spring Boot自動提取它們，而後將這些數據導入可以經過Spring Environment抽象訪問的屬性裏：
@Component class MyBean implements EnvironmentAware { private String instanceId; @Override public void setEnvironment(Environment environment) { this.instanceId = environment.getProperty("vcap.application.instance_id"); } // ... }
全部的Cloud Foundry屬性都以vcap做爲前綴。你能夠使用vcap屬性獲取應用信息（好比應用的公共URL）和服務信息（好比數據庫證書）。具體參考VcapApplicationListener Javadoc。
注：Spring Cloud Connectors項目很適合好比配置數據源的任務.Spring Boot提供自動配置支持和一個spring-boot-starter-cloud-connectors starter POM。
6.2 Heroku
Heroku的是另一個流行的PAAS平臺。想要自定義的Heroku的構建過程，你能夠提供一個Procfile，它提供部署一個應用所需的指令.Heroku爲Java的應用分配一個端口，確保可以路由到外部URI。
你必須配置你的應用監聽正確的端口。下面是用於咱們的啓動器REST應用的Procfile：
web: java -Dserver.port=$PORT -jar target/demo-0.0.1-SNAPSHOT.jar
Spring Boot將-D參數做爲屬性，經過一個Spring的Environment實例訪問.server.port配置屬性適合於內嵌的Tomcat，Jetty或Undertow實例啓用時使用。$ PORT環境變量被分配給Heroku Paas使用。
Heroku默認使用Java 1.6。只要你的Maven或Gradle構建時使用相同的版本就沒問題（Maven用戶能夠設置java.version屬性）。若是你想使用JDK 1.7，在你的pom.xml和Procfile臨近處建立一個system.properties文件。在該文件中添加如下設置：
java.runtime.version=1.7
這就是你須要作的一切。對於Heroku部署來講，常常作的工做就是使用git push將代碼推送到生產環境。
$ git push heroku master
Initializing repository, done. Counting objects: 95, done. Delta compression using up to 8 threads. Compressing objects: 100% (78/78), done. Writing objects: 100% (95/95), 8.66 MiB | 606.00 KiB/s, done. Total 95 (delta 31), reused 0 (delta 0) -----> Java app detected -----> Installing OpenJDK 1.7... done -----> Installing Maven 3.2.3... done -----> Installing settings.xml... done -----> executing /app/tmp/cache/.maven/bin/mvn -B -Duser.home=/tmp/build_0c35a5d2-a067-4abc-a232-14b1fb7a8229 -Dmaven.repo.local=/app/tmp/cache/.m2/repository -s /app/tmp/cache/.m2/settings.xml -DskipTests=true clean install [INFO] Scanning for projects... Downloading: http://repo.spring.io/... Downloaded: http://repo.spring.io/... (818 B at 1.8 KB/sec) .... Downloaded: http://s3pository.heroku.com/jvm/... (152 KB at 595.3 KB/sec) [INFO] Installing /tmp/build_0c35a5d2-a067-4abc-a232-14b1fb7a8229/target/... [INFO] Installing /tmp/build_0c35a5d2-a067-4abc-a232-14b1fb7a8229/pom.xml ... [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 59.358s [INFO] Finished at: Fri Mar 07 07:28:25 UTC 2014 [INFO] Final Memory: 20M/493M [INFO] ------------------------------------------------------------------------ -----> Discovering process types Procfile declares types -> web -----> Compressing... done, 70.4MB -----> Launching... done, v6 http://agile-sierra-1405.herokuapp.com/ deployed to Heroku To git@heroku.com:agile-sierra-1405.git * [new branch] master -> master
如今你的應用已經啓動並運行在Heroku。
6.3 Openshift
Openshift是RedHat公共（和企業）PaaS解決方案。和Heroku類似，它也是經過運行被git提交觸發的腳原本工做的，因此你能夠使用任何你喜歡的方式編寫Spring Boot應用啓動腳本，只要Java運行時環境可用（這是在Openshift上能夠要求的一個標準特性）。爲了實現這樣的效果，你能夠使用DIY Cartridge，並在.openshift/action_scripts下hooks你的倉庫：
基本模式以下：
1.確保Java和構建工具已被遠程安裝，好比使用一個pre_build hook（默認會安裝Java和Maven，不會安裝Gradle）。
2.使用一個build hook去構建你的jar（使用Maven或Gradle），好比
#!/bin/bash cd $OPENSHIFT_REPO_DIR mvn package -s .openshift/settings.xml -DskipTests=true
3.添加一個調用java -jar …的start hook
#!/bin/bash cd $OPENSHIFT_REPO_DIR nohup java -jar target/*.jar --server.port=${OPENSHIFT_DIY_PORT} --server.address=${OPENSHIFT_DIY_IP} &
4.使用一個stop hook
#!/bin/bash source $OPENSHIFT_CARTRIDGE_SDK_BASH PID=$(ps -ef | grep java.*\.jar | grep -v grep | awk '{ print $2 }') if [ -z "$PID" ] then client_result "Application is already stopped" else kill $PID fi
5.將內嵌的服務綁定到平臺提供的在application.properties定義的環境變量，好比
spring.datasource.url: jdbc:mysql://${OPENSHIFT_MYSQL_DB_HOST}:${OPENSHIFT_MYSQL_DB_PORT}/${OPENSHIFT_APP_NAME} spring.datasource.username: ${OPENSHIFT_MYSQL_DB_USERNAME} spring.datasource.password: ${OPENSHIFT_MYSQL_DB_PASSWORD}
在Openshift的網站上有一篇running Gradle in Openshift博客，若是想使用gradle構建運行的應用能夠參考它。因爲一個Gradle bug，你不能使用高於1.6版本的Gradle。
6.4 Google App Engine
Google App Engine跟Servlet 2.5 API是有聯繫的，因此在不修改的狀況系你是不能部署一個Spring應用的。具體查看本指南的Servlet 2.5章節 Container.md)。
Spring Boot CLI
Spring Boot CLI是一個命令行工具，若是想使用Spring進行快速開發能夠使用它。它容許你運行Groovy腳本，這意味着你能夠使用熟悉的類Java語法，而且沒有那麼多的模板代碼。你也能夠啓動一個新的項目或爲Spring Boot CLI編寫本身的命令。
7.1 安裝CLI
你能夠手動安裝Spring Boot CLI，也能夠使用GVM（Groovy環境管理工具）或Homebrew，MacPorts（若是你是一個OSX用戶）。參考"Getting started"的Section 10.2, 「Installing the Spring Boot CLI」 能夠看到全面的安裝指令。
7.2 使用CLI
一旦安裝好CLI，你能夠輸入spring來運行它。若是你不使用任何參數運行spring，將會展示一個簡單的幫助界面：
$ spring
usage: spring [--help] [--version] [] Available commands are: run [options] [--] [args] Run a spring groovy script ... more command help is shown here
你能夠使用help獲取任何支持命令的詳細信息。例如：
$ spring help run
spring run - Run a spring groovy script
usage: spring run [options] [--] [args]
Option Description
------ -----------
--autoconfigure [Boolean] Add autoconfigure compiler transformations (default: true) --classpath, -cp Additional classpath entries -e, --edit Open the file with the default system editor --no-guess-dependencies Do not attempt to guess dependencies --no-guess-imports Do not attempt to guess imports -q, --quiet Quiet logging -v, --verbose Verbose logging of dependency resolution --watch Watch the specified file for changes
version命令提供一個檢查你正在使用的Spring Boot版本的快速方式：
$ spring version
Spring CLI v1.3.0.BUILD-SNAPSHOT
7.2.1 使用CLI運行應用
你能夠使用run命令編譯和運行Groovy源代碼。Spring Boot CLI徹底自包含，以至於你不須要安裝任何外部的Groovy。
下面是一個使用Groovy編寫的"hello world" web應用： hello.grooy
@RestController class WebApplication { @RequestMapping("/") String home() { "Hello World!" } }
想要編譯和運行應用，輸入：
$ spring run hello.groovy
想要給應用傳遞命令行參數，你須要使用一個--來將它們和"spring"命令參數區分開來。例如：
$ spring run hello.groovy -- --server.port=9000
想要設置JVM命令行參數，你能夠使用JAVA_OPTS環境變量，例如：
$ JAVA_OPTS=-Xmx1024m spring run hello.groovy
7.2.1.1推斷「抓」依賴
標準的Groovy的一個全部遊戲@Grab註解，它容許你聲明對第三方庫的依賴。這項有用的技術容許的Groovy以和的Maven或搖籃相同的方式下載廣口瓶，但不須要使用構建工具。
Spring Boot進一步延伸了該技術，它會基於你的代碼嘗試推導你「搶」哪一個庫。例如，因爲WebApplication代碼上使用了@RestController註解，「Tomcat」和「Spring MVC」將被獲取（抓住）。
下面的項目被用做「grab hints」：
| 項目 | 抓鬥 |
|---|---|
| JdbcTemplate的，是NamedParameterJdbcTemplate，數據源 | JDBC應用 |
| @EnableJms | JMS應用 |
| @EnableCaching | 緩存抽象 |
| @測試 | JUnit的 |
| @EnableRabbit | 的RabbitMQ |
| @EnableReactor | 項目反應堆 |
| 繼承規範 | Spock測試 |
| @EnableBatchProcessing | 春天的批次 |
| @ MessageEndpoint，@ EnableIntegrationPatterns | Spring集成 |
| @EnableDeviceResolver | Spring Mobile |
| @控制器@ RestController，@ EnableWebMvc | Spring MVC +嵌入式Tomcat |
| @EnableWebSecurity | Spring Security |
| @EnableTransactionManagement | 春季交易管理 |
注：想要理解自定義是如何生效，能夠查看Spring Boot CLI源碼中的CompilerAutoConfiguration子類。
7.2.1.2推斷「搶」座標
Spring Boot擴展Groovy標準「@Grab」註解使其可以容許你指定一個沒有組或版本的依賴，例如@Grab（'freemarker'）。artifact's的組和版本是經過查看Spring Boot的依賴元數據推斷出來的。注意默認的元數據是和你使用的命令行版本綁定的 - 只有在你遷移到一個CLI新版本時它纔會改變，這樣當你的依賴改變時你就能夠控制了在附錄的表格中能夠查看默認元數據包含的依賴和它們的版本。
7.2.1.3默認導入語句
爲了幫助你減小Groovy的代碼量，一些進口語句被自動包含進來了。注意上面的示例中引用@組件，@ RestController和@RequestMapping而沒有使用全限定名或導入語句。
注：不少春天註解在不使用進口語句的狀況下能夠正常工做嘗試運行你的應用，看一下在添加進口以前哪些會失敗。
7.2.1.4自動建立主方法
跟等效的Java應用不一樣，你不須要在Groovy腳本中添加一個public static void main（String [] args）方法.Spring Boot會使用你編譯後的代碼自動建立一個SpringApplication。
7.2.1.5自定義「抓」元數據
Spring Boot提供一個新的@GrabMetadata註解，你能夠使用它提供自定義的依賴元數據，以覆蓋Spring Boot的默認配置。該元數據經過使用提供一個或多個配置文件座標的註解來指定（使用一個屬性標識符 「類型」 部署到Maven的倉庫）..配置文件中的每一個實體必須遵循組：模塊=版本的格式。
例如，下面的聲明：
`@GrabMetadata("com.example.custom-versions:1.0.0")`
將會加載的Maven處於倉庫com/example/custom-versions/1.0.0/下的custom-versions-1.0.0.properties文件。
能夠經過註解指定多個屬性文件，它們會以聲明的順序被使用例如：
`@GrabMetadata(["com.example.custom-versions:1.0.0", "com.example.more-versions:1.0.0"])`
意味着位於多個版本的屬性將覆蓋位於定製版本的屬性。
你能夠在任何可以使用@Grab的地方使用@GrabMetadata，然而，爲了確保元數據的順序一致，你在應用程序中最多隻能使用一次@ GrabMetadata.Spring IO平臺是一個很是有用的依賴元數據源（ Spring Boot的超集），例如：
@GrabMetadata('io.spring.platform:platform-versions:1.0.4.RELEASE')
7.2.2測試你的代碼
測試命令容許你編譯和運行應用程序的測試用例常規使用方式以下：
$ spring test app.groovy tests.groovy Total: 1, Success: 1, : Failures: 0 Passed? true
在這個示例中，test.groovy包含JUnit @Test方法或Spock規範類。全部的普通框架註解和靜態方法在不使用import導入的狀況下，仍舊能夠使用。
下面是咱們使用的test.groovy文件（含有一個JUnit的測試）：
class ApplicationTests { @Test void homeSaysHello() { assertEquals("Hello World!", new WebApplication().home()) } }
注：若是有多個測試源文件，你能夠傾向於使用一個測試目錄來組織它們。
7.2.3多源文件應用
你能夠在全部接收文件輸入的命令中使用外殼通配符這容許你輕鬆處理來自一個目錄下的多個文件，例如：
$ spring run *.groovy
若是你想將 '測試' 或 '規範' 代碼從主應用代碼中分離，這項技術就十分有用了：
$ spring test app/*.groovy test/*.groovy
7.2.4應用打包
你能夠使用的jar命令打包應用程序爲一個可執行的JAR文件例如：
$ spring jar my-app.jar *.groovy
最終的jar包括編譯應用產生的類和全部依賴，這樣你就能夠使用java -jar來執行它了。該jar文件也包括來自應用classpath的實體。你能夠使用--include和--exclude添加明確的路徑（二者都是用逗號分割，一樣都接收值爲'+'和'-'的前綴，'-'意味着它們將從默認設置中移除）。默認包含（includes）：
public/**, resources/**, static/**, templates/**, META-INF/**, *
默認排除(excludes)：
.*, repository/**, build/**, target/**, **/*.jar, **/*.groovy
查看spring help jar能夠得到更多信息。
7.2.5 初始化新工程
init命令容許你使用start.spring.io在不離開shell的狀況下建立一個新的項目。例如：
$ spring init --dependencies=web,data-jpa my-project
Using service at https://start.spring.io Project extracted to '/Users/developer/example/my-project'
這建立了一個my-project目錄，它是一個基本Maven且依賴spring-boot-starter-web和spring-boot-starter-data-jpa的項目。你能夠使用--list參數列出該服務的能力。
$ spring init --list ======================================= Capabilities of https://start.spring.io ======================================= Available dependencies: ----------------------- actuator - Actuator: Production ready features to help you monitor and manage your application ... web - Web: Support for full-stack web development, including Tomcat and spring-webmvc websocket - Websocket: Support for WebSocket development ws - WS: Support for Spring Web Services Available project types: ------------------------ gradle-build - Gradle Config [format:build, build:gradle] gradle-project - Gradle Project [format:project, build:gradle] maven-build - Maven POM [format:build, build:maven] maven-project - Maven Project [format:project, build:maven] (default) ...
init命令支持不少選項，查看help輸出能夠得到更多詳情。例如，下面的命令建立一個使用Java8和war打包的gradle項目：
$ spring init --build=gradle --java-version=1.8 --dependencies=websocket --packaging=war sample-app.zip Using service at https://start.spring.io Content saved to 'sample-app.zip'
7.2.6 使用內嵌shell
Spring Boot包括完整的BASH和zsh shells的命令行腳本。若是你不使用它們中的任何一個（可能你是一個Window用戶），那你能夠使用shell命令啓用一個集成shell。
$ spring shell
Spring Boot (v1.3.0.BUILD-SNAPSHOT) Hit TAB to complete. Type \'help' and hit RETURN for help, and \'exit' to quit.
從內嵌shell中能夠直接運行其餘命令：
$ version
Spring CLI v1.3.0.BUILD-SNAPSHOT
內嵌shell支持ANSI顏色輸出和tab補全。若是須要運行一個原生命令，你能夠使用$前綴。點擊ctrl-c將退出內嵌shell。
7.2.7 爲CLI添加擴展
使用install命令能夠爲CLI添加擴展。該命令接收一個或多個格式爲group:artifact:version的artifact座標集。例如：
$ spring install com.example:spring-boot-cli-extension:1.0.0.RELEASE
除了安裝你提供座標的artifacts標識外，全部依賴也會被安裝。使用uninstall能夠卸載一個依賴。和install命令同樣，它接收一個或多個格式爲group:artifact:version的artifact座標集。例如：
$ spring uninstall com.example:spring-boot-cli-extension:1.0.0.RELEASE
它會經過你提供的座標卸載相應的artifacts標識和它們的依賴。
爲了卸載全部附加依賴，你能夠使用--all選項。例如：
$ spring uninstall --all
7.3 使用Groovy beans DSL開發應用
Spring框架4.0版本對beans{} DSL（借鑑自Grails）提供原生支持，你能夠使用相同的格式在你的Groovy應用程序腳本中嵌入bean定義。有時候這是一個包括外部特性的很好的方式，好比中間件聲明。例如：
@Configuration class Application implements CommandLineRunner { @Autowired SharedService service @Override void run(String... args) { println service.message } } import my.company.SharedService beans { service(SharedService) { message = "Hello World" } }
你能夠使用beans{}混合位於相同文件的類聲明，只要它們都處於頂級，或若是你喜歡的話，能夠將beans DSL放到一個單獨的文件中。
構建工具插件
Spring Boot爲Maven和Gradle提供構建工具插件。該插件提供各類各樣的特性，包括打包可執行jars。本節提供關於插件的更多詳情及用於擴展一個不支持的構建系統所需的幫助信息。若是你是剛剛開始，那可能須要先閱讀Part III, 「Using Spring Boot」章節的「Chapter 13, Build systems」。
8.1 Spring Boot Maven插件
Spring Boot Maven插件爲Maven提供Spring Boot支持，它容許你打包可執行jar或war存檔，而後就地運行應用。爲了使用它，你須要使用Maven 3.2 （或更高版本）。
注：參考Spring Boot Maven插件站點能夠獲取所有的插件文檔。
8.1.1包含該插件
想要使用Spring Boot Maven插件只需簡單地在你的pom.xml的插件部分包含相應的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> <!-- ... --> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <version>1.3.0.BUILD-SNAPSHOT</version> <executions> <execution> <goals> <goal>repackage</goal> </goals> </execution> </executions> </plugin> </plugins> </build> </project>
該配置會在Maven的生命週期的包裝階段從新打包一個罐子或戰爭下面的示例顯示在目標目錄下既有從新打包後的罐子，也有原始的罐子：
$ mvn package
$ ls target/*.jar
target/myproject-1.0.0.jar target/myproject-1.0.0.jar.original
若是不包含像上面那樣的<執行/>，你能夠本身運行該插件（但只有在包目標也被使用的狀況）例如：
$ mvn package spring-boot:repackage $ ls target/*.jar target/myproject-1.0.0.jar target/myproject-1.0.0.jar.original
若是使用一個里程碑或快照版本，你還須要添加正確的pluginRepository元素：
<pluginRepositories> <pluginRepository> <id>spring-snapshots</id> <url>http://repo.spring.io/snapshot</url> </pluginRepository> <pluginRepository> <id>spring-milestones</id> <url>http://repo.spring.io/milestone</url> </pluginRepository> </pluginRepositories>
8.1.2打包可執行jar和war文件
一旦彈簧引導Maven的插件被包含到你的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"> <!-- ... --> <packaging>jar</packaging> <!-- ... --> </project>
生成的存檔在包階段會被Spring Boot加強。你想啓動的主類便可以經過指定一個配置選項，也能夠經過爲manifest添加一個Main-Class屬性這種常規的方式實現。若是你沒有指定一個main類，該插件會搜索帶有public static void main（String [] args）方法的類。
爲了構建和運行一個項目的神器，你能夠輸入如下命令：
$ mvn package
$ java -jar target/mymodule-0.0.1-SNAPSHOT.jar
爲了構建一個便是可執行的，又能部署到一個外部容器的戰爭文件，你須要標記內嵌容器依賴爲 「提供」，例如：
<?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"> <!-- ... --> <packaging>war</packaging> <!-- ... --> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> <scope>provided</scope> </dependency> <!-- ... --> </dependencies> </project>
注：參考具體「Section 74.1, 「Create a deployable war file」章節。
在插件信息頁面有高級的配置選項和示例。
8.2 Spring Boot Gradle插件
Spring Boot Gradle插件爲Gradle提供Spring Boot支持，運行Spring Boot應用，對於「神聖的」依賴能夠在你的build.gradle文件中省略版本信息。
8.2.1包含該插件
想要使用Spring Boot Gradle插件，你只需簡單的包含一個buildscript依賴，並應用spring-boot插件：
buildscript {
dependencies {
classpath("org.springframework.boot:spring-boot-gradle-plugin:1.3.0.BUILD-SNAPSHOT") } } apply plugin: 'spring-boot'
若是想使用一個里程碑或快照版本，你能夠添加相應的庫引用：
buildscript {
repositories {
maven.url "http://repo.spring.io/snapshot" maven.url "http://repo.spring.io/milestone" } // ... }
8.2.2聲明不帶版本的依賴
對於充分使用該功能，只須要想一般那樣聲明依賴，可是將版本號設置爲空：
dependencies {
compile("org.springframework.boot:spring-boot-starter-web") compile("org.thymeleaf:thymeleaf-spring4") compile("nz.net.ultraq.thymeleaf:thymeleaf-layout-dialect") }
注：你聲明的spring-boot Gradle插件的版本決定了「blessed」依賴的實際版本（確保能夠重複構建）。你最好老是將spring-boot gradle插件版本設置爲你想用的Spring Boot實際版本。提供的版本詳細信息能夠在附錄中找到。
春天啓動插件對於沒有指定版本的依賴只會提供一個版本若是不想使用插件提供的版本，你能夠像日常那樣在聲明依賴的時候指定版本例如：
dependencies {
compile("org.thymeleaf:thymeleaf-spring4:2.1.1.RELEASE") }
8.2.2.1自定義版本管理
若是你須要不一樣於Spring Boot的「blessed」依賴，有可能的話能夠自定義ResolutionStrategy使用的版本。替代的版本元數據使用版本管理配置。例如：
dependencies {
versionManagement("com.mycorp:mycorp-versions:1.0.0.RELEASE@properties") compile("org.springframework.data:spring-data-hadoop") }
。版本信息須要做爲一個的.properties文件發佈到一個倉庫中對於上面的示例，mycorp-versions.properties文件可能包含如下內容：
org.springframework.data\:spring-data-hadoop=2.0.0.RELEASE
屬性文件優先於Spring Boot默認設置，若是有必要的話能夠覆蓋版本號。
8.2.3默認排除規則
Gradle處理「排除規則」的方式和Maven稍微有些不一樣，在使用起始POMs時這可能會引發沒法預料的結果。特別地，當一個依賴能夠經過不一樣的路徑訪問時，對該依賴聲明的排除將不會生效。例如，若是一個starter POM聲明如下內容：
<dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>4.0.5.RELEASE</version> <exclusions> <exclusion> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>4.0.5.RELEASE</version> </dependency> </dependencies>
commons-logging jar不會被Gradle排除，由於經過沒有排除元素的spring-context能夠傳遞性的拉取到它（spring-context→spring-core→commons-logging）。
爲了確保正確的排除被實際應用，Spring Boot Gradle插件將自動添加排除規則。全部排除被定義在spring-boot-dependencies POM，而且針對「starter」POMs的隱式規則也會被添加。
若是不想自動應用排除規則，你能夠使用如下配置：
springBoot {
applyExcludeRules=false }
8.2.4打包可執行jar和war文件
一旦彈簧啓動插件被應用到你的項目，它將使用bootRepackage任務自動嘗試重寫存檔以使它們可以執行。爲了構建一個罐子或戰爭，你須要按一般的方式配置項目。
你想啓動的主類既能夠經過一個配置選項指定，也能夠經過向manifest添加一個Main-Class屬性。若是你沒有指定主類，該插件會搜索帶有公共靜態void main（String [] args）方法的類。
爲了構建和運行一個項目的神器，你能夠輸入如下內容：
$ gradle build
$ java -jar build/libs/mymodule-0.0.1-SNAPSHOT.jar
爲了構建一個即能執行也能夠部署到外部容器的戰爭包，你須要將內嵌容器依賴標記爲 「providedRuntime」，好比：
...
apply plugin: 'war' war { baseName = 'myapp' version = '0.5.0' } repositories { jcenter() maven { url "http://repo.spring.io/libs-snapshot" } } configurations { providedRuntime } dependencies { compile("org.springframework.boot:spring-boot-starter-web") providedRuntime("org.springframework.boot:spring-boot-starter-tomcat") ... }
注：具體參考「第74.1節」，建立可部署的war文件「」。
8.2.5就地（就地）運行項目
爲了在不先構建JAR的狀況下運行項目，你能夠使用 「bootRun」 任務：
$ gradle bootRun
默認狀況下，以這種方式運行項目可讓你的靜態類路徑資源（好比，默認位於的src /主/資源下）在應用運行期間被從新加載。使靜態資源能夠從新加載意味着bootRun任務不會使用processResources任務的輸出，好比，當調用bootRun時，你的應用將以資源未處理的形式來使用它們。
你能夠禁止直接使用靜態classpath中資源這意味着資源再也不是可從新加載的，但processResources任務的輸出將會被使用想要這樣作，只需將bootRun任務的addResources設爲假。：
bootRun {
addResources = false }
8.2.6 Spring Boot插件配置
搖籃插件自動擴展你的構建腳本DSL，它爲腳本添加一個springBoot元素以此做爲引導插件的全局配置。你能夠像配置其餘搖籃擴展那樣爲springBoot設置相應的屬性（下面有配置選項列表）。
springBoot {
backupSource = false }
8.2.7從新包裝配置
該插件添加了一個bootRepackage任務，你能夠直接配置它，好比：
bootRepackage {
mainClass = 'demo.Application' }
下面是可用的配置選項：
| 名稱 | 描述 |
|---|---|
| 啓用 | 布爾值，用於控制再打包的開關（若是你只想要啓動的其餘特性而不是這個，那它就派上用場了） |
| mainClass | 要運行的主類。若是沒有指定，則使用項屬性mainClassName。若是沒有定義mainClassName id，則搜索存檔以尋找一個合適的類。「合適」意味着一個惟一的，具備良好格式的main（）方法的類（若是找到多個則構建會失敗）。你也能夠經過 「運行」 任務（主要屬性）指定主類的名稱，和/或將 「startScripts」（mainClassName屬性）做爲 「springBoot」 配置的替代。 |
| 分類 | 添加到存檔的一個文件名字段（在擴展以前），這樣最初保存的存檔仍舊存放在最初的位置。在存檔被從新打包（repackage）的狀況下，該屬性默認爲null。默認值適用於多數狀況，但若是你想在另外一個項目中使用原jar做爲依賴，最好使用一個擴展來定義該可執行jar |
| withJarTask | Jar任務的名稱或值，用於定位要被repackage的存檔 |
| customConfiguration | 自定義配置的名稱，用於填充內嵌的lib目錄（不指定該屬性，你將獲取全部編譯和運行時依賴） |
8.2.8 使用Gradle自定義配置進行Repackage
有時候不打包解析自compile，runtime和provided做用域的默認依賴可能更合適些。若是建立的可執行jar被原樣運行，你須要將全部的依賴內嵌進該jar中；然而，若是目的是explode一個jar文件，並手動運行main類，你可能在CLASSPATH下已經有一些可用的庫了。在這種狀況下，你能夠使用不一樣的依賴集從新打包（repackage）你的jar。
使用自定義的配置將自動禁用來自compile，runtime和provided做用域的依賴解析。自定義配置便可以定義爲全局的（處於springBoot部份內），也能夠定義爲任務級的。
task clientJar(type: Jar) { appendix = 'client' from sourceSets.main.output exclude('**/*Something*') } task clientBoot(type: BootRepackage, dependsOn: clientJar) { withJarTask = clientJar customConfiguration = "mycustomconfiguration" }
在以上示例中，咱們建立了一個新的clientJar Jar任務從你編譯後的源中打包一個自定義文件集。而後咱們建立一個新的clientBoot BootRepackage任務，並讓它使用clientJar任務和mycustomconfiguration。
configurations {
mycustomconfiguration.exclude group: 'log4j' } dependencies { mycustomconfiguration configurations.runtime }
在BootRepackage中引用的配置是一個正常的Gradle配置。在上面的示例中，咱們建立了一個新的名叫mycustomconfiguration的配置，指示它來自一個runtime，並排除對log4j的依賴。若是clientBoot任務被執行，從新打包的jar將含有全部來自runtime做用域的依賴，除了log4j jars。
8.2.8.1 配置選項
可用的配置選項以下：
| 名稱 | 描述 |
|---|---|
| mainClass | 可執行jar運行的main類 |
| providedConfiguration | provided配置的名稱（默認爲providedRuntime） |
| backupSource | 在從新打包以前，原先的存檔是否備份（默認爲true） |
| customConfiguration | 自定義配置的名稱 |
| layout | 存檔類型，對應於內部依賴是如何制定的（默認基於存檔類型進行推測） |
| requiresUnpack | 一個依賴列表（格式爲"groupId:artifactId"，爲了運行，它們須要從fat jars中解壓出來。）全部節點被打包進胖jar，但運行的時候它們將被自動解壓 |
8.2.9 理解Gradle插件是如何工做的
當spring-boot被應用到你的Gradle項目，一個默認的名叫bootRepackage的任務被自動建立。bootRepackage任務依賴於Gradle assemble任務，當執行時，它會嘗試找到全部限定符爲空的jar artifacts（也就是說，tests和sources jars被自動跳過）。
因爲bootRepackage查找'全部'建立jar artifacts的事實，Gradle任務執行的順序就很是重要了。多數項目只建立一個單一的jar文件，因此一般這不是一個問題。然而，若是你正打算建立一個更復雜的，使用自定義jar和BootRepackage任務的項目setup，有幾個方面須要考慮。
若是'僅僅'從項目建立自定義jar文件，你能夠簡單地禁用默認的jar和bootRepackage任務：
jar.enabled = false bootRepackage.enabled = false
另外一個選項是指示默認的bootRepackage任務只能使用一個默認的jar任務：
bootRepackage.withJarTask = jar
若是你有一個默認的項目setup，在該項目中，主（main）jar文件被建立和從新打包。而且，你仍舊想建立額外的自定義jars，你能夠將自定義的repackage任務結合起來，而後使用dependsOn，這樣bootJars任務就會在默認的bootRepackage任務執行之後運行：
task bootJars bootJars.dependsOn = [clientBoot1,clientBoot2,clientBoot3] build.dependsOn(bootJars)
上面全部方面常常用於避免一個已經建立的boot jar又被從新打包的狀況。從新打包一個存在的boot jar不是什麼大問題，但你可能會發現它包含沒必要要的依賴。
8.3 對其餘構建系統的支持
若是想使用除了Maven和Gradle以外的構建工具，你可能須要開發本身的插件。可執行jars須要遵循一個特定格式，而且一些實體須要以不壓縮的方式寫入（詳情查看附錄中的可執行jar格式章節）。
Spring Boot Maven和Gradle插件都利用spring-boot-loader-tools來實際地產生jars。若是須要，你也能夠自由地直接使用該庫。
8.3.1 從新打包存檔
使用org.springframework.boot.loader.tools.Repackager能夠將一個存在的存檔從新打包，這樣它就變成一個自包含的可執行存檔。Repackager類須要提供單一的構造器參數，它引用一個存在的jar或war包。使用兩個可用的repackage()方法中的一個來替換原始的文件或寫入一個新的目標。在repackager運行前還能夠設置各類配置。
8.3.2 內嵌的庫
當從新打包一個存檔時，你能夠使用org.springframework.boot.loader.tools.Libraries接口來包含對依賴文件的引用。在這裏咱們不提供任何該Libraries接口的具體實現，由於它們一般跟具體的構建系統相關。
若是你的存檔已經包含libraries，你能夠使用Libraries.NONE。
8.3.3 查找main類
若是你沒有使用Repackager.setMainClass()指定一個main類，該repackager將使用ASM去讀取class文件，而後嘗試查找一個合適的，具備public static void main(String[] args)方法的類。若是發現多個候選者，將會拋出異常。
8.3.4 repackage實現示例
這裏是一個傳統的repackage示例：
Repackager repackager = new Repackager(sourceJarFile); repackager.setBackupSource(false); repackager.repackage(new Libraries() { @Override public void doWithLibraries(LibraryCallback callback) throws IOException { // Build system specific implementation, callback for each dependency // callback.library(new Library(nestedFile, LibraryScope.COMPILE)); } });
How-to指南
本章節將回答一些常見的"我該怎麼作"類型的問題，這些問題在咱們使用Spring Boot時常常遇到。這毫不是一個詳盡的列表，但它覆蓋了不少方面。
若是遇到一個特殊的咱們沒有覆蓋的問題，你可能想去查看stackoverflow.com，看是否有人已經給出了答案;這也是一個很好的提新問題的地方（請使用spring-boot標籤）。
咱們也樂意擴展本章節;若是想添加一個'how-to'，你能夠給咱們發一個pull請求。
9.1 Spring Boot應用
9.1.1 解決自動配置問題
Spring Boot自動配置老是嘗試盡最大努力去作正確的事，但有時候會失敗而且很難說出失敗緣由。
在每一個Spring Boot ApplicationContext中都存在一個至關有用的ConditionEvaluationReport。若是開啓DEBUG日誌輸出，你將會看到它。若是你使用spring-boot-actuator，則會有一個autoconfig的端點，它將以JSON形式渲染該報告。能夠使用它調試應用程序，並能查看Spring Boot運行時都添加了哪些特性（及哪些沒添加）。
經過查看源碼和javadoc能夠獲取更多問題的答案。如下是一些經驗：
- 查找名爲* AutoConfiguration的類並閱讀源碼，特別是@Conditional*註解，這能夠幫你找出它們啓用哪些特性及什麼時候啓用。 將--debug添加到命令行或添加系統屬性-Ddebug能夠在控制檯查看日誌，該日誌會記錄你的應用中全部自動配置的決策。在一個運行的Actuator app中，經過查看autoconfig端點（/autoconfig或等效的JMX）能夠獲取相同信息。
- 查找是@ConfigurationProperties的類（好比ServerProperties）並看下有哪些可用的外部配置選項。@ConfigurationProperties類有一個用於充當外部配置前綴的name屬性，所以ServerProperties的值爲prefix="server"，它的配置屬性有server.port，server.address等。在運行的Actuator應用中能夠查看configprops端點。
- 查看使用RelaxedEnvironment明確地將配置從Environment暴露出去。它常常會使用一個前綴。
- 查看@Value註解，它直接綁定到Environment。相比RelaxedEnvironment，這種方式稍微缺少靈活性，但它也容許鬆散的綁定，特別是OS環境變量（因此CAPITALS_AND_UNDERSCORES是period.separated的同義詞）。
- 查看@ConditionalOnExpression註解，它根據SpEL表達式的結果來開啓或關閉特性，一般使用解析自Environment的佔位符進行計算。
9.1.2 啓動前自定義Environment或ApplicationContext
每一個SpringApplication都有ApplicationListeners和ApplicationContextInitializers，用於自定義上下文（context）或環境(environment)。Spring Boot從META-INF/spring.factories下加載不少這樣的內部使用的自定義。有不少方法能夠註冊其餘的自定義：
- 以編程方式爲每一個應用註冊自定義，經過在SpringApplication運行前調用它的addListeners和addInitializers方法來實現。
- 以聲明方式爲每一個應用註冊自定義，經過設置context.initializer.classes或context.listener.classes來實現。
- 以聲明方式爲全部應用註冊自定義，經過添加一個META-INF/spring.factories並打包成一個jar文件（該應用將它做爲一個庫）來實現。
SpringApplication會給監聽器（即便是在上下文被建立以前就存在的）發送一些特定的ApplicationEvents，而後也會註冊監聽ApplicationContext發佈的事件的監聽器。查看Spring Boot特性章節中的Section 22.4, 「Application events and listeners」 能夠獲取一個完整列表。
9.1.4 建立一個非web（non-web）應用
不是全部的Spring應用都必須是web應用（或web服務）。若是你想在main方法中執行一些代碼，但須要啓動一個Spring應用去設置須要的底層設施，那使用Spring Boot的SpringApplication特性能夠很容易實現。SpringApplication會根據它是否須要一個web應用來改變它的ApplicationContext類。首先你須要作的是去掉servlet API依賴，若是不能這樣作（好比，基於相同的代碼運行兩個應用），那你能夠明確地調用SpringApplication.setWebEnvironment(false)或設置applicationContextClass屬性（經過Java API或使用外部配置）。你想運行的，做爲業務邏輯的應用代碼能夠實現爲一個CommandLineRunner，並將上下文降級爲一個@Bean定義。
9.2 屬性&配置
9.2.1 外部化SpringApplication配置
SpringApplication已經被屬性化（主要是setters），因此你能夠在建立應用時使用它的Java API修改它的行爲。或者你能夠使用properties文件中的spring.main.*來外部化（在應用代碼外配置）這些配置。好比，在application.properties中可能會有如下內容：
spring.main.web_environment=false spring.main.show_banner=false
而後Spring Boot在啓動時將不會顯示banner，而且該應用也不是一個web應用。
9.2.2 改變應用程序外部配置文件的位置
默認狀況下，來自不一樣源的屬性以一個定義好的順序添加到Spring的Environment中（查看'Sprin Boot特性'章節的Chapter 23, Externalized Configuration獲取精確的順序）。
爲應用程序源添加@PropertySource註解是一種很好的添加和修改源順序的方法。傳遞給SpringApplication靜態便利設施（convenience）方法的類和使用setSources()添加的類都會被檢查，以查看它們是否有@PropertySources，若是有，這些屬性會被儘量早的添加到Environment裏，以確保ApplicationContext生命週期的全部階段都能使用。以這種方式添加的屬性優先於任何使用默認位置添加的屬性，但低於系統屬性，環境變量或命令行參數。
你也能夠提供系統屬性（或環境變量）來改變該行爲：
- spring.config.name（SPRING_CONFIG_NAME）是根文件名，默認爲application。
- spring.config.location（SPRING_CONFIG_LOCATION）是要加載的文件（例如，一個classpath資源或一個URL）。Spring Boot爲該文檔設置一個單獨的Environment屬性，它能夠被系統屬性，環境變量或命令行參數覆蓋。
無論你在environment設置什麼，Spring Boot都將加載上面討論過的application.properties。若是使用YAML，那具備'.yml'擴展的文件默認也會被添加到該列表。
詳情參考ConfigFileApplicationListener
9.2.3 使用'short'命令行參數
有些人喜歡使用（例如）--port=9000代替--server.port=9000來設置命令行配置屬性。你能夠經過在application.properties中使用佔位符來啓用該功能，好比：
server.port=${port:8080}
注：若是你繼承自spring-boot-starter-parent POM，爲了防止和Spring-style的佔位符產生衝突，maven-resources-plugins默認的過濾令牌（filter token）已經從${*}變爲@（即@maven.token@代替了${maven.token}）。若是已經直接啓用maven對application.properties的過濾，你可能也想使用其餘的分隔符替換默認的過濾令牌。
注：在這種特殊的狀況下，端口綁定可以在一個PaaS環境下工做，好比Heroku和Cloud Foundry，由於在這兩個平臺中PORT環境變量是自動設置的，而且Spring可以綁定Environment屬性的大寫同義詞。
9.2.4 使用YAML配置外部屬性
YAML是JSON的一個超集，能夠很是方便的將外部配置以層次結構形式存儲起來。好比：
spring:
application:
name: cruncher
datasource:
driverClassName: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost/test server: port: 9000
建立一個application.yml文件，將它放到classpath的根目錄下，並添加snakeyaml依賴（Maven座標爲org.yaml:snakeyaml，若是你使用spring-boot-starter那就已經被包含了）。一個YAML文件會被解析爲一個Java Map<String,Object>（和一個JSON對象相似），Spring Boot會平伸該map，這樣它就只有1級深度，而且有period-separated的keys，跟人們在Java中常用的Properties文件很是相似。 上面的YAML示例對應於下面的application.properties文件：
spring.application.name=cruncher
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost/test server.port=9000
查看'Spring Boot特性'章節的Section 23.6, 「Using YAML instead of Properties」能夠獲取更多關於YAML的信息。
9.2.5設置生效的Spring配置文件
Spring Environment有一個API能夠設置生效的profile，但一般你會設置一個系統profile（spring.profiles.active）或一個OS環境變量（SPRING_PROFILES_ACTIVE）。好比，使用一個-D參數啓動應用程序（記着把它放到主類或JAR文件以前）：
$ java -jar -Dspring.profiles.active=production demo-0.0.1-SNAPSHOT.jar
在Spring Boot中，你也能夠在application.properties裏設置生效的我的資料，例如：
spring.profiles.active=production
SpringApplicationBuilder.profiles（）方法替換。所以，後面的Java API可用來在不改變默認設置的狀況下增長配置文件。
想要獲取更多信息可查看'Spring Boot特性'章節的Chapter 24, Profiles。
9.2.6根據環境改變配置
一個YAML文件其實是一系列以---線分割的文檔，每一個文檔都被單獨解析爲一個平坦的（扁平）地圖。
若是一個YAML文檔包含一個spring.profiles關鍵字，那型材的值（以逗號分割的簡檔列表）將被傳入彈簧的Environment.acceptsProfiles（）方法，而且若是這些簡檔的任何一個被激活，對應的文檔被包含到最終的合併中（不然不會）。
示例：
server:
port: 9000
---
spring:
profiles: development
server:
port: 9001
---
spring:
profiles: production
server:
port: 0
在這個示例中，默認的端口是9000，但若是Spring profile'development'生效則該端口是9001，若是'production'生效則它是0。
YAML文檔以它們遇到的順序合併（因此後面的值會覆蓋前面的值）。
想要使用的配置文件文件完成一樣的操做，你能夠使用應用程序 - $ {}配置文件的.properties指定特殊的，我的資料相關的值。
9.2.7發現外部屬性的內置選項
Spring Boot在運行時未來自application.properties（或.yml）的外部屬性綁定進一個應用中。在一個地方不可能存在詳盡的全部支持屬性的列表（技術上也是不可能的），由於你的classpath下的其餘jar文件也可以貢獻。
每一個運行中且有Actuator特性的應用都會有一個configprops端點，它可以展現全部邊界和可經過@ConfigurationProperties綁定的屬性。
附錄中包含一個application.properties示例，它列舉了Spring Boot支持的大多數經常使用屬性。獲取權威列表可搜索@ConfigurationProperties和@Value的源碼，還有不常用的RelaxedEnvironment。
9.3 內嵌的servlet容器
9.3.1 爲應用添加Servlet，Filter或ServletContextListener
Servlet規範支持的Servlet，Filter，ServletContextListener和其餘監聽器能夠做爲@Bean定義添加到你的應用中。須要格外當心的是，它們不會引發太多的其餘beans的熱初始化，由於在應用生命週期的早期它們已經被安裝到容器裏了（好比，讓它們依賴你的DataSource或JPA配置就不是一個好主意）。你能夠經過延遲初始化它們到第一次使用而不是初始化時來突破該限制。
在Filters和Servlets的狀況下，你也能夠經過添加一個FilterRegistrationBean或ServletRegistrationBean代替或以及底層的組件來添加映射（mappings）和初始化參數。
9.3.2 改變HTTP端口
在一個單獨的應用中，主HTTP端口默認爲8080，但能夠使用server.port設置（好比，在application.properties中或做爲一個系統屬性）。因爲Environment值的寬鬆綁定，你也能夠使用SERVER_PORT（好比，做爲一個OS環境變）。
爲了徹底關閉HTTP端點，但仍建立一個WebApplicationContext，你能夠設置server.port=-1（測試時可能有用）。
想獲取更多詳情可查看'Spring Boot特性'章節的Section 26.3.3, 「Customizing embedded servlet containers」，或ServerProperties源碼。
9.3.3 使用隨機未分配的HTTP端口
想掃描一個未使用的端口（爲了防止衝突使用OS本地端口）能夠使用server.port=0。
9.3.4 發現運行時的HTTP端口
你能夠經過日誌輸出或它的EmbeddedServletContainer的EmbeddedWebApplicationContext獲取服務器正在運行的端口。獲取和確認服務器已經初始化的最好方式是添加一個ApplicationListener<EmbeddedServletContainerInitializedEvent>類型的@Bean，而後當事件發佈時將容器pull出來。
使用@WebIntegrationTests的一個有用實踐是設置server.port=0，而後使用@Value注入實際的（'local'）端口。例如：
@RunWith(SpringJUnit4ClassRunner.class) @SpringApplicationConfiguration(classes = SampleDataJpaApplication.class) @WebIntegrationTest("server.port:0") public class CityRepositoryIntegrationTests { @Autowired EmbeddedWebApplicationContext server; @Value("${local.server.port}") int port; // ... }
9.3.5 配置SSL
SSL可以以聲明方式進行配置，通常經過在application.properties或application.yml設置各類各樣的server.ssl.*屬性。例如：
server.port = 8443 server.ssl.key-store = classpath:keystore.jks server.ssl.key-store-password = secret server.ssl.key-password = another-secret
獲取全部支持的配置詳情可查看Ssl。
注：Tomcat要求key存儲（若是你正在使用一個可信存儲）可以直接在文件系統上訪問，即它不能從一個jar文件內讀取。Jetty和Undertow沒有該限制。
使用相似於以上示例的配置意味着該應用將不在支持端口爲8080的普通HTTP鏈接.Spring Boot不支持經過application.properties同時配置HTTP鏈接器和HTTPS鏈接器。若是你兩個都想要，那就須要以編程的方式配置它們中的一個。推薦使用application.properties配置HTTPS，HTTP由於鏈接器是兩個中最容易以編程方式進行配置的。獲取示例可查看彈簧引導採樣Tomcat的多鏈接器示例項目。
9.3.6配置Tomcat
一般你能夠遵循第63.7節，「Discover built-in options for external properties」關於@ConfigurationProperties（這裏主要的是ServerProperties）的建議，但也看看EmbeddedServletContainerCustomizer和各類你能夠添加的Tomcat特定的*定製器。
Tomcat API至關豐富，一旦獲取到TomcatEmbeddedServletContainerFactory，你就可以以多種方式修改它。或核心選擇是添加你本身的TomcatEmbeddedServletContainerFactory。
9.3.7啓用Tomcat的多鏈接器（多個鏈接器）
能夠你將一個org.apache.catalina.connector.Connector添加到TomcatEmbeddedServletContainerFactory，這就可以容許多鏈接器，好比HTTP和HTTPS鏈接器：
@Bean public EmbeddedServletContainerFactory servletContainer() { TomcatEmbeddedServletContainerFactory tomcat = new TomcatEmbeddedServletContainerFactory(); tomcat.addAdditionalTomcatConnectors(createSslConnector()); return tomcat; } private Connector createSslConnector() { Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol"); Http11NioProtocol protocol = (Http11NioProtocol) connector.getProtocolHandler(); try { File keystore = new ClassPathResource("keystore").getFile(); File truststore = new ClassPathResource("keystore").getFile(); connector.setScheme("https"); connector.setSecure(true); connector.setPort(8443); protocol.setSSLEnabled(true); protocol.setKeystoreFile(keystore.getAbsolutePath()); protocol.setKeystorePass("changeit"); protocol.setTruststoreFile(truststore.getAbsolutePath()); protocol.setTruststorePass("changeit"); protocol.setKeyAlias("apitester"); return connector; } catch (IOException ex) { throw new IllegalStateException("can't access keystore: [" + "keystore" + "] or truststore: [" + "keystore" + "]", ex); } }
9.3.8在前端代理服務器後使用Tomcat
Spring Boot將自動配置Tomcat的RemoteIpValve，若是你啓用它的話。這容許你透明地使用標準的x-forwarded-for和x-forwarded-proto頭，不少前端代理服務器都會添加這些頭信息（headers）。將這些屬性中的一個或所有設置爲非空的內容來開啓該功能（它們是大多數代理約定的值，若是你只設置其中的一個，則另外一個也會被自動設置）。
server.tomcat.remote_ip_header=x-forwarded-for server.tomcat.protocol_header=x-forwarded-proto
若是你的代理使用不一樣的頭部（頭），你能夠經過向application.properties添加一些條目來自定義該值的配置，好比：
server.tomcat.remote_ip_header=x-your-remote-ip-header server.tomcat.protocol_header=x-your-protocol-header
該值也能夠配置爲一個默認的，可以匹配信任的內部代理的正則表達式。默認狀況下，受信任的IP包括10 / 8,192.168 / 16,169.254 / 16和127/8。能夠經過嚮應用的.properties添加一個條目來自定義該值的配置，好比：
server.tomcat.internal_proxies=192\\.168\\.\\d{1,3}\\.\\d{1,3}
注：只有在你使用一個屬性文件做爲配置的時候才須要雙反斜槓若是你使用YAML，單個反斜槓就足夠了，192.168 \ d {1,3} \ d {1,3}。和上面的等價。
另外，經過在一個TomcatEmbeddedServletContainerFactory豆中配置和添加RemoteIpValve，你就能夠徹底控制它的設置了。
9.3.9使用Jetty替代Tomcat
Spring Boot starters（特別是spring-boot-starter-web）默認都是使用Tomcat做爲內嵌容器的。你須要排除那些Tomcat的依賴幷包含Jetty的依賴。爲了讓這種處理儘量簡單，Spring Boot將Tomcat的和碼頭的依賴捆綁在一塊兒，而後提供單獨的啓動器。
Maven的示例：
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <exclusions> <exclusion> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jetty</artifactId> </dependency>
搖籃示例：
configurations {
compile.exclude module: "spring-boot-starter-tomcat" } dependencies { compile("org.springframework.boot:spring-boot-starter-web:1.3.0.BUILD-SNAPSHOT") compile("org.springframework.boot:spring-boot-starter-jetty:1.3.0.BUILD-SNAPSHOT") // ... }
9.3.10配置碼頭
一般你能夠遵循第63.7節「發現外部屬性的內置選項」關於@ConfigurationProperties（此處主要是ServerProperties）的建議，但也要看下EmbeddedServletContainerCustomizer.Jetty API至關豐富，一旦獲取到JettyEmbeddedServletContainerFactory，你就能夠使用不少方式修改它。或更完全地就是添加你本身的JettyEmbeddedServletContainerFactory。
9.3.11使用Undertow替代Tomcat
使用Undertow替代Tomcat和使用Jetty替代Tomcat很是相似。你須要排除Tomat依賴，幷包含Undertow starter。
Maven的示例：
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <exclusions> <exclusion> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-undertow</artifactId> </dependency>
搖籃示例：
configurations {
compile.exclude module: "spring-boot-starter-tomcat" } dependencies { compile 'org.springframework.boot:spring-boot-starter-web:1.3.0.BUILD-SNAPSHOT") compile 'org.springframework.boot:spring-boot-starter-undertow:1.3.0.BUILD-SNAPSHOT") // ... }
9.3.12配置Undertow
一般你能夠遵循第63.7節「發現外部屬性的內置選項」關於@ConfigurationProperties（此處主要是ServerProperties和ServerProperties.Undertow），但也要看下EmbeddedServletContainerCustomizer。一旦獲取到UndertowEmbeddedServletContainerFactory，你就能夠使用一個UndertowBuilderCustomizer修改暗潮的配置以知足你的需求。或更完全地就是添加你本身的UndertowEmbeddedServletContainerFactory。
9.3.13啓用Undertow的多監聽器（多個聽衆）
往UndertowEmbeddedServletContainerFactory添加一個UndertowBuilderCustomizer，而後添加一個監聽者到生成器：
@Bean public UndertowEmbeddedServletContainerFactory embeddedServletContainerFactory() { UndertowEmbeddedServletContainerFactory factory = new UndertowEmbeddedServletContainerFactory(); factory.addBuilderCustomizers(new UndertowBuilderCustomizer() { @Override public void customize(Builder builder) { builder.addHttpListener(8080, "0.0.0.0"); } }); return factory; }
9.3.14使用Tomcat7
Tomcat7可用於Spring Boot，但默認使用的是Tomcat8。若是不能使用Tomcat8（例如，你使用的是Java1.6），你須要改變classpath去引用Tomcat7。
9.3.14.1經過Maven使用Tomcat7
若是正在使用啓動器pom和parent，你只須要改變Tomcat的版本屬性，好比，對於一個簡單的webapp或服務：
<properties> <tomcat.version>7.0.59</tomcat.version> </properties> <dependencies> ... <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> ... </dependencies>
9.3.14.2經過Gradle使用Tomcat7
你能夠經過設置tomcat.version屬性改變的Tomcat的版本：
ext['tomcat.version'] = '7.0.59' dependencies { compile 'org.springframework.boot:spring-boot-starter-web' }
9.3.15使用Jetty8
Jetty8可用於Spring Boot，但默認使用的是Jetty9。例如不能使用Jetty9（例如，由於你使用的是Java1.6），你只需改變classpath去引用Jetty8。你也須要排除Jetty的WebSocket相關的依賴。
9.3.15.1經過Maven使用Jetty8
若是正在使用starter pom和parent，你只需添加Jetty starter，去掉WebSocket依賴，並改變版本屬性，好比，對於一個簡單的webapp或服務：
<properties> <jetty.version>8.1.15.v20140411</jetty.version> <jetty-jsp.version>2.2.0.v201112011158</jetty-jsp.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <exclusions> <exclusion> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jetty</artifactId> <exclusions> <exclusion> <groupId>org.eclipse.jetty.websocket</groupId> <artifactId>*</artifactId> </exclusion> </exclusions> </dependency> </dependencies>
9.3.15.2經過Gradle使用Jetty8
你能夠設置jetty.version屬性並排除相關的WebSocket的依賴，好比對於一個簡單的Web應用程序或服務：
ext['jetty.version'] = '8.1.15.v20140411' dependencies { compile ('org.springframework.boot:spring-boot-starter-web') { exclude group: 'org.springframework.boot', module: 'spring-boot-starter-tomcat' } compile ('org.springframework.boot:spring-boot-starter-jetty') { exclude group: 'org.eclipse.jetty.websocket' } }
9.3.16使用@ServerEndpoint建立WebSocket端點
若是想在一個使用內嵌容器的Spring Boot應用中使用@ServerEndpoint，你須要聲明一個單獨的ServerEndpointExporter @Bean：
@Bean public ServerEndpointExporter serverEndpointExporter() { return new ServerEndpointExporter(); }
該豆將用底層的WebSocket容器註冊任何的被@ServerEndpoint註解的bean。當部署到一個單獨的servlet容器時，該角色將被一個servlet容器初始化方法履行，ServerEndpointExporter bean也就沒必要必需的了。
9.3.17啓用HTTP響應壓縮
Spring Boot提供兩種啓用HTTP壓縮的機制;一種是Tomcat特有的，另外一種是使用一個過濾器，能夠配合Jetty，Tomcat和Undertow。
9.3.17.1啓用Tomcat的HTTP響應壓縮
Tomcat的對HTTP響應壓縮提供內建支持默認是禁用的，但能夠經過application.properties輕鬆的啓用：
server.tomcat.compression: on
當設置爲上時，Tomcat的將壓縮響應的長度至少爲2048字節你能夠配置一個整型值來設置該限制而不僅是上，好比：
server.tomcat.compression: 4096
默認狀況下，Tomcat的只壓縮某些MIME類型的響應（text / html的，文本/ XML和文本/無格式）你能夠使用server.tomcat.compressableMimeTypes屬性進行自定義，好比：
server.tomcat.compressableMimeTypes=application/json,application/xml
9.3.17.2使用GzipFilter開啓HTTP響應壓縮
若是你正在使用Jetty或Undertow，或想要更精確的控制HTTP響應壓縮，Spring Boot爲Jetty的GzipFilter提供自動配置。雖然該過濾器是Jetty的一部分，但它也兼容Tomcat和Undertow。想要啓用該過濾器，只需簡單的爲你的應用添加org.eclipse.jetty：碼頭-servlet的依賴。
GzipFilter能夠使用spring.http.gzip。*屬性進行配置。具體參考GzipFilterProperties。
9.4 Spring MVC
9.4.1編寫一個JSON REST服務
在Spring Boot應用中，任何Spring @RestController默認應該渲染爲JSON響應，只要classpath下存在Jackson2。例如：
@RestController public class MyController { @RequestMapping("/thing") public MyThing thing() { return new MyThing(); } }
只要MyThing可以經過Jackson2序列化（好比，一個標準的POJO或Groovy對象），localhost:8080/thing默認響應一個JSON表示。有時在一個瀏覽器中你可能看到XML響應由於瀏覽器傾向於發送XML 響應頭。
9.4.2 編寫一個XML REST服務
若是classpath下存在Jackson XML擴展（jackson-dataformat-xml），它會被用來渲染XML響應，示例和JSON的很是類似。想要使用它，只需爲你的項目添加如下的依賴：
<dependency> <groupId>com.fasterxml.jackson.dataformat</groupId> <artifactId>jackson-dataformat-xml</artifactId> </dependency>
你可能也想添加對Woodstox的依賴。它比JDK提供的默認Stax實現快不少，而且支持良好的格式化輸出，提升了namespace處理能力：
<dependency> <groupId>org.codehaus.woodstox</groupId> <artifactId>woodstox-core-asl</artifactId> </dependency>
若是Jackson的XML擴展不可用，Spring Boot將使用JAXB（JDK默認提供），不過你須要爲MyThing添加額外的註解@XmlRootElement：
@XmlRootElement public class MyThing { private String name; // .. getters and setters }
想要服務器渲染XML而不是JSON，你可能須要發送一個Accept: text/xml頭部（或使用瀏覽器）。
9.4.3 自定義Jackson ObjectMapper
在一個HTTP交互中，Spring MVC（客戶端和服務端）使用HttpMessageConverters協商內容轉換。若是classpath下存在Jackson，你就已經獲取到Jackson2ObjectMapperBuilder提供的默認轉換器。
建立的ObjectMapper（或用於Jackson XML轉換的XmlMapper）實例默認有如下自定義屬性：
- MapperFeature.DEFAULT_VIEW_INCLUSION禁用
- DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES禁用
Spring Boot也有一些簡化自定義該行爲的特性。
你能夠使用當前的environment配置ObjectMapper和XmlMapper實例。Jackson提供一個擴展套件，能夠用來簡單的關閉或開啓一些特性，你能夠用它們配置Jackson處理的不一樣方面。這些特性在Jackson中使用5個枚舉進行描述的，並被映射到environment的屬性上：
| Jackson枚舉 | Environment屬性 | |
|---|---|---|
| com.fasterxml.jackson.databind.DeserializationFeature | `spring.jackson.deserialization.=true | false` |
| com.fasterxml.jackson.core.JsonGenerator.Feature | `spring.jackson.generator.=true | false` |
| com.fasterxml.jackson.databind.MapperFeature | `spring.jackson.mapper.=true | false` |
| com.fasterxml.jackson.core.JsonParser.Feature | `spring.jackson.parser.=true | false` |
| com.fasterxml.jackson.databind.SerializationFeature | `spring.jackson.serialization.=true | false` |
例如，設置spring.jackson.serialization.indent_output=true能夠開啓漂亮打印。注意，因爲鬆綁定的使用，indent_output沒必要匹配對應的枚舉常量INDENT_OUTPUT。
若是想完全替換默認的ObjectMapper，你須要定義一個該類型的@Bean並將它標記爲@Primary。
定義一個Jackson2ObjectMapperBuilder類型的@Bean將容許你自定義默認的ObjectMapper和XmlMapper（分別用於MappingJackson2HttpMessageConverter和MappingJackson2XmlHttpMessageConverter）。
另外一種自定義Jackson的方法是向你的上下文添加com.fasterxml.jackson.databind.Module類型的beans。它們會被註冊入每一個ObjectMapper類型的bean，當爲你的應用添加新特性時，這就提供了一種全局機制來貢獻自定義模塊。
最後，若是你提供任何MappingJackson2HttpMessageConverter類型的@Beans，那它們將替換MVC配置中的默認值。同時，也提供一個HttpMessageConverters類型的bean，它有一些有用的方法能夠獲取默認的和用戶加強的message轉換器。
想要獲取更多細節可查看Section 65.4, 「Customize the @ResponseBody rendering」和WebMvcAutoConfiguration源碼。
9.4.4 自定義@ResponseBody渲染
Spring使用HttpMessageConverters渲染@ResponseBody（或來自@RestController的響應）。你能夠經過在Spring Boot上下文中添加該類型的beans來貢獻其餘的轉換器。若是你添加的bean類型默認已經包含了（像用於JSON轉換的MappingJackson2HttpMessageConverter），那它將替換默認的。Spring Boot提供一個方便的HttpMessageConverters類型的bean，它有一些有用的方法能夠訪問默認的和用戶加強的message轉換器（有用，好比你想要手動將它們注入到一個自定義的RestTemplate）。
在一般的MVC用例中，任何你提供的WebMvcConfigurerAdapter beans經過覆蓋configureMessageConverters方法也能貢獻轉換器，但不一樣於一般的MVC，你能夠只提供你須要的轉換器（由於Spring Boot使用相同的機制來貢獻它默認的轉換器）。最終，若是你經過提供本身的@EnableWebMvc註解覆蓋Spring Boot默認的MVC配置，那你就能夠徹底控制，並使用來自WebMvcConfigurationSupport的getMessageConverters手動作任何事。
具體參考WebMvcAutoConfiguration源碼。
9.4.5 處理Multipart文件上傳
Spring Boot採用Servlet 3 javax.servlet.http.Part API來支持文件上傳。默認狀況下，Spring Boot配置Spring MVC在單個請求中每一個文件最大1Mb，最多10Mb的文件數據。你能夠覆蓋那些值，也能夠設置臨時文件存儲的位置（好比，存儲到的/ tmp文件夾下）及傳遞數據刷新到磁盤的閥值（經過使用MultipartProperties類暴露的屬性）。若是你須要設置文件不受限制，例如，能夠設置multipart.maxFileSize屬性值爲-1。
當你想要接收部分（multipart）編碼文件數據做爲Spring MVC控制器（控制器）處理方法中被@RequestParam註解的MultipartFile類型的參數時，multipart支持就很是有用了。
具體參考MultipartAutoConfiguration源碼。
9.4.6關閉Spring MVC DispatcherServlet
Spring Boot想要服務來自應用程序root /下的全部內容。若是你想將本身的servlet映射到該目錄下也是能夠的，但固然你可能失去一些Boot MVC特性。爲了添加你本身的servlet，並將它映射到根資源，你只需聲明一個Servlet的類型的@Bean，並給它特定的豆名稱的DispatcherServlet（若是隻想關閉但不替換它，你能夠使用該名稱建立不一樣類型的豆）。
9.4.7關閉默認的MVC配置
徹底控制MVC配置的最簡單方式是提供你本身的被@EnableWebMvc註解的@Configuration。這樣全部的MVC配置都逃不出你的掌心。
9.4.8自定義ViewResolvers
ViewResolver是Spring MVC的核心組件，它負責轉換@Controller中的視圖名稱到實際的View實現。注意ViewResolvers主要用在UI應用中，而不是REST風格的服務（查看不是用來渲染@ResponseBody的）.Spring有不少你能夠選擇的ViewResolver實現，而且Spring本身對如何選擇相應實現也沒發表意見。另外一方面，Spring Boot會根據類路徑上的依賴和應用上下文爲你安裝一或兩個ViewResolver實現.DispatcherServlet使用全部在應用上下文中找到的解析器（解析器），並依次嘗試每個直到它獲取到結果，因此若是你正在添加本身的解析器，那就要當心順序和你的解析器添加的位置。
WebMvcAutoConfiguration將會爲你的上下文添加如下ViewResolvers：
- bean id爲defaultViewResolver的InternalResourceViewResolver。這個會定位能夠使用DefaultServlet渲染的物理資源（好比，靜態資源和JSP頁面）。它在視圖（查看名稱）上應用了一個前綴和後綴（默認都爲空，但你能夠經過spring.view.prefix和spring.view.suffix外部配置設置），而後查找在的servlet上下文中具備該路徑的物理資源。能夠經過提供相同類型的豆覆蓋它。
- ID爲beanNameViewResolver的BeanNameViewResolver。這是視圖解析器鏈的一個很是有用的成員，它能夠在查看被解析時收集任何具備相同名稱的豆。
- ID爲的ViewResolver的ContentNegotiatingViewResolver只會在實際查看類型的豆類出現時添加。這是一個 '主' 解析器，它的職責會代理給其餘解析器，它會嘗試找到客戶端發送的一個匹配 '接受' 的HTTP頭部。這有一篇有用的，關於你須要更多瞭解的ContentNegotiatingViewResolver的博客，也要具體查看下源碼。經過定義一個名叫 '的視圖解析器' 的豆，你能夠關閉自動配置的ContentNegotiatingViewResolver。
- 若是使用Thymeleaf，你將有一個ID爲thymeleafViewResolver的ThymeleafViewResolver它會經過加前綴和後綴的視圖名來查找資源（外部配置爲spring.thymeleaf.prefix和spring.thymeleaf.suffix，對應的默認爲'類路徑。： /模板/ '和' 的.html'）。你能夠經過提供相同名稱的豆來覆蓋它。
- 若是使用FreeMarker的，你將有一個ID爲freeMarkerViewResolver的FreeMarkerViewResolver。它會使用加前綴和後綴（外部配置爲spring.freemarker.prefix和spring.freemarker.suffix，對應的默認值爲空和 '.ftl'）的視圖名從加載路徑（外部配置爲spring.freemarker.templateLoaderPath，默認爲 '類路徑：/模板/'）。下查找資源你能夠經過提供一個相同名稱的豆來覆蓋它。
- 若是使用Groovy模板（實際上只要你把groovy-templates添加到類路徑下），你將有一個id爲groovyTemplateViewResolver的Groovy TemplateViewResolver。它會使用加前綴和後綴（外部屬性爲spring.groovy.template.prefix和spring .groovy.template.suffix，對應的默認值爲 '類路徑：/模板/' 和 '.tpl'）的視圖名從加載路徑下查找資源你能夠經過提供一個相同名稱的豆來覆蓋它。
- 若是使用速度，你將有一個ID爲velocityViewResolver的VelocityViewResolver。它會使用加前綴和後綴（外部屬性爲spring.velocity.prefix和spring.velocity.suffix，對應的默認值爲空和 '.vm'）的視圖名從加載路徑（外部屬性爲spring.velocity.resourceLoaderPath，默認爲 '類路徑：/模板/'）。下查找資源你能夠經過提供一個相同名稱的豆來覆蓋它。
具體參考：WebMvcAutoConfiguration，ThymeleafAutoConfiguration，FreeMarkerAutoConfiguration，GroovyTemplateAutoConfiguration，VelocityAutoConfiguration。
9.5日誌
Spring Boot除了commons-logging API外沒有其餘強制性的日誌依賴，你有不少可選的日誌實現。想要使用Logback，你須要包含它，及一些對classpath下commons-logging的綁定。最簡單的方式是經過依賴spring-boot-starter-logging的starter pom。對於一個web應用程序，你只需添加spring-boot-starter-web依賴，由於它依賴於logging starter。例如，使用Maven：
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>
Spring Boot有一個LoggingSystem抽象，用於嘗試經過classpath上下文配置日誌系統。若是Logback可用，則首選它。若是你惟一須要作的就是設置不一樣日誌的級別，那能夠經過在application.properties中使用logging.level前綴實現，好比：
logging.level.org.springframework.web: DEBUG logging.level.org.hibernate: ERROR
你也能夠使用logging.file設置日誌文件的位置（除控制檯以外，默認會輸出到控制檯）。
想要對日誌系統進行更細粒度的配置，你須要使用正在說的LoggingSystem支持的原生配置格式。默認狀況下，Spring Boot從系統的默認位置加載原生配置（好比對於Logback爲classpath:logback.xml），但你能夠使用logging.config屬性設置配置文件的位置。
9.5.1 配置Logback
若是你將一個logback.xml放到classpath根目錄下，那它將會被從這加載。Spring Boot提供一個默認的基本配置，若是你只是設置日誌級別，那你能夠包含它，好比：
<?xml version="1.0" encoding="UTF-8"?> <configuration> <include resource="org/springframework/boot/logging/logback/base.xml"/> <logger name="org.springframework.web" level="DEBUG"/> </configuration>
若是查看spring-boot jar包中的默認logback.xml，你將會看到LoggingSystem爲你建立的不少有用的系統屬性，好比：
- ${PID}，當前進程id
- ${LOG_FILE}，若是在Boot外部配置中設置了logging.file
- $ {LOG_PATH}，若是設置了logging.path（表示日誌文件產生的目錄）
Spring Boot也提供使用自定義的Logback轉換器在控制檯上輸出一些漂亮的彩色ANSI日誌信息（不是日誌文件）。具體參考默認的base.xml配置。
若是Groovy的類路徑在下，你也能夠使用logback.groovy配置的logback。
9.5.2配置Log4j
Spring Boot也支持Log4j或Log4j 2做爲日誌配置，但只有在它們中的某個在classpath下存在的狀況。若是你正在使用starter poms進行依賴裝配，這意味着你須要排除Logback，而後包含你選擇的Log4j版本。若是你不使用starter poms，那除了你選擇的Log4j版本外還要提供commons-logging（至少）。
最簡單的方式可能就是經過starter poms，儘管它須要排除一些依賴，好比，在Maven中：
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> <exclusions> <exclusion> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-logging</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-log4j</artifactId> </dependency>
想要使用Log4j 2，只須要依賴spring-boot-starter-log4j2而不是spring-boot-starter-log4j。
注：使用Log4j各版本的starters都會收集好依賴以知足common logging的要求（好比，Tomcat中使用java.util.logging，但使用Log4j或Log4j 2做爲輸出）。具體查看Actuator Log4j或Log4j 2的示例，瞭解如何將它用於實戰。
9.5.2.1使用YAML或JSON配置Log4j2
除了它的默認XML配置格式，Log4j 2也支持YAML和JSON配置文件。想要使用其餘配置文件格式來配置Log4j 2，你須要添加合適的依賴到classpath。爲了使用YAML，你須要添加com.fasterxml。 jackson.dataformat：jackson-dataformat-yaml依賴，Log4j 2將查找名稱爲log4j2.yaml或log4j2.yml的配置文件。爲了使用JSON，你須要添加com.fasterxml.jackson.core：jackson-databind依賴，Log4j 2將查找名稱爲log4j2.json或log4j2.jsn的配置文件
9.6數據訪問
9.6.1配置一個數據源
想要覆蓋默認的設置只須要定義一個你本身的DataSource類型的@ Bean.Spring Boot提供一個工具構建類DataSourceBuilder，可用來建立一個標準的DataSource（若是它處於classpath下），或者僅建立你本身的DataSource ，而後將它和在第23.7.1節，「第三方配置」解釋的一系列環境屬性綁定。
好比：
@Bean @ConfigurationProperties(prefix="datasource.mine") public DataSource dataSource() { return new FancyDataSource(); } datasource.mine.jdbcUrl=jdbc:h2:mem:mydb datasource.mine.user=sa datasource.mine.poolSize=30
具體參考'Spring Boot特性'章節中的·第28.1節「配置數據源」·和DataSourceAutoConfiguration類源碼。
9.6.2配置兩個數據源
建立多個數據源和建立第一個工做都是同樣的。若是使用針對JDBC或JPA的默認自動配置，你可能想要將其中一個設置爲@Primary（而後它就能被任何@Autowired注入獲取） 。
@Bean @Primary @ConfigurationProperties(prefix="datasource.primary") public DataSource primaryDataSource() { return DataSourceBuilder.create().build(); } @Bean @ConfigurationProperties(prefix="datasource.secondary") public DataSource secondaryDataSource() { return DataSourceBuilder.create().build(); }
9.6.3使用Spring Data倉庫
Spring Data能夠爲你的@Repository接口建立各類風格的實現.Spring Boot會爲你處理全部事情，只要那些@Repositories接口跟你的@EnableAutoConfiguration類處於相同的包（或子包）。
對於不少應用來講，你須要作的就是將正確的Spring Data依賴添加到classpath下（對於JPA有一個spring-boot-starter-data-jpa，對於Mongodb有一個spring-boot-starter-data-mongodb） ，建立一些知識庫接口來處理@Entity對象。具體參考JPA樣本或Mongodb樣本。
Spring Boot會基於它找到的@EnableAutoConfiguration來嘗試猜想你的@Repository定義的位置。想要獲取更多控制，能夠使用@EnableJpaRepositories註解（來自Spring Data JPA）。
9.6.4從Spring配置分離@Entity定義
Spring Boot會基於它找到的@EnableAutoConfiguration來嘗試猜想你的@Entity定義的位置。想要獲取更多控制，你能夠使用@EntityScan註解，好比：
@Configuration @EnableAutoConfiguration @EntityScan(basePackageClasses=City.class) public class Application { //... }
9.6.5配置JPA屬性
Spring Data JPA已經提供了一些獨立的配置選項（好比，針對SQL日誌），而且Spring Boot會暴露它們，針對hibernate的外部配置屬性也更多些。最多見的選項以下：
spring.jpa.hibernate.ddl-auto: create-drop spring.jpa.hibernate.naming_strategy: org.hibernate.cfg.ImprovedNamingStrategy spring.jpa.database: H2 spring.jpa.show-sql: true
（因爲寬鬆的數據綁定策略，連字符或下劃線做爲屬性鍵做用應該是等效的）DDL-自動配置是個特殊狀況，它有不一樣的默認設置，這取決於你是否使用一個內嵌數據庫（建立-drop）。當本地的EntityManagerFactory被建立時，全部spring.jpa.properties。*屬性都被做爲正常的JPA屬性（去掉前綴）傳遞進去了。
具體參考HibernateJpaAutoConfiguration和JpaBaseConfiguration。
9.6.6使用自定義的EntityManagerFactory
爲了徹底控制EntityManagerFactory的配置，你須要添加一個名爲entityManagerFactory的@ Bean.Spring Boot自動配置會根據是否存在該類型的bean來關閉它的實體管理器（實體經理）。
9.6.7使用兩個EntityManagers
即便默認的EntityManagerFactory工做的很好，你也須要定義一個新的EntityManagerFactory，由於一旦出現第二個該類型的bean，默認的將會被關閉。爲了輕鬆的實現該操做，你能夠使用Spring Boot提供的EntityManagerBuilder，或者若是你喜歡的話能夠直接使用來自Spring ORM的LocalContainerEntityManagerFactoryBean。
示例：
// add two data sources configured as above @Bean public LocalContainerEntityManagerFactoryBean customerEntityManagerFactory( EntityManagerFactoryBuilder builder) { return builder .dataSource(customerDataSource()) .packages(Customer.class) .persistenceUnit("customers") .build(); } @Bean public LocalContainerEntityManagerFactoryBean orderEntityManagerFactory( EntityManagerFactoryBuilder builder) { return builder .dataSource(orderDataSource()) .packages(Order.class) .persistenceUnit("orders") .build(); }
上面的配置靠本身基本能夠運行。想要完成做品你也須要爲兩個EntityManagers配置TransactionManagers。其中的一個會被Spring Boot默認的JpaTransactionManager獲取，若是你將它標記爲@Primary。另外一個須要顯式注入到一個新實例。或你能夠使用一個JTA事物管理器生成它兩個。
9.6.8 使用普通的persistence.xml
Spring不要求使用XML配置JPA提供者（provider），而且Spring Boot假定你想要充分利用該特性。若是你傾向於使用persistence.xml，那你須要定義你本身的id爲'entityManagerFactory'的LocalEntityManagerFactoryBean類型的@Bean，並在那設置持久化單元的名稱。
默認設置可查看JpaBaseConfiguration
9.6.9 使用Spring Data JPA和Mongo倉庫
Spring Data JPA和Spring Data Mongo都能自動爲你建立Repository實現。若是它們同時出如今classpath下，你可能須要添加額外的配置來告訴Spring Boot你想要哪一個（或兩個）爲你建立倉庫。最明確地方式是使用標準的Spring Data @Enable* Repositories，而後告訴它你的Repository接口的位置（此處*便可以是Jpa，也能夠是Mongo，或者二者都是）。
這裏也有spring.data.*.repositories.enabled標誌，可用來在外部配置中開啓或關閉倉庫的自動配置。這在你想關閉Mongo倉庫，但仍舊使用自動配置的MongoTemplate時很是有用。
相同的障礙和特性也存在於其餘自動配置的Spring Data倉庫類型（Elasticsearch, Solr）。只須要改變對應註解的名稱和標誌。
9.6.10 將Spring Data倉庫暴露爲REST端點
Spring Data REST可以將Repository的實現暴露爲REST端點，只要該應用啓用Spring MVC。
Spring Boot暴露一系列來自spring.data.rest命名空間的有用屬性來定製化RepositoryRestConfiguration。若是須要提供其餘定製，你能夠建立一個繼承自SpringBootRepositoryRestMvcConfiguration的@Configuration類。該類功能和RepositoryRestMvcConfiguration相同，但容許你繼續使用spring.data.rest。*屬性。
9.7數據庫初始化
一個數據庫能夠使用不一樣的方式進行初始化，這取決於你的技術棧。或者你能夠手動完成該任務，只要數據庫是單獨的過程。
9.7.1使用JPA初始化數據庫
。JPA有個生成DDL的特性，這些能夠設置爲在數據庫啓動時運行這能夠經過兩個外部屬性進行控制：
- spring.jpa.generate-DDL（布爾值）控制該特性的關閉和開啓，跟實現者不要緊
- spring.jpa.hibernate.ddl自動（ENUM）是一個休眠特性，用於更細力度的控制該行爲。更多詳情參考如下內容。
9.7.2使用Hibernate初始化數據庫
你能夠顯式設置spring.jpa.hibernate.ddl-auto，標準的Hibernate屬性值有無，驗證，更新，建立，建立-drop.Spring Boot根據你的數據庫是否爲內嵌數據庫來選擇相應的默認值，若是是內嵌型的則默認值爲建立降，不然爲無。經過查看鏈接類型能夠檢查是否爲內嵌型數據庫，HSQLDB，H2和德比是內嵌的，其餘都不是。當從內存數據庫遷移到一個真正的數據庫時，你須要小心，在新的平臺中不能對數據庫表和數據是否存在進行臆斷。你也須要顯式設置DDL-汽車，或使用其餘機制初始化數據庫。
此外，啓動時處於類路徑根目錄下的import.sql文件會被執行。這在演示或測試時頗有用，但在生產環境中你可能不指望這樣。這是休眠的特性，和春天沒有一點關係。
9.7.3使用Spring JDBC初始化數據庫
Spring JDBC有一個DataSource初始化特性.Spring Boot默認啓用了該特性，並從標準的位置schema.sql和data.sql（位於classpath根目錄）加載SQL。此外，Spring Boot將加載模式 - $ {platform}。 sql和data - $ {platform} .sql文件（若是存在），在這裏platform is spring.datasource.platform的值，好比，你能夠將它設置爲數據庫的供應商名稱（hsqldb，h2，oracle，mysql， postgresql等）.Spring Boot默認啓用Spring JDBC初始化快速失敗特性，因此若是腳本致使異常產生，那應用程序將啓動失敗。腳本的位置能夠經過設置spring.datasource.schema和spring.datasource.data來改變，若是設置spring.datasource.initialize =假則哪一個位置都不會被處理。
你能夠設置spring.datasource.continueOnError =真禁用快速失敗特性一旦應用程序成熟並被部署了不少次，那該設置就頗有用，由於腳本能夠充當 「可憐人的遷移。」 - 例如，插入失敗時意味着數據已經存在，也就不必阻止應用繼續運行。
若是你想要在一個JPA應用中使用schema.sql文件，那若是休眠試圖建立相同的表，DDL-AUTO =創造降將致使錯誤產生。爲了不那些錯誤，能夠將DDL-自動設置爲「」（推薦）或「無」。無論是否使用DDL-AUTO =創造降，你總能夠使用data.sql初始化新數據。
9.7.4初始化Spring Batch數據庫
若是你正在使用Spring Batch，那麼它會爲大多數的流行數據庫平臺預裝SQL初始化腳本.Spring Boot會檢測你的數據庫類型，並默認執行那些腳本，在這種狀況下將關閉快速失敗特性（錯誤被記錄但不會阻止應用啓動）。這是由於那些腳本是可信任的，一般不會包含錯誤，因此錯誤會被忽略掉，而且對錯誤的忽略可讓腳本具備冪等性。你能夠使用彈簧.batch.initializer.enabled =假顯式關閉初始化功能。
9.7.5使用一個高級別的數據遷移工具
Spring Boot跟蹤高級別的數據遷移工具Flyway（基於SQL）和Liquibase（XML）工做的很好。一般咱們傾向於Flyway，由於它一眼看去好像很容易，另外它一般不須要平臺獨立：通常一個或至多須要兩個平臺。
9.7.5.1啓動時執行Flyway數據庫遷移
想要在啓動時自動運行遷飛數據庫遷移，須要將org.flywaydb：飛行用核心添加到你的類路徑下。
遷移是一些V<VERSION>__<NAME>.sql格式的腳本（<VERSION>是一個下劃線分割的版本號，好比'1'或'2_1'）。默認狀況下，它們存放在一個classpath:db/migration的文件夾中，但你能夠使用flyway.locations（一個列表）來改變它。詳情可參考flyway-core中的Flyway類，查看一些可用的配置，好比schemas。Spring Boot在FlywayProperties中提供了一個小的屬性集，可用於禁止遷移，或關閉位置檢測。
默認狀況下，Flyway將自動注入（@Primary）DataSource到你的上下文，並用它進行數據遷移。若是你想使用一個不一樣的DataSource，你能夠建立一個，並將它標記爲@FlywayDataSource的@Bean-若是你這樣作了，且想要兩個數據源，記得建立另外一個並將它標記爲@Primary。或者你能夠經過在外部配置文件中設置flyway.[url,user,password]來使用Flyway的原生DataSource。
這是一個Flyway示例，你能夠做爲參考。
9.7.5.2 啓動時執行Liquibase數據庫遷移
想要在啓動時自動運行Liquibase數據庫遷移，你須要將org.liquibase:liquibase-core添加到classpath下。
主改變日誌（master change log）默認從db/changelog/db.changelog-master.yaml讀取，但你能夠使用liquibase.change-log進行設置。詳情查看LiquibaseProperties以獲取可用設置，好比上下文，默認的schema等。
這裏有個Liquibase示例可做爲參考。
9.8 批處理應用
9.8.1 在啓動時執行Spring Batch做業
你能夠在上下文的某個地方添加@EnableBatchProcessing來啓用Spring Batch的自動配置功能。
默認狀況下，在啓動時它會執行應用的全部做業（Jobs），具體查看JobLauncherCommandLineRunner。你能夠經過指定spring.batch.job.names（多個做業名以逗號分割）來縮小到一個特定的做業或多個做業。
若是應用上下文包含一個JobRegistry，那麼處於spring.batch.job.names中的做業將會從registry中查找，而不是從上下文中自動裝配。這是複雜系統中常見的一個模式，在這些系統中多個做業被定義在子上下文和註冊中心。
具體參考BatchAutoConfiguration和@EnableBatchProcessing。
9.9 執行器
9.9.1 改變HTTP端口或執行器端點的地址
在一個單獨的應用中，執行器的HTTP端口默認和主HTTP端口相同。想要讓應用監聽不一樣的端口，你能夠設置外部屬性management.port。爲了監聽一個徹底不一樣的網絡地址（好比，你有一個用於管理的內部網絡和一個用於用戶應用程序的外部網絡），你能夠將management.address設置爲一個可用的IP地址，而後將服務器綁定到該地址。
查看ManagementServerProperties源碼和'Production-ready特性'章節中的Section 41.3, 「Customizing the management server port」來獲取更多詳情。
9.9.2 自定義'白標'（whitelabel，能夠了解下相關理念）錯誤頁面
Spring Boot安裝了一個'whitelabel'錯誤頁面，若是你遇到一個服務器錯誤（機器客戶端消費的是JSON，其餘媒體類型則會看到一個具備正確錯誤碼的合乎情理的響應），那就能在客戶端瀏覽器中看到該頁面。你能夠設置error.whitelabel.enabled=false來關閉該功能，但一般你想要添加本身的錯誤頁面來取代whitelabel。確切地說，如何實現取決於你使用的模板技術。例如，你正在使用Thymeleaf，你將添加一個error.html模板。若是你正在使用FreeMarker，那你將添加一個error.ftl模板。一般，你須要的只是一個名稱爲error的View，和/或一個處理/error路徑的@Controller。除非你替換了一些默認配置，不然你將在你的ApplicationContext中找到一個BeanNameViewResolver，因此一個id爲error的@Bean多是完成該操做的一個簡單方式。詳情參考ErrorMvcAutoConfiguration。
查看Error Handling章節，瞭解下如何將處理器（handlers）註冊到servlet容器中。
9.10 安全
9.10.1 關閉Spring Boot安全配置
無論你在應用的什麼地方定義了一個使用@EnableWebSecurity註解的@Configuration，它將會關閉Spring Boot中的默認webapp安全設置。想要調整默認值，你能夠嘗試設置security.*屬性（具體查看SecurityProperties和常見應用屬性的SECURITY章節）。
9.10.2 改變AuthenticationManager並添加用戶帳號
若是你提供了一個AuthenticationManager類型的@Bean，那麼默認的就不會被建立了，因此你能夠得到Spring Security可用的所有特性（好比，不一樣的認證選項）。
Spring Security也提供了一個方便的AuthenticationManagerBuilder，可用於構建具備常見選項的AuthenticationManager。在一個webapp中，推薦將它注入到WebSecurityConfigurerAdapter的一個void方法中，好比：
@Configuration public class SecurityConfiguration extends WebSecurityConfigurerAdapter { @Autowired public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception { auth.inMemoryAuthentication() .withUser("barry").password("password").roles("USER"); // ... etc. } // ... other stuff for application security }
若是把它放到一個內部類或一個單獨的類中，你將獲得最好的結果（也就是不跟不少其餘@Beans混合在一塊兒將容許你改變實例化的順序）。secure web sample是一個有用的參考模板。
若是你遇到了實例化問題（好比，使用JDBC或JPA進行用戶詳細信息的存儲），那將AuthenticationManagerBuilder回調提取到一個GlobalAuthenticationConfigurerAdapter（放到init()方法內以防其餘地方也須要authentication manager）多是個不錯的選擇，好比：
@Configuration public class AuthenticationManagerConfiguration extends GlobalAuthenticationConfigurerAdapter { @Override public void init(AuthenticationManagerBuilder auth) { auth.inMemoryAuthentication() // ... etc. } }
9.10.3 當前端使用代理服務器時，啓用HTTPS
對於任何應用來講，確保全部的主端點（URL）都只在HTTPS下可用是個重要的苦差事。若是你使用Tomcat做爲servlet容器，那Spring Boot若是發現一些環境設置的話，它將自動添加Tomcat本身的RemoteIpValve，你也能夠依賴於HttpServletRequest來報告是否請求是安全的（即便代理服務器的downstream處理真實的SSL終端）。這個標準行爲取決於某些請求頭是否出現（x-forwarded-for和x-forwarded-proto），這些請求頭的名稱都是約定好的，因此對於大多數前端和代理都是有效的。
你能夠向application.properties添加如下設置裏開啓該功能，好比：
server.tomcat.remote_ip_header=x-forwarded-for server.tomcat.protocol_header=x-forwarded-proto
（這些屬性出現一個就會開啓該功能，或者你能夠經過添加一個TomcatEmbeddedServletContainerFactory bean本身添加RemoteIpValve）
Spring Security也能夠配置成針對因此或某些請求須要一個安全渠道（channel）。想要在一個Spring Boot應用中開啓它，你只需將application.properties中的security.require_ssl設置爲true便可。
9.11 熱交換
9.11.1 從新加載靜態內容
Spring Boot有不少用於熱加載的選項。使用IDE開發是一個不錯的方式，特別是須要調試的時候（全部的現代IDEs都容許從新加載靜態資源，一般也支持對變動的Java類進行熱交換） .Maven和搖籃插件也支持命令行下的靜態文件熱加載。若是你使用其餘高級工具編寫的CSS / JS，並使用外部的CSS / JS編譯器，那你就能夠充分利用該功能。
9.11.2在不重啓容器的狀況下從新加載Thymeleaf模板
若是你正在使用Thymeleaf，那就將spring.thymeleaf.cache設置爲假。查看ThymeleafAutoConfiguration能夠獲取其餘Thymeleaf自定義選項。
9.11.3在不重啓容器的狀況下從新加載FreeMarker模板
若是你正在使用FreeMarker，那就將spring.freemarker.cache設置爲false。查看FreeMarkerAutoConfiguration能夠獲取其餘FreeMarker自定義選項。
9.11.4在不重啓容器的狀況下從新加載Groovy模板
若是你正在使用Groovy的模板，那就將spring.groovy.template.cache設置爲假。查看GroovyTemplateAutoConfiguration能夠獲取其餘Groovy的自定義選項。
9.11.5在不重啓容器的狀況下從新加載Velocity模板
若是你正在使用的速度，那就將spring.velocity.cache設置爲假。查看VelocityAutoConfiguration能夠獲取其餘速度自定義選項。
9.11.6在不重啓容器的狀況下從新加載Java類
現代IDE（Eclipse，IDEA等）都支持字節碼的熱交換，因此若是你作了一個沒有影響類或方法簽名的改變，它會利索地從新加載並無任何影響。
Spring Loaded在這方面走的更遠，它可以從新加載方法簽名改變的類定義。若是對它進行一些自定義配置能夠強制ApplicationContext刷新本身（但沒有通用的機制來確保這對一個運行中的應用老是安全的，因此它可能只是一個開發時間的技巧）。
9.11.6.1使用Maven配置Spring Loaded
爲了在Maven命令行下使用Spring Loaded，你只需將它做爲一個依賴添加到Spring Boot插件聲明中便可，好比：
<plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>springloaded</artifactId> <version>1.2.0.RELEASE</version> </dependency> </dependencies> </plugin>
正常狀況下，這在Eclipse和IntelliJ中工做的至關漂亮，只要它們有相應的，和Maven默認一致的構建配置（Eclipse m2e對此支持的更好，開箱即用）。
9.11.6.2使用Gradle和IntelliJ配置Spring加載
若是想將Spring Loaded和Gradle，IntelliJ結合起來，那你須要付出代價。默認狀況下，IntelliJ將類編譯到一個跟Gradle不一樣的位置，這會致使Spring Loaded監控失敗。
爲了正確配置IntelliJ，你能夠使用想法Gradle插件：
buildscript {
repositories { jcenter() }
dependencies {
classpath "org.springframework.boot:spring-boot-gradle-plugin:1.3.0.BUILD-SNAPSHOT" classpath 'org.springframework:springloaded:1.2.0.RELEASE' } } apply plugin: 'idea' idea { module { inheritOutputDirs = false outputDir = file("$buildDir/classes/main/") } } // ...
注：的IntelliJ必須配置跟命令行搖籃任務相同的Java的版本，而且彈簧加載必須做爲一個buildscript依賴被包含進去。
此外，你也能夠啓用Intellij內部的自動生成項目，這樣無論何時只要文件被保存都會自動編譯你的代碼。
9.12構建
9.12.1使用Maven自定義依賴版本
若是你使用的Maven進行一個直接或間接繼承彈簧引導依賴性（好比彈簧引導起動機 - 親本）的構建，並想覆蓋一個特定的第三方依賴，那你能夠添加合適的<屬性>元素。瀏覽spring-boot-dependencies POM能夠獲取一個全面的屬性列表。例如，想要選擇一個不一樣的slf4j版本，你能夠添加如下內容：
<properties> <slf4j.version>1.7.5<slf4j.version> </properties>
注：這隻在你的Maven的項目繼承（直接或間接）自彈簧引導依賴性纔有用若是你使用<範圍>進口</範圍>，將彈簧引導依賴性添加到本身的dependencyManagement片斷，那你必須本身從新定義而不是神器覆蓋屬性。
注：每一個Spring Boot發佈都是基於一些特定的第三方依賴集進行設計和測試的，覆蓋版本可能致使兼容性問題。
9.12.2使用Maven建立可執行JAR
spring-boot-maven-plugin可以用來建立可執行的'胖'JAR。若是你正在使用spring-boot-starter-parent POM，你能夠簡單地聲明該插件，而後你的jar將被從新打包：
<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>
若是沒有使用父POM，你仍舊能夠使用該插件。不過，你須要另外添加一個<executions>片斷：
<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <version>1.3.0.BUILD-SNAPSHOT</version> <executions> <execution> <goals> <goal>repackage</goal> </goals> </execution> </executions> </plugin> </plugins> </build>
查看插件文檔電子雜誌詳細的用例。
9.12.3建立其餘的可執行JAR
若是你想將本身的項目以庫jar的形式被其餘項目依賴，而且須要它是一個可執行版本（例如demo），你須要使用略微不一樣的方式來配置該構建。
對於Maven來講，正常的JAR插件和Spring Boot插件都有一個'classifier'，你能夠添加它來建立另外的JAR。示例以下（使用Spring Boot Starter Parent管理插件版本，其餘配置採用默認設置）：
<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <classifier>exec</classifier> </configuration> </plugin> </plugins> </build>
上述配置會產生兩個jars，默認的一個和使用帶有分類器'exec'的引導插件構建的可執行的一個。
對於搖籃用戶來講，步驟相似示例以下：
bootRepackage {
classifier = 'exec' }
9.12.4在可執行jar運行時提取特定的版本
在一個可執行罐子中，爲了運行，多數內嵌的庫不須要拆包（解壓縮），然而有一些庫可能會遇到問題。例如，JRuby的包含它本身的內嵌罐子，它假定JRuby的完整。罐子自己老是可以直接做爲文件訪問的。
爲了處理任何有問題的庫，你能夠標記那些特定的內嵌罐，讓它們在可執行的JAR第一次運行時自動解壓到一個臨時文件夾中。例如，爲了將JRuby的標記爲使用的Maven插件拆包，你須要添加以下的配置：
<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <requiresUnpack> <dependency> <groupId>org.jruby</groupId> <artifactId>jruby-complete</artifactId> </dependency> </requiresUnpack> </configuration> </plugin> </plugins> </build>
使用搖籃徹底上述操做：
springBoot {
requiresUnpack = ['org.jruby:jruby-complete'] }
9.12.6遠程調試一個使用Maven啓動的Spring Boot項目
想要爲使用Maven啓動的Spring Boot應用添加一個遠程調試器，你能夠使用mave插件的jvmArguments屬性。詳情參考示例。
9.12.7遠程調試一個使用Gradle啓動的Spring Boot項目
想要爲使用Gradle啓動的Spring Boot應用添加一個遠程調試器，你能夠使用build.gradle的applicationDefaultJvmArgs屬性或--debug-jvm命令行選項。
build.gradle：
applicationDefaultJvmArgs = [
"-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005" ]
命令行：
$ gradle run --debug-jvm
詳情查看搖籃應用插件。
9.12.8使用Ant構建可執行存檔（存檔）
想要使用的Ant進行構建，你須要抓取依賴，編譯，而後像一般那樣建立一個罐子或戰爭存檔爲了讓它能夠執行：
- 使用合適的啓動器配置主類，好比對於罐文件使用JarLauncher，而後將其餘須要的屬性以清單實體指定，主要是一個啓動級。
- 將運行時依賴添加到一個內嵌的 'LIB' 目錄（對於罐），提供（內嵌容器）依賴添加到一個內嵌的LIB-提供目錄。記住不要壓縮存檔中的實體。
- 在存檔的根目錄添加彈簧引導裝載類（這樣主類就可用了）。
示例：
<target name =「build」depends =「compile」>
<copy todir =「target / classes / lib」>
<fileset dir =「lib / runtime」/>
</ copy>
<jar destfile =「target / spring -boot-sample-actuator - $ {spring-boot.version} .jar「compress =」false「>
<fileset dir =」target / classes「/>
<fileset dir =」src / main / resources「/>
<zipfileset src =「lib / loader / spring-boot-loader-jar - $ {spring-boot.version} .jar」/>
<manifest>
<attribute name =「Main-Class」value =「org.springframework.boot.loader .JarLauncher「/>
<attribute name =」Start-Class「value =」$ {start-class}「/>
</ manifest>
</ jar>
</ target>
該Actuator示例中有一個build.xml文件，能夠使用如下命令來運行：
$ ant -lib /ivy-2.2.jar
在上述操做以後，你能夠使用如下命令運行該應用：
$ java -jar target/*.jar
9.12.9如何使用Java6
若是想在Java6環境中使用Spring Boot，你須要改變一些配置。具體的變化取決於你應用的功能。
9.12.9.1內嵌Servlet容器兼容性
若是你在使用Boot的內嵌Servlet容器，你須要使用一個兼容Java6的容器.Tomcat 7和Jetty 8都是Java 6兼容的。具體參考第63.15節「使用Tomcat 7」和第63.16節「使用Jetty 8 「。
9.12.9.2 JTA API兼容性
Java事務API自身並不要求Java 7，而是官方的API jar包含的已構建類要求Java 7.若是你正在使用JTA，那麼你須要使用可以在Java 6工做的構建版本替換官方的JTA 1.2 API jar 。爲了完成該操做，你須要排除任何對javax.transaction的：javax.transaction的-API的傳遞依賴，並使用org.jboss.spec.javax.transaction：JBoss的事務，api_1.2_spec：1.0.0.Final依賴替換它們。
9.13傳統部署
9.13.1建立一個可部署的戰爭文件
產生一個可部署war包的第一步是提供一個SpringBootServletInitializer子類，並覆蓋它的配置方法。這充分利用了Spring框架對Servlet 3.0的支持，並容許你在應用經過servlet容器啓動時配置它。 ，你只需把應用的主類改成繼承SpringBootServletInitializer便可：
@SpringBootApplication public class Application extends SpringBootServletInitializer { @Override protected SpringApplicationBuilder configure(SpringApplicationBuilder application) { return application.sources(Application.class); } public static void main(String[] args) throws Exception { SpringApplication.run(Application.class, args); } }
下一步是更新你的構建配置，這樣你的項目將產生一個戰爭包而不是JAR包。若是你使用的是Maven，並使用彈簧引導啓動父（爲了配置的Maven的戰爭插件），全部你須要作的就是更改的pom.xml的包裝爲戰爭：
<packaging>war</packaging>
若是你使用搖籃，你須要修改的build.gradle來將戰爭插件應用到項目上：
apply plugin: 'war'
該過程最後的一步是確保內嵌的servlet的容器不能干擾戰包將部署的servlet的容器。爲了達到這個目的，你須要將內嵌容器的依賴標記爲提供。
若是使用Maven的：
<dependencies>
<!-- … --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> <scope>provided</scope> </dependency> <!-- … --> </dependencies> 若是使用Gradle： dependencies { // … providedRuntime 'org.springframework.boot:spring-boot-starter-tomcat' // … }
若是你使用Spring Boot構建工具，將內嵌容器依賴標記爲提供將生產一個可執行war包，在lib-provided目錄有該war包的提供依賴。這意味着，除了部署到servlet容器，你還能夠經過使用命令行java -jar命令來運行應用。
注：查看Spring Boot基於以上配置的一個Maven示例應用。
9.13.2爲老的servlet容器建立一個可部署的戰文件
老的Servlet容器不支持在Servlet 3.0中使用的ServletContextInitializer啓動處理。你仍舊能夠在這些容器使用Spring和Spring Boot，但你須要爲應用添加一個web.xml，並將它配置爲經過一個DispatcherServlet加載一個ApplicationContext 。
9.13.3將現有的應用轉換爲Spring Boot
對於一個非web項目，轉換爲Spring Boot應用很容易（拋棄建立ApplicationContext的代碼，取而代之的是調用SpringApplication或SpringApplicationBuilder）.Spring MVC web應用一般先建立一個可部署的war應用，而後將它遷移爲一個可執行的戰爭或罐子。建議閱讀將罐子轉換成戰爭的入門指南..
經過繼承SpringBootServletInitializer建立一個可執行war（好比，在一個名爲Application的類中），而後添加Spring Boot的@EnableAutoConfiguration註解。示例：
@Configuration @EnableAutoConfiguration @ComponentScan public class Application extends SpringBootServletInitializer { @Override protected SpringApplicationBuilder configure(SpringApplicationBuilder application) { // Customize the application or call application.sources(...) to add sources // Since our example is itself a @Configuration class we actually don't // need to override this method. return application; } }
記住無論你往源放什麼東西，它僅是一個Spring ApplicationContext，正常狀況下，任何生效的在這裏也會起做用。有一些豆你能夠先移除，而後讓Spring Boot提供它的默認實現，不過有可能須要先完成一些事情。
靜態資源能夠移到classpath根目錄下的/ public（或/ static，/ resources，/ META-INF / resources）。一樣的方式也適合於messages.properties（Spring Boot在classpath根目錄下自動發現這些配置） 。
美妙的（Vanilla用法）Spring DispatcherServlet和Spring Security不須要改變。若是你的應用有其餘特性，好比使用其餘servlets或過濾器，那你可能須要添加一些配置到你的應用程序上下文中，按如下操做替換web .XML的那些元素：
- 在容器中安裝一個的Servlet或ServletRegistrationBean類型的@Bean，就好像的web.xml中的的<servlet />和<servlet的映射/>。
- 一樣的添加一個過濾器或FilterRegistrationBean類型的@Bean（相似於<濾波器/>和<濾波器映射/>）。
- 在XML文件中的ApplicationContext中能夠經過@Import添加到你的應用程序中。簡單的狀況下，大量使用註解配置能夠在幾行內定義@Bean定義。
一旦戰爭能夠使用，咱們就經過添加一個主要方法到應用來讓它能夠執行，好比：
public static void main(String[] args) { SpringApplication.run(Application.class, args); }
應用能夠劃分爲多個類別：
- 沒有web.xml的Servlet 3.0+應用
- 有web.xml中的應用
- 有上下文層次的應用
- 沒有上下文層次的應用
全部這些均可以進行適當的轉化，但每一個可能須要稍微不一樣的技巧。
Servlet 3.0+的應用轉化的至關簡單，若是它們已經使用Spring Servlet 3.0+初始化器輔助類。一般全部來自一個存在的WebApplicationInitializer的代碼能夠移到一個SpringBootServletInitializer中。若是一個存在的應用有多個ApplicationContext（好比，若是它使用AbstractDispatcherServletInitializer），那你能夠將全部上下文源放進一個單一的SpringApplication。你遇到的主要難題多是若是那樣不能工做，那你就要維護上下文層次。參考示例構建層次結構的條目。一個存在的包含網頁相關特性的父上下文一般須要分解，這樣全部的ServletContextAware組件都處於子上下文中。
對於還不是Spring應用的應用來講，上面的指南有助於你把應用轉換爲一個Spring Boot應用，但你也能夠選擇其餘方式。
9.13.4部署WAR到Weblogic
想要將Spring Boot應用部署到Weblogic，你須要確保你的servlet初始化器直接實現WebApplicationInitializer（即便你繼承的基類已經實現了它）。
一個傳統的Weblogic的初始化器可能以下所示：
import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boot.context.web.SpringBootServletInitializer; import org.springframework.web.WebApplicationInitializer; @SpringBootApplication public class MyApplication extends SpringBootServletInitializer implements WebApplicationInitializer { }
若是使用的logback，你須要告訴的Weblogic你傾向使用的打包版本而不是服務器預裝的版本你能夠經過添加一個具備以下內容的WEB-INF / weblogic.xml中實現該操做：
<?xml version="1.0" encoding="UTF-8"?> <wls:weblogic-web-app xmlns:wls="http://xmlns.oracle.com/weblogic/weblogic-web-app" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/ejb-jar_3_0.xsd http://xmlns.oracle.com/weblogic/weblogic-web-app http://xmlns.oracle.com/weblogic/weblogic-web-app/1.4/weblogic-web-app.xsd"> <wls:container-descriptor> <wls:prefer-application-packages> <wls:package-name>org.slf4j</wls:package-name> </wls:prefer-application-packages> </wls:container-descriptor> </wls:weblogic-web-app>
轉載自：https：//www.gitbook.com/book/qbgbook/spring-boot-reference-guide-zh/details
- 1. Spring Boot 參考指南（SpringApplication）
- 2. Spring Boot 參考指南（Hazelcast）
- 3. Spring Boot 參考指南（Spring Boot介紹）
- 4. Spring Boot 參考指南（Spring Boot文檔）
- 5. Spring Boot 參考指南（安裝 Spring Boot）
- 6. Spring Boot 參考指南（Spring Integration）
- 7. Spring Boot 參考指南（日誌記錄）
- 8. Spring Boot 參考指南（目錄）
- 9. Spring Boot 參考指南（消息傳遞）
- 10. Spring Boot 參考指南（安全）
- 更多相關文章...
- • SQL 指南 - 網站建設指南
- • HTML 指南 - 網站建設指南
- • 算法總結-雙指針
- • Spring Cloud 微服務實戰(三) - 服務註冊與發現
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 字節跳動21屆秋招運營兩輪面試經驗分享
- 2. Java 3 年，25K 多嗎？
- 3. mysql安裝部署
- 4. web前端開發中父鏈和子鏈方式實現通信
- 5. 3.1.6 spark體系之分佈式計算-scala編程-scala中trait特性
- 6. dataframe2
- 7. ThinkFree在線
- 8. 在線畫圖
- 9. devtools熱部署
- 10. 編譯和鏈接
- 1. Spring Boot 參考指南（SpringApplication）
- 2. Spring Boot 參考指南（Hazelcast）
- 3. Spring Boot 參考指南（Spring Boot介紹）
- 4. Spring Boot 參考指南（Spring Boot文檔）
- 5. Spring Boot 參考指南（安裝 Spring Boot）
- 6. Spring Boot 參考指南（Spring Integration）
- 7. Spring Boot 參考指南（日誌記錄）
- 8. Spring Boot 參考指南（目錄）
- 9. Spring Boot 參考指南（消息傳遞）
- 10. Spring Boot 參考指南（安全）