????????? 在以往我们采用SpringMVC + Spring + MyBatis框架进行开发的时候，搭建和整合三大框架，我们需要做很多工作，比如配置web.xml，配置Spring，配置MyBatis，并将它们整合在一起等，而Spring Boot框架对此开发过程进行了革命性的颠覆，完全抛弃了繁琐的xml配置过程，采用大量的默认配置简化我们的开发过程。

? ????????所以采用Spring Boot可以非常容易和快速地创建基于Spring框架的应用程序，它让编码变简单了，配置变简单了，部署变简单了，监控变简单了。正因为 Spring Boot 它化繁为简，让开发变得极其简单和快速，所以在业界备受关注。

1.2 Spring Boot的特性

能够快速创建基于Spring的应用程序
?能够直接使用java main方法启动内嵌的Tomcat服务器运行Spring Boot程序，不需要部署war包文件
提供约定的starter POM来简化Maven配置，让Maven的配置变得简单
?自动化配置，根据项目的Maven依赖配置，Spring boot自动配置Spring、Spring mvc等
?提供了程序的健康检查等功能
基本可以完全不使用XML配置文件，采用注解配置

1.3 Spring Boot四大核心

1.3.1 自动配置

? ????????针对很多Spring应用程序和常见的应用功能，Spring Boot能自动提供相关配置

1.3.2 起步依赖

????????告诉Spring Boot需要什么功能，它就能引入需要的依赖库

1.3.3 Actuator

????????让你能够深入运行中的Spring Boot应用程序，一探Spring Boot程序的内部信息

1.3.4 命令行界面

????????这是Spring Boot的可选特性，主要针对Groovy语言使用

????????? Groovy是一种基于JVM(Java虚拟机) 的敏捷开发语言，它结合了Python、Ruby和Smalltalk的许多强大的特性，Groovy 代码能够与Java代码很好地结合，也能用于扩展现有代码，由于其运行在JVM上的特性，Groovy可以使用其他Java语言编写的库

二、 Spring Boot入门案例

2.1 开发步骤

2.1.1 创建一个新的Module，选择类型为Spring Initializr

注意：https://start.spring.io 是国外的地址，国内部分地址可能无法访问因此建议选择Constum 选择手动指定国内访问地址 https://start.springboot.io

2.1.2 指定GAV及pom配置信息 ?

2.1.3 选择Spring Boot版本及依赖

会根据选择的依赖自动添加起步依赖并进行自动配置

?2.1.4 修改Content Root路径及文件所在目录

????????点击Finish，第一次创建，在右下角会提示正在下载相关的依赖

2.1.5 对POM.xml文件进行解释

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
<!--
    parent：继承springboot的父级依赖
-->

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.springboot</groupId>
    <artifactId>_01-springboot-first</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>_01-springboot-first</name>
    <description>_01-springboot-first</description>
    <properties>
<!--
    自定义一个属性，用于覆盖父级依赖中的配置属性
        指定使用java版本为1.8
-->
        <java.version>1.8</java.version>
    </properties>
    <dependencies>

<!--
        引入springboot的web项目起步依赖，版本号由springboot父级依赖去决定
-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

    <build>
        <plugins>
<!--
        springboot编译插件
-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2.1.6 对SpringBoot项目结构进行说明

static|templates：后面模板技术中存放文件的目录
application.properties：SpringBoot的配置文件，很多集成的配置都可以在该文件中进行配置，例如：Spring、springMVC、Mybatis、Redis等。目前是空的
?Application.java：SpringBoot程序执行的入口，执行该程序中的main方法，SpringBoot就启动了

2.1.7 创建一个Spring MVC的HelloSpringBootController

注意：新创建的类一定要位于Application同级目录或者下级目录，否则SpringBoot加载不到 ?

2.1.8 在idea中右键，运行Application类中的main方法

????????通过在控制台的输出，可以看到启动SpringBoot框架，会启动一个内嵌的tomcat，端口号为8080，上下文根为空 ?

?2.1.9 在浏览器中输入http://localhost:8080/test访问

2.2 入门案例分析

? Spring Boot的父级依赖spring-boot-starter-parent配置之后，当前的项目就是Spring Boot项目
spring-boot-starter-parent是一个Springboot的父级依赖，开发SpringBoot程序都需要继承该父级项目，它用来提供相关的Maven默认依赖，使用它之后，常用的jar包依赖可以省去version配置
Spring Boot提供了哪些默认jar包的依赖，可查看该父级依赖的pom文件
如果不想使用某个默认的依赖版本，可以通过pom.xml文件的属性配置覆盖各个依赖项，比如覆盖Spring版本

<properties>
	<spring.version>5.2.8.RELEASE</spring.version>
</properties>

????????5.@Controller 及 @ResponseBody 依然是我们之前的Spring MVC，因为Spring Boot的里面? 依然是使用我们的Spring MVC + Spring + MyBatis 等框架

1）、@SpringBootApplication注解是Spring Boot项目的核心注解，主要作用是开启Spring自动配置，如果在Application类上去掉该注解，那么不会启动SpringBoot程序

main方法是一个标准的Java程序的main方法，主要作用是作为项目启动运行的入口

2.3 Spring Boot的核心配置文件

????????Spring Boot的核心配置文件用于配置Spring Boot程序，名字必须以application开始

2.3.1.1 .properties文件（默认采用该文件）

????????键值对的properties属性文件配置方式

# 配置内嵌tomcat的端口号
server.port=9090
# 配置项目的上下文根
server.servlet.context-path=/01-springboot-first

?配置完毕之后，启动浏览器测试

2.3.1.2 .yml文件

yml 是一种 yaml 格式的配置文件，主要采用一定的空格、换行等格式排版进行配置。

yaml 是一种直观的能够被计算机识别的的数据序列化格式，容易被人类阅读，yaml 类似于 xml，但是语法比xml 简洁很多，值与前面的冒号配置项必须要有一个空格， yml 后缀也可以使用 yaml 后缀

server:
  port: 9200
  servlet:
    context-path: /yml

2.3.2 多环境配置

? ????????在实际开发的过程中，我们的项目会经历很多的阶段（开发->测试->上线），每个阶段的配置也会不同，例如：端口、上下文根、数据库等，那么这个时候为了方便在不同的环境之间切换，SpringBoot提供了多环境配置，具体步骤如下

? 为每个环境创建一个配置文件，命名必须以application-环境标识.properties|yml

?dev配置

online配置

test配置

主配置文件中，配置dev环境，

?运行启动服务

访问online环境?,访问成功

?访问test和dev环境，都无法访问。

2.3.3 Spring Boot自定义配置

2.3.3.1 @Value注解

用于逐个读取application.properties中的配置

案例演示

1. 在开发环境的配置文件applicatin-dev.properties中，添加两个自定义配置项stuName和stuAge。在idea中可以看到这两个属性不能被SpringBoot识别，背景是桔色的

?2.在TestController类中使用自定义属性，注意需要使用${}，并且使用@Value注解

?3. 在TestController中定义方法，进行测试

4.启动服务，访问

2.3.3.2 @ConfigurationProperties ?

将整个文件映射成一个对象，用于自定义配置项比较多的情况

案例演示

1.在配置文件中配置自定义属性

2.在com.springboot.model包下创建Student类，并为该类加上Component和ConfigurationProperties注解，prefix可以不指定，如果不指定，那么会去配置文件中寻找与该类的属性名一致的配置，prefix的作用可以区分同名配置

?3.?在TestController类中使用自定义属性，使用@Resource或者Autowire注入

?4.?在TestController中定义方法，进行测试

?5.启动服务，访问

2.3.3.3 中文乱码

如果在SpringBoot核心配置文件中有中文信息，会出现乱码：

一般在配置文件中，不建议出现中文（注释除外）
如果有，可以先转化为unicode码

2.4 Spring Boot前端使用JSP

????????创建_03-springboot-jsp项目

2.4.1 在pom.xml文件中配置以下依赖项

<!--引入Spring Boot内嵌的Tomcat对JSP的解析包，不加解析不了jsp页面-->
<dependency>
   <groupId>org.apache.tomcat.embed</groupId>
   <artifactId>tomcat-embed-jasper</artifactId>
</dependency>
<!-- servlet依赖的jar包start ，可选-->
<dependency>
   <groupId>javax.servlet</groupId>
   <artifactId>javax.servlet-api</artifactId>
</dependency>
<!-- servlet依赖的jar包start -->

<!-- jsp依赖jar包start ，可选-->
<dependency>
   <groupId>javax.servlet.jsp</groupId>
   <artifactId>javax.servlet.jsp-api</artifactId>
   <version>2.3.1</version>
</dependency>
<!-- jsp依赖jar包end -->

<!--jstl标签依赖的jar包start ，可选-->
<dependency>
   <groupId>javax.servlet</groupId>
   <artifactId>jstl</artifactId>
</dependency>
<!--jstl标签依赖的jar包end -->

2.4.2 在pom.xml的build标签中要配置以下信息

????????SpringBoot要求jsp文件必须编译到指定的META-INF/resources目录下才能访问，否则访问不到。

<resources>
            <resource>
                <!--源文件位置 -->
                <directory>src/main/webapp</directory>
                <!--编译到META-INF/resourece 目录下不能随便写 这个路径表示编译后的根路径 -->
                <targetPath>META-INF/resources</targetPath>
                <includes>
                    <!--要那些文件编译过去，**表示webapp 目录下以及子孙目录，*.* 表示所有文件 -->
                    <include>**/*.*</include>
                </includes>
            </resource>
</resources>

2.4.3 在application.properties文件配置Spring MVC的视图展示为jsp，这里相当于Spring MVC的配置

#配置SpringMVC的视图解析器
#前缀
spring.mvc.view.prefix=/
#后缀
spring.mvc.view.suffix=.jsp

集成完毕之后，剩下的步骤和我们使用Spring MVC一样

2.4.4 在com.springboot.controller包下创建TestController类，并编写代码

?2.4.5 在src/main 下创建一个webapp目录，然后在该目录下新建test.jsp页面


<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %><!DOCTYPE html>
<html>
<head>
    <title></title>
</head>
<body>

<h1>这个是jsp页面${mykey}</h1>
</body>
</html>

2.4.6 重新运行Application，通过浏览器访问测试

三、 Spring Boot框架Web开发

3.1 Spring Boot集成MyBatis

3.1.1 案例思路

通过SpringBoot +MyBatis实现对数据库user表键查询操作

3.1.2.2 创建_04-springboot-mybatis项目

创建一个新的SpringBoot的Module

选择SpringBoot版本以及web依赖 ?

3.1.2.3 在pom.xml中相关jar依赖

?注意：由于SpringBoot默认的MySQL驱动包版本过高与我们使用的数据库版本不符，建议修改MySQL的启动包版本号为5.1.46

3.1.2.4 在Springboot的核心配置文件application.properties中配置数据源

?注意根据自己的ip修改url

#配置数据库连接信息
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://192.168.75.137:3306/springbootdb?useUnicode=true&characterEncoding=utf8&useSSL=false
spring.datasource.username=root
spring.datasource.password=123456

#通知MyBatis我们SQL映射接口所在路径
mybatis.mapper-locations=classpath:mapper/*.xml

3.1.2.5 开发代码

1.使用Mybatis逆向工程生成接口、映射文件以及实体bean，具体步骤见最后逆向工程操作步骤

2. 在com.springboot.controller包下创建UserController并编写代码

?3.在com.springboot.service包下创建UserService接口并编写代码

?4.在com.springboot.service.impl包下创建service接口的实现并编写代码

?5.在Mybatis反向工程生成的UserMapper接口上加一个@Mapper注解

?注意：默认情况下，Mybatis的xml映射文件不会编译到target的class目录下，所以我们需要在pom.xml文件中配置resource

<resources>
  <resource>
    <directory>src/main/java</directory>
    <includes>
     <include>**/*.xml</include>
    </includes>
  </resource>
 </resources>

6.UserMapper.xml文件中，编写sql映射

?7. 启动应用，浏览器访问

3.1.3 其它开发方式

3.1.3.1 在运行的主类上添加注解包扫描@MapperScan("com.springboot.mapper")

1、注释掉UserMapper接口上的@Mapper注解

?2、在运行主类Application上加@MapperScan("com.springboot.mapper")

?3、启动应用，浏览器访问

3.1.3.2 将接口和映射文件分开 ?

????????因为SpringBoot不能自动编译接口映射的xml文件，还需要手动在pom文件中指定，所以有的公司直接将映射文件直接放到resources目录下

1、在resources目录下新建目录mapper存放映射文件，将UsertMapper.xml文件移到resources/mapper目录下

?2、在application.properties配置文件中指定映射文件的位置，这个配置只有接口和映射文件不在同一个包的情况下，才需要指定

?别忘了pom文件中加如下配置，不然无法将resource下面的xml文件编译

?3、启动应用，浏览器访问

3.2 Spring Boot 事务支持

Spring Boot 使用事务非常简单，底层依然采用的是Spring本身提供的事务管理

1、在入口类中使用注解 @EnableTransactionManagement 开启事务支持

2、在访问数据库的Service方法上添加注解 @Transactional 即可

3.2.1 案例思路

?????????通过SpringBoot +MyBatis实现对数据库user表进行新增操作，在service层的方法中构建异常，查看事务是否生效? ? ? ??

3.2.2.1 在UserController中添加新增学生的方法

?3.2.2.2 在UserService?接口中新增添加学生方法

?3.2.2.3?在UserServiceImpl接口实现类中添加实现新增学生方法，并构建一个异常，同时在该方法上加@Transactional注解，查看事务是否正常

?3.2.2.4 在Application类上加@EnableTransactionManagement开启事务支持

3.2.2.5 启动Application，通过浏览器访问进行测试

浏览器

?控制台

?数据库表

从上面我们可以看出已经执行了第一次插入操作后，但是抛出了异常，查看数据库，没有数据插入，说明事务已经起到了作用；?

3.2.2.6 注释掉UserServiceImpl上的@Transactional测试

?第一次插入操作成功

3.2.3控制台打印sql日志

配置文件添加如下，并且设置日志级别

3.3 Spring Boot集成Redis

3.3.1 Spring Boot 集成Redis单机模式

3.3.1.1 案例思路

查询学生的功能，先从redis缓存中查找，如果找不到，再从数据库中查找，然后放到redis缓存中

3.3.1.2 实现步骤

3.3.1.2.1 创建项目 _05-springboot-redis

?3.3.1.2.2 在Spring Boot核心配置文件application.properties中配置redis连接信息

3.3.1.2.3 在com.springboot.model包下创建User类并编写代码

?注意：当前实体类需要添加get和set方法，并必须添加可序列化接口Serializable

3.3.1.2.4 在com.springboot.service包下创建UserService接口并编写代码 ?

3.3.1.2.5?在UserServiceImpl中注入RedisTemplate并实现获取所有学生的方法

配置了上面的步骤，Spring Boot将自动配置RedisTemplate，在需要操作redis的类中注入redisTemplate即可。Spring Boot帮我们注入RedisTemplate类，泛型里面只能写 <String, String>、<Object, Object>或者什么都不写

package com.springboot.uservice.impl;

import com.springboot.model.User;
import com.springboot.uservice.UserService;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    /**
     * RedisTemplate: spring 提供的模板工具类，用于操作redis的，使用这个对象操作redis时Key和Value全都是Object类型
     *  一般给redis中存储对象或者文件会使用RedisTemplate
     */
    @Resource
    private RedisTemplate redisTemplate;

    /**
     * StringRedisTemplate: spring 提供的模板工具类，用于操作redis的，使用这个对象操作redis时Key和Value全都是String类型
     */
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 获取所有数据，如果redis中有数据则从redis获取，如果redis中没有数据则从数据库中获取，然后存入到redis中
     * @return
     */
    @Override
    public List<User> getUserAll() {
        //从redis中读取数据
        List<User> userList =(List<User>) redisTemplate.opsForValue().get("userList");
        //进入if表示redis中没有获取到数据，才会读取数据库
        if(userList==null || userList.isEmpty()){
            userList = getData();
            redisTemplate.opsForValue().set("userList", userList);
            System.out.println("----从数据库中读取-------");

        }else {
            System.out.println("----从redis中读取数据----");

        }
        return userList;
        
    }

    /**
     * 模拟从数据库中读取数据
     * @return
     */
    public List<User> getData(){
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三", 20));
        userList.add(new User("李四", 25));
        userList.add(new User("王五", 30));
        return userList;
    }
}

3.3.1.2.5 在com.springboot.controller包下创建UserController类并编写代码

3.3.1.2.7 启动SpringBoot应用，浏览器2次访问

?查看控制台

?第一次从访问redis获取没有获取到数据，会读取数据库数据，并将数据写到redis中

第二次访问redis中有数据，直接读取redis里面的数据

3.3.2 缓存穿透现象

3.3.2.1.1 在UserController程序中创建多个线程调用service的getUserAll()方法

?3.3.2.1.2 清空Redis中的数据，启动应用程序，浏览器访问测试，观察控制台

?注意：多个线程都去查询数据库，这种现象就叫做缓存穿透，如果并发比较大，对数据库的压力过大，有可能造成数据库宕机，假死。

3.3.2.2 解决方案

3.3.2.2.1 修改UserServiceImpl中的代码

package com.springboot.uservice.impl;

import com.springboot.model.User;
import com.springboot.uservice.UserService;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    /**
     * RedisTemplate: spring 提供的模板工具类，用于操作redis的，使用这个对象操作redis时Key和Value全都是Object类型
     *  一般给redis中存储对象或者文件会使用RedisTemplate
     */
    @Resource
    private RedisTemplate redisTemplate;

    /**
     * StringRedisTemplate: spring 提供的模板工具类，用于操作redis的，使用这个对象操作redis时Key和Value全都是String类型
     */
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 获取所有数据，如果redis中有数据则从redis获取，如果redis中没有数据则从数据库中获取，然后存入到redis中
     * @return
     */
    @Override
    public List<User> getUserAll() {
        List<User> userList =(List<User>) redisTemplate.opsForValue().get("userList");

        /**
         * 这里会可能出现缓存穿透问题，如果多线程同时访问时，redis中没有数据，这时会有多个线程同时从数据库中读取数据，造成数据压力增加。
         * 可以使用双重检测的方式来实现
         */

        //进入if表示redis中没有获取到数据 ，只有第一批进入if的线程，才会读取数据库
        if(userList==null || userList.isEmpty()){

            //第一批并发请求，需要逐一排队执行
            synchronized (this) {

                //再次读取数据
                userList = (List<User>) redisTemplate.opsForValue().get("userList");

                //进入if表示redis中没有数据，只有第一批第一个请求会进入if
                if (userList == null || userList.isEmpty()) {
                    //模拟从数据库中读取数据
                    userList = getData();
                    //将数据对象直接存入redis中，因此数据对象必须实现可序列化接口
                    redisTemplate.opsForValue().set("userList", userList);

                    System.out.println("----从数据库中读取-----第一批非第一个请求------");
                }else {
                    System.out.println("----从redis中读取----第一批非第一个请求-------");
                }
            }

        }else {
            System.out.println("----从redis中读取数据------非第一个请求------");
        }
        return userList;
    }

    /**
     * 模拟从数据库中读取数据
     * @return
     */
    public List<User> getData(){
        List<User> userList = new ArrayList<>();
        userList.add(new User("张三", 20));
        userList.add(new User("李四", 25));
        userList.add(new User("王五", 30));
        return userList;
    }
}

3.3.2.2.2 清空Redis中的数据，启动应用程序，浏览器访问测试，查看控制台输出

????????只有第一个线程查询数据库，其它线程查询Redis缓存，这样的解决的小问题就是第一批进来的用户会有一个等待，但是这样的影响可以忽略

3.3.2.3 springboot集成Redis阻止缓存穿透，为什么要做双层验证

1、?防止线程获取到cpu执行权限的时候，其他线程已经将数据放到Redis中了，所以再次判断

2、不能将synchronized范围扩大，因为如果Redis缓存中如果有数据，线程不应该同步，否则影响效率

3.3.3 Spring Boot 集成Redis哨兵模式

? 在实际的生产环境中，如果我们只有一台Redis服务，那么当这台唯一的Redis服务器宕机以后，我们整个服务将变得不可用，因此为了解决单点故障问题我们通常需要配置多个Redis实现Redis中的主从复制，并利用哨兵来实现Redis的高可用

3.3.3.1 在Springboot核心配置文件application.properties中配置redis连接信息

IP地址及master根据自己的情况进行修改

?3.3.3.2启动三台Redis服务器

3.3.3.3?启动三台Redis哨兵

3.3.3.4在Redis Desktop Manager上创建三个连接，连接到6380,6382,6384Redis服务器

3.3.3.5 清空6380主数据，查看情况

6382和6384也跟着清空

3.3.3.7 启动SpringBoot主程序，浏览器访问，查看Redis情况

哨兵会将Redis6382 或6384作为主，等Redis6380再次启动后，会作为从节点

3.4 Spring Boot热部署插件

在实际开发中，我们修改某些代码逻辑功能或页面都需要重启应用，这无形中降低了开发效率，热部署是指当我们修改代码后，服务能自动重启加载新修改的内容，而不需要重启应用，这样大大提高了我们开发的效率。

Spring Boot热部署通过在pom.xml中添加一个spring-boot-devtools插件实现

<!--SpringBoot热部署插件-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-devtools</artifactId>
  <optional>true</optional>
</dependency>

该热部署插件在实际使用中会有一些小问题，明明已经重启，但没有生效，这种情况下，手动重启一下程序；

修改完毕后，需要选中项目，在Build选项中选择Build Module

四、 Spring Boot 非web应用程序

在Spring Boot框架中，要创建一个非Web应用程序（纯Java程序），有两种方式

4.1 方式一：直接在main方法中，根据SpringApplication.run()方法获取返回的Spring容器对象，再获取业务bean进行调用

4.1.1 创建一个SpringBoot Module，_07-springboot-java01

4.1.2 创建一个演示TestService，放到service包下

4.1.3 在Application类的main方法中，获取容器，调用业务bean

执行main方法获取bean对象数据?

4.2 方式二：Spring boot 的入口类实现CommandLineRunner接口

?将Application类的实现CommandLineRunner接口

五、 Spring Boot 使用拦截器

? 1、自定义拦截器类，实现HandlerInterceptor接口

2、注册拦截器类

5.2 Spring Boot使用拦截器步骤

5.2.1 按照Spring MVC的方式编写一个拦截器类，实现HandlerInterceptor接口

创建interceptor包，包下创建MyInterceptor接口，并且实现HandlerInterceptor接口

5.2.2 通过配置类注册拦截器

?????????创建一个config包，创建一个配置类MyConfig，并实现WebMvcConfigurer接口，覆盖接口中的addInterceptors方法，并为该配置类添加@Configuration注解，标注此类为一个配置类，让Spring Boot 扫描到，这里的操作就相当于SpringMVC的注册拦截器，@Configuration就相当于一个applicationContext-mvc.xml

package com.springboot.config;

import com.springboot.interceptor.MyInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;

/**
 * @Configuration 用于标记当前类是spring的配置类，用于模拟spring的配置文件
 *
 * 父接口相对于springMVC文件中的mvc命名空间
 */
@Configuration
public class MyConfig implements WebMvcConfigurer {
    //注入拦截器对象
    @Resource
    private MyInterceptor myInterceptor;
    

    /**
     * 配置拦截器，类似springMVC配置文件中的<mvc:interceptors></mvc:interceptors>标签
     * @param registry 拦截器的注册对象
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        /**
         * 拦截器的注册对象，类似springMVC配置文件中的<mvc:interceptor></mvc:interceptor>
         * 参数为某个拦截器的对象
         * 返回拦截器的配置对象，用于配置拦截器的拦截路径以及忽略的路径
         */
        InterceptorRegistration interceptorRegistration = registry.addInterceptor(myInterceptor);
        //配置拦截器需要拦截的private路径下任意子孙路径的任意请求
        interceptorRegistration.addPathPatterns("/private/**");
        //配置拦截器请求忽略路径,忽略private下的test02请求，这个请求不会被拦截器拦截
        interceptorRegistration.excludePathPatterns("/private/test02");

        /**
         * 注意：如果需要配置多个拦截器，则重复上面的代码即可，但是要注意interceptorRegistration变量不要重名
         */
    }
}

5.2.3 浏览器访问测试拦截成功

六、使用Servlet（了解）

6.1 方式一通过注解扫描方式实现

6.1.1 通过注解方式创建一个Servlet

在下创建com.springboot.servlet包，并在该包下创建TestServlet，并且添加@WebServlet("/test")注解

6.1.2 修改Application类

6.1.3 启动应用SpringBoot，浏览器访问测试

6.2 方式二通过Spring Boot的配置类实现（组件注册）

6.2.1 创建一个Servlet包，下面创建TestServlet类

6.2.2 编写一个Spring Boot的配置类，在该类中注册Servlet

6.2.3 启动应用SpringBoot，浏览器访问测试

七、使用Filter（了解）

7.1 方式一通过注解方式实现

7.1.1 通过注解方式创建一个Filer

7.1.2 修改Application类

?7.1.3 创建controller

7.1.4?启动应用SpringBoot，浏览器访问测试

7.2 方式二通过Spring Boot的配置类实现

7.2.1 创建一个普通的Filter

7.2.2 注册Filter

7.2.3 启动应用SpringBoot，浏览器访问测试

八、 Spring Boot 项目配置字符编码 ?

8.1 方式一使用传统的Spring提供的字符编码过滤器

?1、Config中配置文件类，注册字符编码过滤器

?2、在application.properties中设置spring.http.encoding.enabled=false

8.2 方式二在application.properties中配置字符编码（推荐）

?从 springboot 1.4.2 之后开始新增的一种字符编码设置

# 设置请求响应的字符编码

九、 Spring Boot打包与部署

9.1 Spring Boot程序war包部署

9.1.1 创建Spring Boot Web项目

9.1.1.1 创建一个新的Module，_11-springboot-war01

9.1.1.2 在pom.xml文件中配置内嵌Tomcat对jsp的解析包

<!--SpringBoot项目内嵌tomcat对jsp的解析包-->
<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-tomcat</artifactId>
     <scope>provided</scope>
</dependency>

9.1.1.3 在application.properties配置文件中配置内嵌Tomcat端口号及上下文根和jsp的前后缀

# 内嵌tomcat的配置

9.1.1.4 创建TestController提供方法分别返回字符串及跳转页面

9.1.1.5 浏览器输入地址访问测试

9.1.2 打War包

9.1.2.1 程序入口类同级路径下创建ServletInitializer类(有则不用创建)

9.1.2.2 在 pom.xml中添加（修改）打包方式为war

9.1.2.3 在 pom.xml中配置springboot打包的插件(默认自动加)

9.1.2.4 通过Maven package命令打war包到target目录下

9.1.3 部署到Tomcat服务器上测试运行

9.1.3.1 将target目录下生成的war包拷贝到tomcat的webapps目录，并启动tomcat

启动tomcat

9.1.3.2 通过浏览器访问

?????

9.2 Spring Boot程序打Jar包与运行

????????因为SpringBoot默认的打包方式就是jar包,所以我们直接执行Maven的package命令就行了，这里我们以01-springboot-first为例

9.2.1 通过Maven package命令打jar包到target目录下

将target下的jar包拷贝到某一个目录，在该目录下执行 java -jar 01-springboot-first-0.0.1-SNAPSHOT.jar

9.2.2 浏览器访问测试

9.3 Spring Boot部署与运行方式总结

1、在IDEA中直接运行Spring Boot程序的main方法（开发阶段）

2、用maven将Spring Boot安装为一个jar包，使用Java命令运行

java -jar springboot-xxx.jar

可以将该命令封装到一个Linux的一个shell脚本中（上线部署）

写一个shell脚本：

? #!/bin/sh

? java -jar xxx.jar
赋权限 chmod 777 run.sh

启动shell脚本： ./run.sh

3、使用Spring Boot的maven插件将Springboot程序打成war包，单独部署在tomcat中运行（上线部署常用） ?

十、Spring Boot 集成 Thymeleaf 模板

10.1 认识Thymeleaf

Thymeleaf是一个流行的模板引擎，该模板引擎采用Java语言开发

? 模板引擎是一个技术名词，是跨领域跨平台的概念，在Java语言体系下有模板引擎，在C#、PHP语言体系下也有模板引擎，甚至在JavaScript中也会用到模板引擎技术，Java生态下的模板引擎有 Thymeleaf 、Freemaker 等。

? Thymeleaf 对网络环境不存在严格的要求，既能用于Web环境下，也能用于非Web环境下。在非Web环境下，他能直接显示模板上的静态数据；在Web环境下，它能像Jsp一样从后台接收数据并替换掉模板上的静态数据。它是基于HTML的，以HTML标签为载体，Thymeleaf要寄托在HTML标签下实现。

? Spring Boot 集成了Thymeleaf模板技术，并且Spring Boot官方也推荐使用Thymeleaf来替代JSP技术，Thymeleaf是另外的一种模板技术，它本身并不属于Spring Boot，Spring Boot只是很好地集成这种模板技术，作为前端页面的数据展示，在过去的Java Web开发中，我们往往会选择使用Jsp去完成页面的动态渲染，但是jsp需要翻译编译运行，效率低

? Thymeleaf的官方网站：Thymeleaf

? Thymeleaf官方手册：Tutorial: Using Thymeleaf

10.2 Spring Boot集成Thymeleaf

10.2.1 创建Spring Boot项目_12-sprinboot-thymeleaf，添加web和Thymeleaf依赖

创建后，pom.xml文件下会自动添加如下依赖

10.2.2 在Spring boot的核心配置文件application.properties中对Thymeleaf进行配置

10.2.3 创建ThymeleafControlle去映射到模板页面（和SpringMVC基本一致）

?在com.springboot.controller目下创建ThymeleafController类

10.2.4 在src/main/resources的templates下新建一个test02.html页面用于展示数据

11.2.5 启动程序，浏览器访问

10.3 Thymeleaf的表达式

10.3.1 标准变量表达式

10.3.1.1 语法 ${...}

10.3.1.2 说明

标准变量表达式用于访问容器（tomcat）上下文环境中的变量，功能和EL中的相同。中的变量表达式使用?{变量名} 的方式获取Controller中model其中的数据

10.3.1.3 案例演示

1、在com.springboot.model包下创建User实体类

?2、在ThymeleafController中添加userInfo方法中，向model放入User对象

3、test02.html通过选择变量表达式获取用户数据 ?

4、启动服务，浏览器访问

10.3.2 选择变量表达式

10.3.2.1 语法：*{...}?

10.3.2.2 说明

选择变量表达式，也叫星号变量表达式，使用 th:object 属性来绑定对象

选择表达式首先使用th:object来邦定后台传来的User对象，然后使用 * 来代表这个对象，后面 {} 中的值是此对象中的属性。

选择变量表达式 *{...} 是另一种类似于标准变量表达式 ${...} 表示变量的方法

选择变量表达式在执行时是在选择的对象上求解，而${...}是在上下文的变量Model上求解，这种写法比标准变量表达式繁琐，只需要大家了解即可

10.3.3 URL表达式

10.3.3.1 语法@{...}

10.3.3.2 说明

? 主要用于链接、地址的展示，可用于 <script src="...">、<link href="...">、<a href="...">、<form action="...">、<img src="">等，可以在URL路径中动态获取数据

10.4 Thymeleaf 的常见属性

?10.4.3 th:value

10.4.4 th:attr

该属性也是用于给HTML中某元素的某属性赋值，但该方式写法不够优雅

?10.4.5 th:text

用于文本的显示，该属性显示的文本在标签体中，如果是文本框，数据会在文本框外显示，要想显示在文本框内，使用th:value

10.4.6?th:onclick

? 点击事件

?10.4.7 th:each

这个属性非常常用，比如从后台传来一个对象集合那么就可以使用此属性遍历输出，它与JSTL中的<c: forEach>类似，此属性既可以循环遍历集合，也可以循环遍历数组及Map

10.4.7.1 遍历List集合

  <h1>th:each</h1>
    <!--
        作用：用户循环一个List、Set、Map、数组，根据集合和数组的长度将所寄托标签在页面中重复的进行显示
        语法：th:each="a,b:c"、th:each="a:c"
        注意：
            1.语法中的
                a：表示被循环的集合或者数组当前元素对象
                b：表示被循环的集合或者数组的状态对象，可以利用这个对象获取当前元素是否是第一个，当前元素是第几个等等,具体见下面
                    index:当前迭代对象的index（从0开始计算）
                    count: 当前迭代对象的个数（从1开始计算）这两个用的较多
                    size: 被迭代对象的大小
                    current: 当前迭代变量
                    even/odd: 布尔值，当前循环是否是偶数/奇数（从0开始计算）
                    first: 布尔值，当前循环是否是第一个
                    last: 布尔值，当前循环是否是最后一个
                b是可选参数，如果没有指定b,则提供默认的b,默认b为a+stat,例如a为user，那么默认的b为userstat
                c：表示被循环迭代的集合或者数组对象，可以使用${}、*{}从作用域中获取
    -->

    <h2>循环List</h2>
    <table>
            <tr>
                <td>序号</td>
                <td>姓名</td>
                <td>年龄</td>
                <td>性别</td>
                <td></td>
            </tr>
        <tr th:each="userObj:${userList}" th:object="${userObj}">
            <td th:text="${userObjStat.count}">序号</td>
            <td th:text="*{name}">姓名</td>
            <td th:text="*{age}">年龄</td>
            <td th:text="*{sex}">性别</td>
            <td>
                <a th:href="@{/update}">修改</a>
                <a th:href="@{/delete}">删除</a>
            </td>
        </tr>
    </table>

?10.4.7.2 遍历Map集合

10.4.8 条件判断

10.4.8.1 th:if

10.4.8.2 th:unless

?10.4.8.3 th:switch/th:case

10.4.9 th:inline

th:inline 有三个取值类型 (text, javascript 和 none) ?

10.4.9.1 内敛文本（th:inline=”text”）

10.4.9.2 内敛脚本（th:inline=”javascript”）

10.5 Thymeleaf字面量

Thymeleaf中的字面量分为以下几种：
    1.文本字面量，例如张三等；需要使用单引号括起来，可以使用+进行字符串拼接
    2.数字字面量，例如20,23，-12，-190等，可以使用算数运算符进行运算，例如+-*%/
    3.布尔字面量，取值只有true和false
    4.null字面量，取值为null，通常判断一个对象是否为null，例如${user==null}