一、建立SpringBoot專案

概念

Spring Boot是由Pivotal團隊提供的全新框架，其設計目的是用來簡化新Spring應用的初始搭建以及開發過程。該框架使用了特定的方式來進行配置，從而使開發人員不再需要定義樣板化的配置。通過這種方式，Spring Boot致力於在蓬勃發展的快速應用開發領域(rapid application development)成為領導者。

Spring Boot特點

1. 建立獨立的Spring應用程式
2. 嵌入的Tomcat，無需部署WAR檔案
3. 簡化Maven配置
4. 自動配置Spring
5. 提供生產就緒型功能，如指標，健康檢查和外部配置
6. 絕對沒有程式碼生成和對XML沒有要求配置

構建Spring Boot專案

（1）建立專案，選擇Spring starter Project(需先在Eclipse安裝Spring Tool Suite),按Next:

（2）填寫跟專案相關的各種資訊，然後Next：

（3）選擇需要的Dependency，然後Next：

（4）最後”Finish”,就開始下載jar包了，這個過程需要的時間比較長。

執行專案

專案結構介紹

如上圖所示，Spring Boot的基礎結構共三個檔案:

1. src/main/java 程式開發以及主程式入口
2. src/main/resources 配置檔案
3. src/test/java 測試程式

另外，spingboot建議的目錄結果如下：
root package結構：com.example.myproject

com
  +- example
    +- myproject
      +- Application.java
      |
      +- domain
      |  +- Customer.java
      |  +- CustomerRepository.java
      |
      +- service
      |  +- CustomerService.java
      |
      +- controller
      |  +- CustomerController.java
      |複製程式碼

1、Application.java 建議放到根目錄下面,主要用於做一些框架配置
2、domain目錄主要用於實體（Entity）與資料訪問層（Repository）
3、service 層主要是業務類程式碼
4、controller 負責頁面訪問控制

pom.xml

pom.xml檔案中預設有兩個模組：

spring-boot-starter ：核心模組，包括自動配置支援、日誌和YAML；

spring-boot-starter-test ：測試模組，包括JUnit、Hamcrest、Mockito。

啟動單個controller

1，建立controller

package com.ailianshuo.helloword.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloWorldController {

    @RequestMapping("/hello")
    public String hello() {
        return "Hello World";
    }
}複製程式碼

@RestController 的意思就是controller裡面的方法都以json格式輸出，不用再寫什麼jackjson配置的了

2，啟動controller準備
按上面的程式碼還不能啟動單個controller，需要新增下面程式碼才可以：
（1）@EnableAutoConfiguration ：作用在於讓 Spring Boot 根據應用所宣告的依賴來對 Spring 框架進行自動配置，這就減少了開發人員的工作量。(也可以使用@SpringBootApplication 等價於以預設屬性使用 @Configuration ， @EnableAutoConfiguration 和 @ComponentScan)
（2）啟動程式：
public static void main(String[] args) throws Exception {
SpringApplication.run(**.class, args);
}
完整程式碼如下：

@EnableAutoConfiguration
@RestController
public class HelloWorldController {

    @RequestMapping("/hello")
    public String hello() {
        return "Hello World";
    }

    public static void main(String[] args) {  
           SpringApplication.run(HelloWorldController.class);  
    } 
}複製程式碼

3，啟動單個controller
（1）右鍵HelloWorldController中的main方法，Run As -> Spring Boot App，專案就可以啟動了。

(2) 編譯器顯示如下內容，即為啟動成功。
2017-08-19 11:12:49.814 INFO 4164 — [ main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)
2017-08-19 11:12:49.819 INFO 4164 — [ main] c.a.h.controller.HelloWorldController : Started HelloWorldController in 3.351 seconds (JVM running for 4.573)

（3）在瀏覽器訪問http://localhost:8080/hello ，就可以看到效果了。

在此我向大家推薦一個架構學習交流群。交流學習群號：575745314 裡面會分享一些資深架構師錄製的視訊錄影：有Spring，MyBatis，Netty原始碼分析，高併發、高效能、分散式、微服務架構的原理，JVM效能優化、分散式架構等這些成為架構師必備的知識體系。還能領取免費的學習資源，目前受益良多

二、RESTfull API簡單專案的快速搭建

編輯pom.xml

[html] view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>
2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4. <modelVersion>4.0.0</modelVersion>
6. <groupId>com.lyw</groupId>
7. <artifactId>springboot02</artifactId>
8. <version>0.0.1-SNAPSHOT</version>
9. <packaging>jar</packaging>
11. <name>springboot02</name>
13. <parent>
14. <groupId>org.springframework.boot</groupId>
15. <artifactId>spring-boot-starter-parent</artifactId>
16. <version>1.4.0.RELEASE</version>
17. <relativePath/> <!-- lookup parent from repository -->
18. </parent>
20. <properties>
21. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
22. <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
23. <java.version>1.8</java.version>
24. </properties>
26. <dependencies>
27. <dependency>
28. <groupId>org.springframework.boot</groupId>
29. <artifactId>spring-boot-starter-web</artifactId>
30. </dependency>
32. <dependency>
33. <groupId>org.springframework.boot</groupId>
34. <artifactId>spring-boot-starter-test</artifactId>
35. <scope>test</scope>
36. </dependency>
37. <dependency>
38. <groupId>org.springframework.boot</groupId>
39. <artifactId>spring-boot-devtools</artifactId>
40. </dependency>
41. </dependencies>
43. <build>
44. <plugins>
45. <plugin>
46. <groupId>org.springframework.boot</groupId>
47. <artifactId>spring-boot-maven-plugin</artifactId>
48. </plugin>
49. </plugins>
50. </build>
51. </project>

簡單解釋一下上面的配置

首先看看Spring-boot-start-web包的依賴

可以看到 其實這個包就是一些 日誌包 還有內建Tomcat JSON包 SpringMVC/Web包 這也就差不多解釋了為什麼直接跑起來了

其實這個就是可以理解為簡單封裝了一下Spring 使得我們配置更加便捷。

spring-boot-devtools的引入，其依賴包的學習

這個包 包含一些Spring的核心包。。。

spring-boot-maven-plugin 最後還加入了 一個SpringBoot的Maven外掛

開始寫程式碼。。。

Springboot2Application.java

[java] view plain copy

1. package com.lyw;
3. import org.springframework.boot.SpringApplication;
4. import org.springframework.boot.autoconfigure.SpringBootApplication;
6. @SpringBootApplication
7. public class Springboot02Application {
9. public static void main(String[] args) {
10. SpringApplication.run(Springboot02Application.class, args);
11. }
12. }

User.java

[java] view plain copy

1. package com.lyw.bean;
3. import java.util.Date;
5. /**
6. * Title: User Description: 實體類 Company: blog.csdn.net/lu1005287365/
7. *
8. * @author L lulu
9. */
10. public class User {
11. private Integer id;
12. private String name;
13. private Date date;
14. private char sex;
16. public Integer getId() {
17. return id;
18. }
20. public void setId(Integer id) {
21. this.id = id;
22. }
24. public String getName() {
25. return name;
26. }
28. public void setName(String name) {
29. this.name = name;
30. }
32. public Date getDate() {
33. return date;
34. }
36. public void setDate(Date date) {
37. this.date = date;
38. }
40. public char getSex() {
41. return sex;
42. }
44. public void setSex(char sex) {
45. this.sex = sex;
46. }
48. }

UserControoler.java

[java] view plain copy

1. package com.lyw.controller;
3. import java.util.Date;
4. import java.util.HashMap;
5. import java.util.Map;
7. import org.springframework.web.bind.annotation.PathVariable;
8. import org.springframework.web.bind.annotation.RequestMapping;
9. import org.springframework.web.bind.annotation.RestController;
11. import com.lyw.bean.User;
13. @RestController
14. @RequestMapping(value = "/user")
15. public class UserController {
17. @RequestMapping
18. public String index() {
19. return "Hello BeiJing";
20. }
22. @RequestMapping(value = "/getMap")
23. public Map<String, Object> getThisMap(String msg) {
24. Map<String, Object> map = new HashMap<>();
25. map.put("Name", "LYW");
26. map.put("Sex", "大老爺們");
27. map.put("Message", msg);
28. return map;
29. }
31. @RequestMapping(value = "/getUser/{name}/{sex}")
32. public User getUser(@PathVariable String name, @PathVariable char sex) {
33. User user = new User();
34. user.setId(12);
35. user.setName(name);
36. user.setDate(new Date());
37. user.setSex(sex);
38. return user;
39. }
41. }

執行專案:

直接執行main方法或者使用maven命令: spring-boot:run

上面就是執行的結果。。

解釋

@RestController註解：看看原始碼 其實就是 又封裝了一層 將@Controller和@RsponseBody兩個註解合在一起

這樣一來應該對SpringBoot 也有了初步的認識。。。並且會簡單的使用

三、Spring Boot 實現多環境配置

在實際專案中，我們一般會放置一些配置檔案，這些配置檔案是區分環境的，一般環境有dev，test，prep，prod，分別對應開發，測試，預釋出，生產。那麼在spring boot專案中如何實現不同環境，使用不同的配置檔案呢。

第一步:定義好不同環境的application.properties

application.properties 存放公用的一些配置。
以及最重要的配置 spring.profiles.active=@profiles.active@
application-dev.properties 對應開發環境
application-test.properties 對應測試環境
application-prep.properties 對應預生產環境
application-prod.properties 對應生產環境

第二步：pom中定義profile

第三步:maven命令打包
package -Dmaven.test.skip=true -Pdev

那麼此時就會將application-dev.properties 和application.properties 的配置都打入包中了。

在此我向大家推薦一個架構學習交流群。交流學習群號：575745314 裡面會分享一些資深架構師錄製的視訊錄影：有Spring，MyBatis，Netty原始碼分析，高併發、高效能、分散式、微服務架構的原理，JVM效能優化、分散式架構等這些成為架構師必備的知識體系。還能領取免費的學習資源，目前受益良多

四、Spring Boot應用監控

入門使用：Actuator外掛

Actuator外掛是SpringBoot原生提供的一個服務，可以通過暴露端點路由，用來輸出應用中的諸多 端點資訊。實戰一下！

• pom.xml中新增依賴：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>複製程式碼

啟動Spring Boot應用程式之後，只要在瀏覽器中輸入端點資訊就能獲得應用的一些狀態資訊。

常用端點列舉如下，可以一個個詳細試一下：

當然此時只能使用/health 和 /info端點，其他因為許可權問題無法訪問。想訪問指定端點的話可以在yml配置中新增相關的配置項，比如/metrics端點則需要配置：

endpoints:
  metrics:
    sensitive: false複製程式碼

此時瀏覽器訪問/metrics端點就能得到諸如下面所示的資訊：

當然也可以開啟全部端點許可權，只需如下配置即可：

endpoints:
  sensitive: false複製程式碼

於Actuator外掛提供的監控能力畢竟有限，而且UI比較簡陋，因此需要一個更加成熟一點的工具

Spring Boot Admin監控系統

SBA則是基於Actuator更加進化了一步，其是一個針對Actuator介面進行UI美化封裝的監控工具。我們來實驗一下。

• 首先來建立一個Spring Boot Admin Server工程作為服務端

pom.xml中加入如下依賴：

然後在應用主類上通過加註解來啟用Spring Boot Admin

啟動程式，瀏覽器開啟 localhost:8081 檢視Spring Boot Admin主頁面：

此時Application一欄空空如也，等待待監控的應用加入

• 建立要監控的Spring Boot應用

pom.xml中加入以下依賴

然後在yml配置中新增如下配置，將應用註冊到Admin服務端去：

Client應用一啟動，Admin服務立馬推送來了訊息，告訴你AdminTest上線了：

此時去Admin主介面上檢視，發現Client應用確實已經註冊上來了：

• 檢視Detail

• 檢視 Metrics

• 檢視 Enviroment

• 檢視JMX

• 檢視Threads

• 檢視Trace與詳情

點選最上方JOURNAL，會看到被監控應用程式的事件變化：

圖中可以清晰地看到，應用從 REGISTRATION → UNKNOWN → UP 的狀態跳轉。

這樣就將Actuator外掛提供的所有端點資訊在SBA中全部嘗試了一遍。

在此我向大家推薦一個架構學習交流群。交流學習群號：575745314 裡面會分享一些資深架構師錄製的視訊錄影：有Spring，MyBatis，Netty原始碼分析，高併發、高效能、分散式、微服務架構的原理，JVM效能優化、分散式架構等這些成為架構師必備的知識體系。還能領取免費的學習資源，目前受益良多

五、Spring Boot的日誌管理

預設情況下，Spring Boot的日誌是輸出到控制檯的，不寫入任何日誌檔案。

要讓Spring Boot輸出日誌檔案，最簡單的方式是在application.properties配置檔案中配置logging.path鍵值，如下：（日誌檔案為spring.log）

logging.path=/var/log
複製程式碼

二種方法是在application.properties配置檔案中配置logging.file鍵值，如下：

logging.file=/var/log/myapp.log
複製程式碼

兩種配置方法適用於開發階段，對於部署則存在一定的問題。比如部署到不同的環境，可能就存在需要修改application.properties檔案的情況，這就意味著需要重新打包，再次部署，顯得不便捷。

有鑑於此，Spring Boot提供了一種覆寫application.properties配置檔案中鍵值的方法，在命令列通過指定引數來實現覆寫——在執行時把命令列引數當作標準的系統屬性，如下：

java -jar -Dlogging.path=/tmp myapp.jar
複製程式碼

後，還可以在命令列呼叫Spring Boot的Maven外掛時覆寫這個值。但是，直接使用系統屬性對於外掛方式是無效的。需要使用run.jvmArguments引數來指定系統屬性，設定想要的值：

mvn spring-boot:run -Drun.jvmArguments="-Dlogging.path=/tmp"複製程式碼