SpringBoot教程——檢視閱讀

2020 年 5 月 21 日
筆記
springboot

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="//maven.apache.org/POM/4.0.0"
         xmlns:xsi="//www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="//maven.apache.org/POM/4.0.0 //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!";
    }
}

請求：//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靜態頁面。項目啟動後，我們都可以直接訪問這些頁面。

//請求
//localhost:8080/index.html
//localhost:8080/img/test.gif
//localhost:8080/hello.html //在public和resources文件夾下都有，優先訪問resources下的靜態資源
//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":"[email protected]","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="//maven.apache.org/POM/4.0.0"
         xmlns:xsi="//www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="//maven.apache.org/POM/4.0.0 //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="//java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "//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頁面。如下：

請求://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"
        "//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
//localhost:8080/user/load
從redis獲取緩存數據
//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>

        <!-- 緩存坐標 -->
        <!-- //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="//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），本金翻倍的規律。

Tags: springboot