1 開始

1.1 spring介紹

Spring Boot使開發獨立的，產品級別的基於Spring的應用變得非常簡單，你只需"just run"。 我們為Spring平臺及第三方庫提供開箱即用的設定，這樣你就可以有條不紊地開始。多數Spring Boot應用需要很少的Spring配置。

你可以使用Spring Boot建立Java應用，並使用java -jar啟動它或採用傳統的war部署方式。

1.2 系統要求

預設情況下，Spring Boot 1.3.0.BUILD-SNAPSHOT 需要Java7和Spring框架4.1.3或以上。你可以在Java6下使用Spring Boot，不過需要新增額外配置。具體參考Section 73.9, “How to use Java 6” 。構建環境明確支援的有Maven（3.2+）和Gradle（1.12+）。

Servlet容器 下列內嵌容器支援開箱即用（out of the box）：

名稱      Servlet版本   Java版本
Tomcat 8    3.1     Java 7+
Tomcat 7    3.0     Java 6+
Jetty 9     3.1     Java 7+
Jetty 8     3.0     Java 6+
Undertow 1.1    3.1 Java 7+

你也可以將Spring Boot應用部署到任何相容Servlet 3.0+的容器。

1.3 第一個spring boot應用

在開始前，你需要開啟一個終端，檢查是否安裝可用的Java版本和Maven：

$ mvn -v
Apache Maven 3.2.3 (33f8c3e1027c3ddde99d3cdebad2656a31e8fdf4; 2014-08-11T13:58:10-07:00)
Maven home: /Users/user/tools/apache-maven-3.1.1
Java version: 1.7.0_51, vendor: Oracle Corporation

建立pom.xml檔案

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

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

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

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

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

新增classpath依賴：

Spring Boot提供很多"Starter POMs"，這能夠讓你輕鬆的將jars新增到你的classpath下。我們的示例程式已經在POM的partent節點使用了spring-boot-starter-parent。spring-boot-starter-parent是一個特殊的starter，它提供了有用的Maven預設設定。同時，它也提供了一個dependency-management節點，這樣對於”blessed“依賴你可以省略version標記。

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

如果再次執行mvn dependency:tree，你將看到現在有了一些其他依賴，包括Tomcat web伺服器和Spring Boot自身。

編寫程式碼：

為了完成應用程式，我們需要建立一個單獨的Java檔案。Maven預設會編譯src/main/java下的原始碼，所以你需要建立那樣的檔案結構，然後新增一個名為src/main/java/Example.java的檔案：

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

@RestController
@EnableAutoConfiguration
public class Example {

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

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

@RestController和@RequestMapping說明：

@RestController。這被稱為一個構造型（stereotype）註解。它為閱讀程式碼的人們提供建議。對於Spring，該類扮演了一個特殊角色。在本示例中，我們的類是一個web @Controller，所以當處理進來的web請求時，Spring會詢問它。

@RequestMapping註解提供路由資訊。它告訴Spring任何來自"/"路徑的HTTP請求都應該被對映到home方法。@RestController註解告訴Spring以字串的形式渲染結果，並直接返回給呼叫者。

@EnableAutoConfiguration。這個註解告訴Spring Boot根據新增的jar依賴猜測你想如何配置Spring。由於spring-boot-starter-web新增了Tomcat和Spring MVC，所以auto-configuration將假定你正在開發一個web應用並相應地對Spring進行設定。

main方法。這只是一個標準的方法，它遵循Java對於一個應用程式入口點的約定。我們的main方法通過呼叫run，將業務委託給了Spring Boot的SpringApplication類。SpringApplication將引導我們的應用，啟動Spring，相應地啟動被自動配置的Tomcat web伺服器。我們需要將Example.class作為引數傳遞給run方法來告訴SpringApplication誰是主要的Spring元件。

執行：

 mvn spring-boot:run

如果使用一個瀏覽器開啟 localhost:8080，以下輸出：

Hello World!

建立可執行jar

為了建立可執行的jar，需要將spring-boot-maven-plugin新增到我們的pom.xml中。在dependencies節點下插入以下內容：

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

注：spring-boot-starter-parent POM包含用於繫結repackage目標的配置。如果你不使用parent POM，你將需要自己宣告該配置。具體參考外掛文件。

儲存你的pom.xml，然後從命令列執行mvn package：

 mvn package

如果檢視target目錄，你應該看到myproject-0.0.1-SNAPSHOT.jar。該檔案應該有10Mb左右的大小。如果想偷看內部結構，你可以執行jar tvf：

 jar tvf target/myproject-0.0.1-SNAPSHOT.jar

在target目錄下，你應該也能看到一個很小的名為myproject-0.0.1-SNAPSHOT.jar.original的檔案。這是在Spring Boot重新打包前Maven建立的原始jar檔案。

為了執行該應用程式，你可以使用java -jar命令：

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

2. 使用Spring Boot

2.1 maven

Maven使用者可以繼承spring-boot-starter-parent專案來獲取合適的預設設定。該父專案提供以下特性：

預設編譯級別為Java 1.6
原始碼編碼為UTF-8
一個依賴管理節點，允許你省略普通依賴的<version>標籤，繼承自spring-boot-dependencies POM。
合適的資源過濾
合適的外掛配置（exec外掛，surefire，Git commit ID，shade）
針對application.properties和application.xml的資源過濾

最後一點：由於預設配置檔案接收Spring風格的佔位符（${...}），Maven filtering改用@..@佔位符（你可以使用Maven屬性resource.delimiter來覆蓋它）。

想配置你的專案繼承spring-boot-starter-parent只需要簡單地設定parent為：

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

注：你應該只需要在該依賴上指定Spring Boot版本。如果匯入其他的starters，你可以放心的省略版本號。

使用沒有父POM的Spring Boot

不是每個人都喜歡繼承spring-boot-starter-parent POM。你可能需要使用公司標準parent，或你可能傾向於顯式宣告所有Maven配置。

如果你不使用spring-boot-starter-parent，通過使用一個scope=import的依賴，你仍能獲取到依賴管理的好處：

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

改變Java版本

spring-boot-starter-parent選擇相當保守的Java相容策略。如果你遵循我們的建議，使用最新的Java版本，你可以新增一個java.version屬性：

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

** 使用Spring Boot Maven外掛**

Spring Boot包含一個Maven外掛，它可以將專案打包成一個可執行jar。如果想使用它，你可以將該外掛新增到節點處：

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

注：如果使用Spring Boot starter parent pom，你只需要新增該外掛而無需配置它，除非你想改變定義在partent中的設定。

2.2 組織程式碼

Spring Boot不需要使用任何特殊的程式碼結構，然而，這裡有一些有用的最佳實踐。

使用"default"包

當類沒有包含package宣告時，它被認為處於default package下。通常不推薦使用default package，並應該避免使用它。因為對於使用@ComponentScan，@EntityScan或@SpringBootApplication註解的Spring Boot應用來說，來自每個jar的類都會被讀取，這會造成一定的問題。

定位main應用類

我們通常建議你將main應用類放在位於其他類上面的根包（root package）中。通常使用@EnableAutoConfiguration註解你的main類，並且暗地裡為某些項定義了一個基礎“search package”。例如，如果你正在編寫一個JPA應用，被@EnableAutoConfiguration註解的類所在包將被用來搜尋@Entity項。

使用根包允許你使用@ComponentScan註解而不需要定義一個basePackage屬性。如果main類位於根包中，你也可以使用@SpringBootApplication註解。

下面是一個典型的結構：

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

Application.java檔案將宣告main方法，還有基本的@Configuration。

package com.example.myproject;

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

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application {

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

}

2.3 配置類

Spring Boot提倡基於Java的配置。儘管你可以使用一個XML源來呼叫SpringApplication.run()，我們通常建議你使用@Configuration類作為主要源。一般定義main方法的類也是主要@Configuration的一個很好候選。

1、匯入其他配置類

你不需要將所有的@Configuration放進一個單獨的類。@Import註解可以用來匯入其他配置類。另外，你也可以使用@ComponentScan註解自動收集所有的Spring元件，包括@Configuration類。

2、匯入XML配置

如果你絕對需要使用基於XML的配置，我們建議你仍舊從一個@Configuration類開始。你可以使用附加的@ImportResource註解載入XML配置檔案。

2.4 自動配置

Spring Boot自動配置（auto-configuration）嘗試根據你新增的jar依賴自動配置你的Spring應用。例如，如果你的classpath下存在HSQLDB，並且你沒有手動配置任何資料庫連線beans，那麼我們將自動配置一個記憶體型（in-memory）資料庫。

你可以通過將@EnableAutoConfiguration或@SpringBootApplication註解新增到一個@Configuration類上來選擇自動配置。

注：你只需要新增一個@EnableAutoConfiguration註解。我們建議你將它新增到主@Configuration類上。

禁用特定的自動配置

如果發現應用了你不想要的特定自動配置類，你可以使用@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 {
}

2.5 Spring Beans和依賴注入

你可以自由地使用任何標準的Spring框架技術去定義beans和它們注入的依賴。簡單起見，我們經常使用@ComponentScan註解搜尋beans，並結合@Autowired構造器注入。

如果使用上面建議的結構組織程式碼（將應用類放到根包下），你可以新增@ComponentScan註解而不需要任何引數。你的所有應用程式元件（@Component, @Service, @Repository, @Controller等）將被自動註冊為Spring Beans。

下面是一個@Service Bean的示例，它使用構建器注入獲取一個需要的RiskAssessor bean。

package com.example.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class DatabaseAccountService implements AccountService {

    private final RiskAssessor riskAssessor;

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

    // ...
}

注：注意如何使用構建器注入來允許riskAssessor欄位被標記為final，這意味著riskAssessor後續是不能改變的。

2.6 使用@SpringBootApplication註解

很多Spring Boot開發者總是使用@Configuration，@EnableAutoConfiguration和@ComponentScan註解他們的main類。由於這些註解被如此頻繁地一塊使用（特別是你遵循以上最佳實踐時），Spring Boot提供一個方便的@SpringBootApplication選擇。

該@SpringBootApplication註解等價於以預設屬性使用@Configuration，@EnableAutoConfiguration和@ComponentScan。

package com.example.myproject;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication // same as @Configuration @EnableAutoConfiguration @ComponentScan
public class Application {

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

}

2.7 作為一個打包後的應用執行

如果使用Spring Boot Maven或Gradle外掛建立一個可執行jar，你可以使用java -jar執行你的應用。例如：

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

執行一個打包的程式並開啟遠端除錯支援是可能的，這允許你將偵錯程式附加到打包的應用程式上：

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

2.8 使用Maven外掛執行

Spring Boot Maven外掛包含一個run目標，它可以用來快速編譯和執行應用程式。應用程式以一種暴露的方式執行，由於即時"熱"載入，你可以編輯資源。

 mvn spring-boot:run

你可能想使用有用的作業系統環境變數：

 export MAVEN_OPTS=-Xmx1024m -XX:MaxPermSize=128M -Djava.security.egd=file:/dev/./urandom

3 Spring Boot特性

3.1 SpringApplication

SpringApplication類提供了一種從main()方法啟動Spring應用的便捷方式。在很多情況下，你只需委託給SpringApplication.run這個靜態方法：

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

當應用啟動時，你應該會看到類似下面的東西（這是何方神獸？？）：

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

2013-07-31 00:08:16.117  INFO 56603 --- [           main] o.s.b.s.app.SampleApplication            : Starting SampleApplication v0.1.0 on mycomputer with PID 56603 (/apps/myapp.jar started by pwebb)
2013-07-31 00:08:16.166  INFO 56603 --- [           main] ationConfigEmbeddedWebApplicationContext : Refreshing org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@6e5a8246: startup date [Wed Jul 31 00:08:16 PDT 2013]; root of context hierarchy
2014-03-04 13:09:54.912  INFO 41370 --- [           main] .t.TomcatEmbeddedServletContainerFactory : Server initialized with port: 8080
2014-03-04 13:09:56.501  INFO 41370 --- [           main] o.s.b.s.app.SampleApplication            : S

預設情況下會顯示INFO級別的日誌資訊，包括一些相關的啟動詳情，比如啟動應用的使用者等。

3.1.1 自定義Banner

通過在classpath下新增一個banner.txt或設定banner.location來指定相應的檔案可以改變啟動過程中列印的banner。如果這個檔案有特殊的編碼，你可以使用banner.encoding設定它（預設為UTF-8）。

在banner.txt中可以使用如下的變數：

變數          描述
${application.version}          MANIFEST.MF中宣告的應用版本號，例如1.0
${application.formatted-version}        MANIFEST.MF中宣告的被格式化後的應用版本號（被括號包裹且以v作為字首），用於顯示，例如(v1.0)
${spring-boot.version}      正在使用的Spring Boot版本號，例如1.2.2.BUILD-SNAPSHOT
${spring-boot.formatted-version}        正在使用的Spring Boot被格式化後的版本號（被括號包裹且以v作為字首）, 用於顯示，例如(v1.2.2.BUILD-SNAPSHOT)

注：如果想以程式設計的方式產生一個banner，可以使用SpringBootApplication.setBanner(…)方法。使用org.springframework.boot.Banner介面，實現你自己的printBanner()方法。

3.1.2 自定義SpringApplication

如果預設的SpringApplication不符合你的口味，你可以建立一個本地的例項並自定義它。例如，關閉banner你可以這樣寫：

public static void main(String[] args){
    SpringApplication app = new SpringApplication(MySpringConfiguration.class);
    app.setShowBanner(false);
    app.run(args);
}

注：傳遞給SpringApplication的構造器引數是spring beans的配置源。在大多數情況下，這些將是@Configuration類的引用，但它們也可能是XML配置或要掃描包的引用。

3.1.3 流暢的構建API

如果你需要建立一個分層的ApplicationContext（多個具有父子關係的上下文），或你只是喜歡使用流暢的構建API，你可以使用SpringApplicationBuilder。SpringApplicationBuilder允許你以鏈式方式呼叫多個方法，包括可以建立層次結構的parent和child方法。

new SpringApplicationBuilder()
    .showBanner(false)
    .sources(Parent.class)
    .child(Application.class)
    .run(args);

注：建立ApplicationContext層次時有些限制，比如，Web元件(components)必須包含在子上下文(child context)中，且相同的Environment即用於父上下文也用於子上下文中。

3.1.4 Application事件和監聽器

除了常見的Spring框架事件，比如ContextRefreshedEvent，一個SpringApplication也傳送一些額外的應用事件。一些事件實際上是在ApplicationContext被建立前觸發的。

你可以使用多種方式註冊事件監聽器，最普通的是使用SpringApplication.addListeners(…)方法。在你的應用執行時，應用事件會以下面的次序傳送：

在執行開始，但除了監聽器註冊和初始化以外的任何處理之前，會傳送一個ApplicationStartedEvent。

在Environment將被用於已知的上下文，但在上下文被建立前，會傳送一個ApplicationEnvironmentPreparedEvent。

在refresh開始前，但在bean定義已被載入後，會傳送一個ApplicationPreparedEvent。

啟動過程中如果出現異常，會傳送一個ApplicationFailedEvent。

注：你通常不需要使用應用程式事件，但知道它們的存在會很方便（在某些場合可能會使用到）。在Spring內部，Spring Boot使用事件處理各種各樣的任務。

3.1.5 Web環境

一個SpringApplication將嘗試為你建立正確型別的ApplicationContext。在預設情況下，使用AnnotationConfigApplicationContext或AnnotationConfigEmbeddedWebApplicationContext取決於你正在開發的是否是web應用。

用於確定一個web環境的演算法相當簡單（基於是否存在某些類）。如果需要覆蓋預設行為，你可以使用setWebEnvironment(boolean webEnvironment)。通過呼叫setApplicationContextClass(…)，你可以完全控制ApplicationContext的型別。

注：當JUnit測試裡使用SpringApplication時，呼叫setWebEnvironment(false)是可取的。

3.1.6 命令列啟動器

如果你想獲取原始的命令列引數，或一旦SpringApplication啟動，你需要執行一些特定的程式碼，你可以實現CommandLineRunner介面。在所有實現該介面的Spring beans上將呼叫run(String… args)方法。

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

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

如果一些CommandLineRunner beans被定義必須以特定的次序呼叫，你可以額外實現org.springframework.core.Ordered介面或使用org.springframework.core.annotation.Order註解。

3.1.7 Application退出

每個SpringApplication在退出時為了確保ApplicationContext被優雅的關閉，將會註冊一個JVM的shutdown鉤子。所有標準的Spring生命週期回撥（比如，DisposableBean介面或@PreDestroy註解）都能使用。

此外，如果beans想在應用結束時返回一個特定的退出碼（exit code），可以實現org.springframework.boot.ExitCodeGenerator介面。

4 外化配置

Spring Boot允許外化（externalize）你的配置，這樣你能夠在不同的環境下使用相同的程式碼。你可以使用properties檔案，YAML檔案，環境變數和命令列引數來外化配置。使用@Value註解，可以直接將屬性值注入到你的beans中，並通過Spring的Environment抽象或繫結到結構化物件來訪問。

Spring Boot使用一個非常特別的PropertySource次序來允許對值進行合理的覆蓋，需要以下面的次序考慮屬性：

命令列引數
來自於java:comp/env的JNDI屬性
Java系統屬性（System.getProperties()）
作業系統環境變數
只有在random.*裡包含的屬性會產生一個RandomValuePropertySource
在打包的jar外的應用程式配置檔案（application.properties，包含YAML和profile變數）
在打包的jar內的應用程式配置檔案（application.properties，包含YAML和profile變數）
在@Configuration類上的@PropertySource註解
預設屬性（使用SpringApplication.setDefaultProperties指定）

下面是一個具體的示例（假設你開發一個使用name屬性的@Component）：

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

@Component
public class MyBean {
    @Value("${name}")
    private String name;
    // ...
}

你可以將一個application.properties檔案捆綁到jar內，用來提供一個合理的預設name屬性值。當執行在生產環境時，可以在jar外提供一個application.properties檔案來覆蓋name屬性。對於一次性的測試，你可以使用特定的命令列開關啟動（比如，java -jar app.jar --name="Spring"）。

4.1 配置隨機值

RandomValuePropertySource在注入隨機值（比如，金鑰或測試用例）時很有用。它能產生整數，longs或字串，比如：

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

random.int*語法是OPEN value (,max) CLOSE，此處OPEN，CLOSE可以是任何字元，並且value，max是整數。如果提供max，那麼value是最小的值，max是最大的值（不包含在內）。

4.2訪問命令列屬性

預設情況下，SpringApplication將任何可選的命令列引數（以'--'開頭，比如，--server.port=9000）轉化為property，並將其新增到Spring Environment中。如上所述，命令列屬性總是優先於其他屬性源。

如果你不想將命令列屬性新增到Environment裡，你可以使用SpringApplication.setAddCommandLineProperties(false)來禁止它們。

4.3 Application屬性檔案

SpringApplication將從以下位置載入application.properties檔案，並把它們新增到Spring Environment中：

當前目錄下的一個/config子目錄
當前目錄
一個classpath下的/config包
classpath根路徑（root）

這個列表是按優先順序排序的（列表中位置高的將覆蓋位置低的）。

注：你可以使用YAML（'.yml'）檔案替代'.properties'。

如果不喜歡將application.properties作為配置檔名，你可以通過指定spring.config.name環境屬性來切換其他的名稱。你也可以使用spring.config.location環境屬性來引用一個明確的路徑（目錄位置或檔案路徑列表以逗號分割）。

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

如果spring.config.location包含目錄（相對於檔案），那它們應該以/結尾（在載入前，spring.config.name產生的名稱將被追加到後面）。不管spring.config.location是什麼值，預設的搜尋路徑classpath:,classpath:/config,file:,file:config/總會被使用。以這種方式，你可以在application.properties中為應用設定預設值，然後在執行的時候使用不同的檔案覆蓋它，同時保留預設配置。

注：如果你使用環境變數而不是系統配置，大多數作業系統不允許以句號分割（period-separated）的key名稱，但你可以使用下劃線（underscores）代替（比如，使用SPRINGCONFIGNAME代替spring.config.name）。如果你的應用執行在一個容器中，那麼JNDI屬性（java:comp/env）或servlet上下文初始化引數可以用來取代環境變數或系統屬性，當然也可以使用環境變數或系統屬性。

4.4 特定的Profile屬性

除了application.properties檔案，特定配置屬性也能通過命令慣例application-{profile}.properties來定義。特定Profile屬性從跟標準application.properties相同的路徑載入，並且特定profile檔案會覆蓋預設的配置。

4.5 屬性佔位符

當application.properties裡的值被使用時，它們會被存在的Environment過濾，所以你能夠引用先前定義的值（比如，系統屬性）。

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

4.6 使用YAML代替Properties

YAML是JSON的一個超集，也是一種方便的定義層次配置資料的格式。無論你何時將SnakeYAML 庫放到classpath下，SpringApplication類都會自動支援YAML作為properties的替換。

注：如果你使用'starter POMs'，spring-boot-starter會自動提供SnakeYAML。

4.6.1. 載入YAML

Spring框架提供兩個便利的類用於載入YAML文件，YamlPropertiesFactoryBean會將YAML作為Properties來載入，YamlMapFactoryBean會將YAML作為Map來載入。

示例：

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

上面的YAML文件會被轉化到下面的屬性中：

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

YAML列表被表示成使用[index]間接引用作為屬性keys的形式，例如下面的YAML：

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

將會轉化到下面的屬性中:

my.servers[0]=dev.bar.com
my.servers[1]=foo.bar.com

使用Spring DataBinder工具繫結那樣的屬性（這是@ConfigurationProperties做的事），你需要確定目標bean中有個java.util.List或Set型別的屬性，並且需要提供一個setter或使用可變的值初始化它，比如，下面的程式碼將繫結上面的屬性：

@ConfigurationProperties(prefix="my")
public class Config {
    private List<String> servers = new ArrayList<String>();
    public List<String> getServers() {
        return this.servers;
    }
}

4.6.2. 在Spring環境中使用YAML暴露屬性

YamlPropertySourceLoader類能夠用於將YAML作為一個PropertySource匯出到Sprig Environment。這允許你使用熟悉的@Value註解和佔位符語法訪問YAML屬性。

4.6.3. Multi-profile YAML文件

你可以在單個檔案中定義多個特定配置（profile-specific）的YAML文件，並通過一個spring.profiles key標示應用的文件。例如：

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

在上面的例子中，如果development配置被啟用，那server.address屬性將是127.0.0.1。如果development和production配置（profiles）沒有啟用，則該屬性的值將是192.168.1.100。

YAML缺點

YAML檔案不能通過@PropertySource註解載入。所以，在這種情況下，如果需要使用@PropertySource註解的方式載入值，那就要使用properties檔案。

4.7. 型別安全的配置屬性

使用@Value("${property}")註解注入配置屬性有時可能比較笨重，特別是需要使用多個properties或你的資料本身有層次結構。為了控制和校驗你的應用配置，Spring Boot提供一個允許強型別beans的替代方法來使用properties。

示例：

@Component
@ConfigurationProperties(prefix="connection")
public class ConnectionSettings {
    private String username;
    private InetAddress remoteAddress;
    // ... getters and setters
}

當@EnableConfigurationProperties註解應用到你的@Configuration時，任何被@ConfigurationProperties註解的beans將自動被Environment屬性配置。這種風格的配置特別適合與SpringApplication的外部YAML配置進行配合使用。

# application.yml
connection:
    username: admin
    remoteAddress: 192.168.1.1
# additional configuration as required

為了使用@ConfigurationProperties beans，你可以使用與其他任何bean相同的方式注入它們。

@Service
public class MyService {
    @Autowired
    private ConnectionSettings connection;
     //...
    @PostConstruct
    public void openConnection() {
        Server server = new Server();
        this.connection.configure(server);
    }
}

你可以通過在@EnableConfigurationProperties註解中直接簡單的列出屬性類來快捷的註冊@ConfigurationProperties bean的定義。

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

注：使用@ConfigurationProperties能夠產生可被IDEs使用的後設資料檔案。具體參考Appendix B, Configuration meta-data。

4.7.1. 第三方配置

正如使用@ConfigurationProperties註解一個類，你也可以在@Bean方法上使用它。當你需要繫結屬性到不受你控制的第三方元件時，這種方式非常有用。

為了從Environment屬性配置一個bean，將@ConfigurationProperties新增到它的bean註冊過程：

@ConfigurationProperties(prefix = "foo")
@Bean
public FooComponent fooComponent() {
    ...
}

和上面ConnectionSettings的示例方式相同，任何以foo為字首的屬性定義都會被對映到FooComponent上。

4.7.2. 鬆散的繫結（Relaxed binding）

Spring Boot使用一些寬鬆的規則用於繫結Environment屬性到@ConfigurationProperties beans，所以Environment屬性名和bean屬性名不需要精確匹配。常見的示例中有用的包括虛線分割（比如，context--path繫結到contextPath）和將環境屬性轉為大寫字母（比如，PORT繫結port）。

示例：

@Component
@ConfigurationProperties(prefix="person")
public class ConnectionSettings {
    private String firstName;
}

下面的屬性名都能用於上面的@ConfigurationProperties類：

屬性                  說明
person.firstName    標準駝峰規則
person.first-name   虛線表示，推薦用於.properties和.yml檔案中
PERSON_FIRST_NAME   大寫形式，使用系統環境變數時推薦

Spring會嘗試強制外部的應用屬性在繫結到@ConfigurationProperties beans時型別是正確的。如果需要自定義型別轉換，你可以提供一個ConversionService bean（bean id為conversionService）或自定義屬性編輯器（通過一個CustomEditorConfigurer bean）。

4.7.3. @ConfigurationProperties校驗

Spring Boot將嘗試校驗外部的配置，預設使用JSR-303（如果在classpath路徑中）。你可以輕鬆的為你的@ConfigurationProperties類新增JSR-303 javax.validation約束註解：

@Component
@ConfigurationProperties(prefix="connection")
public class ConnectionSettings {
    @NotNull
    private InetAddress remoteAddress;
    // ... getters and setters
}

你也可以通過建立一個叫做configurationPropertiesValidator的bean來新增自定義的Spring Validator。

注：spring-boot-actuator模組包含一個暴露所有@ConfigurationProperties beans的端點。

5 Profiles

Spring Profiles提供了一種隔離應用程式配置的方式，並讓這些配置只能在特定的環境下生效。任何@Component或@Configuration都能被@Profile標記，從而限制載入它的時機。

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

以正常的Spring方式，你可以使用一個spring.profiles.active的Environment屬性來指定哪個配置生效。你可以使用平常的任何方式來指定該屬性，例如，可以將它包含到你的application.properties中：

spring.profiles.active=dev,hsqldb
或使用命令列開關：

--spring.profiles.active=dev,hsqldb

5.1. 新增啟用的配置(profiles)

spring.profiles.active屬性和其他屬性一樣都遵循相同的排列規則，最高的PropertySource獲勝。也就是說，你可以在application.properties中指定生效的配置，然後使用命令列開關替換它們。

有時，將特定的配置屬性新增到生效的配置中而不是替換它們是有用的。spring.profiles.include屬性可以用來無條件的新增生效的配置。SpringApplication的入口點也提供了一個用於設定額外配置的Java API（比如，在那些通過spring.profiles.active屬性生效的配置之上）：參考setAdditionalProfiles()方法。

示例：當一個應用使用下面的屬性，並用--spring.profiles.active=prod開關執行，那proddb和prodmq配置也會生效：

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

注：spring.profiles屬性可以定義到一個YAML文件中，用於決定什麼時候該文件被包含進配置中。

5.2.以程式設計方式設定profiles

在應用執行前，你可以通過呼叫SpringApplication.setAdditionalProfiles(…)方法，以程式設計的方式設定生效的配置。使用Spring的ConfigurableEnvironment介面激動配置也是可行的。

5.3. Profile特定配置檔案

application.properties（或application.yml）和通過@ConfigurationProperties引用的檔案這兩種配置特定變種都被當作檔案來載入的，具體參考Section 23.3, “Profile specific properties”。

6 日誌

Spring Boot內部日誌系統使用的是Commons Logging，但開放底層的日誌實現。預設為會Java Util Logging, Log4J, Log4J2和Logback提供配置。每種情況下都會預先配置使用控制檯輸出，也可以使用可選的檔案輸出。

預設情況下，如果你使用'Starter POMs'，那麼就會使用Logback記錄日誌。為了確保那些使用Java Util Logging, Commons Logging, Log4J或SLF4J的依賴庫能夠正常工作，正確的Logback路由也被包含進來。

注：如果上面的列表看起來令人困惑，不要擔心，Java有很多可用的日誌框架。通常，你不需要改變日誌依賴，Spring Boot預設的就能很好的工作。

6.1. 日誌格式

Spring Boot預設的日誌輸出格式如下：

2014-03-05 10:57:51.112  INFO 45469 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet Engine: Apache Tomcat/7.0.52
2014-03-05 10:57:51.253  INFO 45469 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2014-03-05 10:57:51.253  INFO 45469 --- [ost-startStop-1] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 1358 ms
2014-03-05 10:57:51.698  INFO 45469 --- [ost-startStop-1] o.s.b.c.e.ServletRegistrationBean        : Mapping servlet: 'dispatcherServlet' to [/]
2014-03-05 10:57:51.702  INFO 45469 --- [ost-startStop-1] o.s.b.c.embedded.FilterRegistrationBean  : Mapping filter: 'hiddenHttpMethodFilter' to: [/*]

輸出的節點（items）如下：

日期和時間 - 精確到毫秒，且易於排序。
日誌級別 - ERROR, WARN, INFO, DEBUG 或 TRACE。
Process ID。
一個用於區分實際日誌資訊開頭的---分隔符。
執行緒名 - 包括在方括號中（控制檯輸出可能會被截斷）。
日誌名 - 通常是源class的類名（縮寫）。
日誌資訊。

5.2. 控制檯輸出

預設的日誌配置會在寫日誌訊息時將它們回顯到控制檯。預設，ERROR, WARN和INFO級別的訊息會被記錄。可以在啟動應用時，通過--debug標識開啟控制檯的DEBUG級別日誌記錄。

 java -jar myapp.jar --debug

如果你的終端支援ANSI，為了增加可讀性將會使用彩色的日誌輸出。你可以設定spring.output.ansi.enabled為一個支援的值來覆蓋自動檢測。

5.3. 檔案輸出

預設情況下，Spring Boot只會將日誌記錄到控制檯而不會寫進日誌檔案。如果除了輸出到控制檯你還想寫入到日誌檔案，那你需要設定logging.file或logging.path屬性（例如在你的application.properties中）。

下表顯示如何組合使用logging.*：

logging.file        logging.path        示例      描述
(none)  (none)      只記錄到控制檯
Specific file       (none)      my.log      寫到特定的日誌檔案裡，名稱可以是一個精確的位置或相對於當前目錄
(none)      Specific folder     /var/log        寫到特定資料夾下的spring.log裡，名稱可以是一個精確的位置或相對於當前目錄

日誌檔案每達到10M就會被輪換（分割），和控制檯一樣，預設記錄ERROR, WARN和INFO級別的資訊。

5.4. 日誌級別

所有支援的日誌系統在Spring的Environment（例如在application.properties裡）都有通過'logging.level.*=LEVEL'（'LEVEL'是TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF中的一個）設定的日誌級別。

示例：application.properties

logging.level.org.springframework.web: DEBUG
logging.level.org.hibernate: ERROR

5.5. 自定義日誌配置

通過將適當的庫新增到classpath，可以啟用各種日誌系統。然後在classpath的根目錄(root)或通過Spring Environment的logging.config屬性指定的位置提供一個合適的配置檔案來達到進一步的定製（注意由於日誌是在ApplicationContext被建立之前初始化的，所以不可能在Spring的@Configuration檔案中，通過@PropertySources控制日誌。系統屬性和平常的Spring Boot外部配置檔案能正常工作）。

根據你的日誌系統，下面的檔案會被載入：

日誌系統    定製
Logback logback.xml
Log4j   log4j.properties或log4j.xml
Log4j2  log4j2.xml
JDK (Java Util Logging) logging.properties

為了幫助定製一些其他的屬性，從Spring的Envrionment轉換到系統屬性：

Spring Environment  System Property 評價
logging.file    LOG_FILE    如果定義，在預設的日誌配置中使用
logging.path    LOG_PATH    如果定義，在預設的日誌配置中使用
PID PID 當前的處理程式(process)ID（如果能夠被發現且還沒有作為作業系統環境變數被定義）

所有支援的日誌系統在解析它們的配置檔案時都能查詢系統屬性。具體可以參考spring-boot.jar中的預設配置。

注：在執行可執行的jar時，Java Util Logging有類載入問題，我們建議你儘可能避免使用它。

6 開發Web應用

Spring Boot非常適合開發web應用程式。你可以使用內嵌的Tomcat，Jetty或Undertow輕輕鬆鬆地建立一個HTTP伺服器。大多數的web應用都使用spring-boot-starter-web模組進行快速搭建和執行。

6.1. Spring Web MVC框架

Spring Web MVC框架（通常簡稱為"Spring MVC"）是一個富"模型，檢視，控制器"的web框架。 Spring MVC允許你建立特定的@Controller或@RestController beans來處理傳入的HTTP請求。 使用@RequestMapping註解可以將控制器中的方法對映到相應的HTTP請求。

示例：

@RestController
@RequestMapping(value="/users")
public class MyRestController {

    @RequestMapping(value="/{user}", method=RequestMethod.GET)
    public User getUser(@PathVariable Long user) {
        // ...
    }

    @RequestMapping(value="/{user}/customers", method=RequestMethod.GET)
    List<Customer> getUserCustomers(@PathVariable Long user) {
        // ...
    }

    @RequestMapping(value="/{user}", method=RequestMethod.DELETE)
    public User deleteUser(@PathVariable Long user) {
        // ...
    }
}

6.1.1. Spring MVC自動配置

Spring Boot為Spring MVC提供適用於多數應用的自動配置功能。在Spring預設基礎上，自動配置新增了以下特性：

引入ContentNegotiatingViewResolver和BeanNameViewResolver beans。
對靜態資源的支援，包括對WebJars的支援。
自動註冊Converter，GenericConverter，Formatter beans。
對HttpMessageConverters的支援。
自動註冊MessageCodeResolver。
對靜態index.html的支援。
對自定義Favicon的支援。

如果想全面控制Spring MVC，你可以新增自己的@Configuration，並使用@EnableWebMvc對其註解。如果想保留Spring Boot MVC的特性，並只是新增其他的MVC配置(攔截器，formatters，檢視控制器等)，你可以新增自己的WebMvcConfigurerAdapter型別的@Bean（不使用@EnableWebMvc註解）。

6.1.2. HttpMessageConverters

Spring MVC使用HttpMessageConverter介面轉換HTTP請求和響應。合理的預設值被包含的恰到好處（out of the box），例如物件可以自動轉換為JSON（使用Jackson庫）或XML（如果Jackson XML擴充套件可用則使用它，否則使用JAXB）。字串預設使用UTF-8編碼。

如果需要新增或自定義轉換器，你可以使用Spring Boot的HttpMessageConverters類：

import org.springframework.boot.autoconfigure.web.HttpMessageConverters;
import org.springframework.context.annotation.*;
import org.springframework.http.converter.*;

@Configuration
public class MyConfiguration {

    @Bean
    public HttpMessageConverters customConverters() {
        HttpMessageConverter<?> additional = ...
        HttpMessageConverter<?> another = ...
        return new HttpMessageConverters(additional, another);
    }
}

任何在上下文中出現的HttpMessageConverter bean將會新增到converters列表，你可以通過這種方式覆蓋預設的轉換器（converters）。

6.1.3. MessageCodesResolver

Spring MVC有一個策略，用於從繫結的errors產生用來渲染錯誤資訊的錯誤碼：MessageCodesResolver。如果設定spring.mvc.message-codes-resolver.format屬性為PREFIXERRORCODE或POSTFIXERRORCODE（具體檢視DefaultMessageCodesResolver.Format列舉值），Spring Boot會為你建立一個MessageCodesResolver。

6.1.4. 靜態內容

預設情況下，Spring Boot從classpath下一個叫/static（/public，/resources或/META-INF/resources）的資料夾或從ServletContext根目錄提供靜態內容。這使用了Spring MVC的ResourceHttpRequestHandler，所以你可以通過新增自己的WebMvcConfigurerAdapter並覆寫addResourceHandlers方法來改變這個行為（載入靜態檔案）。

在一個單獨的web應用中，容器預設的servlet是開啟的，如果Spring決定不處理某些請求，預設的servlet作為一個回退（降級）將從ServletContext根目錄載入內容。大多數時候，這不會發生（除非你修改預設的MVC配置），因為Spring總能夠通過DispatcherServlet處理請求。

此外，上述標準的靜態資源位置有個例外情況是Webjars內容。任何在/webjars/**路徑下的資源都將從jar檔案中提供，只要它們以Webjars的格式打包。

注：如果你的應用將被打包成jar，那就不要使用src/main/webapp資料夾。儘管該資料夾是一個共同的標準，但它僅在打包成war的情況下起作用，並且如果產生一個jar，多數構建工具都會靜悄悄的忽略它。

6.1.5. 模板引擎

正如REST web服務，你也可以使用Spring MVC提供動態HTML內容。Spring MVC支援各種各樣的模板技術，包括Velocity, FreeMarker和JSPs。很多其他的模板引擎也提供它們自己的Spring MVC整合。

Spring Boot為以下的模板引擎提供自動配置支援：

FreeMarker
Groovy
Thymeleaf
Velocity

注：如果可能的話，應該忽略JSPs，因為在內嵌的servlet容器使用它們時存在一些已知的限制。

當你使用這些引擎的任何一種，並採用預設的配置，你的模板將會從src/main/resources/templates目錄下自動載入。

注：IntelliJ IDEA根據你執行應用的方式會對classpath進行不同的整理。在IDE裡通過main方法執行你的應用跟從Maven或Gradle或打包好的jar中執行相比會導致不同的順序。這可能導致Spring Boot不能從classpath下成功地找到模板。如果遇到這個問題，你可以在IDE裡重新對classpath進行排序，將模組的類和資源放到第一位。或者，你可以配置模組的字首為classpath*:/templates/，這樣會查詢classpath下的所有模板目錄。

6.1.6. 錯誤處理

Spring Boot預設提供一個/error對映用來以合適的方式處理所有的錯誤，並且它在servlet容器中註冊了一個全域性的 錯誤頁面。對於機器客戶端（相對於瀏覽器而言，瀏覽器偏重於人的行為），它會產生一個具有詳細錯誤，HTTP狀態，異常資訊的JSON響應。對於瀏覽器客戶端，它會產生一個白色標籤樣式（whitelabel）的錯誤檢視，該檢視將以HTML格式顯示同樣的資料（可以新增一個解析為erro的View來自定義它）。為了完全替換預設的行為，你可以實現ErrorController，並註冊一個該型別的bean定義，或簡單地新增一個ErrorAttributes型別的bean以使用現存的機制，只是替換顯示的內容。

如果在某些條件下需要比較多的錯誤頁面，內嵌的servlet容器提供了一個統一的Java DSL（領域特定語言）來自定義錯誤處理。 示例：

@Bean
public EmbeddedServletContainerCustomizer containerCustomizer(){
    return new MyCustomizer();
}

// ...
private static class MyCustomizer implements EmbeddedServletContainerCustomizer {
    @Override
    public void customize(ConfigurableEmbeddedServletContainer container) {
        container.addErrorPages(new ErrorPage(HttpStatus.BAD_REQUEST, "/400"));
    }
}

你也可以使用常規的Spring MVC特性來處理錯誤，比如@ExceptionHandler方法和@ControllerAdvice。ErrorController將會撿起任何沒有處理的異常。

N.B. 如果你為一個路徑註冊一個ErrorPage，最終被一個過濾器（Filter）處理（對於一些非Spring web框架，像Jersey和Wicket這很常見），然後過濾器需要顯式註冊為一個ERROR分發器（dispatcher）。

@Bean
public FilterRegistrationBean myFilter() {
    FilterRegistrationBean registration = new FilterRegistrationBean();
    registration.setFilter(new MyFilter());
    ...
    registration.setDispatcherTypes(EnumSet.allOf(DispatcherType.class));
    return registration;
}

注：預設的FilterRegistrationBean沒有包含ERROR分發器型別。

6.1.7. Spring HATEOAS

如果你正在開發一個使用超媒體的RESTful API，Spring Boot將為Spring HATEOAS提供自動配置，這在多數應用中都工作良好。自動配置替換了對使用@EnableHypermediaSupport的需求，並註冊一定數量的beans來簡化構建基於超媒體的應用，這些beans包括一個LinkDiscoverer和配置好的用於將響應正確編排為想要的表示的ObjectMapper。ObjectMapper可以根據spring.jackson.*屬性或一個存在的Jackson2ObjectMapperBuilder bean進行自定義。

通過使用@EnableHypermediaSupport，你可以控制Spring HATEOAS的配置。注意這會禁用上述的對ObjectMapper的自定義。

6.2. JAX-RS和Jersey

如果喜歡JAX-RS為REST端點提供的程式設計模型，你可以使用可用的實現替代Spring MVC。如果在你的應用上下文中將Jersey 1.x和Apache Celtix的Servlet或Filter註冊為一個@Bean，那它們工作的相當好。Jersey 2.x有一些原生的Spring支援，所以我們會在Spring Boot為它提供自動配置支援，連同一個啟動器（starter）。

想要開始使用Jersey 2.x只需要加入spring-boot-starter-jersey依賴，然後你需要一個ResourceConfig型別的@Bean，用於註冊所有的端點（endpoints）。

@Component
public class JerseyConfig extends ResourceConfig {
    public JerseyConfig() {
        register(Endpoint.class);
    }
}

所有註冊的端點都應該被@Components和HTTP資源annotations（比如@GET）註解。

@Component
@Path("/hello")
public class Endpoint {
    @GET
    public String message() {
        return "Hello";
    }
}

由於Endpoint是一個Spring元件（@Component），所以它的生命週期受Spring管理，並且你可以使用@Autowired新增依賴及使用@Value注入外部配置。Jersey servlet將被註冊，並預設對映到/*。你可以將@ApplicationPath新增到ResourceConfig來改變該對映。

預設情況下，Jersey將在一個ServletRegistrationBean型別的@Bean中被設定成名稱為jerseyServletRegistration的Servlet。通過建立自己的相同名稱的bean，你可以禁止或覆蓋這個bean。你也可以通過設定spring.jersey.type=filter來使用一個Filter代替Servlet（在這種情況下，被覆蓋或替換的@Bean是jerseyFilterRegistration）。該servlet有@Order屬性，你可以通過spring.jersey.filter.order進行設定。不管是Servlet還是Filter註冊都可以使用spring.jersey.init.*定義一個屬性集合作為初始化引數傳遞過去。

這裡有一個Jersey示例，你可以檢視如何設定相關事項。

6.3. 內嵌servlet容器支援

Spring Boot支援內嵌的Tomcat, Jetty和Undertow伺服器。多數開發者只需要使用合適的'Starter POM'來獲取一個完全配置好的例項即可。預設情況下，內嵌的伺服器會在8080埠監聽HTTP請求。

6.3.1. Servlets和Filters

當使用內嵌的servlet容器時，你可以直接將servlet和filter註冊為Spring的beans。在配置期間，如果你想引用來自application.properties的值，這是非常方便的。預設情況下，如果上下文只包含單一的Servlet，那它將被對映到根路徑（/）。在多Servlet beans的情況下，bean的名稱將被用作路徑的字首。過濾器會被對映到/*。

如果基於約定（convention-based）的對映不夠靈活，你可以使用ServletRegistrationBean和FilterRegistrationBean類實現完全的控制。如果你的bean實現了ServletContextInitializer介面，也可以直接註冊它們。

6.3.2. EmbeddedWebApplicationContext

Spring Boot底層使用了一個新的ApplicationContext型別，用於對內嵌servlet容器的支援。EmbeddedWebApplicationContext是一個特殊型別的WebApplicationContext，它通過搜尋一個單一的EmbeddedServletContainerFactory bean來啟動自己。通常，TomcatEmbeddedServletContainerFactory，JettyEmbeddedServletContainerFactory或UndertowEmbeddedServletContainerFactory將被自動配置。

注：你通常不需要知道這些實現類。大多數應用將被自動配置，並根據你的行為建立合適的ApplicationContext和EmbeddedServletContainerFactory。

6.3.3. 自定義內嵌servlet容器

常見的Servlet容器設定可以通過Spring Environment屬性進行配置。通常，你會把這些屬性定義到application.properties檔案中。 常見的伺服器設定包括：

server.port - 進來的HTTP請求的監聽埠號
server.address - 繫結的介面地址
server.sessionTimeout - session超時時間

具體參考ServerProperties。

程式設計方式的自定義 如果需要以程式設計的方式配置內嵌的servlet容器，你可以註冊一個實現EmbeddedServletContainerCustomizer介面的Spring bean。EmbeddedServletContainerCustomizer提供對ConfigurableEmbeddedServletContainer的訪問，ConfigurableEmbeddedServletContainer包含很多自定義的setter方法。

import org.springframework.boot.context.embedded.*;
import org.springframework.stereotype.Component;

@Component
public class CustomizationBean implements EmbeddedServletContainerCustomizer {
    @Override
    public void customize(ConfigurableEmbeddedServletContainer container) {
        container.setPort(9000);
    }
}

直接自定義ConfigurableEmbeddedServletContainer 如果上面的自定義手法過於受限，你可以自己註冊TomcatEmbeddedServletContainerFactory，JettyEmbeddedServletContainerFactory或UndertowEmbeddedServletContainerFactory。

@Bean
public EmbeddedServletContainerFactory servletContainer() {
    TomcatEmbeddedServletContainerFactory factory = new TomcatEmbeddedServletContainerFactory();
    factory.setPort(9000);
    factory.setSessionTimeout(10, TimeUnit.MINUTES);
    factory.addErrorPages(new ErrorPage(HttpStatus.NOT_FOUND, "/notfound.html");
    return factory;
}

很多可選的配置都提供了setter方法，也提供了一些受保護的鉤子方法以滿足你的某些特殊需求。具體參考相關文件。

6.3.4. JSP的限制

在內嵌的servlet容器中執行一個Spring Boot應用時（並打包成一個可執行的存檔archive），容器對JSP的支援有一些限制。

tomcat只支援war的打包方式，不支援可執行的jar。
內嵌的Jetty目前不支援JSPs。
Undertow不支援JSPs。

這裡有個JSP示例，你可以檢視如何設定相關事項。