2.1 Spring Boot簡介
Spring Boot是由Pivotal團隊提供的基於Spring的全新框架，其設計目的是簡化Spring應用的搭建和開發過程。該框架遵循“約定大於配置”原則，採用特定的方式進行配置，從而使開發者無須進行大量的XML配置。Spring Boot致力於成爲蓬勃發展的快速應用開發領域的領導者。
Spring Boot並不重複“造輪子”，而是在原有Spring框架的基礎上進行封裝，並且它集成了一些類庫，用於簡化開發。換句話說，Spring Boot就是一個大容器。
關於Spring Boot，其官網是這樣描述的：
Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run”.
We take an opinionated view of the Spring platform and third-party libraries so you can get started with minimum fuss. Most Spring Boot applications need very little Spring configuration.
從上面的描述中，我們可以瞭解到，Spring Boot帶給了我們全新的應用部署方案，通過它可以很方便地創建獨立的、生產級的基於Spring的應用程序。同時，通過Spring平臺和第三方庫可以輕鬆構建視圖。
其實，Spring Boot默認集成了Tomcat，因此我們可以只編譯成jar包，通過Java命令啓動應用，大多數Spring Boot應用程序只需要很少的Spring配置。
2.2 第一個Spring Boot工程
本節中，我們將創建第一個Spring Boot工程，讀者可以按照下面的步驟進行操作。
(1) 打開IntelliJ IDEA，依次點擊File→New→Module，在彈出的對話框中選擇Maven，並點擊Next按鈕，創建一個Maven項目。這裏我們在ArtifactId一欄中輸入demo-lesson-one，在GroupId一欄中輸入com.lynn.boot。創建好工程後，爲pom.xml增加以下內容：
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.3.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
其中，標籤聲明瞭Spring Boot的父項目，版本號定義爲2.0.3.RELEASE。我們還可以注意到，標籤中聲明瞭spring-boot-starter-web依賴，它提供了對Spring MVC的支持。
(2) 編寫應用啓動類Application：
package com.lynn.boot;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class,args);
}
}
Spring Boot的強大之處在於可以直接通過main方法啓動Web應用程序。在上述代碼中，我們提供了應用程序的入口，通過調用SpringApplication.run()來啓動內置Web容器。我們注意到，在Application類中添加了@SpringBootApplication註解，我們將在2.4節中介紹它的作用。
默認情況下，Spring Boot內置了Tomcat。當然，它還支持其他容器，如Jetty。倘若我們要將默認容器改爲Jetty，可以將pom.xml文件修改成下面這樣：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jetty</artifactId>
</dependency>
在上述代碼中，我們通過標籤將Tomcat的依賴包移除，並增加了Jetty的依賴包。
(3) 編寫控制器以驗證Spring Boot框架：
package com.lynn.boot.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
@RequestMapping(value = "hello")
public String hello(){
return "Hello World!";
}
}
在上述代碼中，@RestController註解指示了該類爲控制器類，與它對應的註解是 @Controller。@RestController註解相當於 @Controller註解和@ResponseBody註解的結合。@RequestMapping註解的作用是定義一個HTTP請求地址，默認不限制請求方式，可以是GET、POST亦或其他方法，如果要限制請求方法，可以在註解後面增加method屬性，如method=RequestMethod.GET表示只有GET請求才能調用該HTTP地址。
上面提到的註解均爲Spring MVC註解，我們之所以能夠在這裏很方便地使用Spring MVC註解，是因爲第(1)步的依賴中添加了spring-boot-starter-web依賴，該依賴集成了Spring MVC。
(4) 運行Application類的main方法，並訪問localhost:8080/hello，即可看到如圖2-1所示的界面。
通過以上示例，我們可以知道：
使用Spring Boot創建一個工程非常簡單，既沒有XML配置文件，也沒有Tomcat，通過幾個簡單的註解，運行main方法就能啓動一個Web應用；
Spring Boot默認內置Tomcat；
Spring Boot用註解代替了煩瑣的XML配置。
2.3 使用YAML文件配置屬性
在上一節中，我們實現了一個最簡單的Web工程，沒有創建任何配置文件。當然，Spring Boot的任何配置都可以通過代碼實現。爲了便於擴展，它引入了PROPERTIES格式和YAML格式 ①的文件，可以在其中定義一些常用屬性或自定義屬性。
2.3.1 YAML的基本用法
下面我們先來看一下Spring Boot的一般配置，步驟如下。
(1) 在src/main/resources目錄下創建一個名爲application.yml的配置文件，並編寫以下內容：
server:
servlet:
#定義上下文路徑
context-path: /demo
#定義工程啓動的端口
port: 8081在上述配置中，我們通過server.servlet.context-path定義了應用的上下文路徑爲/demo，它的默認值爲/，server.port定義應用的啓動端口，其默認值爲8080，這裏設置爲8081。
(2) 啓動工程並訪問localhost:8081/demo/hello，就可以看到如圖2-1所示的界面。
① 本書的所有示例都使用了YAML 栺式的配置文件。在2.2節中，我們啓動工程時的監聽端口爲8080，上下文路徑爲/，但是我們並沒有配置任何信息，那是因爲所有配置屬性都有默認值，如端口的默認值爲8080。
接下來，我們看一下YAML文件的結構，其基本格式爲：
key1:
key2:
key3: value我們將它替換成properties的形式，即key1.key2.key3=value。當然，key的個數不是固定的。這裏需要說明的是，YAML格式非常嚴格。如果當前key後面需要跟value，則冒號後面必須至少有一個空格，否則編譯不會通過；其次，每個子屬性之間需要通過空格或製表符（即按下Tab鍵）分隔，否則可能無法正確取到屬性值。
如果我們將上面例子中的YAML文件改成以下形式：
server:
servlet:
context-path: /demo
#冒號後面直接跟端口號
port:8081那麼啓動工程後，控制檯會打印如下的報錯信息：
Caused by: org.yaml.snakeyaml.scanner.ScannerException: while scanning a simple key in 'reader', line 6, column 3:
port:8081
^
could not find expected ':'
in 'reader', line 6, column 12:
port:80812.3.2 多環境配置
在一個企業級應用中，我們可能開發時使用開發環境，測試時使用測試環境，上線時使用生產環境。每個環境的配置都不一樣，比如開發環境的數據庫是本地地址，而測試環境的數據庫是測試地址。因此會遇到這樣一個問題：我們在打包的時候，如何生成不同環境的包呢？
這裏的解決方案有很多，具體如下。
每次編譯之前，手動把所有配置信息修改成當前運行的環境信息。這種方式導致每次都需要修改，相當麻煩，也容易出錯。
利用Maven，在pom.xml裏配置多個環境，每次編譯之前將settings.xml修改成當前要編譯的環境ID。這種方式的缺點就是每次都需要手動指定環境，而且如果環境指定錯誤，發佈前是不知道的。
創建多個針對不同環境的配置文件，通過啓動命令指定。這個方案就是本節重點介紹的，也是我強烈推薦的方式。
接下來，我們看一下配置多環境的步驟。
(1) 將application.yml文件修改如下：
server:
servlet:
context-path: /demo
port: 8081
spring:
profiles:
active: dev這裏通過spring.profiles.active指了明當前啓動的環境。
(2) 創建多環境配置文件，文件命名格式爲application-{profile}.yml，其中{profile}即爲上述配置將要指定的環境名，如新增名爲application-dev.yml的文件，我們可以在裏面添加配置：
server:
port: 8080並將spring.profiles.active設置爲dev。
此時啓動工程，可以看到工程的監聽端口已變爲8080。
你可以繼續創建多環境文件，比如命名爲application-test.yml，將監聽端口改爲8082，然後將spring.profiles.active改爲test，再啓動工程觀察效果。在實際項目發佈的過程中，不會手動修改spring.profiles.active的值，而是通過啓動命令來動態修改，具體細節見2.7節。
2.4 常用註解
前面提到過，Spring Boot主要是以註解形式代替煩瑣的XML配置。在這一節中，我將帶領大家瞭解一些常用註解的用法。
2.4.1 @SpringBootApplication
在前面的章節中，讀者是否注意到，Spring Boot支持main方法啓動。在我們需要啓動的主類中加入註解 @SpringBootApplication，就可以告訴Spring Boot這個類是工程的入口。如果不加這個註解，啓動就會報錯。讀者可以嘗試去掉該註解，看一下效果。
查看 @SpringBootApplication註解的源碼，可以發現該註解由 @SpringBootConfiguration、@EnableAutoConfiguration和 @ComponentScan組成。我們可以將 @SpringBootApplication替換爲以上3個註解，如：
package com.lynn.boot;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class,args);
}
}
此時代碼的運行效果與2.2節一致。
2.4.2 @SpringBootConfiguration
加入了 @SpringBootConfiguration註解的類會被認爲是Spring Boot的配置類。我們既可以在application.yml中進行一些配置，也可以通過代碼進行配置。
如果要通過代碼進行配置，就必須在這個類中添加 @SpringBootConfiguration註解。我們既可以在標註了這個註解的類中定義Bean，也可以通過它用代碼動態改變application.yml的一些配置。例如，創建WebConfig類，並改變工程啓動的端口號：
package com.lynn.boot;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.boot.web.servlet.server.ConfigurableServletWebServerFactory;
@SpringBootConfiguration
public class WebConfig implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {
@Override
public void customize(ConfigurableServletWebServerFactory factory) {
//給代碼設置應用啓動端口
factory.setPort(8888);
}
}
啓動工程，可以看到監聽端口已經變成了8888。
說明：如果YAML配置文件和代碼配置了同樣的屬性，則會以代碼配置爲準。因爲在Spring Boot應用啓動後，會先加載配置文件，然後再執行被 @SpringBootConfiguration標註的類，所以它會覆蓋配置文件配置的屬性。
此外，也可以使用 @Configuration註解，它和 @SpringBootConfiguration的效果一樣，不過Spring Boot官方推薦採用 @SpringBootConfiguration註解。
2.4.3 @Bean
@Bean註解是方法級別的註解，主要添加在 @SpringBootConfiguration註解的類中，有時也添加在 @Component註解的類中。它的作用是定義一個Bean，類似於Spring XML配置文件的。
下面我們就來看一下如何通過 @Bean註解注入一個普通類。
(1) 創建一個普通類Person，爲了便於測試，我們爲該類增加了一個字段name：
package com.lynn.boot.bean;
public class Person {
private String name;
public void setName(String name){
this.name = name;
}
public String getName() {
return name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
}
(2) 在2.4.2節創建的WebConfig類中增加以下代碼：
@Bean
public Person person(){
Person person = new Person();
person.setName("lynn");
return person;
}在上述代碼中，我們通過一個 @Bean註解就可以將Person對象加入Spring容器中，它簡化了傳統的Spring XML的方式。
(3) 進行單元測試。首先，添加單元測試依賴：
org.springframework.boot
spring-boot-starter-test
test
Spring Boot默認集成JUnit測試框架，通過添加spring-boot-starter-test依賴就可以集成它。然後在src/main/test目錄下創建一個測試類，並編寫測試代碼：
package com.lynn.boot.test;
import com.lynn.boot.Application;
import com.lynn.boot.bean.Person;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@SpringBootTest(classes = Application.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class MyTest {
@Autowired
private Person person;
@Test
public void test(){
System.out.println(person);
}
}
在上述代碼中，我們添加 @SpringBootTest註解來指定入口類爲Application，再添加 @RunWith註解指定單元測試的運行環境爲SpringJUnit4ClassRunner，即使用JUnit4的單元測試框架，接着通過 @Autowired註解注入了Person類，最後通過test方法打印person信息。
注意：在test方法中需要添加 @Test註解才能啓用單元測試。
啓動單元測試時，可以看到控制檯打印出了以下信息：
Person{name='lynn'}2.4.4 @Value
通常情況下，我們需要定義一些全局變量，此時想到的方法是定義一個public static常量並在需要時調用它。那麼是否有其他更好的方案呢？答案是肯定的，這就是本節要講的 @Value註解。
(1) 在application.yml裏自定義一個屬性data：
self:
message:
data: 這是我自定義的屬性上述配置不是Spring Boot內置屬性，而是我們自定義的屬性。
(2) 修改HelloController類：
package com.lynn.boot.controller;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
@Value("${self.message.data}")
private String value;
@RequestMapping(value = "hello",produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
public String hello(){
return value;
}
}
其中，@Value註解的參數需要使用 ${} 將目標屬性包裝起來，該屬性既可以是Spring內置的屬性，也可以是自定義的屬性。
注意：如果返回的是String類型的值，那麼需要註明produces爲application/json並且charset=utf8，否則可能會出現亂碼；如果返回的是對象，則無須註明。因爲Spring MVC不會對返回的String類型的值做任何處理，而如果返回對象的話，會執行Spring默認的JSON轉換器，它會處理編碼問題。
(3) 啓動工程並訪問localhost:8080/demo/hello，可以看到如圖2-2所示的界面。
說明：@Value註解可以獲取YAML文件的任何屬性值，它的好處如下：
可以通過啓動參數動態改變屬性值，而不用修改代碼；
交給Spring統一管理常量，便於擴展和維護。
2.5 Spring Boot集成模板引擎
在傳統的Spring MVC架構中，我們一般將JSP、HTML頁面放到webapps目錄下。但Spring Boot沒有webapps，更沒有web.xml，如果要寫界面的話，該如何做呢？
我們可以集成模板引擎。Spring Boot官方提供了幾種模板引擎：FreeMarker、Velocity、Thymeleaf、Groovy、Mustache和JSP。本節中，我們以FreeMarker爲例講解Spring Boot是如何集成模板引擎的。
首先，在pom.xml中添加對FreeMarker的依賴：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>在resources目錄下建立static和templates兩個目錄，如圖2-3所示。其中static目錄用於存放靜態資源，譬如CSS、JavaScript和HTML等，templates目錄用於存放模板引擎文件。
然後在templates目錄下面創建index.ftl ①文件，並添加如下內容：
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<h1>Hello World!</h1>
</body>
</html>接着創建控制器類：
@Controller
public class PageController {
@RequestMapping("index.html")
public String index(){
return "index";
}
}
① freemarker 文件的默認後綴爲.ftl。最後，啓動Application.java，訪問localhost:8080/demo/index.html，就可以看到如圖2-4所示的界面。
在上述代碼中，我們要返回FreeMarker模板頁面，因此必須將其定義爲 @Controller，而不是前面定義的 @RestController。@RestController相當於 @Controller和 @ResponseBody的結合體。標註爲 @RestController註解時，SpringMVC的視圖解析器（ViewResolver）將不起作用，即無法返回HTML或JSP頁面。ViewResolver的主要作用是把一個邏輯上的視圖名解析爲一個真正的視圖。當我們將一個控制器標註爲 @Controller並返回一個視圖名時，ViewResolver會通過該視圖名找到實際的視圖，並呈現給客戶端。
2.6 更改默認的JSON轉換器
Spring Boot默認使用Jackson引擎去解析控制器返回的對象，該引擎在性能和便捷性上與第三方引擎（FastJson和Gson等）還有一定的差距，本節將介紹如何將默認轉換器替換爲FastJson轉換器。
(1) 在pom.xml中添加對FastJson的依賴：
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency>(2) 修改WebConfig類，爲其添加方法並設置FastJson轉換器：
@SpringBootConfiguration
public class WebConfig extends WebMvcConfigurationSupport{
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
super.configureMessageConverters(converters);
FastJsonHttpMessageConverter fastConverter=new FastJsonHttpMessageConverter();
FastJsonConfig fastJsonConfig=new FastJsonConfig();
fastJsonConfig.setSerializerFeatures(
SerializerFeature.PrettyFormat
);
List<MediaType> mediaTypeList = new ArrayList<>();
//設置編碼爲UTF-8
mediaTypeList.add(MediaType.APPLICATION_JSON_UTF8);
fastConverter.setSupportedMediaTypes(mediaTypeList);
fastConverter.setFastJsonConfig(fastJsonConfig);
converters.add(fastConverter);
}
}首先應繼承WebMvcConfigurationSupport類，該類提供了Spring Boot對Spring MVC的支持。然後重寫configureMessageConverters方法，該方法配置了消息轉換器。如果第三方框架希望處理Spring MVC中的請求和響應時，那麼需要實現HttpMessageConverter接口。而在上述代碼中，FastJsonHttpMessageConverter便是如此，它實現了HttpMessageConverter接口，並通過FastJsonConfig設置FastJson的處理參數，如通過MediaType設置編碼爲UTF-8，最後添加到HttpMessageConverter中。
這樣Spring MVC在處理響應時就可以將JSON解析引擎替換爲FastJson。
說明：前面提到，如果控制器返回的是String類型的值，則需要顯式設置編碼。我們替換成FastJson後，由於已經設置了編碼，所以無論是字符串還是對象，都無須設置編碼方式，讀者可以試一試。
2.7 打包發佈到服務器上
Spring Boot支持使用jar和war兩種方式啓動應用，下面分別來介紹這兩種方式是怎麼啓動的。
2.7.1 使用內置Tomcat發佈jar包
由於Spring Boot內置了Tomcat，我們可以將工程打包成jar，通過Java命令運行我們的Web工程，具體步驟如下。
(1) 在pom.xml文件中添加以下內容：
<build>
<finalName>api</finalName>
<resources>
<resource>
<directory>src/main/resources</directory>
<filtering>true</filtering>
</resource>
</resources>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<fork>true</fork>
<mainClass>com.lynn.boot.Application</mainClass>
</configuration>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>2.5</version>
<configuration>
<encoding>UTF-8</encoding>
<useDefaultDelimiters>true</useDefaultDelimiters>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.18.1</version>
<configuration>
<skipTests>true</skipTests>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.3.2</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>在pom.xml中，<build>標籤定義了關於Maven編譯和打包的一些信息。其中，<finalName>爲打包後的文件名，<plugins>設置了編譯的一些參數。Maven支持第三方插件，而Spring Boot的編譯插件就是spring-boot-maven-plugin，並通過<mainClass>指定了啓動類。後面maven-surefire-plugin就是Maven官方提供的用於構建測試用例的插件，如果有單元測試類，它在編譯完成後會執行單元測試，單元測試成功後纔會打包；如果不希望執行單元測試，那麼將<skipTests>設置爲true即可。我建議將設置爲true，如果設置爲false，會導致打包時間過長。如果單元測試類中存在對數據庫的增刪改測試，編譯時執行了它，可能會對原有數據造成影響。maven-compiler-plugin爲Maven官方提供的指定編譯器版本的插件，上述代碼中的1.8表示使用JDK 1.8版本編譯。
(2) 通過mvn clean package編譯並打包，如圖2-5所示。
(3) 將打包的內容上傳到服務器中，運行命令：
java -jar api.jar這樣就能啓動一個Spring Boot應用。前面提到，可以通過命令參數來設置不同環境或者動態設置參數，那麼如何設置呢？下面以設置環境爲例，輸入命令：
java -jar api.jar --spring.profiles.active=dev應用啓動時，就會拉取application-dev.yml內的配置信息。如果你想改變任何屬性值，在--後面加上相應的屬性名和要改變的屬性值即可。
2.7.2 打包成war包發佈
除了編譯成jar包發佈外，Spring Boot也支持編譯成war包部署到Tomcat。
(1) 在pom.xml中將應用打包格式改成war：
<packaging>war</packaging>這裏的就是告訴Maven，需要編譯成何種後綴的文件。
(2) 將標籤下的內容修改如下：
<build>
<finalName>api</finalName>
<resources>
<resource>
<directory>src/main/resources</directory>
<filtering>true</filtering>
</resource>
</resources>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>2.5</version>
<configuration>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.18.1</version>
<configuration>
<skipTests>true</skipTests>
</configuration>
</plugin>
</plugins>
</build>上述內容和2.7.1節中的內容相似，增加了maven-resources-plugin插件，它用於編譯resources目錄下的文件。而在spring-boot-maven-plugin插件中無須指定<mainClass>，因爲編譯後的war部署在外部Tomact上，它依託於Tomcat容器運行，不會執行main方法。
(3) 添加Tomcat依賴，將<scope>設置爲provided。這樣做的目的是編譯時去掉tomcat包，否則啓動時可能會報錯。我們也不能直接通過<exclusion>標籤去掉tomcat包，因爲在本地開發時，需要通過Application類啓動。相關代碼如下：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>(4) 修改啓動類Application，它繼承了SpringBootServletInitializer類，並重寫了configure方法，以便Tomcat在啓動時能加載Spring Boot應用：
@SpringBootApplication
public class Application extends SpringBootServletInitializer {
public static void main(String[] args) {
SpringApplication.run(Application.class,args);
}
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(Application.class);
}
}
在上述代碼中，如果我們是通過外部Tomcat啓動應用，則可以去掉main方法。因爲Tomcat在啓動時會執行configure方法，而configure方法會調用source方法並指定Application類，其作用與main方法一致。
(5) 使用mvn clean package編譯並打包成WAR格式的文件，然後將其複製到Tomcat中。啓動Tomcat，可以看到應用能夠被正常訪問。如果通過外部Tomcat啓動應用，則server.port指定的端口失效，轉而使用Tomcat設置的端口號。
通過war啓動程序無法像jar包那樣，在啓動時指定運行環境或其他想要動態改變的參數值，且上下文路徑以war包的名字爲準，還需要自己安裝Tomcat，比較麻煩，因此我推薦優先考慮jar包的啓動方式。
注意：如果以war方式部署多個Spring Boot工程到一個Tomcat下，可能會報錯，其原因是Spring Boot的資源管理是默認打開的，而兩個項目同時使用會衝突。此時需要在每個項目中增加以下配置：
spring:
jvm:
default-domain: api其中，在default-domain後面需要設置domain名，以保證每個工程的domain不一致，這樣才能同時啓動多個工程。
2.8 WebFlux快速入門
Spring Boot 2.0爲我們帶來了WebFlux，它採用Reactor作爲首選的流式框架，並且提供了對RxJava的支持。通過WebFlux，我們可以建立一個異步的、非阻塞的應用程序。接下來，我們就一起來領略WebFlux的風采。
(1) 創建一個基於Spring Boot的Maven工程，將其命名爲demo-lesson-one-webflux，然後在pom.xml文件中添加對WebFlux的依賴：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>(2) 編寫一個Handler，用於包裝數據：
@Component
public class HelloHandler {
public Mono<ServerResponse> hello(ServerRequest request) {
return ServerResponse.ok().contentType(MediaType.TEXT_PLAIN)
.body(BodyInserters.fromObject("Hello, World!"));
}
}
該類自定義了一個方法，該方法返回Mono ①對象。這裏在ServerResponse的body方法中設置要返回的數據。
(3) 編寫接口類，即定義我們通常所說的路由地址（接口地址）：
@SpringBootConfiguration
public class HelloRouter {
@Bean
public RouterFunction<ServerResponse> routeHello(HelloHandler helloHandler) {
return RouterFunctions.route(RequestPredicates.GET("/hello")
.and(RequestPredicates.accept(MediaType.TEXT_PLAIN)), helloHandler::hello);
}
}① Mono 是WebFlux 中屬於publisher（収布者）的類。在WebFlux 中，開収者的方法只需返回Mono 或Flux 類即可。因爲路由需要註冊到Spring容器中，所以該類也需要添加 @SpringBootConfiguration註解，而將返回的路由標識爲一個Bean，這樣才能註冊到Spring容器中。
在上述代碼中，我們定義一個方法routeHello並且返回了RouterFunction對象。在RouterFunction中，指定路由地址爲/hello，並指定Handler和對應的方法，即前面創建的HelloHandler。這樣通過路由地址/hello就可以返回Handler的hello方法所設置的數據。
(4) 啓動Application.java並訪問地址localhost:8080/hello，可以看到瀏覽器正常顯示HelloWorld。
通過控制檯，我們可以很清楚地看到它是通過NettyServer① 啓動的：
Netty started on port(s): 8080這樣我們就建立了一個路由地址。細心的讀者可以發現，上述代碼過於煩瑣，Spring Boot也考慮到了這一點。爲了便於將MVC應用遷移到WebFlux，Spring Boot官方兼容了WebFlux和MVC，即我們可以使用MVC的註解來創建WebFlux的路由地址。
(1) 創建HelloController類並編寫以下代碼：
@RestController
public class HelloController {
@RequestMapping(value = "hello")
public Mono<String> hello(){
return Mono.just("Hello World!");
}
}可以看到，上述代碼和前面編寫的代碼很相似，只是這裏我們需要返回Mono對象，WebFlux將數據都包裝到Mono返回，通過調用just方法即可。just方法傳入的參數類型取決於Mono後面的泛型指定的類型。
(2) 啓動Application.java，我們可以得到和前面代碼一樣的結果。
說明：如果我們通過 @Controller和 @Router兩種方式定義了相同名字的路由地址，則會優先採用@Router方式。
① Netty 是一個異步的、事件驅動的網絡應用程序框架。2.9 小結
通過本章的學習，我們瞭解了Spring Boot的基本用法並感受到了YAML的優雅。本章涵蓋了一些實際項目中可能會用到的知識點，如常用註解、Spring Boot默認引擎的集成、JSON轉換器的更改以及編譯部署應用等。最後還介紹了目前較爲流行的WebFlux框架。在後面的內容中，我們將進一步學習Spring Boot的其他特性。
本文摘自《Spring Cloud實戰演練》
