精通Springboot

目  錄

1       開篇詞：爲何要學 Spring Boot. 1

1.1        Spring Boot 2.0 課程... 2

1.2        Spring Boot 介紹... 3

1.3        Spring Boot 市場熱度... 5

1.4        Spring Boot 和微服務架構... 6

1.5        爲何學習 Spring Boot ？... 7

1.6        總結... 8

2       第1-1課：Spring Boot 產生的背景和它的設計理念... 9

2.1        Spring 的發展史... 9

2.2        Spring Boot 的誕生... 11

2.3        Spring Boot 開發團隊... 12

2.4        Spring Boot 的核心：約定優於配置... 15

2.5        Starters. 16

2.6        Spring、Spring Boot 和 Spring Cloud 的關係... 19

2.7        總結... 20

3       第1-2課：Spring Boot 2.0 都更新了什麼（上）... 20

3.1        基礎環境升級... 21

3.1.1         最低 JDK 8，支持 JDK 9，再也不支持 Java 6 和 7. 21

3.1.2         依賴組件升級... 21

3.2        默認軟件替換和優化... 22

3.2.1         HikariCP. 22

3.2.2         Security. 23

3.2.3         OAuth 2.0. 23

3.2.4         Micrometer 24

3.2.5         Redis 默認使用 Lettuce. 24

3.2.6         配置屬性綁定... 25

3.2.7         Actuator 改進... 26

3.2.8         測試... 26

3.2.9         其餘... 27

3.3        新技術的引入... 27

3.3.1         支持 HTTP/2. 27

3.3.2         嵌入式 Netty 服務器... 28

3.3.3         Kotlin的支持... 28

3.3.4         JOOQ 的支持... 29

3.3.5         支持 Quartz. 29

3.3.6         響應式編程... 29

4       第1-2課：Spring Boot 2.0 都更新了什麼（下）... 31

4.1.1         彩蛋... 31

4.2        1.0 升級 2.0 API 變化... 31

4.2.1         啓動類 SpringBootServletInitializer 31

4.2.2         Thymeleaf 3.0 默認不包含佈局模塊... 33

4.2.3         配置文件... 33

4.2.4         WebMvcConfigurerAdapter 過時... 34

4.2.5         Spring Boot JPA 變化... 34

4.3        是否選擇升級... 37

4.4        總結... 37

5       第1-3課：Spring Boot 依賴環境和項目結構介紹... 38

5.1        安裝 JDK. 40

5.1.1         下載安裝... 40

5.1.2         環境變量配置... 40

5.1.3         測試... 42

5.2        安裝 Maven. 42

5.2.1         下載安裝... 43

5.2.2         環境變量配置... 43

5.2.3         測試... 44

5.2.4         settings.xml 設置... 45

5.3        IntelliJ IDEA 安裝... 46

5.3.1         下載... 46

5.3.2         安裝... 46

5.3.3         配置... 47

5.4        構建項目... 48

5.5        項目結構介紹... 50

5.6        Pom 包介紹... 52

5.7        總結... 56

 

 

 

1    開篇詞：爲何要學 Spring Boot

你們好，我是純潔的微笑，從 2013 年到如今，我一直從業於第三方支付和互聯網金融這兩個領域。在互聯網金融公司工做期間，從零參與了公司技術平臺建設，隨着公司業務不斷髮展，組織技術團隊對平臺進行過四次大架構升級，從最初單體架構發展到最後的微服務架構，我也從一個一線開發人員成長爲互聯網金融公司的技術負責人。

2016 年，也就是構建第四代平臺架構的時候，我在技術調研時瞭解到了 Spring Boot，初步嘗試使用後，被其簡潔快速開發的魅力所吸引，隨即推廣到公司全部項目中。爲了促進學習，我在網絡上連載了 Spring Boot 的系列文章，意外獲得廣大網友的承認，早期的文章能夠在個人我的公衆號或者博客查看：

• 個人公衆號
• 個人博客

2017 年我又從互聯網金融迴歸到第三方支付行業，當時公司正在構建新一代的支付平臺，技術棧和互金的第四代平臺同樣，採用的 Spring Boot + Spring Cloud 相關生態，有所不一樣的是支付行業所面臨的業務更加複雜，交易規模更爲龐大。在互聯網金融公司中第四代平臺大概有二十多個微服務支撐平臺，如今公司的新一代支付系統微服務項目六十多個，每一個服務部署三個實例就高達一百多個；在互金行業只有在搶標的時候有大量的流量，一年交易2、三十億，如今我就任的支付公司天天交易量就高達4、五十億，對系統的穩定性和性能要求更高。

回到第三方支付行業後，我開始負責公司新一代平臺的微服務架構實踐，以及微服務架構下大數據平臺建設。通過兩家公司對 Spring Boot 的使用，我愈加認識到 Spring Boot 對傳統開發帶來的挑戰，Spring Cloud 將來可能會隨着 Kubernetes 和 Service Mesh 的發展有所弱化，可是 Spring Boot 給開發帶來的影響是深遠的。恰逢今年 Spring Boot 2.0 的推出，能夠預見的是將來的發展會愈來愈好。

1.1   Spring Boot 2.0 課程

Spring Boot 2.0 的推出又激起了一陣學習 Spring Boot 的熱潮，單從我我的博客訪問量大幅增長，就能夠感覺到你們對學習 Spring Boot 的熱情。

去年 11 月，我在 GitChat 平臺上發佈的達人課《快速學習 Spring Boot 技術棧》已經累計銷售了 2400 餘份，目前還在不斷的增加中，說明行業內對學習 Spring Boot 的需求在不斷地上漲。

去年在寫 Spring Boot 課程時版本仍是 1.5.8，在今年的 3 月，Spring 官方發佈了 Spring Boot 2.0，其在 1.0 的基礎上進行了大幅優化，2.0 集成了不少優秀的技術和新特性，對性能的提高很是明顯。

Spring Boot 2.0 升級的同時也在 1.0 的基礎上大量優化了 API 的使用，不少 1.0 的 API 在 2.0 版本中已經不適用，在 2.0 版本中使用以前的 API 操做每每會報錯，我也收到了大量相似的留言。結合這些反饋信息，本課程會參考以上內容的基礎上徹底從新設計，課程的變更點以下：

• 2.0 的課程將包含 1.0 的課程，而且會對 1.0 的課程內容進行升級，Spring Boot 使用的版本升級爲 2.X。
• 1.0 只是將當時最經常使用的實戰功能進行了提煉，2.0 課程將會系統性介紹 Spring Boot 各類使用場景。
• 課程內容和技術棧都會使用最新穩定版本，課程數量也由以前的 16 課擴充爲如今的 42 課，至關於寫了一本 Spring Boot 的系統圖書。

經過此課程的學習，相信你會徹底掌握 Spring Boot 2.0 的使用。下面咱們先來了解一下什麼是 Spring Boot ?

《精通 Spring Boot 42 講》。

1.2   Spring Boot 介紹

Spring Boot 是由 Pivotal 團隊提供的全新框架，其設計目的是用來簡化新 Spring 應用的初始搭建以及開發過程，該框架使用了特定的方式來進行配置，從而使開發人員再也不須要定義樣板化的配置。Spring Boot 默認配置了不少框架的使用方式，就像 Maven 整合了全部的 Jar 包，Spring Boot 整合了全部的框架。它的核心設計思想是：約定優於配置，Spring Boot 全部開發細節都是依據此思想進行實現的。

Spring Boot 是一套全新的框架，它來自於 Spring 你們族，所以 Spring 全部具有的功能它都有而且更容易使用；同時還簡化了基於 Spring 的應用開發，經過少許的代碼就能建立一個獨立的、產品級別的 Spring 應用。 

下圖展現出了 Spring Boot 在 Spring 生態中的位置：

 

該項目主要的目的是：

• 上手 Spring 開發更快、更普遍；
• 使用默認方式實現快速開發；
• 提供大多數項目所需的非功能特性，諸如：嵌入式服務器、安全、心跳檢查、外部配置等。

Spring Boot 特性

• 使用 Spring 項目引導頁面能夠在幾秒構建一個項目；
• 方便對外輸出各類形式的服務，如 REST API、WebSocket、Web、Streaming、Tasks；
• 很是簡潔的安全策略集成；
• 支持關係數據庫和非關係數據庫；
• 支持運行期內嵌容器，如 Tomcat、Jetty；
• 強大的開發包，支持熱啓動；
• 自動管理依賴；
• 自帶應用監控；
• 支持各類 IED，如 IntelliJ IDEA、NetBeans。

1.3   Spring Boot 市場熱度

Spring Boot 於 2014 年發佈了第一個正式版本，發佈以後陸續有一些開源愛好者進行了研究，並迅速喜歡上了這款開源軟件，Spring Boot 在初期低調快速發展，直到 2016 年才被真正使用起來。期間不少研究 Spring Boot 的開發者，在網上寫了大量文章，推進了 Spring Boot 在行業內的發展。

從 2016 年到 2018 年，是 Spring Boot 在中國發展的黃金時期，使用 Spring Boot 的企業和我的開發者愈來愈多，咱們從 Spring Boot 關鍵字的百度指數能夠看出。

 

上圖爲 2014 年到 2018 年 Spring Boot 的百度指數，能夠看出 2.0 的推出引起了搜索高峯。

經過谷歌趨勢來看 Spring Boot 在美國的使用狀況發現，中國和美國使用 Spring Boot 的總體頻率保持一致，看來國內技術人同步全球的技術頻率愈來愈快。

 

看到社區使用 Spring Boot 的熱情，Spring 官方也很是重視 Spring Boot 的後續發展，已經把它做爲公司最頂級的項目來推廣，放到了官網上第一的位置，後續 Spring Boot 的發展也被看好。

 

1.4   Spring Boot 和微服務架構

微服務架構是在互聯網高速發展，技術突飛猛進的變化以及傳統架構沒法適應快速變化等多重因素的推進下誕生的產物。互聯網時代的產品一般有兩類特色：需求變化快和用戶羣體龐大。在這種狀況下，如何從系統架構的角度出發，構建靈活、易擴展的系統，快速應對需求的變化；在用戶增長的同時如何保證系統的可伸縮性、高可用性，成爲系統架構面臨的挑戰。

若是還按照之前傳統開發模式，開發一個大而全的系統已經很難知足市場對技術的需求，這時候分而治之的思想被提了出來，因而咱們從單獨架構發展到分佈式架構，又從分佈式架構發展到 SOA 架構，服務不斷地被拆分和分解，粒度也愈來愈小，直到微服務架構的誕生。

大約 2009 年開始，Netflix 徹底從新定義了它的應用程序開發和操做模型，拉開了微服務探索的第一步，直到 2014 年 3 月 Martin Fowler 寫的一篇文章 Microservices 以更加通俗易懂的形式爲你們定義了什麼是微服務架構。Martin Fowler 在文中闡述了對微服務架構的設想，認爲微服務架構是一種架構模式，它提倡將單一應用程序劃分紅一組小的服務，服務之間互相協調、互相配合，爲用戶提供最終價值。

Spring Boot 誕生時，正處於微服務概念在慢慢醞釀中，Spring Boot 的研發融合了微服務架構的理念，實現了在 Java 領域內微服務架構落地的技術支撐。Spring Boot 在開發、測試、部署、運維等方面都作了大量的優化，使用 Spring Boot 開發項目，能夠快速響應需求、獨立完成開發部署上線。

Spring Boot 的一系列特性有助於實現微服務架構的落地，從目前衆多的技術棧對比來看它是 Java 領域微服務架構最優落地技術，沒有之一。

1.5   爲何學習 Spring Boot ？

《精通 Spring Boot 42 講》。

Spring Boot 自己並不提供 Spring 框架的核心特性以及擴展功能，只是用於快速、敏捷地開發新一代基於 Spring 框架的應用程序。同時它集成了大量經常使用的第三方庫配置（如 Redis、MongoDB、JPA、RabbitMQ、Quartz 等），Spring Boot 應用中這些第三方庫幾乎能夠零配置進行開箱即用，大部分的 Spring Boot 應用都只須要很是少許的配置代碼，開發者可以更加專一於業務邏輯。

使用 Spring Boot 開發項目，有如下幾方面優點：

• Spring Boot 使開發變得簡單，提供了豐富的解決方案，快速集成各類解決方案提高開發效率。
• Spring Boot 使配置變得簡單，提供了豐富的 Starters，集成主流開源產品每每只須要簡單的配置便可。
• Spring Boot 使部署變得簡單，其自己內嵌啓動容器，僅僅須要一個命令便可啓動項目，結合 Jenkins、Docker 自動化運維很是容易實現。
• Spring Boot 使監控變得簡單，自帶監控組件，使用 Actuator 輕鬆監控服務各項狀態。

從軟件發展的角度來說，越簡單的開發模式越流行，簡單的開發模式解放出更多生產力，讓開發人員能夠避免將精力耗費在各類配置、語法所設置的門檻上，從而更專一於業務。這點上，Spring Boot 已儘量地簡化了應用開發的門檻。

Spring Boot 所集成的技術棧，涵蓋了各大互聯網公司的主流技術，跟着 Spring Boot 的路線去學習，基本能夠了解國內外互聯網公司的技術特色。 

1.6   總結

Spring Boot 是一套快速開發框架，在微服務架構的大環境下 Spring Boot 一經推出就受到開源社區的追捧。Spring Boot 有強大的生態整合能力，提供了衆多的 Starters 包，很是方便 Spring Boot 集成第三方開源軟件達到開箱即用的效果。

Spring Boot 和微服務架構都是將來軟件開發的大趨勢，越早參與，受益越大。

2    第1-1課：Spring Boot 產生的背景和它的設計理念

《精通 Spring Boot 42 講》共分五大部分，第一部分是從零起步的基礎內容，共4課，幫助你們快速認識 Spring Boot ，我會帶領你們熟悉 Spring Boot 產生的背景和設計理念，同時也會講解 Spring Boot 的環境搭建和項目介紹，最後以一個 Hello World 爲例，來測試一下環境的搭建以及熟悉開發的流程。本章的重點內容是 Spring Boot 2.0 的新變化，若是學習過此前課程的同窗能夠重點關注這一節。下面咱們就具體進入第一講的內容。

要了解 Spring Boot 產生的背景，咱們就必需要先了解一下 Spring 的發展史，不只由於 Spring Boot 來源於 Spring 體系，並且 Spring Boot 的誕生和 Spring 框架的發展息息相關。

2.1   Spring 的發展史

時間回到 2002 年，當時正是 Java EE 和 EJB 大行其道的時候，不少知名公司都是採用此技術方案進行項目開發。這時候有一個美國的小夥子認爲 EJB 太過臃腫，並非全部的項目都須要使用 EJB 這種大型框架，應該會有一種更好的方案來解決這個問題。

他爲了證實本身的想法是正確的，在 2002 年 10 月寫了一本書《Expert One-on-One J2EE》，介紹了當時 Java 企業應用程序開發的狀況，並指出了 Java EE 和 EJB 組件框架中存在的一些主要缺陷。在這本書中，他提出了一個基於普通 Java 類和依賴注入的更簡單的解決方案。

在書中，他展現瞭如何在不使用 EJB 的狀況下構建高質量、可擴展的在線座位預留系統。爲了構建應用程序，他編寫了超過 30,000 行的基礎結構代碼，項目中的根包命名爲 com.interface21，因此人們最初稱這套開源框架爲 interface21，這就是 Spring 的前身。

他是誰呢？他就是大名鼎鼎的 Rod Johnson（下圖），Rod Johnson 在悉尼大學不只得到了計算機學位，同時還得到了音樂學位，更使人吃驚的是在回到軟件開發領域以前，他還得到了音樂學的博士學位。如今 Rod Johnson 已經離開了 Spring，成爲了一個天使投資人，同時也是多個公司的董事，早已走上人生巔峯。

 

在這本書發佈後，一對一的 J2EE 設計和開發一炮而紅。這本書免費提供的大部分基礎架構代碼都是高度可重用的。2003 年 Rod Johnson 和同伴在此框架的基礎上開發了一個全新的框架命名爲 Spring，據 Rod Johnson 介紹 Spring 是傳統 J2EE 新的開始，隨後 Spring 發展進入快車道。

• 2004 年 03 月，1.0 版發佈。
• 2006 年 10 月，2.0 版發佈。
• 2007 年 11 月，改名爲 SpringSource，同時發佈了 Spring 2.5。
• 2009 年 12 月，Spring 3.0 發佈。
• 2013 年 12 月，Pivotal 宣佈發佈 Spring 框架 4.0。
• 2017 年 09 月，Spring 5.0 發佈。

2.2   Spring Boot 的誕生

多年以來，Spring 平臺飽受非議的一點就是大量的 XML 配置以及複雜的依賴管理。

隨着使用 Spring 進行開發的我的和企業愈來愈多，Spring 也慢慢從一個單一簡潔的小框架變成一個大而全的開源軟件，Spring 的邊界不斷進行擴充，到了後來 Spring 幾乎能夠作任何事情，市面上主流的開源軟件、中間件都有 Spring 對應組件支持，人們在享用 Spring 的便利以後，也遇到了一些問題。

Spring 每集成一個開源軟件，就須要增長一些基礎配置，隨着開發項目的逐漸龐大，每每須要集成不少開源軟件。後期使用 Spring 開發大型項目須要引入不少配置文件，致使配置工做難以理解且出錯率高，到了後來人們甚至稱 Spring 爲配置地獄。

在 2013 年的 SpringOne 2GX 會議上，Pivotal 的 CTO Adrian Colyer 迴應了這些批評，而且特別提到該平臺未來的目標之一就是實現免 XML 配置的開發體驗。Spring Boot 所實現的功能超出了這個任務的描述，開發人員不只再也不須要編寫 XML，並且在一些場景中甚至不須要編寫繁瑣的 import 語句。

2013 年，微服務的概念也慢慢興起，快速開發微小獨立的應用變得更爲急迫，Spring 恰好處在這樣一個交叉點上，於 2013 年初啓動了 Spring Boot 項目的研發。2014 年，Spring Boot 伴隨着 Spring 4.0 誕生髮布了第一個正式版本。

Spring Boot 並非要成爲 Spring 平臺裏面衆多「Foundation」層項目的替代者。Spring Boot 的目標不在於爲已解決的問題域提供新的解決方案，而是爲平臺帶來另外一種開發體驗，從而簡化對這些已有技術的使用。對於已經熟悉 Spring 生態系統的開發人員來講，Spring Boot 是一個很理想的選擇；對於採用 Spring 技術的新人來講，Spring Boot 提供一種更簡潔的方式來使用這些技術。

2.3   Spring Boot 開發團隊

咱們常常會看到在介紹 Spring Boot 的時候有這麼一句：Spring Boot 是由 Pivotal 團隊提供的全新框架。由此咱們得知 Spring Boot 是由 Pivotal 團隊所研發，那麼 Pivotal 團隊究竟是一個什麼樣的團隊呢？其實這裏的 Pivotal 團隊是指 Pivotal 公司。

Pivotal 公司：致力於「改變世界構造軟件的方式（We are transforming how the world builds software）」，提供雲原生應用開發 PaaS 平臺及服務，幫助企業客戶採用敏捷軟件開發方法論，從而提升軟件開發人員工做效率、減小運維成本，實現數字化轉型、IT 創新，並最終實現業務創新。

Pivotal 公司可謂是大牛雲集，公司的開源產品有：Spring 以及 Spring 衍生產品、Web 服務器 Tomcat、緩存中間件 Redis、消息中間件 RabbitMQ、平臺即服務的 Cloud Foundry、Greenplum 數據引擎、還有大名鼎鼎的 GemFire（12306 系統解決方案組件之一）。這些著名開源產品背後的開發者都在 Pivotal 公司，其研發團隊聚集了全球的一流開發者，Spring Boot 爲何如此優秀，或許在這裏能夠找到一些答案。

回顧 Pivotal 公司的發展歷史，簡直就是一場商業併購大片：

• 1989 年，羅伯·米創立 Pivotal Labs 公司，它的主營業務是幫助客戶開發軟件，曾給谷歌、Twitter 公司作技術支持；
• 2003 年，EMC 收購了 VMware；
• 2009 年，VMware 收購了 Spring 公司；
• 2012 年，EMC 以現金方式收購了 Pivotal Labs 公司； 
• 2013 年，EMC 和 VMware 分拆出其 Cloud Foundry、Pivotal Labs、Greenplum 等雲計算、大數據資源，GE 投資 1.05 億美圓，成立新公司 Pivotal；
• 2015 年，EMC 又被 DELL 所收購。

Pivotal 公司成立以後，於 2014 年發佈了 Spring Boot，2015 年發佈了 Spring Cloud，2018 年 Pivotal 公司在紐約上市。咱們能夠經過一張圖來了解 Pivotal 公司的發展史。

 

《精通 Spring Boot 42 講》。

2.4   Spring Boot 的核心：約定優於配置

那麼什麼是約定優於配置呢？

約定優於配置（Convention Over Configuration），也稱做按約定編程，是一種軟件設計範式，旨在減小軟件開發人員需作決定的數量、得到簡單的好處，而又不失靈活性。

本質是說，開發人員僅需規定應用中不符約定的部分。例如，若是模型中有個名爲 User 的類，那麼數據庫中對應的表就會默認命名爲 user。只有在偏離這一約定時，例如將該表命名爲「user_info」，才需寫有關這個名字的配置。

咱們能夠按照這個思路來設想，咱們約定 Controller 層就是 Web 請求層能夠省略 MVC 的配置；咱們約定在 Service 結尾的類自動注入事務，就能夠省略了 Spring 的切面事務配置。

在 Spring 體系中，Spring Boot JPA 就是約定優於配置最佳實現之一，不須要關注表結構，咱們約定類名便是表名，屬性名便是表的字段，String 對應 varchar，long 對應 bigint，只有須要一些特殊要求的屬性，咱們再單獨進行配置，按照這個約定咱們能夠將之前的工做大大簡化。

Spring Boot 體系將約定優於配置的思想展示得淋漓盡致，小到配置文件、中間件的默認配置，大到內置容器、生態中的各類 Starters 無不遵循此設計規則。Spring Boot 鼓勵各軟件組織方建立本身的 Starter，建立 Starter 的核心組件之一就是 autoconfigure 模塊，也是 Starter 的核心功能，在啓動的時候進行自動裝配，屬性默認化配置。

能夠說正是由於 Spring Boot 簡化的配置和衆多的 Starters 才讓 Spring Boot 變得簡單、易用、快速上手，也能夠說正是約定優於配置的思想完全落地才讓 Spring Boot 走向輝煌。Spring Boot 約定優於配置的思想讓 Spring Boot 項目很是容易上手，讓編程變得更簡單，其實編程本該很簡單，簡單纔是編程的美。 

2.5   Starters

Spring Boot Starters 基於約定優於配置的理念來設計，Spring Boot Starter 中有兩個核心組件：自動配置代碼和提供自動配置模塊及其它有用的依賴。也就意味着當咱們項目中引入某個 Starter，即擁有了此軟件的默認使用能力，除非咱們須要特定的配置，通常狀況下我僅須要少許的配置或者不配置便可使用組件對應的功能。

Spring Boot 由衆多 Starter 組成，隨着版本的推移 Starter 家族成員也與日俱增。在傳統 Maven 項目中一般將一些層、組件拆分爲模塊來管理，以便相互依賴複用，在 Spring Boot 項目中咱們則能夠建立自定義 Spring Boot Starter 來達成該目的。

Spring Boot 擁有強大融合社區開源軟件的能力，在沒有使用 Spring Boot 以前，咱們須要按照每一個開源軟件的特性，將對應的組件包集成到咱們的開發項目中，由於每一個組件的設計理念和開發團隊都不一致，所以會有不少不一樣的調用風格在咱們的項目中。

Spring Boot 整合了主流的開源軟件造成了一系列的 Starter，讓咱們有了一致的編程體驗來集成各類軟件，Spring Boot 在集成的時候作了大量的優化，讓咱們在集成的時候每每只須要不多的配置和代碼就能夠完成。能夠說各類 Starters 就是 Spring Boot 最大的優點之一。

如下爲經常使用的 Spring Boot Starter 列表。

名稱	描述	Pom
spring-boot-starter	核心 Starter，包括自動配置支持，日誌和 YAML	Pom
spring-boot-starter-activemq	用於使用 Apache ActiveMQ 實現 JMS 消息	Pom
spring-boot-starter-amqp	用於使用 Spring AMQP 和 Rabbit MQ	Pom
spring-boot-starter-cache	用於使用 Spring 框架的緩存支持	Pom
spring-boot-starter-data-elasticsearch	用於使用 ElasticSearch 搜索，分析引擎和 Spring Data ElasticSearch	Pom
spring-boot-starter-data-jpa	用於使用 Hibernate 實現 Spring Data JPA	Pom
spring-boot-starter-data-mongodb	用於使用基於文檔的數據庫 MongoDB 和 Spring Data MongoDB	Pom
spring-boot-starter-data-redis	用於使用 Spring Data Redis 和 Jedis 客戶端操做鍵—值數據存儲 Redis	Pom
spring-boot-starter-jta-atomikos	用於使用 Atomikos 實現 JTA 事務	Pom
sring-boot-starter-mail	用於使用 Java Mail 和 Spring 框架 Email 發送支持	Pom
spring-boot-starter-quartz	用於定時任務 Quartz 的支持	Pom
spring-boot-starter-security	對 Spring Security 的支持	Pom
spring-boot-starter-test	用於測試 Spring Boot 應用，支持經常使用測試類庫，包括 JUnit、Hamcrest 和 Mockito	Pom
spring-boot-starter-thymeleaf	用於使用 Thymeleaf 模板引擎構建 MVC Web 應用	Pom
spring-boot-starter-validation	用於使用 Hibernate Validator 實現 Java Bean 校驗	Pom
spring-boot-starter-web	用於使用 Spring MVC 構建 Web 應用，包括 RESTful。Tomcat 是默認的內嵌容器	Pom
spring-boot-starter-websocket	用於使用 Spring 框架的 WebSocket 支持構建 WebSocket 應用	Pom

這裏只節選了咱們最常使用的 Starter，完整的 Starter 參考這裏：Spring Boot application starters。

由於 Spring Boot 足夠的強大，不少第三方社區都進行了主動的集成。好比：MyBatis、RabbitMQ（高級用法）等，第三方社區支持的列表，能夠在這裏查看 Community Contributions，能夠看到社區貢獻的其餘 Starters 列表。

看完這些 Starters 會不會瞬間以爲 Spring Boot 很強大？幾乎咱們涉及的開源軟件 Spring Boot 都作了支持，在 Spring Boot 環境下使用這些軟件，只須要引入對應的 Starter 包便可。

2.6   Spring、Spring Boot 和 Spring Cloud 的關係

Spring 最初核心的兩大核心功能 Spring IoC 和 Spring Aop 成就了 Spring，Spring 在這兩大核心功能上不斷地發展，纔有了 Spring 事務、Spring MVC 等一系列偉大的產品，最終成就了 Spring 帝國，到了後期 Spring 幾乎能夠解決企業開發中的全部問題。

Spring Boot 是在強大的 Spring 帝國生態基礎上面發展而來，發明 Spring Boot 不是爲了取代 Spring，是爲了讓人們更容易的使用 Spring。因此說沒有 Spring 強大的功能和生態，就不會有後期 Spring Boot 的火熱，Spring Boot 使用約定優於配置的理念，從新重構了 Spring 的使用，讓 Spring 後續的發展更有生命力。

Spring 並無重複製造輪子，它只是將目前各家公司開發的比較成熟、經得起實際考驗的服務框架組合起來，經過 Spring Boot 風格進行再封裝並屏蔽掉複雜的配置和實現原理，最終給開發者提供了一套簡單易懂、易部署、易維護的分佈式系統開發工具包。

Spring Cloud 是一系列框架的有序集合，它利用 Spring Boot 的開發便利性巧妙地簡化了分佈式系統基礎設施的開發。服務發現註冊、配置中心、消息總線、負載均衡、斷路器、數據監控等，均可以用 Spring Boot 的開發風格作到一鍵啓動和部署。

Spring Cloud 是爲了解決微服務架構中服務治理而提供的具有一系列功能的開發框架，而且 Spring Cloud 是徹底基於 Spring Boot 而開發，Spring Cloud 利用 Spring Boot 特性整合了開源行業中優秀的組件，總體對外提供了一套在微服務架構中服務治理的解決方案。

綜上咱們能夠這樣來理解，正是因爲 Spring IoC 和 Spring Aop 兩個強大的功能纔有了 Spring，Spring 生態不斷的發展纔有了 Spring Boot，使用 Spring Boot 讓 Spring 更易用更有生命力，Spring Cloud 是基於 Spring Boot 開發的一套微服務架構下的服務治理方案。

如下爲它們之間的關係。

Spring Ioc/Aop > Spring > Spring Boot > Spring Cloud

2.7   總結

Spring Boot 誕生一方面是由於 Spring 自身發展所遇到的問題，另外一方面在微服務思想誕生之際，急須要一款快速開發工具來實現微服務技術落地，在這樣的背景下誕生了 Spring Boot。

Spring Boot 總體的設計思想是：約定優於配置。依賴此設計思路，Spring Boot 進行了大刀闊斧的改革，讓開發、測試、部署更爲便捷。衆多的 Starters 成就了 Spring Boot 的發展，讓使用 Spring Boot 開發項目變得更加簡單。

3    第1-2課：Spring Boot 2.0 都更新了什麼（上）

2018 年 3 月 1 號 Spring Boot 2.0.0.RELEASE 正式發佈，這是 Spring Boot 1.0 發佈 4 年以後第一次重大修訂，所以有多新功能和特性值得關注！在 Spring Boot 官方博客中咱們瞭解到：Spring Boot 2.0 版本經歷了 17 個月的開發，有 215 個不一樣的使用者提供了超過 6800 次的提交。

咱們將 Spring Boot 2.0 更新的技術分爲三類進行解讀：

• 第一類，基礎環境升級；
• 第二類，默認軟件替換和優化；
• 第三類，新技術的引入。

3.1   基礎環境升級

3.1.1  最低 JDK 8，支持 JDK 9，再也不支持 Java 6 和 7

Spring Boot 2.0 要求 Java 8 做爲最低版本，許多現有的 API 已更新，以利用 Java 8 的特性。例如，接口上的默認方法，函數回調以及新的 API，如 javax.time。若是你正在使用 Java 7 或更早版本，則在開發 Spring Boot 2.0 應用程序以前，須要升級你的 JDK。

Spring Boot 2.0 經過測試能夠在 JDK 9 下正常運行，同時 Spring Boot 2.0 宣佈再也不支持 Java 6 和 7，據我瞭解國內絕大部分互聯網公司的基本環境還在 JDK 7 或者 6 環境下運行，考慮升級 Spring Boot 2.0 的團隊須要考慮這個因素。

3.1.2  依賴組件升級

Spring Boot 2.0 基於 Spring Framework 5 構建，本次 Spring Boot 的升級，同時也升級了部分其依賴的第三方組件，主要有如下幾個：

• Jetty 9.4，Jetty 是一個開源的 Servlet 容器，它爲基於 Java 的 Web 內容，例如 JSP 和 Servlet 提供運行環境。Jetty 是使用 Java 語言編寫的，它的 API 以一組 JAR 包的形式發佈。
• Tomcat 8.5，Apache Tomcat 8.5.x 旨在取代 8.0.x，徹底支持 Java 9。
• Flyway 5，Flyway 是獨立於數據庫的應用、管理並跟蹤數據庫變動的數據庫版本管理工具。用通俗的話講，Flyway 能夠像 SVN 管理不一樣人的代碼那樣，管理不一樣人的 SQL 腳本，從而作到數據庫同步。
• Hibernate 5.2，Hibernate 是一款很是流行的 ORM 框架。
• Gradle 3.4，Spring Boot 的 Gradle 插件在很大程度上已被重寫，有了重大的改進。
• Thymeleaf 3.0，Thymeleaf 3 相對於 Thymeleaf 2 有很是大的性能提高。

3.2   默認軟件替換和優化

3.2.1  HikariCP

默認鏈接池已從 Tomcat 切換到 HikariCP，HikariCP 是一個高性能的 JDBC 鏈接池，Hikari 是日語「光」的意思。

HikariCP 號稱是 Java 業界最快的數據庫鏈接池，官網提供了 c3p0、dbcp二、tomcat、vibur 和 Hikari 等數據鏈接池的性能對比。

 

關於 Hikari 性能爲何如此突出，官網給出的說明以下：

• 字節碼精簡：優化代碼，直到編譯後的字節碼最少，這樣 CPU 緩存能夠加載更多的程序代碼；
• 優化代理和攔截器：減小代碼，例如 HikariCP 的 Statement proxy 只有 100 行代碼；
• 自定義數組類型（FastStatementList）代替 ArrayList：避免每次 get() 調用都要進行 range check，避免調用 remove() 時從頭至尾的掃描；
• 自定義集合類型（ConcurrentBag）：提升併發讀寫的效率；
• 其餘針對 BoneCP 缺陷的優化，好比對於耗時超過一個 CPU 時間片的方法調用的研究。

3.2.2  Security

Spring Security 是 Spring 社區的一個頂級項目，也是 Spring Boot 官方推薦使用的 Security 框架。除了常規的 Authentication 和 Authorization 以外，Spring Security 還提供了諸如 ACLs、LDAP、JAAS、CAS 等高級特性以知足複雜場景下的安全需求。

沒有使用 Spring Boot 以前集成起來相對比較麻煩，而 Spring Boot 中基於 Java 配置實現 Spring Security 功能。Spring Boot 2.0 極大地簡化了默認的安全配置，並使添加定製安全變得簡單。

Spring Boot 2.0 很是容易使用 Spring Security 5.0 保護響應式應用，當檢測到 Spring Security 存在的時候會自動進行默認配置。

3.2.3  OAuth 2.0

OAuth 2.0 是 OAuth 協議的延續版本，但不向後兼容 OAuth 1.0，即徹底廢止了 OAuth1.0。OAuth 2.0 關注客戶端開發者的簡易性。要麼經過組織在資源擁有者和 HTTP 服務商之間的被批准的交互動做表明用戶，要麼容許第三方應用表明用戶得到訪問的權限。

OAuth 2.0 是一個受權框架，或稱受權標準，它能夠使第三方應用程序或客戶端得到對 HTTP 服務上（如 Google、GitHub ）用戶賬戶信息的有限訪問權限。OAuth 2.0 經過將用戶身份驗證委派給託管用戶賬戶的服務以及受權客戶端訪問用戶賬戶進行工做。

Spring Boot 2.0 將 Spring Security OAuth 項目遷移到 Spring Security。再也不提供單獨的依賴包，Spring Boot 2.0 經過 Spring Security 5 提供 OAuth 2.0 客戶端支持。

3.2.4  Micrometer

Micrometer 是一款監控指標的度量類庫，可讓你在沒有供應商鎖定的狀況下對 JVM 的應用程序代碼進行調整。

Spring Boot 2.0 加強了對 Micrometer 的集成，再也不提供本身的指標 API。依靠 micrometer.io 來知足全部應用程序監視需求。

Micrometer 包括尺寸指標的支持，當與尺寸監測系統配對時，尺寸指標能夠有效訪問特定的指定度量標準，而且能夠在其尺寸範圍內向下鑽取。

指標能夠輸出到各類系統和開箱即用的 Spring Boot 2.0，爲 Atlas、Datadog、Ganglia、Graphite、Influx、JMX、New Relic、Prometheus、SignalFx、StatsD 和 Wavefront 提供支持，另外還能夠使用簡單的內存中度量標準。

集成後提供 JVM 指標（包括 CPU、內存、線程和 GC）、Logback、Tomcat、Spring MVC ＆ 提供 RestTemplate。

3.2.5  Redis 默認使用 Lettuce

Redis 方面默認引入了 Lettuce，替代了以前的 Jedis 做爲底層的 Redis 鏈接方式。

Lettuce 是一個可伸縮的線程安全的 Redis 客戶端，用於同步、異步和反應使用。多個線程能夠共享同一個 RedisConnection，它利用優秀 Netty NIO 框架來高效地管理多個鏈接，支持先進的 Redis 功能，如 Sentinel、集羣、流水線、自動從新鏈接和 Redis 數據模型。

國內使用 Jedis 的居多，看來之後要多研究 Lettuce 了。

3.2.6  配置屬性綁定

在 Spring Boot 2.0 中，使用 Environment 綁定機制的 @ConfigurationProperties 數學已經徹底完全修改。藉此機會收緊了綁定的規則，並修復了 Spring Boot 1.x 中的許多不一致之處。

新的 Binder API 也能夠直接使用 @ConfigurationProperties 在代碼中。例如，下面綁定 List 中的 PersonName 對象：

List<PersonName> people = Binder.get(environment)

"my.property"class    .bind(, Bindable.listOf(PersonName.))

new    .orElseThrow(IllegalStateException::);

配置源能夠像這樣在 YAML 中表示：

my:

  property:

  - first-name: Jane

last   -name: Doe

  - first-name: John

last   -name: Doe

3.2.6.1    轉換器支持

Binding 使用了一個新的 ApplicationConversionService 類，它提供了一些額外有用的轉化。最引人注目的是轉換器的 Duration 類型和分隔字符串。

該 Duration 轉換器容許在任一 ISO-8601 格式的持續時間，或是一個簡單的字符串（如 10m，10 分鐘）。現有的屬性已更改成默認使用 Duration，該 @DurationUnit 註釋經過設置若是沒有指定所使用的單元確保向後兼容性。例如，Spring Boot 1.5 中須要秒數的屬性如今必須 @DurationUnit(ChronoUnit.SECONDS) 確保一個簡單的值，例如 10 實際使用的值爲 10s。

分隔字符串轉換容許你將簡單綁定 String 到 Collection 或 Array 沒必要分割逗號。例如，LDAP base-dn屬性用 @Delimiter(Delimiter.NONE)，因此 LDAP DN（一般包含逗號）不會被錯誤解釋。

3.2.7  Actuator 改進

在 Spring Boot 2.0 中 Actuator endpoints 有很大的改進，全部 HTTP Actuator endpoints 如今都在該/actuator路徑下公開，而且生成的 JSON 有效負載獲得了改進。

如今默認狀況下不會暴露不少端點。若是你要從 Spring Boot 1.5 升級現有的應用，請務必查看遷移指南並特別注意該 management.endpoints.web.exposure.include 屬性。

Spring Boot 2.0 改進了從許多端點返回的 JSON 有效負載。

如今許多端點都具備更精確地反映底層數據的 JSON。例如，/actuator/conditions終端（/autoconfig在 Spring Boot 1.5 中）如今有一個頂級 contexts 密鑰來將結果分組 ApplicationContext。

3.2.8  測試

對 Spring Boot 2.0 中測試進行了一些補充和調整：

• @WebFluxTest 已添加新註釋以支持 WebFlux 應用程序的「slice」測試。
• Converter 和 GenericConverter beans 如今自動掃描 @WebMvcTest 和 @WebFluxTest。
• @AutoConfigureWebTestClient 已經添加到 WebTestClient 供測試使用，這個註釋會自動應用於 @WebFluxTest 測試。
• 增長了一個新的 ApplicationContextRunner 測試實用程序，能夠很容易地測試你的自動配置，咱們已將大部份內部測試套件移至此新模型。

3.2.9  其餘

還有一些小的調整和改進：

• @ConditionalOnBean 如今在肯定是否知足條件時使用邏輯 AND 而不是邏輯 OR。
• 無條件類如今包含在自動配置中。
• 該 spring CLI 應用程序如今包括 encodepassword 可用於建立 Spring Security 的兼容散列密碼命令。
• 計劃任務（即 @EnableScheduling）能夠使用 scheduledtasks 執行器端點進行審查。
• 該 loggers 驅動器終端如今容許你從新設置一個日誌的默認級別。
• Spring Session 用戶如今能夠經過 sessions 執行器端點查找和刪除會話。
• 使用 spring-boot-starter-parent 如今基於 Maven 的應用程序-parameters默認使用標誌。

3.3   新技術的引入

3.3.1  支持 HTTP/2

HTTP/2 是第二代的 HTTP 協議，Spring Boot 的 Web 容器選擇中 Tomcat，Undertow 和 Jetty 均已支持 HTTP/2。

相比 HTTP/1.x，HTTP/2 在底層傳輸作了很大的改動和優化：

• HTTP/2 採用二進制格式傳輸數據，而非 HTTP/1.x 的文本格式。二進制格式在協議的解析和優化擴展上帶來更多的優點和可能。
• HTTP/2 對消息頭採用 HPACK 進行壓縮傳輸，可以節省消息頭佔用的網絡的流量；而 HTTP/1.x 每次請求，都會攜帶大量冗餘頭信息，浪費了不少帶寬資源；頭壓縮可以很好的解決該問題。
• 多路複用，直白的說就是全部的請求都是經過一個 TCP 鏈接併發完成。HTTP/1.x 雖然經過 pipeline 也能併發請求，可是多個請求之間的響應會被阻塞的，因此 pipeline 至今也沒有被普及應用，而 HTTP/2 作到了真正的併發請求。同時，流還支持優先級和流量控制。
• Server Push：服務端可以更快的把資源推送給客戶端。例如，服務端能夠主動把 JS 和 CSS 文件推送給客戶端，而不須要客戶端解析 HTML 再發送這些請求，當客戶端須要的時候，它已經在客戶端了。

3.3.2  嵌入式 Netty 服務器

因爲 WebFlux 不依賴於 Servlet API，咱們如今能夠首次爲 Netty 做爲嵌入式服務器提供支持，該 spring-boot-starter-webflux 啓動 POM 將拉取 Netty 4.1 和 Ractor Netty。

注意：你只能將 Netty 用做反應式服務器，不提供阻止 Servlet API 支持。

3.3.3  Kotlin的支持

Spring Boot 2.0 如今包含對 Kotlin 1.2.x 的支持，並提供了 runApplication，一個使用 Kotlin 運行 Spring Boot 應用程序的方法。咱們還公開和利用了 Kotlin 對其餘 Spring 項目（如 Spring Framework，Spring Data 和 Reactor）已添加到其最近版本中的支持。

3.3.4  JOOQ 的支持

JOOQ 是基於 Java 訪問關係型數據庫的工具包。JOOQ 既吸收了傳統 ORM 操做數據的簡單性和安全性，又保留了原生 SQL 的靈活性，它更像是介於 ORMS 和 JDBC 的中間層。對於喜歡寫 SQL 的碼農來講，JOOQ 能夠徹底知足你控制慾，能夠是用 Java 代碼寫出 SQL 的感受來。

3.3.5  支持 Quartz

Spring Boot 1.0 並無提供對 Quartz 的支持，以前出現了各類集成方案，Spring Boot2.0 給出了最簡單的集成方式。

3.3.6  響應式編程

WebFlux 模塊的名稱是 spring-webflux，名稱中的 Flux 來源於 Reactor 中的類 Flux。Spring WebFlux 有一個全新的非堵塞的函數式 Reactive Web 框架，能夠用來構建異步的、非堵塞的、事件驅動的服務，在伸縮性方面表現很是好。

非阻塞的關鍵預期好處是可以以小的固定數量的線程和較少的內存進行擴展。在服務器端 WebFlux 支持兩種不一樣的編程模型：

• 基於註解的 @Controller 和其餘註解也支持 Spring MVC；
• Functional 、Java 8 Lambda 風格的路由和處理。

 

默認狀況下，Spring Boot 2.0 使用 Netty WebFlux，由於 Netty 在異步非阻塞空間中被普遍使用，異步非阻塞鏈接能夠節省更多的資源，提供更高的響應度。經過比較 Servlet 3.1 非阻塞 I/O 沒有太多的使用，由於使用它的成本比較高，Spring WebFlux 打開了一條實用的通路。

使用 Spring WebFlux/WebFlux.fn 提供響應式 Web 編程支持，WebFlux 是一個全新的非堵塞的函數式 Reactive Web 框架，能夠用來構建異步的、非堵塞的、事件驅動的服務，在伸縮性方面表現很是好，此功能來源於 Spring 5.0。

Spring Boot 2.0 也提供了對響應式編程的自動化配置，如 Reactive Spring Data、Reactive Spring Security 等。

點擊瞭解《精通 Spring Boot 42 講》。

最後，Spring Boot 2.0 的新技術還有一個有意思的彩蛋設計，咱們會再下一講介紹。同時，我會詳細解釋一下 Spring Boot 1.0 到 Spring Boot 2.0 API 上的一些變化，以及關因而否須要升級 Spring Boot 的我的建議。

4    第1-2課：Spring Boot 2.0 都更新了什麼（下）

4.1.1  彩蛋

Spring Boot 2.0 支持了動態 Gif 的啓動 Logo 打印。

在 Spring Boot 1.0 項目中 src/main/resources 路徑下新建一個 banner.txt 文件，文件中寫入一些字符，啓動項目時就會發現默認的 Banner 被替換了，到了 Spring Boot 2.0 如今能夠支持 Gif 文件的打印，Spring Boot 2.0 在項目啓動的時候，會將 Gif 圖片的每個畫面，按照順序打印在日誌中，全部的畫面打印完畢後，纔會啓動 Spring Boot 項目。

 

    

項目的啓動 Banner 有什麼用呢，在一些大的組織或者公司中，能夠利用這個特性定製本身專屬的啓動畫面，增長團隊對品牌的認同感。

4.2   1.0 升級 2.0 API 變化

從 Spring Boot 1.0 升級到 2.0 以後，有不少的 API 已通過時，在使用的時候須要注意。

4.2.1  啓動類 SpringBootServletInitializer

Spring Boot 部署到 Tomcat 中去啓動時須要在啓動類添加 SpringBootServletInitializer，2.0 和 1.0 有區別。

// 1.0

importorg.springframework.boot.web.support.SpringBootServletInitializer;

// 2.0

importorg.springframework.boot.web.servlet.support.SpringBootServletInitializer;

@SpringBootApplication

publicclass UserManageApplication extends SpringBootServletInitializer {

@Override   

protected SpringApplicationBuilder configure(SpringApplicationBuilder application)    {

return       application.sources(UserManageApplication.class);

    }

public static void main(String[] args) throws Exception    {

        SpringApplication.run(UserManageApplication.class, args);

    }

}

Spring Boot 2.0 默認不包含 log4j，建議使用 slf4j。

importorg.apache.log4j.Logger;

protectedthisLogger logger = Logger.getLogger(.getClass());

改成：

importorg.slf4j.Logger;

importorg.slf4j.LoggerFactory;

protectedthisLogger logger =  LoggerFactory.getLogger(.getClass());

4.2.2  Thymeleaf 3.0 默認不包含佈局模塊

Spring Boot 2.0 中 spring-boot-starter-thymeleaf 包默認並不包含佈局模塊，使用 Thymeleaf 對頁面進行佈局時，須要單獨添加布局模塊，以下：

<dependency>

<groupId></groupId>  nz.net.ultraq.thymeleaf

<artifactId></artifactId>  thymeleaf-layout-dialect

</dependency>

layout:decorator 標籤在 3.0 過時，推薦使用新的標籤 layout:decorate 進行頁面佈局。

4.2.3  配置文件

大量的 Servlet 專屬的 server.* 被移到了 server.servlet.* 下：

Old property	New property
server.context-parameters.*	server.servlet.context-parameters.*
server.context-path	server.servlet.context-path
server.jsp.class-name	server.servlet.jsp.class-name
server.jsp.init-parameters.*	server.servlet.jsp.init-parameters.*
server.jsp.registered	server.servlet.jsp.registered
server.servlet-path	server.servlet.path

原 spring.http.* 或 spring.server.* 下的一些參數，例如我用到了文件上傳參數，已修改成 sping.servlet.multipart 下。

4.2.4  WebMvcConfigurerAdapter 過時

Spring Boot 2.0 中將原來的 WebMvcConfigurerAdapter 替換爲 WebMvcConfigurer。

1.0 中的用法：

class MyWebMvcConfigurerAdapter extends WebMvcConfigurerAdapterpublic

2.0 中的用法：

publicclass MyWebMvcConfigurerAdapter implements WebMvcConfigurer

4.2.5  Spring Boot JPA 變化

去掉了 xxxOne() 方法

之前的 findOne() 方法其實就是根據傳入的 ID 來查找對象，因此在 Spring Boot 2.0 的 Repository 中咱們能夠添加 findById(long id) 來替換使用。

例如：

Useruser=userRepository.findOne(Long id)

改成手動在 userRepository 手動添加 findById(long id) 方法，使用時將 findOne() 調用改成 findById(long id)：

longidUser user=userRepository.findById()

delete() 方法和 findOne() 相似也被去掉了，能夠使用 deleteById(Long id) 來替換，還有一個不一樣點是 deleteById(Long id) 默認實現返回值爲 void。

Long deleteById(Long id);

改成：

deletevoid//改成類型

voidLongiddeleteById();

固然咱們還有一種方案能夠解決上述的兩種變化，就是自定義 SQL（以下），可是沒有上述方案簡單，不建議使用。

@Query"select t from Tag t where t.tagId = :tagId"()

Tag getByTagId(@Param("tagId") long tagId);

須要指定主鍵的自增策略

Spring Boot 2.0 須要指定主鍵的自增策略，這個和 Spring Boot 1.0 有所區別，1.0 會使用默認的策略，若是不指定自增策略會報錯。

@Id

@GeneratedValue(strategy= GenerationType.IDENTITY)

privatelongid;

分頁組件 PageRequest 變化

在 Spring Boot 2.0 中 ，方法 new PageRequest(page, size, sort) 已通過期再也不推薦使用，推薦使用如下方式來構建分頁信息：

ofby"id"Pageable pageable =PageRequest.(page, size, Sort.(Sort.Direction.ASC,));

跟蹤了一下源碼發現 PageRequest.of() 方法，內部仍是使用的 new PageRequest(page, size, sort)，只是最新的寫法更簡潔一些。

public static PageRequest of(int page, int size, Sort sort) {

returnnew   PageRequest(page, size, sort);

}

JPA 關聯查詢

在使用 Spring Boot 1.0 時，使用 JPA 關聯查詢時咱們會構建一個接口對象來接收結果集，相似以下：

publicinterfaceCollectView{

Long getId()  ;

Long getUserId()  ;

String getProfilePicture()  ;

String getTitle()  ;

}

在使用 Spring Boot 1.0 時，若是沒有查詢到對應的字段會返回空，在 Spring Boot 2.0 中會直接報空指針異常，對結果集的檢查會更加嚴格一些。

這只是目前升級過程當中發現的一些問題，不表明 Spring Boot 2.0 升級中的全部問題，在隨後的課程中會再一一介紹。

4.3   是否選擇升級

經過以上內容能夠看出 Spring Boot 2.0 相對於 1.0 增長了不少新特性，而且最重要的是 Spring Boot 2.0 依賴的 JDK 最低版本是 1.8，估計國內大多互聯網公司尚未這麼激進。另一個新的重大版本更新以後，不免會有一些小 Bug 什麼的，每每須要再發布幾個小版本以後，纔會慢慢穩定下來。

所以個人建議是，若是不是特別須要使用 Spring Boot 2.0 上面提到的新特性，就儘可能不要着急進行升級，等 Spring Boot 2.0 完全穩定下來後再使用。若是想要升級也請先從早期的版本升級到 Spring Boot 1.5X 系列以後，再升級到 Spring Boot 2.0 版本，Spring Boot 2.0 的不少配置內容和 Spring Boot 1.0 不一致須要注意。

Spring Boot 1.0 發佈以後給咱們帶來了全新的開發模式，Spring Boot 2.0 發佈標誌着 Spring Boot 已經走向成熟，對 Java 領域帶來的變革已經開啓！

4.4   總結

能夠看出 Spring Boot 2.0 是歷時 4 年開發出來的巨做，在 Spring Boot 1.0 的基礎上進行了大量的優化，淘汰了不少過時的 API，同時引入了一大批最新的技術，這些新技術在將來的一段時間內都具備引導性。在咱們學習 Spring Boot 2.0 的同時，須要同時學習 Spring Boot 2.0 引入的一些新技術，不建議你們在生產環境直接進行升級，等 Spring Boot 2.0 進一步穩定以後再升級替換。

5    第1-3課：Spring Boot 依賴環境和項目結構介紹

使用 Spring Boot 開發項目須要有兩個基礎環境和一個開發工具，這兩個環境是指 Java 編譯環境和構建工具環境，一個開發工具是指 IDE 開發工具。

Spring Boot 2.0 要求 Java 8 做爲最低版本，須要在本機安裝 JDK 1.8 並進行環境變量配置，同時須要安裝構建工具編譯 Spring Boot 項目，最後準備一個順手的 IDE 開發工具便可。

構建工具是一個把源代碼生成可執行應用程序的自動化工具，Java 領域中主要有三大構建工具：Ant、Maven 和 Gradle。

• Ant（AnotherNeatTool）的核心是由 Java 編寫，採用 XML 做爲構建腳本，這樣就容許你在任何環境下運行構建。Ant 是 Java 領域最先的構建工具，不過由於操做複雜，慢慢的已經被淘汰了。
• Maven，Maven 發佈於 2004 年，目的是解決程序員使用 Ant 所帶來的一些問題，它的好處在於能夠將項目過程規範化、自動化、高效化以及強大的可擴展性。
• Gradle，Gradle 是一個基於 Apache Ant 和 Apache Maven 概念的項目自動化建構工具。它使用一種基於 Groovy 的特定領域語言來聲明項目設置，而不是傳統的 XML。結合了前二者的優勢，在此基礎之上作了不少改進，它具備 Ant 的強大和靈活，又有 Maven 的生命週期管理且易於使用。

 

Spring Boot 官方支持 Maven 和 Gradle 作爲項目構建工具。Gradle 雖然有更好的理念，可是相比 Maven 來說其行業使用率偏低，而且 Spring Boot 官方默認使用 Maven，所以本系列課程選擇使用 Maven 做爲 Spring Boot 項目構建工具。

Java 領域最流行的 IDE 開發工具備 Eclipse 和 IDEA。Eclipse 是 Java 的集成開發環境（IDE），也是 Java 領域最流行的 IDE 開發工具之一，只是 Eclipse 這些年發展緩慢，慢慢的有些陳舊。IDEA（IntelliJ IDEA）是用於 Java 語言開發的集成環境，在業界被公認爲是最好的 Java 開發工具之一，尤爲在智能代碼助手、代碼自動提示、重構、J2EE 支持、創新的 GUI 設計等方面的功能能夠說是超常的。所以強烈推薦你們使用 IntelliJ IDEA 開發 Spring Boot 項目。

接下來將介紹如何搭建基礎環境以及 IntelliJ IDEA 的安裝。

5.1     安裝 JDK

5.1.1   下載安裝

首先打開 Oracle 官網 JDK 1.8 下載頁面，根據下圖選擇下載各系統對應的版本，這裏以 Win10 64 位操做系統爲例。

 

下載完成以後，雙擊鼠標進行安裝，一直單擊「下一步」按鈕直至安裝完畢。

5.1.2   環境變量配置

JDK 安裝完畢後，接下來配置 JDK 環境變量，選擇「個人電腦」 | 「屬性」 | 「高級系統設置」 | 「環境變量」 | 「新建」命令： 

 

在彈出的對話框中新建JAVA_HOME變量以及 Java 安裝地址，以下圖：

 

單擊「肯定」按鈕後，回到環境變量界面，雙擊Path變量，添加兩條 JDK 路徑，以下：

 

以上，Java 環境變量配置完畢！

5.1.3   測試

配置完成以後，測試一下 JDK 是否配置正確，Win10 下使用快捷 window+r 輸入 cmd 命令，進入運行窗口，執行命令java -version，若出現以下結果，則表示安裝成功！

 

5.2     安裝 Maven

安裝 Maven 的前提是完成 Java 環境安裝，Maven 依賴於 Java 環境。

5.2.1   下載安裝

訪問 Maven 官網下載 Maven 對應的壓縮包，以下：

 

選擇 Maven 的 zip 壓縮包（apache-maven-3.5.4.zip），下載完成後解壓到本機目錄下。例如，路徑：D:\Common Files\apache-maven-3.5.4：

 

Maven 爲綠色軟件解壓後便可使用。

5.2.2   環境變量配置

按照上面步驟打開環境變量設置頁面，雙擊 Path 變量，將上一步解壓的目錄添加到 Path 中。

 

以上，Maven 環境配置完畢！

5.2.3   測試

Win10 下使用快捷 window+r 輸入 cmd 命令，彈出「運行」對話框，執行命令 mvn -v，若出現以下結果，則表示安裝成功！

 

5.2.4   settings.xml 設置

Maven 解壓後目錄下會有一個 settings.xml 文件，位置：${M2_HOME}/conf/settings.xml，用來配置 Maven 的倉庫和本地 Jar 包存儲地址。Maven 倉庫地址表明從哪裏去下載項目中的依賴包 Jar 包；Maven 會將全部的 Jar 包統一存儲到一個地址下，方便各個項目複用。

localRepository 設置本地存放 Jar 包地址，能夠根據本身的狀況改動：

locallocal<Repository>D:\Common Files\maven\repository</Repository>

mirrors 爲倉庫列表配置的下載鏡像列表：

<mirrors>

<mirror>    

<id></id>        repo2 

<mirrorOf></mirrorOf>        central 

<name></name>        spring2.0 for this Mirror. 

<url></url>        https://repo.spring.io/libs-milestone 

</mirror>    

    ...

<mirrors>

爲了方便你們使用，我已經配好了一份 settings.xml 模板，可下載後直接覆蓋默認的 settings.xml 文件，覆蓋完成後須要修改 localRepository 路徑。

模板 settings.xml 文件地址，詳見這裏。

5.3     IntelliJ IDEA 安裝

5.3.1   下載

打開 IntelliJ IDEA 2018 官方下載地址，IDEA 分爲兩種版本，即社區版和商業版，商業版付費的功能多，社區版免費的功能少。

 

5.3.2   安裝

下載完成後，雙擊安裝包開始安裝，一直單擊 Next 按鈕：

 

安裝過程當中會選擇安裝路徑，展現 32 或者 64 位的啓動快捷鍵，最後單擊 Finish 按鈕，安裝完成。

5.3.3   配置

安裝完成後，第一次會提示選擇配置設置，選擇下面一個，單擊 OK 按鈕。

 

後面選擇贊成協議，輸入「License server」激活軟件，根據本身的習慣選擇白色或者黑色的默認主題，而後選擇 IntelliJ IDEA 支持的擴展功能，也能夠使用默認直接單擊「下一步」按鈕，最後單擊 Start using IntelliJ IDEA 按鈕完成配置。

以上，開發工具安裝完畢！

5.4     構建項目

咱們有兩種方式來構建 Spring Boot 項目基礎框架，第一種是使用 Spring 官方提供的構建頁面；第二種是使用 IntelliJ IDEA 中的 Spring 插件來建立。

使用 Spring 官方提供頁面構建

• 訪問 http://start.spring.io/ 網址。 
• 選擇構建工具 Maven Project，編程語言選擇 Java、Spring Boot 版本 2.0.5 以及一些工程基本信息，具體可參考下圖：

 

• 單擊 Generate Project 下載項目壓縮包。
• 解壓後，使用 IDEA 導入項目，選擇 File | New | Model from Existing Source.. | 選擇解壓後的文件夾 | OK 命令，選擇 Maven，一路單擊 Next 按鈕，OK done! 
• 若是使用的是 Eclipse，選擇 Import | Existing Maven Projects | Next | 選擇解壓後的文件夾 | Finsh 按鈕，OK done! 

使用 IDEA 構建

• 選擇 File | New | Project... 命令，彈出新建項目的對話框。
• 選擇 Spring Initializr，Next 也會出現上述相似的配置界面，IDEA 幫咱們作了集成。

 

• 填寫相關內容後，單擊 Next 按鈕，選擇依賴的包再單擊 Next 按鈕，最後肯定信息無誤單擊 Finish 按鈕。

對上面的配置作一個解釋：

• 第一個選擇框選擇建立以 Maven 構建項目，仍是以 Gradle 構建項目，這是兩種不一樣的構建方式，其中 Gradle 配置內容更簡潔一些，而且包含了 maven 的使用，但咱們平常使用 maven 居多。 
• 第二個選擇框選擇編程語言，如今支持 Java、Kotlin、和 Groovy。
• 第三個選擇框選擇 Spring Boot 版本，能夠看出 Spring Boot 2.0 的最新版本是 2.0.5。

下面就是項目的配置信息了。

• Group，通常填寫公司域名，好比百度公司就會填：com.baidu，演示使用 com.neo。
• Artifact，能夠理解爲項目的名稱了，能夠根據實際狀況來填，本次演示填 hello。
• Dependencies，在這塊添加咱們項目所依賴的 Spring Boot 組件，能夠多選，本次選擇 Web、Devtools 兩個模塊。

5.5     項目結構介紹

 

如上圖所示，Spring Boot 的基礎結構共三個文件，具體以下。

• src/main/java：程序開發以及主程序入口；
• src/main/resources：配置文件；
• src/test/java：測試程序。

另外，Spring Boot 建議的目錄結構以下。

com.example.myproject 目錄下：

myproject

-src+

-main    +

-java         +

-com.example.myproject              +

-comm                    +

-model                    +

-repository                    +

-service                    +

-web                    +

-Application.java                    +

-resources         +

-static              +

-templates              +

-application.properties              +

-test    +

-pom.xml+

com.example.myproject 目錄下：

• Application.java，建議放到根目錄下面，是項目的啓動類，Spring Boot 項目只能有一個 main() 方面。
• comm 目錄建議放置公共的類，如全局的配置文件、工具類等。
• model 目錄主要用於實體（Entity）與數據訪問層（Repository）。
• repository 層主要是數據庫訪問層代碼。
• service 層主要是業務類代碼。
• web 層負責頁面訪問控制。

resources 目錄下：

• static 目錄存放 web 訪問的靜態資源，如 js、css、圖片等。
• templates 目錄存放頁面模板。
• application.properties 存放項目的配置信息。

test 目錄存放單元測試的代碼；pom.xml 用於配置項目依賴包，以及其餘配置。

採用默認配置能夠省去不少設置，也能夠根據公司的規範進行修改，至此一個 Java 項目搭建好了！

5.6     Pom 包介紹

pom.xml 文件主要描述了項目包的依賴和項目構建時的配置，在默認的 pom.xml 包中分爲五大塊。

第一部分爲項目的描述信息：

<groupId></groupId>com.neo

<artifactId></artifactId>hello

<version></version>2.0.5.RELEASE

<packaging></packaging>jar

<name></name>hello

<description></description>Demo project for Spring Boot

• groupId，項目的包路徑；
• artifactId，項目名稱；
• version，項目版本號；
• packaging，通常有兩個值：jar、war，表示使用 Maven 打包時構建成 Jar 包仍是 War 包；
• name，項目名稱；
• description，項目描述。

第二部分爲項目的依賴配置信息：

<parent>

<groupId></groupId> org.springframework.boot

<artifactId></artifactId> spring-boot-starter-parent

<version></version> 2.0.5.RELEASE

<relativePath/><!-- lookup parent from repository --> 

</parent>

<dependencies>

<dependency> 

<groupId></groupId>   org.springframework.boot

<artifactId></artifactId>   spring-boot-starter-web

</dependency> 

<dependency> 

<groupId></groupId>   org.springframework.boot

<artifactId></artifactId>   spring-boot-devtools

<scope></scope>   runtime

</dependency> 

<dependency> 

<groupId></groupId>   org.springframework.boot

<artifactId></artifactId>   spring-boot-starter-test

<scope></scope>   test

</dependency> 

</dependencies>

• parent，標籤內配置 Spring Boot 父級版本 spring-boot-starter-parent，Maven 支持項目的父子結構，引入父級後會默認繼承父級的配置。
• dependencies，標籤內配置項目所須要的依賴包，Spring Boot 體系內的依賴組件不須要填寫具體版本號，spring-boot-starter-parent 維護了體系內全部依賴包的版本信息。

第三部分爲構建時須要的公共變量：

<properties>

<project.build.sourceEncoding></project.build.sourceEncoding> UTF-8

<project.reporting.outputEncoding></project.reporting.outputEncoding> UTF-8

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

</properties>

上面配置了項目構建時所使用的編碼，輸出所使用的編碼，最後指定了項目使用的 JDK 版本。

第四部分爲構建配置：

<build>

<plugins> 

<plugin>   

<groupId></groupId>     org.springframework.boot

<artifactId></artifactId>     spring-boot-maven-plugin

</plugin>   

</plugins> 

</build>

使用 Maven 構建 Spring Boot 項目必須依賴於 spring-boot-maven-plugin 組件，spring-boot-maven-plugin 可以以 Maven 的方式爲應用提供 Spring Boot 的支持，即爲 Spring Boot 應用提供了執行 Maven 操做的可能。spring-boot-maven-plugin 可以將 Spring Boot 應用打包爲可執行的 jar 或 war 文件，而後以簡單的方式運行 Spring Boot 應用。

以上即爲 pom.xml 文件基礎內容，幾乎全部的 Spring Boot 項目都會用到以上配置信息。

5.7     總結

這一課咱們介紹了 Spring Boot 所依賴的基礎環境，如何去搭建 JDK、Maven 環境，安裝開發工具 IDEA；對 Spring Boot 項目結構進行了解讀，介紹了 pom.xml 文件內容的含義。經過本課的學習，咱們發現構建 Spring Boot 項目更簡單方便，相比傳統項目 Spring Boot 項目配置更加靈活。

6    第1-4課：寫一個 Hello World 來感覺 Spring Boot

在學習新技術的時候咱們都喜歡先寫一個 Hello World 程序，一方面能夠驗證基礎環境的搭建是否正確；另外一方面能夠快速瞭解整個開發流程。本節課咱們就來學習 Spring Boot 的第一個 Hello World 程序。

6.1     什麼是 Spring Boot

Spring 在官方首頁是這樣介紹的：

BUILD ANYTHING.Spring Boot is designed to get you up and running as quickly as possible,with minimal upfront configuration of Spring.Spring Boot takes an opinionated view of building production ready applications.

中文翻譯：Spring Boot 能夠構建一切。Spring Boot 設計之初就是爲了用最少的配置，以最快的速度來啓動和運行 Spring 項目。Spring Boot 使用特定的配置來構建生產就緒型的項目。

6.2     來一個 Hello World

（1）能夠在 Spring Initializr 上面添加，也能夠手動在 pom.xml 中添加以下代碼： 

<dependency>

<groupId></groupId>     org.springframework.boot

<artifactId></artifactId>     spring-boot-starter-web

</dependency>

pom.xml 文件中默認有個模塊：

<dependency>

<groupId></groupId> org.springframework.boot

<artifactId></artifactId> spring-boot-starter-test

<scope></scope> test

</dependency>

• <scope>test</scope>，表示依賴的組件僅僅參與測試相關的工做，包括測試代碼的編譯和執行，不會被打包包含進去；
• spring-boot-starter-test 是 Spring Boot 提供項目測試的工具包，內置了多種測試工具，方便咱們在項目中作單元測試、集成測試。

（2）編寫 Controller 內容

在目錄 src\main\java\com\neo\web 下建立 HelloController：

@RestController

publicclass HelloController {

@RequestMapping"/hello"   ()

public String hello()    {

return"hello world"       ;

    }

}

• @RestController 的意思是 Controller 裏面的方法都以 JSON 格式輸出，不須要有其餘額外的配置；若是配置爲 @Controller，表明輸出內容到頁面。
• @RequestMapping("/hello") 提供路由信息，"/hello" 路徑的 HTTP Request 都會被映射到 hello() 方法上進行處理。

（3）啓動主程序

右鍵單擊項目中的 HelloApplication | run 命令，就能夠啓動項目了，若出現如下內容表示啓動成功：

2018-09-19133357.80132996on8080''::  INFO--- [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat startedport(s):(http) with context path

2018-09-19133357.80232996in0.88::  INFO--- [  restartedMain] com.neo.hello.HelloApplication           : Started HelloApplicationseconds

若是啓動過程當中出現 java ClassNotFoundException 異常，請檢查 Maven 配置是否正確，具體以下。

• 檢查 Maven 的 settings.xml 文件是否引入正確，請參考模板 settings.xml 文件。
• 檢查 IDE 工具中的 Maven 插件是否配置爲本機的 Maven 地址，以下圖：

 

Spring Boot 還提供了另外兩種啓動項目的方式：

• 在項目路徑下，使用命令行 mvn spring-boot:run 來啓動，其效果和上面「啓動主程序」的效果是一致的；
• 或者將項目打包，打包後以 Jar 包的形式來啓動。

# 進行項目根目錄

cd../hello

# 執行打包命令

mvn clean package

# 以 Jar 包的形式啓動

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

啓動成功後，打開瀏覽器輸入網址：http://localhost:8080/hello，就能夠看到如下內容了：

helloworld

開發階段建議使用第一種方式啓動，便於開發過程當中調試。

（4）若是咱們想傳入參數怎麼辦？

請求傳參通常分爲 URL 地址傳參和表單傳參兩種方式，二者各有優缺點，但基本都以鍵值對的方式將參數傳遞到後端。做爲後端程序不用關注前端採用的那種方式，只須要根據參數的鍵來獲取值，Spring 提供了不少種參數接收方式，今天咱們瞭解最簡單的方式：經過 URL 傳參。

只要後端處理請求的方法中存在參數鍵相同名稱的屬性，在請求的過程當中 Spring 會自動將參數值賦值到屬性中，最後在方法中直接使用便可。下面咱們以 hello() 爲例進行演示。

@RestController

publicclass HelloController {

@RequestMapping"/hello"   ()

public String hello(String name)    {

return"hello world, "       +name;

    }

}

從新啓動項目，打開瀏覽器輸入網址 http://localhost:8080/hello?name=neo，返回以下內容。

helloworld，neo

到這裏，咱們的第一個 Spring Boot 項目就開發完成了，有沒有感受很簡單？通過測試發現，修改 Controller 內相關的代碼，須要從新啓動項目才能生效，這樣作很麻煩是否是？彆着急，Spring Boot 又給咱們提供了另一個組件來解決。

6.3     熱部署

熱啓動就須要用到咱們在一開始就引入的另一個組件：spring-boot-devtools。它是 Spring Boot 提供的一組開發工具包，其中就包含咱們須要的熱部署功能，在使用這個功能以前還須要再作一些配置。

6.3.1   添加依賴

在 pom.xml 文件中添加 spring-boot-devtools 組件。

<dependency>

<groupId></groupId> org.springframework.boot

<artifactId></artifactId> spring-boot-devtools

<scope></scope> runtime

</dependency>

其中，<scope>runtime</scope> 表示被依賴組件無需參與項目的編譯，不事後期的測試和運行週期須要其參與。

OK，以上的配置就完成了，若是你使用的是 Eclipse 集成開發環境，那麼恭喜你大功告成了；若是你使用的是 IDEA 集成開發環境，那麼還須要作如下配置。

6.3.2   配置 IDEA

選擇 File | Settings | Compiler 命令，而後勾選 Build project automatically 複選框，低版本的 IDEA 請勾選 make project automatically 複選框。

 

使用快捷鍵 Ctrl + Shift + A，在輸入框中輸入 Registry，勾選 compile.automake.allow.when.app.running 複選框：

 

所有配置完成後，IDEA 就支持熱部署了，你們能夠試着去改動一下代碼就會發現 Spring Boot 會自動從新加載，不再須要手動單擊從新部署了。

爲何 IDEA 須要多配置後面這一步呢？由於 IDEA 默認不是自動編譯的，須要咱們手動去配置後纔會自動編譯，而熱部署依賴於項目的自動編譯功能。

該模塊在完整的打包環境下運行的時候會被禁用，若是你使用 java-jar 啓動應用或者用一個特定的 classloader 啓動，它會認爲這是一個「生產環境」。

6.4     單元測試

單元測試在咱們平常開發中必不可少，一個優秀的程序員，單元測試開發也很是完善。下面咱們看下 Spring Boot 對單元測試又作了哪些支持？

若是咱們只想運行一個 hello world，只須要一個 @Test 註解就能夠了。在 src/test 目錄下新建一個 HelloTest 類，代碼以下：

publicclassHelloTest{

Test    @

    public void hello(){

out"hello world"        System..println();

    }

}

右鍵單擊「運行」按鈕，發現控制檯會輸出：hello world。若是須要測試 Web 層的請求呢？Spring Boot 也給出了支持。

以往咱們在測試 Web 請求的時候，須要手動輸入相關參數在頁面測試查看效果，或者本身寫 post 請求。在 Spring Boot 體系中，Spring 給出了一個簡單的解決方案，使用 MockMVC 進行 Web 測試，MockMVC 內置了不少工具類和方法，能夠模擬 post、get 請求，而且判斷返回的結果是否正確等，也能夠利用 print() 打印執行結果。

@SpringBootTest

publicclass HelloTest {

private   MockMvc mockMvc;

@Before   

public void setUp() throws Exception    {

new        mockMvc = MockMvcBuilders.standaloneSetup(HelloController()).build();

    }

@Test   

public void getHello() throws Exception    {

"/hello?name=小明"        mockMvc.perform(MockMvcRequestBuilders.post()

          .accept(MediaType.APPLICATION_JSON_UTF8)).andDo(print());

    }

}

• @Before 註解的方法表示在測試啓動的時候優先執行，通常用做資源初始化。
• .accept(MediaType.APPLICATION_JSON_UTF8)) 這句是設置 JSON 返回編碼，避免出現中文亂碼的問題。
• 注意導包須要加入如下代碼： 

importstaticorg.springframework.test.web.servlet.result.MockMvcResultHandlers.*;

由於 print() 等方法都是 MockMvcResultHandlers 類的靜態方法。

在類的上面添加 @SpringBootTest，系統會自動加載 Spring Boot 容器。在平常測試中，能夠注入 bean 來作一些局部的業務測試。MockMvcRequestBuilders 能夠支持 post、get 請求，使用 print() 方法會將請求和相應的過程都打印出來，具體以下：

MockHttpServletRequest:

      HTTP Method = POST

      Request URI = /hello

       Parameters = {name=[小明]}

-8          Headers = {Accept=[application/json;charset=UTF]}

set             Body = <no character encoding>

    Session Attrs = {}

Handler:

             Type = com.neo.hello.web.HelloController

public           Method =java.lang.String com.neo.hello.web.HelloController.hello(java.lang.String)

...

MockHttpServletResponse:

200           Status =

null    Error message =

-819          Headers = {Content-Type=[application/json;charset=UTF], Content-Length=[]}

-8     Content type = application/json;charset=UTF

             Body = hello world ,小明

null    Forwarded URL =

null   Redirected URL =

          Cookies = []

從返回的Body = hello world ,neo能夠看出請求成功了。

固然每次請求都看這麼多返回結果，不太容易識別，MockMVC 提供了更多方法來判斷返回結果，其中就有判斷返回值。咱們將上面的 getHello() 方法稍稍進行改造，具體以下所示：

@Test

public void getHello() throws Exception {

"/hello?name=小明"    mockMvc.perform(MockMvcRequestBuilders.post()

/*.andDo(print())*/            .accept(MediaType.APPLICATION_JSON_UTF8))

"小明"            .andExpect(MockMvcResultMatchers.content().string(Matchers.containsString()));

}

把剛纔的 .andDo(print()) 方法註釋掉，添加如下代碼：

.andExpectMockMvcResultMatchers.content.stringMatchers.containsString(()(("小明")));

• MockMvcResultMatchers.content()，這段代碼的意思是獲取到 Web 請求執行後的結果；
• Matchers.containsString("小明")，判斷返回的結果集中是否包含「小明」這個字符串。

咱們先將上面代碼改成：

.andExpectMockMvcResultMatchers.content.stringMatchers.containsString(()(("微笑")));

而後執行 test 便可返回如下結果：

java.lang.AssertionError: Response content

string"微笑"Expected: acontaining

"hello world ,小明"     but: was

...

拋出異常說明：指望的結果是包含「微笑」，結果返回內容是「hello world ,小明」，不符合預期。

接下來咱們把代碼改回：

.andExpectMockMvcResultMatchers.content.stringMatchers.containsString(()(("小明")));

再次執行測試方法，測試用例執行成功，說明請求的返回結果中包含了「小明」字段。

以上實踐的測試方法，只是 spring-boot-starter-test 組件中的一部分功能，spring-boot-starter-test 對測試的支持是全方位的，後面會一一介紹到。

6.5     對比

咱們簡單作一下對比，使用 Spring Boot 以前和使用以後。

使用 Spring Boot 以前：

• 配置 web.xml，加載 Spring 和 Spring MVC
• 配置數據庫鏈接、配置 Spring 事務
• 配置加載配置文件的讀取，開啓註解
• 配置日誌文件
• …
• 配置完成以後部署 Tomcat 調試
• …

如今很是流行微服務，若是項目只是簡單發送郵件的需求，咱們也須要這樣操做一遍。

使用 Spring Boot 以後，僅僅三步便可快速搭建起一個 Web 項目：

• 頁面配置導入到開發工具中
• 進行代碼編寫
• 運行

經過對比能夠發現 Spring Boot 在開發階段作了大量優化，很是容易快速構建一個項目。

6.6     總結

本課學習瞭如何搭建 Spring Boot 開發項目所需的基礎環境，瞭解瞭如何開發一個 Spring Boot 的 Hello World 項目。使用 Spring Boot 能夠很是方便地快速搭建項目，不用關心框架之間的兼容性、組件版本差別化等問題；項目中使用組件，僅僅添加一個配置便可，因此使用 Spring Boot 很是適合構建微服務。

點擊這裏下載源碼。

7    第 2-1 課：Spring Boot 對基礎 Web 開發的支持（上）

《精通 Spring Boot 42 講》共分五大部分，這是第二部份內容，主要講解了 Web 開發相關的技術點，共 10 課。首先讓你們快速認識 Spring Boot 對基礎 Web 開發所作的優化；接下來說解了如何在 Spring Boot 中使用前端技術 JSP、Thymeleaf，重點介紹了 Thymeleaf 的各類使用場景；後面幾課介紹瞭如何使用 Spring Boot 來構建 RESTful 服務、RESTful APIs，利用 WebSocket 雙向通訊的特性建立聊天室。

自從 B/S 架構（Browser/Server，瀏覽器/服務器模式）被髮明以來，由於其具備跨平臺、易移植、方便使用等特色，迅速地成爲了技術架構的首選，前端 Web 技術迅速發展起來。人們利用前端 Web 技術構建各類應用場景，如電子商務平臺、在線聊天室、後臺管理系統等。頁面技術也從最初的 JSP 演化爲如今的模板引擎；信息交互由之前的 XML 發展到如今更流行的 JSON；Spring Filter、IoC、Aop 等概念的發展更加方便人們構建 Web 系統。

Spring Boot 對 Web 開發的支持很全面，包括開發、測試和部署階段都作了支持。spring-boot-starter-web 是 Spring Boot 對 Web 開發提供支持的組件，主要包括 RESTful，參數校驗、使用 Tomcat 做爲內嵌容器等功能，接下來給你們一一介紹。

7.1 JSON 的支持

JSON (JavaScript Object Notation) 是一種輕量級的數據交換格式，易於閱讀和編寫，同時也易於機器解析和生成。JSON 採用徹底獨立於語言的文本格式，可是也使用了相似於 C 語言家族的習慣（包括 C、C++、C#、Java、JavaScript、Perl、Python 等），這些特性使 JSON 成爲理想的數據交換語言。

早期人們習慣使用 XML 進行信息交互，後來 JSON 的使用更加簡單，到了如今信息交互大部分都以 JSON 爲主。早期在 Spring 體系中使用 JSON 還比較複雜，須要配置多項 XML 和註解，如今在 Spring Boot 體系中，對 JSON 支持簡單而又完善，在 Web 層使用僅僅只須要一個註解便可完成。接下來使用案例說明。

新建一個 spring-boot-web 項目，在 pom.xml 中添加 Web 依賴。

<dependency>

<groupId></groupId>     org.springframework.boot

<artifactId></artifactId>     spring-boot-starter-web

</dependency>

啓動類：

@SpringBootApplication

publicclass WebApplication {

public static void main(String[] args)    {

        SpringApplication.run(WebApplication.class, args);

    }

}

在項目根路徑下新建 model 包，在包下新建一個實體類 User，User 信息以下：

publicclassUser{

private   String name;

privateint   age;

private   String pass;

//setter、getter省略   

}

在項目中新建 Web 包，並在 Web 包下新建一個類 WebController，在類中建立一個方法返回 User，以下：

@RestController

publicclass WebController {

@RequestMapping"/getUser"   (name=, method= RequestMethod.POST)

public User getUser()    {

new        User user=User();

"小明"        user.setName();

12        user.setAge();

"123456"        user.setPass();

return       user;

    }

}

• @RestController 註解至關於 @ResponseBody ＋ @Controller 合在一塊兒的做用，若是 Web 層的類上使用了 @RestController 註解，就表明這個類中全部的方法都會以 JSON 的形式返回結果，也至關於 JSON 的一種快捷使用方式；
• @RequestMapping(name="/getUser", method= RequestMethod.POST)，以 /getUser 的方式去請求，method= RequestMethod.POST 是指只能夠使用 Post 的方式去請求，若是使用 Get 的方式去請求的話，則會報 405 不容許訪問的錯誤。

在 test 包下新建 WebControllerTest 測試類，對 getUser() 方法進行測試。

@SpringBootTest

publicclass WebControllerTest {

//省略部分代碼   

@Test   

public void getUser() throws Exception    {

"/getUser"        String responseString = mockMvc.perform(MockMvcRequestBuilders.post())

                .andReturn().getResponse().getContentAsString();

"result : "        System.out.println(+responseString);

    }

}

這裏的測試代碼和上面的稍有區別，「.andReturn().getResponse().getContentAsString(); 」的意思是獲取請求的返回信息，並將返回信息轉換爲字符串，最後將請求的響應結果打印出來。

執行完 Test，返回結果以下：

result"name""小明""age""pass""123456": {:,:12,:}

說明 Spring Boot 自動將 User 對象轉成了 JSON 進行返回。那麼若是返回的是一個 list 呢，在 WebController 添加方法 getUsers()，代碼以下：

"/getUsers"@RequestMapping()

public List<User> getUsers() {

new    List<User> users=ArrayList<User>();

new    User user1=User();

"neo"    user1.setName();

30    user1.setAge();

"neo123"    user1.setPass();

add    users.(user1);

new    User user2=User();

"小明"    user2.setName();

12    user2.setAge();

"123456"    user2.setPass();

add    users.(user2);

return  users;

}

添加測試方法：

Test@

public void getUsers() throws Exception {

get"/getUsers"    String responseString = mockMvc.perform(MockMvcRequestBuilders.())

            .andReturn().getResponse().getContentAsString();

out"result : "    System..println(+responseString);

}

執行測試方法，返回內容以下：

"name""neo""age""pass""neo123""name""小明""age""pass""123456"result : [{:,:30,:},{:,:12,:}]

說明無論是對象仍是集合或者對象嵌套，Spring Boot 都可以將其轉換爲 JSON 字符串，這種方式特別適合系統提供接口時使用。

7.2 請求傳參

請求傳參是 Web 開發最基礎的內容，前端瀏覽器和後端服務器正是依賴交互過程當中的參數，來判斷用戶是否登陸、用戶正在執行時哪些動做，所以參數的傳遞和接收是一個 Web 系統最基礎的功能。Spring Boot 內置了不少種參數接收方式，提供一些註解來幫助限制請求的類型、接收不一樣格式的參數等，接下來咱們舉例介紹。

使用 Spring Boot 能夠輕鬆的對請求作一些限制，好比爲了安全咱們只容許 POST 請求的訪問，只須要在方法上添加一個配置既可：

RequestMappingnamegetUser@(="/", method= RequestMethod.POST)

public User getUser() {

    ...

}

這時候再以 GET 請求去訪問，就會返回以下結果： 

'GET'notRequest methodsupported

若是要求其請求只支持 GET 請求，method 設置爲：method= RequestMethod.GET；若是不進行設置默認兩種方式的請求都支持。

Spring Web 層支持多種方法傳參，在上一課中咱們傳入一個屬性 name，直接使用對象接收也能夠支持。

RequestMappingnamegetUser@(="/", method= RequestMethod.POST)

public String getUser(User user) {

    ...

}

這樣的寫法，只要是 User 的屬性都會被自動填充到 User 對象中；還有另一種傳參的方式，使用 URL 進行傳參，這種形式的傳參地址欄會更加美觀一些。

value"get/{name}"@RequestMapping(=, method=RequestMethod.GET)

public String get(@PathVariable String name) {

return   name;

}

在瀏覽器中輸入網址：http://localhost:8080/get/neo，返回：neo，說明 name 值已經成功傳入。

下一課咱們繼續講解「數據校驗」、「自定義 Filter」、「配置文件」等內容。