瞭解Spring Boot

0.學習目標

• 瞭解SpringBoot的作用

• 掌握java配置的方式

• 瞭解SpringBoot自動配置原理

• 掌握SpringBoot的基本使用

• 瞭解Thymeleaf的基本使用

 

1. 瞭解SpringBoot

在這一部分，我們主要了解以下3個問題：

• 什麼是SpringBoot

• 爲什麼要學習SpringBoot

• SpringBoot的特點

1.1.什麼是SpringBoot

SpringBoot是Spring項目中的一個子工程，與我們所熟知的Spring-framework 同屬於spring的產品:

 

我們可以看到下面的一段介紹：

Takes an opinionated view of building production-ready Spring applications. Spring Boot favors convention over configuration and is designed to get you up and running as quickly as possible.

翻譯一下：

用一些固定的方式來構建生產級別的spring應用。Spring Boot 推崇約定大於配置的方式以便於你能夠儘可能快速的啓動並運行程序。

其實人們把Spring Boot 稱爲搭建程序的腳手架。其最主要作用就是幫我們快速的構建龐大的spring項目，並且儘可能的減少一切xml配置，做到開箱即用，迅速上手，讓我們關注與業務而非配置。

 

1.2.爲什麼要學習SpringBoot

java一直被人詬病的一點就是臃腫、麻煩。當我們還在辛苦的搭建項目時，可能Python程序員已經把功能寫好了，究其原因注意是兩點：

• 複雜的配置，

  項目各種配置其實是開發時的損耗， 因爲在思考 Spring 特性配置和解決業務問題之間需要進行思維切換，所以寫配置擠佔了寫應用程序邏輯的時間。

• 一個是混亂的依賴管理。

  項目的依賴管理也是件喫力不討好的事情。決定項目裏要用哪些庫就已經夠讓人頭痛的了，你還要知道這些庫的哪個版本和其他庫不會有衝突，這難題實在太棘手。並且，依賴管理也是一種損耗，添加依賴不是寫應用程序代碼。一旦選錯了依賴的版本，隨之而來的不兼容問題毫無疑問會是生產力殺手。

 

而SpringBoot讓這一切成爲過去！

Spring Boot 簡化了基於Spring的應用開發，只需要“run”就能創建一個獨立的、生產級別的Spring應用。Spring Boot爲Spring平臺及第三方庫提供開箱即用的設置（提供默認設置，存放默認配置的包就是啓動器），這樣我們就可以簡單的開始。多數Spring Boot應用只需要很少的Spring配置。

我們可以使用SpringBoot創建java應用，並使用java –jar 啓動它，就能得到一個生產級別的web工程。

1.3.SpringBoot的特點

Spring Boot 主要目標是：

• 爲所有 Spring 的開發者提供一個非常快速的、廣泛接受的入門體驗

• 開箱即用（啓動器starter-其實就是SpringBoot提供的一個jar包），但通過自己設置參數（.properties），即可快速擺脫這種方式。

• 提供了一些大型項目中常見的非功能性特性，如內嵌服務器、安全、指標，健康檢測、外部化配置等

• 絕對沒有代碼生成，也無需 XML 配置。

更多細節，大家可以到官網查看。

 

 

2.快速入門

接下來，我們就來利用SpringBoot搭建一個web工程，體會一下SpringBoot的魅力所在！

2.1.創建工程

我們先新建一個空的工程：

 

 

工程名爲demo：

 

新建一個model：

 

使用maven來構建：

 

然後填寫項目座標：

 

目錄結構：

 

項目結構：

 

2.2.添加依賴

看到這裏很多同學會有疑惑，前面說傳統開發的問題之一就是依賴管理混亂，怎麼這裏我們還需要管理依賴呢？難道SpringBoot不幫我們管理嗎？

彆着急，現在我們的項目與SpringBoot還沒有什麼關聯。SpringBoot提供了一個名爲spring-boot-starter-parent的工程，裏面已經對各種常用依賴（並非全部）的版本進行了管理，我們的項目需要以這個項目爲父工程，這樣我們就不用操心依賴的版本問題了，需要什麼依賴，直接引入座標即可！

2.2.1.添加父工程座標

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
    </parent>

2.2.2.添加web啓動器

爲了讓SpringBoot幫我們完成各種自動配置，我們必須引入SpringBoot提供的自動配置依賴，我們稱爲啓動器。因爲我們是web項目，這裏我們引入web啓動器：

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

需要注意的是，我們並沒有在這裏指定版本信息。因爲SpringBoot的父工程已經對版本進行了管理了。

這個時候，我們會發現項目中多出了大量的依賴：

 

這些都是SpringBoot根據spring-boot-starter-web這個依賴自動引入的，而且所有的版本都已經管理好，不會出現衝突。

2.2.3.管理jdk版本

默認情況下，maven工程的jdk版本是1.5，而我們開發使用的是1.8，因此這裏我們需要修改jdk版本，只需要簡單的添加以下屬性即可：

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

2.2.4.完整pom

<?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.leyou.demo</groupId>
    <artifactId>springboot-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
​
    <properties>
        <java.version>1.8</java.version>
    </properties>
​
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
    </parent>
​
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

 

2.3.啓動類

Spring Boot項目通過main函數即可啓動，我們需要創建一個啓動類：

 

然後編寫main函數：

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

2.4.編寫controller

接下來，我們就可以像以前那樣開發SpringMVC的項目了！

我們編寫一個controller：

 

代碼：

@RestController
public class HelloController {
​
    @GetMapping("hello")
    public String hello(){
        return "hello, spring boot!";
    }
}
​

2.5.啓動測試

接下來，我們運行main函數，查看控制檯：

 

並且可以看到監聽的端口信息：

 

• 1）監聽的端口是8080

• 2）SpringMVC的映射路徑是：/

• 3）/hello路徑已經映射到了HelloController中的hello()方法

打開頁面訪問：http://localhost:8080/hello

 

 

測試成功了！

3.Java配置

在入門案例中，我們沒有任何的配置，就可以實現一個SpringMVC的項目了，快速、高效！

但是有同學會有疑問，如果沒有任何的xml，那麼我們如果要配置一個Bean該怎麼辦？比如我們要配置一個數據庫連接池，以前會這麼玩：

<!-- 配置連接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
      init-method="init" destroy-method="close">
    <property name="url" value="${jdbc.url}" />
    <property name="username" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
</bean>

現在該怎麼做呢？

 

3.1.回顧歷史

事實上，在Spring3.0開始，Spring官方就已經開始推薦使用java配置來代替傳統的xml配置了，我們不妨來回顧一下Spring的歷史：

• Spring1.0時代

  在此時因爲jdk1.5剛剛出來，註解開發並未盛行，因此一切Spring配置都是xml格式，想象一下所有的bean都用xml配置，細思極恐啊，心疼那個時候的程序員2秒

• Spring2.0時代

  Spring引入了註解開發，但是因爲並不完善，因此並未完全替代xml，此時的程序員往往是把xml與註解進行結合，貌似我們之前都是這種方式。

• Spring3.0及以後

  3.0以後Spring的註解已經非常完善了，因此Spring推薦大家使用完全的java配置來代替以前的xml，不過似乎在國內並未推廣盛行。然後當SpringBoot來臨，人們才慢慢認識到java配置的優雅。

有句古話說的好：擁抱變化，擁抱未來。所以我們也應該順應時代潮流，做時尚的弄潮兒，一起來學習下java配置的玩法。

3.2.嘗試java配置

java配置主要靠java類和一些註解，比較常用的註解有：

• @Configuration：聲明一個類作爲配置類，代替xml文件

• @Bean：聲明在方法上，將方法的返回值加入Bean容器，代替<bean>標籤

• @value：屬性注入

• @PropertySource：指定外部屬性文件，

我們接下來用java配置來嘗試實現連接池配置：

首先引入Druid連接池依賴：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.6</version>
</dependency>

創建一個jdbc.properties文件，編寫jdbc屬性：

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/leyou
jdbc.username=root
jdbc.password=123

然後編寫代碼：

@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {

    @Value("${jdbc.url}")
    String url;
    @Value("${jdbc.driverClassName}")
    String driverClassName;
    @Value("${jdbc.username}")
    String username;
    @Value("${jdbc.password}")
    String password;

    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(url);
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

解讀：

• @Configuration：聲明我們JdbcConfig是一個配置類

• @PropertySource：指定屬性文件的路徑是:classpath:jdbc.properties

• 通過@Value爲屬性注入值

• 通過@Bean將 dataSource()方法聲明爲一個註冊Bean的方法，Spring會自動調用該方法，將方法的返回值加入Spring容器中。

然後我們就可以在任意位置通過@Autowired注入DataSource了！

 

我們在HelloController中測試：

@RestController
public class HelloController {

    @Autowired
    private DataSource dataSource;

    @GetMapping("hello")
    public String hello() {
        return "hello, spring boot!" + dataSource;
    }
}

然後Debug運行並查看：

 

屬性注入成功了！

 

3.3.SpringBoot的屬性注入

在上面的案例中，我們實驗了java配置方式。不過屬性注入使用的是@Value註解。這種方式雖然可行，但是不夠強大，因爲它只能注入基本類型值。

在SpringBoot中，提供了一種新的屬性注入方式，支持各種java基本數據類型及複雜類型的注入。

1）我們新建一個類，用來進行屬性注入：

@ConfigurationProperties(prefix = "jdbc")
public class JdbcProperties {
    private String url;
    private String driverClassName;
    private String username;
    private String password;
    // ... 略
    // getters 和 setters
}

• 在類上通過@ConfigurationProperties註解聲明當前類爲屬性讀取類

• prefix="jdbc"讀取屬性文件中，前綴爲jdbc的值。

• 在類上定義各個屬性，名稱必須與屬性文件中jdbc.後面部分一致

• 需要注意的是，這裏我們並沒有指定屬性文件的地址，所以我們需要把jdbc.properties名稱改爲application.properties，這是SpringBoot默認讀取的屬性文件名：

   

2）在JdbcConfig中使用這個屬性：

@Configuration
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfig {

    @Bean
    public DataSource dataSource(JdbcProperties jdbc) {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(jdbc.getUrl());
        dataSource.setDriverClassName(jdbc.getDriverClassName());
        dataSource.setUsername(jdbc.getUsername());
        dataSource.setPassword(jdbc.getPassword());
        return dataSource;
    }
}

• 通過@EnableConfigurationProperties(JdbcProperties.class)來聲明要使用JdbcProperties這個類的對象

• 然後你可以通過以下方式注入JdbcProperties：

  • @Autowired注入

    @Autowired
    private JdbcProperties prop;
    

  • 構造函數注入

    private JdbcProperties prop;
    public JdbcConfig(Jdbcproperties prop){
        this.prop = prop;
    }
    

  • 聲明有@Bean的方法參數注入

    @Bean
    public Datasource dataSource(JdbcProperties prop){
        // ...
    }
    

本例中，我們採用第三種方式。

3）測試結果：

 

 

大家會覺得這種方式似乎更麻煩了，事實上這種方式有更強大的功能，也是SpringBoot推薦的注入方式。兩者對比關係：

 

優勢：

• Relaxed binding：鬆散綁定

  • 不嚴格要求屬性文件中的屬性名與成員變量名一致。支持駝峯，中劃線，下劃線等等轉換，甚至支持對象引導。比如：user.friend.name：代表的是user對象中的friend屬性中的name屬性，顯然friend也是對象。@value註解就難以完成這樣的注入方式。

  • meta-data support：元數據支持，幫助IDE生成屬性提示（寫開源框架會用到）。

     

3.4、更優雅的注入

事實上，如果一段屬性只有一個Bean需要使用，我們無需將其注入到一個類（JdbcProperties）中。而是直接在需要的地方聲明即可：

@Configuration
public class JdbcConfig {
    
    @Bean
    // 聲明要注入的屬性前綴，SpringBoot會自動把相關屬性通過set方法注入到DataSource中
    @ConfigurationProperties(prefix = "jdbc")
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        return dataSource;
    }
}

我們直接把@ConfigurationProperties(prefix = "jdbc")聲明在需要使用的@Bean的方法上，然後SpringBoot就會自動調用這個Bean（此處是DataSource）的set方法，然後完成注入。使用的前提是：該類必須有對應屬性的set方法！

我們將jdbc的url改成：/heima，再次測試：

 

 

4.自動配置原理

使用SpringBoot之後，一個整合了SpringMVC的WEB工程開發，變的無比簡單，那些繁雜的配置都消失不見了，這是如何做到的？

一切魔力的開始，都是從我們的main函數來的，所以我們再次來看下啓動類：

 

我們發現特別的地方有兩個：

• 註解：@SpringBootApplication

• run方法：SpringApplication.run()

我們分別來研究這兩個部分。

4.1.瞭解@SpringBootApplication

點擊進入，查看源碼：

 

這裏重點的註解有3個：

• @SpringBootConfiguration

• @EnableAutoConfiguration

• @ComponentScan

4.1.1.@SpringBootConfiguration

我們繼續點擊查看源碼：

 

通過這段我們可以看出，在這個註解上面，又有一個@Configuration註解。通過上面的註釋閱讀我們知道：這個註解的作用就是聲明當前類是一個配置類，然後Spring會自動掃描到添加了@Configuration的類，並且讀取其中的配置信息。而@SpringBootConfiguration是來聲明當前類是SpringBoot應用的配置類，項目中只能有一個。所以一般我們無需自己添加。

 

4.1.2.@EnableAutoConfiguration

關於這個註解，官網上有一段說明：

The second class-level annotation is @EnableAutoConfiguration. This annotation tells Spring Boot to “guess” how you want to configure Spring, based on the jar dependencies that you have added. Since spring-boot-starter-web added Tomcat and Spring MVC, the auto-configuration assumes that you are developing a web application and sets up Spring accordingly.

簡單翻譯以下：

第二級的註解@EnableAutoConfiguration，告訴SpringBoot基於你所添加的依賴，去“猜測”你想要如何配置Spring。比如我們引入了spring-boot-starter-web，而這個啓動器中幫我們添加了tomcat、SpringMVC的依賴。此時自動配置就知道你是要開發一個web應用，所以就幫你完成了web及SpringMVC的默認配置了！

總結，SpringBoot內部對大量的第三方庫或Spring內部庫進行了默認配置，這些配置是否生效，取決於我們是否引入了對應庫所需的依賴，如果有那麼默認配置就會生效。

所以，我們使用SpringBoot構建一個項目，只需要引入所需框架的依賴，配置就可以交給SpringBoot處理了。除非你不希望使用SpringBoot的默認配置，它也提供了自定義配置的入口。

 

4.1.3.@ComponentScan

我們跟進源碼：

 

並沒有看到什麼特殊的地方。我們查看註釋：

 

大概的意思：

配置組件掃描的指令。提供了類似與<context:component-scan>標籤的作用

通過basePackageClasses或者basePackages屬性來指定要掃描的包。如果沒有指定這些屬性，那麼將從聲明這個註解的類所在的包開始，掃描包及子包

而我們的@SpringBootApplication註解聲明的類就是main函數所在的啓動類，因此掃描的包是該類所在包及其子包。因此，一般啓動類會放在一個比較前的包目錄中。

 

4.2.默認配置原理

4.2.1默認配置類

通過剛纔的學習，我們知道@EnableAutoConfiguration會開啓SpringBoot的自動配置，並且根據你引入的依賴來生效對應的默認配置。那麼問題來了：

• 這些默認配置是在哪裏定義的呢？

• 爲何依賴引入就會觸發配置呢？

其實在我們的項目中，已經引入了一個依賴：spring-boot-autoconfigure，其中定義了大量自動配置類：

 

還有：

 

非常多，幾乎涵蓋了現在主流的開源框架，例如：

• redis

• jms

• amqp

• jdbc

• jackson

• mongodb

• jpa

• solr

• elasticsearch

... 等等

我們來看一個我們熟悉的，例如SpringMVC，查看mvc 的自動配置類：

 

打開WebMvcAutoConfiguration：

 

我們看到這個類上的4個註解：

• @Configuration：聲明這個類是一個配置類

• @ConditionalOnWebApplication(type = Type.SERVLET)

  ConditionalOn，翻譯就是在某個條件下，此處就是滿足項目的類是是Type.SERVLET類型，也就是一個普通web工程，顯然我們就是

• @ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })

  這裏的條件是OnClass，也就是滿足以下類存在：Servlet、DispatcherServlet、WebMvcConfigurer，其中Servlet只要引入了tomcat依賴自然會有，後兩個需要引入SpringMVC纔會有。這裏就是判斷你是否引入了相關依賴，引入依賴後該條件成立，當前類的配置纔會生效！

• @ConditionalOnMissingBean(WebMvcConfigurationSupport.class)

  這個條件與上面不同，OnMissingBean，是說環境中沒有指定的Bean這個才生效。其實這就是自定義配置的入口，也就是說，如果我們自己配置了一個WebMVCConfigurationSupport的類，那麼這個默認配置就會失效！

接着，我們查看該類中定義了什麼：

視圖解析器：

 

處理器適配器（HandlerAdapter）：

 

還有很多，這裏就不一一截圖了。

4.2.2.默認配置屬性

另外，這些默認配置的屬性來自哪裏呢？

 

我們看到，這裏通過@EnableAutoConfiguration註解引入了兩個屬性：WebMvcProperties和ResourceProperties。這不正是SpringBoot的屬性注入玩法嘛。

我們查看這兩個屬性類：

 

找到了內部資源視圖解析器的prefix和suffix屬性。

ResourceProperties中主要定義了靜態資源（.js,.html,.css等)的路徑：

 

如果我們要覆蓋這些默認屬性，只需要在application.properties中定義與其前綴prefix和字段名一致的屬性即可。

4.3.總結

SpringBoot爲我們提供了默認配置，而默認配置生效的條件一般有兩個：

• 你引入了相關依賴

• 你自己沒有配置

1）啓動器

所以，我們如果不想配置，只需要引入依賴即可，而依賴版本我們也不用操心，因爲只要引入了SpringBoot提供的stater（啓動器），就會自動管理依賴及版本了。

因此，玩SpringBoot的第一件事情，就是找啓動器，SpringBoot提供了大量的默認啓動器，參考課前資料中提供的《SpringBoot啓動器.txt》

2）全局配置

另外，SpringBoot的默認配置，都會讀取默認屬性，而這些屬性可以通過自定義application.properties文件來進行覆蓋。這樣雖然使用的還是默認配置，但是配置中的值改成了我們自定義的。

因此，玩SpringBoot的第二件事情，就是通過application.properties來覆蓋默認屬性值，形成自定義配置。我們需要知道SpringBoot的默認屬性key，非常多，參考課前資料提供的：《SpringBoot全局屬性.md》

 

5.SpringBoot實踐

接下來，我們來看看如何用SpringBoot來玩轉以前的SSM,我們沿用之前講解SSM用到的數據庫tb_user和實體類User

5.1.整合SpringMVC

雖然默認配置已經可以使用SpringMVC了，不過我們有時候需要進行自定義配置。

5.1.1.修改端口

查看SpringBoot的全局屬性可知，端口通過以下方式配置：

# 映射端口
server.port=80

重啓服務後測試：

 

5.1.2.訪問靜態資源

現在，我們的項目是一個jar工程，那麼就沒有webapp，我們的靜態資源該放哪裏呢？

回顧我們上面看的源碼，有一個叫做ResourceProperties的類，裏面就定義了靜態資源的默認查找路徑：

 

默認的靜態資源路徑爲：

• classpath:/META-INF/resources/

• classpath:/resources/

• classpath:/static/

• classpath:/public

只要靜態資源放在這些目錄中任何一個，SpringMVC都會幫我們處理。

我們習慣會把靜態資源放在classpath:/static/目錄下。我們創建目錄，並且添加一些靜態資源：

 

重啓項目後測試：

 

 

5.1.3.添加攔截器

攔截器也是我們經常需要使用的，在SpringBoot中該如何配置呢？

攔截器不是一個普通屬性，而是一個類，所以就要用到java配置方式了。在SpringBoot官方文檔中有這麼一段說明：

If you want to keep Spring Boot MVC features and you want to add additional MVC configuration (interceptors, formatters, view controllers, and other features), you can add your own @Configuration class of type WebMvcConfigurer but without @EnableWebMvc. If you wish to provide custom instances of RequestMappingHandlerMapping, RequestMappingHandlerAdapter, or ExceptionHandlerExceptionResolver, you can declare a WebMvcRegistrationsAdapter instance to provide such components.

If you want to take complete control of Spring MVC, you can add your own @Configuration annotated with @EnableWebMvc.

翻譯：

如果你想要保持Spring Boot 的一些默認MVC特徵，同時又想自定義一些MVC配置（包括：攔截器，格式化器, 視圖控制器、消息轉換器 等等），你應該讓一個類實現WebMvcConfigurer，並且添加@Configuration註解，但是千萬不要加@EnableWebMvc註解。如果你想要自定義HandlerMapping、HandlerAdapter、ExceptionResolver等組件，你可以創建一個WebMvcRegistrationsAdapter實例 來提供以上組件。

如果你想要完全自定義SpringMVC，不保留SpringBoot提供的一切特徵，你可以自己定義類並且添加@Configuration註解和@EnableWebMvc註解

 

總結：通過實現WebMvcConfigurer並添加@Configuration註解來實現自定義部分SpringMvc配置。

首先我們定義一個攔截器：

public class LoginInterceptor implements HandlerInterceptor {

    private Logger logger = LoggerFactory.getLogger(LoginInterceptor.class);
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        logger.debug("preHandle method is now running!");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
        logger.debug("postHandle method is now running!");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        logger.debug("afterCompletion method is now running!");
    }
}

 

然後，我們定義配置類，註冊攔截器：

@Configuration
public class MvcConfig implements WebMvcConfigurer{
    /**
     * 通過@Bean註解，將我們定義的攔截器註冊到Spring容器
     * @return
     */
    @Bean
    public LoginInterceptor loginInterceptor(){
        return new LoginInterceptor();
    }

    /**
     * 重寫接口中的addInterceptors方法，添加自定義攔截器
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 通過registry來註冊攔截器，通過addPathPatterns來添加攔截路徑
        registry.addInterceptor(this.loginInterceptor()).addPathPatterns("/**");
    }
}

結構如下：

 

接下來運行並查看日誌：

你會發現日誌中什麼都沒有，因爲我們記錄的log級別是debug，默認是顯示info以上，我們需要進行配置。

SpringBoot通過logging.level.*=debug來配置日誌級別，*填寫包名

# 設置com.leyou包的日誌級別爲debug
logging.level.com.leyou=debug

再次運行查看：

2018-05-05 17:50:01.811 DEBUG 4548 --- [p-nio-80-exec-1] com.leyou.interceptor.LoginInterceptor   : preHandle method is now running!
2018-05-05 17:50:01.854 DEBUG 4548 --- [p-nio-80-exec-1] com.leyou.interceptor.LoginInterceptor   : postHandle method is now running!
2018-05-05 17:50:01.854 DEBUG 4548 --- [p-nio-80-exec-1] com.leyou.interceptor.LoginInterceptor   : afterCompletion method is now running!

 

5.2.整合jdbc和事務

spring中的jdbc連接和事務是配置中的重要一環，在SpringBoot中該如何處理呢？

答案是不需要處理，我們只要找到SpringBoot提供的啓動器即可：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

當然，不要忘了數據庫驅動，SpringBoot並不知道我們用的什麼數據庫，這裏我們選擇MySQL：

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

至於事務，SpringBoot中通過註解來控制。就是我們熟知的@Transactional

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User queryById(Long id){
        return this.userMapper.selectByPrimaryKey(id);
    }

    @Transactional
    public void deleteById(Long id){
        this.userMapper.deleteByPrimaryKey(id);
    }
}

 

 

5.3.整合連接池

其實，在剛纔引入jdbc啓動器的時候，SpringBoot已經自動幫我們引入了一個連接池：

 

HikariCP應該是目前速度最快的連接池了，我們看看它與c3p0的對比：

 

因此，我們只需要指定連接池參數即可：

# 連接四大參數
spring.datasource.url=jdbc:mysql://localhost:3306/heima
spring.datasource.username=root
spring.datasource.password=123
# 可省略，SpringBoot自動推斷
spring.datasource.driverClassName=com.mysql.jdbc.Driver

spring.datasource.hikari.idle-timeout=60000
spring.datasource.hikari.maximum-pool-size=30
spring.datasource.hikari.minimum-idle=10

 

當然，如果你更喜歡Druid連接池，也可以使用Druid官方提供的啓動器：

<!-- Druid連接池 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.6</version>
</dependency>

而連接信息的配置與上面是類似的，只不過在連接池特有屬性上，方式略有不同：

#初始化連接數
spring.datasource.druid.initial-size=1
#最小空閒連接
spring.datasource.druid.min-idle=1
#最大活動連接
spring.datasource.druid.max-active=20
#獲取連接時測試是否可用
spring.datasource.druid.test-on-borrow=true
#監控頁面啓動
spring.datasource.druid.stat-view-servlet.allow=true

5.4.整合mybatis

5.4.1.mybatis

SpringBoot官方並沒有提供Mybatis的啓動器，不過Mybatis官網自己實現了：

<!--mybatis -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.3.2</version>
</dependency>

配置，基本沒有需要配置的：

# mybatis 別名掃描
mybatis.type-aliases-package=com.heima.pojo
# mapper.xml文件位置,如果沒有映射文件，請註釋掉
mybatis.mapper-locations=classpath:mappers/*.xml

需要注意，這裏沒有配置mapper接口掃描包，因此我們需要給每一個Mapper接口添加@Mapper註解，才能被識別。

@Mapper
public interface UserMapper {
}

 

5.4.2.通用mapper

通用Mapper的作者也爲自己的插件編寫了啓動器，我們直接引入即可：

<!-- 通用mapper -->
<dependency>
    <groupId>tk.mybatis</groupId>
    <artifactId>mapper-spring-boot-starter</artifactId>
    <version>2.0.2</version>
</dependency>

不需要做任何配置就可以使用了。

@Mapper
public interface UserMapper extends tk.mybatis.mapper.common.Mapper<User>{
}

5.5.啓動測試

將controller進行簡單改造：

@RestController
public class HelloController {

    @Autowired
    private UserService userService;

    @GetMapping("/hello")
    public User hello() {
        User user = this.userService.queryById(8L);
        return user;
    }
}

 

我們啓動項目，查看：

 

 

6.Thymeleaf快速入門

SpringBoot並不推薦使用jsp，但是支持一些模板引擎技術：

 

以前大家用的比較多的是Freemarker，但是我們今天的主角是Thymeleaf！

 

6.1.爲什麼是Thymeleaf？

簡單說， Thymeleaf 是一個跟 Velocity、FreeMarker 類似的模板引擎，它可以完全替代 JSP 。相較與其他的模板引擎，它有如下三個極吸引人的特點：

• 動靜結合：Thymeleaf 在有網絡和無網絡的環境下皆可運行，即它可以讓美工在瀏覽器查看頁面的靜態效果，也可以讓程序員在服務器查看帶數據的動態頁面效果。這是由於它支持 html 原型，然後在 html 標籤裏增加額外的屬性來達到模板+數據的展示方式。瀏覽器解釋 html 時會忽略未定義的標籤屬性，所以 thymeleaf 的模板可以靜態地運行；當有數據返回到頁面時，Thymeleaf 標籤會動態地替換掉靜態內容，使頁面動態顯示。

• 開箱即用：它提供標準和spring標準兩種方言，可以直接套用模板實現JSTL、 OGNL表達式效果，避免每天套模板、該jstl、改標籤的困擾。同時開發人員也可以擴展和創建自定義的方言。

• 多方言支持：Thymeleaf 提供spring標準方言和一個與 SpringMVC 完美集成的可選模塊，可以快速的實現表單綁定、屬性編輯器、國際化等功能。

• 與SpringBoot完美整合，SpringBoot提供了Thymeleaf的默認配置，並且爲Thymeleaf設置了視圖解析器，我們可以像以前操作jsp一樣來操作Thymeleaf。代碼幾乎沒有任何區別，就是在模板語法上有區別。

 

接下來，我們就通過入門案例來體會Thymeleaf的魅力：

 

6.2.編寫接口

編寫一個controller，返回一些用戶數據，放入模型中，等會在頁面渲染

@GetMapping("/all")
public String all(ModelMap model) {
    // 查詢用戶
    List<User> users = this.userService.queryAll();
    // 放入模型
    model.addAttribute("users", users);
    // 返回模板名稱（就是classpath:/templates/目錄下的html文件名）
    return "users";
}

 

6.3.引入啓動器

直接引入啓動器：

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

SpringBoot會自動爲Thymeleaf註冊一個視圖解析器：

 

與解析JSP的InternalViewResolver類似，Thymeleaf也會根據前綴和後綴來確定模板文件的位置：

 

• 默認前綴：classpath:/templates/

• 默認後綴：.html

所以如果我們返回視圖：users，會指向到 classpath:/templates/users.html

一般我們無需進行修改，默認即可。

6.4.靜態頁面

根據上面的文檔介紹，模板默認放在classpath下的templates文件夾，我們新建一個html文件放入其中：

 

編寫html模板，渲染模型中的數據：

注意，把html 的名稱空間，改成：xmlns:th="http://www.thymeleaf.org" 會有語法提示

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>首頁</title>
    <style type="text/css">
        table {border-collapse: collapse; font-size: 14px; width: 80%; margin: auto}
        table, th, td {border: 1px solid darkslategray;padding: 10px}
    </style>
</head>
<body>
<div style="text-align: center">
    <span style="color: darkslategray; font-size: 30px">歡迎光臨！</span>
    <hr/>
    <table class="list">
        <tr>
            <th>id</th>
            <th>姓名</th>
            <th>用戶名</th>
            <th>年齡</th>
            <th>性別</th>
            <th>生日</th>
            <th>備註</th>
        </tr>
        <tr th:each="user : ${users}">
            <td th:text="${user.id}">1</td>
            <td th:text="${user.name}">張三</td>
            <td th:text="${user.userName}">zhangsan</td>
            <td th:text="${user.age}">20</td>
            <td th:text="${user.sex} == 1 ? '男': '女'">男</td>
            <td th:text="${#dates.format(user.birthday, 'yyyy-MM-dd')}">1980-02-30</td>
            <td th:text="${user.note}">1</td>
        </tr>
    </table>
</div>
</body>
</html>

我們看到這裏使用了以下語法：

• ${} ：這個類似與el表達式，但其實是ognl的語法，比el表達式更加強大

• th-指令：th-是利用了Html5中的自定義屬性來實現的。如果不支持H5，可以用data-th-來代替

  • th:each：類似於c:foreach 遍歷集合，但是語法更加簡潔

  • th:text：聲明標籤中的文本

    • 例如<td th-text='${user.id}'>1</td>，如果user.id有值，會覆蓋默認的1

    • 如果沒有值，則會顯示td中默認的1。這正是thymeleaf能夠動靜結合的原因，模板解析失敗不影響頁面的顯示效果，因爲會顯示默認值！

6.5.測試

接下來，我們打開頁面測試一下：

 

 

6.6.模板緩存

Thymeleaf會在第一次對模板解析之後進行緩存，極大的提高了併發處理能力。但是這給我們開發帶來了不便，修改頁面後並不會立刻看到效果，我們開發階段可以關掉緩存使用：

# 開發階段關閉thymeleaf的模板緩存
spring.thymeleaf.cache=false

注意：

在Idea中，我們需要在修改頁面後按快捷鍵：Ctrl + Shift + F9 對項目進行rebuild纔可以。

eclipse中沒有測試過。

我們可以修改頁面，測試一下。