當前位置：首頁 > 前端技术 > javascript >内容正文

javascript

Spring-boot（一）

發布時間：2023/12/10 javascript 50 豆豆

生活随笔收集整理的這篇文章主要介紹了 Spring-boot（一）小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

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><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為：

<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><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屬性：

** 使用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注解。

下面是一個典型的結構：

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;@Autowiredpublic 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-SNAPSHOT2013-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.comname: Developer Setupprod:url: http://foo.bar.comname: 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: adminremoteAddress: 192.168.1.1 # additional configuration as required

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

@Service public class MyService {@Autowiredprivate ConnectionSettings connection;//...@PostConstructpublic 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 {@NotNullprivate 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 {@Beanpublic 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 {@Overridepublic 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 {@GETpublic 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 {@Overridepublic 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示例，你可以查看如何設置相關事項。

轉載于:https://www.cnblogs.com/HHR-SUN/p/7084932.html

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的Spring-boot（一）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

Spring
Boot

上一篇：用JavaSocket编程开发聊天室，附
下一篇： 10.1.2 Document类型【Ja