面试题：

面试题1：简述一下Springboot相对SSM做了哪些提升？

 首先，SpringBoot是采用“约定大于配置”(Convention over Configuration)的理念，让你的项目快速运行起来，简化了大量的XML配置。使用SpringBoot很容易创建一个独立运行（运行jar，内嵌Servlet容器）、准生产级别的基于Spring框架的项目，使用SpringBoot你可以不用或者只用很少的Spring配置即可。

以前，你不仅要实现业务需求，还要自己配置SpringMVC、Spring、Mybatis相关配置信息。而Spring Boot做到自动配置，让你腾出精力和时间更多的去关心核心业务。

SpringBoot的优点？
1 . Spring由于其繁琐的配置，各种XML、Annotation配置，让人眼花缭乱，而且如果出错了也很难找出原因，而SpringBoot友好的内置了很多通用配置信息。
2 . SpringBoot帮助开发者快速启动一个Web容器；
3 . SpringBoot提供了更多的组合式注解，简化开发过程；
4 . SpringBoot可以”零配置”整合很多第三方工具；
5 . SpringBoot继承了原有Spring框架的优秀基因；

追问1：说说你在使用SpringBoot时比较有印象的有哪些注解？

1、@SpringBootApplication：
1 . 这个注解是Spring Boot最核心的注解，用在 Spring Boot的主类上，标识这是一个 Spring Boot 应用，用来开启 Spring Boot 的各项能力。
2 . 实际上这个注解是@Configuration,@EnableAutoConfiguration,@ComponentScan三个注解的组合。由于这些注解一般都是一起使用，所以Spring Boot提供了一个统一的注解@SpringBootApplication。

追问2：@RequestMapping注解的属性有哪些？分别都是干什么用的？

面试题2：SpringBoot 打成的 jar 包和普通的 jar 包有什么区别?

Spring Boot 中默认打包成的 jar 叫做**可执行 jar**，这种jar包可以通过可以通过命令（java -jar xxx.jar）来运行的，但这种jar包不能被其他项目所依赖，因为它和普通 jar 的结构不同，即使被依赖了也不能直接使用其中的类。

普通的jar包，解压后直接就是包名，包里就是我们的代码，而 Spring Boot 打包成的可执行 jar 解压后，在 \BOOT-INF\classes 目录下才是我们的代码，因此无法被直接引用。如果非要引用，可以在 pom.xml 文件中增加配置，将 Spring Boot 项目打包成两个 jar ，一个可执行，一个可引用。

追问1：如何让SpringBoot打的jar包可依赖？

在pom文件中增加以下配置：



org.springframework.boot
spring-boot-maven-plugin




repackage



exec





maven-compiler-plugin

1.8
1.8

面试题3：CORS跨域问题是怎么引起的呢？

Springboot跨域问题，是当前主流web开发人员都绕不开的难题。但我们首先要明确以下几点:
1 . 跨域只存在于浏览器端，不存在于安卓/ios/Node.js/python/ java等其它环境
2 . 跨域请求能发出去，服务端能收到请求并正常返回结果，只是结果被浏览器拦截了。
3 . 之所以会跨域，是因为受到了同源策略的限制，同源策略要求源相同才能正常进行通信，即协议、域名、端口号都完全一致。

 浏览器出于安全的考虑，使用 XMLHttpRequest对象发起 HTTP请求时必须遵守同源策略，否则就是跨域的HTTP请求，默认情况下是被禁止的。换句话说，浏览器安全的基石是同源策略。

追问1：处理过Springboot的CORS跨域问题么？怎么解决的？

方法一、直接采用SpringBoot的注解@CrossOrigin（也支持SpringMVC）:
方法二、处理跨域请求的Configuration:
  增加一个配置类，CrossOriginConfig.java。继承WebMvcConfigurerAdapter或者实现WebMvcConfigurer接口，其他都不用管，项目启动时，会自动读取配置。
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

/
AJAX请求跨域
@author Mr.W
@time 2018-08-13
/
@Configuration
public class CorsConfig extends WebMvcConfigurerAdapter {
static final String ORIGINS[] = new String[] { “GET”, “POST”, “PUT”, “DELETE” };
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping(“/“).allowedOrigins(“*”).allowCredentials(true).allowedMethods(ORIGINS).maxAge(3600);
}
}

 方法三、采用过滤器（filter）的方式:
  同方法二加配置类，增加一个CORSFilter 类，并实现Filter接口即可，其他都不用管，接口调用时，会过滤跨域的拦截。
@Component
public class CORSFilter implements Filter {

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
HttpServletResponse res = (HttpServletResponse) response;
res.addHeader(“Access-Control-Allow-Credentials”, “true”);
res.addHeader(“Access-Control-Allow-Origin”, “*”);
res.addHeader(“Access-Control-Allow-Methods”, “GET, POST, DELETE, PUT”);
res.addHeader(“Access-Control-Allow-Headers”, “Content-Type,X-CAF-Authorization-Token,sessionToken,X-TOKEN”);
if (((HttpServletRequest) request).getMethod().equals(“OPTIONS”)) {
response.getWriter().println(“ok”);
return;
}
chain.doFilter(request, response);
}
@Override
public void destroy() {
}
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
}

springBoot用法：

1.配置springboot文件上传路径：

1.1：配置路径配置类：

package com.example.blogdemo.configuration;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
/**
 * 配置文件上传路径
 * */
@Configuration
public class WebMvcConfig extends WebMvcConfigurerAdapter {
    @Autowired
    private FileUploadProperties fileUploadProperties;
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        //获取jar包所在目录
//        ApplicationHome h = new ApplicationHome(getClass());
//        File jarF = h.getSource();
        //在jar包所在目录下生成一个upload文件夹用来存储上传的图片
        //jarbao:D:\blog\tylblog\blogdemo\target/upload/
//        String imgPuth = jarF.getParentFile().toString()+"/upload/";
        registry.addResourceHandler(fileUploadProperties.getStaticAccessPath()).addResourceLocations("file:/"+fileUploadProperties.getUploadFolder());
    }
}

1.2：配置yml

file:
  staticAccessPath: /uploadBlogImg/**
  uploadFolder: D:\\blog\\tylblog\\uploadBlogImg\\

1.3：使用：

package com.example.blogdemo.service.serviceImpl;
import com.example.blogdemo.configuration.FileUploadProperties;
import com.example.blogdemo.service.FileUploadService;
import com.example.blogdemo.vo.WangEditorVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.system.ApplicationHome;
import org.springframework.stereotype.Service;
import org.springframework.util.ClassUtils;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
@Service
public class FileUploadServiceImpl implements FileUploadService {
    @Autowired
    private FileUploadProperties fileUploadProperties;
//    private String imgPuth= null ;
    private static final String SERVER_PREFIX = "http://localhost:8081/uploadBlogImg/";
    @Override
    public WangEditorVO handleFileUpload(MultipartFile[] file) throws IOException {
        //当file为空时
        if (file == null || file.length == 0) {
            return WangEditorVO.error(500, "无图片信息");
        }
        //获取jar包所在目录
//        ApplicationHome h = new ApplicationHome(getClass());
//        File jarF = h.getSource();
//        //在jar包所在目录下生成一个upload文件夹用来存储上传的图片
//         imgPuth = jarF.getParentFile().toString()+"/upload/";
        //存入数据库的文件地址集合
        List<String> pathList = new ArrayList<>();
        for (MultipartFile multipartFile : file) {
            //获取文件名
            String name = UUID.randomUUID().toString();
            //拼接完整的 存放图片地址，即：D:\\IO\\shop\\shopImage\\文件名.后缀名
            File filePath = new File(fileUploadProperties.getUploadFolder() + name + getSuffix(multipartFile));
            if(!filePath.exists()){
                filePath.mkdirs();
            }
            //将图片存放到path路径下
            multipartFile.transferTo(filePath);
            //拼接完整的 访问图片地址，即：http://localhost:8888/文件名.后缀名
            pathList.add(SERVER_PREFIX + name + getSuffix(multipartFile));
        }
        return WangEditorVO.success(pathList);
    }
    /**
     * 获取文件的后缀名
     *
     * @param multipartFile 上传的文件
     * @return 文件的后缀名
     */
    private String getSuffix(MultipartFile multipartFile) {
        //获取完整的文件名
        String fileName = multipartFile.getOriginalFilename();
        //截取后缀
        String fileSuffix = fileName.substring(fileName.lastIndexOf("."));
        return fileSuffix;
    }
}

2.SpringDat redis的使用

2.1 .导入依赖

 <!-- spring data redis依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- commons-pool2对象池依赖 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

2.2 配置application.yaml

  redis:
    #超时时间
    timeout: 10000ms
    #服务器地址
    host: 192.168.31.115
    #服务器端口
    port: 6379
    #数据库
    database: 0
    #密码
    password: root
    lettuce:
      pool:
        #最大连接数  默认8
        max-active: 1024
        #最大连接阻塞等待时间， 默认-1
        max-wait: 10000ms
        #最大空闲连接
        max-idle: 200
        #最小空闲连接
        min-idle: 5

2.3使用RedisTemplate.opsForvalue();获取letts对象

3.搭建hello world:

3.1：第一步放入依赖：

  <!--超级父pom  是springboot父依赖   声明版本号-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
    </parent>
    <dependencies>
        <!--web项目需要使用的-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
     </dependencies>

3.2：打开程序入口：

/**
 * @EnableConfigurationProperties({FoodConfig.class})
 * 告诉主程序入口类  要自动引入配置文件
 * 配置文件对应的类作为它的参数
 */
@SpringBootApplication
@EnableConfigurationProperties({FoodConfig.class})
public class DemoApplication {
    public static void main(String[] args) {
        //使用SpringApplication类的静态方法  启动springboot程序
        //方法的参数  程序的入口类  main函数的参数
        SpringApplication.run(DemoApplication.class,args);
    }
}

3.3编写业务逻辑：

/**
 * @Controller
 * 控制类  业务逻辑  请求分发  组装响应
 */
@Controller
public class HelloController {
    /**
     * @RequestMapping
     * 指定方法和请求之间的映射关系
     * @return
     */
    @RequestMapping("/hello")
    @ResponseBody
    public String hello(){
        return "Hello Duing";
    }
}

4.lombok的使用：

4.1 idea安装插件：

File -> setting -> plugins -> 查找lombok后安装重启
File -> Setting -> Compiler -> Annotation Processors -> Enable annotation processing勾选

4.2 pom引入依赖：

<dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <version>1.18.10</version>
</dependency>

4.3lombok插件常用注解：

4.3.1：@Getter / @Setter：可以作用在类上和属性上，放在类上，会对所有的非静态(non-static)属性生成
Getter/Setter方法，放在属性上，会对该属性生成Getter/Setter方法。并可以指Getter/Sette的
访问级别。
4.3.2：@EqualsAndHashCode ：默认情况下，会使用所有非瞬态(non-transient)和非静态(non-static)字段来生成equals和hascode方法，也可以指定具体使用哪些属性。 @ToString 生成toString方法，默认情况下，会输出类名、所有属性，属性会按照顺序输出，以逗号分割。
4.3.3：@NoArgsConstructor, @RequiredArgsConstructor and @AllArgsConstructor：无参构造器、部分参:数构造器、全参构造器
4.3.4：@Data：包含@ToString, @EqualsAndHashCode, 所有属性的@Getter, 所有non-final属性的@Setter和@RequiredArgsConstructor的组合，通常情况下，基本上使用这个注解就足够了。
4.3.5：@Budilder：可以进行Builder方式初始化。
4.3.6：@Slf4j：等同于：private final Logger logger = LoggerFactory.getLogger(XXX.class);

5.springboot3种启动方式：

5.1：Application-run

5.2：mvn spring-boot：run

5.3：mvn packag —java -jar

6.springboot多环境配置：

6.1：Multiple Application:

目前使用比较多的是配置多个 application-{profile}.yml 或者多个 application-{profile}.properties文件的写法，一张图就能解释清楚了，如下图所示。

application.yml 文件用于配置各个环境通用的配置，在这里我指定了程序使用的 profile，即 spring.profile.active= ${env:dev}属性，它的值决定了具体使用的配置。

例如 spring.profile.active=dev 时，使用 application-dev.yml + application.yml 的配置。

运行jar包的时候通过设置spring.profile.active=xxx 来指定运行哪个环境，例如使用 dev 环境：

java -jar  xxx.jar  --spring.profiles.active=dev

7.springboot YAML使用：

7.1：语法规则：

1.大小写敏感
2.使用缩进表示层级关系
3.缩进时不允许适应tab键，只允许适应空格
4.相同层级左侧要对齐
5.#表示注释，从这个字符一直到尾，都会被解析器忽略

7.2：YAML 支持的数据结构：

对象：键值对的集合，又称为映射（mapping）/ 哈希（hashes） / 字典（dictionary）
数组：一组按次序排列的值，又称为序列（sequence） / 列表（list）
纯量（scalars）：单个的、不可再分的值

7.2.1：对象的使用：

7.2.2：数组的使用：

7.2.3：YAML 纯量：

8.Thymeleaf的使用：

8.1 pom.xml中加入thymeleaf依赖

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

8.2 在main/resources目录下，创建templates文件夹，创建html文件

文件中引入<html xmlns:th=”http://www.thymeleaf.org”>，获取对标签的提示

name

8.3 编写controller

HelloController.java
@RequestMapping("/hello")
public String hello(Model m){
// m.addAttribute("name", "thymeleaf");
m.addAttribute("name", "<span style='color:red'>thymeleaf</span>");
return "hello";
}

8.4 Hello.html

<!--转义和非转义的html th:text会对<和>进行转义，而th:utext不会转义。-->
<p th:utext="${name}" >name</p>
<p th:text="${name}" >name</p>

Thymeleaf变量表达式：

Thymeleaf选择变量表达式：

Thymeleaf链接URL表达式：

Thymeleaf消息表达式：

Thymeleaf片段表达式：

Thymeleaf语法：

9.springBoot 整合Mybatis：

9.1 引入依赖：

<dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <version>2.1.0</version>
</dependency>
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <scope>runtime</scope>
</dependency>

9.2 在application.properties中配置数据源：

spring.datasource.url=jdbc:mysql://127.0.0.1:3306/mytestdb
spring.datasource.username=root
spring.datasource.password=123456
#默认根据url识别
#spring.datasource.driver-class-name=com.mysql.jdbc.Driver
#使用mybatis-config.xml时的配置项
#mybatis.config-location=classpath:mybatis-config.xml
#代替mybatis-config.xml的配置项
#mybatis.mapper-locations=classpath*:/mappers/*.xml
#mybatis.type-aliases-package=sample.mybatis.domain

9.2.1 properties.yml中的配置：

# 服务端口号
server:
  port: 8080
# 数据库地址
datasource:
  url: localhost:3306/blog_test
spring:
  datasource: # 数据库配置
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://${datasource.url}?useSSL=false&useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&autoReconnect=true&failOverReadOnly=false&maxReconnects=10
    username: root
    password: 123456
    hikari:
      maximum-pool-size: 10 # 最大连接池数
      max-lifetime: 1770000
mybatis:
  # 指定别名设置的包为所有entity
  type-aliases-package: com.itcodai.course10.entity
  configuration:
    map-underscore-to-camel-case: true # 驼峰命名规范
  mapper-locations: # mapper映射文件位置
    - classpath:mapper/*.xml

9.3 Mybatis基于xml配置文件的查询方式：

使用原始的 xml 方式，需要新建 UserMapper.xml 文件，在上面的 application.yml 配置文件中，我们已经定义了 xml 文件的路径：classpath:mapper/*.xml，所以我们在 resources 目录下新建一个 mapper 文件夹，然后创建一个 UserMapper.xml 文件。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itcodai.course10.dao.UserMapper">
  <resultMap id="BaseResultMap" type="com.itcodai.course10.entity.User">
    <id column="id" jdbcType="BIGINT" property="id" />
    <result column="user_name" jdbcType="VARCHAR" property="username" />
    <result column="password" jdbcType="VARCHAR" property="password" />
  </resultMap>
   <select id="getUserByName" resultType="User" parameterType="String">
       select * from user where user_name = #{username}
  </select>
</mapper>

9.3 Mybatis整合之注解方式：

3 在启动类上增加对mapper的包扫描注解 @MapperScan
如果不使用@MapperScan注解，还可以在每个 mapper 接口类上加上 @Mapper 这个注解(不推荐)
4 开发Mapper类，编写sql, 提供给service调用

@Select("select name,role from guest")
@Delete("delete from guest where name=#{name}")
@Update("update guest set role=#{role} where name=#{name}")
@Options(useGeneratedKeys = true,keyProperty = "id")
@Insert("insert into guest(name,role) values(#{name},#{role})")

10. springBoot Mybatis-plus:

10.1 导入依赖：

   <!-- mybatis plus 代码生成器 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.2.0</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.2.0</version>
        </dependency>
        <dependency>

10.2 配置application.yml:

server:
  port: 8081
  servlet:
    context-path: /
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/demo?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
    username: root
    password: lyja
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8
    serialization:
      write-dates-as-timestamps: false
mybatis-plus:
  configuration:
    map-underscore-to-camel-case: true
    auto-mapping-behavior: full
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  mapper-locations: classpath*:mapper/**/*Mapper.xml
  global-config:
    # 逻辑删除配置
    db-config:
      # 删除前
      logic-not-delete-value: 1
      # 删除后
      logic-delete-value: 0

10.3 mybatisplus分页插件MybatisPlusConfig：

package com.example.conf;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * 配置分页插件
 *
 */
@Configuration
public class MybatisPlusConfig {
    /**
     * 分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

10.4 创建数据库 创建对应实体类

10.5编写操作实体类的Mapper类（直接继承BaseMapper）：

ps：BaseMapper :UserTest是自己定义对应实体类的类名
ps:运用mybatis-plus 记得在启动类上面添加@MapperScan注解

BaseMapper里面的对应的方法：

10.6 mybatis-plus常用注解：

【@TableName 】    作用于类上
    @TableName               用于定义表名
注：
    常用属性：
        value                用于定义表名
【@TableId】        作用于属性上
    @TableId                 用于定义表的主键
注：
    常用属性：
        value           用于定义主键字段名
        type            用于定义主键类型（主键策略 IdType）
   主键策略：
      IdType.AUTO          主键自增，系统分配，不需要手动输入
      IdType.NONE          未设置主键
      IdType.INPUT         需要自己输入 主键值。
      IdType.ASSIGN_ID     系统分配 ID，用于数值型数据（Long，对应 mysql 中 BIGINT 类型）。
      IdType.ASSIGN_UUID   系统分配 UUID，用于字符串型数据（String，对应 mysql 中 varchar(32) 类型）。
【@TableField】      作用与属性上
    @TableField            用于定义表的非主键字段。
注：
    常用属性：
        value                用于定义非主键字段名
        exist                用于指明是否为数据表的字段， true 表示是，false 为不是。
        fill                 用于指定字段填充策略（FieldFill）。
    字段填充策略：（一般用于填充 创建时间、修改时间等字段）
        FieldFill.DEFAULT         默认不填充
        FieldFill.INSERT          插入时填充
        FieldFill.UPDATE          更新时填充
        FieldFill.INSERT_UPDATE   插入、更新时填充。
【@TableLogic】
    @TableLogic           用于定义表的字段进行逻辑删除（非物理删除）
注：
    常用属性：
        value            用于定义未删除时字段的值
        delval           用于定义删除时字段的值
【@Version】        作用于属性上
    @Version             用于字段实现乐观锁

用法：

/**
 * 用户测试类
 */
//指定数据库表名称 user_test1
@TableName(value = "user_test1")
public class UserTest {
    /**
     * 主键id 设置自增长策略
     */
    @TableId(value = "id",type = IdType.AUTO)
    private int id;
    /**
     * 用户名称
     */
    @TableField(value = "username")
    private String username;
    /**
     * 年龄
     */
    @TableField(value = "age")
    private int age;
    /**
     * 电话
     */
    @TableField(value = "tel")
    private int tel;
    /**
     * 创建时间
     */
    @TableField(value = "create_time")
    private Date create_time;
    /**
     * 最后修改时间
     */
    @TableField(value = "update_time")
    private Date update_time;
    /**
     * 版本号（用于乐观锁，默认为1）
     * @return
     */
    //@Version
    @TableField(value = "version")
    private int version;
}

BaseMapper方法简介：

复制代码
【添加数据：（增）】
    int insert(T entity);              // 插入一条记录
注：
    T         表示任意实体类型
    entity    表示实体对象
【删除数据：（删）】
    int deleteById(Serializable id);    // 根据主键 ID 删除
    int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);  // 根据 map 定义字段的条件删除
    int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper); // 根据实体类定义的 条件删除对象
    int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList); // 进行批量删除
注：
    id        表示 主键 ID
    columnMap 表示表字段的 map 对象
    wrapper   表示实体对象封装操作类，可以为 null。
    idList    表示 主键 ID 集合（列表、数组），不能为 null 或 empty
【修改数据：（改）】
    int updateById(@Param(Constants.ENTITY) T entity); // 根据 ID 修改实体对象。
    int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper); // 根据 updateWrapper 条件修改实体对象
注：
    update 中的 entity 为 set 条件，可以为 null。
    updateWrapper 表示实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
【查询数据：（查）】
    T selectById(Serializable id); // 根据 主键 ID 查询数据
    List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList); // 进行批量查询
    List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap); // 根据表字段条件查询
    T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 根据实体类封装对象 查询一条记录
    Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询记录的总条数
    List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 entity 集合）
    List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 map 集合）
    List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（但只保存第一个字段的值）
    <E extends IPage<T>> E selectPage(E page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 entity 集合），分页
    <E extends IPage<Map<String, Object>>> E selectMapsPage(E page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 map 集合），分页
注：
    queryWrapper 表示实体对象封装操作类（可以为 null）
    page 表示分页查询条件

Service层接口介绍：

IService 内部进一步封装了 BaseMapper 接口的方法（当然也提供了更详细的方法）。
使用时，可以通过 生成的 mapper 类进行 CRUD 操作，也可以通过 生成的 service 的实现类进行 CRUD 操作。（当然，自定义代码执行也可,不选择继承IService）

public interface UserTestService extends IService<UserTest> {
    List<UserTest> LikeListUser(String username);
}

IService方法介绍：

【添加数据：（增）】
    default boolean save(T entity); // 调用 BaseMapper 的 insert 方法，用于添加一条数据。
    boolean saveBatch(Collection<T> entityList, int batchSize); // 批量插入数据
注：
    entityList 表示实体对象集合 
    batchSize 表示一次批量插入的数据量，默认为 1000
【添加或修改数据：（增或改）】
    boolean saveOrUpdate(T entity); // id 若存在，则修改， id 不存在则新增数据
   default boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper); // 先根据条件尝试更新，然后再执行 saveOrUpdate 操作
   boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize); // 批量插入并修改数据 
【删除数据：（删）】
    default boolean removeById(Serializable id); // 调用 BaseMapper 的 deleteById 方法，根据 id 删除数据。
    default boolean removeByMap(Map<String, Object> columnMap); // 调用 BaseMapper 的 deleteByMap 方法，根据 map 定义字段的条件删除
    default boolean remove(Wrapper<T> queryWrapper); // 调用 BaseMapper 的 delete 方法，根据实体类定义的 条件删除对象。
    default boolean removeByIds(Collection<? extends Serializable> idList); // 用 BaseMapper 的 deleteBatchIds 方法, 进行批量删除。
【修改数据：（改）】
    default boolean updateById(T entity); // 调用 BaseMapper 的 updateById 方法，根据 ID 选择修改。
    default boolean update(T entity, Wrapper<T> updateWrapper); // 调用 BaseMapper 的 update 方法，根据 updateWrapper 条件修改实体对象。
    boolean updateBatchById(Collection<T> entityList, int batchSize); // 批量更新数据
【查找数据：（查）】
    default T getById(Serializable id); // 调用 BaseMapper 的 selectById 方法，根据 主键 ID 返回数据。
    default List<T> listByIds(Collection<? extends Serializable> idList); // 调用 BaseMapper 的 selectBatchIds 方法，批量查询数据。
    default List<T> listByMap(Map<String, Object> columnMap); // 调用 BaseMapper 的 selectByMap 方法，根据表字段条件查询
    default T getOne(Wrapper<T> queryWrapper); // 返回一条记录（实体类保存）。
    Map<String, Object> getMap(Wrapper<T> queryWrapper); // 返回一条记录（map 保存）。
    default int count(Wrapper<T> queryWrapper); // 根据条件返回 记录数。
    default List<T> list(); // 返回所有数据。
    default List<T> list(Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectList 方法，查询所有记录（返回 entity 集合）。
    default List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectMaps 方法，查询所有记录（返回 map 集合）。
    default List<Object> listObjs(); // 返回全部记录，但只返回第一个字段的值。
    default <E extends IPage<T>> E page(E page, Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectPage 方法，分页查询
    default <E extends IPage<Map<String, Object>>> E pageMaps(E page, Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectMapsPage 方法，分页查询
注：
    get 用于返回一条记录。
    list 用于返回多条记录。
    count 用于返回记录总数。
    page 用于分页查询。
【链式调用：】
    default QueryChainWrapper<T> query(); // 普通链式查询
    default LambdaQueryChainWrapper<T> lambdaQuery(); // 支持 Lambda 表达式的修改
    default UpdateChainWrapper<T> update(); // 普通链式修改
    default LambdaUpdateChainWrapper<T> lambdaUpdate(); // 支持 Lambda 表达式的修改
注：
    query 表示查询
    update 表示修改
    Lambda 表示内部支持 Lambda 写法。
形如：
    query().eq("column", value).one();
    lambdaQuery().eq(Entity::getId, value).list();
    update().eq("column", value).remove();
    lambdaUpdate().eq(Entity::getId, value).update(entity);

11. springBoot Mybatis多数据源的配置：

11.1 配置 application.yaml:

server:
  port: 8090
spring:
  datasource:
    db1:
      jdbc-url: jdbc:mysql://cdb-5gkdgdz8.bj.tencentcdb.com:10170/test_schema
      username: root
      password: root123456
    db2:
      jdbc-url: jdbc:mysql://cdb-5gkdgdz8.bj.tencentcdb.com:10170/bak_schema
      username: root
      password: root123456
#  mybatis.config-location=classpath:mybatis-config.xml
#mybatis:
#  mapper-locations: classpath*:/mybatis/mapper/*.xml
#  type-aliases-package: com.duing.model
#  config-location: classpath:mybatis-config.xml
#  mybatis.mapper-locations=classpath*:/mappers/*.xml
#  mybatis.type-aliases-package=sample.mybatis.domain

11.2 配置数据源：

package com.duing.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;
@Configuration
public class DBConfig {
    @Bean(name="db1")
    @ConfigurationProperties("spring.datasource.db1")
    public DataSource datasource1(){
        return DataSourceBuilder.create().build();
    }
    @Bean(name="db2")
    @ConfigurationProperties("spring.datasource.db2")
    public DataSource datasource2(){
        return DataSourceBuilder.create().build();
    }
}

11.3 配置 SqlSessionTemplate：

package com.duing.config;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;
@Configuration
@MapperScan(basePackages = "com.duing.mapper",sqlSessionFactoryRef = "sqlSessionFactory1")
/**
*basePackages = "com.duing.mapper":指定那个mapper包下面使用该数据源
*sqlSessionFactoryRef = "sqlSessionFactory1"：代表使用哪一个工厂
*/
public class DBOneConfig {
    @Autowired
    @Qualifier("db1") //第一个数据源
    //@Qualifier("db2") //代表第二个数据源
    private DataSource dataSource;
    @Bean
    public SqlSessionFactory sqlSessionFactory1() throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        return factoryBean.getObject();
    }
    @Bean
    public SqlSessionTemplate sqlSessionTemplate1() throws Exception {
        SqlSessionTemplate template = new SqlSessionTemplate(sqlSessionFactory1());
        return template;
    }
}

12.springboot 事务：

ps：Spring Boot 默认的事务规则是遇到运行异常（RuntimeException）和程序错误（Error）才会回滚。比如上面我们的例子中抛出的 RuntimeException 就没有问题，但是抛出 SQLException 就无法回滚了。针对非运行时异常，如果要进行事务回滚的话，可以在 @Transactional 注解中使用 rollbackFor 属性来指定异常，比如 @Transactional(rollbackFor = Exception.class)，这样就没有问题了，所以在实际项目中，一定要指定异常。

12.1 :Xml方式：

xml的具体内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
     //配置DataSourceTransactionManager 的管理
    <bean id="txManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" ></property>
    </bean>
  //配置事务
    <tx:advice id="txAdvice" transaction-manager="txManager">
      //配置在哪些方法可用
        <tx:attributes>
            <tx:method name="query*" propagation="SUPPORTS" read-only="true" ></tx:method>
            <tx:method name="get*" propagation="SUPPORTS" read-only="true" ></tx:method>
            <tx:method name="select*" propagation="SUPPORTS" read-only="true" ></tx:method>
            <tx:method name="*" propagation="REQUIRED" rollback-for="Exception" ></tx:method>
        </tx:attributes>
    </tx:advice>
  //service 下面的所有方法可用
     <aop:config>
        <aop:pointcut id="allManagerMethod" expression="execution (* com.test.service.*.*(..))" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="allManagerMethod" order="0"/>
    </aop:config>
</beans>

注意：dataSource是直接拿来用的，所以你在加载DataSource对象时候必须命名为dataSource。比如我用的连接池是阿里的druid，这样写：

ps: 要么方法名用dataSource，要么注解写成@Bean(“dataSource”)

12.2: 在启动类上添加@ImportResource注解，例如：@ImportResource(“classpath:transaction.xml”)

12.3 如果使用注解的方式（分为两步：）：

12.3.1 在pom.xml中添加依赖：

<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
</dependency>

12.3.2 配置事务类：

package com.test.aop;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource;
import org.springframework.transaction.interceptor.RollbackRuleAttribute;
import org.springframework.transaction.interceptor.RuleBasedTransactionAttribute;
import org.springframework.transaction.interceptor.TransactionAttribute;
import org.springframework.transaction.interceptor.TransactionInterceptor;
import com.test.domain.DqeProfileDefine;
@Configuration
public class TxAnoConfig {
    @Autowired
    private DataSource dataSource;
    @Bean("txManager")
    public DataSourceTransactionManager txManager() {
        return new DataSourceTransactionManager(dataSource);
    }
    /*事务拦截器*/
    @Bean("txAdvice")
    public     TransactionInterceptor txAdvice(DataSourceTransactionManager txManager){
        NameMatchTransactionAttributeSource source = new NameMatchTransactionAttributeSource();
          /*只读事务，不做更新操作*/
         RuleBasedTransactionAttribute readOnlyTx = new RuleBasedTransactionAttribute();
         readOnlyTx.setReadOnly(true);
         readOnlyTx.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED );
         /*当前存在事务就使用当前事务，当前不存在事务就创建一个新的事务*/
         //RuleBasedTransactionAttribute requiredTx = new RuleBasedTransactionAttribute();
         //requiredTx.setRollbackRules(
         //    Collections.singletonList(new RollbackRuleAttribute(Exception.class)));
         //requiredTx.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
         RuleBasedTransactionAttribute requiredTx = new RuleBasedTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRED,
             Collections.singletonList(new RollbackRuleAttribute(Exception.class)));
         requiredTx.setTimeout(5);
         Map<String, TransactionAttribute> txMap = new HashMap<>();
         txMap.put("add*", requiredTx);
         txMap.put("save*", requiredTx);
         txMap.put("insert*", requiredTx);
         txMap.put("update*", requiredTx);
         txMap.put("delete*", requiredTx);
         txMap.put("get*", readOnlyTx);
         txMap.put("query*", readOnlyTx);
         source.setNameMap( txMap );
        return new TransactionInterceptor(txManager ,source) ;
    }
    /**切面拦截规则 参数会自动从容器中注入*/
    @Bean
    public DefaultPointcutAdvisor defaultPointcutAdvisor(TransactionInterceptor txAdvice){
        DefaultPointcutAdvisor pointcutAdvisor = new DefaultPointcutAdvisor();
        pointcutAdvisor.setAdvice(txAdvice);
        AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
        pointcut.setExpression("execution (* com.test.service.*.*(..))");
        pointcutAdvisor.setPointcut(pointcut);
        return pointcutAdvisor;
    }
}

12.4 事务的基本用法：

@Service
public class UserServiceImpl implements UserService {
    @Resource
    private UserMapper userMapper;
    @Override
    @Transactional
    public void isertUser2(User user) throws Exception {
        // 插入用户信息
        userMapper.insertUser(user);
        // 手动抛出异常
        throw new SQLException("数据库异常");
    }
}

ps:Spring Boot 默认的事务规则是遇到运行异常（RuntimeException）和程序错误（Error）才会回滚。比如上面我们的例子中抛出的 RuntimeException 就没有问题，但是抛出 SQLException 就无法回滚了。针对非运行时异常，如果要进行事务回滚的话，可以在 @Transactional 注解中使用 rollbackFor 属性来指定异常，比如 @Transactional(rollbackFor = Exception.class)，这样就没有问题了，所以在实际项目中，一定要指定异常。

12.4.1 重点注意： try…catch，所以导致异常被 ”吃“ 掉，事务无法回滚：

示例：

@Service
public class UserServiceImpl implements UserService {
    @Resource
    private UserMapper userMapper;
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void isertUser3(User user) {
        try {
            // 插入用户信息
            userMapper.insertUser(user);
            // 手动抛出异常
            throw new SQLException("数据库异常");
        } catch (Exception e) {
            // 异常处理逻辑
        }
    }
}

解决呢？直接往上抛，给上一层来处理即可，千万不要在事务中把异常自己 ”吃“ 掉。
12.5 事务的范围（经典大坑）：

13.springboot 过滤器（Filter）:

自定义Filter 使用Servlet3.0的注解进行配置第三步的@WebFilter就是3.0的注解

   1）启动类里面增加 @ServletComponentScan，进行扫描
   2）新建一个Filter类，implements Filter，并实现对应的接口
    3) @WebFilter 标记一个类为filter，被spring进行扫描
    urlPatterns：拦截规则，支持正则
    4）控制chain.doFilter的方法的调用，来实现是否通过放行不放行，web应用resp.sendRedirect("/index.html");场景：权限控制、用户登录(非前端后端分离场景)等

方式一（@WebFileter注解）：

启动类：

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

自定义拦截器：

import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
//过滤器拦截路径
@WebFilter(urlPatterns = "/api/*", filterName = "loginFilter")
public class LoginFilter  implements Filter{
     /**
      * 容器加载的时候调用
      */
      @Override
      public void init(FilterConfig filterConfig) throws ServletException {
          System.out.println("拦截器进入========拦截器进入========");
      }
      /**
       * 请求被拦截的时候进行调用
       */
      @Override
      public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
          System.out.println("拦截中========拦截中========");
          HttpServletRequest hrequest = (HttpServletRequest)servletRequest;
          HttpServletResponseWrapper wrapper = new HttpServletResponseWrapper((HttpServletResponse) servletResponse);
          if(hrequest.getRequestURI().indexOf("/index") != -1 ||
                  hrequest.getRequestURI().indexOf("/asd") != -1 ||
                  hrequest.getRequestURI().indexOf("/online") != -1 ||
                  hrequest.getRequestURI().indexOf("/login") != -1
                  ) {
              filterChain.doFilter(servletRequest, servletResponse);
          }else {
              wrapper.sendRedirect("/login");
          }
      }
      /**
       * 容器被销毁的时候被调用
       */
      @Override
      public void destroy() {
          System.out.println("拦截器销毁========拦截器销毁========");
      }
}

方式二（配置Fileterconfig）：

1）创建类实现Filter接口；2）注入springboot容器（代码注入 / 通过注解@WebFilter注入）

14.springboot 拦截器Interceptor:

拦截器的原理很简单，是 AOP 的一种实现，专门拦截对动态资源的后台请求，即拦截对控制层的请求。使用场景比较多的是判断用户是否有权限请求后台，更拔高一层的使用场景也有，比如拦截器可以结合 websocket 一起使用，用来拦截 websocket 请求，然后做相应的处理等等。拦截器不会拦截静态资源，Spring Boot 的默认静态目录为 resources/static，该目录下的静态页面、js、css、图片等等，不会被拦截（也要看如何实现，有些情况也会拦截，我在下文会指出）。

原理： 拦截器（代理模式）的实现基于反射，代理又分静态代理和动态代理，动态代理是拦截器的简单实现。 被访问的目标方法通过代理类（方法）来执行，这样就可以在真正要执行的方法执行前、后做一些处理。
使用场景：读取cookie得到用户信息并将用户对象放入请求、统计日志等。

14.1 定义拦截器实现方式：

1）创建拦截器类实现HandlerInterceptor接口 HandlerInterceptor 接口是所有自定义拦截器或者 Spring Boot 提供的拦截器的鼻祖，所以，首先来了解下该接口。该接口中有三个方法： preHandle(……)、postHandle(……) 和 afterCompletion(……) 。

preHandle(……) 方法：该方法的执行时机是，当某个 url 已经匹配到对应的 Controller 中的某个方法，且在这个方法执行之前。所以 preHandle(……) 方法可以决定是否将请求放行，这是通过返回值来决定的，返回 true 则放行，返回 false 则不会向后执行。
postHandle(……) 方法：该方法的执行时机是，当某个 url 已经匹配到对应的 Controller 中的某个方法，且在执行完了该方法，但是在 DispatcherServlet 视图渲染之前。所以在这个方法中有个 ModelAndView 参数，可以在此做一些修改动作。
afterCompletion(……) 方法：顾名思义，该方法是在整个请求处理完成后（包括视图渲染）执行，这时做一些资源的清理工作，这个方法只有在 preHandle(……) 被成功执行后并且返回 true 才会被执行。

/**
 * 自定义拦截器
 * @author shengwu ni
 * @date 2018/08/03
 */
public class MyInterceptor implements HandlerInterceptor {
    private static final Logger logger = LoggerFactory.getLogger(MyInterceptor.class);
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Method method = handlerMethod.getMethod();
        String methodName = method.getName();
        logger.info("====拦截到了方法：{}，在该方法执行之前执行====", methodName);
        // 返回true才会继续执行，返回false则取消当前请求
        return true;
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        logger.info("执行完方法之后进执行(Controller方法调用之后)，但是此时还没进行视图渲染");
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        logger.info("整个请求都处理完咯，DispatcherServlet也渲染了对应的视图咯，此时我可以做一些清理的工作了");
    }
}

2）创建配置类实现WebMvcConfigurer接口（不会拦截静态资源）：

2.2 取消拦截操作：

据上文，如果我要拦截所有 /admin 开头的 url 请求的话，需要在拦截器配置中添加这个前缀，但是在实际项目中，可能会有这种场景出现：某个请求也是 /admin 开头的，但是不能拦截，比如 /admin/login 等等，这样的话又需要去配置。那么，可不可以做成一个类似于开关的东西，哪里不需要拦截，我就在哪里弄个开关上去，做成这种灵活的可插拔的效果呢？

我们可以定义一个注解，该注解专门用来取消拦截操作，如果某个 Controller 中的方法我们不需要拦截掉，即可在该方法上加上我们自定义的注解即可，下面先定义一个注解：

/**
 * 该注解用来指定某个方法不用拦截
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface UnInterception {
}

然后在 Controller 中的某个方法上添加该注解，在拦截器处理方法中添加该注解取消拦截的逻辑，如下：

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    HandlerMethod handlerMethod = (HandlerMethod) handler;
    //获取拦截的方法
    Method method = handlerMethod.getMethod();
    //获取方法名
    String methodName = method.getName();
    logger.info("====拦截到了方法：{}，在该方法执行之前执行====", methodName);
    // 通过方法，可以获取该方法上的自定义注解，然后通过注解来判断该方法是否要被拦截
    // @UnInterception 是我们自定义的注解
    UnInterception unInterception = method.getAnnotation(UnInterception.class);
    if (null != unInterception) {
        return true;
    }
    // 返回true才会继续执行，返回false则取消当前请求
    return true;
}

14+ SpringBoot监听器：

1）作用：监听器用于监听Web应用程序中某些对象或信息的创建、销毁、增加、修改、删除等动作，然后做出相应的处理。

2）原理：当对象的状态发生变化时，服务器自动调用监听器的方法

3）使用场景：监听器常用于统计在线人数、在线用户、系统加载时的信息初始化等

4）分类：Servlet中监听器有3种类型，如下，二级标题是每一个监听器接口，注意，是接口，因此需要我们根据监听内容的不同选择不同接口进行实现，实现类中接口实现方法实现相应事件触发时我们自己的业务逻辑。

监听ServletContext、Request、Session作用域的创建和销毁
ServletContextListener：监听ServletContext
HttpSessionListener：监听新的Session创建事件
ServletRequestListener：监听ServletRequest的初始化和销毁
监听ServletContext、Request、Session作用域中属性的变化（增加、修改、删除）
ServletContextAttributeListener：监听Servlet上下文参数的变化
HttpSessionAttributeListener：监听HttpSession参数的变化
ServletRequestAttributeListener：监听ServletRequest参数的变化
监听HttpSession中对象状态的改变（被绑定、解除绑定、钝化、活化）
HttpSessionBindingListener：监听HttpSession，并绑定及解除绑定
HttpSessionActivationListener：监听钝化和活动的HttpSession状态改变

14.1 监听器的介绍：

什么是 web 监听器？web 监听器是一种 Servlet 中特殊的类，它们能帮助开发者监听 web 中特定的事件，比如 ServletContext, HttpSession, ServletRequest 的创建和销毁；变量的创建、销毁和修改等。可以在某些动作前后增加处理，实现监控。

14.2 监听器的使用：

web 监听器的使用场景很多，比如监听 servlet 上下文用来初始化一些数据、监听 http session 用来获取当前在线的人数、监听客户端请求的 servlet request 对象来获取用户的访问信息等等。这一节中，我们主要通过这三个实际的使用场景来学习一下 Spring Boot 中监听器的使用。

2.1 监听Servlet上下文对象：

监听 servlet 上下文对象可以用来初始化数据，用于缓存。什么意思呢？我举一个很常见的场景，比如用户在点击某个站点的首页时，一般都会展现出首页的一些信息，而这些信息基本上或者大部分时间都保持不变的，但是这些信息都是来自数据库。如果用户的每次点击，都要从数据库中去获取数据的话，用户量少还可以接受，如果用户量非常大的话，这对数据库也是一笔很大的开销。
针对这种首页数据，大部分都不常更新的话，我们完全可以把它们缓存起来，每次用户点击的时候，我们都直接从缓存中拿，这样既可以提高首页的访问速度，又可以降低服务器的压力。如果做的更加灵活一点，可以再加个定时器，定期的来更新这个首页缓存。就类似与 CSDN 个人博客首页中排名的变化一样。

模拟一下从数据库查询数据：

@Service
public class UserService {
    /**
     * 获取用户信息
     * @return
     */
    public User getUser() {
        // 实际中会根据具体的业务场景，从数据库中查询对应的信息
        return new User(1L, "倪升武", "123456");
    }
}

然后写一个监听器，实现 ApplicationListener 接口，重写 onApplicationEvent 方法，将 ContextRefreshedEvent 对象传进去。如果我们想在加载或刷新应用上下文时，也重新刷新下我们预加载的资源，就可以通过监听 ContextRefreshedEvent 来做这样的事情。如下：

/**
 * 使用ApplicationListener来初始化一些数据到application域中的监听器
 * @author shengni ni
 * @date 2018/07/05
 */
@Component
public class MyServletContextListener implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
        // 先获取到application上下文
        ApplicationContext applicationContext = contextRefreshedEvent.getApplicationContext();
        // 获取对应的service
        UserService userService = applicationContext.getBean(UserService.class);
        User user = userService.getUser();
        // 获取application域对象，将查到的信息放到application域中
        ServletContext application = applicationContext.getBean(ServletContext.class);
        application.setAttribute("user", user);
    }
}

正如注释中描述的一样，首先通过 contextRefreshedEvent 来获取 application 上下文，再通过 application 上下文来获取 UserService 这个 bean，项目中可以根据实际业务场景，也可以获取其他的 bean，然后再调用自己的业务代码获取相应的数据，最后存储到 application 域中，这样前端在请求相应数据的时候，我们就可以直接从 application 域中获取信息，减少数据库的压力。

2.2 监听HTTP会话 Session对象：

监听器还有一个比较常用的地方就是用来监听 session 对象，来获取在线用户数量，现在有很多开发者都有自己的网站，监听 session 来获取当前在下用户数量是个很常见的使用场景，下面来介绍一下如何来使用。

/**
 * 使用HttpSessionListener统计在线用户数的监听器
 * @author shengwu ni
 * @date 2018/07/05
 */
@Component
public class MyHttpSessionListener implements HttpSessionListener {
    private static final Logger logger = LoggerFactory.getLogger(MyHttpSessionListener.class);
    /**
     * 记录在线的用户数量
     */
    public Integer count = 0;
    @Override
    public synchronized void sessionCreated(HttpSessionEvent httpSessionEvent) {
        logger.info("新用户上线了");
        count++;
        httpSessionEvent.getSession().getServletContext().setAttribute("count", count);
    }
    @Override
    public synchronized void sessionDestroyed(HttpSessionEvent httpSessionEvent) {
        logger.info("用户下线了");
        count--;
        httpSessionEvent.getSession().getServletContext().setAttribute("count", count);
    }
}

测试方法如下：

@RestController
@RequestMapping("/listener")
public class TestController {
    /**
     * 获取当前在线人数，该方法有bug
     * @param request
     * @return
     */
    @GetMapping("/total")
    public String getTotalUser(HttpServletRequest request) {
        Integer count = (Integer) request.getSession().getServletContext().getAttribute("count");
        return "当前在线人数：" + count;
    }
}

如果关闭一个浏览器再打开，理论上应该还是2，但是实际测试却是 3。原因是 session 销毁的方法没有执行（可以在后台控制台观察日志打印情况），当重新打开时，服务器找不到用户原来的 session，于是又重新创建了一个 session，那怎么解决该问题呢？
解决：把当前的sessionId记录到浏览器。
cookie = new Cookie(“JSESSIONID”, URLEncoder.encode(request.getSession().getId(), “utf-8”));

@GetMapping("/total2")
public String getTotalUser(HttpServletRequest request, HttpServletResponse response) {
    Cookie cookie;
    try {
        // 把sessionId记录在浏览器中
        cookie = new Cookie("JSESSIONID", URLEncoder.encode(request.getSession().getId(), "utf-8"));
        cookie.setPath("/");
        //设置cookie有效期为2天，设置长一点
        cookie.setMaxAge( 48*60 * 60);
        response.addCookie(cookie);
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }
    Integer count = (Integer) request.getSession().getServletContext().getAttribute("count");
    return "当前在线人数：" + count;
}