SpringBoot教程——檢視閱讀

卡斯特梅的雨傘發表於2020-05-21

Spring Boot

SpringBoot教程——檢視閱讀

參考

SpringBoot教程——一點——藍本——springboot2.1.1

SpringBoot教程——易百——springboo2.0.5.RELEASE

SpringBoot教程——w3c——springboot1.3.3.RELEASE

SpringBoot教程——C語言網——springboot2.1.6

SpringBoot教程部落格——純潔的微笑

SpringBoot教程——javaschool

SpringBoot官網

Spring Boot參考指南——翻譯

SpringBoot教程彙總——部落格專案索引

SpringBoot教程彙總——部落格專案中文索引

Spring Boot 基礎——IBM

SpringBoot教程——極客——雜亂講不好——springboo2.1.5.RELEASE

SpringBoot教程——jc2182——參考——springboo2.3.0.BUILD-SNAPSHOT

基於Spring Boot框架：Spring Boot 2.1.11.RELEASE

略讀

一點

基於spring的知識點基礎上講springboot，只說了最簡單的使用和常用的與其他框架如redis、mybatis的整合。缺點是沒有對springboot與spring原來的細節對比。

C語言中午網

講得比較詳細，有深入到springboot最重要的兩點COC和spring-boot-starter 自動配置依賴模組常用的操作，以及springboot與dubbo構建微服務的操作。

W3C

不是很好，學習起來操作不夠清晰。

javaschool

只有這個好點

spring-boot-starter 起步依賴模組列舉

SpringBoot2.02官方參考指南

沒翻譯完，質量一般，還不如直接看官網

易百

仔細講解了springboot裡的一些使用，還結合了些springcloud的東西，但比較少說與其他框架如redis、mybatis的整合。總體來說這個教程並不好，有點雜亂無章。

IBM

最簡單的hello world。

Spring Boot starter 參考頁面 :列出了其他許多 starter。

spring-boot-starter-web。基於這個 starter，Spring Boot 形成了該應用程式的以下依賴：

使用 Tomcat 作為嵌入式 Web 伺服器容器
使用 Hibernate 進行物件-關係對映 (ORM)
使用 Apache Jackson 繫結 JSON
使用 Spring MVC 作為 REST 框架

如果我們不想用tomcat，可以更改 POM 來使用 Jetty 代替 Tomcat。如果不想用hibernate，改用mybatis，也可以這樣操作。

<dependencies>
    <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>
</dependencies>

Spring Boot基礎入門

什麼是Spring Boot

Spring Boot概述

Spring Boot 是所有基於 Spring Framework 5.0 開發的專案的起點。Spring Boot 的設計是為了讓你儘可能快的跑起來 Spring 應用程式並且儘可能減少你的配置檔案。

簡化了使用Spring的難度，簡省了繁重的配置，提供了各種啟動器，開發者能快速上手。

Spring Boot的優點

使用 Spring 專案引導頁面可以在幾秒構建一個專案
方便對外輸出各種形式的服務，如 REST API、WebSocket、Web、Streaming、Tasks
非常簡潔的安全策略整合
支援關聯式資料庫和非關聯式資料庫
支援執行期內嵌容器，如 Tomcat、Jetty
強大的開發包，支援熱啟動
自動管理依賴自帶應用監控
支援各種 IDE，如 IntelliJ IDEA 、NetBeans

Spring Boot核心功能

起步依賴

起步依賴本質上是一個Maven專案物件模型（Project Object Model，POM），定義了對其他庫的傳遞依賴，這些東西加在一起即支援某項功能。

自動配置

Spring Boot的自動配置是一個執行時（更準確地說，是應用程式啟動時）的過程，考慮了眾多因素，才決定Spring配置應該用哪個，不該用哪個。該過程是Spring自動完成的。

Spring Boot快速入門

步驟：

建立一個普通的maven專案。
pom.xml匯入起步依賴。
編寫引導類

示例：

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.self</groupId>
    <artifactId>hellospringboot</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- 匯入springboot父工程. 注意：任何的SpringBoot工程都必須有的！！！ -->
    <!-- 父工程的作用：鎖定起步的依賴的版本號，並沒有真正到依賴 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.11.RELEASE</version>
    </parent>

    <dependencies>
        <!--web起步依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

</project>

引導類，或者說叫啟動類

@SpringBootApplication
public class MyBootApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyBootApplication.class,args);
    }
}

@Controller
public class HelloController {

    @RequestMapping("/hello")
    @ResponseBody
    public String sayHello(){
        return "Hello Spring Boot!";
    }
}

請求：http://localhost:8080/hello

輸出：

Spring Boot配置檔案

Spring Boot的核心是自動配置（或者叫預設配置），通過自動配置大大減少Spring專案的配置編寫。但是在實際開發中，我們仍然需要根據需求來適當修改某些必要的引數配置，這時Spring Boot提供了兩種格式的配置方便開發者進行修改。

applicaiton*.properties
application.yml（或者application.yaml）

application*.properties

Spring Boot使用了一個全域性的配置檔案application.properties，放在src/main/resources目錄下或者src/main/resources/config下。在 src/main/resources/config 下的優先順序高。Sping Boot的全域性配置檔案的作用是對一些預設配置的配置值進行修改。

Spring Boot內建屬性

示例:

編寫修改Tomcat埠屬性 :

application.properties

server.port=9000

Spring Boot內建屬性參考

自定義屬性

application.properties

server.port=9000

#自定義型別
#基本型別
name=Amy
age=21

#JavaBean型別
user.name=Amy
user.age=21

#陣列/List集合
user.list=Amy,Jack,Roy
#或者
user.list[0]=Amy
user.list[1]=Jack
user.list[2]=Roy

#Map集合
user.map={name:"Amy",age:21}
#或者
user.map.name=Amy
user.map.age=21

自定義配置怎麼取值使用，什麼場景使用？

Profile多環境配置

當應用程式需要部署到不同執行環境時，一些配置細節通常會有所不同，最簡單的比如日誌，生產日誌會將日誌級別設定為WARN或更高階別，並將日誌寫入日誌檔案，而開發的時候需要日誌級別為DEBUG，日誌輸出到控制檯即可。如果按照以前的做法，就是每次釋出的時候替換掉配置檔案，這樣太麻煩了，Spring Boot的Profile就給我們提供瞭解決方案，命令帶上引數就搞定。

步驟：

建立不同環境的application.properties檔案
每個檔案裡面的環境配置變數不同

示例：

application.properties

#啟用prod生產環境
spring.profiles.active= prod
#當profiles不同環境變數檔案裡有配置值時，application.properties裡配置的變數是會被啟用的環境如application-prod.properties裡的值所覆蓋的。
server.port=9000

application-prod.properties

server.port=9004

輸出：

application*.yml

YAML（/ˈjæməl/，尾音類似camel駱駝）是一個可讀性高，用來表達資料序列化的格式。

yml或yaml所表示的YAML Ain’t Markup Language，YAML是一種簡潔的非標記語言，檔名字尾為yml，java中經常用它描述配置檔案application.yml。YAML以資料為中心，比json/xml等更適合做配置檔案。使用空白，縮排，分行組織資料，從而使得表示更加簡潔易讀。

在yml之前使用最多的配置檔案形式是xml和properties檔案。xml檔案太過繁瑣，看過的人都知道，想要新加一個配置節點的話還需要包含在<>標籤裡；而properties配置檔案沒有了標籤，不過當你的配置有很多層級的時候，寫完之後你會發現會有大量重複的程式碼。而yml/yaml檔案結合了兩者的優勢，當你新增節點配置的時候，不需要標籤，在寫多層級配置的時候也不會產生重複程式碼。

yml格式書寫規則

大小寫敏感
使用縮排表示層級關係
禁止使用tab縮排，只能使用空格鍵
縮排長度沒有限制，只要元素對齊就表示這些元素屬於一個層級。
使用#表示註釋
字串可以不用引號標註

Spring Boot內建屬性

注意：

當application.properties和application.yml同時存在時，生效的是application.properties。

#yml檔案在寫時有提示，友好，優先選擇使用
#修改埠
server:
  port: 9090
#基本型別 注意：屬性值大小寫敏感
name: Bruce Wayne
age: 29
#JavaBean型別
user:
  name: Bruce Wayne
  age: 29
#陣列/List集合
#user:層級只能指定一個，後面的如果是在user層級下的只需要tab空格就可以了，再寫user層級則會報錯
#user:
  list: eric,jack,rose
  #下面這種寫法用@Value註解解析不了
  list:
  - Jack
  - Rose
  - Jerry
#Map集合
#user:
#yml語法格式要求key如map: 後面對應的value值必需在冒號：後面空格，否則格式錯誤
  map: {name: Bruce Wayne,age: 29}

Profile多環境配置

application.yml

#啟用test測試環境
#當profiles不同環境變數檔案裡有配置值時，application.yml裡配置的變數是會被啟用的環境如application-test.yml裡的值所覆蓋的。
#還有一點需要特別注意的是當存在application-test.properties與application-test.yml兩個並行時，生效的是application-test.properties
spring:
  profiles:
    active: test

application-test.yml

server:
  port: 9092

Spring Boot讀取配置檔案（properties和yml處理是一樣的）

Spring Boot裡面有兩個註解可以讀取application.properties或application.yml檔案的屬性值。

@Value
@ConfigurationProperties

注意：

1、不能配置user.name=Amy屬性配置，因為取不到Amy的值，取到的是計算機的使用者名稱，在這臺電腦裡我的使用者名稱是Castamere。應該是個系統預設保留的取值配置，這裡沒有深入去研究。

2、不能配置userName=Amy這個key為userName或者username的基本型別配置，否則取到的是還是計算機的使用者名稱。

@Value

基本型別

application.yml

#基本型別 
firstName: Bruce Wayne1111
age: 29

讀取：

@Controller
public class ConfigController {

    @Value("${firstName}")
    private String name;
    @Value("${age}")
    private Integer age;

    @RequestMapping("/show")
    @ResponseBody
    public String showConfig() {
        return name + " : " + age;
    }
}

JavaBean型別

#JavaBean型別
user:
  first: Bruce Wayne
  age: 31

讀取：

@Controller
public class ConfigController {
    @Value("${user.firstName}")
    private String firstName;
    @Value("${user.age}")
    private Integer age;

    @RequestMapping("/show")
    @ResponseBody
    public String showConfig() {
        return firstName + " : " + age;
    }
}

陣列/List集合

user:
  list: Jack,Rose,Jerry

讀取：

@Value("#{'${user.list}'.split(',')}")
private List<String> list;

@RequestMapping("/show")
@ResponseBody
public String showConfig() {
    return JSON.toJSONString(list);
}

Map集合

user:
#yml語法格式要求key如map: 後面對應的value值必需在冒號：後面空格，否則格式錯誤
#讀取的時候要加引號""是給@Value註解用的麼？
# map: {nickname: erci,age: 20}
  map: "{name: 'SuperMan',age: 28}"

讀取：

@Value("#{${user.map}}")
private Map<String,Object> map;

@RequestMapping("/show")
@ResponseBody
public String showConfig() {
    return JSON.toJSONString(map);
}

注意，不加引號會報錯.

#報錯：Caused by: java.lang.IllegalArgumentException: Could not resolve placeholder 'user.map' in value "#{${user.map}}"
user:
  map: {name: 'SuperMan',age: 28}

@ConfigurationProperties

注意以下幾點：

prefix：代表屬性的字首，如果user.nickname字首就是user
屬性名稱必須和properties檔案的屬性名保持一致
屬性必須提供setter方法來注入檔案的屬性值

基本型別

firstName: Bruce Wayne
age: 30

讀取：

@Controller
@ConfigurationProperties
public class ConfigurationController {

    private String firstName;
    private Integer age;

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @RequestMapping("/show")
    @ResponseBody
    public String showConfig() {
        return firstName + " : " + age;
    }
}

輸出：

//成功
Bruce Wayne : 30
//沒有setter方法來注入檔案的屬性值，不會報錯，但是沒有賦值
null : null

JavaBean型別

#JavaBean型別
user:
  firstName: Bruce
  age: 31

讀取：

@Controller
//兩種配置方式都可以
@ConfigurationProperties("user")
//@ConfigurationProperties(prefix = "user")
public class ConfigurationController {

    private String firstName;
    private Integer age;

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @RequestMapping("/show")
    @ResponseBody
    public String showConfig() {
        return firstName + " : " + age;
        //return JSON.toJSONString(list);
        //return JSON.toJSONString(map);
    }
}

Bruce : 31

陣列/List集合

#陣列/List集合
#user:層級只能指定一個，後面的如果是在user層級下的只需要tab空格就可以了，再寫user層級則會報錯
#user:
#兩種list表達方式都可以，傾下第一種
  list: Jack,Rose,Jerry
  list2:
  - Jack
  - Morty
  - Jerry

讀取：

@Controller
//兩種配置方式都可以
@ConfigurationProperties("user")
//@ConfigurationProperties(prefix = "user")
public class ConfigurationController {

    private List<String> list;

    public void setList(List<String> list) {
        this.list = list;
    }

    @RequestMapping("/show")
    @ResponseBody
    public String showConfig() {
        return JSON.toJSONString(list);
    }
}

Map集合

#Map集合
#yml語法格式要求key如map: 後面對應的value值必需在冒號：後面空格，否則格式錯誤
#讀取的時候要加引號""是給@Value註解用的麼？@ConfigurationProperties("user")讀取map不需要加引號，否則報錯，說明兩種讀取方式不同
#報錯：Caused by: java.lang.IllegalArgumentException: Could not resolve placeholder 'user.map' in value "#{${user.map}}"
  map: {name: 'SuperMan',age: 28}
#  map: "{name: 'SuperMan',age: 28}"

讀取：

@Controller
//兩種配置方式都可以
@ConfigurationProperties("user")
//@ConfigurationProperties(prefix = "user")
public class ConfigurationController {
    private Map<String,Object> map;

    public void setMap(Map<String, Object> map) {
        this.map = map;
    }
    
    @RequestMapping("/show")
    @ResponseBody
    public String showConfig() {
        return JSON.toJSONString(map);
    }
}

{"name":"SuperMan","age":28}

Spring Boot熱部署

什麼是熱部署

無法熱部署的缺點：

在實際開發過程中，每次修改程式碼就得將專案重啟，重新部署，對於一些大型應用來說，重啟時間需要花費大量的時間成本。
程式設計師開發過程中重啟緩慢影響開發。在 Java 開發領域，熱部署一直是一個難以解決的問題，目前的 Java 虛擬機器只能實現方法體的修改熱部署，對於整個類的結構修改，仍然需要重啟虛擬機器，對類重新載入才能完成更新操作。

熱部署原理

深層原理是使用了兩個ClassLoader，一個Classloader載入那些不會改變的類（第三方Jar包），另一個ClassLoader載入會更改的類，稱為restart ClassLoader,這樣在有程式碼更改的時候，原來的restart ClassLoader 被丟棄，重新建立一個restart ClassLoader，由於需要載入的類相比較少，所以實現了較快的重啟時間。

Spring Boot熱部署實現方式

Spring Boot有3種熱部署方式：

使用springloaded配置pom.xml檔案，使用mvn spring-boot:run啟動
使用springloaded本地載入啟動，配置jvm引數
使用devtools工具包，操作簡單，但是每次需要重新部署

Spring Boot使用devtools工具包實現熱部署

需要說明以下4點：

devtools可以實現頁面熱部署（即頁面修改後會立即生效，這個可以直接在application.properties檔案中配置spring.thymeleaf.cache=false來實現）
實現類檔案熱部署（類檔案修改後不會立即生效，過會兒生效）
實現對屬性檔案的熱部署。即devtools會監聽classpath下的檔案變動，並且會立即重啟應用（發生在儲存的時候）。這裡可能有疑問，為什麼還要重啟？這樣就不是熱部署啦！注意：因為其採用的虛擬機器機制，該項重啟比正常重啟會快非常多！
scope配置為true，在修改java檔案後就立即熱啟動，而且會清空Session中的資料。如果有使用者登陸的話，專案重啟後需要重新登陸。

示例：

pom.xml新增依賴:

<!--devtools熱部署-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
    <scope>true</scope>
</dependency>

application.yml新增devtools的配置 :

spring:
 devtools:
   restart:
     enabled: true  #設定開啟熱部署
     additional-paths: src/main/java #重啟目錄
     exclude: WEB-INF/**
 freemarker:
   cache: false    #頁面不載入快取，修改即時生效

修改了類檔案後，IDEA不會自動編譯，必須修改IDEA設定。

1、
File-Settings-Compiler-Build Project automatically 
2、
ctrl + shift + alt + / ，選擇Registry,勾上 Compiler autoMake allow when app running

Spring Boot訪問靜態資源

Spring Boot預設靜態資源目錄

在Spring Boot應用啟動過程中，會讀取載入一個靜態資原始檔載入路徑這個屬性

# 預設值為
spring.resources.static-locations=classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/

這個屬性的預設值代表靜態資源掃描目錄：

classpath:/META-INF/resources/ 
classpath:/resources/
classpath:/static/ 
classpath:/public/
/：當前專案的根路徑

這意味著我們可以只要把靜態資原始檔存放在以上目錄，即可以被訪問到！

需注意優先順序問題：根據前後關係確定優先順序，配置路徑在前面會優先訪問前面的靜態資源。也就是說如果classpath:/resources/目錄和classpath:/public/都有一個test.html，那麼根據預設的優先順序，會去訪問classpath:/resources/下的資源。

示例：分別建立了public、resources、static目錄，在目錄下建立html靜態頁面。專案啟動後，我們都可以直接訪問這些頁面。

//請求
http://localhost:8080/index.html
http://localhost:8080/img/test.gif
http://localhost:8080/hello.html //在public和resources資料夾下都有，優先訪問resources下的靜態資源
http://localhost:8080/success.jsp//jsp檔案訪問會直接下載，而不會去解析。

修改Spring Boot靜態資源路徑

我們可以在application.yml檔案中修改靜態資源路徑，如：

# 修改靜態資源載入路徑
spring:
  resources:
    static-locations: classpath:/download,classpath:/static/,classpath:/public/

注意：

如果按照以上寫法會覆蓋Spring Boot的預設路徑。如果希望保留預設路徑，那就要先寫上之前所有值，再最後加上新的路徑。

Spring Boot進階

Spring Boot異常處理

有5種處理方式：

Spring Boot預設異常提示。
自定義error的錯誤頁面。
@ExceptionHandler註解(Controller中自定義)。
@ControllerAdvice註解加 @ExceptionHandler註解抽取所以共用的異常處理方法。
實現HandlerExceptionResovler。

Spring Boot預設異常提示

在Spring Boot應用執行過程中難免會出現各種錯誤，預設情況下，只要出現異常，就會跳轉到Spring Boot預設錯誤提示頁面，如下：

為了給使用者更好的體驗，我們可以使用以下四種手段來優化異常捕獲的情況。

自定義error的錯誤頁面

SpringBoot應用預設已經提供一套錯誤處理機制：就是把所有後臺錯誤統一交給error請求，然後跳轉到了本身自己的錯誤提示頁面。這時，我們利用springboot的錯誤處理機制，重新建立了一個新的error.html，該頁面必須放在resources的templates目錄下。

示例：

pom.xml ——頁面用到了Thymeleaf，所以專案中需要匯入Thymeleaf的依賴。如果沒有加依賴則頁面載入失敗繼續調整到第一種springboot預設異常提示頁面上。

error.html

<head>
    <meta charset="UTF-8">
    <title th:text="${title}"></title>
</head>
<body>
<div >
    <div>
        <div>
            <p><span>頁面出現</span><span class="code" th:text="${status}"></span>錯誤,非常抱歉!</p>
            <a href="/" class="btn-back common-button">您可以點選返回首頁</a>
            <div >
                <div th:text="${#dates.format(timestamp,'yyyy-MM-dd HH:mm:ss')}"></div>
                <div>錯誤原因：</div>
                <div th:text="${message}"></div>
                <div th:text="${error}"></div>
            </div>
        </div>
    </div>
</div>
</body>

異常展示：

@ExceptionHandler註解

 /**@ExceptionHandler 註解只能作用為物件的方法上，並且在執行時有效，value() 可以指定異常類。由該註解注*釋的方法可以具有靈活的輸入引數。
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ExceptionHandler {
    Class<? extends Throwable>[] value() default {};
}

示例：

@Controller
public class HelloController {

    @Autowired
    private User user;

    @RequestMapping("/hello")
    @ResponseBody
    public String sayHello() {
        throw new NullPointerException();
        //return "Hello Spring Boot!";
    }

    @RequestMapping("/user")
    @ResponseBody
    public String helloUser() {
        int i = 10 / 0;
        return JSON.toJSONString(user);
    }

    // 處理java.lang.ArithmeticException
    @ExceptionHandler(ArithmeticException.class)
    @ResponseBody
    public String handlerArithmeticException(Exception e) {
        return "數學運算錯誤：" + e.getMessage();
    }

    // 處理java.lang.NullPointerException
    @ExceptionHandler(value = {NullPointerException.class})
    @ResponseBody
    public String handlerNullPointerException(Exception e) {
        // e:該物件包含錯誤資訊
        return "空指標錯誤：" + e;
    }
}

輸出：

@ControllerAdvice註解

剛才的@ExceptionHandler註解是用在控制器類裡面的，這樣每個控制器都需要定義相關方法，比較繁瑣。這時可以使用@ControllerAdvice來抽取所有共同的@ExceptionHandler方法，從而簡化異常方法的定義。

注意：

當業務Controller有自己的@ExceptionHandler註解處理方法時，生效的是Controller上的異常處理方法，@ControllerAdvice裡的不會生效。

示例：

@ControllerAdvice
public class CommonExceptionHandler {

    // 處理java.lang.ArithmeticException
    @ExceptionHandler(ArithmeticException.class)
    @ResponseBody
    public String handlerArithmeticException(Exception e) {
        return "數學運算錯誤1：" + e.getMessage();
    }

    // 處理java.lang.NullPointerException
    @ExceptionHandler(value = {NullPointerException.class})
    @ResponseBody
    public String handlerNullPointerException(Exception e) {
        // e:該物件包含錯誤資訊
        return "空指標錯誤1：" + e;
    }
}

輸出：

HandlerExceptionResovler

注意：

異常處理優先順序順序：Controller層異常 > @ControllerAdvice > HandlerExceptionResovler

示例：

@Configuration
public class CommonHandlerExceptionResolver implements HandlerExceptionResolver {

    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
        ModelAndView mv = new ModelAndView();
        //判斷不同異常型別，做不同處理
        if(e instanceof ArithmeticException){
            mv.setViewName("error1");
        }
        if(e instanceof NullPointerException){
            mv.setViewName("error2");
        }
        mv.addObject("error", e.toString());
        return mv;
    }
}

輸出：

Spring Boot表單資料驗證

在Spring Boot中我們經常需要對錶單資料進行合法性驗證。下面講解如何在Spring Boot中進行表單驗證。

更多校驗規則參考Spring，兩者是一樣的。

示例：

pom.xml

<dependencies>
        <!--web起步依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- 匯入thymeleaf座標 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
    </dependencies>

Pojo，新增驗證註解

public class User {

    private Integer id;

    @NotEmpty(message = "姓名不能為空")
    private String name;
    @Min(1)
    private Integer age;
    @Email(message = "郵箱地址不正確")
    private String email;
    @NotEmpty(message = "描述不能為空")
    @Length(min = 5, max = 100, message = "描述必須在5-100個字之間")
    private String desc;
    //...}

@Controller
@RequestMapping("/user")
public class UserController {
    /**
     * 跳轉到add.html
     * @return
     */
    @RequestMapping("/toAdd")
    public String toAdd() {
        return "add";
    }
    /**
     * 使用者新增
     * BindingResult: 用於封裝驗證物件（user）裡面的驗證結果
     */
    @RequestMapping("/add")
    public String add(@Valid User user, BindingResult result) {
        if (result.hasErrors()) {
            return "add";
        }
        //save
        System.out.println("儲存使用者:" + JSON.toJSONString(user));
        return "success";
    }
}

設計頁面，回顯錯誤資訊

add.html

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>使用者新增</title>
</head>
<body>
<h3>使用者新增</h3>
<form action="/user/add" method="post">
    使用者名稱：<input type="text" name="name"/><font color="red" th:errors="${user.name}"></font><br/>
    描述：<input type="text" name="desc"/><font color="red" th:errors="${user.desc}"></font><br/>
    年齡：<input type="text" name="age"/><font color="red" th:errors="${user.age}"></font><br/>
    郵箱：<input type="text" name="email"/><font color="red" th:errors="${user.email}"></font><br/>
    <input type="submit" value="儲存"/>
</form>
</body>
</html>

success.html

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>提示頁面</title>
</head>
<body>
儲存成功
</body>
</html>

儲存使用者:{"age":25,"desc":"黃金腦殿下","email":"roy@inc.com","name":"艾米"}

Spring Boot檔案上傳

示例：

\resources\static\upload.html——在靜態資原始檔夾下這樣我們就可以直接訪問靜態資源。

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>檔案上傳頁面</title>
</head>
<body>
檔案上傳頁面

<hr/>
<form action="/upload" method="post" enctype="multipart/form-data">
    請選擇檔案：<input type="file" name="fileName"/><br/>
    <input type="submit" value="開始上傳"/>
</form>
</body>
</html>

@Controller
public class UploadController {

    @RequestMapping("/upload")
    public String upload(MultipartFile fileName, HttpServletRequest request){
        //處理檔案
        System.out.println("檔案原名稱："+fileName.getOriginalFilename());
        System.out.println("檔案型別："+fileName.getContentType());
        String upload = UploadController.class.getResource("/").getFile()+"/upload";
        File file = new File(upload);
        if (!file.exists()) {
            file.mkdir();
        }
        //目標檔案傳入地址路徑+名稱
        try {
            fileName.transferTo(new File(upload + "/" + fileName.getOriginalFilename()));
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "success";
    }
}

Spring Boot檔案下載

示例：

\resources\static\download.html

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>檔案下載</title>
</head>
<body>
<h3>檔案下載</h3>
<a href="/download">下載</a>
</body>
</html>

@Controller
public class DownloadController {

    @RequestMapping("/download")
    public void download(HttpServletResponse response) throws IOException {
        InputStream inputStream = new FileInputStream(DownloadController.class.getResource("/").getFile()+"/static/img/test.gif");
        //2.輸出檔案
        //設定響應頭
        response.setHeader("Content-Disposition","attachment;filename=export.gif");
        OutputStream outputStream = response.getOutputStream();
        byte[] buff = new byte[1024];
        int lenth = 0;
        while ((lenth= inputStream.read(buff))!= -1){
            outputStream.write(buff,0,lenth);
        }
        //3.關閉資源
        outputStream.close();
        inputStream.close();
    }
}

Spring Boot原理分析

@SpringBootApplication

首先，我從引導類開始：

@SpringBootApplication
public class MyBootApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyBootApplication.class,args);
    }

}

引導類程式碼很簡單，但可以看出最關鍵的是@SpringBootApplication註解以及在main方法中執行的SpringAppliation.run()了，我們進去@SpringBootApplication的原始碼：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
  ......
}

我們看到@SpringBootApplication其實是一個複合的註解，它就是由@SpringBootConfiguration、@EnableAutoConfiguration以及@ComponentScan 三個註解組成，所以如果我們把SpringBoot啟動類改寫成如下方式，整個SpringBoot應用依然可以與之前的啟動類功能一樣：

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public class MyBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyBootApplication.class, args);
    }
}

因為我們每次新建專案時都要寫上三個註解來完成配置，這顯然太繁瑣了，SpringBoot就為我們提供了@SpringBootApplication這樣註解來簡化我們的操作。接著，我們重點分析這三個註解的作用。

@SpringBootConfiguration

我們來看@SpringBootConfiguration註解的原始碼：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
}

我們可以看到，SpringBoot為了區別@Configuration而新提供的專屬於SpringBoot的註解，功能其實和@Configuration一模一樣。而這裡的@Configuration註解對於我們來說並不陌生，它就是是個IoC容器的配置類。看到這裡，我們其實可以把SpringBoot的啟動類這樣來看就清楚了：

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class MyBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyBootApplication.class, args);
    }
}

啟動類MyBootApplication其實就是一個標準的Spring純註解下的啟動類，也並沒有什麼特殊。

@EnableAutoConfiguration

看到這個註解，我們不禁聯想出Spring 中很多以“@Enable”開頭的註解，比如：@EnableScheduling、@EnableCaching以及@EnableMBeanExport等，@EnableAutoConfiguration註解的理念和工作原理和它們其實一脈相承。簡單的來說，就是該註解藉助@Import註解的支援，Spring的IoC容器收集和註冊特定場景相關的Bean定義：

@EnableScheduling是通過@Import將Spring排程框架相關的bean都載入到IoC容器。
@EnableMBeanExport是通過@Import將JMX相關的bean定義載入到IoC容器。

而@EnableAutoConfiguration註解也是藉助@Import將所有複合配置條件的bean定義載入到IoC容器，僅此而已！@EnableAutoConfiguration註解的原始碼如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
    ...
}

這其中最關鍵的就是@Import(AutoConfigurationImportSelector.class)了，它藉助AutoConfigurationImportSelector.class可以幫助SpringBoot應用將所有符合條件的@Configuration配置類都載入到當前SpringBoot建立並使用的IoC容器，就像下圖一樣。

下面我們給出AutoConfigurationImportSelector.java的部分原始碼，來解釋和驗證上圖：

public class AutoConfigurationImportSelector
        implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware,
BeanFactoryAware, EnvironmentAware, Ordered {
    protected List<AutoConfigurationImportFilter> getAutoConfigurationImportFilters() {
        return SpringFactoriesLoader.loadFactories(AutoConfigurationImportFilter.class,
                this.beanClassLoader);
    }
    protected List<AutoConfigurationImportListener> getAutoConfigurationImportListeners() {
        return SpringFactoriesLoader.loadFactories(AutoConfigurationImportListener.class,
                this.beanClassLoader);
    }
}

以上原始碼可以看出，@EnableAutoConfiguration正是藉助SpringFactoriesLoader的支援，才能完成所有配置類的載入！

SpringFactoriesLoader

SpringFactoriesLoader屬於Spring框架專屬的一種擴充套件方案(其功能和使用方式類似於Java的SPI方案:java.util.ServiceLoader)，它的主要功能就是從指定的配置檔案META-INF/spring.factories中載入配置，spring.factories是一個非常經典的java properties檔案，內容格式是Key=Value形式，只不過這Key以及Value都非常特殊，為Java類的完整類名(Fully Qualified Name)，比如：

org.springframework.context.ApplicationListener=org.springframework.boot.autoconfigure.BackgroundPreinitializer

然後Spring框架就可以根據某個型別作為Key來查詢對應的型別名稱列表了，SpringFactories原始碼如下：

public abstract class SpringFactoriesLoader {

    private static final Log logger = LogFactory.getLog(SpringFactoriesLoader.class);

    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

    public static <T> List<T> loadFactories(Class<T> factoryClass, ClassLoader classLoader){
        ...
    }

    public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
        ...
    }
    // ...
}

對於@EnableAutoConfiguraion來說，SpringFactoriesLoader的用途和其本意稍微不同，它本意是為了提供SPI擴充套件，而在@EnableAutoConfiguration這個場景下，它更多的是提供了一種配置查詢的功能的支援，也就是根據@EnableAutoConfiguration的完整類名org.springframework.boot.autoconfigure.EnableAutoConfiguration作為Key來獲取一組對應的@Configuration類：

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.cloud.CloudServiceConnectorsAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\
org.springframework.boot.autoconfigure.elasticsearch.jest.JestAutoConfiguration,\
org.springframework.boot.autoconfigure.elasticsearch.rest.RestClientAutoConfiguration,\
org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration,\
org.springframework.boot.autoconfigure.h2.H2ConsoleAutoConfiguration,\
org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastJpaDependencyAutoConfiguration,\
org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration,\
org.springframework.boot.autoconfigure.http.codec.CodecsAutoConfiguration,\
org.springframework.boot.autoconfigure.influx.InfluxDbAutoConfiguration,\
org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration,\
org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration,\
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,\
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration,\
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
org.springframework.boot.autoconfigure.jsonb.JsonbAutoConfiguration,\
org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration,\
org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration,\
org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderValidatorAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
org.springframework.boot.autoconfigure.quartz.QuartzAutoConfiguration,\
org.springframework.boot.autoconfigure.reactor.core.ReactorCoreAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.SecurityFilterAutoConfiguration,\
org.springframework.boot.autoconfigure.security.reactive.ReactiveSecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.reactive.ReactiveUserDetailsServiceAutoConfiguration,\
org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.client.servlet.OAuth2ClientAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.client.reactive.ReactiveOAuth2ClientAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.resource.servlet.OAuth2ResourceServerAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.resource.reactive.ReactiveOAuth2ResourceServerAutoConfiguration,\
org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,\
org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration,\
org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration,\
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration,\
org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration,\
org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.HttpHandlerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.ReactiveWebServerFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.error.ErrorWebFluxAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.function.client.ClientHttpConnectorAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.function.client.WebClientAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.reactive.WebSocketReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketMessagingAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.client.WebServiceTemplateAutoConfiguration

在SpringBoot的autoconfigure依賴包中的META-INF檔案下的spring.factories檔案中，我們可以找到以上內容。

總結來說，@EnableAutoConfiguration能實現自動配置的原理就是：SpringFactoriesLoader從classpath中搜尋所有META-INF/spring.fatories檔案，並將其中Key[org.springframework.boot.autoconfigure.EnableAutoConfiguration]對應的Value配置項通過反射的方式例項化為對應的標註了@Configuration的JavaConfig形式的IoC容器配置類，然後彙總到當前使用的IoC容器中。

@ComponentScan

@ComponentScan註解在Spring Boot啟動的時候其實不是必需的！因為我們知道作為Spring框架裡的老成員，@ComponentScan的功能就是自動掃描並載入複合條件的元件或Bean定義，最終將這些Bean定義載入到當前使用的容器中。這個過程，我們可以手工單個進行註冊，不是一定要通過這個註解批量掃描和註冊，所以說@ComponentScan是非必需的。

所以，如果我們當前應用沒有任何Bean定義需要通過@ComponentScan載入到當前SpringBoot應用對應的IoC容器，那麼，去掉@ComponentScan註解，當前的SpringBoot應用依舊可以完美執行！

Spring Boot整合其他技術

Spring Boot整合Servlet

在Spring Boot應用如何我們需要編寫Servlet相關元件（包括Servlet、Filter、Listener），需要怎麼做呢？Spring Boot提供了兩種使用Servlet元件的方式：

使用@ServletComponentScan註解註冊
使用@Bean註解註解

@ServletComponentScan

注意：在引導類類必須新增@ServletComponentScan註解，該註解用於掃描應用中Servlet相關元件。

示例：

/**
 * 等同於web.xml配置
 *     <servlet>
 *         <servlet-name>helloServlet</servlet-name>
 *         <servlet-class>com.yiidian.controller.HelloServlet</servlet-class>
 *     </servlet>
 *     <servlet-mapping>
 *            <servlet-name>helloServlet</servlet-name>
 *         <url-pattern>/helloServlet</url-pattern>
 *     </servlet-mapping>
 *
 */
// @WebServlet:宣告該類為Servlet程式
@WebServlet("/hi")
//@WebServlet(name="helloServlet",urlPatterns="/hi")
public class HelloServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("HelloServlet");
        String docType = "<!DOCTYPE html> \n";
        String top = "Hello SpringBoot";
        resp.getWriter().println(docType +
                "<html>\n" +
                "<head><title>" + top + "</title></head>\n" +
                "<body bgcolor=\"#f0f0f0\">\n" +
                "<h1 align=\"center\">" + top + "</h1>\n" +
                "</body></html>");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       doGet(req,resp);
    }
}

//表示對所有servlet都執行過濾操作
//@WebFilter
//表示對路徑為/ 的servlet執行過濾操作
//@WebFilter("/")
//表示對路徑為/hi 的servlet執行過濾操作，兩種寫法都可以
@WebFilter("/hi")
//@WebFilter(filterName="HiFilter",urlPatterns="/hi")
//定義Filter過濾器
public class HiFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("HiFilter init");

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("do HiFilter before");
        //放行執行目標servlet資源
        filterChain.doFilter(servletRequest,servletResponse);
        System.out.println("do HiFilter after");
    }

    @Override
    public void destroy() {
        System.out.println("HiFilter destroy");
    }
}

//定義Listener監聽器
@WebListener
public class HiListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("ServletContext物件建立了");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("ServletContext物件消耗了");
    }
}

引導類

@SpringBootApplication
@ServletComponentScan //註冊Servlet元件
public class MyBootApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyBootApplication.class,args);
    }

}

輸出：

ServletContext物件建立了
HiFilter init
do HiFilter before
HelloServlet
do HiFilter after

注意：在測試時發現按照正確配置去寫程式碼但是一直訪問不成功。可能的原因有兩個：

IDEA的問題，一直重啟卻識別不了@ServletComponentScan去掃描servlet，導致失敗。
啟動類的@ServletComponentScan掃描預設是掃描與該啟動類同包以及其子包下的類。

@Bean

第二種方式的程式碼和第一種幾乎一樣，就是引導類的差別，引導類改為使用@Bean註解來註解Servlet、Filter和Listener。

示例：

@SpringBootApplication
public class MyBeanBootApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyBeanBootApplication.class,args);
    }
    //註冊Servlet程式
    @Bean
    public ServletRegistrationBean getServletRegistrationBean(){
        ServletRegistrationBean bean = new ServletRegistrationBean(new HelloServlet());
        bean.addUrlMappings("/hi");
        return bean;
    }
    //註冊Filter
    @Bean
    public FilterRegistrationBean getFilterRegistrationBean(){
        FilterRegistrationBean bean = new FilterRegistrationBean(new HiFilter());
        bean.addUrlPatterns("/hi");
        return bean;
    }
    //註冊Listener
    @Bean
    public ServletListenerRegistrationBean getServletListenerRegistrationBean(){
        return new ServletListenerRegistrationBean(new HiListener());
    }
}

注意：如果兩個都配置則filter和listener會執行兩遍。當使用@Bean整合Servlet時，Servlet，Filter，Listener不需要加對應的註解，因為我們在@Bean中已經把new HelloServlet()建立出來了。

Spring Boot整合JSP

示例：

<?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.self</groupId>
    <artifactId>hellospringboot</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- 匯入springboot父工程. 注意：任何的SpringBoot工程都必須有的！！！ -->
    <!-- 父工程的作用：鎖定起步的依賴的版本號，並沒有真正到依賴 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.11.RELEASE</version>
    </parent>

    <dependencies>
        <!--web起步依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.60</version>
        </dependency>
        <!--devtools熱部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
            <scope>true</scope>
        </dependency>
        <!-- jsp依賴 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>
 <!--       <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </dependency>-->
    </dependencies>
</project>

注意：Error resolving template [userlist], template might not exist or might not be accessible by any of the configured Template Resolvers.這是因為整合jsp就不能依賴thymeleaf。

org.thymeleaf.exceptions.TemplateInputException: Error resolving template [userlist], template might not exist or might not be accessible by any of the configured Template Resolvers
	at org.thymeleaf.engine.TemplateManager.resolveTemplate(TemplateManager.java:869) ~[thymeleaf-3.0.11.RELEASE.jar:3.0.11.RELEASE]
	at org.thymeleaf.engine.TemplateManager.parseAndProcess(TemplateManager.java:607) ~[thymeleaf-3.0.11.RELEASE.jar:3.0.11.RELEASE]



        <!-- 匯入thymeleaf座標 整合jsp就不能依賴thymeleaf，否則會因為請求不到頁面而報錯-->
<!--        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>-->

起步依賴tomcat。因為spring-boot-starter-web已經有spring-boot-starter-tomcat依賴了，如下，因此不再需要再依賴tomcat。

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-tomcat</artifactId>
  <version>2.1.11.RELEASE</version>
  <scope>compile</scope>
</dependency>

擴充套件：

pom中<scope></scope>一些理解
compile:預設值，表示當前依賴包，要參與當前專案的編譯，後續測試，執行時，打包
provided:代表在編譯和測試的時候用，執行，打包的時候不會打包進去
test：表示當前依賴包只參與測試時的工作：比如Junit
runtime：表示當前依賴包只參與執行週期，其他跳過了
system：從參與度和provided一致，不過被依賴項不會從maven遠端倉庫下載，而是從本地的系統拿。需要
systemPath屬性來定義路徑

配置application.yml

#springmvc檢視解析器配置
spring:
  mvc:
    view:
      prefix: /WEB-INF/jsp/  # 字首，注意最後的資料夾jsp後面要加斜槓/
      suffix: .jsp  # 字尾

@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/list")
    public String list(Model model) {
        //模擬使用者資料
        List<User> list = new ArrayList<User>();
        for (int i = 0; i < 3; i++) {
            User user = new User();
            user.setId(ThreadLocalRandom.current().nextInt());
            user.setAge(ThreadLocalRandom.current().nextInt(100));
            user.setName(UUID.randomUUID().toString());
            list.add(user);
        }
        //把資料存入model
        model.addAttribute("list", list);
        //跳轉到jsp頁面: userlist.jsp
        return "userlist";
    }
}

編寫userlist.jsp頁面

注意：Spring Boot專案並不會到templates目錄查詢JSP頁面，它是到/src/main/webapp目錄下查詢。所以我們需要建立webapp目錄，然後在裡面建立我們需要的目錄和JSP檔案。

<%@ page language="java" contentType="text/html; charset=utf-8"
         pageEncoding="utf-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>使用者列表展示</title>
</head>
<body>

<h3>使用者列表展示</h3>
<table border="1">
    <tr>
        <th>編號</th>
        <th>姓名</th>
        <th>年齡</th>
    </tr>
    <c:forEach items="${list}" var="user">
        <tr>
            <td>${user.id}</td>
            <td>${user.name}</td>
            <td>${user.age}</td>
        </tr>
    </c:forEach>
</table>
</body>
</html>

@SpringBootApplication
public class MyBootApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyBootApplication.class,args);
    }
}

修改專案執行目錄,經過測試，不修改也行，估計和IDEA版本有關。

Spring Boot應用預設情況下，會到應用的classes目錄下載入內容，因為JSP頁面並不在classes下面，所以需要把執行目錄手動改為應用的根目錄下，這樣才能載入到JSP頁面。如下：

請求:http://localhost:8080/user/list

輸出：

報錯：

如下圖，是因為application.yml配置jsp頁面解析器路徑名稱弄錯。

Spring Boot整合Thymeleaf

thymeleaf怎麼讀？英 [taim li:f] 美 [taɪm lif] 。百里香葉。

關於模板引擎

市面上主流的 Java 模板引擎有：JSP、Velocity、Freemarker、Thymeleaf。
JSP本質也是模板引擎，Spring Boot官方推薦使用“Thymeleaf”模板引擎。

模板引擎的原理

模板引擎原理圖如下，模板引擎的作用都是將模板(頁面)和資料進行整合然後輸出顯示，區別在於不同的模板使用不同的語法，如 JSP 的JSTL表示式，以及J SP 自己的表示式和語法，同理 Thymeleaf 也有自己的語法。

Spring Boot整合Thymeleaf

示例：

pom.xml匯入Thymeleaf的依賴.

<dependencies>
        <!--web起步依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- thymeleaf -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
    </dependencies>

@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/thyme")
    public String thymeLeaf(Model model){
        model.addAttribute("message","thymeLeaf show");
        //跳轉到templates/show.html
        return "show";
    }
   }

注意以下幾點：

模板檔案（即頁面）必須放在/resources/templates目錄下，否則無法渲染。
Thymeleaf標籤都是以th開頭的。

show.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>SpringBoot整合Thymeleaf</title>
</head>
<body>
<span th:text="${message}"></span>
</body>
</html>

輸出：

Thymeleaf基本語法

變數輸出

方法程式碼

//變數輸出
@RequestMapping("/demo2")
public String demo2(Model model){
	model.addAttribute("name", "張三");
	return "demo2";
}

頁面程式碼

<h3>變數輸出</h3>
<h4 th:text="${name}"></h4>
<h4 th:text="李四"></h4>

條件判斷及迭代遍歷、域物件使用、超連結

show.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>SpringBoot整合Thymeleaf</title>
</head>
<body>
<span th:text="${message}"></span>

<h3>條件判斷</h3>
<div th:if="${gender} == '男'">
    這是一位男性朋友
</div>
<div th:if="${gender} == '女'">
    這是一位女性朋友
</div>
<br/>
<div th:switch="${grade}">
    <span th:case="1">這是1的情況</span>
    <span th:case="2">這是2的情況</span>
    <span th:case="3">這是3的情況</span>
</div>
<h3>迭代遍歷</h3>
<table border="1">
    <tr>
        <td>編號</td>
        <td>姓名</td>
        <td>年齡</td>
    </tr>
    <tr th:each="user : ${list}">
        <td th:text="${user.id}"></td>
        <td th:text="${user.name}"></td>
        <td th:text="${user.age}"></td>
    </tr>
</table>
<h3>域物件資料的獲取</h3>
request: <span th:text="${#httpServletRequest.getAttribute('request')}"></span><br/>
session: <span th:text="${session.session}"></span><br/>
application: <span th:text="${application.application}"></span><br/>
<h3>超連結的語法</h3>
<a th:href="@{~/user/thyme}">訪問demo1</a><br/>

<a th:href="@{~/user/thyme(id=1,name=eric)}">訪問demo1,傳遞引數</a>
</body>
</html>

@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/thyme")
    public String thymeLeaf(Model model, HttpServletRequest request){
        model.addAttribute("message","thymeLeaf show");
        model.addAttribute("gender","男");
        model.addAttribute("grade",2);
        List<User> list = new ArrayList<User>();
        for (int i = 0; i < 3; i++) {
            User user = new User();
            user.setId(ThreadLocalRandom.current().nextInt());
            user.setAge(ThreadLocalRandom.current().nextInt(100));
            user.setName(UUID.randomUUID().toString());
            list.add(user);
        }
        //把資料存入model
        model.addAttribute("list", list);
        //request
        request.setAttribute("request", "request's data");
        //session
        request.getSession().setAttribute("session", "session's data");
        //application
        request.getSession().getServletContext().setAttribute("application", "application's data");
        //跳轉到templates/show.html
        return "show";
    }
  }

輸出：

Spring Boot整合FreeMarker

//跳過

Spring Boot整合MyBatis

前置條件：

CREATE TABLE `t_user` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '主鍵',
  `name` varchar(64) NOT NULL COMMENT '姓名',
  `dept` varchar(254) NOT NULL COMMENT '部門',
  `phone` varchar(16) NOT NULL COMMENT '電話',
  `height` decimal(10,2) DEFAULT NULL COMMENT '身高',
  `create_emp` bigint(20) NOT NULL COMMENT '建立人',
  `create_time` datetime DEFAULT NULL COMMENT '建立時間',
  `modify_emp` bigint(20) DEFAULT NULL COMMENT '修改人',
  `modify_time` datetime DEFAULT NULL COMMENT '修改時間',
  PRIMARY KEY (`id`),
  KEY `idx_name` (`name`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8 COMMENT='使用者表';

示例：

pom.xml——匯入mybatis和mysql驅動程式

<dependencies>
        <!--web起步依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--mybatis 起步依賴-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>
        <!-- MySQL 連線驅動 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>
    </dependencies>

application.yml——配置資料來源連線引數，及mybatis相關配置。

spring：
	datasource: #修改資料庫連線配置
        url: jdbc:mysql://localhost:3306/hello_mybatis?characterEncoding=UTF8
        driver-class-name: com.mysql.jdbc.Driver
        username: root
        password: 123456

# mybatis配置
mybatis:
  type-aliases-package: com.self.pojo # 別名目錄

public class User {

    private Integer id;

    @NotEmpty(message = "姓名不能為空")
    private String name;
    @Min(1)
    private Integer age;
    @Email(message = "郵箱地址不正確")
    private String email;
    @NotEmpty(message = "描述不能為空")
    @Length(min = 5, max = 100, message = "描述必須在5-100個字之間")
    private String desc;

    /**
     * 部門，帝國
     */
    private String dept;
    /**
     * 聯絡號碼
     */
    private String phone;
    /**
     * 身高
     */
    private BigDecimal height;
    /**
     * 建立人
     */
    private Long createEmp;
    /**
     * 建立時間
     */
    private Date createTime;
    /**
     * 修改人
     */
    private Long modifyEmp;
    /**
     * 修改時間
     */
    private Date modifyTime;
    //...
    }

//必須給Dao介面加上@Mapper，這樣Spring Boot在啟動時才能掃描到Dao介面，併為其生成代理物件。
@Mapper
//裝飾用，告訴spring這是個dao註冊bean,不加@Repository的話IDEA會提示這個bean無法@Autowired自動依賴
@Repository
public interface UserDao {

    public List<User> getUsers();
}

UserDao.xml——Dao對映配置，在Dao介面相同目錄下建立同名的XML檔案。

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.self.dao.UserDao">

    <!-- 查詢所有使用者 -->
    <select id="getUsers" resultType="User">
        select * from t_user where 1=1
    </select>
</mapper>

@Controller
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserDao userDao;
    
    @RequestMapping("/showAll")
    @ResponseBody
    public List<User> list(){
        //模擬使用者資料
        List<User> list = userDao.getUsers();
        return list;
    }
}

啟動類不變，輸出：

整合Spring Data JPA

示例：

pom.xml——新增Spring Data JPA的依賴

<dependencies>
        <!--web起步依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- springBoot JPA 的起步依賴 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!-- MySQL 連線驅動 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>
    </dependencies>

application.yml

spring:
  datasource: #修改資料庫連線配置
    url: jdbc:mysql://localhost:3306/mybatis?characterEncoding=UTF8
    driver-class-name: com.mysql.jdbc.Driver
    username: root
    password: root
# jpa配置
  jpa:
    show-sql: true #控制檯輸出生成的SQL語句
    generate-ddl: true # 自動建表

專案使用Spring Data JPA，所以在Pojo實體中必須新增Jpa的對映註解，和資料庫表進行一一對映。

如果pojo欄位不是一一對映，比如比資料庫多了欄位，則會導致執行失敗。

import javax.persistence.*;
@Entity
@Table(name="t_user")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    @NotEmpty(message = "姓名不能為空")
    private String name;
    /**
     * 部門，帝國
     */
    private String dept;
    /**
     * 聯絡號碼
     */
    private String phone;
    /**
     * 身高
     */
    private BigDecimal height;
    /**
     * 建立人
     */
    private Long createEmp;
    /**
     * 建立時間
     */
    private Date createTime;
    /**
     * 修改人
     */
    private Long modifyEmp;
    /**
     * 修改時間
     */
    private Date modifyTime;
//...
}

Spring Data JPA提供了兩個核心介面，我們專案中一般選擇繼承它們：

JpaRepository介面：擁有CRUD，分頁，排序等方法

JpaSpecificationExecutor介面：擁有組合條件搜尋方法

public interface UserDao extends JpaRepository<User, Integer>, JpaSpecificationExecutor {

}

@Controller
@RequestMapping("/user")
public class UserController {

  @Autowired
  private UserDao userDao;

  @RequestMapping("/showAll")
  @ResponseBody
  public List<User> list(){
      //模擬使用者資料
      List<User> list = userDao.findAll();
      return list;
  }
}

輸出：

Spring Boot整合Redis

前提：需要Windows啟動Redis Server 。

解壓redis壓縮包。

開啟一個 cmd 視窗使用 cd 命令切換安裝目錄如 E:\redis 執行：

#啟動redis伺服器
redis-server.exe redis.windows.conf

驗證redis是否啟動成功，另外開啟一個 cmd 視窗使用 cd 命令切換安裝目錄如 E:\redis 執行：

#啟動redis客戶端
redis-cli.exe -h 127.0.0.1 -p 6379
#執行命令
set name mike
get name

示例：

pom.xml——匯入Spring Data Redis依賴！

 <dependencies>
        <!--web起步依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- 配置使用 redis 啟動器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
    </dependencies>

application.yml——Spring Boot的Redis配置

#host：代表Redis服務端地址
#port：Java連線Redis的埠
#database：操作的Redis的資料庫索引
spring:
    redis:
        host: localhost # 預設localhost，需要遠端伺服器需要修改
        port: 6379  # 預設6379，如果不一致需要修改
        database: 0 # 代表連線的資料庫索引，預設為0,

在Controller注入RedisTemplate模板物件，利用它來操作Redis資料庫，這裡寫一個put方法，用於往Redis存入資料，一個get方法，從Redis獲取資料。但需要注意的時候，如果操作的Pojo物件，該Pojo必須實現java.io.Serializable介面。

@Controller
@RequestMapping("/user")
public class UserController {

    @Autowired
    private RedisTemplate redisTemplate;

    @RequestMapping("/load")
    @ResponseBody
    public String loadUsers(){
        List<User> list = userDao.findAll();
        for (User user : list) {
            redisTemplate.opsForValue().set(user.getName(),user);
        }
        return "success";
    }

    @RequestMapping(value = "/get",method = RequestMethod.GET)
    @ResponseBody
    public User getUser(String name){
       return (User) redisTemplate.opsForValue().get(name);
    }
  }

public class User implements Serializable {
    //...
}

請求：
先快取redis
http://localhost:8080/user/load
從redis獲取快取資料
http://localhost:8080/user/get?name=艾米哈珀

輸出：

報錯：Failed to serialize object using DefaultSerializer。這是因為傳輸物件沒有實現序列號介面，無法序列號。

org.springframework.data.redis.serializer.SerializationException: Cannot serialize; nested exception is org.springframework.core.serializer.support.SerializationFailedException: Failed to serialize object using DefaultSerializer; nested exception is java.lang.IllegalArgumentException: DefaultSerializer requires a Serializable payload but received an object of type [com.self.pojo.User]

Spring Boot整合EhCache

EhCache簡介

EhCache 是一個純Java的程式內快取框架，具有快速、精幹等特點，是Hibernate中預設CacheProvider。Ehcache是一種廣泛使用的開源Java分散式快取。主要面向通用快取，Java EE和輕量級容器。它具有記憶體和磁碟儲存，快取載入器，快取擴充套件，快取異常處理程式，一個gzip快取servlet過濾器，支援REST和SOAP api等特點。

配置ehcache.xml——引數說明

引數名說明
name 快取名稱
maxElementsInMemory 快取最大個數
eternal 物件是否永久有效，一但設定了，timeout將不起作用
timeToIdleSeconds 設定物件在失效前的允許閒置時間（單位：秒）。僅當eternal=false物件不是永久有效時使用，可選屬性，預設值是0，也就是可閒置時間無窮大
timeToLiveSeconds 設定物件在失效前允許存活時間（單位：秒）。最大時間介於建立時間和失效時間之間。僅當eternal=false物件不是永久有效時使用，預設是0.，也就是物件存活時間無窮大
overflowToDisk 當記憶體中物件數量達到maxElementsInMemory時，Ehcache將會物件寫到磁碟中
diskSpoolBufferSizeMB 這個引數設定DiskStore（磁碟快取）的快取區大小。預設是30MB。每個Cache都應該有自己的一個緩衝區
maxElementsOnDisk 硬碟最大快取個數
diskPersistent 是否快取虛擬機器重啟期資料
diskExpiryThreadIntervalSeconds 磁碟失效執行緒執行時間間隔，預設是120秒。
memoryStoreEvictionPolicy 當達到maxElementsInMemory限制時，Ehcache將會根據指定的策略去清理記憶體。預設策略是LRU（最近最少使用）。你可以設定為FIFO（先進先出）或是LFU（較少使用）
clearOnFlush 記憶體數量最大時是否清除

示例：

pom.xml

 <!--web起步依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--springboot 整合 junit 起步依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>2.1.6.RELEASE</version>
            <scope>test</scope>
        </dependency>

        <!-- 快取座標 -->
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-cache -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
            <version>2.1.11.RELEASE</version>
        </dependency>
        <!-- Ehcache支援 -->
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
            <version>2.10.6</version>
        </dependency>

ehcache.xml

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">

    <diskStore path="java.io.tmpdir"/>

    <!-- defaultCache： 預設配置 -->
    <defaultCache
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            maxElementsOnDisk="10000000"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
        <persistence strategy="localTempSwap"/>
    </defaultCache>

    <!-- 快取名稱為user的配置 -->
    <cache name="user"
           maxElementsInMemory="10000"
           eternal="false"
           timeToIdleSeconds="120"
           timeToLiveSeconds="120"
           maxElementsOnDisk="10000000"
           diskExpiryThreadIntervalSeconds="120"
           memoryStoreEvictionPolicy="LRU">
        <persistence strategy="localTempSwap"/>
    </cache>
</ehcache>

application.yml

#配置EhCache的配置spring:
cache:
  ehcache:
    config: ehcache.xml

引導類中需要新增@EnableCaching註解，開啟快取功能。

@SpringBootApplication
@EnableCaching // 開啟快取
public class MyBootApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyBootApplication.class,args);
    }
}

@Service
public class UserService {

    @Cacheable(value = "user",key = "#id")
    public User findById(Integer id){
        System.out.println("執行了UserService獲取User");
        User user = new User();
        user.setId(5);
        user.setName("林雨裳");
        user.setDept("艾米帝國");
        user.setPhone("911119");
        return user;
    }
}

@Cacheable的屬性：

value：對應ehcache.xml的快取配置名稱（name屬性值）

key：給快取值起個key，便於Spring內部檢索不同的快取資料。#id這個語法代表把方法形參作為key。

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = MyBootApplication.class)
public class EhCacheTest {

  @Autowired
  private UserService userService;

  @Test
  public void testCache(){
      //第一次
      System.out.println(JSON.toJSONString(userService.findById(5)));
      //第二次
      System.out.println(JSON.toJSONString(userService.findById(5)));
  }

}

輸出：

執行了UserService獲取User
{"dept":"艾米帝國","id":5,"name":"林雨裳","phone":"911119"}
{"dept":"艾米帝國","id":5,"name":"林雨裳","phone":"911119"}

從結果可以看出，第一次呼叫Service的時候，到Service內部獲取資料。但是第二次呼叫Service時已經不需要從Service獲取資料，證明第一次查詢的時候已經把Customer物件快取到EhCache中。

EhCache常用註解

註解說明
@Cacheable 主要針對方法配置，能夠根據方法的請求引數對其進行快取
@CacheConfig 統一配置本類的快取註解的屬性
@CachePut 保證方法被呼叫，又希望結果被快取。與@Cacheable區別在於是否每次都呼叫方法，常用於更新
@CacheEvict 清空快取

@Cacheable/@CachePut/@CacheEvict 主要的引數:

屬性名說明
value 快取的名稱，在 spring 配置檔案中定義，必須指定至少一個例如： @Cacheable(value=”mycache”) 或者 @Cacheable(value={”cache1”,”cache2”}
key 快取的 key，可以為空，如果指定要按照 SpEL 表示式編寫，如果不指定，則預設按照方法的所有引數進行組合例如： @Cacheable(value=”testcache”,key=”#id”)
condition 快取的條件，可以為空，使用 SpEL 編寫，返回 true 或者 false，只有為 true 才進行快取/清除快取例如：@Cacheable(value=”testcache”,condition=”#userName.length()>2”)
unless 否定快取。當條件結果為TRUE時，就不會快取。 @Cacheable(value=”testcache”,unless=”#userName.length()>2”)
allEntries (@CacheEvict ) 是否清空所有快取內容，預設為 false，如果指定為 true，則方法呼叫後將立即清空所有快取例如： @CachEvict(value=”testcache”,allEntries=true)
beforeInvocation (@CacheEvict) 是否在方法執行前就清空，預設為 false，如果指定為 true，則在方法還沒有執行的時候就清空快取，預設情況下，如果方法執行丟擲異常，則不會清空快取例如： @CachEvict(value=”testcache”，beforeInvocation=true)

具體參考一點

Spring Boot整合Junit

示例：

pom.xml

 <!--springboot 整合 junit 起步依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>2.1.6.RELEASE</version>
            <scope>test</scope>
        </dependency>

@RunWith(SpringJUnit4ClassRunner.class)
//重點是加入@SpringBootTest註解，屬性classes用於載入引導類
@SpringBootTest(classes = MyBootApplication.class)
public class JUnitTest {

    @Test
    public void test() {
        System.out.println("Hello JUnit");
    }
}

輸出：

Hello JUnit

Spring Boot整合Quartz

Quartz(石英)簡介

Quartz 是一個完全由Java 編寫的開源任務排程的框架，通過觸發器設定作業定時執行規則，控制作業的執行時間。Quartz 定時器作用很多，比如，定時傳送資訊和定時生成報表等。 Quartz 框架主要核心元件包括排程器、觸發器和作業。排程器作為作業的總指揮，觸發器作為作業的操作者，作業為應用的功能模組。其關係如圖：

示例：

pom.xml

  <!-- sping對schedule的支援 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
        <!--Quartz執行必須依賴到spring-tx包 注意：spring-boot-starter-web已經依賴了，所以不需要再依賴，只需要知道Quartz執行必須依賴到spring-tx包 -->
<!--        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>-->
        <!-- Quartz支援 -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.1</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

Job任務類——我們想實現的定時任務業務程式碼寫在這裡。

public class CheckJob {

    public void task() {
        System.out.println("校驗任務被觸發，當前時間為：" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    }

}

public class ReminderJob {

    //具體定時任務
    public void task(){
        System.out.println("呼吸提醒任務被觸發，當前時間為："+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    }
}

Quartz配置類——每個排程任務都對應一個配置類

@Configuration
public class CheckQuartzConfig {

    @Bean
    public CheckJob createCheckJob() {
        return new CheckJob();
    }

    /**
     * 建立任務
     */
    @Bean("checkJobDetail")
    public MethodInvokingJobDetailFactoryBean checkJobDetailFactoryBean(CheckJob job) {
        MethodInvokingJobDetailFactoryBean detailFactoryBean = new MethodInvokingJobDetailFactoryBean();
        //設定任務物件
        detailFactoryBean.setTargetObject(job);
        //設定任務方法
        detailFactoryBean.setTargetMethod("task");
        return detailFactoryBean;
    }
    /**
     * 觸發器
     */
    @Bean("checkTrigger")
    public CronTriggerFactoryBean createTrigger(@Qualifier("checkJobDetail") MethodInvokingJobDetailFactoryBean bean) {
        CronTriggerFactoryBean triggerFactoryBean = new CronTriggerFactoryBean();
        triggerFactoryBean.setJobDetail(bean.getObject());
         //	每天11點30分觸發執行一次
        triggerFactoryBean.setCronExpression("0 30 11 * * ? *");
        return triggerFactoryBean;
    }
    /**
     * 建立Schduler
     */
    @Bean("checkScheduler")
    public SchedulerFactoryBean createSchedulerFactoryBean(@Qualifier("checkTrigger") CronTriggerFactoryBean bean){
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        //關聯trigger
        schedulerFactoryBean.setTriggers(bean.getObject());
        return schedulerFactoryBean;
    }
}

@Configuration
public class QuartzConfig {

    @Bean
    public ReminderJob createReminderJob() {
        return new ReminderJob();
    }

    @Bean("reminderJobDetail")
    public MethodInvokingJobDetailFactoryBean reminderJobDetailFactoryBean(ReminderJob job) {
        MethodInvokingJobDetailFactoryBean detailFactoryBean = new MethodInvokingJobDetailFactoryBean();
        detailFactoryBean.setTargetObject(job);
        detailFactoryBean.setTargetMethod("task");
        return detailFactoryBean;
    }


    @Bean("reminderTrigger")
    public CronTriggerFactoryBean createTrigger(@Qualifier("reminderJobDetail") MethodInvokingJobDetailFactoryBean bean) {
        CronTriggerFactoryBean triggerFactoryBean = new CronTriggerFactoryBean();
        triggerFactoryBean.setJobDetail(bean.getObject());
         //定時任務3秒執行一次
        triggerFactoryBean.setCronExpression("0/3 * * * * ? *");
        return triggerFactoryBean;
    }

    @Bean("reminderScheduler")
    public SchedulerFactoryBean createSchedulerFactoryBean(@Qualifier("reminderTrigger") CronTriggerFactoryBean bean){
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        schedulerFactoryBean.setTriggers(bean.getObject());
        return schedulerFactoryBean;
    }
}

執行引導類。

輸出：

呼吸提醒任務被觸發，當前時間為：2020-05-21 11:29:51
呼吸提醒任務被觸發，當前時間為：2020-05-21 11:29:54
呼吸提醒任務被觸發，當前時間為：2020-05-21 11:29:57
呼吸提醒任務被觸發，當前時間為：2020-05-21 11:30:00
校驗任務被觸發，當前時間為：2020-05-21 11:30:00
呼吸提醒任務被觸發，當前時間為：2020-05-21 11:30:03
呼吸提醒任務被觸發，當前時間為：2020-05-21 11:30:06
呼吸提醒任務被觸發，當前時間為：2020-05-21 11:30:09

Cron表示式擴充套件

Cron表示式線上工具

Cron表示式教程

CronTrigger

CronTriggers往往比SimpleTrigger更有用，如果您需要基於日曆的概念，而非SimpleTrigger完全指定的時間間隔，復發的發射工作的時間表。 CronTrigger，你可以指定觸發的時間表如“每星期五中午”，或“每個工作日9:30時”，甚至“每5分鐘一班9:00和10:00逢星期一上午，星期三星期五“。即便如此，SimpleTrigger一樣，CronTrigger擁有的startTime指定的時間表時生效，指定的時間表時，應停止（可選）結束時間。

Cron表示式

cron的表示式被用來配置CronTrigger例項。 cron的表示式是字串，實際上是由七子表示式，描述個別細節的時間表。這些子表示式是分開的空白，代表：

Seconds
Minutes
Hours
Day-of-Month
Month
Day-of-Week
Year (可選欄位)

例 "0 0 12 ? * WED" 在每星期三下午12:00 執行,

個別子表示式可以包含範圍, 例如，在前面的例子裡("WED")可以替換成 "MON-FRI", "MON, WED, FRI"甚至"MON-WED,SAT". “*” 代表整個時間段.

每一個欄位都有一套可以指定有效值，如

Seconds (秒) ：可以用數字0－59 表示，

Minutes(分) ：可以用數字0－59 表示，

Hours(時) ：可以用數字0-23表示,

Day-of-Month(天) ：可以用數字1-31 中的任一一個值，但要注意一些特別的月份

Month(月) ：可以用0-11 或用字串 “JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV and DEC” 表示

Day-of-Week(每週)：可以用數字1-7表示（1 ＝星期日）或用字元口串“SUN, MON, TUE, WED, THU, FRI and SAT”表示

“/”：為特別單位，表示為“每”如“0/15”表示每隔15分鐘執行一次,“0”表示為從“0”分開始, “3/20”表示表示每隔20分鐘執行一次，“3”表示從第3分鐘開始執行

“?”：表示每月的某一天，或第周的某一天

“L”：用於每月，或每週，表示為每月的最後一天，或每個月的最後星期幾如“6L”表示“每月的最後一個星期五”

“W”：表示為最近工作日，如“15W”放在每月（day-of-month）欄位上表示為“到本月15日最近的工作日”

““#”：是用來指定“的”每月第n個工作日,例在每週（day-of-week）這個欄位中內容為"6#3" or "FRI#3" 則表示“每月第三個星期五”

常用Cron表示式

0 15 10 * * ? * 每天10點15分觸發
0 15 10 * * ? 2017 2017年每天10點15分觸發
0 * 14 * * ? 每天下午的 2點到2點59分每分觸發
0 0/5 14 * * ? 每天下午的 2點到2點59分(整點開始，每隔5分觸發)
0 0/5 14,18 * * ? 每天下午的 2點到2點59分、18點到18點59分(整點開始，每隔5分觸發)
0 0-5 14 * * ? 每天下午的 2點到2點05分每分觸發
0 15 10 ? * 6L 每月最後一週的星期五的10點15分觸發
0 15 10 ? * 6#3 每月的第三週的星期五開始觸發

Spring Boot整合Task

Spring自身有一個定時任務技術，叫Spring Task，本文講解在Spring Boot應用中如何使用Spring Task。

cron表示式複習：

序號說明必填允許值萬用字元
1 秒是 0-59 , - * /
2 分是 0-59 , - * /
3 時是 0-23 , - * /
4 日是 1-31 , - * ? / L W
5 月是 1-12 / JAN-DEC , - * /
6 周是 1-7 or SUN-SAT , - * ? / L #
7 年否 1970-2099 , - * /

：表示匹配該域的任意值。假如在Minutes域使用, 即表示每分鐘都會觸發事件。
?：只能用在DayofMonth和DayofWeek兩個域。它也匹配域的任意值，但實際不會。因為DayofMonth和DayofWeek會相互影響。例如想在每月的20日觸發排程，不管20日到底是星期幾，則只能使用如下寫法： 13 13 15 20 * ?, 其中最後一位只能用？，而不能使用，如果使用表示不管星期幾都會觸發，實際上並不是這樣。
-：表示範圍。例如在Minutes域使用5-20，表示從5分到20分鐘每分鐘觸發一次
/：斜槓前面值表示起始時間開始觸發，後面值表示每隔固定時間觸發一次。例如在Minutes域使用5/20,則意味著20分鐘觸發一次，從第5分鐘開始，5，25，45等分別觸發一次.
,：表示列出列舉值。例如：在Minutes域使用5,20，則意味著在5和20分每分鐘觸發一次。
L：表示最後，只能出現在DayofWeek和DayofMonth域。如果在DayofWeek域使用5L,意味著在最後的一個星期四觸發。
W:表示有效工作日(週一到週五),只能出現在DayofMonth域，系統將在離指定日期的最近的有效工作日觸發事件。例如：在 DayofMonth使用5W，如果5日是星期六，則將在最近的工作日：星期五，即4日觸發。如果5日是星期天，則在6日(週一)觸發；如果5日在星期一到星期五中的一天，則就在5日觸發。另外一點，W的最近尋找不會跨過月份。
LW:這兩個字元可以連用，表示在某個月最後一個工作日，即最後一個星期五。
:用於確定每個月第幾個星期幾，只能出現在DayofMonth域。例如在4#2，表示某月的第二個星期三。

示例：

pom.xml

 <dependencies>
        <!--web起步依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- sping對schedule的支援 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
    </dependencies>

//引導類必須加上@EnableScheding註解啟動SpringTask
@SpringBootApplication
@EnableScheduling // 開啟Spring Task
public class MyBootApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyBootApplication.class,args);
    }

}

@Component
public class WelcomeTask {
    //“5/20”表示每隔20秒執行一次,“5”表示為從“5”秒開始
    @Scheduled(cron = "5/20 * * * * ?")
    public void task(){
        System.out.println("歡迎任務被觸發，當前時間為："+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    }
}

輸出：

2020-05-21 14:04:33.166  INFO 17100 --- [  restartedMain] com.self.MyBootApplication               : Started MyBootApplication in 5.693 seconds (JVM running for 6.831)//啟動成功時間33秒
歡迎任務被觸發，當前時間為：2020-05-21 14:04:45
歡迎任務被觸發，當前時間為：2020-05-21 14:05:05
歡迎任務被觸發，當前時間為：2020-05-21 14:05:25
歡迎任務被觸發，當前時間為：2020-05-21 14:05:45

spring-boot整合日誌功能（logback、log4j2）

springboot為我們已經內建了log元件。

springboot內建log元件

application.yml

#在application.yml檔案中修改springboot內建日誌級別，預設是info
#方式一：
#debug: true
#方式二：
logging:
  level:
    root: debug

日誌級別從低到高為TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF，級別越高，列印的日誌越少。舉例說明：說將日誌級別設定為Debug，那麼DEBUG, INFO, WARN, ERROR, FATAL, OFF這幾類日誌都會列印。

application.properties檔案中日誌key的第三級的含義為"路徑"：

填寫root，能夠指定整個專案（包含jdk原始碼列印的日誌）的日誌級別；
填寫某個包名，能夠指定該包下所有Java檔案的日誌級別，其餘為被指定的Java檔案的日誌級別為預設級別：Info
甚至可以指定任意Java檔案

整合參考

日誌框架選型——都log4J2或者logback都差不多

springboot整合logback

springboot整合log4J2

springboot整合logback

springboot預設依賴了logback，所以不需要新增依賴。

基本配置：

#官方文件中有提到， SpringBoot 的 Logging 配置的級別有7個：TRACE , DEBUG , INFO , WARN , ERROR , FATAL , OFF
#root日誌以INFO級別輸出
logging.level.root=INFO
#springframework.web日誌以WARN級別輸出
logging.level.org.springframework.web=WARN
#hibernate日誌以ERROR級別輸出
logging.level.org.hibernate=ERROR

在resources下建立logback-spring.xml：

<?xml version="1.0" encoding="UTF-8"?>
<!-- scan 配置檔案如果發生改變，將會被重新載入  scanPeriod 檢測間隔時間-->
<configuration scan="true" scanPeriod="60 seconds" debug="false">
    <contextName>spring-boot-log</contextName>
    <include resource="org/springframework/boot/logging/logback/base.xml"/>
    <!-- 普通日誌 -->
    <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>log/spring-boot-log-info.log</file>
        <!-- 迴圈政策：基於時間建立日誌檔案 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 日誌命名:單個檔案大於128MB 按照時間+自增i 生成log檔案 -->
            <fileNamePattern>log/spring-boot-log-info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>128MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!-- 最大儲存時間：30天-->
            <maxHistory>30</maxHistory>
        </rollingPolicy>
        <append>true</append>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger Line:%-3L - %msg%n</pattern>
            <charset>utf-8</charset>
        </encoder>
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>info</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>
    <!-- 錯誤日誌 -->
    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>log/spring-boot-log-error.log</file>
        <!-- 迴圈政策：基於時間建立日誌檔案 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 日誌命名:單個檔案大於2MB 按照時間+自增i 生成log檔案 -->
            <fileNamePattern>log/spring-boot-log-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>2MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!-- 最大儲存時間：180天-->
            <maxHistory>180</maxHistory>
        </rollingPolicy>
        <append>true</append>
        <!-- 日誌格式 -->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger Line:%-3L - %msg%n</pattern>
            <charset>utf-8</charset>
        </encoder>
        <!-- 日誌級別過濾器 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 過濾的級別 -->
            <level>ERROR</level>
            <!-- 匹配時的操作：接收（記錄） -->
            <onMatch>ACCEPT</onMatch>
            <!-- 不匹配時的操作：拒絕（不記錄） -->
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>
    <!-- 控制檯 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <!-- 日誌格式 -->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level %logger Line:%-3L - %msg%n</pattern>
            <charset>utf-8</charset>
        </encoder>
        <!--此日誌appender是為開發使用，只配置最底級別，控制檯輸出的日誌級別是大於或等於此級別的日誌資訊-->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>INFO</level>
        </filter>
    </appender>
    <!-- additivity 避免執行2次 -->
    <logger name="com.itstyle"  level="INFO"  additivity="false">
        <appender-ref ref="STDOUT"/>
        <appender-ref ref="INFO_FILE"/>
        <appender-ref ref="ERROR_FILE"/>
    </logger>
    <root level="INFO">
        <appender-ref ref="STDOUT" />
        <appender-ref ref="INFO_FILE" />
        <appender-ref ref="ERROR_FILE" />
    </root>
</configuration>

springboot整合log4J2

pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions><!-- 去掉springboot預設配置 -->
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency> <!-- 引入log4j2依賴 -->
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

log4j2-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--Configuration後面的status，這個用於設定log4j2自身內部的資訊輸出，可以不設定，當設定成trace時，你會看到log4j2內部各種詳細輸出-->
<!--monitorInterval：Log4j能夠自動檢測修改配置 檔案和重新配置本身，設定間隔秒數-->
<configuration monitorInterval="5">
    <!--日誌級別以及優先順序排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->

    <!--變數配置-->
    <Properties>
        <!-- 格式化輸出：%date表示日期，%thread表示執行緒名，%-5level：級別從左顯示5個字元寬度 %msg：日誌訊息，%n是換行符-->
        <!-- %logger{36} 表示 Logger 名字最長36個字元 -->
        <property name="LOG_PATTERN" value="%date{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n" />
        <!-- 定義日誌儲存的路徑 -->
        <property name="FILE_PATH" value="logs" />
        <property name="FILE_NAME" value="hellospringboot-log" />
    </Properties>

    <appenders>

        <console name="Console" target="SYSTEM_OUT">
            <!--輸出日誌的格式-->
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <!--控制檯只輸出level及其以上級別的資訊（onMatch），其他的直接拒絕（onMismatch）-->
            <ThresholdFilter level="debug" onMatch="ACCEPT" onMismatch="DENY"/>
        </console>

        <!--檔案會列印出所有資訊，這個log每次執行程式會自動清空，由append屬性決定，適合臨時測試用-->
        <File name="Filelog" fileName="${FILE_PATH}/test.log" append="false">
            <PatternLayout pattern="${LOG_PATTERN}"/>
        </File>

        <!-- 這個會列印出所有的info及以下級別的資訊，每次大小超過size，則這size大小的日誌會自動存入按年份-月份建立的資料夾下面並進行壓縮，作為存檔-->
        <RollingFile name="RollingFileInfo" fileName="${FILE_PATH}/info.log" filePattern="${FILE_PATH}/${FILE_NAME}-INFO-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制檯只輸出level及以上級別的資訊（onMatch），其他的直接拒絕（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval屬性用來指定多久滾動一次，預設是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy屬性如不設定，則預設為最多同一資料夾下7個檔案開始覆蓋-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

        <!-- 這個會列印出所有的warn及以下級別的資訊，每次大小超過size，則這size大小的日誌會自動存入按年份-月份建立的資料夾下面並進行壓縮，作為存檔-->
        <RollingFile name="RollingFileWarn" fileName="${FILE_PATH}/warn.log" filePattern="${FILE_PATH}/${FILE_NAME}-WARN-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制檯只輸出level及以上級別的資訊（onMatch），其他的直接拒絕（onMismatch）-->
            <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval屬性用來指定多久滾動一次，預設是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy屬性如不設定，則預設為最多同一資料夾下7個檔案開始覆蓋-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

        <!-- 這個會列印出所有的error及以下級別的資訊，每次大小超過size，則這size大小的日誌會自動存入按年份-月份建立的資料夾下面並進行壓縮，作為存檔-->
        <RollingFile name="RollingFileError" fileName="${FILE_PATH}/error.log" filePattern="${FILE_PATH}/${FILE_NAME}-ERROR-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制檯只輸出level及以上級別的資訊（onMatch），其他的直接拒絕（onMismatch）-->
            <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval屬性用來指定多久滾動一次，預設是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy屬性如不設定，則預設為最多同一資料夾下7個檔案開始覆蓋-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

    </appenders>

    <!--Logger節點用來單獨指定日誌的形式，比如要為指定包下的class指定不同的日誌級別等。-->
    <!--然後定義loggers，只有定義了logger並引入的appender，appender才會生效-->
    <loggers>

        <!--過濾掉spring和mybatis的一些無用的DEBUG資訊-->
        <logger name="org.mybatis" level="info" additivity="false">
            <AppenderRef ref="Console"/>
        </logger>
        <!--監控系統資訊-->
        <!--若是additivity設為false，則 子Logger 只會在自己的appender裡輸出，而不會在 父Logger 的appender裡輸出。-->
        <Logger name="org.springframework" level="info" additivity="false">
            <AppenderRef ref="Console"/>
        </Logger>

        <root level="info">
            <appender-ref ref="Console"/>
            <appender-ref ref="Filelog"/>
            <appender-ref ref="RollingFileInfo"/>
            <appender-ref ref="RollingFileWarn"/>
            <appender-ref ref="RollingFileError"/>
        </root>
    </loggers>

</configuration>

配置引數詳解

日誌級別

機制：如果一條日誌資訊的級別大於等於配置檔案的級別，就記錄。

trace：追蹤，就是程式推進一下，可以寫個trace輸出
debug：除錯，一般作為最低階別，trace基本不用。
info：輸出重要的資訊，使用較多
warn：警告，有些資訊不是錯誤資訊，但也要給程式設計師一些提示。
error：錯誤資訊。用的也很多。
fatal：致命錯誤。

輸出源

CONSOLE（輸出到控制檯）
FILE（輸出到檔案）

格式

SimpleLayout：以簡單的形式顯示
HTMLLayout：以HTML表格顯示
PatternLayout：自定義形式顯示

PatternLayout自定義日誌佈局：

%d{yyyy-MM-dd HH:mm:ss, SSS} : 日誌生產時間,輸出到毫秒的時間
%-5level : 輸出日誌級別，-5表示左對齊並且固定輸出5個字元，如果不足在右邊補0
%c : logger的名稱(%logger)
%t : 輸出當前執行緒名稱
%p : 日誌輸出格式
%m : 日誌內容，即 logger.info("message")
%n : 換行符
%C : Java類名(%F)
%L : 行號
%M : 方法名
%l : 輸出語句所在的行數, 包括類名、方法名、檔名、行數
hostName : 本地機器名
hostAddress : 本地ip地址

Log4j2配置詳解

1、根節點Configuration

有兩個屬性:

status
monitorinterval

有兩個子節點:

Appenders
Loggers(表明可以定義多個Appender和Logger).

status用來指定log4j本身的列印日誌的級別.

monitorinterval用於指定log4j自動重新配置的監測間隔時間，單位是s,最小是5s.

2、Appenders節點

常見的有三種子節點:Console、RollingFile、File

Console節點用來定義輸出到控制檯的Appender.

name:指定Appender的名字.
target:SYSTEM_OUT 或 SYSTEM_ERR,一般只設定預設:SYSTEM_OUT.
PatternLayout:輸出格式，不設定預設為:%m%n.

File節點用來定義輸出到指定位置的檔案的Appender.

name:指定Appender的名字.
fileName:指定輸出日誌的目的檔案帶全路徑的檔名.
PatternLayout:輸出格式，不設定預設為:%m%n.

RollingFile節點用來定義超過指定條件自動刪除舊的建立新的Appender.

name:指定Appender的名字.
fileName:指定輸出日誌的目的檔案帶全路徑的檔名.
PatternLayout:輸出格式，不設定預設為:%m%n.
filePattern : 指定當發生Rolling時，檔案的轉移和重新命名規則.
Policies:指定滾動日誌的策略，就是什麼時候進行新建日誌檔案輸出日誌.
TimeBasedTriggeringPolicy:Policies子節點，基於時間的滾動策略，interval屬性用來指定多久滾動一次，預設是1 hour。modulate=true用來調整時間：比如現在是早上3am，interval是4，那麼第一次滾動是在4am，接著是8am，12am...而不是7am.
SizeBasedTriggeringPolicy:Policies子節點，基於指定檔案大小的滾動策略，size屬性用來定義每個日誌檔案的大小.
DefaultRolloverStrategy:用來指定同一個資料夾下最多有幾個日誌檔案時開始刪除最舊的，建立新的(通過max屬性)。

Loggers節點，常見的有兩種:Root和Logger.

Root節點用來指定專案的根日誌，如果沒有單獨指定Logger，那麼就會預設使用該Root日誌輸出

level:日誌輸出級別，共有8個級別，按照從低到高為：All < Trace < Debug < Info < Warn < Error < AppenderRef：Root的子節點，用來指定該日誌輸出到哪個Appender.
Logger節點用來單獨指定日誌的形式，比如要為指定包下的class指定不同的日誌級別等。
level:日誌輸出級別，共有8個級別，按照從低到高為：All < Trace < Debug < Info < Warn < Error < Fatal < OFF.
name:用來指定該Logger所適用的類或者類所在的包全路徑,繼承自Root節點.
AppenderRef：Logger的子節點，用來指定該日誌輸出到哪個Appender,如果沒有指定，就會預設繼承自Root.如果指定了，那麼會在指定的這個Appender和Root的Appender中都會輸出，此時我們可以設定Logger的additivity="false"只在自定義的Appender中進行輸出。

例項：

LoggerFactory建立Logger類。

@Component
public class WelcomeTask {
    private static final Logger logger = LoggerFactory.getLogger(UserController.class);

    //“5/20”表示每隔20秒執行一次,“5”表示為從“5”秒開始
    @Scheduled(cron = "5/5 * * * * ?")
    public void task(){
        logger.debug("進入WelcomeTask 定時任務！");
        System.out.println("歡迎任務被觸發，當前時間為："+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        logger.error("完成WelcomeTask 定時任務！");
    }
}

lombok工具簡化建立Logger類。

@Component
@Slf4j
public class WelcomeTask {
    //“5/20”表示每隔20秒執行一次,“5”表示為從“5”秒開始
    @Scheduled(cron = "5/5 * * * * ?")
    public void task(){
        log.debug("進入WelcomeTask 定時任務！");
        System.out.println("歡迎任務被觸發，當前時間為："+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        log.error("完成WelcomeTask 定時任務！");
    }
}

lombok使用參考教程。

lombok就是一個註解工具jar包，能幫助我們省略一繁雜的程式碼。

lombok使用實踐

pom.xml依賴

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.16.20</version>
</dependency>

IDEA外掛裡搜尋lombok外掛安裝，重啟。

常用註解

@Setter 註解在類或欄位，註解在類時為所有欄位生成setter方法，註解在欄位上時只為該欄位生成setter方法。
@Getter 使用方法同上，區別在於生成的是getter方法。
@ToString 註解在類，新增toString方法。
@EqualsAndHashCode 註解在類，生成hashCode和equals方法。
@NoArgsConstructor 註解在類，生成無參的構造方法。
@RequiredArgsConstructor 註解在類，為類中需要特殊處理的欄位生成構造方法，比如final和被@NonNull註解的欄位。
@AllArgsConstructor 註解在類，生成包含類中所有欄位的構造方法。
@Data 註解在類，為類的所有欄位註解@ToString、@EqualsAndHashCode、@Getter的便捷方法，同時為所有非final欄位註解@Setter。

疑問：

1、Q:軟體版本的GA 代表什麼意思？

A:GA:General Availability,正式釋出的版本，在國外都是用GA來說明release版本的 .

引申：

參考

Alpha：是內部測試版,一般不向外部發布,會有很多Bug.一般只有測試人員使用。

Beta：也是測試版，這個階段的版本會一直加入新的功能。在Alpha版之後推出。

RC：(Release　Candidate) 顧名思義麼 ! 用在軟體上就是候選版本。系統平臺上就是發行候選版本。RC版不會再加入新的功能了，主要著重於除錯。

GA:General Availability,正式釋出的版本，在國外都是用GA來說明release版本的。

RTM：(Release to Manufacture)是給工廠大量壓片的版本，內容跟正式版是一樣的，不過RTM版也有出限制、評估版的。但是和正式版本的主要程式程式碼都是一樣的。

OEM：是給計算機廠商隨著計算機販賣的，也就是隨機版。只能隨機器出貨，不能零售。只能全新安裝，不能從舊有作業系統升級。包裝不像零售版精美，通常只有一面CD和說明書(授權書)。

RVL：號稱是正式版，其實RVL根本不是版本的名稱。它是中文版/英文版文件破解出來的。

EVAL：而流通在網路上的EVAL版，與“評估版”類似，功能上和零售版沒有區別。

RTL：Retail(零售版)是真正的正式版，正式上架零售版。在安裝盤的i386資料夾裡有一個eula.txt，最後有一行EULAID，就是你的版本。比如簡體中文正式版是EULAID:WX.4_PRO_RTL_CN，繁體中文正式版是WX.4_PRO_RTL_TW。其中：如果是WX.開頭是正式版，WB.開頭是測試版。PRE，代表家庭版；PRO，代表專業版。

α、β、λ常用來表示軟體測試過程中的三個階段，α是第一階段，一般只供內部測試使用；β是第二個階段，已經消除了軟體中大部分的不完善之處，但仍有可能還存在缺陷和漏洞，一般只提供給特定的使用者群來測試使用；λ是第三個階段，此時產品已經相當成熟，只需在個別地方再做進一步的優化處理即可上市發行。

2、Q:springboot的核心功能起步依賴和自動配置詳解？

3、Q: 自定義配置怎麼取值使用，什麼場景使用？

4、Q: 每次釋出的時候替換掉配置檔案，這樣太麻煩了，Spring Boot的Profile就給我們提供瞭解決方案，命令帶上引數就搞定。是指打包命令帶上引數就能自動載入不同的環境變數配置麼？我們一般是如何打生產包或測試包部署的？怎麼通過jekeins實現不同環境的打包部署？

5、Q: yml配置檔案屬性值是大小寫敏感的麼？教程裡說是，可實際測試中並不是？怎麼理解？

#基本型別 注意：屬性值大小寫敏感
firstName: Bruce Wayne1111
age: 29

@Controller
public class ConfigController {

    @Value("${firstname}")
    private String name;
    @Value("${age}")
    private Integer age;

    @RequestMapping("/show")
    @ResponseBody
    public String showConfig() {
        return name + " : " + age;
    }
}

輸出：

Bruce Wayne1111 : 29

6、Q: 下面@Value取值的表示式怎麼理解符號#的作用？已經什麼時候可以用split()方法?

 @Value("#{'${user.list}'.split(',')}")
    private List<String> list;

7、Q: Spring Boot3種熱部署方式前兩種如何實現？

Spring Boot有3種熱部署方式：

使用springloaded配置pom.xml檔案，使用mvn spring-boot:run啟動
使用springloaded本地載入啟動，配置jvm引數
使用devtools工具包，操作簡單，但是每次需要重新部署

8、Q: 什麼是Thymeleaf ？

9、Q: @Configuration註解的作用？對於下面這個異常處理類的作用？

@Configuration
public class CommonHandlerExceptionResolver implements HandlerExceptionResolver {
}

10、Q: java註解和spring註解需要系統研究一遍。

11、Q: 啟動類SpringbootDemoApplication其實就是一個標準的Spring純註解下的啟動類。怎麼理解Spring純註解下的啟動類？

12、Q: SPI 方案？

A:SPI 全稱為 (Service Provider Interface)，即服務提供商介面，是JDK內建的一種服務提供發現機制。目前有不少框架用它來做服務的擴充套件發現，簡單來說，它就是一種動態替換發現服務實現者的機制。

Java擴充套件方法之SPI

其他：

1、COC:Convention over Configuration,即約定大於配置。

72法則

72法則指以1%的複利計息，72年後（72是約數，準確值是ln2/ln1.01），本金翻倍的規律。

Servlet 教程——檢視閱讀
2020-05-04
Servlet
JDBC教程——檢視閱讀
2020-04-25
JDBC
Spring MVC教程——檢視閱讀
2020-05-14
SpringMVC
磨刀不誤閱讀工 |《如何閱讀一本書》之基礎閱讀和檢視閱讀
2017-05-19
Java高併發系列——檢視閱讀
2020-09-11
Java
Django 原始碼閱讀筆記(基礎檢視)
2020-06-15
Django原始碼筆記
如何在Safari的閱讀檢視中開啟夜間模式?
2016-06-20
模式
《HTTP/2 基礎教程》閱讀摘要
2019-04-16
HTTP
科研基本功——高效文獻檢索與文獻閱讀保姆級教程
2020-04-04
Angular權威教程閱讀總結（1）
2018-03-27
Angular
從SpringBoot啟動，閱讀原始碼設計
2022-10-10
Spring Boot原始碼
php 檢視郵件已讀
2019-02-16
PHP
iOS10 UI教程檢視的繪製與檢視控制器和檢視
2016-11-28
iOSUI
Xamarin iOS教程之警告檢視
2015-06-23
iOS
SAP UI5 初學者教程之四：XML 檢視初探試讀版
2021-10-07
UIXML
【SpringBoot實戰】檢視技術-Thymeleaf
2022-04-23
Spring Boot
Web閱讀器開發系列教程（入門篇）
2019-03-02
Web
www.xttblog.com尚矽谷Java視訊教程_SpringBoot視訊教程
2018-04-06
JavaSpring Boot
【原始碼閱讀】AndPermission原始碼閱讀
2019-05-09
原始碼
Windows10系統下檢視硬碟讀寫速度的方法【圖文教程】
2015-07-15
Windows硬碟
iOS10 UI教程檢視的邊界與檢視的框架
2016-11-23
iOSUI框架
iOS10 UI教程檢視和子檢視的可見性
2016-11-25
iOSUI
教程-檢視的概念和基本用法
2013-08-02
Xamarin iOS教程之自定義檢視
2015-06-24
iOS
【視覺化-原始碼閱讀】antvis / g-base解讀 - 1
2022-02-22
視覺化原始碼
閱讀程式碼就像閱讀猶太法典
2011-12-07
Web閱讀器開發系列教程（Vue環境篇）
2018-10-29
WebVue
在蘋果Mac如何檢視或取消訂閱服務？
2021-02-08
蘋果Mac
閱讀-MTCNN
2019-03-09
CNN
SAP UI5 初學者教程之十四 - 嵌入檢視的使用方式試讀版
2022-01-12
UI
SAP UI5 初學者教程之五：檢視控制器初探試讀版
2021-10-10
UI
業餘草尚矽谷Java視訊教程_SpringBoot視訊教程免費下載
2018-09-10
JavaSpring Boot
如何閱讀一本書——分析閱讀Pre
2020-07-29
JDK原始碼閱讀：Object類閱讀筆記
2021-09-18
JDK原始碼Object筆記
打造web版epub閱讀器（閱讀設計）
2017-06-14
Web
iOS10 UI教程檢視除錯
2016-11-28
iOSUI除錯
Django教程（一） Django檢視與網址
2018-01-12
Django
Xamarin iOS教程之檢視顯示影像
2015-06-17
iOS

SpringBoot教程——檢視閱讀

基本型別

:用於確定每個月第幾個星期幾，只能出現在DayofMonth域。例如在4#2，表示某月的第二個星期三。

相關文章