SpringBoot筆記一

時間  2019-11-08
標籤 springboot 筆記 欄目 Spring 简体版
原文   原文鏈接

1 開始

1.1 spring介紹

Spring Boot使開發獨立的，產品級別的基於Spring的應用變得很是簡單，你只需"just run"。 咱們爲Spring平臺及第三方庫提供開箱即用的設置，這樣你就能夠有條不紊地開始。多數Spring Boot應用須要不多的Spring配置。html

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

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+）。web

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+的容器。spring

1.3 第一個spring boot應用

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

$ 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依賴：apache

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的一個很好候選。

一、導入其餘配置類

你不須要將全部的@Configuration放進一個單獨的類。@Import註解能夠用來導入其餘配置類。另外，你也可使用@ComponentScan註解自動收集全部的Spring組件，包括@Configuration類。

二、導入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示例，你能夠查看如何設置相關事項。

 

http://blog.csdn.net/jsyxcjw/article/details/46763639

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程