Spring Boot啓動參考指南(官方版)
Spring Boot啓動參考指南
做者
Phillip Webb, Dave Syer, Josh Long, Stéphane Nicoll, Rob Winch, Andy Wilkinson, Marcel Overdijk, Christian Dupuis, Sébastien Deleuze, Michael Simons, VedranPavić, Jay Bryant, Madhura Bhavejavascript
2.1.0.BUILD-SNAPSHOTphp
版權(2012-2018年)css
本文件的副本可供你本身使用及分發給他人，但你無須就該等副本收取任何費用，而每一份副本均須載有本版權公告，不管是以印刷形式或以電子方式分發。html
目錄前端
第一部分.Spring啓動文檔java
1.關於文件node
2.尋求幫助mysql
3.第一步react
4.使用SpringBootjquery
11.3.1@RestController和@Requestmap註釋
11.3.2@EnableAutoConfiguration註釋
23.8使用ApplicationRunner或CommandLineRunner
24.7.5@ConfigurationProperties驗證
24.7.6@ConfigurationProperties與@Value
27.1.9 ConfigurableWebBindingInitiators
27.2.2帶有HttpMessageReader和HttpMessageWriters的HTTP編解碼器
27.4.3 ServletWebServerApplicationContext
44.3.24使用Spock測試SpringBoot應用程序
44.4.1 ConfigFileApplicationContextInitiizer
52.8.4自動配置的ReactiveHealthIndicator
72.2 spring-boot:findmainclass
75.3在環境或ApplicationContext啓動以前定製它
75.4構建ApplicationContext層次結構(添加父上下文或根上下文)
77.10.1使用SpringBean添加servlet、過濾器或偵聽器
77.10.2使用Classpath掃描添加servlet、過濾器和偵聽器
77.14使用Tomcat的LegacyCookieProcessor
77.16使用@ServerEndpoint建立WebSocketEndpoint
78.6關閉SpringMVC DispatcherServlet
88.2更改UserDetailsService並添加用戶賬戶
90.8遠程調試從Maven啓動的SpringBoot應用程序
90.9在不使用Ant的狀況下從Ant構建可執行存檔spring-boot-antlib
第一部分.Spring啓動文檔
本節簡要概述SpringBoot參考文檔。它用做文檔其他部分的地圖。
1.關於文件
SpringBoot參考指南以下所示
最新的副本可在docs.spring.io/spring-boot/docs/current/reference.
本文件的副本可供你本身使用及分發給他人，但你無須就該等副本收取任何費用，而每一份副本均須載有本版權公告，不管是以印刷形式或以電子方式分發。
2.尋求幫助
若是你對SpringBoot有問題，咱們願意幫忙。
- 試試看如何處理文件。它們爲最多見的問題提供瞭解決辦法。
- 學習春天的基本知識。SpringBoot構建在許多其餘Spring項目上。檢查spring.io網站上有豐富的參考文獻.若是您是從Spring開始的，請嘗試使用導軌.
- 問一個問題咱們監視stackoverflow.com對於帶有標記的問題
spring-boot. - 使用SpringBoot報告buggithub.com/spring-projects/spring-boot/issues.
![[Note]](http://static.javashuo.com/static/loading.gif) |
| 全部SpringBoot都是開源的，包括文檔。若是你發現文檔有問題，或者你想改進它們，請介入. |
3.第一步
若是您要開始使用SpringBoot或「Spring」，請從如下主題:
4.使用SpringBoot
準備好真正開始使用SpringBoot了嗎？咱們保護了你:
- 創建系統： 馬文 | 梯度 | 螞蟻 | 啓動器
- 最佳作法： 碼結構 | @配置 | @EnableAutoConfiguration | bean和依賴注入
- 運行您的代碼 艾德 | 包裝 | 馬文 | 梯度
- 打包你的應用程序： 生產罐
- Spring Boot CLI： 使用CLI
5.學習Spring啓動特性
須要更多關於SpringBoot核心功能的詳細信息嗎？如下內容是給您的:
- 核心特徵： Spring應用 | 外部配置 | 剖面圖 | 測井
- Web應用程序： MVC | 嵌入式容器
- 處理數據： SQL | 無SQL
- 信息傳遞： 概述 | JMS
- 測試： 概述 | 引導應用程序 | 功用
- 延伸： 自動配置 | @條件
6.轉向生產
當您準備將SpringBoot應用程序推向生產時，咱們有一些技巧你可能會喜歡：
7.高級專題
最後，咱們爲更高級的用戶提供了一些主題：
第二部分。開始
若是您要開始使用SpringBoot或通常的「Spring」，請從閱讀本節開始。它回答了基本的「什麼？」「怎麼作」還有「爲何」問題。它包括對SpringBoot的介紹，以及安裝說明。而後，咱們將引導您構建您的第一個SpringBoot應用程序，同時討論一些核心原則。
8.介紹彈簧啓動
SpringBoot使得建立獨立的、生產級的基於Spring的應用程序變得很容易，您能夠運行這些應用程序。咱們對Spring平臺和第三方庫有一個專斷專行的見解，這樣您就能夠最小的小題大作開始了。大多數SpringBoot應用程序只須要不多的Spring配置。
能夠使用SpringBoot建立能夠經過如下方式啓動的Java應用程序java -jar或者更傳統的戰爭部署。咱們還提供了一個運行「Spring腳本」的命令行工具。
咱們的主要目標是：
- 爲全部Spring開發提供一個快速的、可普遍訪問的入門體驗。
- 不要太執拗己見，但當需求開始偏離缺省值時，請儘快離開。
- 提供大類項目(如嵌入式服務器、安全性、度量、健康檢查和外部化配置)常見的一系列非功能特性。
- 絕對不須要生成代碼，也不須要XML配置。
9.系統要求
SpringBoot2.1.0 BUILD-快照要求Java 8或9和Spring Framework 5.1.0.RELEASE或者更高。
爲下列構建工具提供了顯式構建支持：
| 構建工具 | 版本 |
|---|---|
| 馬文 |
3.3+ |
| 梯度 |
4.4+ |
9.1 servlet容器
SpringBoot支持如下嵌入式servlet容器：
| 名字，姓名 | Servlet版本 |
|---|---|
| Tomcat 9.0 |
4.0 |
| Jetty 9.4 |
3.1 |
| Undertow 2.0 |
4.0 |
您還能夠將SpringBoot應用程序部署到任何與Servlet3.1+兼容的容器中。
10.安裝彈簧啓動
SpringBoot能夠與「經典」Java開發工具一塊兒使用，也能夠做爲命令行工具安裝。無論怎樣，你須要Java SDK v1.8或者更高。在開始以前，應該使用如下命令檢查當前的Java安裝：
$ java -version
若是您是Java開發新手，或者您想嘗試SpringBoot，您可能須要嘗試彈簧啓動CLI(命令行接口)。不然，繼續閱讀「經典」安裝說明。
10.1 Java開發人員的安裝說明
您能夠與任何標準Java庫相同的方式使用SpringBoot。爲此，請包括適當的spring-boot-*.jar你的類路徑上的文件。SpringBoot不須要任何特殊的工具集成，因此您能夠使用任何IDE或文本編輯器。此外，SpringBoot應用程序沒有什麼特別之處，所以您能夠像其餘Java程序同樣運行和調試SpringBoot應用程序。
雖然你能複製SpringBootJars，咱們一般建議您使用支持依賴管理(如Maven或Gradle)的構建工具。
10.1.1 Maven安裝
SpringBoot與ApacheMaven 3.3或更高版本兼容。若是您尚未安裝Maven，能夠按照maven.apache.org.
|
| 在許多操做系統上，Maven能夠安裝包管理器。若是您使用OSX自制，請嘗試 |
Spring引導依賴項使用org.springframework.boot groupId。一般，Maven POM文件從spring-boot-starter-parent項目並將依賴項聲明爲一個或多個。「起步者」。SpringBoot還提供了一個可選的Maven插件若要建立可執行的JAR，請執行如下操做。
下面的清單顯示了一個典型的pom.xml檔案：
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.example</groupId> <artifactId>myproject</artifactId> <version>0.0.1-SNAPSHOT</version> <!-- Inherit defaults from Spring Boot --> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.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>https://repo.spring.io/snapshot</url> <snapshots><enabled>true</enabled></snapshots> </repository> <repository> <id>spring-milestones</id> <url>https://repo.spring.io/milestone</url> </repository> </repositories> <pluginRepositories> <pluginRepository> <id>spring-snapshots</id> <url>https://repo.spring.io/snapshot</url> </pluginRepository> <pluginRepository> <id>spring-milestones</id> <url>https://repo.spring.io/milestone</url> </pluginRepository> </pluginRepositories> </project>
|
| 這，這個，那，那個 |
10.1.2分級安裝
SpringBoot與Gradle 4.4及更高版本兼容。若是您尚未安裝Gradle，能夠按照gradle.org.
屬性能夠聲明Spring啓動依賴項。org.springframework.boot group。一般，項目將依賴項聲明爲一個或多個。「起步者」。Spring Boot提供了一個有用的Gradle插件它能夠用來簡化依賴聲明和建立可執行的JAR。
梯度包裝
當您須要構建一個項目時，Gradle包裝提供了一種很好的「獲取」Gradle的方法。這是一個很小的腳本和庫，您能夠將其與代碼一塊兒用於引導構建過程。看見docs.gradle.org/4.2.1/userguide/gradle_wrapper.html關於細節。
下面的示例顯示了一個典型的build.gradle檔案：
buildscript {
repositories {
jcenter()
maven { url 'https://repo.spring.io/snapshot' }
maven { url 'https://repo.spring.io/milestone' }
}
dependencies {
classpath 'org.springframework.boot:spring-boot-gradle-plugin:2.1.0.BUILD-SNAPSHOT'
}
}
apply plugin: 'java'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'
jar {
baseName = 'myproject'
version = '0.0.1-SNAPSHOT'
}
repositories {
jcenter()
maven { url "https://repo.spring.io/snapshot" }
maven { url "https://repo.spring.io/milestone" }
}
dependencies {
compile("org.springframework.boot:spring-boot-starter-web")
testCompile("org.springframework.boot:spring-boot-starter-test")
}
10.2安裝SpringBootCLI
SpringBootCLI(命令行接口)是一個命令行工具，您能夠使用它快速地使用Spring進行原型。它讓你跑Groovy腳本，這意味着您有一個熟悉的相似Java的語法，而沒有那麼多樣板代碼。
您不須要使用CLI來使用SpringBoot，但這絕對是得到Spring應用程序的最快方法。
10.2.1手動安裝
您能夠從Spring軟件存儲庫下載SpringCLI發行版：
刀刃快照分佈也是可用的。
下載後，按照INSTALL.txt解壓檔案的說明。總之，有一個spring腳本(spring.bat)中的bin/目錄中的.zip檔案。或者，您能夠使用java -jar帶着.jar文件(腳本幫助您確保正確設置了類路徑)。
10.2.2用SDKMAN安裝！
SDKMAN！(SoftwareDevelopmentKitManager)可用於管理各類二進制SDK的多個版本，包括Groovy和SpringBootCLI。去找SDKMAN！從…sdkman.io並使用如下命令安裝SpringBoot：
$ sdk install springboot $ spring --version Spring Boot v2.1.0.BUILD-SNAPSHOT
若是您爲CLI開發特性並但願輕鬆訪問您構建的版本，請使用如下命令：
$ sdk install springboot dev /path/to/spring-boot/spring-boot-cli/target/spring-boot-cli-2.1.0.BUILD-SNAPSHOT-bin/spring-2.1.0.BUILD-SNAPSHOT/ $ sdk default springboot dev $ spring --version Spring CLI v2.1.0.BUILD-SNAPSHOT
的本地實例spring稱爲dev舉個例子。它指向您的目標構建位置，因此每次您重建SpringBoot時，spring是最新的。
經過運行如下命令能夠看到它：
$ sdk ls springboot ================================================================================ Available Springboot Versions ================================================================================ > + dev * 2.1.0.BUILD-SNAPSHOT ================================================================================ + - local version * - installed > - currently in use ================================================================================
10.2.3 OSX自制設備
若是你在mac上使用自制，能夠使用如下命令安裝SpringBootCLI：
$ brew tap pivotal/tap $ brew install springboot
自制安裝spring到/usr/local/bin.
|
| 若是您沒有看到公式，您的BREW安裝多是過期的。在這種狀況下，運行 |
10.2.4 MacPorts安裝
若是你在mac上使用麥克波特，能夠使用如下命令安裝SpringBootCLI：
$ sudo port install spring-boot-cli
10.2.5指揮線完成
SpringBootCLI包括爲巴什和茲什貝殼。你能夠的。source腳本(也稱爲spring)在任何shell中，或將其放在我的或系統範圍內的bash完成初始化中。在debian系統上，系統範圍內的腳本位於/shell-completion/bash當一個新的shell啓動時，該目錄中的全部腳本都會被執行。例如，若是經過使用SDKMAN安裝了腳本，則手動運行腳本！，使用如下命令：
$ . ~/.sdkman/candidates/springboot/current/shell-completion/bash/spring $ spring <HIT TAB HERE> grab help jar run test version
|
| 若是使用HOMEBREW或MacPorts安裝SpringBootCLI，命令行完成腳本將自動註冊到shell中。 |
10.2.6 Windows SCOOP安裝
若是您在Windows上並使用鏟子，能夠使用如下命令安裝SpringBootCLI：
> scoop bucket add extras > scoop install springboot
剷鬥安裝spring到~/scoop/apps/springboot/current/bin.
|
| 若是您沒有看到應用程序清單，您安裝的獨家新聞多是過期的。在這種狀況下，運行 |
10.2.7快速啓動SpringCLI示例
您能夠使用下面的web應用程序來測試您的安裝。首先，建立一個名爲app.groovy，以下：
@RestController
class ThisWillActuallyRun {
@RequestMapping("/")
String home() {
"Hello World!"
}
}
而後從shell運行它，以下所示：
$ spring run app.groovy
|
| 隨着依賴項的下載，應用程序的第一次運行是緩慢的。隨後的運行要快得多。 |
打開localhost:8080在你最喜歡的網頁瀏覽器裏。您應該看到如下輸出：
Hello World!
10.3從較早版本的SpringBoot升級
若是您正在從SpringBoot的早期版本進行升級，請檢查項目wiki的「遷移指南」這提供了詳細的升級說明。也檢查「發佈說明」關於每一個版本的「新的和值得注意的」特性的列表。
升級到新的特性發行版時，一些屬性可能已被重命名或刪除。SpringBoot提供了一種在啓動時分析應用程序環境和打印診斷信息的方法，但也爲您提供了在運行時臨時遷移屬性的方法。若要啓用該功能，請向項目中添加如下依賴項：
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-properties-migrator</artifactId> <scope>runtime</scope> </dependency>
|
| 晚添加到環境中的屬性，例如當使用 |
|
| 完成遷移後，請確保從項目的依賴項中刪除此模塊。 |
若要升級現有的CLI安裝，請使用適當的包管理器命令(例如，brew upgrade)或者，若是手動安裝了CLI，請按照標準指令，請記住更新PATH環境變量以刪除任何舊的引用。
11.開發您的第一個SpringBoot應用程序
本節描述如何開發一個簡單的「HelloWorld！」Web應用程序，它突出了SpringBoot的一些關鍵特性。咱們使用Maven構建這個項目，由於大多數IDE都支持它。
|
| 這，這個，那，那個spring.io網站包含許多「入門」導軌使用Spring Boot。若是你須要解決一個具體的問題，首先檢查那裏。 您能夠經過如下步驟轉到start.spring.io並從依賴項搜索器中選擇「Web」啓動器。這樣作會生成一個新的項目結構，這樣您就能夠當即開始編碼。檢查SpringInitializr文檔更多細節。 |
在開始以前，打開一個終端並運行如下命令，以確保安裝了有效版本的Java和Maven：
$ java -version java version "1.8.0_102" Java(TM) SE Runtime Environment (build 1.8.0_102-b14) Java HotSpot(TM) 64-Bit Server VM (build 25.102-b14, mixed mode)
$ mvn -v Apache Maven 3.5.4 (1edded0938998edf8bf061f1ceb3cfdeccf443fe; 2018-06-17T14:33:14-04:00) Maven home: /usr/local/Cellar/maven/3.3.9/libexec Java version: 1.8.0_102, vendor: Oracle Corporation
|
| 此示例須要在本身的文件夾中建立。後續說明假設您已經建立了一個合適的文件夾，而且它是您的當前目錄。 |
11.1建立POM
咱們須要從建立一個Maven開始pom.xml檔案。這，這個，那，那個pom.xml用於構建項目的配方。打開您最喜歡的文本編輯器並添加如下內容：
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.example</groupId> <artifactId>myproject</artifactId> <version>0.0.1-SNAPSHOT</version> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.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>https://repo.spring.io/snapshot</url> <snapshots><enabled>true</enabled></snapshots> </repository> <repository> <id>spring-milestones</id> <url>https://repo.spring.io/milestone</url> </repository> </repositories> <pluginRepositories> <pluginRepository> <id>spring-snapshots</id> <url>https://repo.spring.io/snapshot</url> </pluginRepository> <pluginRepository> <id>spring-milestones</id> <url>https://repo.spring.io/milestone</url> </pluginRepository> </pluginRepositories> </project>
上面的清單應該爲您提供一個工做構建。您能夠經過運行mvn package(如今，您能夠忽略「jar將爲空-沒有標記爲包含的內容！」警告)。
|
| 此時，您能夠將項目導入IDE(大多數現代Java IDE都包括對Maven的內置支持)。爲了簡單起見，咱們繼續爲這個示例使用純文本編輯器。 |
11.2添加類路徑依賴項
SpringBoot提供了許多「啓動器」，容許您在類路徑中添加罐子。咱們的示例應用程序已經使用了spring-boot-starter-parent在.。parentPOM的章節。這，這個，那，那個spring-boot-starter-parent是一個特殊的啓動程序，它提供了有用的Maven默認值。它還提供了一個dependency-management節，以便您能夠省略version標記用於「祝福」依賴項。
其餘「啓動程序」提供了您在開發特定類型應用程序時可能須要的依賴項。由於咱們正在開發一個web應用程序，因此咱們添加了一個spring-boot-starter-web依賴。在此以前，咱們能夠經過運行如下命令查看咱們目前擁有的內容：
$ mvn dependency:tree [INFO] com.example:myproject:jar:0.0.1-SNAPSHOT
這，這個，那，那個mvn dependency:tree命令打印項目依賴項的樹表示形式。你能夠看到spring-boot-starter-parent自己不提供依賴項。若要添加必要的依賴項，請編輯pom.xml並添加spring-boot-starter-web控件下面的依賴項。parent部分：
<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies>
若是你跑mvn dependency:tree您再次看到，如今有許多附加的依賴項，包括Tomcat Web服務器和SpringBoot自己。
11.3編寫守則
要完成咱們的應用程序，咱們須要建立一個Java文件。默認狀況下，Maven從src/main/java，因此您須要建立該文件夾結構，而後添加一個名爲src/main/java/Example.java若要包含如下代碼，請執行如下操做：
import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.web.bind.annotation.*;
@RestController
@EnableAutoConfiguration
public class Example {
@RequestMapping("/")
String home() {
return "Hello World!";
}
public static void main(String[] args) throws Exception {
SpringApplication.run(Example.class, args);
}
}
雖然這裏沒有太多的代碼，可是正在發生不少事情。在接下來的幾節中，咱們將逐步瞭解重要的部分。
11.3.1@RestController和@Requestmap註釋
咱們的第一個註釋Example類是@RestController。這被稱爲刻板印象註釋它爲閱讀代碼的人和Spring提供了提示，說明類扮演了特定的角色。在這種狀況下，咱們的類是一個web。@Controller，因此Spring在處理傳入的Web請求時會考慮它。
這，這個，那，那個@RequestMapping註釋提供「路由」信息。它告訴Spring，任何帶有/路徑應映射到home方法。這，這個，那，那個@RestController註釋告訴Spring將結果字符串直接呈現給調用者。
|
| 這，這個，那，那個 |
11.3.2@EnableAutoConfiguration註釋
第二個類級註釋是@EnableAutoConfiguration。這個註釋告訴SpringBoot根據您添加的JAR依賴項「猜想」如何配置Spring。自spring-boot-starter-web加上Tomcat和SpringMVC，自動配置假設您正在開發一個Web應用程序，並相應地設置Spring。
啓動器和自動配置
自動配置被設計爲與「啓動器」很好地工做，但這兩個概念並非直接聯繫在一塊兒的。您能夠在啓動程序以外自由選擇JAR依賴項。SpringBoot仍然盡力自動配置您的應用程序。
11.3.3「主要」方法
應用程序的最後一部分是main方法。這只是應用程序入口點遵循Java約定的一個標準方法。咱們的主要方法委託給SpringBootSpringApplication經過調用run.SpringApplication引導咱們的應用程序，啓動Spring，而後啓動自動配置的Tomcat Web服務器。咱們須要經過Example.class做爲對run告知方法SpringApplication這是主要的Spring組件。這，這個，那，那個args數組也被傳遞到公開任何命令行參數。
11.4運行示例
此時，您的應用程序應該能夠工做。由於你用了spring-boot-starter-parent波姆，你有個有用的run能夠用來啓動應用程序的目標。類型mvn spring-boot:run從根項目目錄中啓動應用程序。您應該看到相似於如下內容的輸出：
$ mvn spring-boot:run . ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ \\/ ___)| |_)| | | | | || (_| | ) ) ) ) ' |____| .__|_| |_|_| |_\__, | / / / / =========|_|==============|___/=/_/_/_/ :: Spring Boot :: (v2.1.0.BUILD-SNAPSHOT) ....... . . . ....... . . . (log output here) ....... . . . ........ Started Example in 2.222 seconds (JVM running for 6.514)
若是您打開web瀏覽器到localhost:8080，您將看到如下輸出：
Hello World!
若要優雅地退出應用程序，請按ctrl-c.
11.5建立可執行的JAR
咱們經過建立一個能夠在生產中運行的徹底獨立的可執行JAR文件來完成咱們的示例。可執行的JAR(有時稱爲「FAT JAR」)是包含編譯類以及代碼運行所需的全部JAR依賴項的檔案。
可執行JAR和Java
Java沒有提供加載嵌套JAR文件的標準方法(JAR文件自己包含在JAR中)。若是您但願分發一個獨立的應用程序，這可能會有問題。
爲了解決這個問題，許多開發人員使用「uber」JAR。一個uberjar將全部應用程序依賴項中的全部類打包到一個歸檔文件中。這種方法的問題是很難看出應用程序中有哪些庫。若是在多個JAR中使用相同的文件名(但內容不一樣)，也會出現問題。
春靴不一樣方法讓你直接築巢。
要建立一個可執行的JAR，咱們須要添加spring-boot-maven-plugin敬咱們pom.xml。爲此，請在dependencies部分：
<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>
|
| 這，這個，那，那個 |
保存你的pom.xml跑mvn package在命令行中，以下所示：
$ mvn package [INFO] Scanning for projects... [INFO] [INFO] ------------------------------------------------------------------------ [INFO] Building myproject 0.0.1-SNAPSHOT [INFO] ------------------------------------------------------------------------ [INFO] .... .. [INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ myproject --- [INFO] Building jar: /Users/developer/example/spring-boot-example/target/myproject-0.0.1-SNAPSHOT.jar [INFO] [INFO] --- spring-boot-maven-plugin:2.1.0.BUILD-SNAPSHOT:repackage (default) @ myproject --- [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------
若是你看看target目錄中，您應該看到myproject-0.0.1-SNAPSHOT.jar。文件的大小應該在10 MB左右。若是你想窺視裏面，你能夠用jar tvf，以下：
$ jar tvf target/myproject-0.0.1-SNAPSHOT.jar
您還應該看到一個更小的文件，名爲myproject-0.0.1-SNAPSHOT.jar.original在.。target目錄。這是Maven在SpringBoot從新打包以前建立的原始JAR文件。
若要運行該應用程序，請使用java -jar命令以下：
$ java -jar target/myproject-0.0.1-SNAPSHOT.jar . ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ \\/ ___)| |_)| | | | | || (_| | ) ) ) ) ' |____| .__|_| |_|_| |_\__, | / / / / =========|_|==============|___/=/_/_/_/ :: Spring Boot :: (v2.1.0.BUILD-SNAPSHOT) ....... . . . ....... . . . (log output here) ....... . . . ........ Started Example in 2.536 seconds (JVM running for 2.864)
如前所述，要退出應用程序，請按ctrl-c.
12.接下來要讀什麼？
但願本節提供了一些SpringBoot基礎知識，並幫助您編寫本身的應用程序。若是您是面向任務的開發人員，您可能須要跳到spring.io看看其中的一些開始解決具體問題的指南「我如何用Spring實現這一點？」問題。咱們也有SpringBoot特有的「如何「參考文件。
這，這個，那，那個彈簧啓動庫也有一個一堆樣本你能夠跑了。示例獨立於代碼的其他部分(也就是說，您不須要構建其他的代碼來運行或使用示例)。
不然，下一個邏輯步驟是讀取第三部分，「使用Spring Boot」。若是你真的不耐煩的話，你也能夠跳到前面去讀。彈簧啓動功能.
第三部分。使用Spring Boot
本節將詳細介紹如何使用SpringBoot。它涵蓋了一些主題，如構建系統、自動配置以及如何運行應用程序。咱們還介紹了一些SpringBoot最佳實踐。雖然SpringBoot沒有什麼特別之處(它只是您能夠使用的另外一個庫)，可是下面有一些建議能夠使您的開發過程更容易一些。
若是您是從SpringBoot開始的，您可能應該閱讀開始在潛入這一段以前，導遊。
13.構建系統
強烈建議您選擇支持依賴性管理這能夠使用發佈到「Maven Central」存儲庫的工件。咱們建議您選擇Maven或Gradle。讓SpringBoot與其餘構建系統(例如Ant)一塊兒工做是可能的，但它們並非特別受支持的。
13.1撫養管理
SpringBoot的每一個版本都提供了它支持的依賴項的管理列表。實際上，您不須要在構建配置中爲這些依賴項中的任何一個提供版本，由於SpringBoot爲您管理這些依賴關係。升級SpringBoot自己時，這些依賴項也會以一致的方式升級。
|
| 若是須要，仍然能夠指定版本並覆蓋SpringBoot的建議。 |
管理列表包含了您能夠在SpringBoot中使用的全部Spring模塊，以及一個完善的第三方庫列表。該列表可做爲標準提供。物料清單(spring-boot-dependencies)二者均可以使用的馬文和梯度.
|
| SpringBoot的每一個版本都與Spring框架的一個基本版本相關聯。咱們高度建議您不要指定其版本。 |
13.2 Maven
Maven用戶能夠從spring-boot-starter-parent項目以得到合理的默認值。父項目提供如下特性：
- Java 1.8做爲默認編譯器級別。
- UTF-8源編碼。
- A 撫養管理科，繼承自Spring-boot依賴項pom，該pom管理公共依賴項的版本。這種依賴關係管理容許您在本身的pom中使用時省略那些依賴項的標記。
- 的執行
repackage目標帶着repackage行刑證實。 - 感情用事資源過濾.
- 合理的插件配置(EXEC插件, Git提交ID，和遮蔭).
- 敏感資源過濾
application.properties和application.yml包括特定於配置文件的文件(例如，application-dev.properties和application-dev.yml)
注意，由於application.properties和application.yml文件接受Spring樣式佔位符(${…})，則將Maven篩選更改成使用@..@佔位符。(您能夠經過設置名爲resource.delimiter.)
13.2.1繼承初學者父母
將項目配置爲從spring-boot-starter-parent，設置parent詳情以下：
<!-- Inherit defaults from Spring Boot --> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.0.BUILD-SNAPSHOT</version> </parent>
|
| 您應該只需在此依賴項上指定SpringBoot版本號。若是您導入其餘啓動程序，則能夠安全地省略版本號。 |
使用該設置，還能夠經過重寫本身項目中的屬性來覆蓋各個依賴項。例如，要升級到另外一個Spring數據發佈培訓，您能夠將如下內容添加到您的pom.xml:
<properties> <spring-data-releasetrain.version>Fowler-SR2</spring-data-releasetrain.version> </properties>
|
| 檢查 |
13.2.2在沒有父POM的狀況下使用SpringBoot
不是每一個人都喜歡從spring-boot-starter-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>2.1.0.BUILD-SNAPSHOT</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement>
如前所述，前面的示例設置不容許您使用屬性覆蓋單個依賴項。要達到一樣的結果，您須要在dependencyManagement你的項目之前這，這個，那，那個spring-boot-dependencies入場。例如，要升級到另外一個Spring數據發佈培訓，能夠向您的pom.xml:
<dependencyManagement> <dependencies> <!-- Override Spring Data release train provided by Spring Boot --> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-releasetrain</artifactId> <version>Fowler-SR2</version> <type>pom</type> <scope>import</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-dependencies</artifactId> <version>2.1.0.BUILD-SNAPSHOT</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement>
|
| 在前面的示例中，咱們指定了BOM，可是任何依賴類型均可以相同的方式被重寫。 |
13.2.3使用SpringBootMaven插件
彈簧啓動包括一個Maven插件它能夠將項目打包爲可執行的JAR。將插件添加到您的<plugins>若是您想使用它，以下面的示例所示：
<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>
|
| 若是您使用SpringBootStart父pom，則只須要添加插件。除非您想要更改父級中定義的設置，不然不須要配置它。 |
13.3級
要了解如何在Gradle中使用SpringBoot，請參閱SpringBoot的Gradle插件的文檔：
13.4螞蟻
能夠使用ApacheAnt+Ivy構建SpringBoot項目。這，這個，那，那個spring-boot-antlib「AntLib」模塊還能夠幫助Ant建立可執行的JAR。
要聲明依賴項，典型的ivy.xml文件以下所示：
<ivy-module version="2.0">
<info organisation="org.springframework.boot" module="spring-boot-sample-ant" />
<configurations>
<conf name="compile" description="everything needed to compile this module" />
<conf name="runtime" extends="compile" description="everything needed to run this module" />
</configurations>
<dependencies>
<dependency org="org.springframework.boot" name="spring-boot-starter"
rev="${spring-boot.version}" conf="compile" />
</dependencies>
</ivy-module>
典型build.xml以下示例所示：
<project xmlns:ivy="antlib:org.apache.ivy.ant" xmlns:spring-boot="antlib:org.springframework.boot.ant" name="myapp" default="build"> <property name="spring-boot.version" value="2.1.0.BUILD-SNAPSHOT" /> <target name="resolve" description="--> retrieve dependencies with ivy"> <ivy:retrieve pattern="lib/[conf]/[artifact]-[type]-[revision].[ext]" /> </target> <target name="classpaths" depends="resolve"> <path id="compile.classpath"> <fileset dir="lib/compile" includes="*.jar" /> </path> </target> <target name="init" depends="classpaths"> <mkdir dir="build/classes" /> </target> <target name="compile" depends="init" description="compile"> <javac srcdir="src/main/java" destdir="build/classes" classpathref="compile.classpath" /> </target> <target name="build" depends="compile"> <spring-boot:exejar destfile="build/myapp.jar" classes="build/classes"> <spring-boot:lib> <fileset dir="lib/runtime" /> </spring-boot:lib> </spring-boot:exejar> </target> </project>
|
| 若是您不想使用 |
13.5啓動器
Starters是一組方便的依賴描述符，能夠包含在應用程序中。您能夠爲您須要的全部Spring和相關技術提供一站式服務，而無需搜索示例代碼和複製粘貼大量的依賴描述符。例如，若是您想開始使用Spring和JPA進行數據庫訪問，請將spring-boot-starter-data-jpa項目中的依賴項。
啓動程序包含許多依賴項，您須要這些依賴項才能使項目快速啓動和運行，而且具備一致的、受支持的託管傳遞依賴關係集。
名字裏有什麼
全官初學者遵循相似的命名模式；spring-boot-starter-*，在哪裏*是一種特殊類型的應用程序。當您須要找到啓動器時，此命名結構旨在幫助您。許多IDE中的Maven集成容許您按名稱搜索依賴項。例如，安裝了適當的Eclipse或STS插件後，能夠按ctrl-space在POM編輯器中鍵入「Spring-boot-starter」以得到完整的列表。
如「建立本身的初學者「第三部分，第三人不該以spring-boot，由於它是爲官方的SpringBoot文物保留的。相反，第三方啓動程序一般以項目名稱開始。例如，一個第三方啓動項目稱爲thirdpartyproject一般被命名爲thirdpartyproject-spring-boot-starter.
下面的應用程序啓動程序由SpringBoot在org.springframework.boot小組：
表13.1.彈簧啓動應用程序啓動器
| 名字，姓名 | 描述 | 波姆 |
|---|---|---|
|
|
核心啓動程序，包括自動配置支持、日誌記錄和YAML。 |
|
|
|
使用ApacheActiveMQ啓動JMS消息傳遞 |
|
|
|
使用SpringAMQP和兔子MQ的啓動器 |
|
|
|
使用SpringAOP和AspectJ進行面向方面的編程 |
|
|
|
使用ApacheArtemis啓動JMS消息傳遞 |
|
|
|
彈簧批次起動器 |
|
|
|
開始使用Spring框架的緩存支持 |
|
|
|
使用SpringCloud鏈接器的初學者，它簡化了雲平臺(如CloudFoundry和Heroku)中的服務鏈接 |
|
|
|
開始使用Cassandra分佈式數據庫和Spring數據Cassandra |
|
|
|
使用Cassandra分佈式數據庫和Spring數據的啓動器-Cassandra反應性 |
|
|
|
開始使用Couchbase面向文檔的數據庫和Spring數據庫 |
|
|
|
開始使用面向Couchbase文檔的數據庫和SpringDataCouchbase反應性 |
|
|
|
使用彈性搜索和分析引擎及Spring數據彈性搜索的啓動器 |
|
|
|
使用Spring數據JDBC的啓動程序 |
|
|
|
Spring數據JPA與Hibernate的啓動 |
|
|
|
開始使用Spring數據LDAP |
|
|
|
開始使用MongoDB面向文檔的數據庫和Spring數據MongoDB |
|
|
|
MongoDB面向文檔數據庫和Spring數據的啓動 |
|
|
|
Neo4j圖形數據庫和Spring數據Neo4j的啓動 |
|
|
|
啓動使用Redis鍵值數據存儲與Spring數據Redis和生菜客戶端 |
|
|
|
啓動使用Redis鍵值數據存儲與SpringDataRedisReactiveand生菜客戶端 |
|
|
|
開始使用Spring數據REST在REST上公開Spring數據存儲庫 |
|
|
|
Apache Solr搜索平臺與Spring數據Solr的啓動 |
|
|
|
使用FreeMarker視圖構建MVC Web應用程序的入門 |
|
|
|
使用Groovy模板視圖構建MVC Web應用程序的入門 |
|
|
|
用SpringMVC和SpringHATEOA構建基於超媒體的RESTfulweb應用程序 |
|
|
|
使用Spring集成的啓動器 |
|
|
|
與HikariCP鏈接池一塊兒使用JDBC的啓動程序 |
|
|
|
使用JAX-RS和澤西島構建RESTful Web應用程序的初學者。替代物 |
|
|
|
開始使用jOOQ訪問SQL數據庫。替代物 |
|
|
|
讀寫入門 |
|
|
|
使用Atomikos啓動JTA事務 |
|
|
|
使用Bitronix啓動JTA事務 |
|
|
|
啓動使用Java郵件和Spring框架的電子郵件發送支持 |
|
|
|
使用鬍子視圖構建Web應用程序的初學者 |
|
|
|
使用SpringSecurity的OAuth2/OpenID鏈接客戶端特性的啓動器 |
|
|
|
使用Quartz調度程序的啓動程序 |
|
|
|
使用Spring安全性的啓動器 |
|
|
|
使用包括JUnit、Hamcrest和Mockito在內的庫測試SpringBoot應用程序的初學者 |
|
|
|
使用Thymeleaf視圖構建MVC Web應用程序的入門 |
|
|
|
JavaBean驗證與Hibernate驗證器的啓動 |
|
|
|
使用SpringMVC構建Web應用程序，包括RESTful應用程序。使用Tomcat做爲默認的嵌入式容器。 |
|
|
|
啓動使用SpringWeb服務 |
|
|
|
使用Spring框架的反應性Web支持構建WebFlux應用程序的初學者 |
|
|
|
使用Spring框架的WebSocket支持構建WebSocket應用程序的初學者 |
除了應用程序啓動程序以外，還能夠使用如下啓動程序添加生產準備特徵：
表13.2.彈簧啓動生產啓動器
| 名字，姓名 | 描述 | 波姆 |
|---|---|---|
|
|
使用SpringBootActuator的初學者，它提供生產準備功能，幫助您監視和管理應用程序 |
最後，SpringBoot還包括如下啓動程序，若是要排除或交換特定的技術方面，能夠使用這些啓動程序：
表13.3.彈簧啓動技術啓動器
| 名字，姓名 | 描述 | 波姆 |
|---|---|---|
|
|
開始使用Jetty做爲嵌入式servlet容器。替代物 |
|
|
|
開始使用Log4j2進行日誌記錄。替代物 |
|
|
|
使用Logback開始日誌記錄。默認日誌起動器 |
|
|
|
開始使用反應堆Netty做爲嵌入式反應HTTP服務器。 |
|
|
|
開始使用Tomcat做爲嵌入式servlet容器。使用的默認servlet容器啓動器 |
|
|
|
做爲嵌入式servlet容器的啓動程序。替代物 |
|
| 有關其餘社區貢獻者的列表，請參見自述文件在.。 |
14.構造代碼
SpringBoot不須要任何特定的代碼佈局才能工做。然而，有一些最佳實踐是有幫助的。
14.1使用「默認」包
類不包括package聲明，它被認爲是在「默認包」中。一般不鼓勵使用「默認包」，應該避免使用。它可能會給SpringBoot應用程序帶來特殊問題，這些應用程序使用@ComponentScan, @EntityScan，或@SpringBootApplication註釋，由於每一個JAR中的每一個類都會被讀取。
|
| 咱們建議您遵循Java推薦的包命名約定，並使用反向域名(例如， |
14.2定位主應用程序類
咱們一般建議您將主應用程序類定位在根包中，而不是其餘類。這，這個，那，那個@SpringBootApplication註記一般放在主類中，而且它隱式地定義了特定項的基本「搜索包」。例如，若是您正在編寫JPA應用程序，則@SpringBootApplication帶註釋的類用於搜索@Entity物品。使用根包還容許組件掃描只應用於項目。
|
| 若是你不想用 |
下面的清單顯示了一個典型的佈局：
com
+- example
+- myapplication
+- Application.java
|
+- customer
| +- Customer.java
| +- CustomerController.java
| +- CustomerService.java
| +- CustomerRepository.java
|
+- order
+- Order.java
+- OrderController.java
+- OrderService.java
+- OrderRepository.java
這，這個，那，那個Application.java文件將聲明main方法，以及@SpringBootApplication，以下：
package com.example.myapplication;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
15.配置類
Spring Boot支持基於Java的配置。雖然能夠使用SpringApplication對於xml源，咱們一般建議您的主源是一個@Configuration班級，等級一般定義main方法是一種很好的候選方法。@Configuration.
|
| 許多使用XML配置的Spring配置示例已經在Internet上發佈。若是可能，請始終嘗試使用等效的基於Java的配置。尋覓 |
15.1導入其餘配置類
你不須要把你全部的@Configuration變成一個班級。這，這個，那，那個@Import註釋可用於導入其餘配置類。或者，您能夠使用@ComponentScan自動獲取全部Spring組件，包括@Configuration上課。
15.2導入XML配置
若是您絕對必須使用基於xml的配置，咱們建議您仍然從@Configuration班級，等級而後，您能夠使用@ImportResource註釋以加載XML配置文件。
16.自動配置
SpringBoot自動配置嘗試根據您添加的JAR依賴關係自動配置Spring應用程序。例如，若是HSQLDB在類路徑上，而且沒有手動配置任何數據庫鏈接bean，那麼SpringBoot自動配置內存中的數據庫。
您須要經過添加@EnableAutoConfiguration或@SpringBootApplication中的一個註釋@Configuration上課。
|
| 你只應該加一個 |
16.1逐步取代自動配置
自動配置是非侵入性的。在任什麼時候候，您均可以開始定義本身的配置來替換自動配置的特定部分。例如，若是添加本身的DataSourcebean，默認的嵌入式數據庫支持將再也不支持。
若是您須要瞭解當前應用的是什麼自動配置，以及爲何應用程序，請使用--debug切換。這樣作能夠爲選定的核心記錄器啓用調試日誌，並將條件報告記錄到控制檯。
16.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 {
}
若是類不在類路徑上，則能夠使用excludeName屬性，並指定徹底限定的名稱。最後，還能夠經過使用spring.autoconfigure.exclude財產。
|
| 您能夠在註釋級別和經過使用屬性定義排除。 |
17.Springbean和依賴注入
您能夠使用任何標準的SpringFramework技術來定義bean及其注入的依賴項。爲了簡單起見，咱們常常發現@ComponentScan(找到您的bean)並使用@Autowired(進行構造函數注入)工做得很好。
若是按照上面的建議構造代碼(將應用程序類定位在根包中)，則能夠添加@ComponentScan沒有任何爭論。全部應用程序組件(@Component, @Service, @Repository, @Controller自動註冊爲Springbean。
下面的示例顯示@Servicebean，它使用構造函數注入來得到所需的RiskAssessor豆子：
package com.example.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class DatabaseAccountService implements AccountService {
private final RiskAssessor riskAssessor;
@Autowired
public DatabaseAccountService(RiskAssessor riskAssessor) {
this.riskAssessor = riskAssessor;
}
// ...
}
若是bean有一個構造函數，則能夠省略@Autowired，如如下示例所示：
@Service
public class DatabaseAccountService implements AccountService {
private final RiskAssessor riskAssessor;
public DatabaseAccountService(RiskAssessor riskAssessor) {
this.riskAssessor = riskAssessor;
}
// ...
}
|
| 注意如何使用構造函數注入使 |
18.使用@SpringBootApplication註釋
許多SpringBoot開發人員喜歡他們的應用程序使用自動配置、組件掃描，而且可以在他們的「應用程序類」上定義額外的配置。單曲@SpringBootApplication能夠使用註釋來啓用這三個特性，即：
@EnableAutoConfiguration*啓用彈簧啓動自動配置機構@ComponentScan*啓用@Component掃描應用程序所在的包(請參閱最佳作法)@Configuration容許在上下文中註冊額外的bean或導入其餘配置類
這，這個，那，那個@SpringBootApplication註釋至關於使用@Configuration, @EnableAutoConfiguration，和@ComponentScan使用它們的默認屬性，以下面的示例所示：
package com.example.myapplication;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication // same as @Configuration @EnableAutoConfiguration @ComponentScan
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
|
|
|
|
| 這些特性中沒有一個是強制性的，您能夠選擇用它所啓用的任何特性來替換這個單個註釋。例如，您可能不但願在應用程序中使用組件掃描： package com.example.myapplication;
import org.springframework.boot.SpringApplication;
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
@Configuration
@EnableAutoConfiguration
@Import({ MyConfig.class, MyAnotherConfig.class })
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
} 在這個例子中， |
19.運行您的應用程序
將應用程序打包爲JAR並使用嵌入式HTTP服務器的最大優勢之一是能夠像運行其餘應用程序同樣運行應用程序。調試SpringBoot應用程序也很容易。您不須要任何特殊的IDE插件或擴展。
|
| 本節僅涉及基於JAR的包裝。若是選擇將應用程序打包爲WAR文件，則應參考服務器和IDE文檔。 |
19.1從IDE運行
您能夠從IDE做爲一個簡單的Java應用程序運行SpringBoot應用程序。可是，您首先須要導入項目。導入步驟因IDE和生成系統而異。大多數IDE能夠直接導入Maven項目。例如，Eclipse用戶能夠選擇Import… → Existing Maven Projects從File菜單。
若是不能直接將項目導入IDE，則能夠使用構建插件生成IDE元數據。Maven包括用於月食和理念。Gradle爲各類IDE.
|
| 若是您意外地運行了兩個web應用程序，您會看到一個「端口已經在使用」錯誤。STS用戶能夠使用 |
19.2做爲打包應用程序運行
若是使用SpringBootMaven或Gradle插件建立可執行JAR，則能夠使用java -jar，如如下示例所示：
$ java -jar target/myapplication-0.0.1-SNAPSHOT.jar
還能夠在啓用遠程調試支持的狀況下運行打包應用程序。這樣作能夠將調試器附加到打包的應用程序，以下面的示例所示：
$ java -Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n \
-jar target/myapplication-0.0.1-SNAPSHOT.jar
19.3使用Maven插件
SpringBootMaven插件包括一個run可用於快速編譯和運行應用程序的目標。應用程序以爆炸性的形式運行，就像它們在您的IDE中所作的那樣。下面的示例顯示了運行SpringBoot應用程序的典型Maven命令：
$ mvn spring-boot:run
您可能還須要使用MAVEN_OPTS操做系統環境變量，如如下示例所示：
$ export MAVEN_OPTS=-Xmx1024m
19.4使用Gradle插件
SpringBootGradle插件還包括bootRun可用於以爆炸性形式運行應用程序的任務。這，這個，那，那個bootRun當您應用org.springframework.boot和java插件，如如下示例所示：
$ gradle bootRun
您可能還須要使用JAVA_OPTS操做系統環境變量，如如下示例所示：
$ export JAVA_OPTS=-Xmx1024m
19.5熱交換
因爲SpringBoot應用程序只是普通的Java應用程序，所以JVM熱交換應該是現成的。JVM熱交換在必定程度上受到了它能夠替換的字節碼的限制。爲了更完整的解決方案，賈貝爾能夠使用。
這，這個，那，那個spring-boot-devtools模塊還包括對快速應用程序從新啓動的支持。見第20章，開發工具本章後面的一節以及熱騰騰的「如何-到」關於細節。
20.開發工具
SpringBoot包括一組額外的工具，這些工具能夠使應用程序開發體驗更加愉快。這，這個，那，那個spring-boot-devtools模塊能夠包含在任何項目中，以提供額外的開發時特性。要包含DevTools支持，請將模塊依賴項添加到您的構建中，如Maven和Gradle的如下清單所示：
梅文。
<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <optional>true</optional> </dependency> </dependencies>
格拉德爾。
dependencies {
compile("org.springframework.boot:spring-boot-devtools")
}
|
| 在運行完整打包的應用程序時，將自動禁用開發工具。若是您的應用程序是從 |
|
| 默認狀況下，從新打包的檔案不包含DevTools。若是您想使用某些遠程DevTools功能，則須要禁用 |
20.1財產違約
SpringBoot支持的幾個庫使用緩存來提升性能。例如模板引擎緩存已編譯模板，以免重複解析模板文件。此外，SpringMVC能夠在提供靜態資源時向響應添加HTTP緩存頭。
雖然緩存在生產中很是有益，但它在開發過程當中可能會拔苗助長，從而阻止您看到您剛纔在應用程序中所作的更改。所以，Springboot-DevTools默認禁用緩存選項。
緩存選項一般由application.properties檔案。例如，Thymeleaf提供spring.thymeleaf.cache財產。不須要手動設置這些屬性，spring-boot-devtools模塊自動應用合理的開發時間配置。
由於您在開發SpringMVC和SpringWebFlux應用程序時須要更多關於Web請求的信息，因此開發人員工具將啓用DEBUG的日誌記錄。web伐木組。這將爲您提供有關傳入請求、正在處理它的處理程序、響應結果等方面的信息。若是但願記錄全部請求詳細信息(包括潛在敏感信息)，能夠打開spring.http.log-request-details配置屬性。
|
| 若是不但願應用屬性默認值，則能夠設置 |
|
| 有關DevTools應用的屬性的完整列表，請參見DevToolsPropertyDefaultsPostProcessor. |
20.2自動重啓
使用spring-boot-devtools每當類路徑上的文件發生更改時，都會自動從新啓動。在IDE中工做時，這多是一個有用的特性，由於它爲代碼更改提供了一個很是快速的反饋循環。默認狀況下，指向文件夾的類路徑上的任何條目都會被監視更改。注意，某些資源，如靜態資產和視圖模板，不須要從新啓動應用程序。.
觸發從新啓動
在DevTools監視類路徑資源時，觸發從新啓動的惟一方法是更新類路徑。致使類路徑更新的方式取決於您正在使用的IDE。在Eclipse中，保存修改後的文件將致使類路徑被更新並觸發從新啓動。在IntelliJ IDEA中，構建項目(Build -> Build Project)具備相同的效果。
|
| 只要啓用了分叉，您也能夠使用支持的構建插件(Maven和Gradle)啓動應用程序，由於DevTools須要一個獨立的應用程序類加載程序才能正常運行。默認狀況下，Gradle和Maven在類路徑上檢測DevTools時會這樣作。 |
|
| 當與LiveReload一塊兒使用時，自動從新啓動工做很是好。參見LiveReload部分關於細節。若是使用JRebel，則禁用自動從新啓動以支持動態類從新加載。其餘DevTools特性(如LiveReload和PropertyOverrids)仍然能夠使用。 |
|
| DevTools依賴於應用程序上下文的關機鉤子來關閉它。若是禁用了關機掛鉤( |
|
| 在決定類路徑上的條目是否應該在更改時觸發從新啓動時，DevTools會自動忽略名爲 |
|
| DevTools須要自定義 |
從新啓動VS Reload
SpringBoot提供的從新啓動技術經過使用兩個類加載器來工做。不更改的類(例如，來自第三方JAR的類)被加載到底座類加載器。正在積極開發的類被加載到從新啓動類加載器。從新啓動應用程序時，從新啓動類加載器被丟棄，並建立一個新的類加載器。這種方法意味着應用程序從新啓動一般比「冷啓動」快得多，由於底座類加載器已經可用並已填充。
若是發現從新啓動對應用程序來講不夠快，或者遇到類加載問題，則能夠考慮從新加載技術，例如賈貝爾來自ZeroTurn的。這些工做是經過在加載類時重寫類來完成的，以使它們更易於從新加載。
20.2.1狀態評估中的測井變化
默認狀況下，每次應用程序從新啓動時，都會記錄一個顯示條件評估增量的報告。報告顯示了在進行更改時對應用程序的自動配置所作的更改，例如添加或刪除bean以及設置配置屬性。
若要禁用報表的日誌記錄，請設置如下屬性：
spring.devtools.restart.log-condition-evaluation-delta=false
20.2.2不包括資源
某些資源在更改時不必定須要觸發從新啓動。例如，Thymeleaf模板能夠就地編輯.默認狀況下，更改/META-INF/maven, /META-INF/resources, /resources, /static, /public，或/templates不會觸發從新啓動，但會觸發活重裝。若是要自定義這些排除，能夠使用spring.devtools.restart.exclude財產。例如，僅排除/static和/public您將設置如下屬性：
spring.devtools.restart.exclude=static/**,public/**
|
| 若是你想保留這些默認值加其餘排除，請使用 |
20.2.3觀察其餘路徑
您可能但願在對不位於類路徑上的文件進行更改時從新啓動或從新加載應用程序。若要這樣作，請使用spring.devtools.restart.additional-paths屬性配置其餘路徑以監視更改。您能夠使用spring.devtools.restart.exclude財產前文描述若要控制附加路徑下的更改是否觸發徹底從新啓動或活重裝.
20.2.4禁用從新啓動
若是不想使用從新啓動功能，能夠使用spring.devtools.restart.enabled財產。在大多數狀況下，您能夠在application.properties(這樣作仍然初始化從新啓動類加載器，但它不監視文件更改)。
若是你須要徹底地禁用從新啓動支持(例如，由於它不適用於特定的庫)，您須要設置spring.devtools.restart.enabled System財產false在打電話以前SpringApplication.run(…)，如如下示例所示：
public static void main(String[] args) {
System.setProperty("spring.devtools.restart.enabled", "false");
SpringApplication.run(MyApp.class, args);
}
20.2.5使用觸發器文件
若是您使用持續編譯更改文件的IDE，則可能但願只在特定時間觸發從新啓動。爲此，您能夠使用「觸發器文件」，這是一個特殊的文件，當您想要實際觸發從新啓動檢查時，必須修改該文件。更改文件只會觸發檢查，只有在DevTools檢測到必須作什麼時纔會從新啓動。觸發器文件能夠手動更新，也能夠使用IDE插件更新。
若要使用觸發器文件，請將spring.devtools.restart.trigger-file屬性設置爲觸發器文件的路徑。
|
| 你可能想要設置 |
20.2.6自定義從新啓動類加載程序
如前面所述，從新啓動VS Reload節中，從新啓動功能是經過使用兩個類加載器實現的。對於大多數應用程序來講，這種方法工做得很好。可是，它有時會致使類加載問題。
默認狀況下，IDE中的任何打開項目都帶有「從新啓動」類加載器和任何常規的類加載器。.jar使用「基本」類加載器加載文件。若是您在一個多模塊項目上工做，並且不是每一個模塊都導入到您的IDE中，那麼您可能須要定製一些東西。爲此，您能夠建立一個META-INF/spring-devtools.properties檔案。
這，這個，那，那個spring-devtools.properties文件能夠包含以restart.exclude和restart.include。這，這個，那，那個include元素是應該拖放到「從新啓動」類加載器中的項，而且exclude元素是應該向下推到「基本」類加載器中的項。屬性的值是應用於類路徑的regex模式，以下面的示例所示：
restart.exclude.companycommonlibs=/mycorp-common-[\\w-]+\.jar restart.include.projectcommon=/mycorp-myproj-[\\w-]+\.jar
|
| 全部屬性鍵必須是惟一的。只要財產開始於 |
|
| 全 |
20.2.7已知限制
從新啓動功能不能很好地處理使用標準反序列化的對象。ObjectInputStream。若是須要反序列化數據，則可能須要使用Spring的ConfigurableObjectInputStream結合在一塊兒Thread.currentThread().getContextClassLoader().
不幸的是，一些第三方庫在不考慮上下文類加載器的狀況下反序列化.若是發現這樣的問題，則須要向原始做者請求修復。
20.3 LiveReload
這，這個，那，那個spring-boot-devtools模塊包括嵌入式LiveReload服務器，該服務器可用於在資源更改時觸發瀏覽器刷新。LiveReload瀏覽器擴展能夠免費提供給Chrome、Firefox和Safarilivereload.com.
若是不但願在應用程序運行時啓動LiveReload服務器，則能夠將spring.devtools.livereload.enabled財產false.
|
| 一次只能運行一個LiveReload服務器。在啓動應用程序以前，請確保沒有其餘LiveReload服務器正在運行。若是您從IDE啓動多個應用程序，那麼只有第一個應用程序具備LiveReload支持。 |
20.4全球設置
能夠經過添加名爲.spring-boot-devtools.properties敬你的$HOME文件夾(請注意文件名以「.」開頭)。添加到此文件的任何屬性都應用於全使用DevTools的機器上的SpringBoot應用程序。例如，要將從新啓動配置爲始終使用觸發文件，您將添加如下屬性：
~/.Spring-boot-devtools.properties。
spring.devtools.reload.trigger-file=.reloadtrigger
20.5遠程應用程序
SpringBootDeveloper工具並不侷限於本地開發。在遠程運行應用程序時，還能夠使用幾個特性。遠程支持是可選的。要啓用它，您須要確保devtools包含在從新打包的歸檔中，以下面的清單所示：
<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <excludeDevtools>false</excludeDevtools> </configuration> </plugin> </plugins> </build>
而後，您須要設置一個spring.devtools.remote.secret屬性，如如下示例所示：
spring.devtools.remote.secret=mysecret
|
| 使能 |
遠程DevTools支持分爲兩部分：接受鏈接的服務器端點和在IDE中運行的客戶端應用程序。控件時自動啓用服務器組件。spring.devtools.remote.secret屬性設置。必須手動啓動客戶端組件。
20.5.1運行遠程客戶端應用程序
遠程客戶端應用程序設計爲在IDE中運行。你得跑org.springframework.boot.devtools.RemoteSpringApplication具備與所鏈接的遠程項目相同的類路徑。應用程序惟一須要的參數是它所鏈接的遠程URL。
例如，若是您正在使用Eclipse或STS，而且您有一個名爲my-app您已經部署到CloudFoundry，您將執行如下操做：
- 選擇
Run Configurations…從Run菜單。 - 建立一個新的
Java Application「發射配置」。 - 瀏覽
my-app項目。 - 使用
org.springframework.boot.devtools.RemoteSpringApplication做爲主修班。 - 加
https://myapp.cfapps.io到Program arguments(或者無論您的遠程URL是什麼)。
正在運行的遠程客戶端可能相似於如下清單：
. ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ ___ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | | _ \___ _ __ ___| |_ ___ \ \ \ \ \\/ ___)| |_)| | | | | || (_| []::::::[] / -_) ' \/ _ \ _/ -_) ) ) ) ) ' |____| .__|_| |_|_| |_\__, | |_|_\___|_|_|_\___/\__\___|/ / / / =========|_|==============|___/===================================/_/_/_/ :: Spring Boot Remote :: 2.1.0.BUILD-SNAPSHOT 2015-06-10 18:25:06.632 INFO 14938 --- [ main] o.s.b.devtools.RemoteSpringApplication : Starting RemoteSpringApplication on pwmbp with PID 14938 (/Users/pwebb/projects/spring-boot/code/spring-boot-devtools/target/classes started by pwebb in /Users/pwebb/projects/spring-boot/code/spring-boot-samples/spring-boot-sample-devtools) 2015-06-10 18:25:06.671 INFO 14938 --- [ main] s.c.a.AnnotationConfigApplicationContext : Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@2a17b7b6: startup date [Wed Jun 10 18:25:06 PDT 2015]; root of context hierarchy 2015-06-10 18:25:07.043 WARN 14938 --- [ main] o.s.b.d.r.c.RemoteClientConfiguration : The connection to http://localhost:8080 is insecure. You should use a URL starting with 'https://'. 2015-06-10 18:25:07.074 INFO 14938 --- [ main] o.s.b.d.a.OptionalLiveReloadServer : LiveReload server is running on port 35729 2015-06-10 18:25:07.130 INFO 14938 --- [ main] o.s.b.devtools.RemoteSpringApplication : Started RemoteSpringApplication in 0.74 seconds (JVM running for 1.105)
|
| 因爲遠程客戶端使用的類路徑與實際應用程序相同，所以能夠直接讀取應用程序屬性。這就是爲何 |
|
| 使用老是明智的。 |
|
| 若是須要使用代理訪問遠程應用程序，請配置 |
20.5.2遠程更新
遠程客戶端監視應用程序類路徑的更改，方式與局部重啓。任何更新的資源都被推送到遠程應用程序中，而且(若有須要)觸發從新啓動。若是您在使用本地沒有的雲服務的特性上進行迭代，這可能會頗有幫助。一般，遠程更新和從新啓動要比完整的重建和部署週期快得多。
|
| 只有在遠程客戶端運行時才監視文件。若是在啓動遠程客戶端以前更改文件，則不會將其推送到遠程服務器。 |
21.包裝生產申請
可執行的JAR可用於生產部署。因爲它們是獨立的，因此它們也很是適合基於雲的部署。
要得到額外的「生產準備」功能，如健康、審覈和度量REST或jmx端點，請考慮添加spring-boot-actuator。看見第五部分，「SpringBoot執行器：可生產的特性」關於細節。
22.接下來要讀什麼？
如今您應該瞭解如何使用SpringBoot和應該遵循的一些最佳實踐。如今您能夠繼續瞭解彈簧啓動功能或者你能夠跳過前面讀到「生產準備「春靴的各個方面。
第四部分。彈簧啓動功能
本節討論SpringBoot的細節。在這裏，您能夠了解您可能但願使用和自定義的關鍵特性。若是您尚未這樣作，您可能須要閱讀「第二部分，「開始」「和」第三部分，「使用Spring Boot」「章節，讓你有一個良好的基礎。
23.Spring應用
這，這個，那，那個SpringApplication類提供了一種方便的方法來引導從main()方法。在許多狀況下，您能夠委託給靜態SpringApplication.run方法，如如下示例所示：
public static void main(String[] args) {
SpringApplication.run(MySpringConfiguration.class, args);
}
當應用程序啓動時，您應該會看到相似於如下輸出的內容：
. ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ \\/ ___)| |_)| | | | | || (_| | ) ) ) ) ' |____| .__|_| |_|_| |_\__, | / / / / =========|_|==============|___/=/_/_/_/ :: Spring Boot :: v2.1.0.BUILD-SNAPSHOT 2013-07-31 00:08:16.117 INFO 56603 --- [ main] o.s.b.s.app.SampleApplication : Starting SampleApplication v0.1.0 on mycomputer with PID 56603 (/apps/myapp.jar started by pwebb) 2013-07-31 00:08:16.166 INFO 56603 --- [ main] ationConfigServletWebServerApplicationContext : Refreshing org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@6e5a8246: startup date [Wed Jul 31 00:08:16 PDT 2013]; root of context hierarchy 2014-03-04 13:09:54.912 INFO 41370 --- [ main] .t.TomcatServletWebServerFactory : Server initialized with port: 8080 2014-03-04 13:09:56.501 INFO 41370 --- [ main] o.s.b.s.app.SampleApplication : Started SampleApplication in 2.992 seconds (JVM running for 3.658)
默認狀況下，INFO將顯示日誌消息，包括一些相關的啓動細節，例如啓動應用程序的用戶。若是您須要日誌級別而不是INFO，您能夠設置它，如第26.4節，「日誌水平」,
23.1啓動失敗
若是您的應用程序沒法啓動，請註冊FailureAnalyzers有機會提供一條專門的錯誤消息和解決問題的具體操做。例如，若是您在端口上啓動web應用程序8080並且該端口已經在使用中，您應該會看到相似於如下消息的內容：
*************************** APPLICATION FAILED TO START *************************** Description: Embedded servlet container failed to start. Port 8080 was already in use. Action: Identify and stop the process that's listening on port 8080 or configure this application to listen on another port.
|
| Spring Boot提供了許多 |
若是沒有故障分析器可以處理異常，則仍然能夠顯示完整的條件報告，以更好地瞭解錯誤所在。要作到這一點，你須要啓用debug財產或使能DEBUG測井爲org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener.
例如，若是您正在運行您的應用程序，則使用java -jar，您能夠啓用debug財產以下：
$ java -jar myproject-0.0.1-SNAPSHOT.jar --debug
23.2定製橫幅
在啓動時打印的橫幅能夠經過添加banner.txt文件到類路徑中，或者經過設置spring.banner.location屬性設置爲這樣一個文件的位置。若是文件具備utf-8之外的編碼，則能夠設置spring.banner.charset。除了文本文件以外，還能夠添加banner.gif, banner.jpg，或banner.png圖像文件到類路徑或設置spring.banner.image.location財產。圖像被轉換成ASCII藝術表示法，並打印在任何文字橫幅之上。
在你的banner.txt文件中，能夠使用下列任何佔位符：
表23.1.橫幅變量
| 變量 | 描述 |
|---|---|
|
|
應用程序的版本號，如 |
|
|
應用程序的版本號，如 |
|
|
您正在使用的SpringBoot版本。例如 |
|
|
您所使用的SpringBoot版本，格式化爲顯示(用括號包圍，前綴爲 |
|
|
哪裏 |
|
|
您的應用程序的標題，如 |
|
| 這，這個，那，那個 |
您還能夠使用spring.main.banner-mode屬性以肯定是否必須在其上打印橫幅。System.out (console)，發送到配置的記錄器(log)，或根本不生產(off).
打印的橫幅如下列名稱註冊爲單例bean：springBootBanner.
|
| YAML地圖 spring: main: banner-mode: "off" |
23.3定製Spring應用程序
若是SpringApplication默認值並不適合您的口味，您能夠建立一個本地實例並對其進行自定義。例如，要關閉橫幅，能夠編寫：
public static void main(String[] args) {
SpringApplication app = new SpringApplication(MySpringConfiguration.class);
app.setBannerMode(Banner.Mode.OFF);
app.run(args);
}
|
| 傳遞給 |
還能夠配置SpringApplication經過使用application.properties檔案。看見第24章，外化配置關於細節。
有關配置選項的完整列表，請參見SpringApplicationJavadoc.
23.4 FLUENT BuilderAPI
若是您須要構建一個ApplicationContext層次結構(具備父/子關係的多個上下文)，或者若是您更喜歡使用「流利」構建器API，則能夠使用SpringApplicationBuilder.
這，這個，那，那個SpringApplicationBuilder讓您將多個方法調用連接在一塊兒，幷包括parent和child容許您建立層次結構的方法，如如下示例所示：
new SpringApplicationBuilder() .sources(Parent.class) .child(Application.class) .bannerMode(Banner.Mode.OFF) .run(args);
|
| 建立 |
23.5應用程序事件和偵聽器
除了常見的Spring框架事件以外，例如ContextRefreshedEvent..SpringApplication發送其餘應用程序事件。
|
| 某些事件其實是在 若是但願這些偵聽器自動註冊，而無論應用程序的建立方式如何，則能夠添加 org.springframework.context.ApplicationListener=com.example.project.MyListener |
在應用程序運行時，應用程序事件按如下順序發送：
- 阿
ApplicationStartingEvent在運行開始時發送，但在任何處理以前發送，但偵聽器和初始化器的註冊除外。 - 阿
ApplicationEnvironmentPreparedEvent當Environment在上下文中使用是已知的，但在建立上下文以前。 - 阿
ApplicationPreparedEvent在啓動刷新以前發送，但在加載bean定義以後發送。 - 阿
ApplicationStartedEvent在刷新上下文以後，但在調用任何應用程序和命令行運行程序以前發送。 - 阿
ApplicationReadyEvent在調用任何應用程序和命令行運行程序以後發送。它表示應用程序已準備好爲請求提供服務。 - 阿
ApplicationFailedEvent若是啓動時出現異常，則發送。
|
| 您一般不須要使用應用程序事件，可是知道它們的存在是很方便的。在內部，SpringBoot使用事件來處理各類任務。 |
應用程序事件是經過使用SpringFramework的事件發佈機制發送的。此機制的一部分確保在子上下文中發佈給偵聽器的事件也會在任何祖先上下文中發佈給偵聽器。所以，若是應用程序使用的層次結構爲SpringApplication實例，偵聽器可能接收同一類型應用程序事件的多個實例。
若要容許偵聽器區分針對其上下文的事件和針對後代上下文的事件，則應請求注入其應用程序上下文，而後將注入的上下文與事件的上下文進行比較。能夠經過實現ApplicationContextAware或者，若是偵聽器是bean，則使用@Autowired.
23.6網絡環境
A SpringApplication嘗試建立正確類型的ApplicationContext表明你。用於肯定WebApplicationType至關簡單：
- 若是SpringMVC存在，則
AnnotationConfigServletWebServerApplicationContext使用 - 若是SpringMVC不存在且SpringWebFlux存在，則
AnnotationConfigReactiveWebServerApplicationContext使用 - 不然，
AnnotationConfigApplicationContext使用
這意味着若是您使用SpringMVC和新的WebClient從同一個應用程序中的SpringWebFlux開始，默認狀況下將使用SpringMVC。您能夠經過調用setWebApplicationType(WebApplicationType).
也能夠徹底控制ApplicationContext類型，該類型經過調用setApplicationContextClass(…).
|
| 打電話給 |
23.7訪問應用程序參數
若是須要訪問傳遞給SpringApplication.run(…)，你能夠注射org.springframework.boot.ApplicationArguments豆子這，這個，那，那個ApplicationArguments接口提供對兩個原始數據的訪問。String[]論點和分析option和non-option參數，如如下示例所示：
import org.springframework.boot.*;
import org.springframework.beans.factory.annotation.*;
import org.springframework.stereotype.*;
@Component
public class MyBean {
@Autowired
public MyBean(ApplicationArguments args) {
boolean debug = args.containsOption("debug");
List<String> files = args.getNonOptionArgs();
// if run with "--debug logfile.txt" debug=true, files=["logfile.txt"]
}
}
|
| Spring Boot還註冊了一個 |
23.8使用ApplicationRunner或CommandLineRunner
若是您須要在SpringApplication已經啓動，您能夠實現ApplicationRunner或CommandLineRunner接口。兩個接口都以相同的方式工做，並提供了一個run方法，該方法在前面被調用。SpringApplication.run(…)完成。
這，這個，那，那個CommandLineRunner接口以簡單字符串數組的形式提供對應用程序參數的訪問，而ApplicationRunner使用ApplicationArguments接口。下面的示例顯示CommandLineRunner帶着run方法：
import org.springframework.boot.*;
import org.springframework.stereotype.*;
@Component
public class MyBean implements CommandLineRunner {
public void run(String... args) {
// Do something...
}
}
若是幾個CommandLineRunner或ApplicationRunnerbean被定義爲必須按特定順序調用，您能夠另外實現org.springframework.core.Ordered接口或使用org.springframework.core.annotation.Order註釋
23.9申請出口
各SpringApplication向JVM註冊一個關閉掛鉤，以確保ApplicationContext在出口處優雅地關閉。全部標準的Spring生命週期回調(如DisposableBean接口或@PreDestroy(註釋)能夠使用。
此外，bean還能夠實現org.springframework.boot.ExitCodeGenerator接口時，若是但願返回特定的退出代碼，則爲SpringApplication.exit()叫作。而後，能夠將此退出代碼傳遞給System.exit()若要將其做爲狀態代碼返回，請參見如下示例：
@SpringBootApplication
public class ExitCodeApplication {
@Bean
public ExitCodeGenerator exitCodeGenerator() {
return () -> 42;
}
public static void main(String[] args) {
System.exit(SpringApplication
.exit(SpringApplication.run(ExitCodeApplication.class, args)));
}
}
此外，ExitCodeGenerator接口能夠經過異常實現。當遇到這樣的異常時，SpringBoot返回實現的退出代碼getExitCode()方法。
23.10行政特色
經過指定spring.application.admin.enabled財產。這暴露了SpringApplicationAdminMXBean在站臺上MBeanServer。您能夠使用此特性遠程管理SpringBoot應用程序。此特性對於任何服務包裝器實現也可能有用。
|
| 若是您想知道應用程序在哪一個HTTP端口上運行，請使用 |
|
謹慎 |
|---|---|
| 啓用此特性時要當心，由於MBean公開了關閉應用程序的方法。 |
24.外化配置
SpringBoot容許您將配置外部化，以便在不一樣的環境中使用相同的應用程序代碼。您能夠使用屬性文件、YAML文件、環境變量和命令行參數來外部化配置.屬性能夠將屬性值直接注入bean中。@Value註釋，經過Spring的Environment抽象，或被綁定到結構化對象貫通@ConfigurationProperties.
Spring Boot使用了一個很是特殊的PropertySource旨在容許合理地凌駕於價值觀之上的秩序。屬性按如下順序考慮：
- DevTools全局設置屬性在你的主目錄上(
~/.spring-boot-devtools.properties當DevTools處於活動狀態時)。 @TestPropertySource測試的註釋。properties屬性在您的測試中。可在@SpringBootTest而用於測試應用程序的特定部分的測試註釋.- 命令行參數。
- 屬性
SPRING_APPLICATION_JSON(嵌入到環境變量或系統屬性中的內聯JSON)。 ServletConfiginit參數ServletContextinit參數- 的JNDI屬性
java:comp/env. - Java系統屬性(
System.getProperties()). - 操做系統環境變量。
- A
RandomValuePropertySource中只具備屬性的random.*. - 特定於配置文件的應用程序屬性在你包裝的罐子外面(
application-{profile}.properties和YAML變體)。 - 特定於配置文件的應用程序屬性包裝在你的罐子裏(
application-{profile}.properties和YAML變體)。 - 打包JAR以外的應用程序屬性(
application.properties和YAML變體)。 - 打包在JAR中的應用程序屬性(
application.properties和YAML變體)。 @PropertySource的註釋@Configuration上課。- 默認屬性(由設置指定)
SpringApplication.setDefaultProperties).
爲了提供一個具體的示例，假設您開發了一個@Component使用name屬性，如如下示例所示：
import org.springframework.stereotype.*;
import org.springframework.beans.factory.annotation.*;
@Component
public class MyBean {
@Value("${name}")
private String name;
// ...
}
在應用程序類路徑(例如，在JAR中)上，能夠使用application.properties文件，該文件提供了name。在新環境中運行時，application.properties文件能夠在您的JAR以外提供，該JAR覆蓋name。對於一次性測試，能夠使用特定的命令行開關啓動(例如，java -jar app.jar --name="Spring").
|
| 這，這個，那，那個 $ SPRING_APPLICATION_JSON='{"acme":{"name":"test"}}' java -jar myapp.jar 在前面的示例中，您的結果是 $ java -Dspring.application.json='{"name":"test"}' -jar myapp.jar 還能夠使用命令行參數提供JSON，以下例所示： $ java -jar myapp.jar --spring.application.json='{"name":"test"}' 您還能夠將JSON做爲JNDI變量提供，以下所示： |
24.1配置隨機值
這，這個，那，那個RandomValuePropertySource對於注入隨機值(例如，向祕密或測試用例)頗有用。它能夠生成整數、長、uid或字符串，如如下示例所示：
my.secret=${random.value}
my.number=${random.int}
my.bignumber=${random.long}
my.uuid=${random.uuid}
my.number.less.than.ten=${random.int(10)}
my.number.in.range=${random.int[1024,65536]}
這，這個，那，那個random.int*語法是OPEN value (,max) CLOSE在那裏OPEN,CLOSE任何角色value,max是整數。若是max則提供value是最小值，而且max最大值(獨佔)。
24.2訪問命令行屬性
默認狀況下，SpringApplication轉換任何命令行選項參數(即以--，如--server.port=9000)property並將它們添加到春天Environment。如前所述，命令行屬性老是優先於其餘屬性源。
若是不但願將命令行屬性添加到Environment，您能夠經過如下方式禁用它們SpringApplication.setAddCommandLineProperties(false).
24.3應用程序屬性文件
SpringApplication從application.properties文件位於如下位置，並將它們添加到Spring中Environment:
- A
/config當前目錄的子目錄 - 當前目錄
- 類路徑
/config包裝 - 類生根
列表按優先級排序(在列表中較高的位置中定義的屬性覆蓋在較低位置中定義的屬性)。
|
| 你也能夠使用YAML(‘.yml’)文件做爲「.properties」的替代物。 |
若是你不喜歡application.properties做爲配置文件名，能夠經過指定spring.config.name環境屬性屬性還能夠引用顯式位置。spring.config.location環境屬性(它是以逗號分隔的目錄位置或文件路徑列表)。下面的示例演示如何指定不一樣的文件名：
$ java -jar myproject.jar --spring.config.name=myproject
下面的示例演示如何指定兩個位置：
$ java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties
|
|
|
若是spring.config.location包含目錄(相對於文件)，它們應該以/(並在運行時，附加從spring.config.name在加載以前，包括特定於配置文件的文件名)。中指定的文件spring.config.location做爲-is使用，不支持特定於配置文件的變體，而且被任何特定於配置文件的屬性覆蓋.
配置位置按反向順序搜索。默認狀況下，配置的位置爲classpath:/,classpath:/config/,file:./,file:./config/。獲得的搜索順序以下：
file:./config/file:./classpath:/config/classpath:/
當經過如下方式配置自定義配置位置時spring.config.location，它們替換默認位置。例如，若是spring.config.location配置爲classpath:/custom-config/,file:./custom-config/，搜索順序以下：
file:./custom-config/classpath:custom-config/
或者，當經過如下方法配置自定義配置位置時spring.config.additional-location，除默認位置外，還將使用它們。在默認位置以前搜索其餘位置。例如，若是classpath:/custom-config/,file:./custom-config/配置後，搜索順序以下：
file:./custom-config/classpath:custom-config/file:./config/file:./classpath:/config/classpath:/
此搜索順序容許您在一個配置文件中指定默認值，而後在另外一個配置文件中選擇性地覆蓋這些值。中爲應用程序提供默認值。application.properties(或您選擇的其餘任何基本名稱)spring.config.name)在默認位置之一。而後，能夠在運行時使用位於其中一個自定義位置的不一樣文件重寫這些默認值。
|
| 若是使用環境變量而不是系統屬性，大多數操做系統都不容許以週期分隔的鍵名，但能夠使用下劃線(例如， |
|
| 若是應用程序在容器中運行，則JNDI屬性(在 |
24.4剖面特性
除了……以外application.properties還能夠使用下列命名約定定義特定於配置文件的屬性：application-{profile}.properties。這，這個，那，那個Environment具備一組默認配置文件(默認狀況下，[default])，若是未設置活動配置文件，則使用。換句話說，若是沒有顯式激活配置文件，則application-default.properties都裝好了。
特定於配置文件的屬性是從與標準位置相同的位置加載的。application.properties，使用特定於配置文件的文件老是覆蓋非特定的文件，不管配置文件特定的文件是否位於打包的JAR內部或外部。
若是指定了多個配置文件，則應用最後一次獲勝策略。例如，由spring.profiles.active屬性的配置後添加SpringApplicationAPI，所以優先。
|
| 若是您在 |
24.5屬性中的佔位符
中的值application.properties經過現有的Environment當它們被使用時，您能夠引用之前定義的值(例如，從系統屬性)。
app.name=MyApp
app.description=${app.name} is a Spring Boot application
|
| 您還能夠使用此技術建立現有SpringBoot屬性的「短」變體。見第76.4節，「使用‘短’命令行參數」如何瞭解細節。 |
24.6使用YAML代替屬性
YAML是JSON的超集，所以是指定分層配置數據的方便格式。這，這個，那，那個SpringApplication類自動支持YAML做爲屬性的替代方法，只要您有蛇YAML你的類路徑上的圖書館。
|
| 若是使用「starters」，SnakeYAML將自動由 |
24.6.1裝載YAML
SpringFramework提供了兩個方便的類，可用於加載YAML文檔。這，這個，那，那個YamlPropertiesFactoryBean負載YAML ASProperties而YamlMapFactoryBean將YAML加載爲Map.
例如，考慮如下YAML文檔：
environments: dev: url: http://dev.example.com name: Developer Setup prod: url: http://another.example.com name: My Cool App
前面的示例將轉換爲如下屬性：
environments.dev.url=http://dev.example.com environments.dev.name=Developer Setup environments.prod.url=http://another.example.com environments.prod.name=My Cool App
YAML列表表示爲[index]脫扣器。例如，考慮如下YAML：
my: servers: - dev.example.com - another.example.com
前面的示例將轉換爲如下屬性：
my.servers[0]=dev.example.com my.servers[1]=another.example.com
經過使用SpringBoot的Binder實用程序(這是@ConfigurationProperties，則須要在類型爲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;
}
}
24.6.2在Spring環境中將YAML公開爲屬性
這，這個，那，那個YamlPropertySourceLoader類可用於將YAML公開爲PropertySource春天Environment。這樣作可讓您使用@Value帶有佔位符語法的註釋以訪問YAML屬性。
24.6.3多概況YAML文件
能夠在單個文件中指定多個特定於配置文件的YAML文檔。spring.profiles鍵指示什麼時候應用文檔，如如下示例所示：
server: address: 192.168.1.100 --- spring: profiles: development server: address: 127.0.0.1 --- spring: profiles: production & eu-central server: address: 192.168.1.120
在前面的示例中，若是development配置文件處於活動狀態，則server.address財產127.0.0.1。相似地，若是production 和 eu-central配置文件處於活動狀態，server.address財產192.168.1.120。若是development, production和eu-central配置文件是不啓用，則屬性的值爲192.168.1.100.
|
|
|
若是在應用程序上下文啓動時沒有顯式活動，默認配置文件將被激活。所以，在下面的YAML中，咱們爲spring.security.user.password那是可得的只在「默認」配置文件中：
server:
port: 8000
---
spring:
profiles: default
security:
user:
password: weak
然而，在下面的示例中，密碼老是被設置，由於它沒有附加到任何配置文件，而且在全部其餘配置文件中都必須在必要時顯式地重置它：
server:
port: 8000
spring:
security:
user:
password: weak
使用spring.profiles元素能夠經過使用!性格。若是爲單個文檔指定了否認的和非否認的配置文件，則至少必須有一個非否認的配置文件匹配，而且任何否認的配置文件都不能匹配。
24.6.4 YAML缺陷
屬性沒法加載YAML文件。@PropertySource註釋所以，在須要以這種方式加載值的狀況下，須要使用屬性文件。
24.7類型安全配置屬性
使用@Value("${property}")注入配置屬性的註釋有時會很麻煩，特別是若是您正在處理多個屬性，或者您的數據本質上是分層的。SpringBoot提供了一種使用屬性的替代方法，該方法容許強類型bean控制和驗證應用程序的配置，以下面的示例所示：
package com.example;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties("acme")
public class AcmeProperties {
private boolean enabled;
private InetAddress remoteAddress;
private final Security security = new Security();
public boolean isEnabled() { ... }
public void setEnabled(boolean enabled) { ... }
public InetAddress getRemoteAddress() { ... }
public void setRemoteAddress(InetAddress remoteAddress) { ... }
public Security getSecurity() { ... }
public static class Security {
private String username;
private String password;
private List<String> roles = new ArrayList<>(Collections.singleton("USER"));
public String getUsername() { ... }
public void setUsername(String username) { ... }
public String getPassword() { ... }
public void setPassword(String password) { ... }
public List<String> getRoles() { ... }
public void setRoles(List<String> roles) { ... }
}
}
前面的POJO定義瞭如下屬性：
acme.enabled，值爲false默認狀況下。acme.remote-address，具備能夠被脅迫的類型。String.acme.security.username具備嵌套的「Security」對象，該對象的名稱由屬性的名稱決定。特別是，返回類型根本不被使用，並且多是SecurityProperties.acme.security.password.acme.security.roles的集合String.
|
| getter和setter一般是強制性的，由於綁定是經過標準的JavaBeans屬性描述符進行的，就像SpringMVC中的那樣。在下列狀況下，可省略一位策劃人：
有些人使用ProjectLombok自動添加getter和setter。確保Lombok不會爲這種類型生成任何特定的構造函數，由於容器會自動使用它來實例化對象。 最後，只考慮標準JavaBean屬性，不支持在靜態屬性上綁定。 |
|
您還須要列出要在@EnableConfigurationProperties註釋，如如下示例所示：
@Configuration
@EnableConfigurationProperties(AcmeProperties.class)
public class MyConfiguration {
}
|
| 當 上面示例中的bean名稱是 |
即便前面的配置爲AcmeProperties，咱們建議@ConfigurationProperties只處理環境，特別是不從上下文注入其餘bean。話雖如此，@EnableConfigurationProperties註釋是也自動應用於您的項目，以便任何現有帶註釋的bean@ConfigurationProperties配置爲Environment。你能夠走捷徑MyConfiguration確保AcmeProperties已是一個bean，以下面的示例所示：
@Component
@ConfigurationProperties(prefix="acme")
public class AcmeProperties {
// ... see the preceding example
}
這種類型的配置特別適用於SpringApplication外部YAML配置，如如下示例所示：
# application.yml acme: remote-address: 192.168.1.1 security: username: admin roles: - USER - ADMIN # additional configuration as required
與之合做@ConfigurationPropertiesbean，您能夠與任何其餘bean相同的方式注入它們，以下面的示例所示：
@Service
public class MyService {
private final AcmeProperties properties;
@Autowired
public MyService(AcmeProperties properties) {
this.properties = properties;
}
//...
@PostConstruct
public void openConnection() {
Server server = new Server(this.properties.getRemoteAddress());
// ...
}
}
|
| 使用 |
24.7.1第三方配置
以及使用@ConfigurationProperties若要對類進行註釋，還能夠將其用於公共類。@Bean方法。當您想要將屬性綁定到超出您控制範圍的第三方組件時，這樣作特別有用。
配置bean的步驟。Environment屬性，添加@ConfigurationProperties到它的bean註冊，以下面的示例所示：
@ConfigurationProperties(prefix = "another")
@Bean
public AnotherComponent anotherComponent() {
...
}
屬性定義的任何屬性。another前綴映射到AnotherComponentbean的方式相似於前面的AcmeProperties舉個例子。
24.7.2放寬約束力
SpringBoot使用一些寬鬆的規則進行綁定Environment屬性@ConfigurationProperties類之間不須要徹底匹配。Environment屬性名稱和bean屬性名稱。有用的常見示例包括破折號分隔的環境屬性(例如，context-path綁定到contextPath)和大寫環境屬性(例如，PORT綁定到port).
例如，請考慮如下幾點@ConfigurationProperties班級：
@ConfigurationProperties(prefix="acme.my-project.person")
public class OwnerProperties {
private String firstName;
public String getFirstName() {
return this.firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
}
在前面的示例中，能夠使用如下屬性名稱：
表24.1.鬆弛結合
| 財產 | 注 |
|---|---|
|
|
烤肉串箱，推薦用於 |
|
|
標準駱駝案例語法。 |
|
|
中使用的另外一種格式：下劃線表示法。 |
|
|
大寫格式，在使用系統環境變量時推薦。 |
|
| 這，這個，那，那個 |
表24.2.每一個屬性源放鬆綁定規則
| 財產來源 | 簡約 | 列單 |
|---|---|---|
| 屬性文件 |
駱駝箱，烤肉串箱，或下劃線表示法 |
標準列表語法 |
| YAML檔案 |
駱駝箱，烤肉串箱，或下劃線表示法 |
標準YAML列表語法或逗號分隔的值 |
| 環境變量 |
大寫格式，下劃線做爲分隔符。 |
由下劃線包圍的數值，如 |
| 系統性質 |
駱駝箱，烤肉串箱，或下劃線表示法 |
標準列表語法 |
|
| 咱們建議，在可能的狀況下，屬性以小寫的kebab格式存儲，例如 |
當綁定到Map屬性，若是key包含除小寫字母-數字字符或-，您須要使用括號表示法，以便保留原始值。若是密鑰未被[]，任何不是alpha-數字或-都被移走了。例如，考慮將下列屬性綁定到Map:
acme:
map:
"[/key1]": value1
"[/key2]": value2
/key3: value3
上面的屬性將綁定到Map帶着/key1, /key2和key3就像地圖上的鑰匙。
24.7.3合併複雜類型
當在多個地方配置列表時，能夠經過替換整個列表來重寫。
例如，假設MyPojo對象name和description屬性null默認狀況下。下面的示例公開MyPojo對象AcmeProperties:
@ConfigurationProperties("acme")
public class AcmeProperties {
private final List<MyPojo> list = new ArrayList<>();
public List<MyPojo> getList() {
return this.list;
}
}
考慮如下配置：
acme:
list:
- name: my name
description: my description
---
spring:
profiles: dev
acme:
list:
- name: my another name
若是dev側寫不活躍，AcmeProperties.list包含一個MyPojo條目，如先前定義的。若是dev可是，已啓用配置文件。list 仍然只包含一個條目(名稱爲my another name以及對.的描述null)這種配置不加一秒鐘MyPojo實例添加到列表中，而且它不合並項。
當List在多個配置文件中指定，則使用優先級最高的配置文件(僅使用該配置文件)。考慮如下示例：
acme:
list:
- name: my name
description: my description
- name: another name
description: another description
---
spring:
profiles: dev
acme:
list:
- name: my another name
在前面的示例中，若是dev側寫很活躍，AcmeProperties.list含一 MyPojo條目(名稱爲my another name以及對.的描述null)對於YAML，逗號分隔的列表和YAML列表均可以用於徹底覆蓋列表的內容。
爲Map屬性，則能夠綁定從多個源提取的屬性值。可是，對於多個源中的相同屬性，則使用具備最高優先級的屬性。下面的示例公開Map<String, MyPojo>從…AcmeProperties:
@ConfigurationProperties("acme")
public class AcmeProperties {
private final Map<String, MyPojo> map = new HashMap<>();
public Map<String, MyPojo> getMap() {
return this.map;
}
}
考慮如下配置：
acme:
map:
key1:
name: my name 1
description: my description 1
---
spring:
profiles: dev
acme:
map:
key1:
name: dev name 1
key2:
name: dev name 2
description: dev description 2
若是dev側寫不活躍，AcmeProperties.map包含一個帶鍵的條目key1(名稱爲my name 1以及對.的描述my description 1)若是dev可是，已啓用配置文件，map包含兩個帶鍵的條目。key1(名稱爲dev name 1以及對.的描述my description 1)和key2(名稱爲dev name 2以及對.的描述dev description 2).
|
| 前面的合併規則適用於來自全部屬性源的屬性，而不只僅是YAML文件。 |
24.7.4屬性轉換
當外部應用程序屬性綁定到@ConfigurationProperties豆子若是須要自定義類型轉換，則能夠提供ConversionServicebean(有一個名爲conversionService)或自定義屬性編輯器(經過CustomEditorConfigurer(豆子)或習慣Converters(將bean定義註釋爲@ConfigurationPropertiesBinding).
|
| 因爲此bean是在應用程序生命週期早期被請求的，請確保限制您 |
轉換持續時間
SpringBoot爲表示持續時間提供了專門的支持。若是您暴露了java.time.Duration屬性時，應用程序屬性中的下列格式可用：
- 常客
long表示(使用毫秒做爲默認單位，除非@DurationUnit已指定) - 標準ISO-8601格式被
java.util.Duration - 一種更易讀的格式，其中值和單元耦合在一塊兒(例如，
10s表示10秒)
考慮如下示例：
@ConfigurationProperties("app.system")
public class AppSystemProperties {
@DurationUnit(ChronoUnit.SECONDS)
private Duration sessionTimeout = Duration.ofSeconds(30);
private Duration readTimeout = Duration.ofMillis(1000);
public Duration getSessionTimeout() {
return this.sessionTimeout;
}
public void setSessionTimeout(Duration sessionTimeout) {
this.sessionTimeout = sessionTimeout;
}
public Duration getReadTimeout() {
return this.readTimeout;
}
public void setReadTimeout(Duration readTimeout) {
this.readTimeout = readTimeout;
}
}
若要指定30秒的會話超時，30, PT30S和30s都是等價物。能夠下列任何形式指定500 ms的讀取超時：500, PT0.5S和500ms.
您還能夠使用任何受支持的單元。它們是：
ns納秒us微秒ms毫秒s幾秒鐘m幾分鐘h幾個小時d好幾天
默認單位爲毫秒，能夠使用@DurationUnit如上面的示例所示。
|
| 若是您正在從簡單地使用 |
轉換數據大小
Spring Framework有一個DataSize值類型，容許以字節表示大小。若是您暴露了DataSize屬性時，應用程序屬性中的下列格式可用：
- 常客
long表示(使用字節做爲默認單位，除非@DataSizeUnit已指定) - 一種更易讀的格式，其中值和單元耦合在一塊兒(例如，
10MB表示10兆字節)
考慮如下示例：
@ConfigurationProperties("app.io")
public class AppIoProperties {
@DataSizeUnit(DataUnit.MEGABYTES)
private DataSize bufferSize = DataSize.ofMegabytes(2);
private DataSize sizeThreshold = DataSize.ofBytes(512);
public DataSize getBufferSize() {
return this.bufferSize;
}
public void setBufferSize(DataSize bufferSize) {
this.bufferSize = bufferSize;
}
public DataSize getSizeThreshold() {
return this.sizeThreshold;
}
public void setSizeThreshold(DataSize sizeThreshold) {
this.sizeThreshold = sizeThreshold;
}
}
若要指定10兆字節的緩衝區大小，10和10MB都是等價物。大小閾值爲256字節，可指定爲256或256B.
您還能夠使用任何受支持的單元。它們是：
B表示字節KB千字節MB兆字節GB千兆字節TB爲兆字節
默認單位是字節，能夠使用@DataSizeUnit如上面的示例所示。
|
| 若是您正在從簡單地使用 |
24.7.5@ConfigurationProperties驗證
Spring Boot試圖驗證@ConfigurationProperties類，只要它們被Spring註釋@Validated註釋您能夠使用jsr-303。javax.validation直接對配置類進行約束註釋。爲此，請確保類路徑上有符合JSR-303的實現，而後將約束註釋添加到字段中，以下面的示例所示：
@ConfigurationProperties(prefix="acme")
@Validated
public class AcmeProperties {
@NotNull
private InetAddress remoteAddress;
// ... getters and setters
}
|
| 還能夠經過註釋 |
雖然嵌套屬性在綁定時也將獲得驗證，但最好的作法是將關聯字段註釋爲@Valid。這確保即便沒有找到嵌套屬性也會觸發驗證。下面的示例構建在前面的AcmeProperties例子：
@ConfigurationProperties(prefix="acme")
@Validated
public class AcmeProperties {
@NotNull
private InetAddress remoteAddress;
@Valid
private final Security security = new Security();
// ... getters and setters
public static class Security {
@NotEmpty
public String username;
// ... getters and setters
}
}
還能夠添加自定義SpringValidator經過建立一個名爲configurationPropertiesValidator。這，這個，那，那個@Bean方法應聲明static。配置屬性驗證器是在應用程序生命週期的早期建立的，並聲明@Bean方法能夠建立bean，而沒必要實例化@Configuration班級，等級這樣作能夠避免任何可能因早期實例化而引發的問題。有一個屬性驗證樣本這說明了如何設置。
|
| 這，這個，那，那個 |
24.7.6@ConfigurationProperties與@Value
這，這個，那，那個@Value註釋是一個核心容器特性，它不提供與類型安全配置屬性相同的特性。下表總結了@ConfigurationProperties和@Value:
| 特徵 | @ConfigurationProperties |
@Value |
|---|---|---|
| 是 |
否 |
|
| 是 |
否 |
|
|
|
否 |
是 |
若是您爲您本身的組件定義了一組配置鍵，咱們建議您將它們分組到帶註釋的POJO中。@ConfigurationProperties。你也應該知道，由於@Value不支持輕鬆綁定，若是須要使用環境變量提供值，則不是很好的選擇。
最後，當您能夠編寫一個SpEL表達在@Value，這些表達式不是從應用程序屬性文件.
25.剖面圖
SpringProfiles提供了一種隔離應用程序配置部分並使其僅在特定環境中可用的方法。任何@Component或@Configuration能夠用@Profile若要限制加載時間，請參見如下示例：
@Configuration
@Profile("production")
public class ProductionConfiguration {
// ...
}
您能夠使用spring.profiles.active Environment屬性指定哪些配置文件是活動的。您能夠使用本章前面描述的任何方式指定該屬性。例如，您能夠將它包含在您的application.properties，如如下示例所示：
spring.profiles.active=dev,hsqldb
還能夠使用如下開關在命令行中指定它：--spring.profiles.active=dev,hsqldb.
25.1添加活動概要文件
這，這個，那，那個spring.profiles.active屬性遵循與其餘屬性相同的排序規則：PropertySource贏了。這意味着您能夠在application.properties而後取代經過使用命令行開關。
有時，具備特定於配置文件的屬性是有用的加而不是替換它們。這，這個，那，那個spring.profiles.include屬性可用於無條件地添加活動配置文件。這，這個，那，那個SpringApplication入口點還具備一個JavaAPI，用於設置其餘配置文件(即，在由spring.profiles.active財產)。見setAdditionalProfiles()方法Spring應用.
例如，當使用開關運行具備下列屬性的應用程序時，--spring.profiles.active=prod，proddb和prodmq還啓動了配置文件：
--- my.property: fromyamlfile --- spring.profiles: prod spring.profiles.include: - proddb - prodmq
|
| 記住 |
25.2以編程方式設置概要文件
能夠經過如下方式以編程方式設置活動配置文件：SpringApplication.setAdditionalProfiles(…)在應用程序運行以前。還能夠使用Spring的ConfigurableEnvironment接口。
25.3配置文件-特定配置文件
特定於配置文件的兩種變體application.properties(或application.yml)和經過@ConfigurationProperties被視爲文件並加載。見「第24.4節，「配置文件特有的屬性」「詳細狀況。
26.測井
彈簧啓動共用測井對於全部內部日誌記錄，但保持基礎日誌實現處於打開狀態。提供了默認配置。Java Util測井, Log4J2，和Logback。在每種狀況下，記錄器都預先配置爲使用控制檯輸出和可選文件輸出。
默認狀況下，若是使用「starters」，則使用Logback進行日誌記錄。還包括適當的Logback路由，以確保使用JavaUtil日誌記錄、CommonLogging、Log4J或SLF4J的依賴庫都正確工做。
|
| Java有不少日誌記錄框架可用。若是上面的列表看起來很混亂，不要擔憂。一般，您不須要更改日誌記錄依賴項，SpringBoot默認設置也很好。 |
26.1日誌格式
SpringBoot的默認日誌輸出相似於如下示例：
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: [/*]
輸出的項目以下：
- 日期和時間：毫秒精度，易於排序。
- 日誌級別：
ERROR,WARN,INFO,DEBUG，或TRACE. - 進程ID
- A
---分隔符以區分實際日誌消息的開始。 - 線程名稱：括在方括號中(能夠截斷控制檯輸出)。
- 記錄器名稱：這一般是源類名(一般縮寫)。
- 日誌信息。
|
| Logback沒有 |
26.2控制檯輸出
默認日誌配置在寫入消息時將消息回顯到控制檯。默認狀況下，ERROR-水平，WARN-級別，和INFO-記錄級別消息。還能夠啓用「調試」模式，方法是將應用程序啓動爲--debug旗子。
$ java -jar myapp.jar --debug
|
| 您還能夠指定 |
啓用調試模式後，將選擇核心記錄器(嵌入式容器、Hibernate和SpringBoot)以輸出更多信息。啓用調試模式不將應用程序配置爲將全部消息記錄爲DEBUG水平。
或者，您能夠啓用「跟蹤」模式，方法是將應用程序啓動爲--trace旗(或)trace=true在你的application.properties)這樣作能夠爲選擇的核心記錄器(嵌入式容器、Hibernate模式生成和整個Spring組合)啓用跟蹤日誌記錄。
26.2.1彩色編碼輸出
若是您的終端支持ANSI，則使用顏色輸出來提升可讀性。你能夠spring.output.ansi.enabled轉到支撐值以覆蓋自動檢測。
顏色編碼是經過使用%clr轉換詞。最簡單的形式是，轉換器根據日誌級別對輸出進行着色，以下面的示例所示：
%clr(%5p)
下表描述日誌級別到顏色的映射：
| 水平 | 顏色 |
|---|---|
|
|
紅色 |
|
|
紅色 |
|
|
黃色 |
|
|
綠色 |
|
|
綠色 |
|
|
綠色 |
或者，您能夠經過提供顏色或樣式做爲轉換的選項來指定應該使用的顏色或樣式。例如，要使文本變黃，請使用如下設置：
%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){yellow}
支持下列顏色和樣式：
bluecyanfaintgreenmagentaredyellow
26.3文件輸出
默認狀況下，SpringBoot只記錄到控制檯，不寫入日誌文件。若是要在控制檯輸出以外寫入日誌文件，則須要設置logging.file或logging.path屬性(例如，在application.properties).
下表顯示了logging.*屬性能夠一塊兒使用：
表26.1.測井特性
logging.file |
logging.path |
例 | 描述 |
|---|---|---|---|
| (無) |
(無) |
控制檯只記錄。 |
|
| 特定文件 |
(無) |
|
寫入指定的日誌文件。名稱能夠是確切的位置，也能夠是相對於當前目錄的位置。 |
| (無) |
特定目錄 |
|
寫字 |
日誌文件在達到10 MB時旋轉，與控制檯輸出同樣，ERROR-水平，WARN-級別，和INFO-默認狀況下記錄級別消息。大小限制能夠使用logging.file.max-size財產。之前旋轉的文件被無限期存檔，除非logging.file.max-history屬性已設置。
|
| 日誌系統是在應用程序生命週期的早期初始化的。所以，在經過 |
|
| 日誌屬性獨立於實際的日誌基礎結構。所以，特定的配置鍵(如 |
26.4原木水平
全部受支持的日誌系統均可以在Spring中設置記錄器級別Environment(例如，在application.properties)經過使用logging.level.<logger-name>=<level>哪裏level是跟蹤、調試、信息、警告、錯誤、致命或關閉之一。這，這個，那，那個root能夠經過如下方式配置記錄器：logging.level.root.
下面的示例顯示了application.properties:
logging.level.root=WARN logging.level.org.springframework.web=DEBUG logging.level.org.hibernate=ERROR
26.5原木組
可以將相關的記錄器組合在一塊兒，以便可以同時配置它們，這一般是有用的。例如，您可能一般會更改日誌記錄級別。全Tomcat相關的記錄器，但您不能輕鬆地記住頂級軟件包。
爲此，SpringBoot容許您在Spring中定義日誌組Environment。例如，經過將「tomcat」組添加到application.properties:
logging.group.tomcat=org.apache.catalina, org.apache.coyote, org.apache.tomcat
定義完後，能夠用一行更改組中全部記錄器的級別：
logging.level.tomcat=TRACE
SpringBoot包括下列預約義的日誌組，能夠開箱即用：
| 名字，姓名 | 伐木工 |
|---|---|
| 萬維網 |
|
| SQL |
|
26.6自定義日誌配置
能夠經過在類路徑中包含適當的庫來激活各類日誌系統，並能夠經過在類路徑根目錄中或在下面的Spring指定的位置提供適當的配置文件來進一步定製這些日誌系統。Environment財產：logging.config.
能夠強制SpringBoot使用特定的日誌系統，方法是使用org.springframework.boot.logging.LoggingSystem系統屬性值應該是LoggingSystem執行。您還能夠徹底禁用SpringBoot的日誌配置，方法是使用none.
|
| 由於日誌記錄是初始化的之前這，這個，那，那個 |
根據日誌記錄系統的不一樣，將加載如下文件：
| 測井系統 | 定製化 |
|---|---|
| Logback |
|
| Log4j2 |
|
| JDK(Java Util日誌記錄) |
|
|
| 若是可能，咱們建議您使用 |
|
| JavaUtil日誌記錄中存在已知的類加載問題，在從「可執行JAR」運行時會致使問題。若是可能的話，咱們建議您在從「可執行的JAR」運行時避免使用它。 |
爲了幫助定製，其餘一些屬性將從Spring中傳輸Environment到系統屬性，以下表所述：
| 春季環境 | 系統性質 | 評論意見 |
|---|---|---|
|
|
|
記錄異常時使用的轉換字。 |
|
|
|
若是已定義，則在默認日誌配置中使用。 |
|
|
|
最大日誌文件大小(若是啓用LOG_FILE)。(僅支持默認的Logback設置。) |
|
|
|
要保留的存檔日誌文件的最大數量(若是啓用log_file)。(僅支持默認的Logback設置。) |
|
|
|
若是已定義，則在默認日誌配置中使用。 |
|
|
|
要在控制檯上使用的日誌模式(Stdout)。(僅支持默認的Logback設置。) |
|
|
|
日誌日期格式的附錄模式。(僅支持默認的Logback設置。) |
|
|
|
要在文件中使用的日誌模式(若是 |
|
|
|
在呈現日誌級別時使用的格式(默認值) |
|
|
|
當前進程ID(若是可能的話會被發現，若是尚未定義爲OS環境變量的話)。 |
全部受支持的日誌記錄系統在解析其配置文件時均可以參考系統屬性。中的默認配置spring-boot.jar例如：
|
| 若是要在日誌記錄屬性中使用佔位符，則應使用Spring Boot語法而不是底層框架的語法。特別要注意的是，若是您使用Logback，您應該使用 |
|
| 您能夠將mdc和其餘臨時內容添加到日誌行中，只需重寫 2015-09-30 12:30:04.031 user:someone INFO 22174 --- [ nio-8080-exec-0] demo.Controller Handling authenticated request |
26.7 Logback擴展
SpringBoot包括一些能夠幫助高級配置的Logback擴展。您能夠在logback-spring.xml配置文件
|
| 由於標準 |
|
| 這些擴展不能與Logback的組態掃描。若是嘗試這樣作，對配置文件進行更改將致使一個相似於正在記錄的如下內容之一的錯誤： |
ERROR in ch.qos.logback.core.joran.spi.Interpreter@4:71 - no applicable action for [springProperty], current ElementPath is [[configuration][springProperty]] ERROR in ch.qos.logback.core.joran.spi.Interpreter@4:71 - no applicable action for [springProfile], current ElementPath is [[configuration][springProfile]]
26.7.1配置文件-特定配置
這，這個，那，那個<springProfile>標記容許您根據活動的Spring配置文件選擇性地包含或排除配置部分。配置文件中的任何位置都支持配置文件節。<configuration>元素。使用name屬性指定哪一個配置文件接受配置。這，這個，那，那個<springProfile>標記能夠包含一個簡單的配置文件名稱(例如staging)或配置文件表達式。配置文件表達式容許表示更復雜的配置文件邏輯，例如production & (eu-central | eu-west)。檢查參考指南更多細節。下面的清單顯示了三個示例配置文件：
<springProfile name="staging"> <!-- configuration to be enabled when the "staging" profile is active --> </springProfile> <springProfile name="dev | staging"> <!-- configuration to be enabled when the "dev" or "staging" profiles are active --> </springProfile> <springProfile name="!production"> <!-- configuration to be enabled when the "production" profile is not active --> </springProfile>
26.7.2環境特性
這，這個，那，那個<springProperty>標記容許您公開Spring中的屬性Environment在Logback中使用。若是您想從application.properties在您的Logback配置中的文件。標記的工做方式相似於Logback的標準<property>標籤。可是，與其指定直接value，您能夠指定source(從Environment)若是您須要將該財產存儲在local範圍內，能夠使用scope屬性。若是須要回退值(若是屬性未在Environment)，您能夠使用defaultValue屬性。下面的示例演示如何公開在Logback中使用的屬性：
<springProperty scope="context" name="fluentHost" source="myapp.fluentd.host"
defaultValue="localhost"/>
<appender name="FLUENT" class="ch.qos.logback.more.appenders.DataFluentAppender">
<remoteHost>${fluentHost}</remoteHost>
...
</appender>
|
| 這，這個，那，那個 |
27.開發Web應用程序
SpringBoot很是適合Web應用程序的開發。您能夠經過使用嵌入式Tomcat、Jetty、Under拖車或Netty建立一個自包含的HTTP服務器。大多數web應用程序使用spring-boot-starter-web模塊快速啓動和運行。還能夠選擇使用spring-boot-starter-webflux模塊。
若是你尚未開發一個SpringBootWeb應用程序，你能夠按照「HelloWorld！」實例中的開始部分。
27.1「SpringWebMVC框架」
這，這個，那，那個SpringWebMVC框架(一般簡稱爲「SpringMVC」)是一個豐富的「模型視圖控制器」Web框架。Springmvc容許您建立特殊的@Controller或@RestController用來處理傳入的HTTP請求的bean。方法將控制器中的方法映射到HTTP。@RequestMapping註釋。
下面的代碼顯示了一個典型的@RestController它提供JSON數據：
@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) {
// ...
}
}
SpringMVC是核心Spring框架的一部分，詳細信息可在參考文獻。還有幾個指南介紹了SpringMVCspring.io/guides.
27.1.1 SpringMVC自動配置
SpringBoot爲SpringMVC提供了自動配置，它適用於大多數應用程序。
自動配置在Spring的默認值之上添加了如下特性：
- 歸入
ContentNegotiatingViewResolver和BeanNameViewResolver豆子 - 支持服務靜態資源，包括對WebJars的支持(涵蓋在本文檔的後面)).
- 自動登記
Converter,GenericConverter，和Formatter豆子 - 支持
HttpMessageConverters(包括在內)在本文檔的後面). - 自動登記
MessageCodesResolver(包括在內)在本文檔的後面). - 靜態
index.html支持。 - 習俗
Favicon支助(包括在內)在本文檔的後面). - 自動使用
ConfigurableWebBindingInitializer豆(覆蓋)在本文檔的後面).
若是您想保持SpringBootMVC特性，而且但願添加額外的MVC配置(攔截器、格式化程序、視圖控制器和其餘特性)，您能夠添加本身的@Configuration類型類WebMvcConfigurer但無 @EnableWebMvc。若是您但願提供RequestMappingHandlerMapping, RequestMappingHandlerAdapter，或ExceptionHandlerExceptionResolver，您能夠聲明WebMvcRegistrationsAdapter實例來提供這些組件。
若是您想徹底控制SpringMVC，能夠添加您本身的@Configuration帶註釋@EnableWebMvc.
27.1.2 HttpMessage轉換器
SpringMVC使用HttpMessageConverter接口來轉換HTTP請求和響應。明智之舉也包括在內。例如，對象能夠自動轉換爲JSON(經過使用Jackson庫)或XML(若是可用的話使用Jackson XML擴展，或者在Jackson XML擴展不可用時使用JAXB)。默認狀況下，字符串編碼爲UTF-8.
若是須要添加或自定義轉換器，能夠使用SpringBoot的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被添加到轉換器列表中。您也能夠一樣的方式覆蓋默認轉換器。
27.1.3自定義JSON序列化程序和反序列化器
若是使用Jackson序列化和反序列化JSON數據，則可能須要編寫本身的JsonSerializer和JsonDeserializer上課。自定義序列化程序一般是經過模塊向Jackson註冊，可是SpringBoot提供了另外一種選擇@JsonComponent註釋，使直接註冊Springbean更加容易。
您能夠使用@JsonComponent直接註釋JsonSerializer或JsonDeserializer實現。還能夠在包含序列化器/反序列化器的類中做爲內部類使用它，以下面的示例所示：
import java.io.*;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import org.springframework.boot.jackson.*;
@JsonComponent
public class Example {
public static class Serializer extends JsonSerializer<SomeObject> {
// ...
}
public static class Deserializer extends JsonDeserializer<SomeObject> {
// ...
}
}
全@JsonComponent豆類ApplicationContext都會自動註冊到傑克遜那裏。由於@JsonComponent元註釋@Component，適用一般的組件掃描規則。
Spring Boot還提供JsonObjectSerializer和JsonObjectDeserializer基類，這些基類在序列化對象時爲標準Jackson版本提供了有用的替代方案。看見JsonObjectSerializer和JsonObjectDeserializer在Javadoc中得到詳細信息。
27.1.4消息代碼解析器
SpringMVC有一種用於生成錯誤代碼的策略，用於從綁定錯誤中呈現錯誤消息：MessageCodesResolver。若是您設置spring.mvc.message-codes-resolver.format財產PREFIX_ERROR_CODE或POSTFIX_ERROR_CODE，Spring Boot爲您建立一個DefaultMessageCodesResolver.Format).
27.1.5靜態含量
默認狀況下，SpringBoot從一個名爲/static(或/public或/resources或/META-INF/resources)在類路徑中或從ServletContext。它使用ResourceHttpRequestHandler，這樣您就能夠經過添加本身的WebMvcConfigurer和凌駕於addResourceHandlers方法。
在獨立的web應用程序中，容器中的默認servlet也被啓用，並充當後盾，從ServletContext若是春天決定不處理它。大多數狀況下，這種狀況不會發生(除非修改默認的MVC配置)，由於Spring老是能夠經過DispatcherServlet.
默認狀況下，資源被映射到/**，可是您能夠經過spring.mvc.static-path-pattern財產。例如，將全部資源從新定位到/resources/**可實現如下目標：
spring.mvc.static-path-pattern=/resources/**
還能夠使用spring.resources.static-locations屬性(將默認值替換爲目錄位置列表)。根servlet上下文路徑，"/"自動添加爲一個位置。
除了前面提到的「標準」靜態資源位置以外，還爲WebJars內容。中具備路徑的任何資源。/webjars/**若是JAR文件以Webjars格式打包，則從JAR文件中提供服務。
|
| 不要使用 |
SpringBoot還支持SpringMVC提供的高級資源處理特性，容許用例，例如破壞緩存的靜態資源或Webjars的版本無關URL。
若要將版本無關的URL用於Webjars，請添加webjars-locator-core依賴。而後聲明你的Webjar。以jQuery爲例，添加"/webjars/jquery/jquery.min.js"結果"/webjars/jquery/x.y.z/jquery.min.js"。哪裏x.y.z是Webjar版本。
|
| 若是使用JBoss，則須要聲明 |
要使用緩存破壞，如下配置爲全部靜態資源配置緩存破壞解決方案，有效地添加內容散列，如<link href="/css/spring-2a2d595e6ed9a0b24f027f2b63b134d6.css"/>，以URL表示：
spring.resources.chain.strategy.content.enabled=true spring.resources.chain.strategy.content.paths=/**
|
| 到資源的連接在運行時用模板重寫，這要感謝 |
例如，當用JavaScript模塊加載器動態加載資源時，重命名文件不是一個選項。這就是爲何其餘戰略也獲得支持並能夠結合在一塊兒的緣由。「固定」策略在不更改文件名的狀況下在URL中添加靜態版本字符串，以下面的示例所示：
spring.resources.chain.strategy.content.enabled=true spring.resources.chain.strategy.content.paths=/** spring.resources.chain.strategy.fixed.enabled=true spring.resources.chain.strategy.fixed.paths=/js/lib/ spring.resources.chain.strategy.fixed.version=v12
使用此配置，JavaScript模塊位於"/js/lib/"使用固定版本控制策略("/v12/js/lib/mymodule.js")，而其餘資源仍然使用內容1(<link href="/css/spring-2a2d595e6ed9a0b24f027f2b63b134d6.css"/>).
看見ResourceProperties得到更多支持的選項。
|
27.1.6歡迎頁
SpringBoot支持靜態和模板歡迎頁面。它首先尋找一個index.html文件在配置的靜態內容位置中。若是找不到一個，它就會查找一個index模板。若是找到其中之一，則自動將其用做應用程序的歡迎頁。
27.1.7海關偏袒
春靴favicon.ico在配置的靜態內容位置和類路徑的根中(按該順序)。若是存在這樣的文件，則自動將其用做應用程序的首選項。
27.1.8路徑匹配和內容協商
SpringMVC能夠經過查看請求路徑並將其匹配到應用程序中定義的映射來將傳入的HTTP請求映射處處理程序(例如，@GetMapping控制器方法的註釋)。
SpringBoot默認選擇禁用後綴模式匹配，這意味着請求相似"GET /projects/spring-boot.json"將沒法與@GetMapping("/projects/spring-boot")映射。這被認爲是SpringMVC應用程序的最佳實踐。這個特性過去主要用於HTTP客戶機，它沒有發送正確的「接受」請求頭；咱們須要確保向客戶端發送正確的ContentType。現在，內容協商變得更加可靠。
還有其餘處理HTTP客戶端的方法，這些方法不一致地發送適當的「接受」請求標頭。不使用後綴匹配，咱們能夠使用查詢參數來確保請求相似"GET /projects/spring-boot?format=json"將被映射到@GetMapping("/projects/spring-boot"):
spring.mvc.contentnegotiation.favor-parameter=true # We can change the parameter name, which is "format" by default: # spring.mvc.contentnegotiation.parameter-name=myparam # We can also register additional file extensions/media types with: spring.mvc.contentnegotiation.media-types.markdown=text/markdown
若是您理解這些警告，而且仍然但願您的應用程序使用後綴模式匹配，則須要進行如下配置：
spring.mvc.contentnegotiation.favor-path-extension=true # You can also restrict that feature to known extensions only # spring.mvc.pathmatch.use-registered-suffix-pattern=true # We can also register additional file extensions/media types with: # spring.mvc.contentnegotiation.media-types.adoc=text/asciidoc
27.1.9 ConfigurableWebBindingInitiators
SpringMVC使用WebBindingInitializer若要初始化WebDataBinder特別的請求。若是你本身創造ConfigurableWebBindingInitializer @Bean，SpringBoot自動配置SpringMVC來使用它。
27.1.10模板引擎
除了RESTWeb服務以外，您還能夠使用SpringMVC來提供動態HTML內容。SpringMVC支持多種模板技術，包括Thymeleaf、FreeMarker和JSP。此外，許多其餘模板引擎包括本身的SpringMVC集成。
SpringBoot包括對下列模板引擎的自動配置支持：
|
| 若是可能，應該避免JSP。有幾個已知限制當將它們與嵌入式servlet容器一塊兒使用時。 |
當您使用默認配置的模板引擎之一時，您的模板將自動從src/main/resources/templates.
|
| 根據運行應用程序的方式，IntelliJIDEA對類路徑的排序不一樣。經過IDE的主方法在IDE中運行應用程序，與使用Maven或Gradle或從打包JAR運行應用程序時相比，會產生不一樣的順序。這可能致使SpringBoot沒法找到類路徑上的模板。若是有此問題，能夠從新排序IDE中的類路徑，以便首先放置模塊的類和資源。或者，您能夠將模板前綴配置爲搜索 |
27.1.11錯誤處理
默認狀況下，SpringBoot提供一個/error映射，以合理的方式處理全部錯誤，並將其註冊爲servlet容器中的「全局」錯誤頁。對於機器客戶端，它生成一個JSON響應，其中包含錯誤、HTTP狀態和異常消息的詳細信息。對於瀏覽器客戶端，有一個「Whitelabel」錯誤視圖，它以HTML格式呈現相同的數據(要自定義它，添加一個View決心error)若要徹底替換默認行爲，能夠實現ErrorController並註冊該類型的bean定義或添加類型的bean。ErrorAttributes使用現有機制但替換內容。
|
| 這，這個，那，那個 |
還能夠定義帶註釋的類。@ControllerAdvice自定義JSON文檔以返回特定控制器和/或異常類型，以下面的示例所示：
@ControllerAdvice(basePackageClasses = AcmeController.class)
public class AcmeControllerAdvice extends ResponseEntityExceptionHandler {
@ExceptionHandler(YourException.class)
@ResponseBody
ResponseEntity<?> handleControllerException(HttpServletRequest request, Throwable ex) {
HttpStatus status = getStatus(request);
return new ResponseEntity<>(new CustomErrorType(status.value(), ex.getMessage()), status);
}
private HttpStatus getStatus(HttpServletRequest request) {
Integer statusCode = (Integer) request.getAttribute("javax.servlet.error.status_code");
if (statusCode == null) {
return HttpStatus.INTERNAL_SERVER_ERROR;
}
return HttpStatus.valueOf(statusCode);
}
}
在前面的示例中，若是YourException中定義的控制器引起AcmeController的JSON表示形式。CustomErrorType使用POJO代替ErrorAttributes表明。
自定義錯誤頁
若是要顯示給定狀態代碼的自定義HTML錯誤頁，能夠將文件添加到/error文件夾。錯誤頁能夠是靜態HTML(即在任何靜態資源文件夾下添加)，也能夠使用模板構建。文件的名稱應該是確切的狀態代碼或序列掩碼。
例如，要映射404對於靜態HTML文件，文件夾結構以下：
src/
+- main/
+- java/
| + <source code>
+- resources/
+- public/
+- error/
| +- 404.html
+- <other public assets>
映射全部5xx使用FreeMarker模板出錯，文件夾結構以下所示：
src/
+- main/
+- java/
| + <source code>
+- resources/
+- templates/
+- error/
| +- 5xx.ftl
+- <other templates>
對於更復雜的映射，還能夠添加實現ErrorViewResolver接口，如如下示例所示：
public class MyErrorViewResolver implements ErrorViewResolver {
@Override
public ModelAndView resolveErrorView(HttpServletRequest request,
HttpStatus status, Map<String, Object> model) {
// Use the request or status to optionally return a ModelAndView
return ...
}
}
您還能夠使用常規的SpringMVC功能，如@ExceptionHandler方法和@ControllerAdvice。這，這個，那，那個ErrorController而後提取任何未處理的異常。
在SpringMVC以外映射錯誤頁面
對於不使用SpringMVC的應用程序，能夠使用ErrorPageRegistrar接口直接註冊ErrorPages。此抽象直接用於底層嵌入式servlet容器，即便您沒有SpringMVC，也能夠工做。DispatcherServlet.
@Bean
public ErrorPageRegistrar errorPageRegistrar(){
return new MyErrorPageRegistrar();
}
// ...
private static class MyErrorPageRegistrar implements ErrorPageRegistrar {
@Override
public void registerErrorPages(ErrorPageRegistry registry) {
registry.addErrorPages(new ErrorPage(HttpStatus.BAD_REQUEST, "/400"));
}
}
|
| 若是您註冊了 |
@Bean
public FilterRegistrationBean myFilter() {
FilterRegistrationBean registration = new FilterRegistrationBean();
registration.setFilter(new MyFilter());
...
registration.setDispatcherTypes(EnumSet.allOf(DispatcherType.class));
return registration;
}
注意，默認的FilterRegistrationBean不包括ERROR調度員類型。
警告：當部署到servlet容器時，SpringBoot使用其錯誤頁面篩選器將具備錯誤狀態的請求轉發到相應的錯誤頁。只有在還沒有提交響應的狀況下，才能將請求轉發到正確的錯誤頁。默認狀況下，WebSphereApplicationServer8.0及更高版本在成功完成servlet的服務方法後提交響應。應該經過設置com.ibm.ws.webcontainer.invokeFlushAfterService到false.
27.1.12彈簧
若是您開發了一個使用超媒體的RESTfulAPI，SpringBoot爲SpringHATEOA提供了自動配置，它能夠很好地應用於大多數應用程序。自動配置取代了使用@EnableHypermediaSupport並註冊多個bean以方便構建基於超媒體的應用程序，包括LinkDiscoverers(用於客戶端支持)和ObjectMapper配置爲正確地將響應編組到所需的表示形式。這，這個，那，那個ObjectMapper是經過設置spring.jackson.*屬性，或者，若是存在，則由Jackson2ObjectMapperBuilder豆子
您能夠經過使用@EnableHypermediaSupport。注意，這樣作將禁用ObjectMapper前面描述的自定義。
27.1.13 CORS支持
跨源資源共享(CORS)是W3C規範由大多數瀏覽器這容許您以靈活的方式指定哪些類型的跨域請求是被受權的，而不是使用一些不太安全和功能較弱的方法，例如iframe或JSONP。
截至4.2版，SpringMVC支持CORS。使用控制器方法CORS配置帶着@CrossOriginSpringBoot應用程序中的註釋不須要任何特定的配置。全局CORS配置能夠經過註冊WebMvcConfigurer帶有自定義的beanaddCorsMappings(CorsRegistry)方法，如如下示例所示：
@Configuration
public class MyConfiguration {
@Bean
public WebMvcConfigurer corsConfigurer() {
return new WebMvcConfigurer() {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/api/**");
}
};
}
}
27.2「SpringWebFlux框架」
SpringWebFlux是SpringFramework5.0中引入的新的反應性Web框架。與SpringMVC不一樣，它不須要ServletAPI，徹底異步和非阻塞，並實現了反應流規格經過反應堆工程.
SpringWebFlux有兩種風格：基於功能的和基於註釋的。基於註釋的註釋很是接近SpringMVC模型，以下面的示例所示：
@RestController
@RequestMapping("/users")
public class MyRestController {
@GetMapping("/{user}")
public Mono<User> getUser(@PathVariable Long user) {
// ...
}
@GetMapping("/{user}/customers")
public Flux<Customer> getUserCustomers(@PathVariable Long user) {
// ...
}
@DeleteMapping("/{user}")
public Mono<User> deleteUser(@PathVariable Long user) {
// ...
}
}
函數變體「WebFlim.fn」將路由配置與請求的實際處理分離開來，以下面的示例所示：
@Configuration
public class RoutingConfiguration {
@Bean
public RouterFunction<ServerResponse> monoRouterFunction(UserHandler userHandler) {
return route(GET("/{user}").and(accept(APPLICATION_JSON)), userHandler::getUser)
.andRoute(GET("/{user}/customers").and(accept(APPLICATION_JSON)), userHandler::getUserCustomers)
.andRoute(DELETE("/{user}").and(accept(APPLICATION_JSON)), userHandler::deleteUser);
}
}
@Component
public class UserHandler {
public Mono<ServerResponse> getUser(ServerRequest request) {
// ...
}
public Mono<ServerResponse> getUserCustomers(ServerRequest request) {
// ...
}
public Mono<ServerResponse> deleteUser(ServerRequest request) {
// ...
}
}
WebFlux是Spring框架的一部分，詳細信息可在其參考文獻.
|
| 你能夠定義 |
要開始，添加spring-boot-starter-webflux模塊到您的應用程序。
|
| 加法 |
27.2.1 SpringWebFlux自動配置
SpringBoot爲SpringWebFlux提供了自動配置，它適用於大多數應用程序。
自動配置在Spring的默認值之上添加了如下特性：
若是您想保持SpringBootWebFlux特性，而且但願添加其餘功能WebFlux配置，您能夠添加本身的@Configuration類型類WebFluxConfigurer但無 @EnableWebFlux.
若是您想徹底控制SpringWebFlux，能夠添加您本身的@Configuration帶註釋@EnableWebFlux.
27.2.2帶有HttpMessageReader和HttpMessageWriters的HTTP編解碼器
SpringWebFlux使用HttpMessageReader和HttpMessageWriter接口來轉換HTTP請求和響應。它們被配置爲CodecConfigurer經過查看類路徑中可用的庫來實現合理的默認值。
Spring Boot使用CodecCustomizer實例。例如spring.jackson.*配置密鑰應用於Jackson編解碼器。
若是須要添加或自定義編解碼器，則能夠建立自定義CodecCustomizer組件，如如下示例所示：
import org.springframework.boot.web.codec.CodecCustomizer;
@Configuration
public class MyConfiguration {
@Bean
public CodecCustomizer myCodecCustomizer() {
return codecConfigurer -> {
// ...
}
}
}
你也能夠利用引導的自定義JSON序列化程序和反序列化器.
27.2.3靜態含量
默認狀況下，SpringBoot從一個名爲/static(或/public或/resources或/META-INF/resources)在類路徑中。它使用ResourceWebHandler從SpringWebFlux開始，這樣您就能夠經過添加本身的WebFlux來修改這種行爲了。WebFluxConfigurer和凌駕於addResourceHandlers方法。
默認狀況下，資源被映射到/**，可是您能夠經過設置spring.webflux.static-path-pattern財產。例如，將全部資源從新定位到/resources/**可實現如下目標：
spring.webflux.static-path-pattern=/resources/**
還能夠經過如下方法自定義靜態資源位置：spring.resources.static-locations。這樣作將用目錄位置列表替換默認值。若是這樣作，默認歡迎頁檢測切換到自定義位置。因此，若是有一個index.html在啓動時的任何位置，它都是應用程序的主頁。
除了前面列出的「標準」靜態資源位置以外，還爲WebJars內容。中具備路徑的任何資源。/webjars/**若是JAR文件以Webjars格式打包，則從JAR文件中提供服務。
|
| SpringWebFlux應用程序並不嚴格依賴ServletAPI，所以它們不能做爲WAR文件部署，也不使用 |
27.2.4模板引擎
除了RESTWeb服務以外，還能夠使用SpringWebFlux提供動態HTML內容。SpringWebFlux支持多種模板技術，包括Thymeleaf、FreeMarker和鬍子。
SpringBoot包括對下列模板引擎的自動配置支持：
當您使用默認配置的模板引擎之一時，您的模板將自動從src/main/resources/templates.
27.2.5錯誤處理
Spring Boot提供了一個WebExceptionHandler以合理的方式處理全部錯誤。它在處理順序中的位置就在WebFlux提供的處理程序以前，後者被認爲是最後一個。對於機器客戶端，它生成一個JSON響應，其中包含錯誤、HTTP狀態和異常消息的詳細信息。對於瀏覽器客戶端，有一個「Whitelabel」錯誤處理程序，它以HTML格式呈現相同的數據。您還能夠提供本身的HTML模板來顯示錯誤(請參閱下一節).
自定義此特性的第一步一般涉及使用現有機制，但替換或加強錯誤內容。爲此，能夠添加類型爲ErrorAttributes.
若要更改錯誤處理行爲，能夠實現ErrorWebExceptionHandler並註冊該類型的bean定義。由於WebExceptionHandler是至關低級的，SpringBoot也提供了方便。AbstractErrorWebExceptionHandler爲了讓您以WebFlux函數的方式處理錯誤，以下面的示例所示：
public class CustomErrorWebExceptionHandler extends AbstractErrorWebExceptionHandler {
// Define constructor here
@Override
protected RouterFunction<ServerResponse> getRoutingFunction(ErrorAttributes errorAttributes) {
return RouterFunctions
.route(aPredicate, aHandler)
.andRoute(anotherPredicate, anotherHandler);
}
}
要得到更完整的圖片，還能夠使用子類。DefaultErrorWebExceptionHandler直接覆蓋特定方法。
自定義錯誤頁
若是要顯示給定狀態代碼的自定義HTML錯誤頁，能夠將文件添加到/error文件夾。錯誤頁能夠是靜態HTML(即在任何靜態資源文件夾下添加)，也能夠是用模板構建的。文件的名稱應該是確切的狀態代碼或序列掩碼。
例如，要映射404對於靜態HTML文件，文件夾結構以下：
src/
+- main/
+- java/
| + <source code>
+- resources/
+- public/
+- error/
| +- 404.html
+- <other public assets>
映射全部5xx使用鬍子模板出錯，文件夾結構以下所示：
src/
+- main/
+- java/
| + <source code>
+- resources/
+- templates/
+- error/
| +- 5xx.mustache
+- <other templates>
27.2.6 Web過濾器
SpringWebFlux提供了一個WebFilter接口，可用於過濾HTTP請求-響應交換。WebFilter應用程序上下文中的bean將自動用於篩選每一個交換。
在篩選器的順序很重要的地方，它們能夠實現。Ordered或用@Order。SpringBoot自動配置能夠爲您配置Web過濾器。這樣作時，將使用下表中顯示的命令：
| Web過濾器 | 命令 |
|---|---|
|
|
|
|
|
|
|
|
|
27.3日航-斯普斯卡共和國和澤西島
若是您更喜歡用於REST端點的JAX-RS編程模型，則能夠使用可用的實現之一，而不是SpringMVC。澤西和ApacheCXF工做得很好。CXF要求您註冊它的Servlet或Filter做爲@Bean在您的應用程序上下文中。澤西有一些原生的Spring支持，因此咱們還在SpringBoot中爲它提供了自動配置支持，同時還提供了一個啓動器。
要開始使用澤西，包括spring-boot-starter-jersey做爲一種依賴，那麼你就須要一種依賴。@Bean類型ResourceConfig在其中註冊全部端點，如如下示例所示：
@Component
public class JerseyConfig extends ResourceConfig {
public JerseyConfig() {
register(Endpoint.class);
}
}
|
| 澤西對掃描可執行檔案的支持至關有限。例如，它沒法掃描在 |
對於更高級的自定義，還能夠註冊任意數量的實現ResourceConfigCustomizer.
全部註冊的端點應該是@Components使用HTTP資源註釋(@GET)，如如下示例所示：
@Component
@Path("/hello")
public class Endpoint {
@GET
public String message() {
return "Hello";
}
}
由於Endpoint是春天@Component，它的生命週期由Spring管理，您能夠使用@Autowired註釋注入依賴項並使用@Value註解注入外部配置。默認狀況下，Jerseyservlet被註冊並映射到/*。能夠經過添加@ApplicationPath敬你的ResourceConfig.
默認狀況下，澤西島被設置爲@Bean類型ServletRegistrationBean命名jerseyServletRegistration。默認狀況下，servlet是延遲初始化的，可是能夠經過設置spring.jersey.servlet.load-on-startup。您能夠使用相同的名稱建立本身的bean，從而禁用或重寫該bean。還能夠經過設置spring.jersey.type=filter(在這種狀況下，@Bean替換或覆蓋是jerseyFilterRegistration)過濾器有一個@Order，您能夠將其設置爲spring.jersey.filter.order。servlet和過濾器註冊均可以經過如下方式給出init參數：spring.jersey.init.*若要指定屬性映射，請執行如下操做。
有一個澤西樣本這樣你就能看到如何安排好一切。
27.4嵌入式Servlet容器支持
SpringBoot包括對嵌入式系統的支持貓貓, 碼頭，和下引服務器。大多數開發人員使用適當的「初學者」來得到徹底配置的實例。默認狀況下，嵌入式服務器偵聽端口上的HTTP請求8080.
|
| 若是您選擇使用Tomcat onCentOS，請注意，默認狀況下，臨時目錄用於存儲已編譯的JSP、文件上載等。此目錄可由 |
27.4.1 servlet、過濾器和偵聽器
當使用嵌入式servlet容器時，能夠註冊servlet、過濾器和全部偵聽器(如HttpSessionListener)，經過使用Springbean或掃描servlet組件。
將servlet、過濾器和偵聽器註冊爲Springbean
任何Servlet, Filter，或Servlet*Listener實例，即Springbean在嵌入式容器中註冊。若是要引用application.properties在配置過程當中。
默認狀況下，若是上下文僅包含單個servlet，則將其映射到/。對於多個Servlet bean，bean名稱用做路徑前綴。過濾器映射到/*.
若是基於約定的映射不夠靈活，則能夠使用ServletRegistrationBean, FilterRegistrationBean，和ServletListenerRegistrationBean類用於徹底控制。
SpringBoot提供了許多自動配置，能夠定義過濾器bean。下面是幾個過濾器的示例及其各自的順序(低階值意味着更高的優先級)：
| Servlet過濾器 | 命令 |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
一般是安全的，讓過濾豆子無序。
若是須要特定的訂單，則應避免配置一個篩選器，該篩選器將在Ordered.HIGHEST_PRECEDENCE，由於它可能與應用程序的字符編碼配置背道而馳。若是servlet篩選器包裝了請求，則應該將其配置爲小於或等於FilterRegistrationBean.REQUEST_WRAPPER_FILTER_MAX_ORDER.
27.4.2 servlet上下文初始化
嵌入式servlet容器不直接執行Servlet3.0+javax.servlet.ServletContainerInitializer界面或彈簧org.springframework.web.WebApplicationInitializer接口。這是一個有意的設計決策，旨在下降第三方庫在WAR中運行可能破壞SpringBoot應用程序的風險。
若是須要在SpringBoot應用程序中執行servlet上下文初始化，則應該註冊一個實現org.springframework.boot.web.servlet.ServletContextInitializer接口。單曲onStartup方法提供對ServletContext而且，若是有必要，能夠很容易地用做現有的適配器。WebApplicationInitializer.
掃描servlet、過濾器和偵聽器
使用嵌入式容器時，自動註冊帶註釋的類@WebServlet, @WebFilter，和@WebListener能夠經過如下方式啓用@ServletComponentScan.
|
|
|
27.4.3 ServletWebServerApplicationContext
在引擎蓋下，SpringBoot使用了一種不一樣類型的ApplicationContext支持嵌入式servlet容器。這，這個，那，那個ServletWebServerApplicationContext是一種特殊的WebApplicationContext經過搜索單個ServletWebServerFactory豆子一般是TomcatServletWebServerFactory, JettyServletWebServerFactory，或UndertowServletWebServerFactory已經自動配置好了。
|
| 您一般不須要知道這些實現類。大多數應用程序都是自動配置的，而且 |
27.4.4定製嵌入式servlet容器
能夠使用Spring配置常見的servlet容器設置Environment財產。一般，您將在application.properties檔案。
常見的服務器設置包括：
- 網絡設置：監聽傳入HTTP請求的端口(
server.port)，要綁定到的接口地址。server.address等等。 - 會話設置：會話是否持久(
server.servlet.session.persistence)，會話超時(server.servlet.session.timeout)，會話數據的位置(server.servlet.session.store-dir)，以及會話-cookie配置(server.servlet.session.cookie.*). - 錯誤管理：錯誤頁面的位置(
server.error.path等等。 - SSL
- http壓縮
SpringBoot儘量多地嘗試公開公共設置，但這並不老是可能的。對於這些狀況，專用名稱空間提供特定於服務器的自定義(請參閱server.tomcat和server.undertow)例如訪問日誌能夠使用嵌入式servlet容器的特定功能進行配置。
|
| 見 |
程序定製
若是須要以編程方式配置嵌入的servlet容器，則能夠註冊實現WebServerFactoryCustomizer接口。WebServerFactoryCustomizer提供對ConfigurableServletWebServerFactory，其中包括許多定製的setter方法。下面的示例顯示了以編程方式設置端口：
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.boot.web.servlet.server.ConfigurableServletWebServerFactory;
import org.springframework.stereotype.Component;
@Component
public class CustomizationBean implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {
@Override
public void customize(ConfigurableServletWebServerFactory server) {
server.setPort(9000);
}
}
|
|
|
直接定製ConfigurableServletWebServerFactory
若是前面的自定義技術太有限，則能夠註冊TomcatServletWebServerFactory, JettyServletWebServerFactory，或UndertowServletWebServerFactory你本身吃吧。
@Bean
public ConfigurableServletWebServerFactory webServerFactory() {
TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
factory.setPort(9000);
factory.setSessionTimeout(10, TimeUnit.MINUTES);
factory.addErrorPages(new ErrorPage(HttpStatus.NOT_FOUND, "/notfound.html"));
return factory;
}
爲許多配置選項提供了setter。若是您須要作一些更有異國情調的事情，還提供了幾個受保護的方法「鉤子」。見源代碼文檔關於細節。
27.4.5 JSP限制
當運行使用嵌入式servlet容器(並打包爲可執行存檔)的SpringBoot應用程序時，JSP支持有一些限制。
- 對於Jetty和Tomcat，若是您使用WAR打包，它應該能夠工做。可執行的WAR將在與
java -jar，也能夠部署到任何標準容器中。在使用可執行JAR時，不支持JPS。 - 欠付不支持JSP。
- 建立自定義
error.jsp頁不覆蓋默認視圖。錯誤處理. 自定義錯誤頁應該用它代替。
有一個JSP樣本這樣你就能看到如何安排好一切。
28.保安
若是彈簧安全在類路徑上，則Web應用程序在默認狀況下是安全的。Spring Boot依賴SpringSecurity的內容協商策略來決定是否使用httpBasic或formLogin。若要向web應用程序添加方法級安全性，還能夠添加@EnableGlobalMethodSecurity有你想要的設置。更多信息可在彈簧安全參考指南.
默認UserDetailsService只有一個用戶。用戶名是user，密碼是隨機的，在應用程序啓動時在信息級別打印，以下面的示例所示：
Using generated security password: 78fa095d-3f4c-48b1-ad50-e24c31d5cf35
|
| 若是您微調日誌記錄配置，請確保 |
您能夠經過提供spring.security.user.name和spring.security.user.password.
默認狀況下，Web應用程序中得到的基本功能以下：
- A
UserDetailsService(或ReactiveUserDetailsService在WebFlux應用程序的狀況下，bean具備內存存儲和生成密碼的單個用戶(請參見SecurityProperties.User對於用戶的屬性)。 - 整個應用程序的基於表單的登陸或HTTP基本安全性(取決於內容類型)(若是執行器位於類路徑上，則包括執行器端點)。
- A
DefaultAuthenticationEventPublisher用於發佈身份驗證事件。
你能夠提供不一樣的AuthenticationEventPublisher爲它添加一個豆子。
28.1 MVC安全性
默認安全配置是在SecurityAutoConfiguration和UserDetailsServiceAutoConfiguration. SecurityAutoConfiguration進口品SpringBootWebSecurityConfiguration對於網絡安全和UserDetailsServiceAutoConfiguration配置身份驗證，這也與非web應用程序相關。若要徹底關閉默認web應用程序安全配置，能夠添加類型爲WebSecurityConfigurerAdapter(這樣作不會禁用UserDetailsService配置或執行器的安全性)。
也能夠關閉UserDetailsService配置時，能夠添加類型爲UserDetailsService, AuthenticationProvider，或AuthenticationManager。中有幾個安全應用程序。彈簧啓動樣本讓您從通用例開始。
能夠經過添加自定義來重寫訪問規則。WebSecurityConfigurerAdapter。SpringBoot提供了方便的方法，能夠用來覆蓋執行器端點和靜態資源的訪問規則。EndpointRequest能夠用來建立RequestMatcher，這是基於management.endpoints.web.base-path財產。PathRequest能夠用來建立RequestMatcher用於經常使用地點的資源。
28.2 WebFlux安全
相似於SpringMVC應用程序，能夠經過添加spring-boot-starter-security依賴。默認安全配置是在ReactiveSecurityAutoConfiguration和UserDetailsServiceAutoConfiguration. ReactiveSecurityAutoConfiguration進口品WebFluxSecurityConfiguration對於網絡安全和UserDetailsServiceAutoConfiguration配置身份驗證，這也與非web應用程序相關。若要徹底關閉默認web應用程序安全配置，能夠添加類型爲WebFilterChainProxy(這樣作不會禁用UserDetailsService配置或執行器的安全性)。
也能夠關閉UserDetailsService配置時，能夠添加類型爲ReactiveUserDetailsService或ReactiveAuthenticationManager.
能夠經過添加自定義來配置訪問規則。SecurityWebFilterChain。SpringBoot提供了方便的方法，能夠用來覆蓋執行器端點和靜態資源的訪問規則。EndpointRequest能夠用來建立ServerWebExchangeMatcher，這是基於management.endpoints.web.base-path財產。
PathRequest能夠用來建立ServerWebExchangeMatcher用於經常使用地點的資源。
例如，您能夠經過添加如下內容來自定義您的安全配置：
@Bean
public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
return http
.authorizeExchange()
.matchers(PathRequest.toStaticResources().atCommonLocations()).permitAll()
.pathMatchers("/foo", "/bar")
.authenticated().and()
.formLogin().and()
.build();
}
28.3 OAuth2
OAuth2是Spring支持的普遍使用的受權框架。
28.3.1客戶
若是你有spring-security-oauth2-client在類路徑上，您能夠利用一些自動配置來輕鬆地設置OAuth2/OpenIDConnect客戶端。此配置使用OAuth2ClientProperties.
對象下注冊多個OAuth2/OpenID鏈接提供程序。spring.security.oauth2.client.provider前綴，如如下示例所示：
spring.security.oauth2.client.provider.my-oauth-provider.authorization-uri=http://my-auth-server/oauth/authorize spring.security.oauth2.client.provider.my-oauth-provider.token-uri=http://my-auth-server/oauth/token spring.security.oauth2.client.provider.my-oauth-provider.user-info-uri=http://my-auth-server/userinfo spring.security.oauth2.client.provider.my-oauth-provider.user-info-authentication-method=header spring.security.oauth2.client.provider.my-oauth-provider.jwk-set-uri=http://my-auth-server/token_keys spring.security.oauth2.client.provider.my-oauth-provider.user-name-attribute=name
對於支持OpenID鏈接提供程序的OpenID鏈接發現，能夠進一步簡化配置。提供程序須要配置issuer-uri它斷言的URI是它的頒發者標識符。例如，若是issuer-uri提供的是「https：/example.com」，而後是OpenID Provider Configuration Request將被製做成「https：//example.com/.well-known/openid-configuration」.預期結果將是OpenID Provider Configuration Response。下面的示例演示如何使用issuer-uri:
spring.security.oauth2.client.provider.oidc-provider.issuer-uri=https://dev-123456.oktapreview.com/oauth2/default/
OpenID鏈接登陸客戶端註冊
對象下注冊多個開放ID鏈接客戶端。spring.security.oauth2.client.registration.login前綴，如如下示例所示：
spring.security.oauth2.client.registration.login.my-client-1.client-id=abcd spring.security.oauth2.client.registration.login.my-client-1.client-secret=password spring.security.oauth2.client.registration.login.my-client-1.client-name=Client for user scope spring.security.oauth2.client.registration.login.my-client-1.provider=my-oauth-provider spring.security.oauth2.client.registration.login.my-client-1.scope=user spring.security.oauth2.client.registration.login.my-client-1.redirect-uri=http://localhost:8080/login/oauth2/code/my-client-1 spring.security.oauth2.client.registration.login.my-client-1.client-authentication-method=basic spring.security.oauth2.client.registration.login.my-client-1.authorization-grant-type=authorization_code spring.security.oauth2.client.registration.login.my-client-2.client-id=abcd spring.security.oauth2.client.registration.login.my-client-2.client-secret=password spring.security.oauth2.client.registration.login.my-client-2.client-name=Client for email scope spring.security.oauth2.client.registration.login.my-client-2.provider=my-oauth-provider spring.security.oauth2.client.registration.login.my-client-2.scope=email spring.security.oauth2.client.registration.login.my-client-2.redirect-uri=http://localhost:8080/login/oauth2/code/my-client-2 spring.security.oauth2.client.registration.login.my-client-2.client-authentication-method=basic spring.security.oauth2.client.registration.login.my-client-2.authorization-grant-type=authorization_code
默認狀況下，Spring的OAuth2LoginAuthenticationFilter只處理URL匹配/login/oauth2/code/*。若是要自定義redirect-uri要使用不一樣的模式，您須要提供配置來處理該自定義模式。例如，對於servlet應用程序，能夠添加本身的WebSecurityConfigurerAdapter這相似於如下幾點：
public class OAuth2LoginSecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.anyRequest().authenticated()
.and()
.oauth2Login()
.redirectionEndpoint()
.baseUri("/custom-callback");
}
}
一樣的屬性也適用於servlet和反應性應用程序。
OAuth2受權代碼客戶端註冊
您能夠註冊多個OAuth2authorization_code客戶在spring.security.oauth2.client.registration.authorization-code前綴，如如下示例所示：
spring.security.oauth2.client.registration.authorization-code.my-client-1.client-id=abcd spring.security.oauth2.client.registration.authorization-code.my-client-1.client-secret=password spring.security.oauth2.client.registration.authorization-code.my-client-1.client-name=Client for user scope spring.security.oauth2.client.registration.authorization-code.my-client-1.provider=my-oauth-provider spring.security.oauth2.client.registration.authorization-code.my-client-1.scope=user spring.security.oauth2.client.registration.authorization-code.my-client-1.redirect-uri=http://my-redirect-uri.com spring.security.oauth2.client.registration.authorization-code.my-client-1.client-authentication-method=basic spring.security.oauth2.client.registration.authorization-code.my-client-1.authorization-grant-type=authorization_code spring.security.oauth2.client.registration.authorization-code.my-client-2.client-id=abcd spring.security.oauth2.client.registration.authorization-code.my-client-2.client-secret=password spring.security.oauth2.client.registration.authorization-code.my-client-2.client-name=Client for email scope spring.security.oauth2.client.registration.authorization-code.my-client-2.provider=my-oauth-provider spring.security.oauth2.client.registration.authorization-code.my-client-2.scope=email spring.security.oauth2.client.registration.authorization-code.my-client-2.redirect-uri=http://my-redirect-uri.com spring.security.oauth2.client.registration.authorization-code.my-client-2.client-authentication-method=basic spring.security.oauth2.client.registration.authorization-code.my-client-2.authorization-grant-type=authorization_code
OAuth2通用提供者的客戶端註冊
對於常見的OAuth2和OpenID提供商，包括Google、Gizub、Facebook和Okta，咱們提供了一組提供者默認值(google, github, facebook，和okta分別)。
若是不須要自定義這些提供程序，則能夠將provider屬性爲須要推斷默認值的屬性。此外，若是客戶端的ID與默認支持的提供程序匹配，SpringBoot也會推斷這一點。
換句話說，如下示例中的兩個配置使用Google Provider：
spring.security.oauth2.client.registration.login.my-client.client-id=abcd spring.security.oauth2.client.registration.login.my-client.client-secret=password spring.security.oauth2.client.registration.login.my-client.provider=google spring.security.oauth2.client.registration.login.google.client-id=abcd spring.security.oauth2.client.registration.login.google.client-secret=password
28.3.2資源服務器
若是你有spring-security-oauth2-resource-server在類路徑上，只要指定了JWK集URI或OIDC Issuer URI，Spring Boot就能夠設置OAuth2資源服務器，如如下示例所示：
spring.security.oauth2.resourceserver.jwt.jwk-set-uri=https://example.com/oauth2/default/v1/keys
spring.security.oauth2.resourceserver.jwt.issuer-uri=https://dev-123456.oktapreview.com/oauth2/default/
一樣的屬性也適用於servlet和反應性應用程序。
或者，您能夠定義本身的JwtDecoder用於servlet應用程序的bean或ReactiveJwtDecoder用於反應性應用。
28.3.3受權服務器
目前，SpringSecurity不支持實現OAuth2.0受權服務器。可是，此功能可從彈簧安全OAuth項目，它最終將被SpringSecurity徹底取代。在此以前，您能夠使用spring-security-oauth2-autoconfigure模塊以輕鬆設置OAuth2.0受權服務器；請參見其文獻資料爲了獲得指示。
28.4執行器安全
爲安全起見，除/health和/info默認狀況下禁用。這，這個，那，那個management.endpoints.web.exposure.include屬性可用於啓用執行機構。
若是Spring安全性位於類路徑上，而且沒有其餘WebSecurityConfigurerAdapter，則除/health和/info由SpringBoot自動配置保護。若是您定義了一個自定義WebSecurityConfigurerAdapter，SpringBoot自動配置將退出，您將徹底控制執行器訪問規則。
|
| 在設置 |
28.4.1跨站點請求僞造保護
因爲SpringBoot依賴SpringSecurity的默認設置，默認狀況下CSRF保護是打開的。這意味着執行器端點須要POST(關機和記錄器端點)，PUT或DELETE在使用默認安全配置時，將獲得一個403禁止的錯誤。
|
| 只有在建立非瀏覽器客戶端使用的服務時，咱們才建議徹底禁用CSRF保護。 |
有關csrf保護的其餘信息，請參閱彈簧安全參考指南.
29.使用SQL數據庫
這，這個，那，那個彈簧框架提供對使用sql數據庫的普遍支持，可直接使用jdbc訪問JdbcTemplate來完成諸如Hibernate之類的「對象關係映射」技術。彈簧數據提供額外的功能級別：建立Repository直接從接口實現，並使用約定從您的方法名稱生成查詢。
29.1配置數據源
爪哇javax.sql.DataSource接口提供了處理數據庫鏈接的標準方法。傳統上，「DataSource」使用URL以及創建數據庫鏈接的一些憑據。
|
| 看見「如何到」一節對於更高級的示例，一般要徹底控制DataSource的配置。 |
29.1.1嵌入式數據庫支持
使用內存內嵌入式數據庫開發應用程序一般很方便.顯然，內存中的數據庫不提供持久存儲.您須要在應用程序啓動時填充數據庫，並準備好在應用程序結束時丟棄數據。
|
| 「如何到」部分包括一節，介紹如何初始化數據庫。. |
彈簧引導能夠自動配置嵌入式。氫, HSQL，和德比數據庫。您不須要提供任何鏈接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>
|
| 你須要依賴 |
|
| 若是出於任何緣由，您確實爲嵌入式數據庫配置了鏈接URL，請注意確保禁用了數據庫的自動關閉。若是你使用h2，你應該使用 |
29.1.2鏈接到生產數據庫
還能夠使用池自動配置生產數據庫鏈接。DataSource。Spring Boot使用如下算法來選擇特定的實現：
- 咱們更喜歡HikariCP由於它的性能和併發性。若是HikariCP可用，咱們老是選擇它。
- 不然，若是Tomcat池
DataSource是可用的，咱們用它。 - 若是沒有HikariCP或Tomcat池數據源，而且共用DBCP 2是可用的，咱們用它。
若是您使用spring-boot-starter-jdbc或spring-boot-starter-data-jpa「Starters」，您將自動得到一個依賴項HikariCP.
|
| 能夠徹底繞過該算法，並經過設置 |
|
| 其餘鏈接池始終能夠手動配置。若是你定義了你本身的 |
中的外部配置屬性控制數據源配置。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.hikari.*, spring.datasource.tomcat.*，和spring.datasource.dbcp2.*)有關詳細信息，請參閱您正在使用的鏈接池實現的文檔。
例如，若是您使用Tomcat鏈接池，您能夠自定義許多其餘設置，如如下示例所示：
# Number of ms to wait before throwing an exception if no connection is available. spring.datasource.tomcat.max-wait=10000 # Maximum number of active connections that can be allocated from this pool at the same time. spring.datasource.tomcat.max-active=50 # Validate the connection before borrowing it from the pool. spring.datasource.tomcat.test-on-borrow=true
29.1.3鏈接到JNDI數據源
若是將SpringBoot應用程序部署到ApplicationServer，則可能須要使用ApplicationServer的內置特性配置和管理DataSource，並使用JNDI訪問它。
這，這個，那，那個spring.datasource.jndi-name屬性可用做spring.datasource.url, spring.datasource.username，和spring.datasource.password屬性訪問DataSource從特定的JNDI位置。例如，application.properties演示如何按定義訪問JBossDataSource:
spring.datasource.jndi-name=java:jboss/datasources/customers
29.2使用JdbcTemplate
春天的JdbcTemplate和NamedParameterJdbcTemplate類是自動配置的，您能夠@Autowire它們直接進入您本身的bean中，以下面的示例所示：
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;
}
// ...
}
控件能夠自定義模板的某些屬性。spring.jdbc.template.*屬性，如如下示例所示：
spring.jdbc.template.max-rows=500
|
| 這，這個，那，那個 |
29.3 JPA和Spring Data JPA
JavaPersistenceAPI是一種標準技術，容許您將對象「映射」到關係數據庫。這，這個，那，那個spring-boot-starter-data-jpaPOM提供了一種快速入門的方法。它提供瞭如下關鍵依賴項：
- Hibernate：最流行的JPA實現之一。
- SpringDataJPA：使基於JPA的存儲庫易於實現。
- SpringOrms：Spring框架中的核心ORM支持。
|
| 咱們不會詳細討論JPA或彈簧數據這裏你能夠跟着「使用JPA訪問數據」從spring.io並閱讀春季數據JPA和冬眠參考文件。 |
29.3.1實體類
傳統上，JPA「實體」類是在persistence.xml檔案。對於SpringBoot，這個文件是沒必要要的，取而代之的是「實體掃描」。默認狀況下，主配置類下面的全部包(用@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.state = state;
}
public String getName() {
return this.name;
}
public String getState() {
return this.state;
}
// ... etc
}
|
| 屬性自定義實體掃描位置。 |
29.3.2 Spring數據JPA存儲庫
春季數據JPA存儲庫是您能夠定義的訪問數據的接口。JPA查詢是根據您的方法名稱自動建立的。例如，CityRepository接口可能會聲明findAllByState(String state)方法來查找處於給定狀態的全部城市。
對於更復雜的查詢，能夠使用Spring數據的Query註釋
Spring數據存儲庫一般從Repository或CrudRepository接口。若是使用自動配置，則從包含主配置類的包(帶註釋的類)中搜索存儲庫。@EnableAutoConfiguration或@SpringBootApplication)趴下。
下面的示例顯示了典型的Spring數據存儲庫接口定義：
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 findByNameAndStateAllIgnoringCase(String name, String state);
}
SpringDataJPA存儲庫支持三種不一樣的引導模式：默認模式、延遲模式和延遲模式。若要啓用延遲或延遲引導，請將spring.data.jpa.repositories.bootstrap-mode到deferred或lazy分別。使用延遲或延遲引導時，自動配置EntityManagerFactoryBuilder將使用上下文的異步任務執行器(若是有的話)做爲引導執行器。
|
| 咱們幾乎沒有觸及SpringDataJPA的表面。有關詳細信息，請參閱Spring數據JPA參考文檔. |
29.3.3建立和刪除JPA數據庫
默認狀況下，會自動建立jpa數據庫。只若是使用嵌入式數據庫(H二、HSQL或Derby)。能夠經過如下方法顯式配置JPA設置：spring.jpa.*財產。例如，要建立和刪除表，能夠將如下行添加到application.properties:
spring.jpa.hibernate.ddl-auto=create-drop
|
| Hibernate本身的內部屬性名(若是您更好地記住它)是 |
spring.jpa.properties.hibernate.globally_quoted_identifiers=true
前面示例中的行傳遞的值爲true爲hibernate.globally_quoted_identifiers屬性設置爲Hibernate實體管理器。
默認狀況下，DDL執行(或驗證)將推遲到ApplicationContext已經開始了。還有一個spring.jpa.generate-ddl標誌，但若是Hibernate自動配置處於活動狀態，則不使用它，由於ddl-auto設置更細粒度.
29.3.4視圖中的OpenEntityManager
若是正在運行web應用程序，默認狀況下SpringBoot註冊OpenEntityManagerInViewInterceptor應用「OpenEntityManager in View」模式，容許在web視圖中延遲加載。若是不想要這種行爲，則應設置spring.jpa.open-in-view到false在你的application.properties.
29.4 Spring數據JDBC
Spring數據包括對jdbc的存儲庫支持，並將自動爲CrudRepository。對於更高級的查詢，@Query提供了註釋。
當類路徑上有必要的依賴項時，SpringBoot將自動配置Spring數據的JDBC存儲庫。能夠經過一個依賴項將它們添加到您的項目中。spring-boot-starter-data-jdbc。若是有必要，能夠經過添加@EnableJdbcRepositories註釋或JdbcConfiguration應用程序的子類。
|
| 有關SpringDataJDBC的詳細信息，請參閱參考文獻. |
29.5使用H2的Web控制檯
這，這個，那，那個H2數據庫提供一個基於瀏覽器的控制檯Spring Boot能夠自動爲您配置。當知足下列條件時，控制檯將自動配置：
- 您正在開發一個基於servlet的Web應用程序。
com.h2database:h2在類路徑上。- 你在用Spring Boot開發工具.
|
| 若是您沒有使用SpringBoot的開發工具，但仍然但願使用h2的控制檯，則能夠配置 |
|
| h2控制檯僅供開發期間使用，所以您應注意確保 |
29.5.1更改H2控制檯的路徑
默認狀況下，控制檯可在/h2-console。控件能夠自定義控制檯的路徑。spring.h2.console.path財產。
29.6使用jOOQ
面向Java對象的查詢(JOOQ)是一種流行的產品數據奇才它從數據庫中生成Java代碼，並容許您經過其FLUENT API構建類型安全的SQL查詢。商業版本和開源版本均可以與SpringBoot一塊兒使用。
29.6.1代碼生成
爲了使用jOOQ類型安全查詢，須要從數據庫模式生成Java類。您能夠按照JOOQ用戶手冊。若是您使用jooq-codegen-maven插件，您也能夠使用spring-boot-starter-parent「父POM」，您能夠安全地省略插件的<version>標籤。還能夠使用SpringBoot定義的版本變量(如h2.version)聲明插件的數據庫依賴關係。下面的清單顯示了一個示例：
<plugin>
<groupId>org.jooq</groupId>
<artifactId>jooq-codegen-maven</artifactId>
<executions>
...
</executions>
<dependencies>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<version>${h2.version}</version>
</dependency>
</dependencies>
<configuration>
<jdbc>
<driver>org.h2.Driver</driver>
<url>jdbc:h2:~/yourdatabase</url>
</jdbc>
<generator>
...
</generator>
</configuration>
</plugin>
29.6.2使用DSLContext
jOOQ提供的Fluent API是經過org.jooq.DSLContext接口。Spring Boot自動配置DSLContext做爲SpringBean並將其鏈接到應用程序DataSource。使用DSLContext，你能夠@Autowire如如下示例所示：
@Component
public class JooqExample implements CommandLineRunner {
private final DSLContext create;
@Autowired
public JooqExample(DSLContext dslContext) {
this.create = dslContext;
}
}
|
| jOOQ手冊傾向於使用一個名爲 |
而後，您能夠使用DSLContext若要構造查詢，請參見如下示例：
public List<GregorianCalendar> authorsBornAfter1980() {
return this.create.selectFrom(AUTHOR)
.where(AUTHOR.DATE_OF_BIRTH.greaterThan(new GregorianCalendar(1980, 0, 1)))
.fetch(AUTHOR.DATE_OF_BIRTH);
}
29.6.3 jOOQ SQL方言
除非spring.jooq.sql-dialect屬性，Spring Boot將肯定要用於數據源的SQL方言。若是SpringBoot沒法檢測到方言，它將使用DEFAULT.
|
| SpringBoot只能自動配置jOOQ開源版本支持的方言。 |
29.6.4定製jOOQ
能夠經過定義本身的自定義來實現更高級的自定義。@Bean定義，當jOOQ使用時使用Configuration是被創造出來的。能夠爲如下jOOQ類型定義bean：
ConnectionProviderExecutorProviderTransactionProviderRecordMapperProviderRecordUnmapperProviderRecordListenerProviderExecuteListenerProviderVisitListenerProviderTransactionListenerProvider
您也能夠建立本身的org.jooq.Configuration @Bean若是您想徹底控制jOOQ配置。
三十使用NoSQL技術
Spring數據提供了幫助您訪問各類NoSQL技術的其餘項目，包括：MongoDB, Neo4J, 彈性搜索, 索爾, 雷迪斯, 雙子火, 卡桑德拉, Couchbase和LDAP。SpringBoot爲Redis、MongoDB、Neo4j、Elasticsearch、Solr Cassandra、Couchbase和LDAP提供了自動配置。您能夠使用其餘項目，但您必須本身配置它們。請參閱適當的參考文件projects.spring.io/spring-data.
30.1 Redis
雷迪斯是一個緩存、消息代理和功能豐富的鍵值存儲。Spring Boot爲生菜和吉迪斯客戶端庫及其之上的抽象春季數據紅寶石.
有一個spring-boot-starter-data-redis用於以方便的方式收集依賴項的「初學者」。默認狀況下，它使用生菜。該啓動器同時處理傳統應用程序和反應性應用程序。
|
| 咱們還提供 |
30.1.1鏈接到Redis
您能夠注入一個自動配置的RedisConnectionFactory, StringRedisTemplate或香草RedisTemplate實例，就像其餘SpringBean同樣。默認狀況下，實例試圖鏈接到localhost:6379。下面的清單顯示了這樣一個bean的示例：
@Component
public class MyBean {
private StringRedisTemplate template;
@Autowired
public MyBean(StringRedisTemplate template) {
this.template = template;
}
// ...
}
|
| 您還能夠註冊任意數量的bean，這些bean實現了 |
若是你加上你本身的@Bean在任何自動配置的類型中，它都將替換默認值(除非在RedisTemplate，當排除基於bean名稱時，redisTemplate，而不是它的類型)。默認狀況下，若是commons-pool2在類路徑上，您將獲得一個池鏈接工廠。
30.2 MongoDB
MongoDB是一個開源的NoSQL文檔數據庫，它使用相似JSON的模式，而不是傳統的基於表的關係數據。SpringBoot爲使用MongoDB提供了一些方便，包括spring-boot-starter-data-mongodb和spring-boot-starter-data-mongodb-reactive「先開始」。
30.2.1鏈接到MongoDB數據庫
要訪問MONGO數據庫，能夠注入一個自動配置的org.springframework.data.mongodb.MongoDbFactory。默認狀況下，實例嘗試鏈接到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並配置其餘設置，如複製集，如如下示例所示：
spring.data.mongodb.uri=mongodb://user:secret@mongo1.example.com:12345,mongo2.example.com:23456/test
或者，只要使用mongo2.x，就能夠指定host/port。例如，您能夠在application.properties:
spring.data.mongodb.host=mongoserver spring.data.mongodb.port=27017
若是你已經定義了你本身的MongoClient，它將用於自動配置合適的MongoDbFactory。左右開弓com.mongodb.MongoClient和com.mongodb.client.MongoClient是支持的。
|
| 若是您使用MONGO3.0 Java驅動程序， |
|
| 若是 |
|
| 若是不使用SpringDataMONGO，則能夠插入 |
|
| 若是您使用的是反應性驅動程序，則SSL須要Netty。若是Netty可用，而且還沒有定製要使用的工廠，則自動配置將自動配置此工廠。 |
30.2.2蒙古板
春季數據MongoDB提供一個MongoTemplate類，它的設計與Spring的很是類似。JdbcTemplate。同.同樣JdbcTemplate，SpringBoot自動配置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;
}
// ...
}
見MongoOperationsJavadoc得到完整的細節。
30.2.3 Spring數據MongoDB存儲庫
Spring數據包括對MongoDB的存儲庫支持。與前面討論的JPA存儲庫同樣，基本原則是根據方法名稱自動構造查詢。
實際上，SpringDataJPA和SpringDataMongoDB共享相同的公共基礎設施。您能夠從前面的JPA示例開始，假設City如今是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 findByNameAndStateAllIgnoringCase(String name, String state);
}
|
| 控件能夠自定義文檔掃描位置。 |
|
| 有關SpringDataMongoDB(包括其富對象映射技術)的詳細信息，請參閱參考文獻. |
30.2.4嵌入式MONGO
Spring Boot爲嵌入式蒙戈。若要在SpringBoot應用程序中使用它，請在de.flapdoodle.embed:de.flapdoodle.embed.mongo.
能夠經過設置spring.data.mongodb.port財產。若要使用隨機分配的空閒端口，請使用值0。這，這個，那，那個MongoClient由MongoAutoConfiguration自動配置爲使用隨機分配的端口。
|
| 若是不配置自定義端口，默認狀況下，嵌入式支持將使用隨機端口(而不是27017)。 |
若是類路徑上有SLF4J，則MONGO產生的輸出將自動路由到名爲org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongo.
你能夠宣佈你本身的IMongodConfig和IRuntimeConfigbean來控制MONGO實例的配置和日誌路由。
30.3 Neo4j
Neo4j是一個開源的NoSQL圖形數據庫，它使用由一級關係鏈接的節點的豐富數據模型，比傳統的RDBMS方法更適合鏈接大數據。SpringBoot爲使用Neo4j提供了一些方便，包括spring-boot-starter-data-neo4j「初學者」。
30.3.1鏈接到Neo4j數據庫
要訪問neo4j服務器，能夠注入一個自動配置的org.neo4j.ogm.session.Session。默認狀況下，實例嘗試鏈接到localhost:7687使用博爾特協議。下面的示例演示如何注入Neo4jSession:
@Component
public class MyBean {
private final Session session;
@Autowired
public MyBean(Session session) {
this.session = session;
}
// ...
}
能夠經過設置spring.data.neo4j.*屬性，如如下示例所示：
spring.data.neo4j.uri=bolt://my-server:7687 spring.data.neo4j.username=neo4j spring.data.neo4j.password=secret
能夠經過添加org.neo4j.ogm.config.Configuration @Bean。同時，添加一個@Bean類型SessionFactory禁用自動配置，並給予您徹底控制。
30.3.2使用嵌入式模式
若是你加上org.neo4j:neo4j-ogm-embedded-driver對於應用程序的依賴項，SpringBoot會自動配置一個在進程內嵌入的Neo4j實例，該實例在應用程序關閉時不會持久化任何數據。
|
| 因爲嵌入的Neo4jOGM驅動程序不提供Neo4j內核自己，因此必須聲明 |
當類路徑上有多個驅動程序時，嵌入式驅動程序優先於其餘驅動程序。經過設置，能夠顯式禁用嵌入模式。spring.data.neo4j.embedded.enabled=false.
數據Neo4j試驗若是嵌入式驅動程序和Neo4j內核位於上述類路徑上，則自動使用嵌入式Neo4j實例。
|
| 您能夠經過爲配置中的數據庫文件提供路徑來啓用嵌入式模式的持久性。 |
30.3.3 Neo4jSession
默認狀況下，若是您正在運行Web應用程序，會話將綁定到請求的整個處理過程當中的線程(也就是說，它使用「OpenSession in View」模式)。若是不想要這種行爲，請將如下行添加到application.properties檔案：
spring.data.neo4j.open-in-view=false
30.3.4 Spring數據Neo4j存儲庫
Spring數據包括對Neo4j的存儲庫支持。
與許多其餘Spring數據模塊同樣，SpringDataNeo4j與SpringDataJPA共享公共基礎設施。您能夠從前面的JPA示例開始，並定義City做爲Neo4j OGM@NodeEntity而不是JPA@Entity存儲庫抽象以一樣的方式工做，以下面的示例所示：
package com.example.myapp.domain;
import java.util.Optional;
import org.springframework.data.neo4j.repository.*;
public interface CityRepository extends Neo4jRepository<City, Long> {
Optional<City> findOneByNameAndState(String name, String state);
}
這，這個，那，那個spring-boot-starter-data-neo4j「初學者」啓用了存儲庫支持和事務管理。能夠自定義查找存儲庫和實體的位置，方法是@EnableNeo4jRepositories和@EntityScan分別在@Configuration-豆子
|
| 有關SpringDataNeo4j(包括其對象映射技術)的詳細信息，請參閱參考文獻. |
30.4雙子火
彈簧數據Gemfire提供方便的Spring友好工具來訪問樞軸雙子火數據管理平臺。有一個spring-boot-starter-data-gemfire用於以方便的方式收集依賴項的「初學者」。Gemfire目前不支持自動配置，可是能夠使用單一註釋：@EnableGemfireRepositories.
30.5 Solr
阿帕奇索爾是搜索引擎。Spring Boot爲Solr 5客戶端庫提供了基本的自動配置，而且它之上的抽象由彈簧數據Solr。有一個spring-boot-starter-data-solr用於以方便的方式收集依賴項的「初學者」。
30.5.1鏈接到Solr
您能夠注入一個自動配置的SolrClient實例，就像其餘Springbean同樣。默認狀況下，實例嘗試鏈接到localhost:8983/solr。下面的示例演示如何注入Solrbean：
@Component
public class MyBean {
private SolrClient solr;
@Autowired
public MyBean(SolrClient solr) {
this.solr = solr;
}
// ...
}
若是你加上你本身的@Bean類型SolrClient，它將替換默認值。
30.5.2 Spring數據Solr存儲庫
Spring數據包括對ApacheSolr的存儲庫支持。與前面討論的JPA存儲庫同樣，基本原則是根據方法名稱自動爲\You構造查詢。
實際上，SpringDataJPA和SpringDataSolr共享相同的公共基礎設施。您能夠從前面的JPA示例開始，假設City如今是@SolrDocument類而不是JPA@Entity，以一樣的方式工做。
|
| 有關SpringDataSolr的詳細信息，請參閱參考文獻. |
30.6彈性搜索
彈性搜索是一個開源、分佈式、RESTful的搜索和分析引擎。SpringBoot爲彈力搜索提供了基本的自動配置。
SpringBoot支持幾個HTTP客戶端：
- 正式的Java「低級」和「高級」REST客戶端
- 玩笑
傳輸客戶端仍由彈簧數據彈性搜索，您能夠開始使用spring-boot-starter-data-elasticsearch「初學者」。
30.6.1經過REST客戶端鏈接到彈性搜索
ElasticSearch船兩個不一樣的REST客戶端您能夠用來查詢集羣：「低級」客戶端和「高級」客戶端。
若是你有org.elasticsearch.client:elasticsearch-rest-client依賴於類路徑，SpringBoot將自動配置和註冊RestClientbean，在默認狀況下是目標。localhost:9200。你能夠進一步調整RestClient配置，如如下示例所示：
spring.elasticsearch.rest.uris=http://search.example.com:9200 spring.elasticsearch.rest.username=user spring.elasticsearch.rest.password=secret
您還能夠註冊任意數量的bean，這些bean實現了RestClientBuilderCustomizer用於更高級的自定義。若要徹底控制註冊，請定義RestClient豆子
若是你有org.elasticsearch.client:elasticsearch-rest-high-level-client依賴於類路徑，SpringBoot將自動配置RestHighLevelClient，它封裝了任何現有的RestClientbean，重用它的HTTP配置。
30.6.2使用JEST鏈接到彈性搜索
若是你有Jest在類路徑上，您能夠注入一個自動配置的JestClient默認目標localhost:9200。您能夠進一步優化客戶端的配置方式，如如下示例所示：
spring.elasticsearch.jest.uris=http://search.example.com:9200 spring.elasticsearch.jest.read-timeout=10000 spring.elasticsearch.jest.username=user spring.elasticsearch.jest.password=secret
您還能夠註冊任意數量的bean，這些bean實現了HttpClientConfigBuilderCustomizer用於更高級的自定義。下面的示例優化其餘HTTP設置：
static class HttpSettingsCustomizer implements HttpClientConfigBuilderCustomizer {
@Override
public void customize(HttpClientConfig.Builder builder) {
builder.maxTotalConnection(100).defaultMaxTotalConnectionPerRoute(5);
}
}
若要徹底控制註冊，請定義JestClient豆子
30.6.3使用Spring數據鏈接彈性搜索
要鏈接到Elasticearch，必須提供一個或多個羣集節點的地址。能夠經過設置spring.data.elasticsearch.cluster-nodes屬性以逗號分隔。host:port名單。配置就位後，ElasticsearchTemplate或TransportClient能夠像任何其餘Springbean同樣注入，以下面的示例所示：
spring.data.elasticsearch.cluster-nodes=localhost:9300
@Component
public class MyBean {
private final ElasticsearchTemplate template;
public MyBean(ElasticsearchTemplate template) {
this.template = template;
}
// ...
}
若是你加上你本身的ElasticsearchTemplate或TransportClient @Bean，它將替換默認值。
30.6.4 Spring數據彈性搜索庫
Spring數據包括對Elasticearch的存儲庫支持。與前面討論的JPA存儲庫同樣，基本原則是根據方法名稱自動爲您構造查詢。
實際上，SpringDataJPA和SpringDataElasticearch共享相同的公共基礎設施。您能夠從前面的JPA示例開始，假設City如今是一個彈性搜索@Document類而不是JPA@Entity，以一樣的方式工做。
|
| 有關Spring數據彈性搜索的詳細信息，請參閱參考文獻. |
30.7卡桑德拉
卡桑德拉是一個開放源碼的分佈式數據庫管理系統，旨在處理跨越許多商品服務器的大量數據。Spring Boot爲Cassandra提供了自動配置，並在此基礎上提供了春季數據卡桑德拉。有一個spring-boot-starter-data-cassandra用於以方便的方式收集依賴項的「初學者」。
30.7.1鏈接卡桑德拉
您能夠注入一個自動配置的CassandraTemplate或者卡桑德拉Session實例，就像對任何其餘SpringBean同樣。這，這個，那，那個spring.data.cassandra.*屬性可用於自定義鏈接。通常來講，你提供keyspace-name和contact-points屬性，如如下示例所示：
spring.data.cassandra.keyspace-name=mykeyspace spring.data.cassandra.contact-points=cassandrahost1,cassandrahost2
下面的代碼清單顯示瞭如何注入Cassandrabean：
@Component
public class MyBean {
private CassandraTemplate template;
@Autowired
public MyBean(CassandraTemplate template) {
this.template = template;
}
// ...
}
若是你加上你本身的@Bean類型CassandraTemplate，它將替換默認值。
30.7.2 Spring數據庫
Spring數據包括對Cassandra的基本存儲庫支持。目前，這比前面討論的JPA存儲庫更有限，須要用@Query.
|
| 有關SpringDataCassandra的詳細信息，請參閱參考文獻. |
30.8 Couchbase
Couchbase是一個開源的、分佈式的、面向多模型的面向NoSQL文檔的數據庫，它是爲交互式應用程序優化的.Spring Boot爲Couchbase提供了自動配置，而且它之上的抽象由彈簧數據庫。確實有。spring-boot-starter-data-couchbase和spring-boot-starter-data-couchbase-reactive用於以方便的方式收集依賴項的「啓動器」。
30.8.1鏈接到Couchbase
你能夠獲得一個Bucket和Cluster經過添加Couchbase SDK和一些配置。這，這個，那，那個spring.couchbase.*屬性可用於自定義鏈接。一般，您提供引導主機、桶名和密碼，以下面的示例所示：
spring.couchbase.bootstrap-hosts=my-host-1,192.168.1.123 spring.couchbase.bucket.name=my-bucket spring.couchbase.bucket.password=secret
|
| 你須要提供至少引導主機，在這種狀況下，桶名是 |
還能夠自定義一些CouchbaseEnvironment設置。例如，如下配置將超時更改成打開新的Bucket並啓用SSL支持：
spring.couchbase.env.timeouts.connect=3000 spring.couchbase.env.ssl.key-store=/location/of/keystore.jks spring.couchbase.env.ssl.key-store-password=secret
檢查spring.couchbase.env.*屬性獲取更多詳細信息。
30.8.2 Spring數據庫
Spring數據包括對Couchbase的存儲庫支持。有關SpringDataCouchbase的詳細信息，請參閱參考文獻.
您能夠注入一個自動配置的CouchbaseTemplate實例，與任何其餘SpringBean同樣，提供了一個違約 CouchbaseConfigurer是可用的(正如前面所解釋的，啓用Couchbase支持時會發生這種狀況)。
下面的示例演示如何注入Couchbase bean：
@Component
public class MyBean {
private final CouchbaseTemplate template;
@Autowired
public MyBean(CouchbaseTemplate template) {
this.template = template;
}
// ...
}
您能夠在本身的配置中定義幾個bean來覆蓋自動配置提供的bean：
- A
CouchbaseTemplate@Bean名爲couchbaseTemplate. - 阿
IndexManager@Bean名爲couchbaseIndexManager. - A
CustomConversions@Bean名爲couchbaseCustomConversions.
爲了不在您本身的配置中對這些名稱進行硬編碼，您能夠重用這些名稱。BeanNames由SpringDataCouchbase提供。例如，您能夠自定義要使用的轉換器，以下所示：
@Configuration
public class SomeConfiguration {
@Bean(BeanNames.COUCHBASE_CUSTOM_CONVERSIONS)
public CustomConversions myCustomConversions() {
return new CustomConversions(...);
}
// ...
}
|
| 若是您但願徹底繞過SpringDataCouchbase的自動配置，請提供您本身的實現 |
30.9 LDAP
LDAP(輕量級目錄訪問協議)是一種開放的、與供應商無關的、行業標準的應用程序協議，用於經過IP網絡訪問和維護分佈式目錄信息服務。Spring Boot爲任何兼容的ldap服務器提供自動配置，以及對內存中嵌入式ldap服務器的支持。無邊.
LDAP抽象由春季數據LDAP。有一個spring-boot-starter-data-ldap用於以方便的方式收集依賴項的「初學者」。
30.9.1鏈接到LDAP服務器
若要鏈接到LDAP服務器，請確保在spring-boot-starter-data-ldap「起始」或spring-ldap-core而後在applicy.properties中聲明服務器的URL，以下面的示例所示：
spring.ldap.urls=ldap://myserver:1235 spring.ldap.username=admin spring.ldap.password=secret
若是須要自定義鏈接設置，能夠使用spring.ldap.base和spring.ldap.base-environment財產。
阿LdapContextSource是基於這些設置自動配置的。若是您須要自定義它，例如使用PooledContextSource，您仍然能夠注入自動配置的LdapContextSource。確保標記您的定製ContextSource如@Primary以便自動配置LdapTemplate用它。
30.9.2 Spring數據LDAP存儲庫
Spring數據包括對LDAP的存儲庫支持。有關SpringDataLDAP的詳細信息，請參閱參考文獻.
您還能夠注入一個自動配置的LdapTemplate實例，與任何其餘SpringBean同樣，以下面的示例所示：
@Component
public class MyBean {
private final LdapTemplate template;
@Autowired
public MyBean(LdapTemplate template) {
this.template = template;
}
// ...
}
30.9.3嵌入式內存LDAP服務器
出於測試目的，SpringBoot支持自動配置內存中的ldap服務器。無邊。若要配置服務器，請將依賴項添加到com.unboundid:unboundid-ldapsdk並聲明base-dn財產以下：
spring.ldap.embedded.base-dn=dc=spring,dc=io
|
| 能夠定義多個基DN值，可是，因爲可分辨名稱一般包含逗號，所以必須使用正確的表示法來定義它們。 在YAML文件中，能夠使用YAML列表符號： spring.ldap.embedded.base-dn: - dc=spring,dc=io - dc=pivotal,dc=io 在屬性文件中，必須將索引做爲屬性名稱的一部分： spring.ldap.embedded.base-dn[0]=dc=spring,dc=io spring.ldap.embedded.base-dn[1]=dc=pivotal,dc=io |
默認狀況下，服務器在隨機端口上啓動並觸發常規LDAP支持。不須要指定spring.ldap.urls財產。
若是有一個schema.ldif文件在您的類路徑上，它用於初始化服務器。若是要從其餘資源加載初始化腳本，也能夠使用spring.ldap.embedded.ldif財產。
默認狀況下，標準模式用於驗證LDIF檔案。經過設置spring.ldap.embedded.validation.enabled財產。若是您有自定義屬性，則能夠使用spring.ldap.embedded.validation.schema若要定義自定義屬性類型或對象類，請執行如下操做。
30.10 InfluxDB
InfluxDB它是一個開放源碼的時間序列數據庫，用於快速、高可用性地存儲和檢索諸如操做監視、應用度量、物聯網傳感器數據和實時分析等領域的時間序列數據。
30.10.1鏈接到InfluxDB
Spring Boot自動配置InfluxDB實例，只要influxdb-java客戶端位於類路徑上，而且設置了數據庫的URL，以下面的示例所示：
spring.influx.url=http://172.0.0.1:8086
若是鏈接到InFluxDB須要用戶和密碼，則能夠將spring.influx.user和spring.influx.password相應的屬性。
InfluxDB依賴於OkHttp。若是您須要調優http客戶端InfluxDB在幕後使用，您能夠註冊OkHttpClient.Builder豆子
31.緩存
SpringFramework支持透明地嚮應用程序添加緩存。在其核心，抽象將緩存應用於方法，從而減小了基於緩存中可用信息的執行次數。緩存邏輯是透明地應用的，對調用方沒有任何干擾。Spring Boot自動配置緩存基礎結構，只要經過@EnableCaching註釋
|
| 檢查相關部分更多細節，請參考Spring框架。 |
簡而言之，向服務的操做添加緩存就像將相關注釋添加到其方法中同樣簡單，以下面的示例所示：
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;
@Component
public class MathService {
@Cacheable("piDecimals")
public int computePiDecimal(int i) {
// ...
}
}
此示例演示如何在可能代價高昂的操做上使用緩存。在調用computePiDecimal，抽象將在piDecimals匹配i爭論。若是找到一個條目，緩存中的內容將當即返回給調用方，而且不會調用該方法。不然，將調用該方法，並在返回值以前更新緩存。
|
謹慎 |
|---|---|
| 您還能夠使用標準的jsr-107(Jcache)註釋(如 |
若是沒有添加任何特定的緩存庫，則SpringBoot自動配置簡單提供者它使用內存中的併發映射。當須要緩存時(如piDecimals)，此提供程序將爲您建立該提供程序。簡單的提供程序並非真正推薦用於生產使用的，可是它對於開始使用和確保您理解這些特性是很好的。當您決定使用緩存提供程序時，請確保閱讀其文檔，以瞭解如何配置應用程序使用的緩存。幾乎全部提供程序都要求您顯式地配置在應用程序中使用的每一個緩存。有些提供了一種自定義由spring.cache.cache-names財產。
|
31.1支持緩存提供者
緩存抽象沒有提供實際的存儲，而是依賴於由org.springframework.cache.Cache和org.springframework.cache.CacheManager接口。
若是還沒有定義類型的beanCacheManager或者是CacheResolver命名cacheResolver(見CachingConfigurer)，SpringBoot嘗試檢測如下提供程序(按指定的順序)：
- 屬屬
- JCache(JSR-107)(EhCache 三、Hazelcast、Infinisan等)
- EhCache 2.x
- 哈澤爾卡斯特
- 英菲尼斯潘
- Couchbase
- 雷迪斯
- 咖啡因
- 簡約
|
| 也有可能力設置 |
|
| 使用 |
若是CacheManager是由SpringBoot自動配置的，您能夠在它徹底初始化以前進一步調優它的配置，方法是公開一個實現CacheManagerCustomizer接口。下面的示例設置一個標誌，表示應該將空值傳遞給基礎映射：
@Bean
public CacheManagerCustomizer<ConcurrentMapCacheManager> cacheManagerCustomizer() {
return new CacheManagerCustomizer<ConcurrentMapCacheManager>() {
@Override
public void customize(ConcurrentMapCacheManager cacheManager) {
cacheManager.setAllowNullValues(false);
}
};
}
|
| 在前面的示例中，自動配置 |
31.1.1通用
若是上下文定義至少一org.springframework.cache.Cache豆子一個CacheManager將建立該類型的全部bean。
31.1.2 JCache(JSR-107)
JCache經過存在的javax.cache.spi.CachingProvider在類路徑(即，與JSR-107兼容的緩存庫存在於類路徑上)上，JCacheCacheManager由spring-boot-starter-cache「初學者」。有各類兼容的庫，SpringBoot爲Ehcache 三、Hazelcast和InfinisPAN提供了依賴關係管理。任何其餘兼容的庫也能夠添加。
可能存在多個提供程序，在這種狀況下，必須顯式指定提供程序。即便JSR-107標準沒有強制執行一種標準的方法來定義配置文件的位置，SpringBoot也會盡最大努力適應設置帶有實現細節的緩存，以下面的示例所示：
# Only necessary if more than one provider is present spring.cache.jcache.provider=com.acme.MyCachingProvider spring.cache.jcache.config=classpath:acme.xml
|
| 當緩存庫同時提供本機實現和JSR-107支持時，SpringBoot更喜歡JSR-107支持，所以若是切換到不一樣的JSR-107實現，也能夠使用相同的特性。 |
|
| 春靴對Hazelcast的通常支持。若是一我的 |
有兩種方法能夠自定義基礎javax.cache.cacheManager:
- 能夠在啓動時經過設置
spring.cache.cache-names財產。若是一個習俗javax.cache.configuration.Configurationbean是定義的，它用於自定義它們。 org.springframework.boot.autoconfigure.cache.JCacheManagerCustomizer類的引用調用bean。CacheManager徹底定製。
|
| 若是一個標準 |
31.1.3 EhCache 2.x
EhCache若是一個名爲ehcache.xml能夠在類路徑的根部找到。若是找到EhCache 2.x，則EhCacheCacheManager由spring-boot-starter-cache「初學者」用於引導緩存管理器。還能夠提供另外一個配置文件，如如下示例所示：
spring.cache.ehcache.config=classpath:config/another-config.xml
31.1.4哈澤爾廣播公司
春靴對Hazelcast的通常支持。若是HazelcastInstance已自動配置，它將自動包裝在CacheManager.
31.1.5無限
英菲尼斯潘沒有默認配置文件位置，所以必須顯式指定。不然，將使用默認引導程序。
spring.cache.infinispan.config=infinispan.xml
能夠在啓動時經過設置spring.cache.cache-names財產。若是一個習俗ConfigurationBuilderbean是定義的，它用於自定義緩存。
|
| InfinisPAN在SpringBoot中的支持僅限於嵌入式模式，是至關基礎的。若是您想要更多的選項，您應該使用正式的InfinispanSpringBootStart。看見英菲尼斯潘文件更多細節。 |
31.1.6 Couchbase
若是CouchbaseJava客戶端和couchbase-spring-cache實現是可用的，Couchbase是配置..CouchbaseCacheManager是自動配置的。還能夠在啓動時經過設置spring.cache.cache-names財產。這些緩存在Bucket那是自動配置的。你能夠的。也在另外一個上建立額外的緩存Bucket經過使用自定義程序。假設您須要兩個緩存(cache1和cache2)關於「主要」Bucket還有一個(cache3)具備自定義時間的緩存，在「另外一個」上生存2秒。Bucket。您能夠經過配置建立前兩個緩存，以下所示：
spring.cache.cache-names=cache1,cache2
而後，您能夠定義@Configuration類來配置額外的Bucket而cache3緩存以下：
@Configuration
public class CouchbaseCacheConfiguration {
private final Cluster cluster;
public CouchbaseCacheConfiguration(Cluster cluster) {
this.cluster = cluster;
}
@Bean
public Bucket anotherBucket() {
return this.cluster.openBucket("another", "secret");
}
@Bean
public CacheManagerCustomizer<CouchbaseCacheManager> cacheManagerCustomizer() {
return c -> {
c.prepareCache("cache3", CacheBuilder.newInstance(anotherBucket())
.withExpiration(2));
};
}
}
此示例配置重用Cluster這是經過自動配置建立的。
31.1.7 Redis
若是雷迪斯是否可用並配置，則RedisCacheManager是自動配置的。在啓動時能夠經過設置spring.cache.cache-names屬性和緩存默認值能夠經過使用spring.cache.redis.*財產。例如，下面的配置建立cache1和cache2緩存活下去的時間10分鐘：
spring.cache.cache-names=cache1,cache2 spring.cache.redis.time-to-live=600000
|
| 默認狀況下，會添加一個鍵前綴，這樣，若是兩個單獨的緩存使用相同的鍵，Redis就不會有重疊的鍵，而且不能返回無效的值。若是您建立本身的設置，咱們強烈建議將此設置保持爲啓用狀態。 |
|
| 能夠經過添加 |
31.1.8咖啡因
咖啡因Java 8重寫了番石榴的緩存，取代了對番石榴的支持。若是咖啡因存在，CaffeineCacheManager(由spring-boot-starter-cache是自動配置的。能夠在啓動時經過設置spring.cache.cache-names屬性，而且能夠經過如下之一進行自定義(按指定的順序)：
- 由
spring.cache.caffeine.spec - A
com.github.benmanes.caffeine.cache.CaffeineSpecbean被定義爲 - A
com.github.benmanes.caffeine.cache.Caffeinebean被定義爲
例如，下面的配置建立cache1和cache2緩存的最大大小爲500，而且活下去的時間10分鐘
spring.cache.cache-names=cache1,cache2 spring.cache.caffeine.spec=maximumSize=500,expireAfterAccess=600s
若是com.github.benmanes.caffeine.cache.CacheLoaderbean被定義，它將自動關聯到CaffeineCacheManager。由於CacheLoader將與全緩存管理器管理的緩存，它必須定義爲CacheLoader<Object, Object>。自動配置忽略任何其餘泛型類型.
31.1.9簡單
若是找不到其餘提供程序，則使用ConcurrentHashMap在配置緩存存儲時。若是應用程序中沒有緩存庫，這是默認的。默認狀況下，緩存是根據須要建立的，但能夠經過設置cache-names財產。例如，若是你只想cache1和cache2緩存，設置cache-names財產以下：
spring.cache.cache-names=cache1,cache2
若是這樣作，而且應用程序使用未列出的緩存，那麼當須要緩存時，它會在運行時失敗，而不是在啓動時失敗。若是使用未聲明的緩存，這與「真實」緩存提供程序的行爲方式相似。
31.1.10無
何時@EnableCaching在您的配置中，還須要一個合適的緩存配置。若是須要在某些環境中徹底禁用緩存，請強制緩存類型爲none若要使用NO-OP實現，請參見如下示例：
spring.cache.type=none
三十二信息傳遞
Spring框架爲與消息傳遞系統集成提供了普遍的支持，簡化了JMSAPI的使用JmsTemplate異步接收消息的完整基礎結構。SpringAMQP爲高級消息隊列協議提供了相似的功能集。Spring Boot還提供了自動配置選項。RabbitTemplate還有拉比·MQ。SpringWebSocket內置了對STOMP消息傳遞的支持，SpringBoot經過啓動器和少許的自動配置對此提供了支持。SpringBoot還支持ApacheKafka。
32.1 JMS
這，這個，那，那個javax.jms.ConnectionFactory接口提供了建立javax.jms.Connection用於與JMS代理交互。儘管春天須要一個ConnectionFactory要使用JMS，一般不須要本身直接使用它，而是能夠依賴更高級別的消息抽象。(見相關部分)的詳細信息。)SpringBoot還自動配置發送和接收消息所需的基礎設施。
32.1.1 ActiveMQ支持
何時ActiveMQ在類路徑上可用，SpringBoot也能夠配置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
默認狀況下，CachingConnectionFactory包裹本地人ConnectionFactory中的可由外部配置屬性控制的合理設置。spring.jms.*:
spring.jms.cache.session-cache-size=5
若是您但願使用本機池，能夠經過向org.messaginghub:pooled-jms和配置JmsPoolConnectionFactory所以，如如下示例所示：
spring.activemq.pool.enabled=true spring.activemq.pool.max-connections=50
|
| 看見 |
默認狀況下，若是還不存在ActiveMQ，則ActiveMQ將建立一個目的地，以便根據其提供的名稱解析目的地。
32.1.2 Artemis支持
Spring Boot能夠自動配置ConnectionFactory當它發現阿耳特米斯在類路徑上可用。若是存在代理，則會自動啓動和配置嵌入式代理(除非模式屬性已顯式設置)。支持的模式以下embedded(明確表示須要嵌入代理，若是類路徑上沒法使用代理，則應發生錯誤)native(使用netty運輸協議)。配置後者時，SpringBoot將配置ConnectionFactory它鏈接到具備默認設置的本地計算機上運行的代理。
|
| 若是你用 |
中的外部配置屬性控制artemis配置。spring.artemis.*。例如，您能夠在application.properties:
spring.artemis.mode=native spring.artemis.host=192.168.1.210 spring.artemis.port=9876 spring.artemis.user=admin spring.artemis.password=secret
嵌入代理時，您能夠選擇是否要啓用持久性，並列出應該可用的目的地。能夠將它們指定爲逗號分隔的列表，以便使用默認選項建立它們，或者能夠定義類型的bean(S)。org.apache.activemq.artemis.jms.server.config.JMSQueueConfiguration或org.apache.activemq.artemis.jms.server.config.TopicConfiguration，分別用於高級隊列和主題配置。
默認狀況下，CachingConnectionFactory包裹本地人ConnectionFactory中的可由外部配置屬性控制的合理設置。spring.jms.*:
spring.jms.cache.session-cache-size=5
若是您但願使用本機池，能夠經過向org.messaginghub:pooled-jms和配置JmsPoolConnectionFactory所以，如如下示例所示：
spring.artemis.pool.enabled=true spring.artemis.pool.max-connections=50
看見ArtemisProperties得到更多支持的選項。
不涉及JNDI查找，目的地將根據其名稱進行解析，使用name屬性在Artemis配置中或經過配置提供的名稱中。
32.1.3使用JNDI鏈接工廠
若是在應用程序服務器中運行應用程序，SpringBoot嘗試定位JMSConnectionFactory經過使用JNDI。默認狀況下，java:/JmsXA和java:/XAConnectionFactory檢查位置。您能夠使用spring.jms.jndi-name若是須要指定替代位置，請建立如下示例：
spring.jms.jndi-name=java:/MyConnectionFactory
32.1.4發送消息
春天的JmsTemplate是自動配置的，您能夠直接將它自動放入本身的bean中，以下面的示例所示：
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;
}
// ...
}
|
|
|
32.1.5接收消息
當JMS基礎設施存在時，任何bean均可以用@JmsListener若要建立偵聽器端點，請執行如下操做。若是沒有JmsListenerContainerFactory已定義了默認配置，則會自動配置默認配置。若是DestinationResolver或者是MessageConverterbean是定義的，它會自動與默認工廠相關聯。
默認狀況下，默認工廠是事務性的。若是您在一個基礎設施中運行，其中JtaTransactionManager默認狀況下，它與偵聽器容器相關聯。若是沒有，則sessionTransacted已啓用標誌。在後一種狀況下，能夠經過添加如下方法將本地數據存儲事務與傳入消息的處理相關聯@Transactional在偵聽器方法(或其委託)上。這確保本地事務完成後確認傳入消息。這還包括髮送在同一JMS會話上執行的響應消息。
下面的組件在someQueue目的地：
@Component
public class MyBean {
@JmsListener(destination = "someQueue")
public void processMessage(String content) {
// ...
}
}
|
| 看見.的Javadoc |
若是您須要建立更多JmsListenerContainerFactory實例，或者若是要覆蓋默認值，SpringBoot將提供一個DefaultJmsListenerContainerFactoryConfigurer能夠用來初始化DefaultJmsListenerContainerFactory具備與自動配置的設置相同的設置。
例如，下面的示例公開另外一個使用特定MessageConverter:
@Configuration
static class JmsConfiguration {
@Bean
public DefaultJmsListenerContainerFactory myFactory(
DefaultJmsListenerContainerFactoryConfigurer configurer) {
DefaultJmsListenerContainerFactory factory =
new DefaultJmsListenerContainerFactory();
configurer.configure(factory, connectionFactory());
factory.setMessageConverter(myMessageConverter());
return factory;
}
}
那麼你能夠在任何地方使用這個工廠。@JmsListener-附加說明的方法以下：
@Component
public class MyBean {
@JmsListener(destination = "someQueue", containerFactory="myFactory")
public void processMessage(String content) {
// ...
}
}
32.2 AMQP
高級消息隊列協議(AMQP)是一種面向消息中間件的平臺中立、線級協議.SpringAMQP項目將核心Spring概念應用於基於AMQP的消息傳遞解決方案的開發。SpringBoot爲經過RabbitMQ使用AMQP提供了一些方便，包括spring-boot-starter-amqp「初學者」。
32.2.1兔MQ支持
兔MQ是基於AMQP協議的輕量級、可靠、可伸縮和可移植的消息代理。彈簧使用RabbitMQ經過AMQP協議進行通訊。
中的外部配置屬性控制RabbitMQ配置。spring.rabbitmq.*。例如，您能夠在application.properties:
spring.rabbitmq.host=localhost spring.rabbitmq.port=5672 spring.rabbitmq.username=admin spring.rabbitmq.password=secret
若是ConnectionNameStrategybean存在於上下文中，它將自動用於命名由自動配置的鏈接。ConnectionFactory。看見RabbitProperties有關更多受支持的選項。
|
| 看見理解AMQP，RabbitMQ使用的協議更多細節。 |
32.2.2發送消息
春天的AmqpTemplate和AmqpAdmin是自動配置的，您能夠直接將它們自動放入本身的bean中，以下面的示例所示：
import org.springframework.amqp.core.AmqpAdmin;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class MyBean {
private final AmqpAdmin amqpAdmin;
private final AmqpTemplate amqpTemplate;
@Autowired
public MyBean(AmqpAdmin amqpAdmin, AmqpTemplate amqpTemplate) {
this.amqpAdmin = amqpAdmin;
this.amqpTemplate = amqpTemplate;
}
// ...
}
|
|
|
若有須要，任何org.springframework.amqp.core.Queue它被定義爲bean自動用於在RabbitMQ實例上聲明相應的隊列。
若要重試操做，能夠在AmqpTemplate(例如，在代理鏈接丟失時)：
spring.rabbitmq.template.retry.enabled=true spring.rabbitmq.template.retry.initial-interval=2s
默認狀況下將禁用重試。您還能夠自定義RetryTemplate以編程方式聲明RabbitRetryTemplateCustomizer豆子
32.2.3接收消息
當存在兔子基礎設施時，任何bean均可以用@RabbitListener若要建立偵聽器端點，請執行如下操做。若是沒有RabbitListenerContainerFactory已定義爲默認值。SimpleRabbitListenerContainerFactory自動配置，您能夠使用spring.rabbitmq.listener.type財產。若是MessageConverter或者是MessageRecovererbean是定義的，它會自動與默認工廠相關聯。
下面的示例組件在someQueue排隊：
@Component
public class MyBean {
@RabbitListener(queues = "someQueue")
public void processMessage(String content) {
// ...
}
}
|
| 看見.的Javadoc |
若是您須要建立更多RabbitListenerContainerFactory實例，或者若是要覆蓋默認值，SpringBoot將提供一個SimpleRabbitListenerContainerFactoryConfigurer和一個DirectRabbitListenerContainerFactoryConfigurer能夠用來初始化SimpleRabbitListenerContainerFactory和一個DirectRabbitListenerContainerFactory具備與自動配置使用的工廠相同的設置。
|
| 您所選擇的容器類型並不重要。這兩個bean由自動配置公開。 |
例如，下面的配置類公開了另外一個使用特定MessageConverter:
@Configuration
static class RabbitConfiguration {
@Bean
public SimpleRabbitListenerContainerFactory myFactory(
SimpleRabbitListenerContainerFactoryConfigurer configurer) {
SimpleRabbitListenerContainerFactory factory =
new SimpleRabbitListenerContainerFactory();
configurer.configure(factory, connectionFactory);
factory.setMessageConverter(myMessageConverter());
return factory;
}
}
那麼你能夠在任何地方使用這個工廠。@RabbitListener-附加說明的方法以下：
@Component
public class MyBean {
@RabbitListener(queues = "someQueue", containerFactory="myFactory")
public void processMessage(String content) {
// ...
}
}
您能夠啓用重試來處理偵聽器拋出異常的狀況。默認狀況下，RejectAndDontRequeueRecoverer，但您能夠定義MessageRecoverer你本身的。當重試用盡時，消息將被拒絕，若是代理被配置爲刪除或路由到死信交換。默認狀況下，將禁用重試。您還能夠自定義RetryTemplate以編程方式聲明RabbitRetryTemplateCustomizer豆子
|
重要 |
|---|---|
| 默認狀況下，若是禁用重試並引起異常，則將無限期地從新嘗試傳遞。能夠經過兩種方式修改此行爲： |
32.3 Apache Kafka支持
阿帕奇卡夫卡的自動配置支持spring-kafka項目。
中的外部配置屬性控制Kafka配置。spring.kafka.*。例如，您能夠在application.properties:
spring.kafka.bootstrap-servers=localhost:9092 spring.kafka.consumer.group-id=myGroup
|
| 若要在啓動時建立主題，請添加類型爲 |
看見KafkaProperties得到更多支持的選項。
32.3.1發送信息
春天的KafkaTemplate是自動配置的，您能夠直接在本身的bean中自動配置它，以下面的示例所示：
@Component
public class MyBean {
private final KafkaTemplate kafkaTemplate;
@Autowired
public MyBean(KafkaTemplate kafkaTemplate) {
this.kafkaTemplate = kafkaTemplate;
}
// ...
}
|
| 若是財產 |
32.3.2接收消息
當apache Kafka基礎設施存在時，任何bean均可以用@KafkaListener若要建立偵聽器端點，請執行如下操做。若是沒有KafkaListenerContainerFactory已經定義好了，默認的鍵將自動配置爲spring.kafka.listener.*.
下面的組件在someTopic題目：
@Component
public class MyBean {
@KafkaListener(topics = "someTopic")
public void processMessage(String content) {
// ...
}
}
若是KafkaTransactionManagerbean是定義的，它自動與容器工廠相關聯。相似地，若是RecordMessageConverter, ErrorHandler或AfterRollbackProcessorbean是定義的，它會自動與默認工廠相關聯。
|
| 風俗 |
32.3.3 Kafka流
SpringforApacheKafka提供了一個工廠bean來建立一個StreamsBuilder對象並管理其流的生命週期。Spring Boot自動配置所需的KafkaStreamsConfiguration豆子kafka-streams在類路徑上，Kafka流經過@EnableKafkaStreams註釋
啓用Kafka流意味着必須設置應用程序id和引導服務器。前者能夠使用spring.kafka.streams.application-id，拖欠spring.application.name若是沒有設定。後者能夠全局設置，也能夠僅針對流進行特殊重寫。
使用專用屬性能夠得到其餘幾個屬性；其餘任意的Kafka屬性能夠使用spring.kafka.streams.properties命名空間。另見第32.3.4節，「額外的Kafka屬性」想了解更多信息。
要使用工廠bean，只需鏈接StreamsBuilder進入你的@Bean如如下示例所示：
@Configuration
@EnableKafkaStreams
static class KafkaStreamsExampleConfiguration {
@Bean
public KStream<Integer, String> kStream(StreamsBuilder streamsBuilder) {
KStream<Integer, String> stream = streamsBuilder.stream("ks1In");
stream.map((k, v) -> new KeyValue<>(k, v.toUpperCase())).to("ks1Out",
Produced.with(Serdes.Integer(), new JsonSerde<>()));
return stream;
}
}
默認狀況下，由StreamBuilder對象自動啓動。您能夠使用spring.kafka.streams.auto-startup財產。
32.3.4額外的Kafka屬性
自動配置支持的屬性顯示在附錄A，通用應用特性。注意，在大多數狀況下，這些屬性(連字符或CamelCase)直接映射到ApacheKafka虛線屬性。有關詳細信息，請參閱ApacheKafka文檔。
前幾個屬性適用於全部組件(生產者、消費者、管理員和流)，但若是您但願使用不一樣的值，則能夠在組件級別指定。ApacheKafka指定的屬性具備高、中或低的重要性。SpringBoot自動配置支持全部高重要性屬性、一些選定的中、低屬性以及沒有默認值的任何屬性。
只有一部分由Kafka支持的屬性能夠經過KafkaProperties班級，等級若是但願使用不直接支持的其餘屬性配置生產者或使用者，請使用如下屬性：
spring.kafka.properties.prop.one=first spring.kafka.admin.properties.prop.two=second spring.kafka.consumer.properties.prop.three=third spring.kafka.producer.properties.prop.four=fourth spring.kafka.streams.properties.prop.five=fifth
這設置了公共prop.one卡夫卡first(適用於生產者、消費者和管理員)prop.two管理屬性second，prop.three消費者財產third，prop.four生產者財產fourth而prop.five流屬性fifth.
您還能夠配置SpringKafkaJsonDeserializer詳情以下：
spring.kafka.consumer.value-deserializer=org.springframework.kafka.support.serializer.JsonDeserializer spring.kafka.consumer.properties.spring.json.value.default.type=com.example.Invoice spring.kafka.consumer.properties.spring.json.trusted.packages=com.example,org.acme
相似地，您能夠禁用JsonSerializer在標頭中發送類型信息的默認行爲：
spring.kafka.producer.value-serializer=org.springframework.kafka.support.serializer.JsonSerializer spring.kafka.producer.properties.spring.json.add.type.headers=false
|
重要 |
|---|---|
| 以這種方式設置的屬性覆蓋SpringBoot顯式支持的任何配置項。 |
33.調用REST服務RestTemplate
若是須要從應用程序調用遠程REST服務，能夠使用Spring框架的RestTemplate班級，等級自RestTemplate實例在使用以前一般須要進行自定義，SpringBoot不提供任何單獨的自動配置。RestTemplate豆子可是，它會自動配置一個RestTemplateBuilder，能夠用來建立RestTemplate須要時執行實例。自動配置RestTemplateBuilder確保明智HttpMessageConverters適用於RestTemplate實例。
下面的代碼顯示了一個典型的示例：
@Service
public class MyService {
private final RestTemplate restTemplate;
public MyService(RestTemplateBuilder restTemplateBuilder) {
this.restTemplate = restTemplateBuilder.build();
}
public Details someRestCall(String name) {
return this.restTemplate.getForObject("/{name}/details", Details.class, name);
}
}
|
|
|
33.1餐廳模板定製
有三種主要的方法RestTemplate自定義，取決於您但願自定義應用的範圍。
若要使任何自定義的範圍儘量窄，請插入自動配置的RestTemplateBuilder而後根據須要調用它的方法。每一個方法調用返回一個新的RestTemplateBuilder實例，所以自定義隻影響構建器的這種使用。
若要進行應用程序範圍內的附加定製，請使用RestTemplateCustomizer豆子全部這些bean都會自動註冊到自動配置的RestTemplateBuilder並應用於任何用它構建的模板。
下面的示例顯示了一個自定義程序，該自定義程序配置除如下以外的全部主機的代理使用。192.168.0.5:
static class ProxyCustomizer implements RestTemplateCustomizer {
@Override
public void customize(RestTemplate restTemplate) {
HttpHost proxy = new HttpHost("proxy.example.com");
HttpClient httpClient = HttpClientBuilder.create()
.setRoutePlanner(new DefaultProxyRoutePlanner(proxy) {
@Override
public HttpHost determineProxy(HttpHost target,
HttpRequest request, HttpContext context)
throws HttpException {
if (target.getHostName().equals("192.168.0.5")) {
return null;
}
return super.determineProxy(target, request, context);
}
}).build();
restTemplate.setRequestFactory(
new HttpComponentsClientHttpRequestFactory(httpClient));
}
}
最後，最極端的(並且不多使用)選項是建立本身的RestTemplateBuilder豆子這樣作能夠關閉RestTemplateBuilder並阻止任何RestTemplateCustomizer被使用的豆子。
34.調用REST服務WebClient
若是類路徑上有SpringWebFlux，也能夠選擇使用WebClient呼叫遠程休息服務。相比較RestTemplate，這個客戶有一種功能更強的感受和徹底的反應。您能夠了解更多關於WebClient在奉獻中Spring框架文檔中的.
Spring Boot建立並預先配置WebClient.Builder對於您；強烈建議將其注入組件並使用它建立WebClient實例。SpringBoot將構建器配置爲共享HTTP資源，以與服務器相同的方式反映編解碼器的設置(請參見WebFlux HTTP編解碼器自動配置)，還有更多。
下面的代碼顯示了一個典型的示例：
@Service
public class MyService {
private final WebClient webClient;
public MyService(WebClient.Builder webClientBuilder) {
this.webClient = webClientBuilder.baseUrl("http://example.org").build();
}
public Mono<Details> someRestCall(String name) {
return this.webClient.get().uri("/{name}/details", name)
.retrieve().bodyToMono(Details.class);
}
}
34.1 WebClient運行時
Spring Boot將自動檢測哪一個ClientHttpConnector開車WebClient，取決於應用程序類路徑上可用的庫。
這，這個，那，那個spring-boot-starter-webflux取決於io.projectreactor.netty:reactor-netty默認狀況下，這會同時帶來服務器和客戶端實現。若是選擇使用Jetty做爲反應性服務器，則應添加對JettyReactiveHTTP客戶端庫的依賴關係，org.eclipse.jetty:jetty-reactive-httpclient，由於它將自動與服務器共享HTTP資源。
開發人員能夠經過定義本身的ClientHttpConnector在這種狀況下，而且取決於您選擇的HTTP客戶機庫，您還應該定義一個資源工廠bean來管理該客戶端的HTTP資源。例如，ReactorResourceFactory用於反應堆Netty客戶端。
您能夠了解更多關於WebClientSpring框架參考文檔中的配置選項.
34.2 Web客戶端定製
有三種主要的方法WebClient自定義，取決於您但願自定義應用的範圍。
若要使任何自定義的範圍儘量窄，請插入自動配置的WebClient.Builder而後根據須要調用它的方法。WebClient.Builder實例是有狀態的：構建器上的任何更改都反映在隨後使用它建立的全部客戶端中。若是但願使用相同的構建器建立多個客戶端，還能夠考慮使用WebClient.Builder other = builder.clone();.
對全部用戶進行應用程序範圍的、附加的自定義。WebClient.Builder實例，您能夠聲明WebClientCustomizer和更改WebClient.Builder局部注射點。
最後，您能夠回到原來的api並使用WebClient.create()。在這種狀況下，沒有自動配置或WebClientCustomizer被應用。
35.驗證
只要JSR-303實現(例如Hibernate驗證器)在類路徑上，Bean Validation1.1支持的方法驗證功能就會自動啓用。這容許使用bean方法進行註釋。javax.validation對其參數和/或其返回值的約束。具備此類註釋方法的目標類須要用@Validated類型級別的註釋，以便搜索它們的方法以查找內聯約束註釋。
例如，如下服務觸發第一個參數的驗證，確保其大小介於8到10之間：
@Service
@Validated
public class MyBean {
public Archive findByCodeAndAuthor(@Size(min = 8, max = 10) String code,
Author author) {
...
}
}
36.發送電子郵件
Spring框架爲發送電子郵件提供了一個簡單的抽象，使用JavaMailSender接口，SpringBoot提供了它的自動配置以及一個啓動模塊.
|
| 見參考文獻有關如何使用 |
若是spring.mail.host以及相關的圖書館(由spring-boot-starter-mail)是可用的，默認狀況下JavaMailSender若是不存在，則建立。屬性中的配置項能夠進一步自定義發送方。spring.mail命名空間。看見MailProperties更多細節。
特別是，某些默認超時值是無限的，您可能但願更改此值，以免線程被沒有響應的郵件服務器阻塞，以下面的示例所示：
spring.mail.properties.mail.smtp.connectiontimeout=5000 spring.mail.properties.mail.smtp.timeout=3000 spring.mail.properties.mail.smtp.writetimeout=5000
還能夠配置JavaMailSender現有的Session來自JNDI：
spring.mail.jndi-name=mail/Session
當jndi-name設置後，它將優先於全部其餘與會話相關的設置。
37.使用JTA的分佈式事務
Spring Boot支持跨多個XA資源的分佈式JTA事務，方法是使用Atomikos或比特羅尼嵌入式事務管理器當部署到適當的JavaEE應用服務器時，也支持JTA事務。
當檢測到JTA環境時，Spring的JtaTransactionManager用於管理事務。自動配置的JMS、DataSource和JPAbean被升級，以支持XA事務。您能夠使用標準的Spring成語，例如@Transactional，以參與分佈式事務。若是您位於JTA環境中，而且仍然但願使用本地事務，則能夠將spring.jta.enabled財產false若要禁用JTA自動配置，請執行如下操做。
37.1使用Atomikos事務管理器
Atomikos是一個流行的開源事務管理器，能夠嵌入到SpringBoot應用程序中。您能夠使用spring-boot-starter-jta-atomikos啓動引入適當的Atomikos庫。SpringBoot自動配置Atomikos並確保depends-on將設置應用於Springbean以進行正確的啓動和關閉排序。
默認狀況下，Atomikos事務日誌被寫入transaction-logs應用程序主目錄中的目錄(應用程序JAR文件所在的目錄)。您能夠經過設置spring.jta.log-dir你的財產application.properties檔案。屬性以spring.jta.atomikos.properties也可用於自定義AtomikosUserTransactionServiceImp。見AtomikosPropertiesJavadoc得到完整的細節。
|
| 爲了確保多個事務管理器可以安全地協調相同的資源管理器，每一個Atomikos實例必須配置一個惟一的ID。默認狀況下，此ID是運行Atomikos的機器的IP地址。若要確保生產中的惟一性，應配置 |
37.2使用Bitronix事務管理器
比特羅尼是一個流行的開源JTA事務管理器實現。您能夠使用spring-boot-starter-jta-bitronix啓動將適當的Bitronix依賴項添加到項目中。與Atomikos同樣，SpringBoot會自動配置Bitronix並對bean進行後處理，以確保啓動和關閉順序是正確的。
默認狀況下，Bitronix事務日誌文件(part1.btm和part2.btm)寫到transaction-logs應用程序主目錄中的目錄。屬性來自定義此目錄的位置。spring.jta.log-dir財產。屬性以spring.jta.bitronix.properties也綁定到bitronix.tm.Configurationbean，容許徹底自定義。見Bitronix文檔關於細節。
|
| 爲了確保多個事務管理器可以安全地協調相同的資源管理器，每一個Bitronix實例必須配置一個惟一的ID。默認狀況下，此ID是運行Bitronix的機器的IP地址。若要確保生產中的惟一性，應配置 |
37.3使用JavaEE託管事務管理器
若是將SpringBoot應用程序打包爲war或ear文件並將其部署到JavaEE應用服務器上，您能夠使用應用程序服務器的內置事務管理器。SpringBoot試圖經過查看常見的JNDI位置來自動配置事務管理器(java:comp/UserTransaction, java:comp/TransactionManager等等)。若是使用應用服務器提供的事務服務，一般還但願確保全部資源都由服務器管理，並經過JNDI公開。Spring Boot試圖經過查找ConnectionFactory在JNDI路徑上(java:/JmsXA或java:/XAConnectionFactory)，您能夠使用spring.datasource.jndi-name財產若要配置您的DataSource.
37.4混合XA和非XA JMS鏈接
當使用JTA時，主JMSConnectionFactorybean是XA感知的，並參與分佈式事務。在某些狀況下，您可能但願使用非XA處理某些JMS消息。ConnectionFactory。例如，JMS處理邏輯可能比XA超時時間更長。
若是您想使用非XAConnectionFactory，您能夠將nonXaJmsConnectionFactory而不是@Primary jmsConnectionFactory豆子爲了保持一致性，jmsConnectionFactorybean還經過使用bean別名提供。xaJmsConnectionFactory.
下面的示例演示如何注入ConnectionFactory實例：
// Inject the primary (XA aware) ConnectionFactory
@Autowired
private ConnectionFactory defaultConnectionFactory;
// Inject the XA aware ConnectionFactory (uses the alias and injects the same as above)
@Autowired
@Qualifier("xaJmsConnectionFactory")
private ConnectionFactory xaConnectionFactory;
// Inject the non-XA aware ConnectionFactory
@Autowired
@Qualifier("nonXaJmsConnectionFactory")
private ConnectionFactory nonXaConnectionFactory;
37.5支持替代嵌入式事務管理器
這，這個，那，那個XAConnectionFactoryWrapper和XADataSourceWrapper接口可用於支持其餘嵌入式事務管理器。接口負責包裝。XAConnectionFactory和XADataSource豆類，並將它們做爲常規公開。ConnectionFactory和DataSourcebean，它透明地註冊在分佈式事務中。DataSource和JMS自動配置使用JTA變體，只要您有JtaTransactionManager中註冊的bean和適當的XA包裝bean。ApplicationContext.
這，這個，那，那個BitronixXAConnectionFactoryWrapper和BitronixXADataSourceWrapper提供關於如何編寫XA包裝器的良好示例。
38.哈澤爾卡斯特
若是哈澤爾卡斯特在類路徑上，並找到合適的配置，SpringBoot自動配置HazelcastInstance你能夠在你的應用程序中注入。
若是定義com.hazelcast.config.ConfigBeanSpring Boot使用這個。若是您的配置定義了實例名，SpringBoot將嘗試定位一個現有實例，而不是建立一個新實例。
您還能夠指定hazelcast.xml要經過配置使用的配置文件，如如下示例所示：
spring.hazelcast.config=classpath:config/my-hazelcast.xml
不然，SpringBoot嘗試從默認位置查找Hazelcast配置：hazelcast.xml在工做目錄或類路徑的根目錄中。咱們還檢查hazelcast.config設置系統屬性。見Hazelcast文件更多細節。
若是hazelcast-client在類路徑中，SpringBoot第一次嘗試經過檢查如下配置選項來建立客戶端：
- A的存在
com.hazelcast.client.config.ClientConfig豆子 - 控件定義的配置文件。
spring.hazelcast.config財產。 - 的存在
hazelcast.client.config系統屬性 - A
hazelcast-client.xml在工做目錄或類路徑的根目錄中。
|
| 春靴也有對Hazelcast的顯式緩存支持。若是啓用了緩存，則 |
39.石英調度器
Spring Boot爲使用石英調度器，包括spring-boot-starter-quartz「初學者」。若是石英可用，Scheduler是自動配置的(經過SchedulerFactoryBean抽象)
將自動獲取下列類型的bean並將其與Scheduler:
JobDetail*定義特定職務。JobDetail實例能夠使用JobBuilderAPICalendar.Trigger*定義什麼時候觸發特定做業。
默認狀況下，內存中的JobStore被利用了。可是，若是DataSourcebean在您的應用程序中可用，若是spring.quartz.job-store-type屬性進行相應配置，如如下示例所示：
spring.quartz.job-store-type=jdbc
當使用JDBC存儲時，模式能夠在啓動時初始化，以下面的示例所示：
spring.quartz.jdbc.initialize-schema=always
|
| 默認狀況下，使用Quartz庫提供的標準腳本檢測和初始化數據庫。還能夠經過設置 |
默認狀況下，配置建立的做業不會覆蓋已從持久性做業存儲區讀取的已註冊做業。若要啓用覆蓋現有做業定義，請將spring.quartz.overwrite-existing-jobs財產。
石英調度器配置能夠使用spring.quartz屬性和SchedulerFactoryBeanCustomizerbean，它容許編程。SchedulerFactoryBean定製。高級Quartz配置屬性能夠使用spring.quartz.properties.*.
|
| 特別是， |
做業能夠定義設置器來注入數據映射屬性。也能夠相似的方式注入常規bean，以下例所示：
public class SampleJob extends QuartzJobBean {
private MyService myService;
private String name;
// Inject "MyService" bean
public void setMyService(MyService myService) { ... }
// Inject the "name" job data property
public void setName(String name) { ... }
@Override
protected void executeInternal(JobExecutionContext context)
throws JobExecutionException {
...
}
}
四十任務執行和調度
在沒有TaskExecutorbean在上下文中，SpringBoot自動配置ThreadPoolTaskExecutor具備可自動關聯到異步任務執行的合理默認值(@EnableAsync)和SpringMVC異步請求處理。
線程池使用8個核心線程，它們能夠根據負載增加和收縮。這些默認設置能夠使用spring.task.execution命名空間，如如下示例所示：
spring.task.execution.pool.max-threads=16 spring.task.execution.pool.queue-capacity=100 spring.task.execution.pool.keep-alive=10s
這將線程池更改成使用有界隊列，以便當隊列滿(100個任務)時，線程池將增長到最多16個線程。當線程空閒10秒時(而不是默認的60秒)，線程的收縮更具備侵略性。
A ThreadPoolTaskScheduler若是須要與計劃的任務執行相關聯，也能夠自動配置(@EnableScheduling)線程池默認使用一個線程，這些設置能夠使用spring.task.scheduling命名空間。
雙雙TaskExecutorBuilder豆和aTaskSchedulerBuilder若是須要建立自定義執行器或調度程序，則能夠在上下文中使用bean。
41.彈簧集成
SpringBoot爲使用彈簧集成，包括spring-boot-starter-integration「初學者」。SpringIntegration經過消息傳遞和其餘傳輸(如HTTP、TCP和其餘傳輸)提供抽象。若是SpringIntegration在類路徑上可用，則經過@EnableIntegration註釋
SpringBoot還配置了一些特性，這些特性是由其餘SpringIntegration模塊的存在觸發的。若是spring-integration-jmx也在類路徑上，消息處理統計信息是經過JMX發佈的。若是spring-integration-jdbc可用時，能夠在啓動時建立默認數據庫架構，以下所示：
spring.integration.jdbc.initialize-schema=always
見IntegrationAutoConfiguration和IntegrationProperties有關更多細節的類。
默認狀況下，若是千分尺meterRegistrybean是存在的，Spring集成度量將經過千分尺進行管理。若是但願使用遺留的SpringIntegration度量，請添加DefaultMetricsFactorybean到應用程序上下文。
42.春季會議
彈簧啓動春季會議用於多種數據存儲的自動配置。在構建Servlet Web應用程序時，能夠自動配置如下存儲：
- JDBC
- 雷迪斯
- 哈澤爾卡斯特
- MongoDB
在構建反應性Web應用程序時，能夠自動配置如下存儲：
- 雷迪斯
- MongoDB
若是類路徑上存在單個Spring會話模塊，SpringBoot將自動使用該存儲實現。若是有多個實現，則必須選擇StoreType來存儲會話。例如，要使用JDBC做爲後端存儲，能夠按照如下方式配置應用程序：
spring.session.store-type=jdbc
|
| 能夠經過設置 |
每一個商店都有特定的附加設置。例如，能夠自定義JDBC存儲的表名，以下面的示例所示：
spring.session.jdbc.table-name=SESSIONS
若要設置會話的超時，能夠使用spring.session.timeout財產。若是未設置該屬性，則自動配置將返回到server.servlet.session.timeout.
43.對JMX的監測和管理
Java管理擴展(JMX)提供了監視和管理應用程序的標準機制。默認狀況下，SpringBoot建立一個MBeanServerID爲mbeanServer並公開任何用SpringJMX註釋的bean(@ManagedResource, @ManagedAttribute，或@ManagedOperation).
見JmxAutoConfiguration獲取更多詳細信息。
44.測試
SpringBoot在測試應用程序時提供了許多實用程序和註釋來幫助您。測試支持由兩個模塊提供：spring-boot-test包含核心項，以及spring-boot-test-autoconfigure支持測試的自動配置。
大多數開發人員使用spring-boot-starter-test「初學者」，它導入SpringBoot測試模塊以及JUnit、AssertJ、Hamcrest和許多其餘有用的庫。
44.1測試範圍依賴項
這，這個，那，那個spring-boot-starter-test「初學者」(在test scope)包含下列提供的庫：
- 聯合股：Java應用程序單元測試的事實標準。
- 彈簧試驗&SpringBootTest：對SpringBoot應用程序的實用程序和集成測試支持。
- AssertJ一個流利的斷言庫。
- 漢克雷斯特匹配器對象庫(也稱爲約束或謂詞)。
- 莫基託Java模擬框架。
- JSONASSERT：JSON的斷言庫。
- JsonPath：用於JSON的XPath。
咱們一般認爲這些公共庫在編寫測試時頗有用。若是這些庫不適合您的須要，則能夠添加您本身的其餘測試依賴項。
44.2測試Spring應用程序
依賴注入的主要優勢之一是它應該使您的代碼更容易進行單元測試。屬性實例化對象。new操做員甚至不涉及Spring。您也能夠使用模擬對象而不是真正的依賴關係。
一般，您須要超越單元測試，開始集成測試(使用Spring)ApplicationContext)可以在不須要部署應用程序或鏈接到其餘基礎結構的狀況下執行集成測試是很是有用的。
Spring框架包括一個專門用於這種集成測試的測試模塊。能夠將依賴項直接聲明爲org.springframework:spring-test或使用spring-boot-starter-test「起動機」把它臨時拉進來。
若是您沒有使用spring-test模塊以前，您應該從讀取相關部分Spring框架參考文檔。
44.3測試SpringBoot應用程序
Spring引導應用程序是SpringApplicationContext所以，除了一般使用普通Spring上下文所作的工做以外，沒有什麼特別的事情要作來測試它。
|
| 外部屬性、日誌記錄和SpringBoot的其餘特性在默認狀況下僅在如下狀況下才會安裝在上下文中 |
Spring Boot提供了一個@SpringBootTest註釋，能夠做爲標準的替代。spring-test @ContextConfiguration當您須要SpringBoot特性時進行註釋。註釋的做用是建立ApplicationContext在您的測試中使用SpringApplication。除了……以外@SpringBootTest還提供了一些其餘註釋。測試更具體的切片一份申請書。
|
| 若是您使用的是JUnit 4，請不要忘記添加 |
默認狀況下，@SpringBootTest不會啓動服務器。您能夠使用webEnvironment屬性@SpringBootTest爲了進一步完善測試的運行方式：
MOCK(默認)：加載WebApplicationContext並提供一個模擬Web環境。使用此註釋時不會啓動嵌入式服務器。若是您的類路徑上沒有web環境，則此模式將透明地退回到建立常規的非web環境。ApplicationContext。它能夠與@AutoConfigureMockMvc或@AutoConfigureWebTestClient用於基於模擬的web應用程序測試。RANDOM_PORT*裝載WebServerApplicationContext並提供了一個真實的網絡環境。嵌入式服務器將啓動並在隨機端口上偵聽。DEFINED_PORT*裝載WebServerApplicationContext並提供了一個真實的網絡環境。嵌入式服務器將在定義的端口上啓動並偵聽(從application.properties)或在默認端口8080.NONE*加載ApplicationContext用SpringApplication但沒有提供任何Web環境(模擬或其餘)。
|
| 若是你的測試是 |
|
|
|
44.3.1檢測Web應用程序類型
若是SpringMVC可用，則配置一個基於MVC的常規應用程序上下文。若是您只有SpringWebFlux，咱們將檢測它並配置一個基於WebFlux的應用程序上下文。
若是二者都存在，則優先考慮SpringMVC。若是要在此方案中測試反應性web應用程序，則必須將spring.main.web-application-type財產：
@RunWith(SpringRunner.class)
@SpringBootTest(properties = "spring.main.web-application-type=reactive")
public class MyWebFluxTests { ... }
44.3.2檢測測試配置
若是您熟悉Spring測試框架，您可能已經習慣於使用@ContextConfiguration(classes=…)爲了指定哪一個Spring@Configuration裝貨。或者，您可能常用嵌套。@Configuration測試中的類。
在測試SpringBoot應用程序時，這一般不是必需的。彈簧靴@*Test當您沒有顯式定義主配置時，註釋會自動搜索您的主配置。
搜索算法從包含測試的包開始工做，直到找到帶註釋的類。@SpringBootApplication或@SpringBootConfiguration。只要你結構化代碼以一種明智的方式，一般能夠找到您的主要配置。
|
| 若是您使用測試註釋以測試應用程序中更特定的部分，則應避免添加特定於主要方法的應用類. 的基礎組件掃描配置 |
若是要自定義主配置，能夠使用嵌套的@TestConfiguration班級，等級不像嵌套的@Configuration類，它將用於替代應用程序的主要配置，即嵌套的@TestConfiguration類除了應用程序的主要配置外，還使用。
|
| Spring的測試框架在測試之間緩存應用程序上下文。所以，只要您的測試共享相同的配置(不管如何發現)，加載上下文的潛在耗時過程只會發生一次。 |
44.3.3不包括測試配置
若是應用程序使用組件掃描(例如，若是您使用@SpringBootApplication或@ComponentScan)，您可能會發現只爲特定測試建立的頂級配置類在任何地方都會意外地被選中。
由於咱們以前見過, @TestConfiguration能夠在測試的內部類上使用，以自定義主配置。當被安排到頂級班級時，@TestConfiguration表示src/test/java不該經過掃描來拾取。而後，能夠在須要的地方顯式導入該類，如如下示例所示：
@RunWith(SpringRunner.class)
@SpringBootTest
@Import(MyTestsConfiguration.class)
public class MyTests {
@Test
public void exampleTest() {
...
}
}
|
| 若是你直接用 |
44.3.4用模擬環境進行測試
默認狀況下，@SpringBootTest沒有啓動服務器。若是您有要在此模擬環境中測試的web端點，則能夠另外配置MockMvc如如下示例所示：
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@RunWith(SpringRunner.class)
@SpringBootTest
@AutoConfigureMockMvc
public class MockMvcExampleTests {
@Autowired
private MockMvc mvc;
@Test
public void exampleTest() throws Exception {
this.mvc.perform(get("/")).andExpect(status().isOk())
.andExpect(content().string("Hello World"));
}
}
|
| 若是但願只關注web層而不啓動完整的 |
或者，您能夠配置WebTestClient如如下示例所示：
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.reactive.AutoConfigureWebTestClient;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.reactive.server.WebTestClient;
@RunWith(SpringRunner.class)
@SpringBootTest
@AutoConfigureWebTestClient
public class MockWebTestClientExampleTests {
@Autowired
private WebTestClient webClient;
@Test
public void exampleTest() {
this.webClient.get().uri("/").exchange().expectStatus().isOk()
.expectBody(String.class).isEqualTo("Hello World");
}
}
44.3.5使用運行中的服務器進行測試
若是您須要啓動一個完整運行的服務器，咱們建議您使用隨機端口。若是你用@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)，每次測試運行時都會隨機選擇可用端口。
這，這個，那，那個@LocalServerPort註釋可用於注入實際使用的端口進入你的測試。爲了方便起見，須要對已啓動的服務器進行REST調用的測試能夠另外使用。@Autowire a WebTestClient，它解析與正在運行的服務器的相對連接，並附帶一個用於驗證響應的專用API，如如下示例所示：
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.reactive.server.WebTestClient;
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
public class RandomPortWebTestClientExampleTests {
@Autowired
private WebTestClient webClient;
@Test
public void exampleTest() {
this.webClient.get().uri("/").exchange().expectStatus().isOk()
.expectBody(String.class).isEqualTo("Hello World");
}
}
此設置要求spring-webflux在類路徑上。若是您不能或不肯添加網絡流量，SpringBoot還提供了一個TestRestTemplate設施：
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.test.context.junit4.SpringRunner;
import static org.assertj.core.api.Assertions.assertThat;
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
public class RandomPortTestRestTemplateExampleTests {
@Autowired
private TestRestTemplate restTemplate;
@Test
public void exampleTest() {
String body = this.restTemplate.getForObject("/", String.class);
assertThat(body).isEqualTo("Hello World");
}
}
44.3.6使用JMX
因爲測試上下文框架緩存上下文，所以默認狀況下禁用JMX以防止相同組件在同一域中註冊。若是這種測試須要訪問MBeanServer，也考慮將其標記爲髒的：
@RunWith(SpringRunner.class)
@SpringBootTest(properties = "spring.jmx.enabled=true")
@DirtiesContext
public class SampleJmxTests {
@Autowired
private MBeanServer mBeanServer;
@Test
public void exampleTest() {
// ...
}
}
44.3.7嘲弄和間諜豆
在運行測試時，有時須要在應用程序上下文中模擬某些組件。例如，在開發期間不可用的遠程服務上可能有一個外觀。當您想要模擬在實際環境中可能很難觸發的失敗時，模擬也是很是有用的。
彈簧啓動包括一個@MockBean註釋，可用於爲您內部的bean定義一個Mockito模擬。ApplicationContext。您能夠使用註釋添加新bean或替換單個現有bean定義。該註釋可直接用於測試類、測試中的字段或@Configuration類別和字段。在字段上使用時，也會注入建立的模擬實例。模擬bean在每一個測試方法以後都會自動重置。
|
| 若是您的測試使用SpringBoot的測試註釋之一(如 @TestExecutionListeners(MockitoTestExecutionListener.class) |
下面的示例替換現有的RemoteService帶有模擬實現的bean：
import org.junit.*;
import org.junit.runner.*;
import org.springframework.beans.factory.annotation.*;
import org.springframework.boot.test.context.*;
import org.springframework.boot.test.mock.mockito.*;
import org.springframework.test.context.junit4.*;
import static org.assertj.core.api.Assertions.*;
import static org.mockito.BDDMockito.*;
@RunWith(SpringRunner.class)
@SpringBootTest
public class MyTests {
@MockBean
private RemoteService remoteService;
@Autowired
private Reverser reverser;
@Test
public void exampleTest() {
// RemoteService has been injected into the reverser bean
given(this.remoteService.someCall()).willReturn("mock");
String reverse = reverser.reverseSomeCall();
assertThat(reverse).isEqualTo("kcom");
}
}
此外，您還能夠使用@SpyBean若要用Mockito包裝現有的bean，請執行如下操做spy。見Javadoc詳細狀況。
|
| Spring的測試框架在測試之間緩存應用程序上下文，並重用用於共享相同配置的測試的上下文，而使用 |
44.3.8自動配置測試
SpringBoot的自動配置系統在應用程序中運行良好，但有時對測試來講可能有點過了。它一般幫助只加載測試應用程序的「片斷」所需的配置部分。例如，您可能但願測試SpringMVC控制器是否正確地映射URL，而且不但願在這些測試中涉及數據庫調用，或者您可能但願測試JPA實體，而且在這些測試運行時對Web層不感興趣。
這，這個，那，那個spring-boot-test-autoconfigure模塊包含許多註釋，這些註釋可用於自動配置此類「片」。它們中的每個都以相似的方式工做，提供了一個@…Test加載ApplicationContext和一個或多個@AutoConfigure…可用於自定義自動配置設置的註釋。
|
| 每一個切片限制組件掃描到適當的組件，並加載一組很是受限的自動配置類。若是你須要排除其中一個 |
|
| 也能夠使用 |
44.3.9自動配置的JSON測試
若要測試對象JSON序列化和反序列化是否正常工做，能夠使用@JsonTest註釋@JsonTest自動配置可用的受支持的JSON映射程序，它能夠是如下庫之一：
- 傑克森
ObjectMapper，任何@JsonComponent豆子和傑克遜Modules GsonJsonb
|
| 啓用的自動配置的列表。 |
若是須要配置自動配置的元素，能夠使用@AutoConfigureJsonTesters註釋
SpringBoot包括基於AssertJ的幫助程序，它們使用JSONAssert和JsonPath庫來檢查JSON是否如預期的那樣出現。這，這個，那，那個JacksonTester, GsonTester,JsonbTester，和BasicJsonTester類能夠分別用於Jackson、GSON、Jsonb和String。測試類上的任何輔助字段均可以是@Autowired使用時@JsonTest。下面的示例顯示了Jackson的測試類：
import org.junit.*;
import org.junit.runner.*;
import org.springframework.beans.factory.annotation.*;
import org.springframework.boot.test.autoconfigure.json.*;
import org.springframework.boot.test.context.*;
import org.springframework.boot.test.json.*;
import org.springframework.test.context.junit4.*;
import static org.assertj.core.api.Assertions.*;
@RunWith(SpringRunner.class)
@JsonTest
public class MyJsonTests {
@Autowired
private JacksonTester<VehicleDetails> json;
@Test
public void testSerialize() throws Exception {
VehicleDetails details = new VehicleDetails("Honda", "Civic");
// Assert against a `.json` file in the same package as the test
assertThat(this.json.write(details)).isEqualToJson("expected.json");
// Or use JSON path based assertions
assertThat(this.json.write(details)).hasJsonPathStringValue("@.make");
assertThat(this.json.write(details)).extractingJsonPathStringValue("@.make")
.isEqualTo("Honda");
}
@Test
public void testDeserialize() throws Exception {
String content = "{\"make\":\"Ford\",\"model\":\"Focus\"}";
assertThat(this.json.parse(content))
.isEqualTo(new VehicleDetails("Ford", "Focus"));
assertThat(this.json.parseObject(content).getMake()).isEqualTo("Ford");
}
}
|
| JSON助手類也能夠直接用於標準單元測試。爲此，請調用 |
44.3.10自動配置的SpringMVC測試
若要測試SpringMVC控制器是否按預期工做，請使用@WebMvcTest註釋@WebMvcTest自動配置SpringMVC基礎結構，並將掃描bean限制爲@Controller, @ControllerAdvice, @JsonComponent, Converter, GenericConverter, Filter, WebMvcConfigurer，和HandlerMethodArgumentResolver。正規化@Component使用此註釋時不會掃描bean。
|
| 啓用的自動配置設置的列表。 |
|
| 若是您須要註冊額外的組件，好比Jackson |
一般，@WebMvcTest僅限於單個控制器，並與@MockBean爲所需的協做者提供模擬實現。
@WebMvcTest也自動配置MockMvc。模擬MVC提供了一種功能強大的方法，能夠快速測試MVC控制器，而無需啓動完整的HTTP服務器。
|
| 您還能夠自動配置 |
import org.junit.*;
import org.junit.runner.*;
import org.springframework.beans.factory.annotation.*;
import org.springframework.boot.test.autoconfigure.web.servlet.*;
import org.springframework.boot.test.mock.mockito.*;
import static org.assertj.core.api.Assertions.*;
import static org.mockito.BDDMockito.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
@RunWith(SpringRunner.class)
@WebMvcTest(UserVehicleController.class)
public class MyControllerTests {
@Autowired
private MockMvc mvc;
@MockBean
private UserVehicleService userVehicleService;
@Test
public void testExample() throws Exception {
given(this.userVehicleService.getVehicleDetails("sboot"))
.willReturn(new VehicleDetails("Honda", "Civic"));
this.mvc.perform(get("/sboot/vehicle").accept(MediaType.TEXT_PLAIN))
.andExpect(status().isOk()).andExpect(content().string("Honda Civic"));
}
}
|
| 若是須要配置自動配置的元素(例如，什麼時候應用servlet篩選器)，則能夠在 |
若是使用htmlUnit或Selenium，則自動配置還提供了HTMLUnit。WebClient豆和/或aWebDriver豆子如下示例使用HtmlUnit：
import com.gargoylesoftware.htmlunit.*;
import org.junit.*;
import org.junit.runner.*;
import org.springframework.beans.factory.annotation.*;
import org.springframework.boot.test.autoconfigure.web.servlet.*;
import org.springframework.boot.test.mock.mockito.*;
import static org.assertj.core.api.Assertions.*;
import static org.mockito.BDDMockito.*;
@RunWith(SpringRunner.class)
@WebMvcTest(UserVehicleController.class)
public class MyHtmlUnitTests {
@Autowired
private WebClient webClient;
@MockBean
private UserVehicleService userVehicleService;
@Test
public void testExample() throws Exception {
given(this.userVehicleService.getVehicleDetails("sboot"))
.willReturn(new VehicleDetails("Honda", "Civic"));
HtmlPage page = this.webClient.getPage("/sboot/vehicle.html");
assertThat(page.getBody().getTextContent()).isEqualTo("Honda Civic");
}
}
|
| 默認狀況下，SpringBoot |
若是你在類路徑上有Spring保安，@WebMvcTest也會掃描WebSecurityConfigurer豆子您能夠使用SpringSecurity的測試支持，而不是徹底禁用此類測試的安全性。關於如何使用Spring安全的更多詳細信息MockMvc支持可在如下內容中找到：第79章，用Spring安全性進行測試如何-到部分。
|
| 有時候編寫SpringMVC測試是不夠的；SpringBoot能夠幫助您運行使用實際服務器進行完整的端到端測試。. |
44.3.11自動配置的SpringWebFlux測試
來測試一下春季WebFlux控制器按預期工做，能夠使用@WebFluxTest註釋@WebFluxTest自動配置SpringWebFlux基礎結構，並將掃描bean限制爲@Controller, @ControllerAdvice, @JsonComponent, Converter, GenericConverter，和WebFluxConfigurer。正規化@Component對象時不掃描bean。@WebFluxTest使用註釋。
|
| 啓用的自動配置的列表。 |
|
| 若是您須要註冊額外的組件，好比Jackson |
一般，@WebFluxTest僅限於單個控制器，並與@MockBean註釋爲所需的協做者提供模擬實現。
@WebFluxTest也自動配置WebTestClient，它提供了一種功能強大的方法，能夠快速測試WebFlux控制器，而無需啓動完整的HTTP服務器。
|
| 您還能夠自動配置 |
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.reactive.WebFluxTest;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.reactive.server.WebTestClient;
@RunWith(SpringRunner.class)
@WebFluxTest(UserVehicleController.class)
public class MyControllerTests {
@Autowired
private WebTestClient webClient;
@MockBean
private UserVehicleService userVehicleService;
@Test
public void testExample() throws Exception {
given(this.userVehicleService.getVehicleDetails("sboot"))
.willReturn(new VehicleDetails("Honda", "Civic"));
this.webClient.get().uri("/sboot/vehicle").accept(MediaType.TEXT_PLAIN)
.exchange()
.expectStatus().isOk()
.expectBody(String.class).isEqualTo("Honda Civic");
}
}
|
| 此設置僅受WebFlux應用程序支持，由於 |
|
|
|
|
| 有時編寫SpringWebFlux測試是不夠的；SpringBoot能夠幫助您運行使用實際服務器進行完整的端到端測試。. |
44.3.12自動配置的數據JPA測試
您能夠使用@DataJpaTest用於測試JPA應用程序的註釋。默認狀況下，它配置內存內嵌入式數據庫，掃描@Entity類，並配置Spring數據JPA存儲庫。正規化@Componentbean未加載到ApplicationContext.
|
| 啓用的自動配置設置的列表。 |
默認狀況下，數據JPA測試是事務性的，而且在每一個測試結束時回滾。見相關部分在SpringFramework參考文檔中得到更多細節。若是這不是您想要的，您能夠禁用測試或整個類的事務管理，以下所示：
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
@RunWith(SpringRunner.class)
@DataJpaTest
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public class ExampleNonTransactionalTests {
}
DataJPA測試也可能會注入一個TestEntityManager，它提供了標準JPA的替代方案。EntityManager這是專門爲測試設計的。若是你想用TestEntityManager外@DataJpaTest實例，也能夠使用@AutoConfigureTestEntityManager註釋一個JdbcTemplate若是你須要的話也能夠。下面的示例顯示@DataJpaTest正在使用的註釋：
import org.junit.*;
import org.junit.runner.*;
import org.springframework.boot.test.autoconfigure.orm.jpa.*;
import static org.assertj.core.api.Assertions.*;
@RunWith(SpringRunner.class)
@DataJpaTest
public class ExampleRepositoryTests {
@Autowired
private TestEntityManager entityManager;
@Autowired
private UserRepository repository;
@Test
public void testExample() throws Exception {
this.entityManager.persist(new User("sboot", "1234"));
User user = this.repository.findByUsername("sboot");
assertThat(user.getUsername()).isEqualTo("sboot");
assertThat(user.getVin()).isEqualTo("1234");
}
}
內存中的嵌入式數據庫一般用於測試，由於它們速度快，不須要任何安裝。可是，若是您更願意對實際數據庫運行測試，則能夠使用@AutoConfigureTestDatabase註釋，如如下示例所示：
@RunWith(SpringRunner.class)
@DataJpaTest
@AutoConfigureTestDatabase(replace=Replace.NONE)
public class ExampleRepositoryTests {
// ...
}
44.3.13自動配置的JDBC測試
@JdbcTest相似於@DataJpaTest而是用於只須要DataSource也不要使用SpringDataJDBC。默認狀況下，它配置內存內嵌入數據庫和JdbcTemplate。正規化@Componentbean未加載到ApplicationContext.
|
| 啓用的自動配置的列表。 |
默認狀況下，JDBC測試是事務性的，而且在每一個測試結束時回滾。見相關部分在SpringFramework參考文檔中得到更多細節。若是這不是您想要的，您能夠禁用測試或整個類的事務管理，以下所示：
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.autoconfigure.jdbc.JdbcTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
@RunWith(SpringRunner.class)
@JdbcTest
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public class ExampleNonTransactionalTests {
}
若是您但願在實際數據庫上運行測試，則能夠使用@AutoConfigureTestDatabase註釋的方式與DataJpaTest。(見「第44.3.12節，「自動配置數據JPA測試」".)
44.3.14自動配置的數據JDBC測試
@DataJdbcTest相似於@JdbcTest而是用於使用Spring數據JDBC存儲庫的測試。默認狀況下，它配置內存內嵌入數據庫，JdbcTemplate，以及Spring數據JDBC存儲庫。正規化@Componentbean未加載到ApplicationContext.
|
| 啓用的自動配置的列表。 |
默認狀況下，數據JDBC測試是事務性的，而且在每一個測試結束時回滾。見相關部分在SpringFramework參考文檔中得到更多細節。若是這不是您想要的，您能夠將測試或整個測試類的事務管理禁用爲如jdbc示例所示.
若是您但願在實際數據庫上運行測試，則能夠使用@AutoConfigureTestDatabase註釋的方式與DataJpaTest。(見「第44.3.12節，「自動配置數據JPA測試」".)
44.3.15自動配置的jOOQ測試
你能夠用@JooqTest以相似的方式@JdbcTest但對於與jOOQ相關的測試。因爲jOOQ嚴重依賴與數據庫模式相對應的基於Java的模式，DataSource被利用了。若是要用內存中的數據庫替換它，能夠使用@AutoConfigureTestDatabase覆蓋這些設置。(有關在SpringBoot中使用jOOQ的更多信息，請參見「第29.6節，「使用jOOQ」「，在本章前面。@Componentbean未加載到ApplicationContext.
|
| 啓用的自動配置的列表。 |
@JooqTest配置DSLContext。正規化@Componentbean未加載到ApplicationContext。下面的示例顯示@JooqTest正在使用的註釋：
import org.jooq.DSLContext;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.autoconfigure.jooq.JooqTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@JooqTest
public class ExampleJooqTests {
@Autowired
private DSLContext dslContext;
}
JOOQ測試是事務性的，默認狀況下在每一個測試結束時回滾。若是這不是您想要的，您能夠將測試或整個測試類的事務管理禁用爲如jdbc示例所示.
44.3.16自動配置的數據MongoDB測試
你能夠用@DataMongoTest測試MongoDB應用程序。默認狀況下，它配置內存中嵌入的MongoDB(若是可用)，配置MongoTemplate，掃描@Document類，並配置Spring數據MongoDB存儲庫。正規化@Componentbean未加載到ApplicationContext。(有關在SpringBoot中使用MongoDB的更多信息，請參見「第30.2節，「MongoDB」「，在本章前面。
|
| 啓用的自動配置設置的列表。 |
下面的類顯示@DataMongoTest正在使用的註釋：
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.mongo.DataMongoTest;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@DataMongoTest
public class ExampleDataMongoTests {
@Autowired
private MongoTemplate mongoTemplate;
//
}
內存中嵌入的MongoDB一般適用於測試，由於它速度快，不須要任何開發人員安裝。可是，若是您更願意對真實的MongoDB服務器運行測試，則應該排除嵌入的MongoDB自動配置，以下面的示例所示：
import org.junit.runner.RunWith;
import org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration;
import org.springframework.boot.test.autoconfigure.data.mongo.DataMongoTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@DataMongoTest(excludeAutoConfiguration = EmbeddedMongoAutoConfiguration.class)
public class ExampleDataMongoNonEmbeddedTests {
}
44.3.17自動配置的數據Neo4j測試
你能夠用@DataNeo4jTest測試Neo4j應用程序。默認狀況下，它使用內存內嵌入的neo4j(若是嵌入式驅動程序可用)，掃描@NodeEntity類，並配置Spring數據Neo4j存儲庫。正規化@Componentbean未加載到ApplicationContext。(有關在SpringBoot中使用Neo4J的更多信息，請參見「第30.3節，「Neo4j」「，在本章前面。
|
| 啓用的自動配置設置的列表。 |
下面的示例展現了在SpringBoot中使用Neo4J測試的典型設置：
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.neo4j.DataNeo4jTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@DataNeo4jTest
public class ExampleDataNeo4jTests {
@Autowired
private YourRepository repository;
//
}
默認狀況下，DataNeo4j測試是事務性的，在每一個測試結束時回滾。見相關部分在SpringFramework參考文檔中得到更多細節。若是這不是您想要的，您能夠禁用測試或整個類的事務管理，以下所示：
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.autoconfigure.data.neo4j.DataNeo4jTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
@RunWith(SpringRunner.class)
@DataNeo4jTest
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public class ExampleNonTransactionalTests {
}
44.3.18自動配置的數據Redis測試
你能夠用@DataRedisTest測試Redis應用程序。默認狀況下，它掃描@RedisHash類和配置SpringDataRedis存儲庫。正規化@Componentbean未加載到ApplicationContext。(有關在SpringBoot中使用Redis的更多信息，請參見「第30.1節，「Redis」「，在本章前面。
|
| 啓用的自動配置設置的列表。 |
下面的示例顯示@DataRedisTest正在使用的註釋：
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.redis.DataRedisTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@DataRedisTest
public class ExampleDataRedisTests {
@Autowired
private YourRepository repository;
//
}
44.3.19自動配置的數據LDAP測試
你能夠用@DataLdapTest測試LDAP應用程序。默認狀況下，它配置內存中嵌入的ldap(若是可用)，配置LdapTemplate，掃描@Entry類，並配置Spring數據LDAP存儲庫。正規化@Componentbean未加載到ApplicationContext。(有關在SpringBoot中使用LDAP的更多信息，請參見「第30.9節，「LDAP」「，在本章前面。
|
| 啓用的自動配置設置的列表。 |
下面的示例顯示@DataLdapTest正在使用的註釋：
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.ldap.DataLdapTest;
import org.springframework.ldap.core.LdapTemplate;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@DataLdapTest
public class ExampleDataLdapTests {
@Autowired
private LdapTemplate ldapTemplate;
//
}
內存中嵌入的LDAP一般適用於測試，由於它速度快，不須要任何開發人員安裝。可是，若是您更願意對實際的LDAP服務器運行測試，則應該排除嵌入式LDAP自動配置，以下面的示例所示：
import org.junit.runner.RunWith;
import org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration;
import org.springframework.boot.test.autoconfigure.data.ldap.DataLdapTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@DataLdapTest(excludeAutoConfiguration = EmbeddedLdapAutoConfiguration.class)
public class ExampleDataLdapNonEmbeddedTests {
}
44.3.20自動配置的REST客戶端
您能夠使用@RestClientTest用於測試REST客戶端的註釋。默認狀況下，它自動配置Jackson、gson和jsonb支持，配置RestTemplateBuilder，並增長了對MockRestServiceServer。正規化@Componentbean未加載到ApplicationContext.
|
| 啓用的自動配置設置的列表。 |
屬性指定要測試的特定bean。value或components屬性@RestClientTest，如如下示例所示：
@RunWith(SpringRunner.class)
@RestClientTest(RemoteVehicleDetailsService.class)
public class ExampleRestClientTest {
@Autowired
private RemoteVehicleDetailsService service;
@Autowired
private MockRestServiceServer server;
@Test
public void getVehicleDetailsWhenResultIsSuccessShouldReturnDetails()
throws Exception {
this.server.expect(requestTo("/greet/details"))
.andRespond(withSuccess("hello", MediaType.TEXT_PLAIN));
String greeting = this.service.callRestService();
assertThat(greeting).isEqualTo("hello");
}
}
44.3.21自動配置的SpringREST文檔測試
您能夠使用@AutoConfigureRestDocs要使用的註釋彈簧休息文檔在您的測試中使用Mock MVC仍是放心。它消除了SpringREST文檔中對JUnit規則的需求。
@AutoConfigureRestDocs能夠用來覆蓋默認輸出目錄(target/generated-snippets若是您正在使用Maven或build/generated-snippets若是您正在使用Gradle)。它還能夠用於配置出如今任何文檔URI中的主機、方案和端口。
用Mock MVC自動配置SpringREST文檔測試
@AutoConfigureRestDocs自定義MockMvcbean使用SpringREST文檔。您能夠使用@Autowired並在測試中使用它，就像在使用Mock MVC和SpringREST文檔時同樣，以下面的示例所示：
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import static org.springframework.restdocs.mockmvc.MockMvcRestDocumentation.document;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
@RunWith(SpringRunner.class)
@WebMvcTest(UserController.class)
@AutoConfigureRestDocs
public class UserDocumentationTests {
@Autowired
private MockMvc mvc;
@Test
public void listUsers() throws Exception {
this.mvc.perform(get("/users").accept(MediaType.TEXT_PLAIN))
.andExpect(status().isOk())
.andDo(document("list-users"));
}
}
若是您須要對SpringRESTDocs配置的控制比@AutoConfigureRestDocs，您能夠使用RestDocsMockMvcConfigurationCustomizerbean，如如下示例所示：
@TestConfiguration
static class CustomizationConfiguration
implements RestDocsMockMvcConfigurationCustomizer {
@Override
public void customize(MockMvcRestDocumentationConfigurer configurer) {
configurer.snippets().withTemplateFormat(TemplateFormats.markdown());
}
}
若是要使用SpringRESTDocs對參數化輸出目錄的支持，能夠建立RestDocumentationResultHandler豆子自動配置調用alwaysDo使用此結果處理程序，從而致使每一個MockMvc調用以自動生成默認代碼段。下面的示例顯示RestDocumentationResultHandler定義以下：
@TestConfiguration
static class ResultHandlerConfiguration {
@Bean
public RestDocumentationResultHandler restDocumentation() {
return MockMvcRestDocumentation.document("{method-name}");
}
}
自動配置的SpringREST文檔測試
@AutoConfigureRestDocs使.RequestSpecificationbean，預先配置爲使用SpringREST文檔，可用於測試。您能夠使用@Autowired並在測試中使用它，就像在使用REST和SpringREST文檔時同樣，以下面的示例所示：
import io.restassured.specification.RequestSpecification;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.restdocs.AutoConfigureRestDocs;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.test.context.junit4.SpringRunner;
import static io.restassured.RestAssured.given;
import static org.hamcrest.CoreMatchers.is;
import static org.springframework.restdocs.restassured3.RestAssuredRestDocumentation.document;
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
@AutoConfigureRestDocs
public class UserDocumentationTests {
@LocalServerPort
private int port;
@Autowired
private RequestSpecification documentationSpec;
@Test
public void listUsers() {
given(this.documentationSpec).filter(document("list-users")).when()
.port(this.port).get("/").then().assertThat().statusCode(is(200));
}
}
若是您須要對SpringRESTDocs配置的控制比@AutoConfigureRestDocs..RestDocsRestAssuredConfigurationCustomizer能夠使用bean，如如下示例所示：
@TestConfiguration
public static class CustomizationConfiguration
implements RestDocsRestAssuredConfigurationCustomizer {
@Override
public void customize(RestAssuredRestDocumentationConfigurer configurer) {
configurer.snippets().withTemplateFormat(TemplateFormats.markdown());
}
}
44.3.22附加自動配置和切片
每一個切片提供一個或多個@AutoConfigure…註釋，即定義應該做爲片的一部分包含的自動配置。能夠經過建立自定義來添加其餘自動配置。@AutoConfigure…註釋或簡單地添加@ImportAutoConfiguration以下面的示例所示：
@RunWith(SpringRunner.class)
@JdbcTest
@ImportAutoConfiguration(IntegrationAutoConfiguration.class)
public class ExampleJdbcTests {
}
|
| 確保不使用常規 |
44.3.23用戶配置和切片
若是你構造代碼以一種明智的方式，你的@SpringBootApplication類是默認使用做爲測試的配置。
而後，重要的是不要用特定於特定功能領域的配置設置丟棄應用程序的主類。
假設您正在使用Spring批處理，並依賴於它的自動配置。你能夠定義你的@SpringBootApplication詳情以下：
@SpringBootApplication
@EnableBatchProcessing
public class SampleApplication { ... }
由於這個類是測試的源配置，因此任何片測試實際上都試圖啓動Spring批處理，這確定不是您想要作的。推薦的方法是將特定區域的配置移動到單獨的。@Configuration在與應用程序相同的級別初始化，如如下示例所示：
@Configuration
@EnableBatchProcessing
public class BatchConfiguration { ... }
|
| 根據應用程序的複雜性，您可能有一個 |
另外一個形成混亂的緣由是類路徑掃描。假設，當您以合理的方式構造您的代碼時，您須要掃描一個額外的包。您的應用程序可能相似如下代碼：
@SpringBootApplication
@ComponentScan({ "com.example.app", "org.acme.another" })
public class SampleApplication { ... }
這樣作能夠有效地覆蓋默認組件掃描指令，並附帶掃描這兩個包的反作用，而無論您選擇的是哪一個切片。例如，@DataJpaTest彷佛忽然掃描了應用程序的組件和用戶配置。一樣，將自定義指令移動到單獨的類是解決此問題的好方法。
|
| 若是這不是一個選項，您能夠建立一個 |
44.3.24使用Spock測試SpringBoot應用程序
若是但願使用Spock測試SpringBoot應用程序，則應該添加對Spock的依賴項spock-spring模塊到應用程序的構建。spock-spring將Spring的測試框架集成到Spock中。建議您使用Spock 1.1或更高版本，以受益於對Spock的Spring框架和SpringBoot集成的許多改進。看見Spock的Spring模塊文檔更多細節。
44.4測試實用程序
測試應用程序時一般有用的一些測試實用程序類打包爲spring-boot.
44.4.1 ConfigFileApplicationContextInitiizer
ConfigFileApplicationContextInitializer是ApplicationContextInitializer能夠應用於測試來加載SpringBootapplication.properties檔案。當您不須要@SpringBootTest，如如下示例所示：
@ContextConfiguration(classes = Config.class, initializers = ConfigFileApplicationContextInitializer.class)
|
| 使用 |
44.4.2 TestPropertyValue
TestPropertyValues容許您快速將屬性添加到ConfigurableEnvironment或ConfigurableApplicationContext。你能夠用key=value字符串以下：
TestPropertyValues.of("org=Spring", "name=Boot").applyTo(env);
44.4.3產出捕獲
OutputCapture是JUnitRule你能夠用來捕捉System.out和System.err輸出。能夠將捕獲聲明爲@Rule而後使用toString()對於斷言，以下所示：
import org.junit.Rule;
import org.junit.Test;
import org.springframework.boot.test.rule.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"));
}
}
44.4.4 TestRestTemplate
|
| SpringFramework5.0提供了一個新的 |
TestRestTemplate是春天的另外一種方便的選擇RestTemplate這在集成測試中頗有用。您能夠得到一個普通模板或發送基本HTTP身份驗證的模板(帶有用戶名和密碼)。在這兩種狀況下，模板都以一種測試友好的方式運行，不對服務器端錯誤拋出異常。建議使用ApacheHTTP客戶端(4.3.2或更高版本)，但不是強制性的。若是你的類路徑上有這個，TestRestTemplate經過適當配置客戶端進行響應。若是您確實使用了Apache的HTTP客戶端，則啓用了一些額外的測試友好特性：
- 沒有遵循重定向(所以您能夠斷言響應位置)。
- 忽略cookie(所以模板是無狀態的)。
TestRestTemplate能夠在集成測試中直接實例化，如如下示例所示：
public class MyTest {
private TestRestTemplate template = new TestRestTemplate();
@Test
public void testRequest() throws Exception {
HttpHeaders headers = this.template.getForEntity(
"http://myhost.example.com/example", String.class).getHeaders();
assertThat(headers.getLocation()).hasHost("other.example.com");
}
}
或者，若是您使用@SpringBootTest註釋WebEnvironment.RANDOM_PORT或WebEnvironment.DEFINED_PORT，您能夠注入一個徹底配置的TestRestTemplate而後開始使用它。若是有必要，能夠經過RestTemplateBuilder豆子沒有指定主機和端口的任何URL都會自動鏈接到嵌入式服務器，以下面的示例所示：
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
public class SampleWebClientTests {
@Autowired
private TestRestTemplate template;
@Test
public void testRequest() {
HttpHeaders headers = this.template.getForEntity("/example", String.class)
.getHeaders();
assertThat(headers.getLocation()).hasHost("other.example.com");
}
@TestConfiguration
static class Config {
@Bean
public RestTemplateBuilder restTemplateBuilder() {
return new RestTemplateBuilder().setConnectTimeout(Duration.ofSeconds(1))
.setReadTimeout(Duration.ofSeconds(1));
}
}
}
45.WebSocket
SpringBoot提供了用於嵌入式Tomcat、Jetty和Under拖車的WebSocket自動配置。若是將WAR文件部署到獨立容器，SpringBoot假定容器負責WebSocket支持的配置。
Spring框架提供富WebSocket支持對於mvc web應用程序，能夠經過spring-boot-starter-websocket模塊。
WebSocket支持也可用於反應性Web應用並要求將WebSocketAPI與spring-boot-starter-webflux:
<dependency> <groupId>javax.websocket</groupId> <artifactId>javax.websocket-api</artifactId> </dependency>
46.Web服務
Spring Boot提供了Web服務的自動配置，因此您必須作的就是定義Endpoints.
這，這個，那，那個SpringWeb服務特性能夠輕鬆地使用spring-boot-starter-webservices模塊。
SimpleWsdl11Definition和SimpleXsdSchemabean能夠分別爲WSDL和XSD自動建立。爲此，配置它們的位置，以下面的示例所示：
spring.webservices.wsdl-locations=classpath:/wsdl
47.調用Web服務WebServiceTemplate
若是須要從應用程序調用遠程Web服務，能夠使用WebServiceTemplate班級，等級自WebServiceTemplate實例在使用以前一般須要進行自定義，SpringBoot不提供任何單獨的自動配置。WebServiceTemplate豆子可是，它會自動配置一個WebServiceTemplateBuilder，能夠用來建立WebServiceTemplate須要時執行實例。
下面的代碼顯示了一個典型的示例：
@Service
public class MyService {
private final WebServiceTemplate webServiceTemplate;
public MyService(WebServiceTemplateBuilder webServiceTemplateBuilder) {
this.webServiceTemplate = webServiceTemplateBuilder.build();
}
public DetailsResp someWsCall(DetailsReq detailsReq) {
return (DetailsResp) this.webServiceTemplate.marshalSendAndReceive(detailsReq, new SoapActionCallback(ACTION));
}
}
默認狀況下，WebServiceTemplateBuilder檢測合適的基於HTTP的WebServiceMessageSender在類路徑上使用可用的HTTP客戶端庫。您還能夠自定義讀取和鏈接超時，以下所示：
@Bean
public WebServiceTemplate webServiceTemplate(WebServiceTemplateBuilder builder) {
return builder.messageSenders(new HttpWebServiceMessageSenderBuilder()
.setConnectTimeout(5000).setReadTimeout(2000).build()).build();
}
48.建立本身的自動配置
若是您在開發共享庫的公司工做，或者在開源或商業庫上工做，您可能須要開發本身的自動配置。自動配置類能夠打包在外部JAR中，而且仍然能夠經過SpringBoot來獲取。
自動配置能夠與提供自動配置代碼的「初學者」相關聯，以及您將與其一塊兒使用的典型庫。咱們首先介紹構建您本身的自動配置所需的知識，而後繼續討論建立自定義啓動程序所需的典型步驟.
|
| A 演示項目演示如何一步地建立初學者。 |
48.1理解自動配置bean
在引擎蓋下，自動配置是用標準實現的。@Configuration上課。額外@Conditional註釋用於限制什麼時候應用自動配置。一般，自動配置類使用@ConditionalOnClass和@ConditionalOnMissingBean註釋。這確保了自動配置只在找到相關類和還沒有聲明本身的類時應用。@Configuration.
的源代碼。spring-boot-autoconfigure去看@ConfigurationSpring提供的類(請參閱META-INF/spring.factories檔案)。
48.2自動配置候選人的位置
彈簧啓動檢查是否存在META-INF/spring.factories文件在已發佈的JAR中。文件應將配置類列在EnableAutoConfiguration鍵，如如下示例所示：
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ com.mycorp.libx.autoconfigure.LibXAutoConfiguration,\ com.mycorp.libx.autoconfigure.LibXWebAutoConfiguration
您能夠使用@AutoConfigureAfter或@AutoConfigureBefore若是您的配置須要按照特定的順序應用，則進行註釋。例如，若是您提供了特定於web的配置，則您的類可能須要在WebMvcAutoConfiguration.
若是您想訂購某些不該該彼此直接瞭解的自動配置，也能夠使用@AutoConfigureOrder。該註釋具備與常規註釋相同的語義。@Order註釋，但爲自動配置類提供了專用訂單。
|
| 自動配置必須以這種方式加載。只。確保它們是在特定的包空間中定義的，特別是，它們永遠不是組件掃描的目標。 |
48.3條件註釋
您幾乎老是但願包含一個或多個@Conditional自動配置類的註釋。這，這個，那，那個@ConditionalOnMissingBean註釋是一個常見的示例，用於容許開發人員在不滿意默認設置的狀況下覆蓋自動配置。
Spring Boot包括@Conditional註釋，您能夠經過註釋在本身的代碼中重用這些註釋。@Configuration階級或我的@Bean方法。這些說明包括：
- 第48.3.1節，「階級條件」
- 第48.3.2節，「豆條件」
- 第48.3.3節，「財產條件」
- 第48.3.4節，「資源情況」
- 第48.3.5節，「Web應用條件」
- 第48.3.6節，「Spel表達式條件」
48.3.1類條件
這，這個，那，那個@ConditionalOnClass和@ConditionalOnMissingClass註釋容許根據特定類的存在與否包括配置。因爲註釋元數據是經過ASM，您能夠使用value屬性來引用真正的類，即便該類可能不會實際出如今正在運行的應用程序類路徑中。您還能夠使用name屬性指定類名時，請使用String價值。
|
| 若是你用 |
48.3.2豆子條件
這，這個，那，那個@ConditionalOnBean和@ConditionalOnMissingBean註釋容許根據是否存在特定bean來包含bean。您能夠使用value屬性指定bean的類型或name若要按名稱指定bean，請執行如下操做。這，這個，那，那個search屬性容許您限制ApplicationContext在搜索bean時應考慮的層次結構。
當放置在@Bean方法時，目標類型默認爲方法的返回類型，如如下示例所示：
@Configuration
public class MyAutoConfiguration {
@Bean
@ConditionalOnMissingBean
public MyService myService() { ... }
}
在前面的示例中，myService若是沒有類型的bean，則將建立bean。MyService已包含在ApplicationContext.
|
| 對於添加bean定義的順序，您須要很是當心，由於這些條件是根據到目前爲止處理的內容來計算的。所以，咱們建議只使用 |
|
|
|
48.3.3財產條件
這，這個，那，那個@ConditionalOnProperty註釋容許基於SpringEnvironment屬性包括配置。使用prefix和name屬性指定應該檢查的屬性。默認狀況下，存在和不等於false是匹配的。還能夠使用havingValue和matchIfMissing屬性。
48.3.4資源條件
這，這個，那，那個@ConditionalOnResource註釋只容許在存在特定資源時包含配置。能夠經過使用一般的Spring約定來指定資源，以下面的示例所示：file:/home/user/test.dat.
48.3.5 Web應用條件
這，這個，那，那個@ConditionalOnWebApplication和@ConditionalOnNotWebApplication註釋容許包含配置，這取決於應用程序是不是「web應用程序」。Web應用程序是使用Spring的任何應用程序WebApplicationContext，定義session範圍，或具備StandardServletEnvironment.
48.3.6 Spel表達條件
這，這個，那，那個@ConditionalOnExpression註釋容許根據Spel表達式.
48.4測試您的自動配置
自動配置可能受到許多因素的影響：用戶配置(@Bean定義和Environment(定製)、條件評估(存在特定庫)以及其餘。具體而言，每一個測試都應該建立一個定義良好的ApplicationContext表示這些自定義的組合。ApplicationContextRunner爲實現這一目標提供了一種很好的方法。
ApplicationContextRunner一般定義爲測試類的一個字段來收集基本的、通用的配置。下面的示例確保UserServiceAutoConfiguration老是被引用：
private final ApplicationContextRunner contextRunner = new ApplicationContextRunner() .withConfiguration(AutoConfigurations.of(UserServiceAutoConfiguration.class));
|
| 若是必須定義多個自動配置，則不須要對它們的聲明排序，由於它們的調用順序與運行應用程序時的順序徹底相同。 |
每一個測試均可以使用運行程序來表示特定的用例。例如，下面的示例調用一個用戶配置(UserConfiguration)並檢查自動配置是否正確回退。調用run提供可與Assert4J.
@Test
public void defaultServiceBacksOff() {
this.contextRunner.withUserConfiguration(UserConfiguration.class)
.run((context) -> {
assertThat(context).hasSingleBean(UserService.class);
assertThat(context.getBean(UserService.class)).isSameAs(
context.getBean(UserConfiguration.class).myUserService());
});
}
@Configuration
static class UserConfiguration {
@Bean
public UserService myUserService() {
return new UserService("mine");
}
}
還能夠輕鬆自定義Environment，如如下示例所示：
@Test
public void serviceNameCanBeConfigured() {
this.contextRunner.withPropertyValues("user.name=test123").run((context) -> {
assertThat(context).hasSingleBean(UserService.class);
assertThat(context.getBean(UserService.class).getName()).isEqualTo("test123");
});
}
轉輪也可用於顯示ConditionEvaluationReport。報告可在INFO或DEBUG水平。下面的示例演示如何使用ConditionEvaluationReportLoggingListener若要在自動配置測試中打印報表，請執行如下操做。
@Test
public void autoConfigTest {
ConditionEvaluationReportLoggingListener initializer = new ConditionEvaluationReportLoggingListener(
LogLevel.INFO);
ApplicationContextRunner contextRunner = new ApplicationContextRunner()
.withInitializer(initializer).run((context) -> {
// Do something...
});
}
48.4.1模擬Web上下文
若是須要測試僅在servlet或反應性web應用程序上下文中操做的自動配置，請使用WebApplicationContextRunner或ReactiveWebApplicationContextRunner分別。
48.4.2凌駕於Classpath之上
還能夠測試在運行時不存在特定的類和/或包時會發生什麼。彈簧啓動船FilteredClassLoader這很容易被跑步者使用。在下面的示例中，咱們斷言若是UserService不存在，則自動配置被正確禁用：
@Test
public void serviceIsIgnoredIfLibraryIsNotPresent() {
this.contextRunner.withClassLoader(new FilteredClassLoader(UserService.class))
.run((context) -> assertThat(context).doesNotHaveBean("userService"));
}
48.5建立本身的初學者
庫的完整Spring啓動程序可能包含如下組件：
- 這，這個，那，那個
autoconfigure模塊，其中包含自動配置代碼。 - 這，這個，那，那個
starter提供依賴項的autoconfigure模塊以及庫和任何一般有用的附加依賴項。簡而言之，添加啓動器應該提供開始使用該庫所需的一切。
|
| 若是不須要將這兩個關注點分開，則能夠將自動配置代碼和依賴關係管理組合在一個模塊中。 |
48.5.1命名
您應該確保爲初學者提供適當的命名空間。不要以spring-boot，即便您使用不一樣的MavengroupId。咱們可能會提供官方支持的東西，您的自動配置在將來。
根據經驗，您應該以初學者的名字命名組合模塊。例如，假設您正在爲「acme」建立一個啓動程序，並將其命名爲自動配置模塊。acme-spring-boot-autoconfigure和啓動器acme-spring-boot-starter。若是隻有一個模塊組合了這兩個模塊，請命名它。acme-spring-boot-starter.
另外，若是初學者提供配置鍵，請爲它們使用惟一的命名空間。尤爲是，不要將鍵包含在SpringBoot使用的命名空間中(例如server, management, spring等等)。若是您使用相同的命名空間，咱們未來可能會以破壞模塊的方式修改這些命名空間。
確保觸發元數據生成這樣，IDE輔助也能夠用於您的密鑰。您可能須要查看生成的元數據(META-INF/spring-configuration-metadata.json)以確保您的鑰匙有正確的文檔記錄。
48.5.2 autoconfigure模塊
這，這個，那，那個autoconfigure模塊包含開始使用庫所需的全部內容。它還可能包含配置鍵定義(如@ConfigurationProperties)和任何可用於進一步自定義組件初始化方式的回調接口。
|
| 應該將庫的依賴項標記爲可選的，以即可以將 |
SpringBoot使用註釋處理器來收集元數據文件中自動配置的條件(META-INF/spring-autoconfigure-metadata.properties)若是該文件存在，則用於篩選不匹配的自動配置，這將縮短啓動時間。建議在包含自動配置的模塊中添加如下依賴項：
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-autoconfigure-processor</artifactId> <optional>true</optional> </dependency>
對於Gradle 4.5和更早版本，應該在compileOnly配置，如如下示例所示：
dependencies {
compileOnly "org.springframework.boot:spring-boot-autoconfigure-processor"
}
對於Gradle 4.6及更高版本，應該在annotationProcessor配置，如如下示例所示：
dependencies {
annotationProcessor "org.springframework.boot:spring-boot-autoconfigure-processor"
}
48.5.3啓動模塊
起動機其實是一個空罐子。它的惟一目的是提供使用庫所需的依賴項。你能夠把它看做是對開始所須要的東西的一種執拗己見的見解。
不要對添加啓動程序的項目進行假設。若是您要自動配置的庫一般須要其餘啓動程序，那麼也要提到它們。提供一套合適的違約若是可選依賴項的數量很高，則依賴關係可能很困難，由於您應該避免包含對於庫的典型使用來講沒必要要的依賴關係。換句話說，您不該該包括可選的依賴項。
|
| 不管哪一種方式，您的啓動程序都必須引用核心SpringBootStart( |
49.Kotlin支持
科特林是一種針對jvm(和其餘平臺)的靜態類型語言，它容許編寫簡潔而優雅的代碼，同時提供互操做性使用Java編寫的現有庫。
SpringBoot經過利用Spring框架、Spring數據和反應堆等其餘Spring項目中的支持來提供Kotlin支持。見Spring Framework Kotlin支持文檔想了解更多信息。
從SpringBoot和Kotlin開始，最簡單的方法就是遵循本綜合教程。您能夠經過如下方式建立新的kotlin項目start.spring.io。歡迎加入#Spring頻道科特林·斯拉克或者用spring和kotlin標籤上堆棧溢出若是你須要支持的話。
49.1所需經費
Spring Boot支持Kotlin 1.2.x。利用Kotlin，org.jetbrains.kotlin:kotlin-stdlib和org.jetbrains.kotlin:kotlin-reflect必定在類路徑上。這，這個，那，那個kotlin-stdlib變體kotlin-stdlib-jdk7和kotlin-stdlib-jdk8也能夠使用。
自默認狀況下，kotlin類是最終類。，您可能但願配置科特林-彈簧插件，以便自動打開Spring註釋的類，以便它們能夠被代理.
Jackson的Kotlin模塊用於序列化/反序列化Kotlin中的JSON數據。當在類路徑上找到它時，它會自動註冊。若是Jackson和Kotlin存在，則會記錄一條警告消息，但Jackson Kotlin模塊不存在。
|
| 這些依賴項和插件是默認狀況下提供的，若是一個引導程序將kotlin項目引導到start.spring.io. |
49.2零-安全
Kotlin的主要特徵之一是零安全。它處理的是null值，而不是將問題推遲到運行時並遇到NullPointerException。這有助於消除常見的bug來源，而無需支付包裝器的費用，例如Optional。Kotlin還容許使用帶有可空值的函數構造，如科特林空安全綜合指南.
儘管Java不容許在其類型系統中表示空安全性，可是Spring框架、Spring數據和反應堆如今經過工具友好的註釋提供了API的空安全性。默認狀況下，Kotlin中使用的JavaAPI中的類型被識別爲平臺類型對此，空檢查是放鬆的。Kotlin對JSR 305註釋的支持結合可空性，註釋爲Kotlin中相關的SpringAPI提供了空安全性。
能夠經過添加-Xjsr305具備下列選項的編譯器標誌：-Xjsr305={strict|warn|ignore}。默認行爲與-Xjsr305=warn。這，這個，那，那個strict值須要在從SpringAPI推斷的Kotlin類型中被考慮到空安全性，但在使用時應該知道SpringAPI的可空性聲明甚至可能在次要版本之間發展，並且未來可能會增長更多的檢查)。
|
| 泛型類型參數、varargs和數組元素的空性還不支持。看見spr-15942最新的信息。還要注意SpringBoot本身的API是還沒有附加說明. |
49.3 Kotlin API
49.3.1運行應用程序
Spring Boot提供了一種慣用的方法來運行應用程序runApplication<MyApplication>(*args)如如下示例所示：
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
@SpringBootApplication
class MyApplication
fun main(args: Array<String>) {
runApplication<MyApplication>(*args)
}
這是對SpringApplication.run(MyApplication::class.java, *args)。它還容許定製應用程序，如如下示例所示：
runApplication<MyApplication>(*args) {
setBannerMode(OFF)
}
49.3.2擴展
科特林擴展提供擴展具備其餘功能的現有類的能力。SpringBootKotlinAPI利用這些擴展爲現有的API添加新的Kotlin專用便利。
TestRestTemplate擴展，相似於Spring框架爲RestOperations在Spring框架中提供。除其餘外，擴展能夠利用Kotlin具體化的類型參數。
49.4撫養管理
爲了不在類路徑上混合不一樣版本的Kotlin依賴項，提供瞭如下Kotlin依賴項的依賴關係管理：
kotlin-reflectkotlin-runtimekotlin-stdlibkotlin-stdlib-jdk7kotlin-stdlib-jdk8kotlin-stdlib-jre7kotlin-stdlib-jre8
使用Maven，Kotlin版本能夠經過kotlin.version屬性和插件管理是爲kotlin-maven-plugin。使用Gradle，SpringBoot插件自動對齊kotlin.version用Kotlin插件的版本。
49.5 @ConfigurationProperties
@ConfigurationProperties目前只適用於lateinit或可空var屬性(建議使用前者)，由於由構造函數初始化的不可變類是還沒有獲得支持.
@ConfigurationProperties("example.kotlin")
class KotlinExampleProperties {
lateinit var name: String
lateinit var description: String
val myService = MyService()
class MyService {
lateinit var apiToken: String
lateinit var uri: URI
}
}
|
| 生成你本身的元數據使用註釋處理器， |
49.6測試
雖然能夠使用JUnit 4(默認狀況下由spring-boot-starter-test)爲了測試Kotlin代碼，建議使用JUnit 5。JUnit 5使測試類可以實例化一次，並在類的全部測試中重用。這樣就能夠使用@BeforeAll和@AfterAll關於非靜態方法的註釋，這很適合Kotlin。
若要使用JUnit 5，請排除junit:junit依賴於spring-boot-starter-test，添加JUnit 5依賴項，並相應地配置Maven或Gradle插件。見JUnit 5文件更多細節。你也須要將測試實例生命週期切換到「每類」。.
49.7資源
49.7.1進一步閱讀
- Kotlin語言參考
- 科特林·斯拉克(有專用的#彈簧通道)
- StackOverflow
spring和kotlin標籤 - 試試你的瀏覽器中的Kotlin
- Kotlin博客
- 使人敬畏的Kotlin
- 教程：使用SpringBoot和Kotlin構建Web應用程序
- 用Kotlin開發SpringBoot應用程序
- 帶Kotlin、Spring Boot和PostgreSQL的地理空間信使
- Introducing Kotlin support in Spring Framework 5.0
- SpringFramework5KotlinAPI，函數式方法
49.7.2例子
- 春靴-科特林-演示：常規SpringBoot+SpringDataJPA項目
- 混和：SpringBoot 2+WebFlux+反應性Spring數據MongoDB
- 春-科林-滿棧：WebFlux Kotlin徹底堆棧示例，用Kotlin2js做爲前端，而不是JavaScript或類型記錄
- 春-花瓣-科特林Kotlin版本的SpringPet亭示例應用程序
- 春-科林-深潛：一步地將Boot 1.0+Java遷移到Boot 2.0+Kotlin
五十接下來要讀什麼？
若是您想了解本節中討論的任何類的更多信息，能夠查看SpringBootAPI文檔或者您能夠瀏覽直接源代碼。若是您有特定的問題，請查看如何部分。
若是您對SpringBoot的核心特性感到滿意，您能夠繼續閱讀生產準備功能.
第五部分彈簧啓動執行器：可生產的特性
SpringBoot包含了許多其餘特性，以幫助您在將應用程序推向生產時監視和管理它。您能夠選擇使用HTTP端點或使用JMX來管理和監視應用程序。審計、健康和度量收集也能夠自動應用於應用程序。
51.啓用生產準備功能
這，這個，那，那個spring-boot-actuator模塊提供了SpringBoot的全部生產準備功能。啓用這些特性的最簡單方法是將依賴項添加到spring-boot-starter-actuator「Starter」
執行器的定義
執行器是指用於移動或控制某物的機械裝置的製造術語。執行器能夠從一個小的變化中產生大量的運動。
若要將執行器添加到基於Maven的項目中，請添加如下「初學者」依賴項：
<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")
}
52.端點
執行器端點容許您監視應用程序並與其交互。SpringBoot包含許多內置端點，並容許您添加本身的端點。例如，health端點提供了基本的應用程序健康信息。
每一個端點能夠是啓用或禁用。這將控制端點是否已建立，其bean是否存在於應用程序上下文中。要遠程訪問，端點還必須是經過JMX或HTTP公開。大多數應用程序選擇HTTP，其中端點的ID以及前綴爲/actuator映射到URL。例如，默認狀況下，health端點映射到/actuator/health.
有如下與技術無關的端點：
| ID | 描述 | 默認啓用 |
|---|---|---|
|
|
公開當前應用程序的審覈事件信息。 |
是 |
|
|
顯示應用程序中全部Springbean的完整列表。 |
是 |
|
|
公開可用的緩存。 |
是 |
|
|
顯示在配置類和自動配置類上計算的條件以及它們匹配或不匹配的緣由。 |
是 |
|
|
顯示全部 |
是 |
|
|
公開Spring的屬性 |
是 |
|
|
顯示已應用的任何天橋數據庫遷移。 |
是 |
|
|
顯示應用程序健康信息。 |
是 |
|
|
顯示HTTP跟蹤信息(默認狀況下，最後100個HTTP請求-響應交換)。 |
是 |
|
|
顯示任意應用程序信息。 |
是 |
|
|
顯示Spring集成圖。 |
是 |
|
|
顯示和修改應用程序中記錄器的配置。 |
是 |
|
|
顯示已應用的任何Liquibase數據庫遷移。 |
是 |
|
|
顯示當前應用程序的「度量」信息。 |
是 |
|
|
顯示全部 |
是 |
|
|
顯示應用程序中的計劃任務。 |
是 |
|
|
容許從Spring會話支持的會話存儲中檢索和刪除用戶會話。當使用Spring會話對反應性Web應用程序的支持時不可用。 |
是 |
|
|
讓應用程序優雅地關閉。 |
否 |
|
|
執行線程轉儲。 |
是 |
若是您的應用程序是Web應用程序(SpringMVC、SpringWebFlux或澤西島)，則能夠使用如下附加端點：
| ID | 描述 | 默認啓用 |
|---|---|---|
|
|
返回壓縮的GZip |
是 |
|
|
經過HTTP公開JMX bean(當Jolokia在類路徑上時，WebFlux不可用)。 |
是 |
|
|
返回日誌文件的內容(若是 |
是 |
|
|
以Prometheus服務器能夠刮取的格式公開度量。 |
是 |
要了解更多關於Actuator端點及其請求和響應格式的信息，請參閱單獨的API文檔(HTML或PDF).
52.1啓用端點
默認狀況下，除shutdown都啓用了。若要配置端點的啓用，請使用其management.endpoint.<id>.enabled財產。下面的示例啓用shutdown端點：
management.endpoint.shutdown.enabled=true
若是但願啓用端點而不是選擇退出，請將management.endpoints.enabled-by-default財產false並使用單個端點enabled屬性選擇返回。下面的示例啓用info終結點並禁用全部其餘端點：
management.endpoints.enabled-by-default=false management.endpoint.info.enabled=true
|
| 禁用的端點將從應用程序上下文中徹底刪除。若是隻想更改公開端點的技術，請使用 |
52.2暴露終結點
因爲端點可能包含敏感信息，所以應該仔細考慮什麼時候公開它們。下表顯示了內置端點的默認公開：
| ID | JMX | 萬維網 |
|---|---|---|
|
|
是 |
否 |
|
|
是 |
否 |
|
|
是 |
否 |
|
|
是 |
否 |
|
|
是 |
否 |
|
|
是 |
否 |
|
|
是 |
是 |
|
|
N/A |
否 |
|
|
是 |
否 |
|
|
是 |
是 |
|
|
是 |
是 |
|
|
N/A |
否 |
|
|
N/A |
否 |
|
|
是 |
否 |
|
|
是 |
否 |
|
|
是 |
否 |
|
|
是 |
否 |
|
|
N/A |
否 |
|
|
是 |
否 |
|
|
是 |
否 |
|
|
是 |
否 |
|
|
是 |
否 |
若要更改公開的端點，請使用下列特定技術include和exclude物業：
| 財產 | 違約 |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
這，這個，那，那個include屬性列出公開的端點的ID。這，這個，那，那個exclude屬性列出不該公開的端點的ID。這，這個，那，那個exclude屬性優先於include財產。左右開弓include和exclude屬性能夠配置爲端點ID列表。
例如，中止在JMX上公開全部端點，而只公開health和info端點，使用如下屬性：
management.endpoints.jmx.exposure.include=health,info
*可用於選擇全部端點。例如，要經過HTTP公開全部內容，除了env和beans端點，使用如下屬性：
management.endpoints.web.exposure.include=* management.endpoints.web.exposure.exclude=env,beans
|
|
management: endpoints: web: exposure: include: "*" |
|
| 若是您的應用程序是公開的，咱們強烈建議您也保護你的端點. |
|
| 若是要實現本身的端點公開策略，能夠註冊 |
52.3保護HTTP端點
您應該注意以與任何其餘敏感URL相同的方式保護HTTP端點。若是SpringSecurity存在，則使用SpringSecurity的內容協商策略在默認狀況下保護端點。若是您但願爲HTTP端點配置自定義安全性，例如，只容許具備特定角色的用戶訪問它們，SpringBoot提供了一些方便RequestMatcher對象，這些對象能夠與SpringSecurity組合使用。
典型的Spring安全配置可能以下所示：
@Configuration
public class ActuatorSecurity extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http.requestMatcher(EndpointRequest.toAnyEndpoint()).authorizeRequests()
.anyRequest().hasRole("ENDPOINT_ADMIN")
.and()
.httpBasic();
}
}
前面的示例使用EndpointRequest.toAnyEndpoint()若要將請求與任何端點匹配，而後確保全部請求都具備ENDPOINT_ADMIN角色。其餘幾種匹配方法也可用於EndpointRequest。請參閱API文檔(HTML或PDF)的細節。
若是您在防火牆後部署應用程序，您可能更但願您的全部執行器端點均可以被訪問，而不須要身份驗證。您能夠經過更改management.endpoints.web.exposure.include財產以下：
應用特性。
management.endpoints.web.exposure.include=*
此外，若是SpringSecurity存在，則須要添加自定義安全配置，該配置容許對端點進行未經身份驗證的訪問，以下面的示例所示：
@Configuration
public class ActuatorSecurity extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http.requestMatcher(EndpointRequest.toAnyEndpoint()).authorizeRequests()
.anyRequest().permitAll();
}
}
52.4配置終結點
端點自動緩存不接受任何參數的讀取操做的響應。若要配置端點緩存響應的時間量，請使用其cache.time-to-live財產。下面的示例設置beans端點的緩存爲10秒：
應用特性。
management.endpoint.beans.cache.time-to-live=10s
|
| 前綴 |
|
| 發出通過身份驗證的HTTP請求時， |
52.5用於執行器Web端點的超媒體
添加了一個「發現頁」，其中包含指向全部端點的連接。「發現頁」可在/actuator默認狀況下。
配置自定義管理上下文路徑時，「發現頁」將自動從/actuator管理上下文的根。例如，若是管理上下文路徑是/management，則發現頁可從/management。當管理上下文路徑設置爲/，則禁用發現頁以防止與其餘映射發生衝突的可能性。
52.6 CORS支助
跨源資源共享(CORS)是W3C規範這容許您以靈活的方式指定什麼類型的跨域請求被受權。若是使用SpringMVC或SpringWebFlux，則能夠配置Actuator的Web端點以支持此類場景。
默認狀況下，CORS支持是禁用的，而且僅在management.endpoints.web.cors.allowed-origins屬性已設置。如下配置容許GET和POST從example.com域：
management.endpoints.web.cors.allowed-origins=http://example.com management.endpoints.web.cors.allowed-methods=GET,POST
|
| 看見CorsEndpoint性質有關選項的完整列表。 |
52.7實現自定義端點
若是添加@Bean帶註釋@Endpoint，任何帶有註釋的方法@ReadOperation, @WriteOperation，或@DeleteOperation自動在JMX上公開，在Web應用程序中也經過HTTP公開。能夠使用澤西、SpringMVC或SpringWebFlux經過HTTP公開端點。
還能夠經過如下方法編寫特定於技術的端點：@JmxEndpoint或@WebEndpoint。這些端點僅限於各自的技術。例如@WebEndpoint只能經過HTTP而不是經過JMX公開。
能夠經過如下方法編寫特定於技術的擴展：@EndpointWebExtension和@EndpointJmxExtension。這些註釋容許您提供特定於技術的操做來加強現有端點。
最後，若是須要訪問特定於web框架的功能，則能夠實現servlet或Spring。@Controller和@RestController端點的代價是它們沒法經過JMX或使用不一樣的Web框架得到。
52.7.1接收輸入
端點上的操做經過其參數接收輸入。當經過Web公開時，這些參數的值將從URL的查詢參數和JSON請求體中獲取。當經過JMX公開時，參數將映射到MBean操做的參數。默認狀況下須要參數。它們能夠經過用@org.springframework.lang.Nullable.
JSON請求體中的每一個根屬性均可以映射到端點的一個參數。考慮如下JSON請求體：
{
"name": "test",
"counter": 42
}
這可用於調用一個寫操做，該操做將String name和int counter參數。
|
| 由於端點與技術無關，因此只能在方法簽名中指定簡單類型。特別是聲明具備自定義類型的單個參數，該類型定義 |
|
| 爲了容許將輸入映射到操做方法的參數，實現端點的Java代碼應該用 |
輸入類型轉換
若是有必要，傳遞給端點操做方法的參數將自動轉換爲所需的類型。在調用操做方法以前，經過JMX或HTTP請求接收的輸入將使用ApplicationConversionService.
52.7.2自定義Web終結點
上的操做。@Endpoint, @WebEndpoint，或@EndpointWebExtension使用澤西、SpringMVC或SpringWebFlux經過HTTP自動公開。
Web端點請求謂詞
對於Web公開的端點上的每一個操做，都會自動生成請求謂詞.
路徑
謂詞的路徑由端點的ID和Web暴露的端點的基本路徑決定。默認的基本路徑是/actuator。例如，具備ID的端點sessions將使用/actuator/sessions做爲謂詞中的路徑。
經過註釋操做方法的一個或多個參數，能夠進一步定製路徑。@Selector。這樣的參數做爲路徑變量添加到路徑謂詞中。當調用端點操做時，變量的值將傳遞給操做方法。
http方法
謂詞的HTTP方法由操做類型肯定，以下表所示：
| 操做 | http方法 |
|---|---|
|
|
|
|
|
|
|
|
|
消費
爲了@WriteOperation(httpPOST)，它使用請求體，謂詞的USEES子句是application/vnd.spring-boot.actuator.v2+json, application/json。對於全部其餘操做，USPES子句爲空。
產
謂詞的Products子句能夠由produces屬性的@DeleteOperation, @ReadOperation，和@WriteOperation註釋。屬性是可選的。若是不使用它，則會自動肯定Products子句。
若是操做方法返回void或VoidProducts子句爲空。若是操做方法返回org.springframework.core.io.Resource，產生子句是application/octet-stream。對於全部其餘操做，Products子句爲application/vnd.spring-boot.actuator.v2+json, application/json.
Web端點響應狀態
端點操做的默認響應狀態取決於操做類型(讀、寫或刪除)以及操做返回的內容(若是有的話)。
A @ReadOperation返回一個值，響應狀態爲200(OK)。若是不返回值，則響應狀態爲404(未找到)。
若是@WriteOperation或@DeleteOperation返回一個值，響應狀態爲200(OK)。若是不返回值，則響應狀態爲204(無內容)。
若是在沒有必需參數的狀況下調用操做，或者使用不能轉換爲所需類型的參數調用操做方法，則響應狀態將爲400(壞請求)。
Web端點範圍請求
HTTP範圍請求可用於請求HTTP資源的一部分。當使用SpringMVC或SpringWebFlux時，返回org.springframework.core.io.Resource自動支持範圍請求。
|
| 使用澤西時不支持範圍請求。 |
Web端點安全
web端點或特定於web的端點擴展上的操做能夠接收當前java.security.Principal或org.springframework.boot.actuate.endpoint.SecurityContext做爲方法參數。前者一般與@Nullable爲通過身份驗證的用戶和未經身份驗證的用戶提供不一樣的行爲。後者一般用於使用其isUserInRole(String)方法。
52.7.3 servlet端點
A Servlet經過實現帶註釋的類，能夠將其公開爲端點。@ServletEndpoint也實現了Supplier<EndpointServlet>。Servlet端點提供與servlet容器更深層次的集成，但代價是可移植性。它們用於公開現有的Servlet做爲終點。對於新的端點，@Endpoint和@WebEndpoint只要有可能，應該首選註釋。
52.7.4主計長端點
@ControllerEndpoint和@RestControllerEndpoint能夠用於實現僅由SpringMVC或SpringWebFlux公開的端點。使用SpringMVC和SpringWebFlux的標準註釋映射方法，如@RequestMapping和@GetMapping，將端點的ID用做路徑的前綴。控制器端點提供與Spring的Web框架更深層次的集成，但代價是可移植性。這，這個，那，那個@Endpoint和@WebEndpoint只要有可能，應該首選註釋。
52.8衛生信息
您能夠使用健康信息來檢查正在運行的應用程序的狀態。當生產系統發生故障時，監控軟件常用它來警告某人。公開的信息health端點依賴於management.endpoint.health.show-details屬性，能夠使用如下值之一配置該屬性：
| 名字，姓名 | 描述 |
|---|---|
|
|
細節永遠不會顯示。 |
|
|
詳細信息只顯示給受權用戶。受權角色能夠使用 |
|
|
詳細信息顯示給全部用戶。 |
默認值是never。當用戶處於端點的一個或多個角色時，他們被認爲是被受權的。若是端點沒有配置角色(默認)，則全部通過身份驗證的用戶都被視爲已受權。能夠使用management.endpoint.health.roles財產。
|
| 若是您已經保護了您的應用程序並但願使用 |
健康信息是從 HealthIndicatorRegistry(默認狀況下，全部HealthIndicator中定義的實例。ApplicationContext。Spring Boot包括許多自動配置的HealthIndicators你也能夠本身寫。默認狀況下，最終系統狀態由HealthAggregator對每一個狀態進行排序。HealthIndicator基於一個有序的狀態列表。排序列表中的第一個狀態用做整體健康狀態。若是沒有HealthIndicator返回已知的狀態。HealthAggregator..UNKNOWN使用狀態。
|
| 這，這個，那，那個 |
52.8.1自動配置的HealthIndicator
如下內容HealthIndicators在適當狀況下由SpringBoot自動配置：
| 名字，姓名 | 描述 |
|---|---|
| 檢查卡桑德拉數據庫是否啓動。 |
|
| 檢查低磁盤空間。 |
|
| 檢查鏈接到 |
|
| 檢查Elasticearch集羣是否已啓動。 |
|
| 檢查InfluxDB服務器是否已啓動。 |
|
| 檢查JMS代理是否已運行。 |
|
| 檢查郵件服務器是否已啓動。 |
|
| 檢查蒙戈數據庫是否打開。 |
|
| 檢查Neo4j服務器是否已啓動。 |
|
| 檢查兔子服務器是否啓動。 |
|
| 檢查Redis服務器是否已啓動。 |
|
| 檢查Solr服務器是否已啓動。 |
|
| 能夠經過設置 |
52.8.2書寫自定義健康指示器
若要提供自定義健康信息，能夠註冊實現HealthIndicator接口。您須要提供health()方法並返回Health迴應。這，這個，那，那個Health響應應該包括狀態，而且能夠選擇包括要顯示的其餘詳細信息。下面的代碼顯示了一個示例HealthIndicator執行狀況：
import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Component;
@Component
public class MyHealthIndicator 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();
}
}
|
| 給定值的標識符。 |
除了SpringBoot的預約義Status類型，也有可能Health返回自定義Status表示新的系統狀態的。在這種狀況下，HealthAggregator接口，或者使用management.health.status.order配置屬性。
例如，假設一個新的Status有代碼FATAL正在用在你的HealthIndicator實現。若要配置嚴重程度順序，請將如下屬性添加到應用程序屬性中：
management.health.status.order=FATAL, DOWN, OUT_OF_SERVICE, UNKNOWN, UP
響應中的HTTP狀態代碼反映了整體健康情況(例如，UP地圖到200，同時OUT_OF_SERVICE和DOWN地圖到503)。若是經過HTTP訪問健康端點，還可能但願註冊自定義狀態映射。例如，如下屬性映射FATAL至503(服務不可用)：
management.health.status.http-mapping.FATAL=503
|
| 若是您須要更多的控制，您能夠定義本身的 |
下表顯示了內置狀態的默認狀態映射：
| 地位 | 映射 |
|---|---|
| 向下 |
服務不可用(503) |
| 停用 |
服務不可用(503) |
| 向上 |
默認狀況下不進行映射，所以http狀態爲200。 |
| 未知數 |
默認狀況下不進行映射，所以http狀態爲200。 |
52.8.3反應性健康指標
對於反應性應用程序，如使用SpringWebFlux的應用程序，ReactiveHealthIndicator提供非阻塞契約，以得到應用程序健康。相似於傳統HealthIndicator的內容收集健康信息。 ReactiveHealthIndicatorRegistry(默認狀況下，全部HealthIndicator和 ReactiveHealthIndicator中定義的實例。ApplicationContext。正規化HealthIndicator在彈性調度程序上執行不針對反應性API的檢查。
|
| 在反應性應用程序中， |
若要從反應性API中提供自定義健康信息，能夠註冊實現ReactiveHealthIndicator接口。下面的代碼顯示了一個示例ReactiveHealthIndicator執行狀況：
@Component
public class MyReactiveHealthIndicator implements ReactiveHealthIndicator {
@Override
public Mono<Health> health() {
return doHealthCheck() //perform some specific health check that returns a Mono<Health>
.onErrorResume(ex -> Mono.just(new Health.Builder().down(ex).build())));
}
}
|
| 若要自動處理錯誤，請考慮從 |
52.8.4自動配置的ReactiveHealthIndicator
如下內容ReactiveHealthIndicators在適當狀況下由SpringBoot自動配置：
| 名字，姓名 | 描述 |
|---|---|
| 檢查卡桑德拉數據庫是否啓動。 |
|
| 檢查蒙戈數據庫是否打開。 |
|
| 檢查Redis服務器是否已啓動。 |
|
| 若有必要，應採用反應性指標取代常規指標。還有，任何 |
52.9申請資料
應用程序信息公開從全部InfoContributor中定義的beanApplicationContext。Spring Boot包括許多自動配置的InfoContributor豆子，你能夠本身寫。
52.9.1自動配置的InfoContributor
如下內容InfoContributor在適當的狀況下，Spring Boot會自動配置bean：
| 名字，姓名 | 描述 |
|---|---|
| 公開 |
|
| 若是 |
|
| 若是 |
|
| 能夠經過設置 |
52.9.2自定義應用程序信息
您能夠自定義由info經過設置端點info.*彈簧特性。全Environment屬性下的屬性。info鍵會自動暴露。例如，能夠將下列設置添加到application.properties檔案：
info.app.encoding=UTF-8 info.app.java.source=1.8 info.app.java.target=1.8
|
| 與其硬編碼這些值，您還能夠在構建時展開info屬性. 假設您使用了Maven，您能夠重寫前面的示例，以下所示： info.app.encoding=@project.build.sourceEncoding@ info.app.java.source=@java.version@ info.app.java.target=@java.version@ |
52.9.3 Git提交信息
的另外一個有用特性info端點是它發佈有關git構建項目時的源代碼存儲庫。若是GitPropertiesbean可用，則git.branch, git.commit.id，和git.commit.time屬性暴露了。
|
| A |
若是要顯示完整的git信息(即git.properties)，使用management.info.git.mode財產以下：
management.info.git.mode=full
52.9.4構建信息
若是BuildPropertiesbean可用，則info端點還能夠發佈有關生成的信息。若是META-INF/build-info.properties文件可在類路徑中使用。
|
| Maven和Gradle插件均可以生成該文件。見「生成信息「更多細節。 |
52.9.5編寫自定義信息貢獻者
若要提供自定義應用程序信息，能夠註冊實現InfoContributor接口。
下面的示例提供了一個example具備單個值的條目：
import java.util.Collections;
import org.springframework.boot.actuate.info.Info;
import org.springframework.boot.actuate.info.InfoContributor;
import org.springframework.stereotype.Component;
@Component
public class ExampleInfoContributor implements InfoContributor {
@Override
public void contribute(Info.Builder builder) {
builder.withDetail("example",
Collections.singletonMap("key", "value"));
}
}
若是你到達info端點，您應該會看到一個包含如下附加條目的響應：
{
"example": {
"key" : "value"
}
}
53.HTTP上的監控與管理
若是您正在開發一個Web應用程序，SpringBootActuator會自動配置全部啓用的端點，以便經過HTTP公開。默認約定是使用id的端點的前綴爲/actuator做爲URL路徑。例如health暴露爲/actuator/health。提示：SpringMVC、SpringWebFlux和澤西支持執行機構。
53.1自定義管理端點路徑
有時，自定義管理端點的前綴是有用的。例如，您的應用程序可能已經使用了/actuator爲了另外一個目的。您能夠使用management.endpoints.web.base-path屬性更改管理端點的前綴，如如下示例所示：
management.endpoints.web.base-path=/manage
前文application.properties示例將端點更改成/actuator/{id}到/manage/{id}(例如，/manage/info).
|
| 除非已將管理端口配置爲使用不一樣的HTTP端口公開端點, |
若是要將端點映射到其餘路徑，則能夠使用management.endpoints.web.path-mapping財產。
下面的示例映射/actuator/health到/healthcheck:
應用特性。
management.endpoints.web.base-path=/ management.endpoints.web.path-mapping.health=healthcheck
53.2自定義管理服務器端口
使用默認的HTTP端口公開管理端點是基於雲的部署的明智選擇。可是，若是應用程序在您本身的數據中心內運行，您可能更願意使用不一樣的HTTP端口來公開端點。
您能夠設置management.server.port屬性更改HTTP端口，如如下示例所示：
management.server.port=8081
53.3配置特定於管理的SSL
當配置爲使用自定義端口時，管理服務器也能夠使用它本身的ssl經過如下各類配置management.server.ssl.*財產。例如，這樣作可讓管理服務器在HTTP上可用，而主應用程序則使用HTTPS，如如下屬性設置所示：
server.port=8443 server.ssl.enabled=true server.ssl.key-store=classpath:store.jks server.ssl.key-password=secret management.server.port=8080 management.server.ssl.enabled=false
或者，主服務器和管理服務器均可以使用SSL，但能夠使用不一樣的密鑰存儲，以下所示：
server.port=8443 server.ssl.enabled=true server.ssl.key-store=classpath:main.jks server.ssl.key-password=secret management.server.port=8080 management.server.ssl.enabled=true management.server.ssl.key-store=classpath:management.jks management.server.ssl.key-password=secret
53.4自定義管理服務器地址
屬性來自定義管理端點可用的地址。management.server.address財產。若是您只想在內部或面向操做的網絡上偵聽，或者只想偵聽來自localhost.
|
| 只有當端口與主服務器端口不一樣時，才能偵聽不一樣的地址。 |
下面的示例application.properties不容許遠程管理鏈接：
management.server.port=8081 management.server.address=127.0.0.1
53.5禁用HTTP端點
若是不但願經過HTTP公開端點，能夠將管理端口設置爲-1，如如下示例所示：
management.server.port=-1
這能夠使用management.endpoints.web.exposure.exclude屬性，以下面的示例所示：
management.endpoints.web.exposure.exclude=*
54.對JMX的監測和管理
Java管理擴展(JMX)提供了監視和管理應用程序的標準機制。默認狀況下，SpringBoot將管理端點做爲JMX MBean公開在org.springframework.boot域。
54.1定製MBean名稱
MBean的名稱一般是從id端點。例如，health端點公開爲org.springframework.boot:type=Endpoint,name=Health.
若是應用程序包含多個SpringApplicationContext，你可能會發現名字衝突。若要解決此問題，能夠將spring.jmx.unique-names財產true因此MBean名稱老是惟一的。
您還能夠自定義暴露端點的JMX域。下面的設置顯示了在application.properties:
spring.jmx.unique-names=true management.endpoints.jmx.domain=com.example.myapp
54.2禁用JMX端點
若是不但願在JMX上公開端點，則能夠將management.endpoints.jmx.exposure.exclude財產*，如如下示例所示：
management.endpoints.jmx.exposure.exclude=*
54.3經過HTTP爲JMX使用Jolokia
Jolokia是一種JMX-HTTP橋，它提供了一種訪問JMXbean的替代方法。若要使用Jolokia，請將依賴項包含到org.jolokia:jolokia-core。例如，對於Maven，能夠添加如下依賴項：
<dependency> <groupId>org.jolokia</groupId> <artifactId>jolokia-core</artifactId> </dependency>
而後，能夠經過添加jolokia或*到management.endpoints.web.exposure.include財產。而後，您能夠經過如下方式訪問它：/actuator/jolokia在您的管理HTTP服務器上。
54.3.1定製Jolokia
Jolokia有許多設置，傳統上經過設置servlet參數來配置這些設置。使用SpringBoot，您能夠使用application.properties檔案。若要這樣作，請在參數前面加上management.endpoint.jolokia.config.，如如下示例所示：
management.endpoint.jolokia.config.debug=true
54.3.2禁用Jolokia
若是使用Jolokia但不但願SpringBoot配置它，請將management.endpoint.jolokia.enabled財產false，以下：
management.endpoint.jolokia.enabled=false
55.伐木工
SpringBootActuator包括在運行時查看和配置應用程序日誌級別的能力。您能夠查看整個列表或單個記錄器的配置，該配置由顯式配置的日誌級別以及日誌框架提供的有效日誌級別組成。這些級別能夠是：
TRACEDEBUGINFOWARNERRORFATALOFFnull
null指示沒有顯式配置。
55.1配置記錄器
若要配置給定的記錄器，POST資源URI的部分實體，如如下示例所示：
{
"configuredLevel": "DEBUG"
}
|
| 若要「重置」記錄器的特定級別(並使用默認配置)，能夠傳遞 |
56.度量標準
SpringBoot執行器提供依賴關係管理和自動配置千分尺，支持多個監視系統的應用程序度量外觀，包括：
|
56.1開始
Spring Boot自動配置複合MeterRegistry併爲它在類路徑上找到的每一個受支持的實現向複合添加一個註冊表。依賴於micrometer-registry-{system}在運行時，類路徑足以讓SpringBoot配置註冊表。
大多數註冊中心都有共同的特性。例如，即便千分尺註冊表實如今類路徑上，也能夠禁用特定的註冊表。例如，要禁用Datadog：
management.metrics.export.datadog.enabled=false
Spring Boot還會將任何自動配置的註冊表添加到Metrics除非您顯式地告訴它不要：
management.metrics.use-global-registry=false
您能夠註冊任意數量的MeterRegistryCustomizerbean以進一步配置註冊表，例如在向註冊表註冊任何表以前應用公共標記：
@Bean
MeterRegistryCustomizer<MeterRegistry> metricsCommonTags() {
return registry -> registry.config().commonTags("region", "us-east-1");
}
能夠將自定義應用於特定的註冊表實現，方法是更具體地說明泛型類型：
@Bean
MeterRegistryCustomizer<GraphiteMeterRegistry> graphiteMetricsNamingConvention() {
return registry -> registry.config().namingConvention(MY_CUSTOM_CONVENTION);
}
有了這個設置，你就能夠注入MeterRegistry在組件和註冊度量中：
@Component
public class SampleBean {
private final Counter counter;
public SampleBean(MeterRegistry registry) {
this.counter = registry.counter("received.messages");
}
public void handleMessage(String message) {
this.counter.increment();
// handle message implementation
}
}
春靴配置內置的工具。(即：MeterBinder實現)，您能夠經過配置或專用註釋標記進行控制。
56.2支持的監測系統
56.2.1 Atlas
默認狀況下，度量被導出到阿特拉斯在你的本地機器上運行。的位置Atlas服務器能夠使用如下方法提供使用：
management.metrics.export.atlas.uri=http://atlas.example.com:7101/api/v1/publish
56.2.2 Datadog
Datadog註冊表將度量推送到datadoghq週期性的。將指標導出到Datadog，必須提供您的API密鑰：
management.metrics.export.datadog.api-key=YOUR_KEY
還能夠更改將度量發送到Datadog的間隔：
management.metrics.export.datadog.step=30s
56.2.3 Dynatraces
DynatraceRegistry週期性地將度量推送到配置的URI。將指標導出到戴納通，必須提供API令牌、設備ID和URI：
management.metrics.export.dynatrace.api-token=YOUR_TOKEN management.metrics.export.dynatrace.device-id=YOUR_DEVICE_ID management.metrics.export.dynatrace.uri=YOUR_URI
您還能夠更改將度量發送到Dynatraces的時間間隔：
management.metrics.export.dynatrace.step=30s
56.2.4彈性
默認狀況下，度量被導出到彈性在你的本地機器上運行。能夠使用如下屬性提供要使用的彈性服務器的位置：
management.metrics.export.elastic.hosts=http://elastic.example.com:8086
56.2.5神經節
默認狀況下，度量被導出到神經節在你的本地機器上運行。這，這個，那，那個Ganglia服務器能夠使用如下方法提供要使用的主機和端口：
management.metrics.export.ganglia.host=ganglia.example.com management.metrics.export.ganglia.port=9649
56.2.6石墨
默認狀況下，度量被導出到石墨在你的本地機器上運行。這，這個，那，那個石墨服務器能夠使用如下方法提供要使用的主機和端口：
management.metrics.export.graphite.host=graphite.example.com management.metrics.export.graphite.port=9004
千分尺提供缺省值HierarchicalNameMapper它控制着維度米id的大小。映射到平面層次結構名稱.
|
| 要控制這種行爲，請定義 |
@Bean
public GraphiteMeterRegistry graphiteMeterRegistry(GraphiteConfig config, Clock clock) {
return new GraphiteMeterRegistry(config, clock, MY_HIERARCHICAL_MAPPER);
}
56.2.7流入
默認狀況下，度量被導出到流入在你的本地機器上運行。的位置流入服務器能夠使用如下方法提供使用：
management.metrics.export.influx.uri=http://influx.example.com:8086
56.2.8 JMX
千分尺提供了一個分層映射到JMX，主要是一種廉價的、可移植的本地查看度量的方法。默認狀況下，度量被導出到metricsJMX域能夠使用如下方法提供要使用的域：
management.metrics.export.jmx.domain=com.example.app.metrics
千分尺提供缺省值HierarchicalNameMapper它控制着維度米id的大小。映射到平面層次結構名稱.
|
| 要控制這種行爲，請定義 |
@Bean
public JmxMeterRegistry jmxMeterRegistry(JmxConfig config, Clock clock) {
return new JmxMeterRegistry(config, clock, MY_HIERARCHICAL_MAPPER);
}
56.2.9新文物
新的遺留註冊中心將度量推送到新文物週期性的。將指標導出到新文物，必須提供您的API密鑰和賬戶ID：
management.metrics.export.newrelic.api-key=YOUR_KEY management.metrics.export.newrelic.account-id=YOUR_ACCOUNT_ID
您還能夠更改將度量發送到NewRelic的時間間隔：
management.metrics.export.newrelic.step=30s
56.2.10普羅米修斯
普羅米修斯指望對單個應用實例進行抓取或輪詢，以得到度量標準。Spring Boot提供了一個執行器端點，可在/actuator/prometheus提出[醫]擦傷普羅米修斯(Prometheus)適當的格式。
|
| 默認狀況下，端點不可用，必須公開，請參見暴露端點更多細節。 |
下面是一個例子scrape_config添加到prometheus.yml:
scrape_configs: - job_name: 'spring' metrics_path: '/actuator/prometheus' static_configs: - targets: ['HOST:PORT']
56.2.11 SignalFx
SignalFx註冊表將度量推送到SignalFx週期性的。將指標導出到SignalFx，必須提供訪問令牌：
management.metrics.export.signalfx.access-token=YOUR_ACCESS_TOKEN
還能夠更改將度量發送到SignalFx的間隔：
management.metrics.export.signalfx.step=30s
56.2.12簡單
千分尺附帶一個簡單的內存後端，若是沒有配置其餘註冊表，它將自動用做後備。這容許您查看在度量端點.
當您使用其餘可用後端時，內存中的後端會當即禁用本身。您還能夠顯式禁用它：
management.metrics.export.simple.enabled=false
56.2.13國家統計d
StatsD註冊中心熱切地將度量經過UDP推送給StatsD代理。默認狀況下，度量被導出到StatsD探員在你的本地機器上運行。能夠使用如下方法提供要使用的StatsD代理主機和端口：
management.metrics.export.statsd.host=statsd.example.com management.metrics.export.statsd.port=9125
還能夠將StatsD行協議更改成使用(默認爲Datadog)：
management.metrics.export.statsd.flavor=etsy
56.2.14波前
波前註冊表將度量推送到波前週期性的。若是要將指標導出到波前直接地，必須提供您的API令牌：
management.metrics.export.wavefront.api-token=YOUR_API_TOKEN
或者，您能夠使用在您的環境中設置的Wavefront Sideecar或內部代理將度量數據轉發到Wavefront API主機：
management.metrics.export.wavefront.uri=proxy://localhost:2878
|
| 若是將度量發佈到Wavefront代理(如文獻)，主機必須位於 |
還能夠更改將度量發送到Wavefront的間隔：
management.metrics.export.wavefront.step=30s
56.3支助計量
SpringBoot在適用時註冊瞭如下核心指標：
-
JVM指標，報告如下指標的使用狀況：
- 各類內存和緩衝池
- 與垃圾收集有關的統計數據
- 線程利用率
- 裝入/卸載的類數
- CPU度量
- 文件描述符度量
- 卡夫卡消費者衡量標準
- Log4j2度量：記錄每一個級別記錄到Log4j2的事件數。
- Logback度量：記錄在每一個級別登陸到Logback的事件數
- 正常運行時間度量：報告正常運行時間的度量和表示應用程序的絕對啓動時間的固定度量
- Tomcat度量
- 彈簧集成度量標準
56.3.1 SpringMVC度量
自動配置支持SpringMVC處理的請求的檢測。何時management.metrics.web.server.auto-time-requests是true，此工具用於全部請求。或者，當設置爲false，您能夠經過添加@Timed請求處理方法：
@RestController
@Timed
public class MyController {
@GetMapping("/api/people")
@Timed(extraTags = { "region", "us-east-1" }) @Timed(value = "all.people", longTask = true)
public List<Person> listPeople() { ... }
}
|
|
一個控制器類，用於在控制器中的每一個請求處理程序上啓用時間。 |
|
|
爲單個端點啓用的一種方法。若是類中有它，這是沒必要要的，可是能夠用於進一步自定義這個特定端點的定時器。 |
|
|
一種方法 |
默認狀況下，使用名稱生成度量，http.server.requests。能夠經過設置management.metrics.web.server.requests-metric-name財產。
默認狀況下，與SpringMVC相關的指標被標記爲如下信息：
| 標籤 | 描述 |
|---|---|
|
|
處理請求時拋出的任何異常的簡單類名。 |
|
|
請求的方法(例如， |
|
|
請求的結果基於響應的狀態代碼。1XX是 |
|
|
響應的HTTP狀態代碼(例如， |
|
|
若是可能的話，在變量替換以前請求的URI模板(例如， |
若要自定義標記，請提供@Bean實現WebMvcTagsProvider.
56.3.2 SpringWebFlux度量
自動配置支持由WebFlux控制器和功能處理程序處理的全部請求的檢測.
默認狀況下，使用名稱生成度量。http.server.requests。能夠經過設置management.metrics.web.server.requests-metric-name財產。
默認狀況下，與WebFlux相關的度量使用如下信息進行標記：
| 標籤 | 描述 |
|---|---|
|
|
處理請求時拋出的任何異常的簡單類名。 |
|
|
請求的方法(例如， |
|
|
請求的結果基於響應的狀態代碼。1XX是 |
|
|
響應的HTTP狀態代碼(例如， |
|
|
若是可能的話，在變量替換以前請求的URI模板(例如， |
若要自定義標記，請提供@Bean實現WebFluxTagsProvider.
56.3.3 HTTP客戶端度量
彈簧啓動執行器管理兩個RestTemplate和WebClient。爲此，必須注入一個自動配置的構建器，並使用它建立實例：
RestTemplateBuilder爲RestTemplateWebClient.Builder爲WebClient
還能夠手動應用負責此工具的自定義器，即MetricsRestTemplateCustomizer和MetricsWebClientCustomizer.
默認狀況下，使用名稱生成度量，http.client.requests。能夠經過設置management.metrics.web.client.requests-metric-name財產。
默認狀況下，工具化客戶端生成的度量將使用如下信息進行標記：
method，請求的方法(例如，GET或POST).uri，在變量替換以前請求的URI模板(若是可能的話)(例如，/api/person/{id}).status，響應的HTTP狀態代碼(例如，200或500).clientNameURI的主機部分。
若要自定義標記，並根據客戶端的選擇，能夠提供@Bean實現RestTemplateExchangeTagsProvider或WebClientExchangeTagsProvider。中有一些方便的靜態函數。RestTemplateExchangeTags和WebClientExchangeTags.
56.3.4緩存度量
自動配置啓用全部可用的儀表。Caches在啓動時以指標爲前綴cache。對於一組基本的度量，緩存檢測是標準化的。此外，緩存特定的指標也是可用的.
支持如下緩存庫：
- 咖啡因
- EhCache 2
- 哈澤爾卡斯特
- 任何符合JCache(JSR-107)的實現
指標由緩存的名稱和CacheManager它是從bean名稱派生的。
|
| 只有啓動時可用的緩存才綁定到註冊表。對於在啓動階段後動態建立或以編程方式建立的緩存，須要顯式註冊.一個 |
56.3.5數據源度量
自動配置啓用全部可用的儀表。DataSource對象具備名爲jdbc。數據源檢測結果是表示池中當前活動的、最大容許的和最小容許的鏈接的量規。這些量規中的每個都有一個前綴爲jdbc.
度量標準也被標記爲DataSource根據bean名稱計算。
|
| 默認狀況下，SpringBoot爲全部受支持的數據源提供元數據；您能夠添加其餘 |
另外，Hikari特有的度量也公開了一個hikaricp前綴。每一個度量都由池的名稱標記(能夠用spring.datasource.name).
56.3.6冬眠度量
自動配置支持全部可用Hibernate的檢測。EntityManagerFactory實例，這些實例使用名爲hibernate.
度量標準也被標記爲EntityManagerFactory它是從bean名稱派生的。
要啓用統計信息，標準的jpa屬性hibernate.generate_statistics必須設置爲true。您能夠在自動配置的EntityManagerFactory如如下示例所示：
spring.jpa.properties.hibernate.generate_statistics=true
56.3.7兔MQ計量
自動配置將啓用全部可用的RabbitMQ鏈接工廠的儀表，其度量名爲rabbitmq.
56.4註冊自定義指標
若要註冊自定義度量，請插入MeterRegistry在您的組件中，以下面的示例所示：
class Dictionary {
private final List<String> words = new CopyOnWriteArrayList<>();
Dictionary(MeterRegistry registry) {
registry.gaugeCollectionSize("dictionary.size", Tags.empty(), this.words);
}
// …
}
若是您發如今組件或應用程序之間反覆測試一組度量，則能夠將此套件封裝在MeterBinder執行。默認狀況下，全部MeterBinderbean將自動綁定到Spring管理的MeterRegistry.
56.5定製我的指標
若是須要將自定義應用於特定的Meter實例能夠使用io.micrometer.core.instrument.config.MeterFilter接口。默認狀況下，全部MeterFilter豆子將自動應用於千分尺。MeterRegistry.Config.
例如，若是要重命名mytag.region標記到mytag.area開始的全部儀表IDcom.example，您能夠這樣作：
@Bean
public MeterFilter renameRegionTagMeterFilter() {
return MeterFilter.renameTag("com.example", "mytag.region", "mytag.area");
}
56.5.1通用標籤
常見的標籤一般用於操做環境中的維度向下鑽取，如主機、實例、區域、堆棧等。公用標記應用於全部儀表，能夠配置以下示例所示：
management.metrics.tags.region=us-east-1 management.metrics.tags.stack=prod
上面的示例添加了region和stack標記到全部值爲us-east-1和prod分別。
|
| 若是使用Graphite，公共標記的順序很是重要。因爲使用這種方法沒法保證公共標記的順序，所以建議Graphite用戶定義自定義 |
每米56.5.2
除了……以外MeterFilterbean，也能夠使用屬性在每米的基礎上應用有限的定製集。每米自定義適用於以給定名稱開頭的全部儀表ID.例如，如下內容將禁用任何具備ID的儀表。example.remote
management.metrics.enable.example.remote=false
如下屬性容許每米定製：
表56.1.每米定製
| 財產 | 描述 |
|---|---|
|
|
是否拒絕儀表發射任何指標。 |
|
|
是否發佈適合於計算聚合(跨維度)百分位數近似的直方圖。 |
|
|
發佈應用程序中計算的百分位數 |
|
|
使用SLA定義的桶發佈累積直方圖。 |
有關背後概念的更多詳細信息percentiles-histogram, percentiles和sla參考「直方圖和百分位數」部分千分尺的文件。
56.6計量終點
Spring Boot提供了一個metrics可用於診斷性地檢查應用程序收集的指標的端點。默認狀況下，端點不可用，必須公開，請參見暴露端點更多細節。
導航到/actuator/metrics顯示可用儀表名稱的列表。您能夠經過提供一個選擇器的名稱來向下查看有關特定儀表的信息。/actuator/metrics/jvm.memory.max.
|
| 您在這裏使用的名稱應該與代碼中使用的名稱相匹配，而不是在命名以後使用的名稱。換句話說，若是 |
您還能夠添加任意數量的tag=KEY:VALUE將參數查詢到URL的末尾，以便在儀表上按尺寸向下鑽取。/actuator/metrics/jvm.memory.max?tag=area:nonheap.
|
| 報告的測量結果是相加與表名匹配的全部儀表的統計數據以及已應用的任何標記。所以，在上面的示例中，返回的「value」統計數據是堆中「Code Cache」、「壓縮類空間」和「Metaspace」區域的最大內存足跡的總和。若是您只想查看「Metaspace」的最大大小，能夠添加一個額外的 |
57.審計
SpringSecurity運行後，SpringBootActuator有一個靈活的審計框架來發布事件(默認狀況下，「身份驗證成功」、「失敗」和「訪問拒絕」異常)。此特性對於報告和實現基於身份驗證失敗的鎖定策略很是有用。若要自定義已發佈的安全事件，能夠提供您本身的AbstractAuthenticationAuditListener和AbstractAuthorizationAuditListener.
您還能夠將審計服務用於您本身的業務事件。要作到這一點，要麼注入現有的AuditEventRepository在您本身的組件中直接使用該組件，或者發佈AuditApplicationEvent與春天ApplicationEventPublisher(經過實施ApplicationEventPublisherAware).
58.http跟蹤
全部HTTP請求都自動啓用跟蹤。您能夠查看httptrace終結點並獲取關於最後100個請求-響應交換的基本信息。
58.1自定義HTTP跟蹤
若要自定義每一個跟蹤中包含的項，請使用management.trace.http.include配置屬性。對於高級定製，請考慮註冊本身的HttpExchangeTracer執行。
默認狀況下，InMemoryHttpTraceRepository它存儲最後100個請求響應交換的跟蹤。若是須要擴展容量，能夠定義您本身的InMemoryHttpTraceRepository豆子您還能夠建立本身的備選方案。HttpTraceRepository執行。
59.過程監測
在.。spring-boot模塊中，您能夠找到兩個類來建立一般對進程監視有用的文件：
ApplicationPidFileWriter建立包含應用程序PID的文件(默認狀況下，在應用程序目錄中，文件名爲application.pid).WebServerPortFileWriter建立一個文件(或多個文件)，其中包含正在運行的web服務器的端口(默認狀況下，在應用程序目錄中，文件名爲application.port).
默認狀況下，不會激活這些寫入器，但能夠啓用：
59.1擴展配置
在.。META-INF/spring.factories文件，您能夠激活寫入PID文件的監聽器，以下面的示例所示：
org.springframework.context.ApplicationListener=\ org.springframework.boot.context.ApplicationPidFileWriter,\ org.springframework.boot.web.context.WebServerPortFileWriter
59.2以編程方式
還能夠經過調用SpringApplication.addListeners(…)方法並傳遞適當的Writer對象。此方法還容許您自定義Writer構造函數
六十雲鑄造支架
SpringBoot的執行器模塊包括在部署到兼容的CloudFoundry實例時激活的額外支持。這，這個，那，那個/cloudfoundryapplicationPATH爲全部用戶提供了另外一種安全路由。@Endpoint豆子
擴展支持使CloudFoundryManagementUI(例如能夠用來查看已部署應用程序的Web應用程序)能夠經過SpringBoot執行器信息獲得加強。例如，應用程序狀態頁可能包含完整的健康信息，而不是典型的「運行」或「中止」狀態。
|
| 這，這個，那，那個 |
60.1禁用擴展雲鑄造驅動器支持
若是要徹底禁用/cloudfoundryapplication端點，能夠將如下設置添加到application.properties檔案：
應用特性。
management.cloudfoundry.enabled=false
60.2雲鑄造公司自簽證書
默認狀況下，/cloudfoundryapplication端點對各類CloudFoundry服務進行SSL調用。若是您的CloudFoundryUAA或CloudController服務使用自簽名證書，則須要設置如下屬性：
應用特性。
management.cloudfoundry.skip-ssl-validation=true
60.3自定義上下文路徑
若是服務器的上下文路徑已配置爲/，CloudFoundry端點將沒法在應用程序的根目錄上使用。例如，若是server.servlet.context-path=/app，CloudFoundry端點將在/app/cloudfoundryapplication/*.
若是您指望CloudFoundry端點始終可用在/cloudfoundryapplication/*不管服務器的上下文路徑如何，您都須要在應用程序中顯式地配置它。根據使用中的Web服務器，配置將有所不一樣。對於Tomcat，能夠添加如下配置：
@Bean
public TomcatServletWebServerFactory servletWebServerFactory() {
return new TomcatServletWebServerFactory() {
@Override
protected void prepareContext(Host host,
ServletContextInitializer[] initializers) {
super.prepareContext(host, initializers);
StandardContext child = new StandardContext();
child.addLifecycleListener(new Tomcat.FixContextListener());
child.setPath("/cloudfoundryapplication");
ServletContainerInitializer initializer = getServletContextInitializer(
getContextPath());
child.addServletContainerInitializer(initializer, Collections.emptySet());
child.setCrossContext(true);
host.addChild(child);
}
};
}
private ServletContainerInitializer getServletContextInitializer(String contextPath) {
return (c, context) -> {
Servlet servlet = new GenericServlet() {
@Override
public void service(ServletRequest req, ServletResponse res)
throws ServletException, IOException {
ServletContext context = req.getServletContext()
.getContext(contextPath);
context.getRequestDispatcher("/cloudfoundryapplication").forward(req,
res);
}
};
context.addServlet("cloudfoundry", servlet).addMapping("/*");
};
}
61.接下來要讀什麼？
若是您想探索本章中討論的一些概念，您能夠看看執行器。樣本應用。您還可能但願閱讀有關繪圖工具的內容，例如石墨.
不然，您能夠繼續閱讀有關「部署選項」或者跳出一些關於SpringBoot的深度信息構建工具插件.
第六部分。部署SpringBoot應用程序
SpringBoot的軟包裝選項在部署應用程序時提供了大量的選擇。您能夠將SpringBoot應用程序部署到各類雲平臺、容器映像(如Docker)或虛擬/真實機器上。
本節介紹了一些更常見的部署場景。
62.部署到雲端
SpringBoot的可執行JAR已經爲大多數流行的雲PaaS(平臺即服務)提供商作好了準備。這些提供者傾向於要求您「攜帶您本身的容器」。它們管理應用程序進程(而不是特定的Java應用程序)，所以它們須要一個適配的中間層。你的向雲的正在運行的進程的概念。
兩個流行的雲提供商Heroku和CloudFoundry採用了一種「buildpack」方法。構建包將部署的代碼封裝在所需的任何內容中。啓動你的申請。它多是一個JDK和一個調用java、嵌入式Web服務器或成熟的應用服務器。構建包是可插拔的，但理想狀況下，您應該可以儘量少地對其進行自定義。這減小了不受您控制的功能的佔用。它最大限度地減小了開發環境和生產環境之間的差別。
理想狀況下，您的應用程序，如SpringBoot可執行JAR，包含了在其中打包運行所需的一切。
在本節中，咱們將討論如何得到咱們開發的簡單應用程序在「入門」部分啓動並在雲中運行。
62.1雲鑄造
雲Foundry提供默認的構建包，若是沒有指定其餘的buildpack，這些包就會發揮做用。雲鑄造Javabuildpack對Spring應用程序有很好的支持，包括SpringBoot。您能夠部署獨立的可執行的jar應用程序以及傳統的.war打包應用程序。
一旦構建了應用程序(例如，經過使用mvn clean package)安裝cf命令行工具，使用cf push命令替換編譯後的路徑。.jar。必定要用你的cf命令行客戶端在推送申請以前。下面的行使用cf push命令部署應用程序：
$ cf push acloudyspringtime -p target/demo-0.0.1-SNAPSHOT.jar
|
| 在前面的示例中，咱們將 |
見cf push文獻資料尋找更多的選擇。若是有云鑄造廠manifest.yml文件存在於同一目錄中，則考慮。
在這一點上，cf開始上載應用程序，生成相似於如下示例的輸出：
Uploading acloudyspringtime... OK
Preparing to start acloudyspringtime... OK
-----> Downloaded app package (8.9M)
-----> Java Buildpack Version: v3.12 (offline) | https://github.com/cloudfoundry/java-buildpack.git#6f25b7e
-----> Downloading Open Jdk JRE 1.8.0_121 from https://java-buildpack.cloudfoundry.org/openjdk/trusty/x86_64/openjdk-1.8.0_121.tar.gz (found in cache)
Expanding Open Jdk JRE to .java-buildpack/open_jdk_jre (1.6s)
-----> Downloading Open JDK Like Memory Calculator 2.0.2_RELEASE from https://java-buildpack.cloudfoundry.org/memory-calculator/trusty/x86_64/memory-calculator-2.0.2_RELEASE.tar.gz (found in cache)
Memory Settings: -Xss349K -Xmx681574K -XX:MaxMetaspaceSize=104857K -Xms681574K -XX:MetaspaceSize=104857K
-----> Downloading Container Certificate Trust Store 1.0.0_RELEASE from https://java-buildpack.cloudfoundry.org/container-certificate-trust-store/container-certificate-trust-store-1.0.0_RELEASE.jar (found in cache)
Adding certificates to .java-buildpack/container_certificate_trust_store/truststore.jks (0.6s)
-----> Downloading Spring Auto Reconfiguration 1.10.0_RELEASE from https://java-buildpack.cloudfoundry.org/auto-reconfiguration/auto-reconfiguration-1.10.0_RELEASE.jar (found in cache)
Checking status of app 'acloudyspringtime'...
0 of 1 instances running (1 starting)
...
0 of 1 instances running (1 starting)
...
0 of 1 instances running (1 starting)
...
1 of 1 instances running (1 running)
App started
祝賀你!應用程序如今正在運行！
一旦應用程序處於活動狀態，就能夠使用cf apps命令，如如下示例所示：
$ cf apps Getting applications in ... OK name requested state instances memory disk urls ... acloudyspringtime started 1/1 512M 1G acloudyspringtime.cfapps.io ...
一旦CloudFoundry確認您的應用程序已經部署，您就能夠在給定的URI中找到應用程序。在前面的示例中，您能夠在http://acloudyspringtime.cfapps.io/.
62.1.1綁定到服務
默認狀況下，有關正在運行的應用程序的元數據以及服務鏈接信息將做爲環境變量公開給應用程序(例如：$VCAP_SERVICES)這個架構決定是因爲CloudFoundry的Polyglot(任何語言和平臺均可以做爲構建包來支持)。過程範圍內的環境變量與語言無關。
環境變量並不老是最簡單的API，所以SpringBoot會自動提取它們，並將數據扁平化成能夠經過Spring的屬性訪問的屬性。Environment抽象，如如下示例所示：
@Component
class MyBean implements EnvironmentAware {
private String instanceId;
@Override
public void setEnvironment(Environment environment) {
this.instanceId = environment.getProperty("vcap.application.instance_id");
}
// ...
}
全部雲鑄造屬性都之前綴vcap。你能夠用vcap屬性訪問應用程序信息(例如應用程序的公共URL)和服務信息(例如數據庫憑據)。見「CloudFoundryVcapEnvironment-PostProcessor」有關詳細信息的Javadoc。
|
| 這，這個，那，那個彈簧雲鏈接器項目更適合於配置DataSource等任務。Spring Boot包括自動配置支持和 |
62.2 Heroku
Heroku是另外一個流行的PaaS平臺。若要自定義Heroku構建，請提供Procfile，它提供了部署應用程序所需的咒語。Heroku分配port使Java應用程序使用並確保到外部URI的路由工做。
必須將應用程序配置爲偵聽正確的端口。下面的示例顯示Procfile對於初學者REST應用程序：
web: java -Dserver.port=$PORT -jar target/demo-0.0.1-SNAPSHOT.jar
春靴-D做爲從Spring訪問的屬性可用的參數Environment舉個例子。這，這個，那，那個server.portConfiguration屬性被輸入到嵌入的Tomcat、Jetty或Undertu實例，而後在啓動時使用端口。這，這個，那，那個$PORT環境變量由Heroku PaaS分配給咱們。
這應該是你須要的一切。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.8... done
-----> Installing Maven 3.3.1... done
-----> Installing settings.xml... done
-----> Executing: mvn -B -DskipTests=true clean install
[INFO] Scanning for projects...
Downloading: https://repo.spring.io/...
Downloaded: https://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上啓動並運行。
62.3 OpenShift
OpenShift是Kubernetes容器編排平臺的RedHat公共(和企業)擴展。與Kubernetes相似，OpenShift有許多安裝基於SpringBoot的應用程序的選項。
OpenShift有許多描述如何部署SpringBoot應用程序的資源，包括：
62.4亞馬遜網絡服務(AWS)
AmazonWebServices提供多種方法來安裝基於SpringBoot的應用程序，或者做爲傳統的Web應用程序(WAR)安裝，或者做爲帶有嵌入式Web服務器的可執行JAR文件安裝。備選方案包括：
- AWS彈性豆柄
- AWS代碼部署
- AWS OPS工程
- AWS雲造成
- AWS集裝箱登記處
每一種都有不一樣的特色和訂價模式。在本文檔中，咱們只描述了最簡單的選項：AWS彈性豆柄。
62.4.1 AWS彈性豆柄
如該官員所述彈性豆柄Java指南，部署Java應用程序有兩個主要選項。您能夠使用「Tomcat平臺」或「JavaSE平臺」。
使用Tomcat平臺
此選項適用於生成WAR文件的SpringBoot項目。不須要特殊配置。你只須要遵循官方指南就好了。
使用JavaSE平臺
此選項適用於生成JAR文件並運行嵌入式Web容器的SpringBoot項目。彈性Bean秸稈環境在端口80上運行一個nginx實例來代理實際應用程序，運行在端口5000上。若要配置它，請將如下行添加到您的application.properties檔案：
server.port=5000
|
| 默認狀況下，ElasticBean秸稈會上傳源並在AWS中編譯它們。可是，最好仍是上傳二進制文件。爲此，請將相似於如下內容的行添加到您的 deploy: artifact: target/demo-0.0.1-SNAPSHOT.jar |
|
| 默認狀況下，彈性豆柄環境是負載平衡的。負載均衡器的成本很高。爲了不這種成本，請將環境類型設置爲「單個實例」，如Amazon文檔。還能夠使用CLI和如下命令建立單個實例環境： eb create -s |
62.4.2摘要
這是實現AWS的最簡單的方法之一，可是還有更多的事情要討論，好比如何將ElasticBean秸稈集成到任何CI/CD工具中，使用ElasticBeansarMaven插件而不是CLI，等等。有一個博客帖子詳細介紹這些主題。
62.5 BOXFUSE和AmazonWeb服務
箱式保險絲工做方式是將SpringBoot、可執行JAR或WAR轉換成一個最小的VM映像，能夠在VirtualBox或AWS上不做改動地部署。Box引信爲SpringBoot提供了深度集成，並使用SpringBoot配置文件中的信息自動配置端口和健康檢查URL。Box引信對它生成的圖像以及它提供的全部資源(實例、安全組、彈性負載平衡器等)都利用了這些信息。
一旦建立了一個BOXFUSE賬戶，將其鏈接到AWS賬戶，安裝BoxFUSE客戶端的最新版本，並確保應用程序已由Maven或Gradle構建(例如，使用mvn clean package)，您能夠使用相似於如下命令的命令將SpringBoot應用程序部署到AWS：
$ boxfuse run myapp-1.0.jar -env=prod
見boxfuse run文獻資料尋找更多的選擇。若是有一個boxfuse.conf文件存在於當前目錄中，則考慮。
|
| 默認狀況下，BoxFUSE激活一個名爲Spring的概要文件 |
在這一點上，boxfuse爲您的應用程序建立一個映像，上傳它，並在AWS上配置和啓動必要的資源，從而產生相似於如下示例的輸出：
Fusing Image for myapp-1.0.jar ... Image fused in 00:06.838s (53937 K) -> axelfontaine/myapp:1.0 Creating axelfontaine/myapp ... Pushing axelfontaine/myapp:1.0 ... Verifying axelfontaine/myapp:1.0 ... Creating Elastic IP ... Mapping myapp-axelfontaine.boxfuse.io to 52.28.233.167 ... Waiting for AWS to create an AMI for axelfontaine/myapp:1.0 in eu-central-1 (this may take up to 50 seconds) ... AMI created in 00:23.557s -> ami-d23f38cf Creating security group boxfuse-sg_axelfontaine/myapp:1.0 ... Launching t2.micro instance of axelfontaine/myapp:1.0 (ami-d23f38cf) in eu-central-1 ... Instance launched in 00:30.306s -> i-92ef9f53 Waiting for AWS to boot Instance i-92ef9f53 and Payload to start at http://52.28.235.61/ ... Payload started in 00:29.266s -> http://52.28.235.61/ Remapping Elastic IP 52.28.233.167 to i-92ef9f53 ... Waiting 15s for AWS to complete Elastic IP Zero Downtime transition ... Deployment completed successfully. axelfontaine/myapp:1.0 is up and running at http://myapp-axelfontaine.boxfuse.io/
您的應用程序如今應該在AWS上啓動並運行。
請看博客上的文章在EC2上部署SpringBoot應用程序以及BoxfueSpringBoot集成文檔要開始使用Maven構建來運行這個應用程序。
62.6谷歌雲
GoogleCloud有幾個選項可用於啓動SpringBoot應用程序。最容易開始使用的多是AppEngine，但您也能夠找到在容器中運行SpringBoot的方法，或者在帶有Compute引擎的虛擬機上運行SpringBoot。
要在AppEngine中運行，您能夠首先在UI中建立一個項目，該項目爲您設置惟一標識符，還能夠設置HTTP路由。將Java應用程序添加到項目中，並將其保留爲空，而後使用GoogleCloudSDK要將SpringBoot應用程序從命令行或CI構建中插入到該槽中，請執行如下操做。
應用引擎標準要求您使用WAR包裝。跟隨這些步驟將AppEngine標準應用程序部署到GoogleCloud。
或者，AppEngine Flex要求您建立一個app.yaml文件來描述應用程序所需的資源。一般，你把這個文件放進src/main/appengine，它應該相似於如下文件：
service: default runtime: java env: flex runtime_config: jdk: openjdk8 handlers: - url: /.* script: this field is required, but ignored manual_scaling: instances: 1 health_check: enable_health_check: False env_variables: ENCRYPT_KEY: your_encryption_key_here
您能夠經過將項目ID添加到構建配置中來部署應用程序(例如，使用Maven插件)，以下面的示例所示：
<plugin> <groupId>com.google.cloud.tools</groupId> <artifactId>appengine-maven-plugin</artifactId> <version>1.3.0</version> <configuration> <project>myproject</project> </configuration> </plugin>
而後用mvn appengine:deploy(若是須要先進行身份驗證，則生成失敗)。
63.安裝SpringBoot應用程序
除了運行SpringBoot應用程序以外，還能夠使用java -jar，也能夠爲Unix系統製做徹底可執行的應用程序。徹底可執行的JAR能夠像任何其餘可執行的二進制文件同樣執行，也能夠是在init.d或systemd。這使得在常見的生產環境中安裝和管理SpringBoot應用程序變得很是容易。
|
謹慎 |
|---|---|
| 徹底可執行的JAR經過在文件前面嵌入一個額外的腳原本工做。目前，有些工具不接受這種格式，所以您可能並不老是可以使用這種技術。例如 |
若要使用Maven建立一個「徹底可執行」的JAR，請使用如下插件配置：
<plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <executable>true</executable> </configuration> </plugin>
下面的示例顯示了等效的Gradle配置：
bootJar {
launchScript()
}
而後，您能夠經過鍵入./my-application.jar(在哪裏my-application是你的藝術品的名字)。包含JAR的目錄用做應用程序的工做目錄。
63.1支持的操做系統
默認腳本支持大多數Linux發行版，並在CentOS和Ubuntu上進行測試。其餘平臺，如OSX和FreeBSD，須要使用自定義embeddedLaunchScript.
63.2 Unix/Linux服務
能夠輕鬆地以unix/linux服務的形式啓動SpringBoot應用程序，方法是init.d或systemd.
63.2.1安裝爲init.d服務(系統五)
若是您將SpringBoot的Maven或Gradle插件配置爲生成一個徹底可執行JAR，而且您不使用自定義embeddedLaunchScript，您的應用程序能夠用做init.d服務。爲此，將JAR符號連接到init.d支持標準start, stop, restart，和status命令。
該腳本支持如下特性：
- 以擁有JAR文件的用戶身份啓動服務。
- 經過使用
/var/run/<appname>/<appname>.pid - 將控制檯日誌寫入
/var/log/<appname>.log
假設您已經安裝了SpringBoot應用程序/var/myapp，將SpringBoot應用程序安裝爲init.d服務，建立一個符號連接，以下所示：
$ sudo ln -s /var/myapp/myapp.jar /etc/init.d/myapp
安裝完畢後，您能夠按照一般的方式啓動和中止服務。例如，在基於Debian的系統上，能夠使用如下命令啓動它：
$ service myapp start
|
| 若是應用程序啓動失敗，請檢查寫入的日誌文件。 |
還能夠使用標準操做系統工具將應用程序標記爲自動啓動。例如，在Debian上，能夠使用如下命令：
$ update-rc.d myapp defaults <priority>
確保init.d服務
|
| 下面是一組關於如何保護做爲init.d服務運行的SpringBoot應用程序的指導方針。它並不打算是一份詳盡的清單，列出爲強化應用程序和運行應用程序的環境而應該作的全部事情。 |
看成爲root執行時，就像在使用root啓動init.d服務時同樣，默認的可執行腳本以擁有JAR文件的用戶的身份運行應用程序。您不該該將SpringBoot應用程序做爲root所以，應用程序的JAR文件永遠不該該屬於root。相反，建立一個特定的用戶來運行您的應用程序並使用chown要使它成爲JAR文件的全部者，以下面的示例所示：
$ chown bootapp:bootapp your-app.jar
在這種狀況下，默認的可執行腳本以bootapp用戶。
|
| 爲了減小應用程序的用戶賬戶被破壞的可能性，您應該考慮阻止它使用登陸shell。例如，能夠將賬戶的shell設置爲 |
您還應該採起措施防止修改應用程序的JAR文件。首先，配置其權限，使其不能被寫入，而且只能由其全部者讀取或執行，以下面的示例所示：
$ chmod 500 your-app.jar
其次，若是您的應用程序或運行它的賬戶被破壞，您還應該採起措施限制損壞。若是攻擊者確實得到了訪問權限，他們能夠使JAR文件可寫並更改其內容。防止這種狀況的一種方法是經過使用chattr，如如下示例所示：
$ sudo chattr +i your-app.jar
這將防止任何用戶(包括root用戶)修改JAR。
若是根用戶用於控制應用程序的服務，則用.conf檔案若要自定義其啓動，請將.conf文件由根用戶讀取和計算。應當相應地加以擔保。使用chmod這樣，該文件只能由全部者讀取並使用。chown要使全部者具備根，以下面的示例所示：
$ chmod 400 your-app.conf $ sudo chown root:root your-app.conf
63.2.2安裝爲systemd服務
systemd是SystemV init系統的繼承者，如今許多現代Linux發行版都在使用它。雖然您能夠繼續使用init.d腳本systemd，也能夠經過如下方式啓動SpringBoot應用程序systemd「服務」腳本。
假設您已經安裝了SpringBoot應用程序/var/myapp，將SpringBoot應用程序安裝爲systemd服務，建立一個名爲myapp.service把它放進去/etc/systemd/system目錄。如下腳本提供了一個示例：
[Unit] Description=myapp After=syslog.target [Service] User=myapp ExecStart=/var/myapp/myapp.jar SuccessExitStatus=143 [Install] WantedBy=multi-user.target
|
重要 |
|---|---|
| 請記住更改 |
|
| 這，這個，那，那個 |
注意，與做爲init.d服務，運行應用程序的用戶、PID文件和控制檯日誌文件由systemd所以，必須經過在「service」腳本中使用適當的字段來配置它自己。諮詢服務單元配置手冊頁更多細節。
若要在系統啓動時將應用程序標記爲自動啓動，請使用如下命令：
$ systemctl enable myapp.service
請參閱man systemctl更多細節。
63.2.3自定義啓動腳本
由Maven或Gradle插件編寫的默認嵌入式啓動腳本能夠經過多種方式進行定製。對於大多數人來講，使用默認腳本和一些自定義一般就足夠了。若是發現沒法自定義所需的內容，請使用embeddedLaunchScript選項能夠徹底寫入您本身的文件。
在編寫開始腳本時自定義它
當開始腳本被寫入JAR文件時，定製它的元素一般是有意義的。例如，init.d腳本能夠提供「描述」。由於您預先知道了描述(而且它不須要更改)，因此您最好在JAR生成時提供它。
若要自定義編寫的元素，請使用embeddedLaunchScriptProperties選擇SpringBootMaven或Gradle插件。
默認腳本支持如下屬性替換：
| 名字，姓名 | 描述 | 分級違約 | Maven缺省 |
|---|---|---|---|
|
|
腳本模式。 |
|
|
|
|
這，這個，那，那個 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
單行版本 |
|
|
|
|
|
|
|
|
|
|
|
|
|
的默認值 |
包含罐子的文件夾 |
包含罐子的文件夾 |
|
|
引用默認啓動腳本中應該內聯的文件腳本。這可用於設置環境變量，如 |
||
|
|
默認值 |
||
|
|
默認值 |
||
|
|
默認值 |
||
|
|
中的PID文件名的默認值。 |
||
|
|
是否 |
|
|
|
|
默認值 |
60 |
60 |
在腳本運行時自定義腳本
用於須要自定義的腳本項。後已經編寫了JAR，您能夠使用環境變量或配置文件.
默認腳本支持下列環境屬性：
| 變量 | 描述 |
|---|---|
|
|
操做的「模式」。默認狀況取決於JAR的構建方式，但一般是 |
|
|
是否 |
|
|
PID文件夾的根名稱( |
|
|
要在其中放置日誌文件的文件夾的名稱( |
|
|
要從其中讀取.conf文件的文件夾的名稱(默認狀況下，該文件夾與jar-file相同)。 |
|
|
控件中日誌文件的名稱。 |
|
|
應用程序的名稱。若是JAR是從符號連接運行的，腳本就會猜想應用程序的名稱。若是它不是符號連接，或者您但願顯式設置應用程序名稱，這多是有用的。 |
|
|
傳遞給程序的參數(SpringBoot應用程序)。 |
|
|
的位置 |
|
|
在JVM啓動時傳遞給它的選項。 |
|
|
JAR文件的顯式位置，以防腳本被用來啓動一個實際上沒有嵌入的JAR。 |
|
|
若是不爲空，則設置 |
|
|
在強制關閉以前中止應用程序時等待的時間(以秒爲單位)( |
|
| 這，這個，那，那個 |
除了.JARFILE和APP_NAME，則上一節中列出的設置能夠經過使用.conf檔案。該文件應位於JAR文件的旁邊，而且具備相同的名稱，但後綴爲.conf而不是.jar。例如，一個名爲/var/myapp/myapp.jar使用名爲/var/myapp/myapp.conf，如如下示例所示：
myapp.conf.
JAVA_OPTS=-Xmx1024M LOG_FOLDER=/custom/log/folder
|
| 若是不喜歡將配置文件放在JAR文件旁邊，則能夠設置 |
若要了解如何適當保護此文件，請參見確保init.d服務安全的指南.
63.3微軟Windows服務
能夠將SpringBoot應用程序做爲Windows服務啓動，方法是winsw.
A(單獨維護樣本)描述如何爲SpringBoot應用程序建立Windows服務。
64.接下來要讀什麼？
檢查一下雲鑄造, 赫魯庫, OpenShift，和箱式保險絲有關PaaS能夠提供的功能種類的更多信息，請參見網站。這些只是最流行的JavaPaaS供應商中的四個。因爲SpringBoot很是適合基於雲的部署，因此您也能夠自由地考慮其餘提供者。
下一節繼續討論彈簧啓動CLI或者你能夠跳到前面去讀構建工具插件.
第七部分彈簧啓動CLI
SpringBootCLI是一個命令行工具，若是您想要快速開發Spring應用程序，能夠使用它。它容許您運行Groovy腳本，這意味着您有一個熟悉的相似Java的語法，而沒有太多的樣板代碼。您還能夠引導一個新項目或爲它編寫您本身的命令。
65.安裝CLI
使用SDKMAN能夠手動安裝SpringBootCLI(命令行接口)！(SDK管理器)，若是您是OSX用戶，則能夠使用HomeBREW或MacPorts。看見10.2節，「安裝SpringBoot CLI」在「入門」一節中得到全面的安裝說明。
66.使用CLI
一旦安裝了CLI，就能夠經過鍵入spring並在命令行按Enter。若是你跑spring在沒有任何參數的狀況下，將顯示一個簡單的幫助屏幕，以下所示：
$ spring
usage: spring [--help] [--version]
<command> [<args>]
Available commands are:
run [options] <files> [--] [args]
Run a spring groovy script
... more command help is shown here
你能夠打字spring help若要獲取有關任何受支持命令的更多詳細信息，請參見如下示例：
$ spring help run
spring run - Run a spring groovy script
usage: spring run [options] <files> [--] [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命令提供了一種快速檢查使用的SpringBoot版本的方法，以下所示：
$ spring version Spring CLI v2.1.0.BUILD-SNAPSHOT
66.1使用CLI運行應用程序
方法能夠編譯和運行Groovy源代碼。run命令。SpringBootCLI是徹底獨立的，因此您不須要安裝任何外部Groovy。
下面的示例顯示了用Groovy編寫的「Hello World」Web應用程序：
你好，太棒了。
@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
|
| 設置時 |
66.1.1推導出「抓取」屬地
標準Groovy包括@Grab註釋，它容許您聲明對第三方庫的依賴關係。這個有用的技術可讓Groovy以與Maven或Gradle相同的方式下載JAR，但不須要使用構建工具。
SpringBoot進一步擴展了這一技術，並試圖根據您的代碼推斷出要「抓取」哪些庫。例如，因爲WebApplication前面顯示的代碼使用@RestController註解，SpringBoot抓住了「Tomcat」和「SpringMVC」。
如下項目用做「抓取提示」：
| 項目 | 抓取 |
|---|---|
|
|
JDBC應用 |
|
|
JMS應用 |
|
|
緩存抽象。 |
|
|
JUnit |
|
|
拉比·MQ |
| 延展 |
史波克測試。 |
|
|
彈簧批。 |
|
|
彈簧集成。 |
|
|
SpringMVC+嵌入式Tomcat。 |
|
|
春季保安。 |
|
|
春季事務管理 |
|
| 見 |
66.1.2推導出「抓取」座標
SpringBoot擴展了Groovy的標準@Grab經過容許您在沒有組或版本的狀況下指定依賴項(例如，@Grab('freemarker'))這樣作能夠參考SpringBoot的默認依賴元數據來推斷工件的組和版本。
|
| 默認元數據綁定到您使用的CLI版本。只有當您移動到CLI的新版本時，它纔會更改，這將使您控制依賴項的版本什麼時候會更改。顯示默認元數據中包含的依賴項及其版本的表能夠在附錄. |
66.1.3默認導入語句
爲了幫助縮小Groovy代碼的大小，如下幾個import語句自動包括在內。注意前面的示例如何引用@Component, @RestController，和@RequestMapping不須要使用徹底限定的名稱或import陳述。
|
| 許多Spring註釋無需使用 |
66.1.4自動主法
與等效的Java應用程序不一樣，不須要包含public static void main(String[] args)方法與您的Groovy劇本。一個SpringApplication自動建立，編譯後的代碼將充當source.
66.1.5自定義依賴關係管理
默認狀況下，cli使用spring-boot-dependencies解析時@Grab依賴關係。能夠使用@DependencyManagementBom註釋註釋的值應該指定座標(groupId:artifactId:version)一個或多個Maven Boms。
例如，考慮如下聲明：
@DependencyManagementBom("com.example.custom-bom:1.0.0")
前面的聲明顯示custom-bom-1.0.0.pom在Maven存儲庫中com/example/custom-versions/1.0.0/.
當您指定多個BOM時，將按照聲明它們的順序應用它們，以下面的示例所示：
@DependencyManagementBom(["com.example.custom-bom:1.0.0", "com.example.another-bom:1.0.0"])
上面的示例代表another-bom中重寫依賴關係管理。custom-bom.
你能夠用@DependencyManagementBom任何你能夠使用的地方@Grab。可是，要確保依賴關係管理的順序一致，能夠使用@DependencyManagementBom在您的應用程序中最多一次。依賴管理的一個有用來源(它是SpringBoot的依賴管理的超集)是彈簧IO平臺，您能夠將其包含在如下行中：
@DependencyManagementBom('io.spring.platform:platform-bom:1.1.2.RELEASE')
66.2具備多源文件的應用程序
您能夠在接受文件輸入的全部命令中使用「shell globing」。這樣作可讓您使用來自單個目錄的多個文件，以下面的示例所示：
$ spring run *.groovy
66.3包裝您的應用程序
您能夠使用jar命令將應用程序打包到一個自包含的可執行JAR文件中，以下面的示例所示：
$ spring jar my-app.jar *.groovy
生成的JAR包含經過編譯應用程序和應用程序的全部依賴項生成的類，這樣就能夠使用java -jar。JAR文件還包含來自應用程序類路徑的條目。能夠向JAR添加和移除顯式路徑，方法是--include和--exclude。二者都是逗號分隔的，而且都接受前綴，以「+」和「-」的形式表示應該從默認值中刪除它們。默認包含以下：
public/**, resources/**, static/**, templates/**, META-INF/**, *
默認排除以下：
.*, repository/**, build/**, target/**, **/*.jar, **/*.groovy
類型spring help jar在命令行上獲取更多信息。
66.4啓動一個新項目
這，這個，那，那個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輸出更多細節。例如，下面的命令建立一個使用Java 8和war包裝：
$ 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'
66.5使用嵌入式Shell
SpringBoot包括用於Bash和zsh shell的命令行完成腳本。若是您不使用這些shell(可能您是Windows用戶)，則能夠使用shell命令啓動集成shell，如如下示例所示：
$ spring shell Spring Boot (v2.1.0.BUILD-SNAPSHOT) Hit TAB to complete. Type \'help' and hit RETURN for help, and \'exit' to quit.
在嵌入的shell中，能夠直接運行其餘命令：
$ version Spring CLI v2.1.0.BUILD-SNAPSHOT
嵌入式外殼支持ANSI顏色輸出以及tab完成。若是須要運行本機命令，能夠使用!前綴。若要退出嵌入的外殼，請按ctrl-c.
66.6向CLI添加擴展
能夠使用install命令。該命令以格式接受一組或多組工件座標。group:artifact:version，如如下示例所示：
$ spring install com.example:spring-boot-cli-extension:1.0.0.RELEASE
除了安裝您所提供的座標所標識的工件以外，還安裝了全部工件的依賴關係。
若要卸載依賴項，請使用uninstall命令。就像install命令中，它接受一組或多組工件座標，格式爲group:artifact:version，如如下示例所示：
$ spring uninstall com.example:spring-boot-cli-extension:1.0.0.RELEASE
它卸載您提供的座標和它們的依賴項所標識的工件。
若要卸載全部其餘依賴項，能夠使用--all選項，如如下示例所示：
$ spring uninstall --all
67.使用GroovyBeans DSL開發應用程序
SpringFramework4.0對beans{}「DSL」(借用自砂礫)，而且能夠使用相同的格式將bean定義嵌入到Groovy應用程序腳本中。這有時是包含中間件聲明等外部特性的好方法，以下面的示例所示：
@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放在一個單獨的文件中。
68.配置CLIsettings.xml
SpringBootCLI使用Aether(Maven的依賴解析引擎)來解決依賴關係。CLI使用了~/.m2/settings.xml配置乙醚。CLI遵照下列配置設置：
- 離線
- 鏡子
- 服務器
- 代理
-
剖面圖
- 活化
- 儲存庫
- 活動剖面
看見Maven設置文檔以獲取更多信息。
69.接下來要讀什麼？
有一些示例groovy腳本能夠從GitHub存儲庫中得到，您能夠使用它來嘗試SpringBootCLI。也有普遍的Javadoc貫穿於源代碼.
若是您發現您已經達到了CLI工具的極限，那麼您可能但願將您的應用程序轉換爲一個完整的Gradle或Maven構建的「Groovy項目」。下一節將介紹SpringBoot的「構建工具插件，能夠與Gradle或Maven一塊兒使用。
第八編構建工具插件
SpringBoot爲Maven和Gradle提供了構建工具插件。插件提供了多種特性，包括可執行JAR的打包。本節提供了更多關於這兩個插件的詳細信息，以及在須要擴展不受支持的構建系統時提供的一些幫助。若是你纔剛開始，你可能想讀「第13章，構建系統「從」第三部分，「使用Spring Boot」「第一節。
70.Spring Boot Maven插件
這，這個，那，那個Spring Boot Maven插件在Maven中提供SpringBoot支持，容許您打包可執行的JAR或WAR存檔，並運行應用程序「就地」。要使用它，必須使用Maven 3.2(或更高版本)。
|
| 見Spring Boot Maven插件站點得到完整的插件文檔。 |
70.1包括插件
若要使用SpringBootMaven插件，請在plugins你的部分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> <!-- ... --> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <version>2.1.0.BUILD-SNAPSHOT</version> <executions> <execution> <goals> <goal>repackage</goal> </goals> </execution> </executions> </plugin> </plugins> </build> </project>
前面的配置從新打包了一個JAR或WAR，該JAR或WAR是在packageMaven生命週期的階段。下面的示例既顯示了從新打包的JAR，也顯示了target目錄：
$ mvn package $ ls target/*.jar target/myproject-1.0.0.jar target/myproject-1.0.0.jar.original
若是不包括<execution/>如前面的示例所示，配置能夠本身運行插件(但也必須使用包目標)，以下面的示例所示：
$ 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>https://repo.spring.io/snapshot</url> </pluginRepository> <pluginRepository> <id>spring-milestones</id> <url>https://repo.spring.io/milestone</url> </pluginRepository> </pluginRepositories>
70.2包裝可執行罐和戰爭文件
一次spring-boot-maven-plugin已經包含在您的pom.xml，它會自動嘗試重寫檔案，以便經過使用spring-boot:repackage進球。您應該將您的項目配置爲構建JAR或WAR(視狀況而定)，方法是使用一般的packaging元素，如如下示例所示：
<?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>
在package相位。要啓動的主類能夠經過使用配置選項或添加Main-Class屬性以一般的方式添加到清單。若是未指定主類，則插件將搜索具備public static void main(String[] args)方法。
要構建和運行項目工件，能夠鍵入如下內容：
$ mvn package $ java -jar target/mymodule-0.0.1-SNAPSHOT.jar
要構建一個既可執行又可部署到外部容器中的WAR文件，您須要將嵌入的容器依賴項標記爲「提供」，以下面的示例所示：
<?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>
|
| 見「第91.1節，「建立可部署的戰爭文件」「有關如何建立可部署的WAR文件的更多詳細信息，請參見。 |
高級配置選項和示例可在插件信息頁面.
71.彈簧啓動級插件
SpringBootGradle插件在Gradle中提供了SpringBoot支持，容許您打包可執行的JAR或WAR存檔，運行SpringBoot應用程序，並使用由spring-boot-dependencies。它須要Gradle 4.4或更高版本。請參閱插件的文檔以瞭解更多信息：
72.彈簧啓動AntLib模塊
SpringBootAntLib模塊爲ApacheAnt提供了基本的SpringBoot支持。您能夠使用該模塊建立可執行的JAR。要使用該模塊，您須要聲明一個額外的spring-boot命名空間中的build.xml，如如下示例所示：
<project xmlns:ivy="antlib:org.apache.ivy.ant" xmlns:spring-boot="antlib:org.springframework.boot.ant" name="myapp" default="build"> ... </project>
您須要記住使用-lib選項，如如下示例所示：
$ ant -lib <folder containing spring-boot-antlib-2.1.0.BUILD-SNAPSHOT.jar>
|
| 「使用SpringBoot」部分包含了一個更完整的示例使用ApacheAnt |
72.1 Spring啓動Ant任務
曾經spring-boot-antlib命名空間已聲明，可以使用下列附加任務：
72.1.1 spring-boot:exejar
您能夠使用exejar建立SpringBoot可執行JAR的任務。任務支持如下屬性：
| 屬性 | 描述 | 所需 |
|---|---|---|
|
|
要建立的目標JAR文件 |
是 |
|
|
Java類文件的根目錄 |
是 |
|
|
要運行的主應用程序類。 |
否(默認值是第一個找到的類，它聲明 |
如下嵌套元素可用於該任務：
| 元素 | 描述 |
|---|---|
|
|
|
|
|
一個或多個資源收集應該將其添加到組成應用程序運行時依賴類路徑的一組JAR庫中。 |
72.1.2實例
本節展現了兩個Ant任務示例。
指定開始類。
<spring-boot:exejar destfile="target/my-application.jar" classes="target/classes" start-class="com.example.MyApplication"> <resources> <fileset dir="src/main/resources" /> </resources> <lib> <fileset dir="lib" /> </lib> </spring-boot:exejar>
開始上課。
<exejar destfile="target/my-application.jar" classes="target/classes"> <lib> <fileset dir="lib" /> </lib> </exejar>
72.2 spring-boot:findmainclass
這，這個，那，那個findmainclass任務在內部由exejar若要找到聲明main。若是有必要，也能夠在構建中直接使用此任務。支持下列屬性：
| 屬性 | 描述 | 所需 |
|---|---|---|
|
|
Java類文件的根目錄 |
是(除非 |
|
|
可用於短路 |
否 |
|
|
應該與結果一塊兒設置的Ant屬性 |
否(若是未指定結果，將記錄結果) |
72.2.1實例
本節包含三個使用findmainclass.
找到並記錄。
<findmainclass classesroot="target/classes" />
找到並準備好。
<findmainclass classesroot="target/classes" property="main-class" />
覆蓋並設置。
<findmainclass mainclass="com.example.MainClass" property="main-class" />
73.支持其餘構建系統
若是您想使用Maven、Gradle或Ant之外的構建工具，則可能須要開發本身的插件。可執行的JAR須要遵循特定的格式，某些條目須要以未壓縮的形式編寫(請參閱「可執行JAR格式「詳見附錄中的一節)。
SpringBootMaven和Gradle插件都使用spring-boot-loader-tools才能真正產生罐子。若是須要，能夠直接使用這個庫。
73.1從新包裝檔案館
若要從新打包現有存檔，使其成爲自帶的可執行存檔，請使用org.springframework.boot.loader.tools.Repackager。這，這個，那，那個Repackager類接受引用現有JAR或WAR存檔的單個構造函數參數。使用兩種可用的一種repackage()方法替換原始文件或寫入新目標。在從新打包程序運行以前，還能夠在其上配置各類設置。
73.2嵌套庫
從新打包存檔時，能夠使用org.springframework.boot.loader.tools.Libraries接口。咱們沒有提供任何具體的實現Libraries在這裏，由於它們一般是特定於構建系統的。
若是您的存檔已經包含了庫，則能夠使用Libraries.NONE.
73.3找到主修班
若是你不使用Repackager.setMainClass()若要指定主類，rePackager將使用ASM若要讀取類文件並嘗試使用public static void main(String[] args)方法。若是找到多個候選人，則引起異常。
73.4從新包裝實現示例
下面的示例顯示了一個典型的從新打包實現：
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));
}
});
74.接下來要讀什麼？
若是您對構建工具插件的工做方式感興趣，能夠查看spring-boot-toolsGitHub上的模塊。可執行JAR格式的更多技術細節將在附錄.
若是您有特定的與構建相關的問題，能夠查看「如何「嚮導。
第九編「How-to」指南
本節給出了一些常見的‘我如何作那個…’的答案在使用SpringBoot時常常出現的問題。它的覆蓋範圍並不是詳盡無遺，但確實涵蓋了至關多的內容。
若是您有特定的問題，咱們在這裏不討論，您可能須要檢查。stackoverflow.com看看是否有人已經給出了答案。這也是一個問新問題的好地方(請使用spring-boot(標籤)。
咱們也很是樂意擴展這一節。若是您想添加「如何-to」，請給咱們發送一個拉請求.
75.彈簧引導應用
本節包含與SpringBoot應用程序直接相關的主題。
75.1建立本身的FailureAnalyzer
FailureAnalyzer是一種很好的方法，能夠在啓動時攔截異常並將其轉換爲人類可讀的消息，包裝在FailureAnalysis。SpringBoot爲應用程序上下文相關的異常、JSR-303驗證等提供了這樣的分析器。您也能夠建立本身的。
AbstractFailureAnalyzer的方便擴展。FailureAnalyzer它檢查要處理的異常中是否存在指定的異常類型。您能夠對此進行擴展，以便您的實現只有在異常實際存在時纔有機會處理它。若是因爲任何緣由沒法處理異常，則返回null給另外一個實現一個處理異常的機會。
FailureAnalyzer實現必須在META-INF/spring.factories。下面的示例註冊ProjectConstraintViolationFailureAnalyzer:
org.springframework.boot.diagnostics.FailureAnalyzer=\ com.example.ProjectConstraintViolationFailureAnalyzer
|
| 若是須要訪問 |
75.2自動配置故障排除
SpringBoot自動配置盡力「作正確的事情」，但有時失敗，很難說出緣由。
有一個很是有用的ConditionEvaluationReport可在任何SpringBoot中得到ApplicationContext。若是您啓用DEBUG測井輸出若是您使用spring-boot-actuator(見執行者章節)，也有一個conditions在JSON中呈現報表的端點。使用該端點調試應用程序，並查看SpringBoot在運行時添加了哪些特性(哪些特性還沒有添加)。
更多的問題能夠經過查看源代碼和Javadoc來回答。閱讀代碼時，請記住如下經驗規則：
- 查找名爲
*AutoConfiguration閱讀他們的資料來源。特別注意@Conditional*註釋，以瞭解它們啓用了哪些特性以及什麼時候啓用。加--debug到命令行或系統屬性。-Ddebug在您的應用程序中得到全部自動配置決策的控制檯日誌。在運行中的Actuator應用程序中，請查看conditions端點(/actuator/conditions或相同信息的JMX等價物)。 - 查找
@ConfigurationProperties(如ServerProperties)並從中讀取可用的外部配置選項。這，這個，那，那個@ConfigurationProperties註釋有一個name屬性，用做外部屬性的前綴。所以，ServerProperties有prefix="server"它的配置屬性是server.port,server.address和其餘人。在運行中的Actuator應用程序中，請查看configprops端點。 - 查找
bind方法的Binder將配置值顯式地從Environment以輕鬆的方式。它常與前綴連用。 - 尋找
@Value直接綁定到Environment. - 尋找
@ConditionalOnExpression爲響應Spel表達式而打開和關閉功能的註釋，一般使用從Environment.
75.3在環境或ApplicationContext啓動以前定製它
A SpringApplication有ApplicationListeners和ApplicationContextInitializers用於將自定義應用於上下文或環境的。SpringBoot從META-INF/spring.factories。註冊其餘自定義的方法不止一種：
- 經過調用
addListeners和addInitializers方法SpringApplication在你運行以前。 - 經過設置
context.initializer.classes或context.listener.classes財產。 - 以聲明方式，爲全部應用程序添加
META-INF/spring.factories並打包應用程序都用做庫的JAR文件。
這，這個，那，那個SpringApplication送些特別的ApplicationEvents到偵聽器(有些甚至在建立上下文以前)，而後爲由ApplicationContext也是見「第23.5節，「應用程序事件和偵聽器」「在‘SpringBoot特性’部分得到完整列表。
還能夠自定義Environment在經過如下方法刷新應用程序上下文以前EnvironmentPostProcessor。每一個實現都應在META-INF/spring.factories，如如下示例所示：
org.springframework.boot.env.EnvironmentPostProcessor=com.example.YourEnvironmentPostProcessor
實現能夠加載任意文件並將它們添加到Environment。例如，如下示例從類路徑加載YAML配置文件：
public class EnvironmentPostProcessorExample implements EnvironmentPostProcessor {
private final YamlPropertySourceLoader loader = new YamlPropertySourceLoader();
@Override
public void postProcessEnvironment(ConfigurableEnvironment environment,
SpringApplication application) {
Resource path = new ClassPathResource("com/example/myapp/config.yml");
PropertySource<?> propertySource = loadYaml(path);
environment.getPropertySources().addLast(propertySource);
}
private PropertySource<?> loadYaml(Resource path) {
if (!path.exists()) {
throw new IllegalArgumentException("Resource " + path + " does not exist");
}
try {
return this.loader.load("custom-resource", path).get(0);
}
catch (IOException ex) {
throw new IllegalStateException(
"Failed to load yaml configuration from " + path, ex);
}
}
}
|
| 這，這個，那，那個 |
|
謹慎 |
|---|---|
| 使用時 |
75.4構建ApplicationContext層次結構(添加父上下文或根上下文)
您能夠使用ApplicationBuilder類來建立父/子ApplicationContext等級制度。見「第23.4節，「FLUENT Builder API」「在‘SpringBoot特性’一節中能夠得到更多信息。
75.5建立一個非web應用程序
並不是全部Spring應用程序都必須是Web應用程序(或Web服務)。若是您想在main方法，還能夠引導Spring應用程序來設置要使用的基礎設施，能夠使用SpringApplication春靴的特徵。一個SpringApplication改變它的ApplicationContext類，取決於它是否定爲須要Web應用程序。您能夠作的第一件事是將與服務器相關的依賴關係(例如ServletAPI)排除在類路徑以外。若是不能這樣作(例如，從同一個代碼庫運行兩個應用程序)，則能夠顯式調用setWebApplicationType(WebApplicationType.NONE)你的SpringApplication實例或設置applicationContextClass屬性(經過JavaAPI或具備外部屬性)。您但願做爲業務邏輯運行的應用程序代碼能夠實現爲CommandLineRunner做爲一個@Bean定義。
76.屬性和配置
本節包括有關設置和讀取屬性、配置設置及其與SpringBoot應用程序的交互的主題。
76.1在構建時自動展開屬性
您能夠使用現有的構建配置來自動展開這些屬性，而不是硬編碼項目的構建配置中也指定的一些屬性。這在Maven和Gradle中都是可能的。
76.1.1使用Maven自動擴展屬性
能夠使用資源篩選從Maven項目自動展開屬性。若是您使用spring-boot-starter-parent，而後您能夠引用Maven的「項目屬性」@..@佔位符，如如下示例所示：
app.encoding=@project.build.sourceEncoding@ app.java.version=@java.version@
|
| 只有產品配置是這樣過濾的(換句話說，不對其應用過濾)。 |
|
| 若是啓用 |
若是不使用初學者父級，則須要在<build/>元素pom.xml:
<resources> <resource> <directory>src/main/resources</directory> <filtering>true</filtering> </resource> </resources>
您還須要在其中包含如下元素<plugins/>:
<plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-resources-plugin</artifactId> <version>2.7</version> <configuration> <delimiters> <delimiter>@</delimiter> </delimiters> <useDefaultDelimiters>false</useDefaultDelimiters> </configuration> </plugin>
|
| 這，這個，那，那個 |
76.1.2使用分級自動擴展屬性
您能夠經過配置Java插件來自動擴展Gradle項目中的屬性processResources這樣作的任務，如如下示例所示：
processResources {
expand(project.properties)
}
而後，能夠使用佔位符引用Gradle項目的屬性，如如下示例所示：
app.name=${name}
app.description=${description}
|
| 格拉德爾氏 |
76.2外部化SpringApplication
A SpringApplication有bean屬性(主要是setter)，因此在建立應用程序以修改其行爲時，能夠使用它的JavaAPI。或者，您能夠經過在spring.main.*。例如，在application.properties，您可能具備如下設置：
spring.main.web-application-type=none spring.main.banner-mode=off
而後SpringBoot橫幅不會在啓動時打印，應用程序也不會啓動嵌入式Web服務器。
外部配置中定義的屬性覆蓋用Java API指定的值，但用於建立ApplicationContext。考慮如下申請：
new SpringApplicationBuilder() .bannerMode(Banner.Mode.OFF) .sources(demo.MyApp.class) .run(args);
如今考慮如下配置：
spring.main.sources=com.acme.Config,com.acme.ExtraConfig spring.main.banner-mode=console
實際應用如今顯示橫幅(由配置覆蓋)，並使用三個源做爲ApplicationContext(按如下順序排列)：demo.MyApp, com.acme.Config，和com.acme.ExtraConfig.
76.3更改應用程序外部屬性的位置
默認狀況下，來自不一樣來源的屬性將添加到Spring中Environment按規定的順序(見「第24章，外化配置「在‘SpringBoot特性’一節中獲得確切的順序)。
增長和修改此順序的一個很好的方法是添加@PropertySource對應用程序源的註釋。類傳遞給SpringApplication靜態方便方法和使用setSources()檢查他們是否有@PropertySources。若是有，則將這些屬性添加到Environment的全部階段均可以使用。ApplicationContext生命週期。以這種方式添加的屬性比經過使用默認位置添加的屬性具備更低的優先級(如application.properties)、系統屬性、環境變量或命令行。
還能夠提供如下系統屬性(或環境變量)來更改行爲：
spring.config.name(SPRING_CONFIG_NAME)：默認爲application做爲文件名的根目錄。spring.config.location(SPRING_CONFIG_LOCATION)：要加載的文件(例如類路徑資源或URL)。單獨的Environment屬性源是爲該文檔設置的，它能夠被系統屬性、環境變量或命令行覆蓋。
不管您在環境中設置了什麼，SpringBoot老是加載application.properties如上文所述。默認狀況下，若是使用YAML，那麼擴展名爲「.yml」的文件也會添加到列表中。
SpringBoot記錄加載在DEBUG級別和它沒有找到的候選人TRACE水平。
看見ConfigFileApplicationListener更多細節。
76.4使用「短」命令行參數
有些人喜歡使用(例如)--port=9000而不是--server.port=9000若要在命令行上設置配置屬性，請執行如下操做。中的佔位符能夠啓用此行爲。application.properties，如如下示例所示：
server.port=${port:8080}
|
| 若是您從 |
|
| 在這種特殊狀況下，端口綁定在PaaS環境(如Heroku或CloudFoundry)中工做。在這兩個平臺中， |
76.5將YAML用於外部屬性
YAML是JSON的超集，所以是以分層格式存儲外部屬性的方便語法，如如下示例所示：
spring: application: name: cruncher datasource: driverClassName: com.mysql.jdbc.Driver url: jdbc:mysql://localhost/test server: port: 9000
建立一個名爲application.yml把它放在你的類路徑的根部。而後添加snakeyaml到依賴項(Maven座標)org.yaml:snakeyaml，若是使用spring-boot-starter)將YAML文件解析爲JavaMap<String,Object>(就像一個JSON對象)，SpringBoot將地圖平放，這樣它就像許多人習慣的那樣，具備一個層次深和週期分隔的鍵。PropertiesJava文件。
前面的示例YAML對應於如下內容application.properties檔案：
spring.application.name=cruncher spring.datasource.driverClassName=com.mysql.jdbc.Driver spring.datasource.url=jdbc:mysql://localhost/test server.port=9000
見「第24.6節，「使用YAML而不是屬性」「有關YAML的更多信息，請參見‘SpringBoot功能’部分。
76.6設置活動Spring配置文件
春天Environment有一個API，可是您一般會設置一個系統屬性(spring.profiles.active)或OS環境變量(SPRING_PROFILES_ACTIVE)此外，您還能夠使用-D參數(請記住將其放在主類或JAR存檔以前)，以下所示：
$ java -jar -Dspring.profiles.active=production demo-0.0.1-SNAPSHOT.jar
在SpringBoot中，還能夠在application.properties，如如下示例所示：
spring.profiles.active=production
以這種方式將值集替換爲系統屬性或環境變量設置，而不是由SpringApplicationBuilder.profiles()方法。所以，後一種JavaAPI能夠用於在不更改默認值的狀況下加強概要文件。
見「第25章，剖面圖在「SpringBoot功能」一節中得到更多信息。
76.7根據環境變化配置
YAML文件其實是一系列由---行，每一個文檔分別解析成一個扁平的地圖。
若是YAML文檔包含spring.profiles鍵，則配置文件值(以逗號分隔的配置文件列表)輸入Spring。Environment.acceptsProfiles()方法。若是其中任何一個配置文件是活動的，則該文檔將包含在最後的合併中(不然，它不會)，以下面的示例所示：
server: port: 9000 --- spring: profiles: development server: port: 9001 --- spring: profiles: production server: port: 0
在前面的示例中，默認端口是9000。可是，若是名爲「Development」的Spring配置文件是活動的，那麼端口是9001。若是「Production」處於活動狀態，則端口爲0。
|
| YAML文檔按遇到它們的順序合併。後面的值覆蓋先前的值。 |
要對屬性文件執行相同的操做，能夠使用application-${profile}.properties若要指定特定於配置文件的值，請執行如下操做。
76.8發現外部屬性的內置選項
Spring Boot綁定外部屬性application.properties(或.yml文件和其餘位置)在運行時進入應用程序。在單個位置上沒有(技術上也不可能)列出全部受支持的屬性，由於貢獻能夠來自類路徑上的其餘JAR文件。
具備Actuator特性的正在運行的應用程序具備configprops顯示全部綁定和綁定屬性的終結點。@ConfigurationProperties.
附錄包括application.properties示例包含SpringBoot支持的最多見屬性的列表。最終列表來自於搜索源代碼@ConfigurationProperties和@Value註釋以及偶爾使用Binder。有關加載屬性的確切順序的更多信息，請參見「第24章，外化配置".
77.嵌入式Web服務器
每一個SpringBootWeb應用程序都包括一個嵌入式Web服務器。這個特性帶來了許多如何解決的問題，包括如何更改嵌入式服務器和如何配置嵌入式服務器。本節回答這些問題。
77.1使用另外一個Web服務器
許多SpringBootStarter包括默認的嵌入式容器。
- 對於servlet堆棧應用程序，
spring-boot-starter-web包括Tomcatspring-boot-starter-tomcat，但你能夠用spring-boot-starter-jetty或spring-boot-starter-undertow相反。 - 對於反應性堆棧應用程序，
spring-boot-starter-webflux包括反應堆Nettyspring-boot-starter-reactor-netty，但你能夠用spring-boot-starter-tomcat,spring-boot-starter-jetty，或spring-boot-starter-undertow相反。
切換到不一樣的HTTP服務器時，除了包含所需的依賴項外，還須要排除默認的依賴項。SpringBoot爲HTTP服務器提供了單獨的啓動程序，以幫助儘量簡化此過程。
下面的Maven示例展現瞭如何排除Tomcat幷包含SpringMVC的JettyforSpringMVC：
<properties> <servlet-api.version>3.1.0</servlet-api.version> </properties> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <exclusions> <!-- Exclude the Tomcat dependency --> <exclusion> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> </exclusion> </exclusions> </dependency> <!-- Use Jetty instead --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jetty</artifactId> </dependency>
|
| The version of the Servlet API has been overridden as, unlike Tomcat 9 and Undertow 2.0, Jetty 9.4 does not support Servlet 4.0. |
下面的Gradle示例演示瞭如何排除Netty，幷包括SpringWebFlux的UndertoforSpringWebFlux：
configurations {
// exclude Reactor Netty
compile.exclude module: 'spring-boot-starter-reactor-netty'
}
dependencies {
compile 'org.springframework.boot:spring-boot-starter-webflux'
// Use Undertow instead
compile 'org.springframework.boot:spring-boot-starter-undertow'
// ...
}
|
|
|
77.2禁用Web服務器
若是類路徑包含啓動Web服務器所需的比特，SpringBoot將自動啓動它。若要禁用此行爲，請配置WebApplicationType在你的application.properties，如如下示例所示：
spring.main.web-application-type=none
77.3更改HTTP端口
在獨立應用程序中，主HTTP端口默認爲8080可是能夠用server.port(例如，在application.properties或做爲系統屬性)。因爲放寬了對.的約束Environment值，也能夠使用SERVER_PORT(例如，做爲OS環境變量)。
若要徹底關閉HTTP端點，但仍要建立一個WebApplicationContext，使用server.port=-1。(這樣作有時對測試頗有用。)
有關詳細信息，請參閱「第27.4.4節，「定製嵌入式servlet容器」「在‘SpringBoot特性’部分，或ServerProperties源代碼。
77.4使用隨機未分配的HTTP端口
若要掃描自由端口(使用OS本機防止衝突)，請使用server.port=0.
77.5在運行時發現HTTP端口
您能夠從日誌輸出或從ServletWebServerApplicationContext經過它WebServer。得到該值並確保它已初始化的最佳方法是添加@Bean類型ApplicationListener<ServletWebServerInitializedEvent>並在事件發佈時將容器從事件中取出。
使用的測試@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)還能夠經過使用@LocalServerPort註釋，如如下示例所示：
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)
public class MyWebIntegrationTests {
@Autowired
ServletWebServerApplicationContext server;
@LocalServerPort
int port;
// ...
}
|
|
|
77.6啓用HTTP響應壓縮
Http響應壓縮由Jetty、Tomcat和安德託支持。能夠在application.properties，以下：
server.compression.enabled=true
默認狀況下，要執行壓縮，響應長度必須至少爲2048字節。能夠經過設置server.compression.min-response-size財產。
默認狀況下，只有當響應的內容類型爲下列之一時，纔會壓縮其響應：
text/htmltext/xmltext/plaintext/csstext/javascriptapplication/javascriptapplication/jsonapplication/xml
能夠經過設置server.compression.mime-types財產。
77.7配置SSL
能夠經過設置各類server.ssl.*屬性，一般在application.properties或application.yml。下面的示例顯示如何在application.properties:
server.port=8443 server.ssl.key-store=classpath:keystore.jks server.ssl.key-store-password=secret server.ssl.key-password=another-secret
看見Ssl有關全部受支持屬性的詳細信息。
使用前面示例中的配置意味着應用程序再也不支持端口8080處的普通HTTP鏈接器。Spring Boot不支持經過如下方式配置HTTP鏈接器和HTTPS鏈接器application.properties。若是但願二者兼得，則須要以編程方式配置其中之一。咱們建議使用application.properties要配置HTTPS，HTTP鏈接器更容易以編程方式進行配置。見spring-boot-sample-tomcat-multi-connectors示例項目示例。
77.8配置HTTP/2
能夠在SpringBoot應用程序中啓用HTTP/2支持，server.http2.enabled配置屬性。這種支持取決於所選擇的Web服務器和應用程序環境，由於JDK 8不支持該協議。
|
| 春靴不支持 |
77.8.1帶有如下內容的HTTP/2
對於Ruby1.4.0+，支持HTTP/2，而不須要對JDK 8進行任何額外的要求。
77.8.2HTTP/2與Jetty
在Jetty9.4.8中，HTTP/2也被氪庫。要啓用這種支持，應用程序須要有兩個額外的依賴項：org.eclipse.jetty:jetty-alpn-conscrypt-server和org.eclipse.jetty.http2:http2-server.
使用Tomcat的77.8.3 HTTP/2
SpringBoot默認附帶Tomcat9.0.x，它在使用JDK 9或更高版本時支持HTTP/2。或者，能夠在JDK 8上使用HTTP/2，若是libtcnative庫及其依賴項安裝在主機操做系統上。
庫文件夾必須可用(若是尚未)到JVM庫路徑。您能夠使用jvm參數(如-Djava.library.path=/usr/local/opt/tomcat-native/lib。關於這一點的更多信息官方Tomcat文件.
在JDK 8上啓動Tomcat 9.0.x，若是沒有本機支持，將記錄如下錯誤：
ERROR 8787 --- [ main] o.a.coyote.http11.Http11NioProtocol : The upgrade handler [org.apache.coyote.http2.Http2Protocol] for [h2] only supports upgrade via ALPN but has been configured for the ["https-jsse-nio-8443"] connector that does not support ALPN.
此錯誤並不致命，應用程序仍然以HTTP/1.1SSL支持啓動。
77.8.4帶有反應堆Netty的HTTP/2
這，這個，那，那個spring-boot-webflux-starter默認狀況下使用反應堆Netty做爲服務器。使用JDK 9或更高版本的JDK支持，能夠爲HTTP/2配置ResiveNetty。對於JDK 8環境或最佳運行時性能，此服務器還支持帶有本機庫的HTTP/2。爲此，應用程序須要有額外的依賴項。
Spring Boot管理io.netty:netty-tcnative-boringssl-static「uber jar」，包含全部平臺的本機庫。開發人員能夠選擇僅使用分類器導入所需的依賴項(請參閱Netty官方文件).
77.9配置Web服務器
一般，您應該首先考慮使用許多可用的配置鍵之一，並經過在application.properties(或application.yml，或環境等見「第76.8節，「發現外部屬性的內置選項」「)這，這個，那，那個server.*命名空間在這裏很是有用，它包括了以下所示的名稱空間server.tomcat.*, server.jetty.*而其餘的則是針對特定於服務器的特性。見附錄A，通用應用特性.
前面的部分已經介紹了許多常見的用例，例如壓縮、SSL或HTTP/2。可是，若是用例中不存在配置密鑰，則應該查看WebServerFactoryCustomizer。您能夠聲明這樣的組件並訪問與您的選擇相關的服務器工廠：您應該爲所選的服務器(Tomcat、Jetty、ReactiveNetty、Under拖車)和所選的Web堆棧(servlet或反應性)選擇變量。
下面的示例用於Tomcatspring-boot-starter-web(servlet堆棧)：
@Component
public class MyTomcatWebServerCustomizer
implements WebServerFactoryCustomizer<TomcatServletWebServerFactory> {
@Override
public void customize(TomcatServletWebServerFactory factory) {
// customize the factory here
}
}
此外，SpringBoot還提供：
| 服務器 | Servlet堆棧 | 反應堆棧 |
|---|---|---|
| 貓貓 |
|
|
| 碼頭 |
|
|
| 下引 |
|
|
| 反應器 |
N/A |
|
一旦您能夠訪問WebServerFactory，您一般能夠向其添加自定義器，以配置特定的部件，如鏈接器、服務器資源或服務器自己-全部這些都使用特定於服務器的API。
做爲最後的手段，你也能夠宣佈你本身的WebServerFactory組件，它將覆蓋SpringBoot提供的組件。在本例中，不能依賴server命名空間了。
77.10嚮應用程序添加servlet、過濾器或偵聽器
在servlet堆棧應用程序中，即便用spring-boot-starter-web，有兩種方法能夠添加Servlet, Filter, ServletContextListener，以及ServletAPI對應用程序支持的其餘偵聽器：
77.10.1使用SpringBean添加servlet、過濾器或偵聽器
若要添加Servlet, Filter，或Servlet*Listener經過使用Springbean，您必須提供一個@Bean它的定義。當您想注入配置或依賴項時，這樣作很是有用。可是，您必須很是當心，以避免它們致使太多其餘bean的急切初始化，由於它們必須在應用程序生命週期的早期就安裝在容器中。(例如，讓它們依賴於您的DataSource或JPA配置)您能夠經過在第一次使用時而不是在初始化時延遲初始化bean來繞過這些限制。
如屬Filters和Servlets，還能夠添加映射和init參數。FilterRegistrationBean或者是ServletRegistrationBean代替或補充基礎組件。
|
| 若是沒有 |
與任何其餘Springbean同樣，您能夠定義servlet過濾器bean的順序；請確保檢查「這一節名爲「將servlet、過濾器和偵聽器註冊爲Springbean」「分段。
禁用servlet或過濾器的註冊
如前文描述，任何Servlet或Filterbean自動在servlet容器中註冊。若要禁用特定的註冊，請執行如下操做Filter或Servletbean，爲它建立一個註冊bean並將其標記爲禁用，以下面的示例所示：
@Bean
public FilterRegistrationBean registration(MyFilter filter) {
FilterRegistrationBean registration = new FilterRegistrationBean(filter);
registration.setEnabled(false);
return registration;
}
77.10.2使用Classpath掃描添加servlet、過濾器和偵聽器
@WebServlet, @WebFilter，和@WebListener帶註釋的類能夠自動在嵌入式servlet容器中註冊。@Configuration類@ServletComponentScan並指定包含要註冊的組件的包。默認狀況下，@ServletComponentScan從帶註釋的類的包中進行掃描。
77.11配置訪問日誌記錄
訪問日誌能夠經過各自的名稱空間爲Tomcat、Under拖車和Jetty配置。
例如，在Tomcat上使用定製模式.
server.tomcat.basedir=my-tomcat server.tomcat.accesslog.enabled=true server.tomcat.accesslog.pattern=%t %a "%r" %s (%D ms)
|
| 日誌的默認位置是 |
下面的訪問日誌能夠相似的方式配置，以下面的示例所示：
server.undertow.accesslog.enabled=true server.undertow.accesslog.pattern=%t %a "%r" %s (%D ms)
日誌存儲在logs相對於應用程序的工做目錄。能夠經過設置server.undertow.accesslog.directory財產。
最後，Jetty的訪問日誌也能夠配置以下：
server.jetty.accesslog.enabled=true server.jetty.accesslog.filename=/var/log/jetty-access.log
默認狀況下，日誌重定向到System.err。有關詳細信息，請參閱碼頭文件.
77.12運行在前端代理服務器後面
您的應用程序可能須要發送302用絕對連接重定向或呈現內容。在代理後面運行時，調用方須要一個指向代理的連接，而不是指向承載應用程序的機器的物理地址的連接。一般，這樣的狀況是經過與代理的契約來處理的，代理會添加標題來告訴後端如何構造指向本身的連接。
若是代理添加常規X-Forwarded-For和X-Forwarded-Proto頭(大多數代理服務器都這樣作)，應該正確地呈現絕對連接，前提是server.use-forward-headers設置爲true在你的application.properties.
|
| 若是應用程序在CloudFoundry或Heroku中運行，則 |
77.12.1自定義Tomcat的代理配置
若是使用Tomcat，則還能夠配置用於攜帶「轉發」信息的標頭的名稱，以下面的示例所示：
server.tomcat.remote-ip-header=x-your-remote-ip-header server.tomcat.protocol-header=x-your-protocol-header
Tomcat還配置了一個與要信任的內部代理匹配的默認正則表達式。默認狀況下，10/8, 192.168/16, 169.254/16和127/8是值得信任的。您能夠自定義閥門的配置，方法是在application.properties，如如下示例所示：
server.tomcat.internal-proxies=192\\.168\\.\\d{1,3}\\.\\d{1,3}
|
| 只有在使用屬性文件進行配置時才須要雙反斜槓。若是使用YAML，則單反斜槓就足夠了，與前面示例中所示的值相等的值將爲 |
|
| 經過設置 |
您能夠徹底控制Tomcat的配置RemoteIpValve經過關閉自動開關(爲此，設置server.use-forward-headers=false)中添加了一個新的閥門實例。TomcatServletWebServerFactory豆子
77.13使用Tomcat啓用多個鏈接器
您能夠添加一個org.apache.catalina.connector.Connector到TomcatServletWebServerFactory，它容許多個鏈接器，包括HTTP和HTTPS鏈接器，如如下示例所示：
@Bean
public ServletWebServerFactory servletContainer() {
TomcatServletWebServerFactory tomcat = new TomcatServletWebServerFactory();
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);
}
}
77.14使用Tomcat的LegacyCookieProcessor
默認狀況下，SpringBoot使用的嵌入式Tomcat不支持Cookie格式的「Version 0」，所以您可能會看到如下錯誤：
java.lang.IllegalArgumentException: An invalid character [32] was present in the Cookie value
若是可能的話，您應該考慮更新代碼，使其只存儲符合後續Cookie規範的值。可是，若是不能更改cookie的編寫方式，則能夠將Tomcat配置爲使用LegacyCookieProcessor。切換到LegacyCookieProcessor，使用WebServerFactoryCustomizerbean，它添加了一個TomcatContextCustomizer，如如下示例所示：
@Bean
public WebServerFactoryCustomizer<TomcatServletWebServerFactory> cookieProcessorCustomizer() {
return (factory) -> factory.addContextCustomizers(
(context) -> context.setCookieProcessor(new LegacyCookieProcessor()));
}
77.15使用如下方式啓用多個偵聽器
添加一個UndertowBuilderCustomizer到UndertowServletWebServerFactory並將偵聽器添加到Builder，如如下示例所示：
@Bean
public UndertowServletWebServerFactory servletWebServerFactory() {
UndertowServletWebServerFactory factory = new UndertowServletWebServerFactory();
factory.addBuilderCustomizers(new UndertowBuilderCustomizer() {
@Override
public void customize(Builder builder) {
builder.addHttpListener(8080, "0.0.0.0");
}
});
return factory;
}
77.16使用@ServerEndpoint建立WebSocketEndpoint
若是你想用@ServerEndpoint在使用嵌入式容器的SpringBoot應用程序中，必須聲明一個ServerEndpointExporter @Bean，如如下示例所示：
@Bean
public ServerEndpointExporter serverEndpointExporter() {
return new ServerEndpointExporter();
}
前面示例中顯示的bean註冊任何@ServerEndpoint帶有基礎WebSocket容器的註釋bean。當部署到獨立servlet容器時，此角色由servlet容器初始化器執行，ServerEndpointExporterbean不是必需的。
78.SpringMVC
SpringBoot有許多啓動程序，包括SpringMVC。請注意，有些初學者包括對SpringMVC的依賴，而不是直接包含它。本節回答關於SpringMVC和SpringBoot的常見問題。
78.1編寫JSON REST服務
任何春天@RestController在SpringBoot應用程序中，只要Jackson 2在類路徑上，默認狀況下應該呈現JSON響應，以下面的示例所示：
@RestController
public class MyController {
@RequestMapping("/thing")
public MyThing thing() {
return new MyThing();
}
}
只要MyThing能夠由Jackson 2(對於普通POJO或Groovy對象爲true)序列化，而後localhost:8080/thing默認狀況下爲它提供JSON表示。請注意，在瀏覽器中，有時可能會看到XML響應，由於瀏覽器傾向於發送更喜歡XML的接受標頭。
78.2編寫XML REST服務
若是您有Jackson XML擴展(jackson-dataformat-xml)在類路徑上，您能夠使用它來呈現XML響應。咱們用於JSON的前面的示例將起做用。若要使用Jackson XML呈現程序，請將如下依賴項添加到項目中：
<dependency> <groupId>com.fasterxml.jackson.dataformat</groupId> <artifactId>jackson-dataformat-xml</artifactId> </dependency>
您還可能但願添加對Woodstox的依賴。它比JDK提供的默認StAX實現更快，還添加了漂亮的打印支持和改進的命名空間處理。下面的清單顯示瞭如何將依賴項包含在伍德斯托克斯:
<dependency> <groupId>org.codehaus.woodstox</groupId> <artifactId>woodstox-core-asl</artifactId> </dependency>
若是Jackson的XML擴展不可用，則使用JAXB(默認狀況下在JDK中提供)，另外還要求MyThing註釋爲@XmlRootElement，如如下示例所示：
@XmlRootElement
public class MyThing {
private String name;
// .. getters and setters
}
要使服務器呈現XML而不是JSON，您可能須要發送一個Accept: text/xml標題(或使用瀏覽器)。
78.3自定義Jackson ObjectMapper
SpringMVC(客戶機和服務器端)使用HttpMessageConverters若要協商HTTP交換中的內容轉換，請執行如下操做。若是Jackson在類路徑上，則您已經得到了由Jackson2ObjectMapperBuilder的實例是爲您自動配置的。
這，這個，那，那個ObjectMapper(或XmlMapper對於Jackson XML轉換器)實例(默認狀況下建立)具備如下自定義屬性：
MapperFeature.DEFAULT_VIEW_INCLUSION殘廢DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES殘廢SerializationFeature.WRITE_DATES_AS_TIMESTAMPS殘廢
SpringBoot還提供了一些特性，使定製這種行爲更加容易。
您能夠配置ObjectMapper和XmlMapper經過使用環境執行實例。Jackson提供了一系列簡單的ON/OFF功能，可用於配置處理的各個方面。在映射到環境中的屬性的六個枚舉(在Jackson中)中描述了這些特性：
| Enum | 財產 | 價值 |
|---|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
例如，要啓用漂亮的打印，請設置spring.jackson.serialization.indent_output=true。請注意，因爲使用了鬆弛結合，案件indent_output不須要匹配對應的枚舉常量的狀況，即INDENT_OUTPUT.
此基於環境的配置應用於自動配置。Jackson2ObjectMapperBuilder並應用於經過使用構建器建立的任何映射器，包括自動配置的ObjectMapper豆子
語境Jackson2ObjectMapperBuilder能夠由一個或多個自定義Jackson2ObjectMapperBuilderCustomizer豆子這樣的定製bean能夠被訂購(Boot本身的定製器的訂單爲0)，容許在Boot自定義以前和以後應用額外的定製。
任何類型的豆類com.fasterxml.jackson.databind.Module將自動註冊到自動配置的Jackson2ObjectMapperBuilder並適用於任何ObjectMapper它建立的實例。這提供了在嚮應用程序添加新功能時提供自定義模塊的全局機制。
若是要替換默認值ObjectMapper徹底，要麼定義@Bean並將其標記爲@Primary或者，若是您更喜歡基於構建器的方法，則定義Jackson2ObjectMapperBuilder@Bean。注意，在任何一種狀況下，這樣作都會禁用ObjectMapper.
若是你提供任何@Beans類型MappingJackson2HttpMessageConverter，它們替換了MVC配置中的默認值。另外，一個類型的方便beanHttpMessageConverters提供(若是使用默認的MVC配置，則始終可用)。它有一些有用的方法來訪問默認的和用戶加強的消息轉換器。
見「第78.4節，「自定義@ResponseBody呈現」「分段和WebMvcAutoConfiguration有關更多細節的源代碼。
78.4自定義@ResponseBody呈現
彈簧使用HttpMessageConverters渲染@ResponseBody(或來自@RestController)您能夠經過在SpringBoot上下文中添加適當類型的bean來貢獻額外的轉換器。若是您添加的bean是默認包含的類型(如MappingJackson2HttpMessageConverter對於JSON轉換)，它將替換默認值。一種方便型豆類HttpMessageConverters若是使用默認的MVC配置，則始終可用。它有一些有用的方法來訪問默認的和用戶加強的消息轉換器(例如，若是您想手動將它們注入到自定義中，則可能頗有用。)RestTemplate).
與正常的mvc用法同樣，任何WebMvcConfigurer您提供的bean還能夠經過覆蓋configureMessageConverters方法。可是，與普通的MVC不一樣，您只能提供所需的額外轉換器(由於SpringBoot使用相同的機制來貢獻其缺省值)。最後，若是您選擇退出SpringBoot默認MVC配置，提供您本身的@EnableWebMvc配置，您能夠徹底控制並手動執行全部操做。getMessageConverters從…WebMvcConfigurationSupport.
見WebMvcAutoConfiguration有關更多細節的源代碼。
78.5處理多部分文件上載
Spring Boot包含Servlet 3javax.servlet.http.PartAPI支持上傳文件。默認狀況下，SpringBoot在單個請求中配置SpringMVC，最大大小爲每一個文件1MB，文件數據最多爲10 MB。您能夠重寫這些值，即存儲中間數據的位置(例如，到/tmp目錄)，以及經過使用公開的屬性將數據刷新到磁盤的閾值。MultipartProperties班級，等級例如，若是要指定文件是無限的，請將spring.servlet.multipart.max-file-size財產-1.
當您但願將多部分編碼的文件數據做爲@RequestParam-帶註釋的類型參數MultipartFile在SpringMVC控制器處理程序方法中。
見MultipartAutoConfiguration有關更多細節的消息來源。
78.6關閉SpringMVC DispatcherServlet
默認狀況下，全部內容都來自應用程序的根(/)若是您但願映射到另外一條路徑，則能夠按如下方式配置路徑：
spring.mvc.servlet.path=/acme
若是有其餘servlet，則能夠聲明@Bean類型Servlet或ServletRegistrationBean對於每一個和SpringBoot，它們將透明地註冊到容器中。由於servlet是以這種方式註冊的，因此能夠將它們映射到DispatcherServlet而不調用它。
配置DispatcherServlet你本身是不尋常的，但若是你真的須要這樣作，@Bean類型DispatcherServletPath還必須提供自定義路徑的方法。DispatcherServlet.
78.7關閉默認MVC配置
要徹底控制mvc配置，最簡單的方法是提供您本身的@Configuration帶着@EnableWebMvc註釋這樣作的話，全部的MVC配置都將掌握在您的手中。
78.8自定義視圖轉換器
A ViewResolver是SpringMVC的核心組件，在@Controller到實際View實現。請注意ViewResolvers主要用於ui應用程序，而不是REST樣式的服務(View不用於呈現@ResponseBody)的實現有不少種。ViewResolver選擇和Spring自己並非關於您應該使用哪種選擇的意見。另外一方面，Spring Boot爲您安裝一個或兩個，這取決於它在類路徑和應用程序上下文中找到了什麼。這，這個，那，那個DispatcherServlet使用它在應用程序上下文中找到的全部解析器，依次嘗試每一個解析器，直到獲得結果爲止，所以，若是添加本身的解析器，則必須知道順序和添加解析器的位置。
WebMvcAutoConfiguration添加如下內容ViewResolvers關於你的背景：
- 阿
InternalResourceViewResolver名爲「defaultViewResolver」。此方法定位能夠經過使用DefaultServlet(若是使用靜態資源和JSP頁面，則包括這些頁面)。它將前綴和後綴應用於視圖名稱，而後在servlet上下文中查找具備該路徑的物理資源(默認值均爲空，但可經過如下方式進行外部配置)spring.mvc.view.prefix和spring.mvc.view.suffix)您能夠經過提供相同類型的bean來覆蓋它。 - A
BeanNameViewResolver名爲「beanNameViewResolver」。這是視圖解析器鏈的有用成員，並獲取與View被解決了。不該該有必要重寫或替換它。 - A
ContentNegotiatingViewResolver名爲「viewResolver」的是其實是豆類View如今時這是一個「主」解析器，它將委託給全部其餘解析器，並試圖找到與客戶端發送的「接受」HTTP頭匹配的內容。有一個有用的博客ContentNegotiatingViewResolver您可能但願學習更多，也能夠查看源代碼以得到詳細信息。您能夠關閉自動配置的ContentNegotiatingViewResolver經過定義一個名爲「viewResolver」的bean。 - 若是您使用Thymeleaf，您也有一個
ThymeleafViewResolver名爲「hymeleafViewResolver」。它經過用前綴和後綴包圍視圖名稱來查找資源。前綴是spring.thymeleaf.prefix，後綴是spring.thymeleaf.suffix。前綴和後綴的值分別默認爲「classpath：/模板/」和「.html」。你能夠覆蓋ThymeleafViewResolver經過提供同名的bean。 - 若是您使用FreeMarker，您也有一個
FreeMarkerViewResolver名爲「FreeMarkerViewResolver」。它在加載程序路徑中查找資源(外部化爲spring.freemarker.templateLoaderPath並之前綴和後綴包圍視圖名稱，其默認值爲「classpath：/Template/」。前綴外部化爲spring.freemarker.prefix，而且後綴被外部化爲spring.freemarker.suffix。前綴和後綴的默認值分別爲空和.ftl。你能夠覆蓋FreeMarkerViewResolver經過提供同名的bean。 - 若是使用Groovy模板(實際上，若是
groovy-templates在您的類路徑上)，您也有一個GroovyMarkupViewResolver名爲「groovyMarkupViewResolver」。它在加載程序路徑中查找資源，方法是在視圖名稱周圍加上前綴和後綴(外部化爲spring.groovy.template.prefix和spring.groovy.template.suffix)前綴和後綴的默認值分別爲「classpath：/模板/」和「.tpl」。你能夠覆蓋GroovyMarkupViewResolver經過提供同名的bean。
有關更多細節，請參見如下各節：
WebMvcAutoConfigurationThymeleafAutoConfigurationFreeMarkerAutoConfigurationGroovyTemplateAutoConfiguration
79.用Spring安全性進行測試
SpringSecurity支持以特定用戶的身份運行測試。例如，下面的代碼段中的測試將與具備ADMIN角色。
@Test
@WithMockUser(roles="ADMIN")
public void requestProtectedUrlWithUser() throws Exception {
mvc
.perform(get("/"))
...
}
SpringSecurity提供了與SpringMVC測試的全面集成，這也能夠用於使用@WebMvcTest切片和MockMvc.
有關SpringSecurity的測試支持的詳細信息，請參閱SpringSecurity的參考文獻).
80.澤西
80.1使用Spring安全保護澤西端點
SpringSecurity能夠用於保護基於澤西島的Web應用程序，其方式與用於保護基於SpringMVC的Web應用程序的方式很是類似。可是，若是您想在澤西使用SpringSecurity的方法級安全性，則必須將澤西配置爲使用setStatus(int)相反sendError(int)。這使澤西沒法在SpringSecurity有機會向客戶端報告身份驗證或受權失敗以前提交響應。
這，這個，那，那個jersey.config.server.response.setStatusOverSendError屬性必須設置爲true關於申請ResourceConfigbean，如如下示例所示：
@Component
public class JerseyConfig extends ResourceConfig {
public JerseyConfig() {
register(Endpoint.class);
setProperties(Collections.singletonMap(
"jersey.config.server.response.setStatusOverSendError", true));
}
}
81.http客戶端
SpringBoot提供了許多與HTTP客戶端一塊兒工做的啓動程序。本節回答與使用它們有關的問題。
81.1配置RestTemplate以使用代理
如上文所述第33.1節，「餐廳模板定製」，您能夠使用RestTemplateCustomizer帶着RestTemplateBuilder要構建自定義的RestTemplate。這是建立RestTemplate配置爲使用代理。
代理配置的確切細節取決於正在使用的底層客戶端請求工廠。下面的示例配置HttpComponentsClientRequestFactory帶着HttpClient，它對全部主機都使用一個代理，除了192.168.0.5:
static class ProxyCustomizer implements RestTemplateCustomizer {
@Override
public void customize(RestTemplate restTemplate) {
HttpHost proxy = new HttpHost("proxy.example.com");
HttpClient httpClient = HttpClientBuilder.create()
.setRoutePlanner(new DefaultProxyRoutePlanner(proxy) {
@Override
public HttpHost determineProxy(HttpHost target,
HttpRequest request, HttpContext context)
throws HttpException {
if (target.getHostName().equals("192.168.0.5")) {
return null;
}
return super.determineProxy(target, request, context);
}
}).build();
restTemplate.setRequestFactory(
new HttpComponentsClientHttpRequestFactory(httpClient));
}
}
82.測井
SpringBoot沒有強制的日誌記錄依賴項，但CommonsLoggingAPI除外，它一般由Spring框架的spring-jcl模塊。使用Logback，你須要把它包括進去spring-jcl在類路徑上。作到這一點的最簡單的方法是經過啓動程序，這都依賴於spring-boot-starter-logging。對於web應用程序，只需spring-boot-starter-web，由於它依賴於日誌記錄啓動程序。若是使用Maven，下面的依賴項將爲您添加日誌記錄：
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>
春靴LoggingSystem試圖根據類路徑的內容配置日誌記錄的抽象。若是登陸是可用的，這是第一選擇。
若是您須要對日誌記錄所作的惟一更改是設置各類記錄器的級別，則能夠在application.properties經過使用「logging.level」前綴，以下面的示例所示：
logging.level.org.springframework.web=DEBUG logging.level.org.hibernate=ERROR
還能夠使用「logging.file」設置要寫入日誌的文件的位置(除了控制檯)。
若要配置日誌系統的更細粒度設置，須要使用LoggingSystem有疑問。默認狀況下，SpringBoot從系統的默認位置獲取本機配置(如classpath:logback.xml，可是能夠使用「logging.config」屬性設置配置文件的位置。
82.1爲日誌配置Logback
若是你把logback.xml在您的類路徑的根，它是從那裏(或從logback-spring.xml，以利用Boot提供的模板功能)。SpringBoot提供了一個默認的基本配置，若是您想設置級別，能夠包括它，以下面的示例所示：
<?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>
若是你看看base.xml在Spring-boot jar中，您能夠看到它使用了一些有用的系統屬性，LoggingSystem負責爲您建立：
${PID}*當前進程ID。${LOG_FILE}*是否logging.file設置在Boot的外部配置中。${LOG_PATH}*是否logging.path(表示日誌文件駐留的目錄)在Boot的外部配置中設置。${LOG_EXCEPTION_CONVERSION_WORD}*是否logging.exception-conversion-word設置在Boot的外部配置中。
SpringBoot還經過使用自定義的Logback轉換器在控制檯(但不是在日誌文件中)提供一些很好的ANSI彩色終端輸出。參見默認值base.xml詳細配置。
若是Groovy在類路徑上，您應該可以用logback.groovy也是若是存在，則優先考慮此設置。
82.1.1爲純文件輸出配置Logback
若是要禁用控制檯日誌記錄並只將輸出寫入文件，則須要自定義logback-spring.xml進口file-appender.xml但不是console-appender.xml，如如下示例所示：
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<include resource="org/springframework/boot/logging/logback/defaults.xml" />
<property name="LOG_FILE" value="${LOG_FILE:-${LOG_PATH:-${LOG_TEMP:-${java.io.tmpdir:-/tmp}}/}spring.log}"/>
<include resource="org/springframework/boot/logging/logback/file-appender.xml" />
<root level="INFO">
<appender-ref ref="FILE" />
</root>
</configuration>
您還須要添加logging.file敬你的application.properties，如如下示例所示：
logging.file=myapplication.log
82.2配置用於日誌記錄的Log4j
彈簧啓動支架Log4j 2若是它位於類路徑上，則用於日誌配置。若是將啓動程序用於組裝依賴項，則必須排除Logback，而後包含log4j2。若是不使用啓動程序，則須要提供(至少)spring-jcl除了Log4j 2。
最簡單的路徑多是經過啓動，儘管它須要一些與排除。下面的示例演示如何在Maven中設置Starter：
<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-log4j2</artifactId> </dependency>
下面的示例展現了在Gradle中設置Starter的一種方法：
dependencies {
compile 'org.springframework.boot:spring-boot-starter-web'
compile 'org.springframework.boot:spring-boot-starter-log4j2'
}
configurations {
all {
exclude group: 'org.springframework.boot', module: 'spring-boot-starter-logging'
}
}
|
| Log4j啓動程序將常見日誌記錄需求的依賴項集合在一塊兒(例如讓Tomcat使用)。 |
|
| 以確保使用 |
82.2.1使用YAML或JSON配置Log4j 2
除了默認的XML配置格式以外，Log4j 2還支持YAML和JSON配置文件。若要將Log4j 2配置爲使用替代配置文件格式，請將適當的依賴項添加到類路徑中，並將配置文件命名爲與所選文件格式匹配的配置文件，以下面的示例所示：
| 格式 | 相依性 | 文件名 |
|---|---|---|
| YAML |
|
|
| 傑森 |
|
|
83.數據存取
SpringBoot包括許多用於處理數據源的啓動程序。本節回答與此相關的問題。
83.1配置自定義數據源
配置本身的DataSource，定義@Bean在你的配置中。Spring Boot重用您的DataSource任何須要的地方，包括數據庫初始化。若是須要將某些設置外部化，則能夠綁定DataSource對環境的影響(見「第24.7.1節，「第三方配置」」).
下面的示例演示如何在bean中定義數據源：
@Bean
@ConfigurationProperties(prefix="app.datasource")
public DataSource dataSource() {
return new FancyDataSource();
}
下面的示例演示如何經過設置屬性來定義數據源：
app.datasource.url=jdbc:h2:mem:mydb app.datasource.username=sa app.datasource.pool-size=30
假設你FancyDataSource具備URL、用戶名和池大小的常規JavaBean屬性，這些設置在DataSource提供給其餘組件。常客數據庫初始化也會發生(因此相關的子集spring.datasource.*仍然能夠與您的自定義配置一塊兒使用)。
若是配置自定義JNDI，則能夠應用相同的原則。DataSource，如如下示例所示：
@Bean(destroyMethod="")
@ConfigurationProperties(prefix="app.datasource")
public DataSource dataSource() throws Exception {
JndiDataSourceLookup dataSourceLookup = new JndiDataSourceLookup();
return dataSourceLookup.getDataSource("java:comp/env/jdbc/YourDS");
}
SpringBoot還提供了一個實用程序生成器類，稱爲DataSourceBuilder，它能夠用於建立標準數據源之一(若是它位於類路徑上)。構建器能夠根據類路徑上可用的內容來檢測要使用的對象。它還能夠根據JDBCURL自動檢測驅動程序。
下面的示例演示如何使用DataSourceBuilder:
@Bean
@ConfigurationProperties("app.datasource")
public DataSource dataSource() {
return DataSourceBuilder.create().build();
}
用它運行一個應用程序DataSource，您所須要的只是鏈接信息。還能夠提供特定於池的設置。有關更多細節，請檢查將在運行時使用的實現。
下面的示例演示如何經過設置屬性來定義JDBC數據源：
app.datasource.url=jdbc:mysql://localhost/test app.datasource.username=dbuser app.datasource.password=dbpass app.datasource.pool-size=30
然而，有一個陷阱。因爲未公開鏈接池的實際類型，所以在您的自定義元數據中不會生成任何鍵。DataSource並且您的IDE中沒有可用的完成(由於DataSource接口不公開屬性)。此外，若是您碰巧在類路徑上有Hikari，則此基本設置不起做用，由於Hikari沒有url屬性(但確實有jdbcUrl財產)。在這種狀況下，您必須按照如下方式重寫您的配置：
app.datasource.jdbc-url=jdbc:mysql://localhost/test app.datasource.username=dbuser app.datasource.password=dbpass app.datasource.maximum-pool-size=30
您能夠經過強制鏈接池使用並返回專用實現來解決這個問題，而不是DataSource。不能在運行時更改實現，但選項列表將是顯式的。
下面的示例演示如何建立HikariDataSource帶着DataSourceBuilder:
@Bean
@ConfigurationProperties("app.datasource")
public HikariDataSource dataSource() {
return DataSourceBuilder.create().type(HikariDataSource.class).build();
}
你甚至能夠經過利用DataSourceProperties爲您作-也就是說，提供一個默認的嵌入式數據庫與一個合理的用戶名和密碼，若是沒有提供URL。您能夠很容易地初始化DataSourceBuilder從任何DataSourceProperties對象，所以您還能夠注入SpringBoot自動建立的DataSource。可是，這將您的配置分爲兩個名稱空間：url, username, password, type，和driver在……上面spring.datasource其他的在您的自定義命名空間上(app.datasource)爲了不這種狀況，您能夠從新定義一個自定義。DataSourceProperties在您的自定義命名空間上，以下面的示例所示：
@Bean
@Primary
@ConfigurationProperties("app.datasource")
public DataSourceProperties dataSourceProperties() {
return new DataSourceProperties();
}
@Bean
@ConfigurationProperties("app.datasource")
public HikariDataSource dataSource(DataSourceProperties properties) {
return properties.initializeDataSourceBuilder().type(HikariDataSource.class)
.build();
}
這個設置讓你同步默認狀況下，SpringBoot爲您作了什麼，只是選擇了一個專用鏈接池(在代碼中)，而且在同一個命名空間中公開了它的設置。由於DataSourceProperties是照顧url/jdbcUrl爲您翻譯，您能夠按如下方式配置它：
app.datasource.url=jdbc:mysql://localhost/test app.datasource.username=dbuser app.datasource.password=dbpass app.datasource.maximum-pool-size=30
|
| 由於您的自定義配置選擇了Hikari， |
見「第29.1節，「配置數據源」「在」SpringBoot特性「部分和DataSourceAutoConfiguration獲取更多詳細信息。
83.2配置兩個DataSources
若是須要配置多個數據源，則能夠應用上一節中描述的相同技巧。可是，您必須標記其中一個DataSource實例@Primary，由於道路上的各類自動配置都但願可以按類型得到一個。
若是你本身創造DataSource，自動配置退出。在下面的示例中，咱們提供了精確性與自動配置在主數據源上提供的特性集相同：
@Bean
@Primary
@ConfigurationProperties("app.datasource.first")
public DataSourceProperties firstDataSourceProperties() {
return new DataSourceProperties();
}
@Bean
@Primary
@ConfigurationProperties("app.datasource.first")
public DataSource firstDataSource() {
return firstDataSourceProperties().initializeDataSourceBuilder().build();
}
@Bean
@ConfigurationProperties("app.datasource.second")
public BasicDataSource secondDataSource() {
return DataSourceBuilder.create().type(BasicDataSource.class).build();
}
|
|
|
這兩個數據源也爲高級自定義綁定。例如，您能夠按照如下方式配置它們：
app.datasource.first.type=com.zaxxer.hikari.HikariDataSource app.datasource.first.maximum-pool-size=30 app.datasource.second.url=jdbc:mysql://localhost/test app.datasource.second.username=dbuser app.datasource.second.password=dbpass app.datasource.second.max-total=30
您能夠將相同的概念應用於二級DataSource一樣，如如下示例所示：
@Bean
@Primary
@ConfigurationProperties("app.datasource.first")
public DataSourceProperties firstDataSourceProperties() {
return new DataSourceProperties();
}
@Bean
@Primary
@ConfigurationProperties("app.datasource.first")
public DataSource firstDataSource() {
return firstDataSourceProperties().initializeDataSourceBuilder().build();
}
@Bean
@ConfigurationProperties("app.datasource.second")
public DataSourceProperties secondDataSourceProperties() {
return new DataSourceProperties();
}
@Bean
@ConfigurationProperties("app.datasource.second")
public DataSource secondDataSource() {
return secondDataSourceProperties().initializeDataSourceBuilder().build();
}
前面的示例使用SpringBoot在自動配置中使用的相同邏輯在自定義命名空間上配置兩個數據源。
83.3使用Spring數據存儲庫
Spring數據能夠建立@Repository各類口味的界面。Spring Boot爲您處理全部這些，只要那些@Repositories的包(或子包)中包含。@EnableAutoConfiguration班級，等級
對於許多應用程序，只需在類路徑上放置正確的Spring數據依賴項(有一個spring-boot-starter-data-jpa對於JPA和一個spring-boot-starter-data-mongodb(對於MongoDB)，並建立一些存儲庫接口來處理@Entity物品。示例在JPA樣品而MongoDB樣本.
Spring Boot試圖猜想您@Repository定義，根據@EnableAutoConfiguration它找到了。若要得到更多控制，請使用@EnableJpaRepositories註釋(來自SpringDataJPA)。
有關Spring數據的更多信息，請參見春季數據項目頁面.
83.4將@實體定義與Spring配置分開
Spring Boot試圖猜想您@Entity定義，根據@EnableAutoConfiguration它找到了。要得到更多的控制，能夠使用@EntityScan註釋，如如下示例所示：
@Configuration
@EnableAutoConfiguration
@EntityScan(basePackageClasses=City.class)
public class Application {
//...
}
83.5配置JPA屬性
SpringDataJPA已經提供了一些與供應商無關的配置選項(例如用於SQL日誌記錄的配置選項)，SpringBoot將這些選項以及Hibernate的一些選項公開爲外部配置屬性。其中一些是根據上下文自動檢測到的，所以您不須要設置它們。
這，這個，那，那個spring.jpa.hibernate.ddl-auto是一個特例，由於根據運行時條件，它有不一樣的默認值。若是使用嵌入式數據庫，而且沒有架構管理器(如Liquibase或Flyway)處理DataSource，默認爲create-drop。在全部其餘狀況下，它默認爲none.
要使用的方言也會根據當前的DataSource，但你能夠spring.jpa.database若是你想要顯式的，而且繞過啓動時的檢查，那就是你本身。
|
| 指定 |
下面的示例顯示了最經常使用的設置選項：
spring.jpa.hibernate.naming.physical-strategy=com.example.MyPhysicalNamingStrategy spring.jpa.show-sql=true
此外，spring.jpa.properties.*做爲普通的jpa屬性傳遞(前綴去掉了前綴)。EntityManagerFactory是被創造出來的。
|
| 若是須要將高級自定義應用於Hibernate屬性，請考慮註冊 |
83.6配置Hibernate命名策略
Hibernate使用兩種不一樣的命名策略若要將名稱從對象模型映射到相應的數據庫名稱，請執行如下操做。物理和隱式策略實現的徹底限定類名能夠經過設置spring.jpa.hibernate.naming.physical-strategy和spring.jpa.hibernate.naming.implicit-strategy分別屬性。或者，若是ImplicitNamingStrategy或PhysicalNamingStrategybean在應用程序上下文中可用，Hibernate將被自動配置爲使用它們。
默認狀況下，SpringBoot使用SpringPhysicalNamingStrategy。此實現提供了與Hibernate 4相同的表結構：全部點都被下劃線替換，camel大小寫也被下劃線替換。默認狀況下，全部表名都以小寫形式生成，但若是架構須要該標誌，則能夠重寫該標誌。
例如，TelephoneNumber實體映射到telephone_number桌子
若是您更喜歡使用Hibernate 5的默認設置，請設置如下屬性：
spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
或者，您能夠配置如下bean：
@Bean
public PhysicalNamingStrategy physicalNamingStrategy() {
return new PhysicalNamingStrategyStandardImpl();
}
看見HibernateJpaAutoConfiguration和JpaBaseConfiguration更多細節。
83.7使用自定義EntityManagerFactory
控件的配置徹底控制EntityManagerFactory，您須要添加一個@Bean名爲「實體經理工廠」。Spring Boot自動配置在存在該類型bean的狀況下關閉其實體管理器。
83.8使用兩個實體管理器
即便默認EntityManagerFactory很好，你須要定義一個新的。不然，該類型的第二個bean的存在將關閉默認值。爲了便於操做，您能夠使用方便。EntityManagerBuilder由SpringBoot提供。或者，您能夠只在LocalContainerEntityManagerFactoryBean直接來自SpringORM，以下面的示例所示：
// 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();
}
上面的配置幾乎是獨立工做的。要完成圖片，您須要配置TransactionManagers對於這兩我的EntityManagers也是若是你把其中一個標記爲@Primary，它能夠在默認狀況下被撿起。JpaTransactionManager春靴。另外一個必須顯式地注入到一個新實例中。或者，您能夠使用跨二者的JTA事務管理器。
若是使用Spring數據，則須要配置@EnableJpaRepositories所以，如如下示例所示：
@Configuration
@EnableJpaRepositories(basePackageClasses = Customer.class,
entityManagerFactoryRef = "customerEntityManagerFactory")
public class CustomerConfiguration {
...
}
@Configuration
@EnableJpaRepositories(basePackageClasses = Order.class,
entityManagerFactoryRef = "orderEntityManagerFactory")
public class OrderConfiguration {
...
}
83.9使用傳統persistence.xml檔案
Spring Boot將不會搜索或使用META-INF/persistence.xml默認狀況下。若是你喜歡使用傳統的persistence.xml，您須要定義本身的@Bean類型LocalEntityManagerFactoryBean(ID爲‘ghtyManagerFactory’)並在那裏設置持久性單元名。
看見JpaBaseConfiguration用於默認設置。
83.10使用Spring數據JPA和MONGO存儲庫
Spring數據JPA和Spring Data MONGO均可以自動建立Repository爲您實現。若是它們都存在於類路徑中，那麼您可能須要作一些額外的配置來告訴SpringBoot要建立哪一個存儲庫。最明確的方法是使用標準的Spring數據@EnableJpaRepositories和@EnableMongoRepositories註釋，並提供Repository接口。
還有旗子(spring.data.*.repositories.enabled和spring.data.*.repositories.type)，能夠用來在外部配置中打開或關閉自動配置的存儲庫。這樣作是有用的，例如，若是您想關閉MONGO存儲庫，但仍然使用自動配置。MongoTemplate.
對於其餘自動配置的Spring數據存儲庫類型(Elasticearch、Solr和其餘類型)，存在相同的障礙和相同的特性。要使用它們，請相應地更改註釋和標誌的名稱。
83.11將Spring數據存儲庫公開爲REST端點
Spring數據REST能夠公開Repository爲您提供REST端點的實現，前提是爲應用程序啓用了SpringMVC。
Spring Boot公開了一組有用的屬性(來自spring.data.rest命名空間)，自定義RepositoryRestConfiguration。若是須要提供其餘自定義，則應使用RepositoryRestConfigurer豆子
|
| 若是您沒有在您的自定義中指定任何訂單 |
83.12配置JPA使用的組件
若是要配置JPA使用的組件，則須要確保在JPA以前初始化該組件。當組件自動配置時，SpringBoot會爲您處理這個問題。例如，當Flyway自動配置時，Hibernate被配置爲依賴於Flyway，這樣Flyway就有機會在Hibernate嘗試使用以前初始化數據庫。
若是您本身正在配置組件，則能夠使用EntityManagerFactoryDependsOnPostProcessor子類做爲設置所需依賴項的方便方法。例如，若是將Hibernate搜索與Elasticearch一塊兒用做索引管理器，則任何EntityManagerFactorybean必須配置爲依賴於elasticsearchClientbean，如如下示例所示：
/**
* {@link EntityManagerFactoryDependsOnPostProcessor} that ensures that
* {@link EntityManagerFactory} beans depend on the {@code elasticsearchClient} bean.
*/
@Configuration
static class ElasticsearchJpaDependencyConfiguration
extends EntityManagerFactoryDependsOnPostProcessor {
ElasticsearchJpaDependencyConfiguration() {
super("elasticsearchClient");
}
}
83.13用兩個DataSources配置jOOQ
若是須要對多個數據源使用jOOQ，則應建立本身的DSLContext每一個人。請參閱JooqAutoConfiguration更多細節。
|
| 特別是， |
84.數據庫初始化
根據堆棧的不一樣，能夠不一樣的方式初始化SQL數據庫。固然，若是數據庫是一個單獨的進程，您也能夠手動完成。
84.1使用JPA初始化數據庫
JPA具備生成DDL的功能，這些特性能夠設置爲在數據庫啓動時運行。這是經過兩個外部屬性控制的：
spring.jpa.generate-ddl(Boole)打開和關閉功能，而且與供應商無關。spring.jpa.hibernate.ddl-auto(Enum)是一個Hibernate特性，它以更細粒度的方式控制行爲。本指南後面將對此特性進行更詳細的描述。
84.2使用Hibernate初始化數據庫
你能夠spring.jpa.hibernate.ddl-auto顯式和標準Hibernate屬性值爲none, validate, update, create，和create-drop。SpringBoot根據它是否定爲您的數據庫是嵌入式的，爲您選擇一個默認值。默認爲create-drop若是沒有檢測到架構管理器，則爲none在全部其餘狀況下。經過查看Connection類型。hsqldb, h2，和derby是嵌入的，而其餘的則不是。在從內存中切換到「真實」數據庫時，要當心，不要對新平臺中的表和數據的存在作出假設。你要麼必須設置ddl-auto顯式或使用其餘機制之一初始化數據庫。
- 1. Spring boot參考指南
- 2. Spring Boot 參考指南（SpringApplication）
- 3. Spring Boot 參考指南（Hazelcast）
- 4. Spring Boot 參考指南（Spring Boot介紹）
- 5. Spring Boot 參考指南（Spring Boot文檔）
- 6. Spring Boot 參考指南（安裝 Spring Boot）
- 7. Spring Boot 參考指南（自動配置）
- 8. Spring Boot參考指南中文版--Chapter1.Spring Boot中文文檔
- 9. Spring Boot 參考指南（Spring Integration）
- 10. Spring Boot 參考指南（日誌記錄）
- 更多相關文章...
- • SQL 指南 - 網站建設指南
- • HTML 指南 - 網站建設指南
- • SpringBoot中properties文件不能自動提示解決方法
- • 算法總結-雙指針
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Spring boot參考指南
- 2. Spring Boot 參考指南（SpringApplication）
- 3. Spring Boot 參考指南（Hazelcast）
- 4. Spring Boot 參考指南（Spring Boot介紹）
- 5. Spring Boot 參考指南（Spring Boot文檔）
- 6. Spring Boot 參考指南（安裝 Spring Boot）
- 7. Spring Boot 參考指南（自動配置）
- 8. Spring Boot參考指南中文版--Chapter1.Spring Boot中文文檔
- 9. Spring Boot 參考指南（Spring Integration）
- 10. Spring Boot 參考指南（日誌記錄）