农历鼠年马上就过去了，我个人也希望在2021有一个好的开始，所以2021年打算通过看一本SpringBoot的全栈开发教材来重新再认识一下SpringBoot，当下其已经成为了Java界最为流行的后端应用开发框架，通过学习这本书也是想让自己在框架的部分稍微精进一些，同时也把自己以前所学的一些杂七杂八的SpringBoot知识重新整合一下，这边文章应该会长期更新，只不过可能不会太及时，我也是看一点学一点，如果大家有需要指教的也可以一起交流，毕竟写学习笔记也是学习的一个好的基础。

第一章 SpringBoot入门

1.1 SpringBoot简介

SpringBoot目前的最新版本是2.3.5.RELEASE，在Spring官网可以查到所有版本，推荐后缀是release的稳定版，基于学习的目的我个人是比较喜欢用最新版本的详情查看Spring官网版本列举如下图所示：

SpringBoot的目前最新版本

1.2 开发第一个SpringBoot程序

我经常看到大神使用eclipse的，所以作为菜鸟主要记录一下用IDEA创建SpringBoot项目
创建项目开始选择的Spring初始化器，记得选好SDK，通常或者基本都是Java8。

创建SpringBoot项目

需要联网到官网下载最新的依赖即可，创建之前还需要填写一些项目信息包括项目描述和打包方式等等，按照正常SpringBoot的情况写就可以，创建完之后在setting中修改maven配置文件和本地仓库，然后等待项目加载完成就行。

新创建的SpringBoot项目pom文件里都会默认继承SpringBoot父依赖，然后里边就是最新的SpringBoot版本，但是这是作为一般模块来用，一般我们做项目的话会优先创建父工程，所以parent标签引入SpringBoot父依赖就不合适了，所以采用的依赖引入方式都是

    <properties>
        <java.version>1.8</java.version>
        <springboot.version>2.3.5.RELEASE</springboot.version>
        <lombok.version>1.18.16</lombok.version>
    </properties>
<!--引入SpringBoot父依赖的方式-->
        <dependencies>
            <!--springboot总依赖-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${springboot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--springbootweb-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>${springboot.version}</version>
            </dependency>
            <!--springboottest-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <version>${springboot.version}</version>
            </dependency>
            <!--lombok-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>
        </dependencies>

第一行就是直接引入SpringBoot的父依赖，type和scope的标签都是固定的，这种写法可以让我们引入SpringBoot以外的其他父依赖比如SpringCloud或者SpringCloud Alibaba等等，然而一个父依赖的标签只能引入一种父依赖
另外有一点需要注意：

<dependencyManagement>
        <dependencies>
            
        </dependencies>
</dependencyManagement>

如果我们把所有的依赖都包在dependencies标签内那么整体就成了一个声明式的依赖管理，一般父项目的pom文件中就是这么声明依赖的，而本身父项目是不会导入依赖，只是声明依赖版本，上文的properties标签就是统一声明依赖版本管理。
项目运行只需要执行application类的main方法即可。

第二章 SpringBoot基础配置

2.1 不使用spring-boot-stater-parent

这个就是上文讲过的直接导入父项目的依赖而不是使用parent标签。

2.2 @Spring BootApplication

一个标注在启动类上的注解，通过标注可以启动SpringBoot应用。

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

}

这个组合注解由3个注解组成，第一个表示配置类，第二个表示自动配置，第三个表示包扫描，也就是可以把我们在pom文件中的依赖和properties或者yml中的配置进行调用然后顺利启动程序。

2.3 定制banner

程序启动的时候在控制台打印的Spring标志是可以替换的，可以在resources目录下新建一个banner.txt，如图

banner替换

2.4 容器配置

一般SpringBoot自带Tomcat，也是web开发里最常用的web容器，将web包直接放入Tomcat就可以运行程序，SpringBoot为了简化开发在web依赖中自带有Tomcat，我们也可以在properties文件里进行配置，关于配置文件后续再讲。

server.servlet.context-path=/jump
server.port=2021
server.tomcat.uri-encoding=utf-8

一般常用的是配置端口号也就是Tomcat的运行端口还有就是项目的访问路径，注意前面加上/不然会报错，对于项目的访问路径其实配置的就是启动项目后输入IP、端口号然后加上访问路径再去访问接口。

2.5 Properties配置

作为一个快速开发的Java脚手架带给我们最直接的视觉变化就是配置的精简，只需要很少的注解或者是一个配置文件即可，注解是Java一个非常神奇的存在，很多框架借助注解的特点可以让我们的开发变得非常简便。
目前SpringBoot的版本使用两种配置文件 *.properties和 *.yml，刚初始化好的一个SpringBoot项目会帮我们自动生成properties配置文件，你也可以把它修改成properties后缀的配置文件。

2.6 配置文件的位置

配置文件的位置

如图所示，如果4个位置都有propertie配置文件，加载的顺序是1~4逐渐降低

配置文件一般写在resources目录下，properties文件的语法如下：

book.name=三国演义
book.autho=罗贯中
book.price=30

可以使用如下方法使用自定义的配置

    @Component
    @ConfigurationProperties(prefix ="book")
    public class Book {
        private String name;
        private String author;
        private Float price;
        //省略 getter/setter
    }

@ConfigurationProperties注解可以把自定义的属性加载到一个类中，然后再用@Component注解注入到IOC容器中。

2.7 YAML配置

yml文件也是常用的配置文件格式，之所以用这种是因为在引入到Java类的配置比较方便。

server:
  port: 2021
  servlet:
    context-path: /jump
  tomcat:
    uri-encoding: utf-8

以上是yml的常规配置操作，每一级别的配置都是换行前边加至少一个空格并且后边加上冒号，冒号后必须跟着一个空格。
以上是关于yml文件的简单配置，当我们需要在文件中自定义配置的时候也即复杂配置的时候yml相比properties的优势就显示出来了。例如：

senior:
 name: 和谐福
 age: 20
 id: 2
 student:
  - column: 1
    address: 重庆
  - column: 2
    address: 杭州
 favorite:
   - 篮球
   - 足球
   - 羽毛球

上图是yml文件的自定义配置，同一级别的配置前面的空格需要保持一致，“student”属性可以配置成对象，我们也可以把student中的属性加入到一个Java类中，如图：

package com.senior.study.jumpdown.config;

import lombok.Data;
import org.springframework.stereotype.Component;

/**
 * @author bjl_m
 */
@Component
@Data
/**
 * @author 白纪良
 */
public class StudentProperties {
    private Integer column;
    private String address;
}

需要加上@Component来注册到IOC容器中，需要注意的是，“column”前面的“-”表示一个元素，如果“column”前面有一个“-”但是下面的address没有那么说明整体是一个元素，也可以是一个对象，如上图的配置一个加上两个“-”那么说明“student”属性配置成一个对象类型的集合，并且其中包含有2个元素。注意“column”下面的属性不能再有“-”，如果有那就是两个对象的两个属性注入。配置之后的效果如下：

自定义yml配置

我们也可以把所有的配置都注册成为一个Java类。
注入的Java类代码如下：

package com.senior.study.jumpdown.config;

import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * @author bjl_m
 */
@Component
@ConfigurationProperties(prefix = "senior")
@Data
public class SeniorProperties {
    private Integer id;
    private String name;
    private Integer age;
    private List<String> favorite;
    private List<StudentProperties> student;

    @Autowired
    public void setStudent(List<StudentProperties> student) {
        this.student = student;
    }
}

@ConfigurationProperties(prefix = "senior")属性senior开头的自定义属性，里面的属性分别对应该配置类的所有自定义内容。可以看到“favorite”定义为了集合，是字符串类型所以需要在每个元素上添加“-”。
最后使用@Autowired使用setter注入“student”对象，也是集合形式，如上图StudentProperties 类所示，这就是yml文件自定义配置的代码注入方式，这种方式在我们需要配置集合和数组的时候很常用。
还有另外一种方式可以注入自定义配置比如，@ProprtySource

package com.senior.study.jumpdown.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

@Component
@PropertySource(value = "classpath:bjl.properties",encoding = "UTF-8")
@Data
@ConfigurationProperties(prefix = "bjl")
public class BjlProperties {
    private String name;
    private Integer age;
}

@PropertySource注解的使用很简单，当我们自定义一个配置文件，也就是命名不是application而是别的什么，如果直接用@ConfigurationProperties这个注解是无效的，所以需要用到@PropertySource注解整体注入到一个自定义的Java类中。但是这个注解对yml的支持不够所以我们在自定义配置文件的时候最好用properties后缀

2.8 Profile配置

这个功能主要是用来多环境配置文件的切换，一般我们需要在项目里创建数个配置文件，如图

多环境配置文件

命名的规则是application-{dev（pro、test）}.yml（properties），一般需要遵守这个命名格式，然后我们要新建一个application.yml或者是application.properties文件，在当中启用Profile的配置

spring:
  profiles:
    active: pro

第三章 SpringBoot整合视图层技术

3.1 整合Thymeleaf

Thymeleaf是Freemaker的比较好的替代品，作为前端引擎也比较适合后端工程师进行开发。
引入themeleaf需要引入springboot启动器，还需要web依赖，此处不再赘述。

    <properties>
        <thymeleaf.version>2.3.4.RELEASE</thymeleaf.version>
    </properties>

          <!--thymeleaf-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-thymeleaf</artifactId>
                <version>${thymeleaf.version}</version>
            </dependency>

第二步我们需要在yml文件进行配置

#   thymeleaf配置
spring:
  thymeleaf:
#    是否开启缓存（默认）
    cache: true
#    检查模板是否存在（默认）
    check-template: true
#    模板位置是否存在(默认)
    check-template-location: true
#    模板文件编码
    encoding: UTF-8
    servlet:
#     文档类型配置
      content-type: text/html
#      页面后缀
    suffix: .html
#    前缀
    prefix: classpath:/templates/

说明一下前缀后缀，前缀的配置是默认的，我们可以在resources目录下新建templates文件夹新建一个html页面，后缀需要配置.html，前缀默认配置也即默认回到根目录的templates下找到html页面。
简单新建一个实体类

package com.senior.study.jumpdown.domain;

import lombok.Data;

/**
 * @author bjl_m
 */
@Data
public class Book {
    private Integer id;
    private String name;
}

和控制器controller

package com.senior.study.jumpdown.controller;

import com.senior.study.jumpdown.domain.Book;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.ModelAndView;

/**
 * @author bjl_m
 */
@RestController
@RequestMapping("books")
public class BookController {

    /**
     * springboot整合thymeleaf
     * @return
     */
    @GetMapping("book")
    public ModelAndView book(){
        Book book = new Book();
        book.setName("淘气包马小跳");
        book.setId(1);
        System.out.println(book);
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject(book);
        modelAndView.setViewName("books");
        return modelAndView;
    }
}

这里注意的是我们返回ModelAndView 对象，它可以直接将数据返回到页面并且返回自定义页面。

springboot整合thymeleaf返回自定义视图

这样的话基本整合完成。

3.2 整合Freemaker

Freemarker对比thymeleaf是相对古老的视图引擎，springboot对于freemarker也有了很完善的支持。首先还是引入依赖。

    <properties>
        <freemarker.version>2.3.4.RELEASE</freemarker.version>
    </properties>
      <!--freemarker-->
      <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-freemarker</artifactId>
                <version>${freemarker.version}</version>
            </dependency>
        </dependencies>

还需要web依赖，此处不再赘述。
接下来对Freemaker进行配置

    #    freemarker配置
  #    httpservletrequest的属性是否可以覆盖controller中的同名项
  freemarker:
    allow-request-override: false
#    httpsession的属性是否可以覆盖controller中的同名项
    allow-session-override: false
#    是否开启缓存
    cache: false
#    模板编码
    charset: UTF-8
#    是否检查模板位置
    check-template-location: true
#    文档类型配置
    content-type: text/html
#    是否将httpservletrequest中的属性加入到model中
    expose-request-attributes: false
#    是否将httpsession中的属性添加到model中
    expose-session-attributes: false
#    后缀
    suffix: .ftl
#    模板文件位置 前缀
    template-loader-path: classpath:/templates/

注意，在最底下的前缀配置中跟thymeleaf是一样的，都是从项目根目录下的templates找到模板。

/**
     * springboot整合freemarker
     * @return
     */
    @GetMapping("book2")
    public ModelAndView bookFreeMarker(){
        Book book = new Book();
        book.setName("中国味道");
        book.setId(2);
        System.out.println(book);
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject(book);
        modelAndView.setViewName("books-freemarker");
        return modelAndView;
    }

我们在controller新建一个跳转方法，内容跟thymeleaf基本一致，之后再新建freemaker模板。

<!DOCTYPE html>
<html lang="en" >
<head>
    <meta charset="UTF-8">
    <title>books</title>
</head>
<body>
thanks books-freemarker
<a>${book.id}</a>
<a>${book.name}</a>
</body>
</html>

这里去掉了第二行对thymeleaf的引入，在a标签中也去掉了专有的th语法，同样是用${}接收传输对象。效果如下：

springboot整合freemaker

第四章 SpringBoot整合Web开发

4.1 返回JSON数据

json交互是目前前后端分离开发模式的通用方式，springMVC提供了默认的方式比如@ResponseBody注解，用于方法时该方法的返回值会自动转换为json，用于类上时会默认整个类的所有方法返回值自动转化为json，springMVC还有一种复合注解，@RestController，它等于@Controller+@ResponseBody。
另外除了springMVC自带的还有一些第三方json框架可供选择。比如阿里巴巴的Fastjson或者谷歌的Gson，一般项目中使用fastjson比较多，目的也是为了对json进行转化或者是字符串和json之间的互转等等，那我推荐一个国内的活跃框架hutool。hutool开源框架

4.2 静态资源访问

第五章 SpringBoot整合持久层技术

5.1 整合JdbcTemplate

JdbcTemplate是spring封装的操作数据库的操作API，类似于mybatis或者是springdatajpa，我们先尝试用springboot整合jdbctemplate.
首先引入jdbc的依赖

    <properties>
        <mysql.version>8.0.21</mysql.version>
        <druid.version>1.2.5</druid.version>
        <springboot.version>2.3.5.RELEASE</springboot.version>
    </properties>
    <!--dependenciesmanagement作用：加上这个标签里面的依赖就成为了父pom
    只是声明依赖，由子类引入具体依赖，但是不加这个标签就是引入springboot的另一种形式，
    等价于用parent标签引入springboot父项目-->

    <!--    <dependencyManagement>-->
        <dependencies>
            <!--springbootweb-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>${springboot.version}</version>
            </dependency>
            <!--springboot整合jdbcTemplate-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-jdbc</artifactId>
                <version>${springboot.version}</version>
            </dependency>
            <!--springboot整合mysql-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
                <scope>runtime</scope>
            </dependency>
            <!--阿里巴巴数据连接池-->
<!--            <dependency>-->
<!--                <groupId>com.alibaba</groupId>-->
<!--                <artifactId>druid-spring-boot-starter</artifactId>-->
<!--                <version>${druid.version}</version>-->
<!--            </dependency>-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>
        </dependencies>
<!--    </dependencyManagement>-->

需要引入web的基础依赖、springboot封装的jdbc启动器、mysql依赖和阿里巴巴数据库连接池，这里注意连接池没有使用springboot启动器而使用普通的maven依赖。
但是如果我们直接继承springboot父依赖例如：

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

就可以使用springboot的阿里巴巴数据库连接池启动器

            <!--阿里巴巴数据连接池-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
            </dependency>

也就是说如果我们使用引入springbootdependencies方式使用springboot那不能直接使用Druid的springboot启动器。