注：文章內容來自于黑馬的虎哥，個人感覺寫的挺好的，所以只是做了簡單整理，我只是文章的搬運工！

?

# 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?配置。

更多細節，大家可以到[官網](http://projects.spring.io/spring-boot/)查看。

# 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函數：

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

## 2.4.編寫controller

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

我們編寫一個controller：

代碼：

@RestControllerpublic 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.Driverjdbc.url=jdbc:mysql://127.0.0.1:3306/leyoujdbc.username=rootjdbc.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;@Beanpublic 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`中測試：

@RestControllerpublic class HelloController {@Autowiredprivate 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 {@Beanpublic 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注入

???@Autowiredprivate JdbcProperties prop;

??-?構造函數注入

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

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

@Beanpublic Datasource dataSource(JdbcProperties prop){// ...}

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

）測試結果：

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

?

優勢：

- Relaxed binding：松散綁定

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

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

## 3.4、更優雅的注入

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

@Configurationpublic 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](https://docs.spring.io/spring/docs/5.0.5.RELEASE/spring-framework-reference/web.html#mvc) (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);@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {logger.debug("preHandle method is now running!");return true;}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {logger.debug("postHandle method is now running!");}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {logger.debug("afterCompletion method is now running!");}}

然后，我們定義配置類，注冊攔截器：

@Configurationpublic class MvcConfig implements WebMvcConfigurer{/***?通過@Bean注解，將我們定義的攔截器注冊到Spring容器* @return*/@Beanpublic LoginInterceptor loginInterceptor(){return new LoginInterceptor();}/***?重寫接口中的addInterceptors方法，添加自定義攔截器* @param registry*/@Overridepublic void addInterceptors(InterceptorRegistry registry) {//?通過registry來注冊攔截器，通過addPathPatterns來添加攔截路徑registry.addInterceptor(this.loginInterceptor()).addPathPatterns("/**");}}

結構如下：

接下來運行并查看日志：

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

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

#?設置com.leyou包的日志級別為debuglogging.level.com.leyou=debug

再次運行查看：

```verilog2018-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><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`

@Servicepublic class UserService {@Autowiredprivate UserMapper userMapper;public User queryById(Long id){return this.userMapper.selectByPrimaryKey(id);}@Transactionalpublic void deleteById(Long id){this.userMapper.deleteByPrimaryKey(id);}}

## 5.3.整合連接池

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

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

?

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

#?連接四大參數spring.datasource.url=jdbc:mysql://localhost:3306/heimaspring.datasource.username=rootspring.datasource.password=123#?可省略，SpringBoot自動推斷spring.datasource.driverClassName=com.mysql.jdbc.Driverspring.datasource.hikari.idle-timeout=60000spring.datasource.hikari.maximum-pool-size=30spring.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[官網](https://github.com/mybatis/spring-boot-starter)自己實現了：

<!--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`注解，才能被識別。

@Mapperpublic 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>

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

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

## 5.5.啟動測試

將controller進行簡單改造：

@RestControllerpublic class HelloController {@Autowiredprivate 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中沒有測試過。

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

?

總結

以上是生活随笔為你收集整理的SpringBoot入门详解源码分析的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。