SpringBoot

一、 Spring Boot简介

SpringBoot本质是Spring Framework，Spring Framework主要作用就是整合其他技术。所以学习Spring Boot就是在学习如何整合其他技术。

二、 第一个基于Spring Boot的Spring MVC项目

1 配置依赖

在pom.xml中添加一个继承（主要目的：1. 配置文件 2. 插件3.依赖jar）
引入springmvc启动器

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.10.RELEASE</version>
</parent>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

1.1 注意
在公司中可能会出现必须继承某个项目，如果Spring Boot用了继承就不能继承别的项目了。所以Spring Boot还提供了依赖的方式。

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.1.10.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

2 新建启动类

必须在包中新建这个类，不能直接放入到java文件夹。在com.bjsxt下新建自定义名称的类(规范：XXXXApplication)

//启动类
//可以自动扫描当前类所在包及子包的注解
//注意：此类要放入到包中
@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class,args);
    }
}

3 新建控制器

在com.bjsxt包下新建 controller.DemoController(保证这个类在启动类子包中(或同级包中))

@Controller
public class DemoController {
    @RequestMapping("/show")
    @ResponseBody
    public String show(){
        return "hello";
    }
}

4 启动项目

运行主方法。
默认tomcat端口为8080端口

三、 Spring Boot配置文件

在官方文档中查询所有SpringBoot已经整合的技术的属性
https://docs.spring.io/spring-boot/docs/2.1.9.RELEASE/reference/html/common-application-properties.html

1 application.properties配置(一般用application.yml)

属性名=属性值

2 application.yml

把属性名根据点进行拆分。例如server.port=8080应该写成

server:
  port: 8080

优点：

有层次感
配置写的更少的了

properties的写法：

spring.datasource.url=xxxx
spring.datasource.username=mmmm

yml写法：

spring:
  datasource:
url: xxx
username: mmmm

还有一个先于application.yml加载的配置文件叫做bootstrap.yml。这个配置用来程序引导的，后面学习SpringCloud时会使用。

四、 Spring Boot项目结构

五、 Spring Boot整合MyBatis

1 依赖启动器

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.1</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.48</version>
</dependency>

1 配置配置文件
在application.yml中添加

# mybatis 配置
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/maven
    username: root
    password: smallming
    driver-class-name: com.mysql.jdbc.Driver
# 加载MyBatis的mapper.xml
mybatis:
  mapper-locations: classpath:mybatis/*.xml

如果希望设置实体类包别名

mybatis:
  mapper-locations: classpath:mybatis/*.xml
  type-aliases-package: com.bjsxt.pojo

2 添加注解
在启动类上添加注解，表示mapper接口所在位置

@SpringBootApplication
@MapperScan("com.bjsxt.mapper")
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class,args);
    }
}

3 编写Mapper接口
在com.bjsxt.mapper下新建接口

public interface UserMapper {
    List<User> selectAll();
}

3.1 在mapper上添加注解
如果不在MyApplication启动类上添加@MapperScan必须在UserMapper接口上添加@Mapper注解。

@Mapper
public interface UserMapper {

4 编写mapper.xml
在resource下新建mybatis文件夹，mapper.xml文件名没有要求了，不需要和接口名完全对应了，是根据namespace去找接口。

六、 Spring Boot整合Druid

1 数据库连接池回顾

在内存中一块空间，空间中放置N多个数据库连接对象。对象可以是处于活动状态，也可以是空闲（Idle）状态的。数据库获取连接对象时不在从数据库中获取连接对象，而是从数据库连接池中获取到连接对象，当获取到连接对象后，对象处于活动状态（Active），当连接对象使用完成后，在代码中进行连接关闭，实际上是把连接对象从活动状态变为空闲状态，不是真正的关闭。
在频繁访问数据库（访问频率特别高的）的应用中，使用数据库连接池效率高。

2 Druid

Druid是由阿里巴巴推出的数据库连接池。它结合了C3P0、DBCP、PROXOOL等数据库连接池的优点。之所以从众多数据库连接池中脱颖而出，还有一个重要的原因就是它包含控制台。

3 代码实现

3.1 添加依赖
此依赖版本一定不能太高，否则和数据库驱动不匹配，无法访问控制台页面。

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.1.9.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.10</version>
    </dependency>
    <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>
    </dependency>
    <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>
        <version>5.1.47</version>
    </dependency>
</dependencies>

3.2 编写配置文件
其中spring.datasource.type就告诉程序使用druid连接池。

spring:
  datasource:
    # 使用阿里的Druid连接池
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    # 填写你数据库的url、登录名、密码和数据库名
    url: jdbc:mysql://localhost:3306/maven?useSSL=false&characterEncoding=utf8
    username: root
    password: root
    druid:
      # 连接池的配置信息
      # 初始化大小，最小，最大
      initial-size: 5
      min-idle: 5
      maxActive: 20
      # 配置获取连接等待超时的时间
      maxWait: 60000
      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      timeBetweenEvictionRunsMillis: 60000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      minEvictableIdleTimeMillis: 300000
      validationQuery: SELECT 1
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      # 打开PSCache，并且指定每个连接上PSCache的大小
      poolPreparedStatements: true
      maxPoolPreparedStatementPerConnectionSize: 20
      # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
      filters: stat,wall,slf4j
      # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
      connectionProperties: druid.stat.mergeSql\=true;druid.stat.slowSqlMillis\=5000
      # 配置DruidStatFilter
      web-stat-filter:
        enabled: true
        url-pattern: "/*"
        exclusions: "*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*"
      # 配置DruidStatViewServlet
      stat-view-servlet:
        url-pattern: "/druid/*"
        # IP白名单(没有配置或者为空，则允许所有访问)
        allow: 127.0.0.1,192.168.163.1
        # IP黑名单 (存在共同时，deny优先于allow)
        deny: 192.168.1.188
        #  禁用HTML页面上的“Reset All”功能
        reset-enable: false
        # 登录名
        login-username: admin
        # 登录密码
        login-password: 123456
mybatis:
  mapper-locations: classpath:mybatis/*.xml

七、 Spring Boot整合PageHelper

Spring Boot整合PageHelper不需要做任何配置文件的配置，添加依赖后就可以直接使用。
1 添加依赖

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
    <version>1.2.12</version>
</dependency>

2 编写代码
代码中一定要注意，要把PageHelper.startPage()写在上面。

//pageNumber为当前页码 pageSize为页大小
PageHelper.startPage(pageNumber,pageSize);
//查询全部
List<POJO> list = tbItemMapper.selectAll();
// 构造方法参数必须是查询全部的结果。否则无法知道给哪个sql后面拼接limit
//PageInfo是分页查询所有查询结果封装的类，所有的结果都从这个类取
PageInfo<TbItem> pi = new PageInfo<>(list);
System.out.println(pi.getList());
System.out.println(pi.getTotal());

八、 Spring Boot整合logback

Spring Boot推荐使用logback作为日志工具。
直接把logback放在resources就可以生效了。

九、 Spring Boot整合JSP

1添加依赖

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
    <scope>provided</scope>
</dependency>

2 在项目中创建webapp目录并将其设置为资源目录
在项目中新建webapp/WEB-INF目录

设置工作目录

3 在 yml配置文件中配置视图解析器参数

4 在控制类中声明单元方法请求转发jsp资源

十、 SpringBoot整合Thymeleaf

Thymeleaf视图显示技术。是Spring Boot官方推荐使用的视图显示技术。
Thymeleaf就是HTML页面，在HTML页面中嵌入Thymeleaf语法标签（HTML标签的属性），效果和JSTL等效。
Thymeleaf在Spring Boot项目中放入到resources/templates中。这个文件夹中的内容是无法通过浏览器URL直接访问的（和WEB-INF效果一样），所有Thymeleaf页面必须先走控制器。

1 步骤

1.1 在pom.xml中添加Thymeleaf启动器

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

1.2 在resources下新建templates文件夹。新建index.html
html页面随意写句话，以免访问index.html是空白页。

1.3 新建控制器
此处方法返回值为页面名称。

@RequestMapping("/showIndex")
public String showIndex(){
    System.out.println("执行index");
    return "index";
}

2 Thymeleaf语法

为了有提示，修改html页面中标签为

<html xmlns:th="http://www.thymeleaf.org" >

2.1 th:text属性
向HTML标签内部输出信息。

<!--直接向标签内部填充内容，清空原有内容 -->
<span th:text="jqk"></span>
<!-- 从作用于中获取name输入到标签内部 -->
<span th:text="${name}"></span>
<!-- 获取session作用域内容-->
<span th:text="${session.name}"></span>

2.2 th:value
表单元素，设置HTML标签中表单元素value属性时使用。

<input type="text" th:value="${name}"/>

2.3 th:if
进行逻辑判断。如果成立该标签生效（显示），如果不成立，此标签无效（不显示）。
注意：判断条件中逻辑判断符号写在${}外面的

<span th:if="${name}!='张三'">会显示</span>

2.4 th:each

循环遍历.
示例中u为迭代遍历。
th:each=”u,i 😒{list}” 其中i表示迭代状态。
1,index:当前迭代器的索引 从0开始
2,count:当前迭代对象的计数 从1开始
3,size:被迭代对象的长度
4,even/odd:布尔值，当前循环是否是偶数/奇数 从0开始
5,first:布尔值，当前循环的是否是第一条，如果是返回true否则返回false
6,last:布尔值，当前循环的是否是最后一条，如果是则返回true否则返回false

<table border="1" width="500">
    <tr>
        <td>编号</td>
        <td>姓名</td>
    </tr>
    <tr th:each="u : ${list}">
        <td th:text="${u.id}" ></td>
        <td th:text="${u.name}"></td>
    </tr>
</table>

2.5 th:href
设置href属性的。取值使用@{}取值

<a th:href="@{/getParam(id=1,name='bjsxt')}" >跳转</a>
<!-- 获取作用域值-->
<a th:href="@{/getParam(name=${name})}">跳转二</a>

十一、 Spring Boot 开发者工具(电脑性能不好不推荐使用)

使用开发者工具包不需要重启。监听内容改变。

1 在pom.xml中添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>

2 导入SpringBoot打包插件

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <fork>true</fork>
            </configuration>
        </plugin>
    </plugins>
</build>

注意:需要配置继承父项目，统一版本号

<!--配置项目继承-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.10.RELEASE</version>
</parent>

3 设置IDEA自动编译

菜单 File --> settings

4 修改Registry

Ctrl+Shift+Alt+/ 点击弹出框中Registry…

勾选

十二、 Spring Boot项目打包部署

SpringBoot项目可以是jar类型的maven项目，也可以是一个war
类型的maven项目，取决于我们要不要整合jsp使用。但是不管 是哪种项目类型， 已经不是我们传统意义上的项目结构了，在本 地使用SpringBoot的启动器即可 访问我们开发的项目。如果我们将项目功能开发完成后，需要使用SpringBoot的打包 功能来将项目进行打包。
SpringBoot项目打包在linux服务器中运行:
①jar类型项目会打成jar包:
jar类型项目使用SpringBoot打包插件打包时，会在打成的jar中内置一个tomcat 的jar。所以我们可以使用jdk直接运行该jar项目即可，jar项目中有一个功能， 将功能代码放到其内置的tomcat中运行。我们直接使用浏览器访问即可。
②war类型项目会打成war包:
在打包时需要将内置的tomcat插件排除，配置servlet的依赖。
将war正常的放到tomcat服务器中运行即可。

1 SpringBoot项目打包插件

必须保证项目中包含SpringBoot打包插件。pom.xml中检查

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <fork>true</fork>
            </configuration>
        </plugin>
    </plugins>
</build>

2 SpringBoot项目打包成jar包

点击IDEA右侧Maven – > Lifecycle --> install

打包后的内容出现在target根目录

2.1运行jar包项目

① 在本地windows系统中运行
把此jar粘贴到任意目录，示例粘贴到D根目录下
启动windows命令行。依次输入：

# d:
# java-jar 文件名.jar

也可以新建一个批处理文件，例如：run.bat，在文件中添加

d:
java -jar 文件名.jar

② 部署到linux
1、和windows步骤一样。把jar上传到linux后放入到任意目录中，进入到jar所在目录 后执行java -jar 文件.jar 就可以运行。
2、也可以在jar所在文件夹中新建一个文件，执行运行文件。

# vim startup.sh
文件中输入java -jar 文件.jar
# chmod a+x startup.sh
# ./startup

3.SpringBoot项目打包成war包

① 如果我们当前的maven项目本身就是war类型的项目，直接打包即可
但是如果我们当前的maven项目是jar类型的项目，我们需要将项目修改
为war类型，修改项目的pom文件，使用packaging标签设置值为war
并且需要在项目中创建webApp文件夹，并设置为资源文件夹。

② 在SpringBoot的pom文件中将web启动器中的tomcat依赖排除
因为我们打包的war项目要放在自己的tomcat服务器中运行，需要
排出SpringBoot项目内置的tomcat。然后再手动的将tomcat插件
依赖过来，并设置其scope值为provided。

<!--配置SpringBoot的web启动器-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <!--排除web启动中自动依赖的tomcat插件-->
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!--
    手动依赖tomcat插件，但是表明项目打包时该依赖不会被打进去，目的主要是保证开发阶段本地SpringBoot
    项目可以正常运行
-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <!--打包的时候可以不用包进去，别的设施会提供。事实上该依赖理论上可以参与编译，测试，运行等周期。
        相当于compile，但是打包阶段做了exclude操作-->
    <scope>provided</scope>
</dependency>

③ SpringBoot的启动类继承SpringBootServletInitializer，并重写configure

@SpringBootApplication
@MapperScan("com.bjsxt.mapper")
public class MyApplication extends SpringBootServletInitializer {
    //重写配置方法
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(MyApplication.class);
    }
    public static void main(String[] args) {
        //启动SpringBoot
        SpringApplication.run(MyApplication.class,args);
    }
}

④ 使用install命令打包项目，并将war包放到tomcat下的webapps下，启动
tomcat即可。

⑤如果我们使用的是tomcat7则需要将javax.el-api-3.0.0.jar包放到tomcat下 的lib目录中。

十三、 异常显示页面

默认情况，Spring Boot项目错误页面如下。

当项目实际上线，如果给用户显示这个页面就不是很友好。当系统出现异常时应该给用户显示更加友好的错误页面。

1 设置具体的状态码页面

在templates/下新建error文件夹，在error中新建：状态.html的页面。例如当出现500时显示的页面为500.html

1 使用x进行模糊匹配

当出现5开头状态码的错误时，显示页面可以命名为5xx.html
当出现50开头状态码的错误时，显示页面可以命名为50x.html

2 统一错误显示页面

在templates下新建error.html。如果项目中不存在具体状态码的页面或没有使用x成功匹配的页面时，显示error.html作为错误显示页面。

十四、 异常处理

在Spring Boot项目中除了设置错误页面，还可以通过注解实现错误处理。
常见方式有两种：
1、在控制器类中添加一个方法，结合@ExceptionHandler。但是只能对当前控制器中方法出现异常进行解决。
2、新建全局异常类，通过@ControllerAdvice结合@ExceptionHandler。当全局异常处理和局部处理同时存在时，局部生效（就近原则）

1 局部异常处理

@Controller
public class DemoController {
    @RequestMapping("/demo1")
    @ResponseBody
    public String demo1(){
        int i = 5/0;
        return "demo1";
    }

    @ExceptionHandler(ArithmeticException.class)
    @ResponseBody
    public String ArithmeticException(){
        return "出错了";
    }
}

2 全局异常处理类

@ControllerAdvice
public class ExceptionController {
    @ExceptionHandler(ArithmeticException.class)
    @ResponseBody
    public String AriExceptioin(){
        return "执行全局";
    }
}

十五、 Spring整合Junit5

1 添加启动器

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

2 编写测试类

在src/main/test里面新建com.bjsxt.MyTest
注意：

1. 测试类不能叫做Test
2. 测试方法必须是public
3. 测试方法返回值必须是void
4. 测试方法必须没有参数

//告诉SpringBoot使用哪个单元测试工具
@ExtendWith(SpringExtension.class)
@WebAppConfiguration
//当前类为测试类，classes指定哪个类为启动类
@SpringBootTest(classes = MyApplication.class)
public class MyTest {
    @Autowired
    UserMapper userMapper;
    @Autowired
    private UserService userService;
    @Test
    public void test(){
        User user = userMapper.selectById(1L);
        System.out.println(user);
        System.out.println(userService.test());
    }
}

十六、 Spring Boot整合Quartz

1 scheduled简介

Scheduled是Spring3.0后内置的定时任务器。通过Scheduled可以完成周期的执行一些功能。存在于spring-conext-support.jar中。
在SpringBoot中使用Scheduled非常简单，只需要在对应的方法上添加@Scheduled注解在配置对应的参数就可以完成。

2 SpringBoot中Scheduled代码实现

新建Maven项目SpringQuartz。
2.1 添加依赖
由于spring-boot-starter-web并没有依赖spring-conext-support，所以需要单独添加此依赖。

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.10.RELEASE</version>
</parent>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
    </dependency>
</dependencies>

2.2 创建启动类
新建com.bjsxt.QuartzApplication启动类

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

2.3 新建定时任务
新建com.bjsxt.scheduled.DemoScheduled类。
注意类上有@Component注解，启动项目就需要加载类及类中的@Scheduled注解。

@Component
public class DemoScheduled {
    @Scheduled(cron="0/2 * * * * *")
    public void testScheduled(){
        System.out.println("test scheduled");
    }
}

3 cron表达式

Cron表达式是一个字符串，分为6或7个域，每一个域代表一个含义
Cron有如下两种语法格式：
（1） Seconds Minutes Hours Day Month Week Year
（2）Seconds Minutes Hours Day Month Week
3.1 结构
corn从左到右（用空格隔开）：
秒 分 小时 月份中的日期 月份 星期中的日期 年份
3.2 各字段的含义

Cron表达式的时间字段除允许设置数值外，还可使用一些特殊的字符，提供列表、范围、通配符等功能，细说如下：

●星号(*)：可用在所有字段中，表示对应时间域的每一个时刻，例如，在分钟字段时，表示“每分钟”；
●问号（?）：该字符只在日期和星期字段中使用，它通常指定为“无意义的值”，相当于占位符；
●减号(-)：表达一个范围，如在小时字段中使用“10-12”，则表示从10到12点，即10,11,12；
●逗号(,)：表达一个列表值，如在星期字段中使用“MON,WED,FRI”，则表示星期一，星期三和星期五；
●斜杠(/)：x/y表达一个等步长序列，x为起始值，y为增量步长值。如在分钟字段中使用0/15，则表示为0,15,30和45秒，而5/15在分钟字段中表示5,20,35,50，你也可以使用/y，它等同于0/y；
●L：该字符只在日期和星期字段中使用，代表“Last”的意思，但它在两个字段中意思不同。L在日期字段中，表示这个月份的最后一天，如一月的31号，非闰年二月的28号；如果L用在星期中，则表示星期六，等同于7。但是，如果L出现在星期字段里，而且在前面有一个数值X，则表示“这个月的最后X天”，例如，6L表示该月的最后星期五；
●W：该字符只能出现在日期字段里，是对前导日期的修饰，表示离该日期最近的工作日。例如15W表示离该月15号最近的工作日，如果该月15号是星期六，则匹配14号星期五；如果15日是星期日，则匹配16号星期一；如果15号是星期二，那结果就是15号星期二。但必须注意关联的匹配日期不能够跨月，如你指定1W，如果1号是星期六，结果匹配的是3号星期一，而非上个月最后的那天。W字符串只能指定单一日期，而不能指定日期范围；
●LW组合：在日期字段可以组合使用LW，它的意思是当月的最后一个工作日；
●井号(#)：该字符只能在星期字段中使用，表示当月某个工作日。如6#3表示当月的第三个星期五(6表示星期五，#3表示当前的第三个)，而4#5表示当月的第五个星期三，假设当月没有第五个星期三，忽略不触发；
● C：该字符只在日期和星期字段中使用，代表“Calendar”的意思。它的意思是计划所关联的日期，如果日期没有被关联，则相当于日历中所有日期。例如5C在日期字段中就相当于日历5日以后的第一天。1C在星期字段中相当于星期日后的第一天。
Cron表达式对特殊字符的大小写不敏感，对代表星期的缩写英文大小写也不敏感。

例子:

@Scheduled(cron = “0 0 1 1 1 ?”)//每年一月的一号的1:00:00 执行一次
@Scheduled(cron = “0 0 1 1 1,6 ?”) //一月和六月的一号的1:00:00 执行一次
@Scheduled(cron = “0 0 1 1 1,4,7,10 ?”) //每个季度的第一个月的一号的1:00:00 执行一次
@Scheduled(cron = “0 0 1 1 * ?”)//每月一号 1:00:00 执行一次
@Scheduled(cron=“0 0 1 * * *”) //每天凌晨1点执行一次

4 Quartz

4.1 简介

官方解释

Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目。可以方便的继承在Java项目中完成任务调度功能。总体功能和java.util.Timer很像，但是要比Timer功能更加强大。且不像Scheduler执行一个固定的任务，在Quartz可以对任务进行操作，新增任务，删除任务等。

例如：
每天固定时间执行任务！
每隔2天执行一次任务！
这些都是任务调度。Quartz都可以轻松地完整这些事情。

4.2 核心

Quartz核心包含四个概念。
4.2.1 Job

表示一个工作，要执行的具体内容。

4.2.2 JobDetail

表示一个具体的可执行的调度任务。JobDetail除了包含Job还包含了任务调度和策略。

4.2.3 Trigger

触发器。配置调度参数，定义什么时候去调用。

4.2.4 Scheduler

表示调度容器。Scheduler可以包含多个JobDetail和Trigger。

5 SpringBoot整合Quartz

新建Maven项目SpringQuartz

5.1 新建数据库导入数据

在MySQL中新建数据库quartz。
运行quartz.sql文件，导入数据文件（在当前版本中使用数据库初始化文件属性always不生效。）

5.2 添加依赖

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.1.9.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

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

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

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

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

5.3 配置配置文件

新建application.yml，并配置数据源

spring:
  datasource:
    username: root
    driver-class-name: com.mysql.jdbc.Driver
    password: root
    url: jdbc:mysql://localhost:3306/quartz?useSSL=false
 quartz:
      jdbc:
        initialize-schema: never
      job-store-type: jdbc

5.4 新建静态类

新建com.bjsxt.statics.QuartzStatic。为了记录每次执行Job的时间，定义一个静态常量。

public class QuartzStatic {
    public static long preTime=0L;
}

5.5 新建Job

新建com.bjsxt.job.MyJob定义Job的内容。

public class MyJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        long currTime = System.currentTimeMillis();
        if(QuartzStatic.preTime==0L){
            QuartzStatic.preTime = currTime;
        }
        System.out.println("execute执行-- MyJob"+(currTime- QuartzStatic.preTime));
        QuartzStatic.preTime = currTime;
    }
}

5.6 新建启动类

新建com.bjsxt.QuartzApplication

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

5.7 新建测试类

新建测试类com.bjsxt.MyTest。
在测试类中测试Quartz中新增、修改、删除、暂停、恢复、查询等功能。在每个功能执行完成后要注意数据库中数据的变化。

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class MyTest {

    @Autowired
    private Scheduler scheduler;
    @Test
    public void testRun(){
        try {
            Thread.sleep(50000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Test
    public void testAdd() {
        System.out.println("scheduler:" + scheduler);
        JobDetail jobDetais = JobBuilder.newJob(MyJob.class).withIdentity("job-name", "job-group").build();
        jobDetais.getJobDataMap().put("data-key","data-value");
        Trigger trigger = TriggerBuilder.newTrigger().withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?")).withIdentity("trigger-name", "trigger-value").build();
        try {
            Date date = scheduler.scheduleJob(jobDetais, trigger);
            scheduler.start();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }



    public void update(){
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey("trigger-name", "trigger-value");
            CronTrigger trigger = (CronTrigger)scheduler.getTrigger(triggerKey);
            trigger= trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?")).build();
            scheduler.rescheduleJob(triggerKey,trigger);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }


    public void testDeleteJob(){
        try {
            boolean result = scheduler.deleteJob(new JobKey("job-name", "job-group"));
            System.out.println("执行结果："+result);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }


    public void testPauseJob(){
        try {
            JobKey jobKey = new JobKey("job-name", "job-group");
            scheduler.pauseJob(jobKey);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
    @Test
    public void testResumeJob(){
        try {
            JobKey jobKey = new JobKey("job-name", "job-group");
            scheduler.resumeJob(jobKey);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
    @Test
    public void testQueryJobs(){
        try {
            GroupMatcher<JobKey> groupMatcher = GroupMatcher.anyJobGroup();
            Set<JobKey> jobKeySet = scheduler.getJobKeys(groupMatcher);
            for(JobKey jobKey : jobKeySet){
                List<? extends Trigger> listTriggers = scheduler.getTriggersOfJob(jobKey);
                System.out.println("=========================================");
                for(Trigger trigger : listTriggers){
                    System.out.println(jobKey.getName());
                    System.out.println(jobKey.getGroup());
                    System.out.println(scheduler.getTriggerState(trigger.getKey()));
                    System.out.println(((CronTrigger) trigger).getCronExpression());
                }
                System.out.println("==========================================");
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

    }
}

十七、 Spring Boot中Bean管理

Spring Boot 由于没有XML文件，所以所有的Bean管理都放入在一个配置类中实现。
配置类就是类上具有@Configuration的类。这个类就相当于之前的applicationContext.xml

1 创建同类型Bean的实现方式

1.1 新建配置类
com.bjsxt.config.MyConfig ， 规范都是放入到config文件夹中。
注意：
配置类要有@Configuration
方法要有@Bean

@Configuration
public class MyConfig {
    //访问权限修饰符没有强制要求，一般是protected
    //返回值就是注入到Spring容器中实例类型。
    // 方法名没有强制要求,相当于<bean >中id属性。
    @Bean
    protected User jqk(){
        User user = new User();
        user.setId(1L);
        user.setName("张三");
        return user;
    }
    //自定义bean名称
    @Bean("nml")
    protected  User abc(){
        User user = new User();
        user.setId(2L);
        user.setName("李四");
        return user;
    }
}

1.2 新建测试类
如果Spring容器中存在同类型的Bean通过Bean的名称获取到Bean对象。或结合@Qualifier使用

@SpringBootTest(classes = BeanApplication.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class test {
    @Autowired
    @Qualifier("jqk")
    private User abc;
    @Test
    public void test(){
        System.out.println(abc);
    }
}

2 配置类中获取容器对象

在配置类的方法中通过方法参数让Spring容器把对象注入。

//自定义bean名称
@Bean("nml")
protected  User abc(){
    User user = new User();
    user.setId(2L);
    user.setName("李四");
    return user;
}

@Bean
//可以直接从方法参数中取到。
public People peo(User nml){
    People p = new People();
    p.setUser(nml);
    return p;
}

十八、 SpringBoot整合拦截器

1 新建拦截器类。

注意：
不要忘记类上注解@Component

@Component
public class DemoInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("执行拦截器");
        return false;
    }
}

2 配置拦截器

注意：
类上有注解@Configuration。此类相当于SpringMVC配置文件。
addPathPattern(): 拦截哪些URL。 /** 拦截全部
excludePathPatterns(): 不拦截哪些URL。当和addPathPattern()冲突时， excludePathPatterns()生效。

@Configuration
public class MyConfig implements WebMvcConfigurer {
    @Autowired
    private DemoInterceptor demoInterceptor;
    //配置拦截器的映射
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(demoInterceptor).addPathPatterns("/**").excludePathPatterns("/login");
    }


}

十九、 Spring框架提供的MD5加密工具类

String md5 = DigestUtils.md5DigestAsHex("smallming".getBytes());
System.out.println(md5);