Quartz入门教程

水深无声 2024-03-27 16:30 22阅读 0赞

> 本文[参考文章][Link 1]编写

### Quartz ###

[官网][Link 2]

> `Quartz` 是 OpenSymphony 开源组织在 Job Scheduling 领域又一个开源项目，是完全由 Java 开发的一个开源任务日程管理系统，“任务进度管理器”就是一个在预先确定（被纳入日程）的时间到达时，负责执行（或者通知）其他软件组件的系统。 Quartz 是一个开源的作业调度框架，它完全由 Java 写成，并设计用于 J2SE 和 J2EE 应用中，它提供了巨大的灵活性而不牺牲简单性

### 应用场景 ###

在日常的开发过程中，简单的定时任务，比如每天凌晨对数据进行备份，这样的场景，我们使用 `Spring`提供的注解 `@Schedule`就可以满足业务，但是对于一些复杂的任务调度场景，比如日程提醒，从日程中取消，开始，停止，暂停日程进度，这样复杂一些的场景，`@Schedule`就无法满足了，此时就需要用到Quartz ，它可以**持久性作业（即，保持调度定时的状态）** ，**作业管理 （即，对调度作业进行有效的管理）**

### 组成部分 ###

![在这里插入图片描述][a712e72f6cfb4adc97434e31729517f6.png]

*  `Scheduler`：`Quartz` 中的任务调度器，通过 `Trigger(触发器)` 和 `JobDetail(任务详情)`可以用来调度、暂停和删除任务。调度器就相当于一个容器，装载着任务和触发器，该类是一个接口，代表一个 `Quartz` 的独立运行容器，`Trigger(触发器)` 和 `JobDetail(任务详情)`可以注册到 `Scheduler`中，这样当`Trigger(触发器)`被触发时，对应的`Job`就会执行,两者在 `Scheduler`中拥有各自的组及名称，组及名称是 `Scheduler`查找定位容器中某一对象的依据，`Trigger(触发器)` 的组及名称必须唯一，`JobDetail(任务详情)`的组和名称也必须唯一，但二者的组名称可以一致，因为它们是不同类型的
 *  `Trigger`：`Quartz` 中的触发器，是一个类，描述触发 `Job(任务)` 执行的时间触发规则，主要有 `SimpleTrigger`和 `CronTrigger`这两个子类。当且仅当需调度一次或者以固定时间间隔周期执行调度，`SimpleTrigger` 是最适合的选择；而 `CronTrigger` 则可以通过 `Cron`表达式定义出各种复杂时间规则的调度方案：如工作日周一到周五的 15：00 ~ 16：00 执行调度等
 *  `JobDetail`：`Quartz`中需要执行的任务详情，包括了任务的唯一标识和具体要执行的任务，可以通过 `JobDataMap` 往任务中传递数据，`JobDetail`绑定指定的Job，每次`Scheduler`调度执行一个`Job`的时候，首先会拿到对应的`Job`，然后创建该`Job`实例，再去执行`Job`中的`execute()`的内容，任务执行结束后，关联的`Job`对象实例会被释放，且会被`JVM GC`清除
 *  `Job`：`Quartz`中具体的任务，包含了执行任务的具体方法。是一个接口，只定义一个方法`execute()`方法，在实现接口的 `execute()`方法中编写业务逻辑
 *  `JobExecutionContext`:`JobExecutionContext`中包含了`Quartz`运行时的环境以及`Job`本身的详细数据信息。当`Schedule`调度执行一个`Job`的时候，就会将`JobExecutionContext`传递给该`Jo`b的`execute()`中，`Job`就可以通过`JobExecutionContext`对象获取信息。

### Cron 表达式 ###

[Cron表达式在线生成][Cron]

> Cron 表达式是一个字符串，包括 6~7 个时间元素，在 Quartz 中可以用于指定任务的执行时间

*  Cron 语法

秒 分 小时 日 月 周 年
    
    例：
    0/2 * * * * ?   表示每2秒 执行任务
    0 0/2 * * * ?    表示每2分钟 执行任务

<table> 
 <thead> 
  <tr> 
   <th>时间元素</th> 
   <th>可出现的字符</th> 
   <th>有效数值范围</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>秒</td> 
   <td>, - * /</td> 
   <td>0-59</td> 
  </tr> 
  <tr> 
   <td>分</td> 
   <td>, - * /</td> 
   <td>0-59</td> 
  </tr> 
  <tr> 
   <td>小时</td> 
   <td>, - * /</td> 
   <td>0-23</td> 
  </tr> 
  <tr> 
   <td>日</td> 
   <td>, - * / ? L W</td> 
   <td>0-31</td> 
  </tr> 
  <tr> 
   <td>月</td> 
   <td>, - * /</td> 
   <td>1-12</td> 
  </tr> 
  <tr> 
   <td>周</td> 
   <td>, - * / ? L #</td> 
   <td>1-7或SUN-SAT</td> 
  </tr> 
  <tr> 
   <td>年</td> 
   <td>, - * /</td> 
   <td>当前年份-大于等于当前年份（例：2023-2024）</td> 
  </tr> 
 </tbody> 
</table>

*  Cron 语法中特殊字符说明

<table> 
 <thead> 
  <tr> 
   <th>字符</th> 
   <th>作用</th> 
   <th>举例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>,</td> 
   <td>列出枚举值</td> 
   <td>在分钟域使用5,10，表示在5分和10分各触发一次</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>表示触发范围</td> 
   <td>在分钟域使用5-10，表示从5分到10分钟每分钟触发一次</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>匹配任意值</td> 
   <td>在分钟域使用*, 表示每分钟都会触发一次</td> 
  </tr> 
  <tr> 
   <td>/</td> 
   <td>起始时间开始触发，每隔固定时间触发一次</td> 
   <td>在分钟域使用5/10,表示5分时触发一次，每10分钟再触发一次</td> 
  </tr> 
  <tr> 
   <td>?</td> 
   <td>在日和周中，用于匹配任意值</td> 
   <td>在日域使用?,表示每天都触发一次</td> 
  </tr> 
  <tr> 
   <td>#</td> 
   <td>在周中，确定第几周星期几</td> 
   <td>1#2 表示第1周 的星期2</td> 
  </tr> 
  <tr> 
   <td>L</td> 
   <td>表示最后</td> 
   <td>在周中，4L表示本月最后一个星期4</td> 
  </tr> 
  <tr> 
   <td>W</td> 
   <td>表示有效工作日(周一到周五)</td> 
   <td>2W,表示每月 2号最近的那个工作日</td> 
  </tr> 
 </tbody> 
</table>

### Quartz基于数据库存储任务信息 ###

> 为了保证可以动态的添加，删除任务，`Quartz` 存储任务信息有两种方式，使用内存或者使用数据库来存储

[数据库SQL脚本官网下载地址][SQL]

![在这里插入图片描述][473561e3009c40a08f6e1a2d847cfb2a.png]

*  解压下载后的`quartz-2.3.0-distribution.tar.gz`文件，在`quartz-2.3.0-distribution\quartz-2.3.0-SNAPSHOT\src\org\quartz\impl\jdbcjobstore`目录下得到各类型数据库的SQL脚本  
    ![在这里插入图片描述][4d255e2dc9a64f54ad8a980ce3afd71a.png]
 *  `Quartz` 目前支持的数据库  
    `cloudscape数据库`：一个以 Java 类库形式提供的、轻量级的、可嵌入的关系引擎。与其他的关系数据库系统类似。Cloudscape 也有事务（提交和回滚），并提供了崩溃恢复。与其他数据库一样，它允许多个线程共享同一连接  
    `cubrid数据库`：是一个全面开源，且完全免费的关系数据库管理系统  
    `db2数据库`:DB2就是IBM开发的一种大型关系型数据库平台  
    `derby数据库`：一个完全用java编写的数据库，非常小巧，既可以做为单独的数据库服务器使用，也可以内嵌在应用程序中使用  
    `firebird数据库`:一个真正的关系数据库，支持存储过程、视图、触发器、事务等大型关系数据库的所有特性  
    `h2数据库`：h2是一个开源的、纯java实现的关系数据库。支持网络版和嵌入式版本，另外还提供了内存版,支持相当标准的sql标准,提供了非常友好的基于web的数据库管理界面  
    `hsqldb数据库`:一个开放源代码的JAVA数据库，其具有标准的SQL语法和JAVA接口  
    `informix数据库`:是IBM公司出品的关系数据库管理系统（RDBMS）家族。作为一个集成解决方案，它被定位为作为IBM在线事务处理（OLTP）旗舰级数据服务系统  
    `mysql数据库`：一个关系型数据库管理系统，由瑞典MySQL AB 公司开发，是最流行的关系型数据库管理系统之一  
    `oracle数据库`:是甲骨文公司的一款关系数据库管理系统。它是一种高效率的、可靠性好的、适应高吞吐量的数据库方案。  
    `pointbase数据库`:是由oracle的创始人之一的Bruce Scott开发的一套小型数据库。  
    `postgresql数据库`:是一种特性非常齐全的自由软件的对象-关系型数据库管理系统  
    `sapdb数据库`:sapdb是SAP公司开发的开源数据库，结构和Oracle非常近似  
    `solid数据库`:solid数据库是一款“轻量级”的数据库，是标准的 关系型数据库，支持 SQL / ACID / 事务隔离级别等标准，也支持存储过程、 触发器、事件等。  
    `SQL Server数据库`:美国Microsoft公司推出的一种关系型数据库系统。支持对称多处理器结构、存储过程、ODBC，并具有自主的SQL语言  
    `sybase数据库`:美国Sybase公司研制的一种关系型数据库系统，是一种典型的UNIX或WindowsNT平台上客户机/服务器环境下的大型数据库系统。
 *  使用脚本`tables_mysql.sql`创建的表概述(*此处字段中的注释为后续补充，官网脚本并未提供*)

`1.qrtz_blob_triggers表`：自定义的**triggers**使用**blog**类型进行存储，非自定义的**triggers**不会存放在此表中，**Quartz**提供的**triggers**包括：**CronTrigger**，**CalendarIntervalTrigger**，**DailyTimeIntervalTrigger**以及**SimpleTrigger**，这几个**trigger**信息会保存在后面的几张表中

CREATE TABLE `qrtz_blob_triggers`  (
      `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '调度器名称',
      `TRIGGER_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '触发器名称，qrtz_triggers表trigger_name的外键',
      `TRIGGER_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '触发器群组，qrtz_triggers表trigger_group的外键',
      `BLOB_DATA` blob NULL COMMENT '任务信息，存放持久化job对象',
      PRIMARY KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) USING BTREE,
      CONSTRAINT `qrtz_blob_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) ON DELETE RESTRICT ON UPDATE RESTRICT
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = 'Trigger 作为 Blob 类型存储(用于 Quartz 用户用 JDBC 创建他们自己定制的 Trigger 类型，JobStore 并不知道如何存储实例的时候)' ROW_FORMAT = Dynamic;

`2.qrtz_calendars表`：**Quartz**为我们提供了日历的功能，可以自己定义一个时间段，可以控制触发器在这个时间段内触发或者不触发；现在提供6种类型：**AnnualCalendar**，**CronCalendar**，**DailyCalendar**，**HolidayCalendar**，**MonthlyCalendar**，**WeeklyCalendar**

CREATE TABLE `qrtz_calendars`  (
      `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '调度器名称',
      `CALENDAR_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '触发器名称',
      `CALENDAR` blob NOT NULL COMMENT '日历信息，存放持久化calendar对象',
      PRIMARY KEY (`SCHED_NAME`, `CALENDAR_NAME`) USING BTREE
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '以 Blob 类型存储存放日历信息， quartz可配置一个日历来指定一个时间范围。' ROW_FORMAT = Dynamic;

`3.qrtz_cron_triggers表`：存放**cron**类型的触发器

CREATE TABLE `qrtz_cron_triggers`  (
      `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '调度器名称',
      `TRIGGER_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '触发器名称，qrtz_triggers表trigger_name的外键',
      `TRIGGER_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '触发器组名称，qrtz_triggers表trigger_group的外键',
      `CRON_EXPRESSION` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT 'cron表达式',
      `TIME_ZONE_ID` varchar(80) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '时区',
      PRIMARY KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) USING BTREE,
      CONSTRAINT `qrtz_cron_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) ON DELETE RESTRICT ON UPDATE RESTRICT
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '存储触发器的cron表达式' ROW_FORMAT = Dynamic;

`4.qrtz_fired_triggers表`：存储已经触发的**trigger**相关信息，**trigger**随着时间的推移状态发生变化，直到最后**trigger**执行完成，从表中被删除；

CREATE TABLE `qrtz_fired_triggers`  (
      `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '调度器名称',
      `ENTRY_ID` varchar(95) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '调度器实例id',
      `TRIGGER_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '触发器名称，qrtz_triggers表trigger_name的外键',
      `TRIGGER_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '触发器组，qrtz_triggers表trigger_group的外键',
      `INSTANCE_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '调度器实例名',
      `FIRED_TIME` bigint(13) NOT NULL COMMENT '触发时间',
      `SCHED_TIME` bigint(13) NOT NULL COMMENT '定时器制定的时间',
      `PRIORITY` int(11) NOT NULL COMMENT '优先级',
      `STATE` varchar(16) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '状态',
      `JOB_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '集群中job的名字,该名字用户自己可以随意定制,无强行要求',
      `JOB_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '集群中job的所属组的名字,该名字用户自己随意定制,无强行要求',
      `IS_NONCONCURRENT` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '是否并发',
      `REQUESTS_RECOVERY` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '是否接受恢复执行，默认为false，设置了RequestsRecovery为true，则会被重新执行',
      PRIMARY KEY (`SCHED_NAME`, `ENTRY_ID`) USING BTREE
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '存储与已触发的 Trigger 相关的状态信息，以及相联 Job 的执行信息。' ROW_FORMAT = Dynamic;

`5.qrtz_job_details表`：存储**jobDetails**信息，相关信息在定义的时候指定

CREATE TABLE `qrtz_job_details`  (
      `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '调度器名称',
      `JOB_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '任务名称',
      `JOB_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '任务群组',
      `DESCRIPTION` varchar(250) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '关于任务的说明',
      `JOB_CLASS_NAME` varchar(250) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '任务class全路径，quartz就是根据这个路径到classpath找到该job类',
      `IS_DURABLE` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '是否为持久，把该属性设置为1，quartz会把job持久化到数据库中',
      `IS_NONCONCURRENT` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '是否并发',
      `IS_UPDATE_DATA` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '是否更新数据',
      `REQUESTS_RECOVERY` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '是否接受恢复执行，默认为false，设置了RequestsRecovery为true，则该job会被重新执行',
      `JOB_DATA` blob NULL COMMENT '任务信息，存放持久化job对象',
      PRIMARY KEY (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`) USING BTREE
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '存储每一个已配置的 jobDetail 的详细信息' ROW_FORMAT = Dynamic;

`6.qrtz_locks表`：**Quartz**提供的锁表，存储程序的悲观锁的信息(假如使用了悲观锁)，为多个节点调度提供分布式锁，实现分布式调度，默认有2个锁；  
**STATE\_ACCESS**主要用在**scheduler**定期检查是否失效的时候，保证只有一个节点去处理已经失效的**scheduler**；  
**TRIGGER\_ACCESS**主要用在**TRIGGER**被调度的时候，保证只有一个节点去执行调度；

CREATE TABLE `qrtz_locks`  (
      `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '调度器名称',
      `LOCK_NAME` varchar(40) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '悲观锁名称',
      PRIMARY KEY (`SCHED_NAME`, `LOCK_NAME`) USING BTREE
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '存储程序的悲观锁的信息(假如使用了悲观锁)' ROW_FORMAT = Dynamic;

`7.qrtz_paused_trigger_grps表`：存放暂停掉的触发器

CREATE TABLE `qrtz_paused_trigger_grps`  (
      `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '调度器名称',
      `TRIGGER_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '触发器组，qrtz_triggers表trigger_group的外键',
      PRIMARY KEY (`SCHED_NAME`, `TRIGGER_GROUP`) USING BTREE
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '存储已暂停的 Trigger 组的信息' ROW_FORMAT = Dynamic;

`8.qrtz_scheduler_state表`：存储所有节点的scheduler，会定期检查scheduler是否失效，记录了最后最新的检查时间，在quartz.properties中设置了CHECKIN\_INTERVAL为1000，也就是每秒检查一次；

CREATE TABLE `qrtz_scheduler_state`  (
      `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '调度器名称',
      `INSTANCE_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '实例名称，配置文件中org.quartz.scheduler.instanceId配置的名字，会写入该字段',
      `LAST_CHECKIN_TIME` bigint(13) NOT NULL COMMENT '上次检查时间',
      `CHECKIN_INTERVAL` bigint(13) NOT NULL COMMENT '检查间隔时间',
      PRIMARY KEY (`SCHED_NAME`, `INSTANCE_NAME`) USING BTREE
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '存储集群中note实例信息，quartz会定时读取该表的信息判断集群中每个实例的当前状态' ROW_FORMAT = Dynamic;

`9.qrtz_simple_triggers表`：存储简单的触发器信息，包括重复次数，间隔，以及已触的次数

CREATE TABLE `qrtz_simple_triggers`  (
      `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '调度器名称',
      `TRIGGER_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '触发器名称，qrtz_triggers表trigger_ name的外键',
      `TRIGGER_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '触发器组，qrtz_triggers表trigger_group的外键',
      `REPEAT_COUNT` bigint(7) NOT NULL COMMENT '重复的次数统计',
      `REPEAT_INTERVAL` bigint(12) NOT NULL COMMENT '重复的间隔时间',
      `TIMES_TRIGGERED` bigint(10) NOT NULL COMMENT '已经触发的次数',
      PRIMARY KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) USING BTREE,
      CONSTRAINT `qrtz_simple_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) ON DELETE RESTRICT ON UPDATE RESTRICT
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '存储简单的 Trigger，包括重复次数，间隔，以及已触发的次数。' ROW_FORMAT = Dynamic;

`10.qrtz_simprop_triggers表`：存储**CalendarIntervalTrigger**和**DailyTimeIntervalTrigger**两种类型的触发器

CREATE TABLE `qrtz_simprop_triggers`  (
      `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '调度器名称',
      `TRIGGER_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '触发器名称，qrtz_triggers表trigger_ name的外键',
      `TRIGGER_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '触发器群组，qrtz_triggers表trigger_group的外键',
      `STR_PROP_1` varchar(512) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'String类型的trigger的第一个参数',
      `STR_PROP_2` varchar(512) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'String类型的trigger的第二个参数',
      `STR_PROP_3` varchar(512) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'String类型的trigger的第三个参数',
      `INT_PROP_1` int(11) NULL DEFAULT NULL COMMENT 'int类型的trigger的第一个参数',
      `INT_PROP_2` int(11) NULL DEFAULT NULL COMMENT 'int类型的trigger的第二个参数',
      `LONG_PROP_1` bigint(20) NULL DEFAULT NULL COMMENT 'long类型的trigger的第一个参数',
      `LONG_PROP_2` bigint(20) NULL DEFAULT NULL COMMENT 'long类型的trigger的第二个参数',
      `DEC_PROP_1` decimal(13, 4) NULL DEFAULT NULL COMMENT 'decimal类型的trigger的第一个参数',
      `DEC_PROP_2` decimal(13, 4) NULL DEFAULT NULL COMMENT 'decimal类型的trigger的第二个参数',
      `BOOL_PROP_1` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'Boolean类型的trigger的第一个参数',
      `BOOL_PROP_2` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'Boolean类型的trigger的第二个参数',
      PRIMARY KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) USING BTREE,
      CONSTRAINT `qrtz_simprop_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) ON DELETE RESTRICT ON UPDATE RESTRICT
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '存储CalendarIntervalTrigger和DailyTimeIntervalTrigger' ROW_FORMAT = Dynamic;

`11.qrtz_triggers表`：存储已配置的 **Trigger** 的信息，一个**Job**可以被多个**Trigger**绑定，但是一个**Trigger**只能绑定一个**Job**

CREATE TABLE `qrtz_triggers`  (
      `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '调度器名称',
      `TRIGGER_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '触发器名称',
      `TRIGGER_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '触发器组名称',
      `JOB_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '任务名称，qrtz_job_details表job_name的外键',
      `JOB_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '任务群组，qrtz_job_details表job_group的外键',
      `DESCRIPTION` varchar(250) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '关于触发器的说明信息',
      `NEXT_FIRE_TIME` bigint(13) NULL DEFAULT NULL COMMENT '下次执行时间，默认为-1，意味不会自动触发',
      `PREV_FIRE_TIME` bigint(13) NULL DEFAULT NULL COMMENT '上次执行时间（毫秒）',
      `PRIORITY` int(11) NULL DEFAULT NULL COMMENT '线程优先级',
      `TRIGGER_STATE` varchar(16) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '当前触发器状态；WAITING-等待， PAUSED-暂停，ACQUIRED-正常执行 ，BLOCKED-阻塞 ERROR-错误',
      `TRIGGER_TYPE` varchar(8) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '触发器类型，使用cron表达式',
      `START_TIME` bigint(13) NOT NULL COMMENT '开始时间',
      `END_TIME` bigint(13) NULL DEFAULT NULL COMMENT '结束时间',
      `CALENDAR_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '日程表名称，表qrtz_calendars的calendar_name字段外键',
      `MISFIRE_INSTR` smallint(2) NULL DEFAULT NULL COMMENT 'misfire处理规则,1代表【以当前时间为触发频率立刻触发一次，然后按照Cron频率依次执行】,\n   2代表【不触发立即执行,等待下次Cron触发频率到达时刻开始按照Cron频率依次执行�】,\n   -1代表【以错过的第一个频率时间立刻开始执行,重做错过的所有频率周期后，当下一次触发频率发生时间大于当前时间后，再按照正常的Cron频率依次执行',
      `JOB_DATA` blob NULL COMMENT '任务信息，存放持久化job对象',
      PRIMARY KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) USING BTREE,
      INDEX `SCHED_NAME`(`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`) USING BTREE,
      CONSTRAINT `qrtz_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`) REFERENCES `qrtz_job_details` (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`) ON DELETE RESTRICT ON UPDATE RESTRICT
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '存储已配置的触发器 的信息' ROW_FORMAT = Dynamic;

### SpringBoot整合Quartz ###

*  创建数据库`test_quartz`将`tables_mysql.sql`导入并运行
 *  导入`Maven`依赖（这里使用 **druid** 作为数据库连接池，**Quartz** 默认使用 **c3p0**）

<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>
                <version>2.3.5.RELEASE</version>
            </dependency>
            
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>1.1.10</version>
            </dependency>
            
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>3.4.3.4</version>
            </dependency>
            
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>5.8.2</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <scope>runtime</scope>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>

*  新建配置文件`quartz.properties`

> 默认情况下，**Quartz** 会加载 **classpath** 下的 **quartz.properties** 作为配置文件。如果找不到，则会使用 **quartz** 框架自己 **jar** 包下 **org/quartz** 底下的 **quartz.properties** 文件

`quartz.properties`：

#定时任务实例的id 默认自动
    org.quartz.scheduler.instanceId=AUTO
    # 定时任务的线程名,相同集群实例名称必须相同
    org.quartz.scheduler.instanceName=DefaultQuartzScheduler
    #如果您希望Quartz Scheduler通过RMI作为服务器导出本身，则将“rmi.export”标志设置为true
    #在同一个配置文件中为'org.quartz.scheduler.rmi.export'和'org.quartz.scheduler.rmi.proxy'指定一个'true'值是没有意义的,如果你这样做'export'选项将被忽略
    org.quartz.scheduler.rmi.export=false
    #如果要连接（使用）远程服务的调度程序，则将“org.quartz.scheduler.rmi.proxy”标志设置为true。您还必须指定RMI注册表进程的主机和端口 - 通常是“localhost”端口1099
    org.quartz.scheduler.rmi.proxy=false
    #如果想使用Quartz在执行一个job前使用UserTransaction，则应该设置该属性为true。job执行完、在JobDataMap改变之后事务会提交。默认值是false。 可以在你的job类中使用 @ExecuteInJTATransaction注解, 可以控制job是否使用事务。
    org.quartz.scheduler.wrapJobExecutionInUserTransaction=false
    
    
    #实例化ThreadPool时，使用的线程类为SimpleThreadPool
    org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
    #threadCount和threadPriority将以setter的形式注入ThreadPool实例
    #并发个数  如果你只有几个工作每天触发几次 那么1个线程就可以,如果你有成千上万的工作，每分钟都有很多工作 那么久需要50-100之间.
    #只有1到100之间的数字是非常实用的
    org.quartz.threadPool.threadCount=5
    #优先级 默认值为5
    org.quartz.threadPool.threadPriority=5
    #可以是“true”或“false”，默认为false
    org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread=true
    
    
    #在被认为“misfired”(失火)之前，调度程序将“tolerate(容忍)”一个Triggers(触发器)将其下一个启动时间通过的毫秒数。默认值（如果您在配置中未输入此属性）为60000（60秒）
    org.quartz.jobStore.misfireThreshold=5000
    # 默认存储在内存中,RAMJobStore快速轻便，但是当进程终止时，所有调度信息都会丢失
    #org.quartz.jobStore.class=org.quartz.simpl.RAMJobStore
    
    #持久化方式，默认存储在内存中，此处使用数据库方式
    org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
    #您需要为JobStore选择一个DriverDelegate才能使用。DriverDelegate负责执行特定数据库可能需要的任何JDBC工作
    # StdJDBCDelegate是一个使用“vanilla”JDBC代码（和SQL语句）来执行其工作的委托,用于完全符合JDBC的驱动程序
    org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
    #可以将“org.quartz.jobStore.useProperties”配置参数设置为“true”（默认为false），以指示JDBCJobStore将JobDataMaps中的所有值都作为字符串，
    #因此可以作为名称 - 值对存储而不是在BLOB列中以其序列化形式存储更多复杂的对象。从长远来看，这是更安全的，因为您避免了将非String类序列化为BLOB的类版本问题
    org.quartz.jobStore.useProperties=true
    #表前缀
    org.quartz.jobStore.tablePrefix=qrtz_
    #数据源别名，自定义
    org.quartz.jobStore.dataSource=qzDS
    
    
    #使用阿里的druid作为数据库连接池
    org.quartz.dataSource.qzDS.connectionProvider.class=com.wf.test_quartz_demo.config.DruidPoolingConnectionProvider
    org.quartz.dataSource.qzDS.URL=jdbc:mysql://127.0.0.1:3306/test_quartz?characterEncoding=utf8&useSSL=false&autoReconnect=true&serverTimezone=UTC
    org.quartz.dataSource.qzDS.user=root
    org.quartz.dataSource.qzDS.password=root
    org.quartz.dataSource.qzDS.driver=com.mysql.jdbc.Driver
    org.quartz.dataSource.qzDS.maxConnections=10
    #设置为“true”以打开群集功能。如果您有多个Quartz实例使用同一组数据库表，则此属性必须设置为“true”，否则您将遇到破坏
    #org.quartz.jobStore.isClustered=false

***注：以上配置中需要修改的地方有***  
`org.quartz.dataSource.qzDS.connectionProvider.class`：这是druid连接池的配置类，需要修改为自己的路径  
`org.quartz.dataSource.qzDS.URL`:需要修改为自己的数据库连接  
`org.quartz.dataSource.qzDS.user`:需要修改为自己的数据库用户名  
`org.quartz.dataSource.qzDS.password`：需要修改为自己的数据库密码

`application.properties`:

server.port=8081
    # mysql配置
    spring.datasource.druid.driver-class-name=com.mysql.jdbc.Driver
    spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
    spring.datasource.druid.url=jdbc:mysql://127.0.0.1:3306/test_quartz?characterEncoding=utf8&useSSL=false&autoReconnect=true&serverTimezone=UTC
    spring.datasource.druid.username=root
    spring.datasource.druid.password=root
    #连接池初始化大小，最小，最大
    spring.datasource.druid.initial-size=3
    spring.datasource.druid.min-idle=3
    spring.datasource.druid.max-active=10
    #连接池最大等待时间
    spring.datasource.druid.max-wait=60000
    # mybatis-plus配置
    mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
    mybatis-plus.mapper-locations=classpath*:/mapper/*.xml
    mybatis-plus.type-aliases-package=com.wf.test_quartz_demo.bean

*  **编写Quartz配置类**

package com.wf.test_quartz_demo.config;
    
    import com.sun.istack.internal.NotNull;
    import org.quartz.Scheduler;
    import org.springframework.beans.factory.config.PropertiesFactoryBean;
    import org.springframework.boot.autoconfigure.quartz.SchedulerFactoryBeanCustomizer;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.io.ClassPathResource;
    import org.springframework.scheduling.quartz.SchedulerFactoryBean;
    
    import java.io.IOException;
    import java.util.Properties;
    
    /**
     * @Description: quartz 配置类
     */
    @Configuration
    public class QuartzConfig implements SchedulerFactoryBeanCustomizer {
        
    
        @Bean
        public Properties properties() throws IOException {
        
            PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
            // 对quartz.properties文件进行读取
            propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
            // 在quartz.properties中的属性被读取并注入后再初始化对象
            propertiesFactoryBean.afterPropertiesSet();
            return propertiesFactoryBean.getObject();
        }
    
        @Bean
        public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        
            SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
            schedulerFactoryBean.setQuartzProperties(properties());
            return schedulerFactoryBean;
        }
    
    
        /*
         * 通过SchedulerFactoryBean获取Scheduler的实例
         */
        @Bean
        public Scheduler scheduler() throws IOException {
        
            return schedulerFactoryBean().getScheduler();
        }
    
        /**
         * 使用阿里的druid作为数据库连接池
         */
        @Override
        public void customize(@NotNull SchedulerFactoryBean schedulerFactoryBean) {
        
            schedulerFactoryBean.setStartupDelay(2);
            schedulerFactoryBean.setAutoStartup(true);
            schedulerFactoryBean.setOverwriteExistingJobs(true);
        }
    
    }

*  **编写连接池配置类**

package com.wf.test_quartz_demo.config;
    
    
    import com.alibaba.druid.pool.DruidDataSource;
    import lombok.Data;
    import org.quartz.SchedulerException;
    import org.quartz.utils.ConnectionProvider;
    
    import java.sql.Connection;
    import java.sql.SQLException;
    
    /**
     * @Description: druid连接池配置
     */
    @Data
    public class DruidPoolingConnectionProvider implements ConnectionProvider {
        
    
        // JDBC驱动
        public String driver;
    
        // JDBC连接串
        public String URL;
    
        // 数据库用户名
        public String user;
    
        // 数据库用户密码
        public String password;
    
        // 数据库最大连接数
        public int maxConnections;
    
        // 数据库SQL查询每次连接返回执行到连接池，以确保它仍然是有效的。
        public String validationQuery;
    
        private boolean validateOnCheckout;
    
        private int idleConnectionValidationSeconds;
    
        public String maxCachedStatementsPerConnection;
    
        private String discardIdleConnectionsSeconds;
    
        public static final int DEFAULT_DB_MAX_CONNECTIONS = 10;
    
        public static final int DEFAULT_DB_MAX_CACHED_STATEMENTS_PER_CONNECTION = 120;
    
        // Druid连接池
        private DruidDataSource datasource;
    
        @Override
        public Connection getConnection() throws SQLException {
        
            return datasource.getConnection();
        }
    
        @Override
        public void shutdown() {
        
            datasource.close();
        }
    
        @Override
        public void initialize() throws SQLException {
        
            if (this.URL == null) {
        
                throw new SQLException("DBPool could not be created: DB URL cannot be null");
            }
            if (this.driver == null) {
        
                throw new SQLException("DBPool driver could not be created: DB driver class name cannot be null!");
            }
            if (this.maxConnections < 0) {
        
                throw new SQLException("DBPool maxConnections could not be created: Max connections must be greater than zero!");
            }
            datasource = new DruidDataSource();
            try{
        
                datasource.setDriverClassName(this.driver);
            } catch (Exception e) {
        
                try {
        
                    throw new SchedulerException("Problem setting driver class name on datasource: " + e.getMessage(), e);
                } catch (SchedulerException ignored) {
        
                }
            }
            datasource.setUrl(this.URL);
            datasource.setUsername(this.user);
            datasource.setPassword(this.password);
            datasource.setMaxActive(this.maxConnections);
            datasource.setMinIdle(1);
            datasource.setMaxWait(0);
            datasource.setMaxPoolPreparedStatementPerConnectionSize(DEFAULT_DB_MAX_CONNECTIONS);
            if (this.validationQuery != null) {
        
                datasource.setValidationQuery(this.validationQuery);
                if(!this.validateOnCheckout)
                    datasource.setTestOnReturn(true);
                else
                    datasource.setTestOnBorrow(true);
                datasource.setValidationQueryTimeout(this.idleConnectionValidationSeconds);
            }
        }
    }

*  编写实体类

`CodeEnum`:用于响应状态码

package com.wf.test_quartz_demo.bean;
    
    /**
     * 状态码枚举
     */
    public enum CodeEnum {
        
    
        /**操作成功**/
        SUCCESS(200,"操作成功"),
        /**服务调用异常**/
        SERVICE_CALL_EXCEPTION(400,"服务调用异常"),
        /**操作失败**/
        ERROR(500,"操作失败"),
        /**参数不合法**/
        ILLEGAL_PARAMETER(5001,"参数不合法"),
        /**验证码已失效**/
        VERIFICATION_CODE_FAILURE(5002,"验证码已失效"),
        /**用户昵称重复**/
        DUPLICATE_NICKNAME(5003,"用户昵称重复"),
        /**用户名或密码错误**/
        LOGIN_FAILED(5004,"用户名或密码错误"),
        /**文件上传失败**/
        FILE_UPLOAD_FAILED(5005,"文件上传失败"),
        /**资源不存在*/
        RESOURCE_DOES_NOT_EXIST(5006,"资源不存在"),
        /** 当前项目已存在该用户*/
        DUPLICATE_USER(5007,"用户重复入项"),
        /**无效签名**/
        JWT_INVALID(2001,"无效签名"),
        /**token过期**/
        JWT_OVERDUE(2002,"token过期"),
        /**token算法不一致**/
        JWT_ALGORITHM_INCONSISTENCY(2003,"token算法不一致"),
        /**token失效**/
        JWT_LOSE_EFFECT(2004,"token失效"),
        /**非法请求**/
        ILLEGAL_REQUEST(2005,"非法请求,请求来源不合法");
    
        /**
         * 自定义状态码
         **/
        private Integer code;
        /**自定义描述**/
        private String message;
    
        CodeEnum(Integer code, String message){
        
            this.code = code;
            this.message = message;
        }
    
        public Integer getCode() {
        
            return code;
        }
        public String getMessage() {
        
            return message;
        }
    }

`CommonResult`:响应数据结构

package com.wf.test_quartz_demo.bean;
    
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * 请求信息类，用于返回请求是否成功
     * @param <T>
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class CommonResult<T>{
        
        /**
         * 响应状态码
         */
        private int code;
    
        /**
         * 响应结果描述
         */
        private String message;
    
        /**
         * 返回的数据
         */
        private T data;
    
        /**
         * 成功返回
         * @param data
         * @param <T>
         * @return
         */
        public static <T> CommonResult<T> success(T data) {
        
            CommonResult<T> response= new CommonResult<>();
            response.setCode(CodeEnum.SUCCESS.getCode());
            response.setMessage(CodeEnum.SUCCESS.getMessage());
            response.setData(data);
            return response;
        }
    
        /**
         *  失败返回,自定义code
         * @param code
         * @param message
         * @param <T>
         * @return
         */
        public static <T> CommonResult<T> fail(Integer code, String message) {
        
            CommonResult<T> response = new CommonResult<>();
            response.setCode(code);
            response.setMessage(message);
            return response;
        }
    
        /**
         *  失败返回
         * @param codeEnum
         * @param <T>
         * @return
         */
        public static <T> CommonResult<T> fail(CodeEnum codeEnum) {
        
            CommonResult<T> response = new CommonResult<>();
            response.setCode(codeEnum.getCode());
            response.setMessage(codeEnum.getMessage());
            return response;
        }
        /**
         *  失败返回
         * @param message
         * @param <T>
         * @return
         */
        public static <T> CommonResult<T> fail(String message) {
        
            CommonResult<T> response = new CommonResult<>();
            response.setCode(CodeEnum.ERROR.getCode());
            response.setMessage(message);
            return response;
        }
    
    }

`QuartzJobVO`：任务信息VO

package com.wf.test_quartz_demo.bean;
    
    
    import lombok.Data;
    import java.math.BigInteger;
    
    /**
     * @Description: 定时任务信息
     */
    @Data
    public class QuartzJobVO {
        
        private String schedName;
        private String jobName;
        private String jobGroup;
        private String description;
        private String jobClassName;
        private BigInteger nextFireTime;
        private BigInteger startTime;
        private String triggerState;
        private String cronExpression;
    }

`RecordsParam`:接口请求参数

package com.wf.test_quartz_demo.bean;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.quartz.JobDataMap;
    
    /**
     * 记录查询参数
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class RecordsParam {
        
    
        /**
         * 分页页码
         */
        private Integer page = 1;
        /**
         * 单页展示条数
         */
        private Integer size = 10;
    
        /**
         * 任务名称
         */
        private String jobName;
    
        /**
         * 任务组名称
         */
        private String jobGroupName;
    
        /**
         * 触发器名称
         */
        private String triggerName;
    
        /**
         * 触发器组名称
         */
        private String triggerGroupName;
        /**
         * corn表达式
         */
        private String corn;
    
        /**
         * 实际执行业务逻辑的job路径
         */
        private  String classPath;
    
        /**
         * 需要向job传递的参数
         */
        private JobDataMap jobDataMap;
    
        /**
         * 备注
         */
        private String  remarks;
    
        /**
         * 分页起始页
         */
        private Integer pageIndex;
    
    
    }

*  编写Mapper.xml

`QuartzJobInfoMapper.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.wf.test_quartz_demo.mapper.QuartzJobInfoMapper">
    
    
        <select id="getJobAndTriggerDetails" resultType="QuartzJobVO" parameterType="RecordsParam">
            SELECT
                tqjd.SCHED_NAME as schedName,
                tqjd.JOB_NAME as jobName,
                tqjd.JOB_GROUP as jobGroup,
                tqjd.DESCRIPTION as description,
                tqjd.JOB_CLASS_NAME as jobClassName,
                tqt.NEXT_FIRE_TIME as nextFireTime,
                tqt.START_TIME as startTime,
                tqt.TRIGGER_STATE as triggerState,
                tqct.CRON_EXPRESSION as cronExpression
            FROM
                qrtz_job_details tqjd
                    LEFT JOIN qrtz_triggers tqt ON tqjd.SCHED_NAME = tqt.SCHED_NAME
                    AND tqjd.JOB_NAME = tqt.JOB_NAME
                    AND tqjd.JOB_GROUP = tqt.JOB_GROUP
                    LEFT JOIN qrtz_cron_triggers tqct ON tqt.SCHED_NAME = tqct.SCHED_NAME
                    AND tqt.TRIGGER_NAME = tqct.TRIGGER_NAME
                    AND tqt.TRIGGER_GROUP = tqct.TRIGGER_GROUP
            WHERE
                tqt.TRIGGER_TYPE = 'CRON'
            <if test="pageIndex !=null">
                LIMIT #{
        pageIndex},#{
        size}
            </if>
        </select>
    
    
    </mapper>

*  编写Mapper接口

`QuartzJobInfoMapper`

package com.wf.test_quartz_demo.mapper;
    
    import com.wf.test_quartz_demo.bean.QuartzJobVO;
    import com.wf.test_quartz_demo.bean.RecordsParam;
    import org.springframework.stereotype.Repository;
    
    import java.util.List;
    
    
    @Repository
    public interface QuartzJobInfoMapper  {
        
    
        /**
         * 查询任务列表
         * @param param
         * @return
         */
        List<QuartzJobVO> getJobAndTriggerDetails(RecordsParam param);
    
    }

*  编写Service接口及实现类

`TestQuartzJobInfoService`

package com.wf.test_quartz_demo.service;
    
    
    import java.util.List;
    
    import com.wf.test_quartz_demo.bean.CommonResult;
    import com.wf.test_quartz_demo.bean.QuartzJobVO;
    import com.wf.test_quartz_demo.bean.RecordsParam;
    
    /**
     * @Description: 定时任务
     */
    public interface TestQuartzJobInfoService  {
        
    
        CommonResult<String> addJob(RecordsParam param);
    
        CommonResult<String> pauseJob(RecordsParam param);
    
        CommonResult<String> resumeJob(RecordsParam param);
    
        CommonResult<String> updateJob(RecordsParam param);
    
        CommonResult<String> deleteJob(RecordsParam param);
    
        CommonResult<List<QuartzJobVO>> getJobAndTriggerDetails(RecordsParam param);
    }

`TestQuartzJobServiceImpl`

package com.wf.test_quartz_demo.service.impl;
    
    
    import com.wf.test_quartz_demo.bean.CodeEnum;
    import com.wf.test_quartz_demo.bean.CommonResult;
    import com.wf.test_quartz_demo.bean.QuartzJobVO;
    import com.wf.test_quartz_demo.bean.RecordsParam;
    import com.wf.test_quartz_demo.mapper.QuartzJobInfoMapper;
    import com.wf.test_quartz_demo.service.TestQuartzJobInfoService;
    import lombok.extern.slf4j.Slf4j;
    import org.quartz.*;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    import javax.annotation.Resource;
    import java.util.List;
    
    /**
     * @Description: 任务调度测试service
     */
    @Slf4j
    @Service
    public class TestQuartzJobServiceImpl implements TestQuartzJobInfoService {
        
        @Resource
        private QuartzJobInfoMapper quartzJobMapper;
        @Resource
        private Scheduler scheduler;
    
    
        /**
         * 添加任务
         * @param param
         * @return
         */
        @Override
        public CommonResult<String> addJob(RecordsParam param) {
        
            try {
        
                if(param!=null){
        
                    //动态控制job,根据job的类路径，创建JobDetail
                    Class clsss = Class.forName(param.getClassPath());
                    //设置job的业务逻辑类路径
                    JobDetail jobDetail = JobBuilder.newJob(clsss)
                            //设置job的名称，组名称
                            .withIdentity(param.getJobName(), param.getJobGroupName())
                            //设置对job的说明描述
                            .withDescription(param.getRemarks())
                            //向job传递参数
                            .usingJobData(param.getJobDataMap())
                            .build();
    
                    // 创建触发器
                    CronTrigger trigger = TriggerBuilder.newTrigger()
                            //设置触发器的名称，触发器的组名
                            .withIdentity(param.getTriggerName(), param.getTriggerGroupName())
                            .startNow()
                            //设置corn表达式
                            .withSchedule(CronScheduleBuilder.cronSchedule(param.getCorn()))
                            .build();
                    // 启动调度器
                    scheduler.start();
                    scheduler.scheduleJob(jobDetail, trigger);
    
                    return CommonResult.success("添加任务成功");
                }
    
                return CommonResult.fail(CodeEnum.ILLEGAL_PARAMETER);
    
            } catch (Exception e) {
        
                log.info("创建定时任务失败{}" , e.getMessage());
                return CommonResult.fail("添加任务失败："+e.getMessage());
            }
    
        }
    
    
        /**
         * 暂停任务
         * @param param
         * @return
         */
        @Override
        public CommonResult<String> pauseJob(RecordsParam param)  {
        
            try {
        
                if(param!=null){
        
                    //设置任务名称，任务组名称
                    scheduler.pauseJob(JobKey.jobKey(param.getJobName(), param.getJobGroupName()));
                    return CommonResult.success("暂停任务成功");
                }
                return CommonResult.fail(CodeEnum.ILLEGAL_PARAMETER);
    
            } catch (SchedulerException e) {
        
                log.info("暂停任务失败{}" , e.getMessage());
                return CommonResult.fail("暂停任务失败："+e.getMessage());
            }
    
        }
    
        /**
         * 恢复任务
         * @param param
         * @return
         */
        @Override
        public CommonResult<String> resumeJob(RecordsParam param) {
        
            try {
        
                if(param!=null){
        
                    //设置任务名称，任务组名称
                    scheduler.resumeJob(JobKey.jobKey(param.getJobName(), param.getJobGroupName()));
                    return CommonResult.success("恢复任务成功");
                }
                return CommonResult.fail(CodeEnum.ILLEGAL_PARAMETER);
    
            } catch (SchedulerException e) {
        
                log.info("恢复任务失败{}" , e.getMessage());
                return CommonResult.fail("恢复任务失败："+e.getMessage());
            }
    
        }
    
        /**
         * 修改任务
         * @param param
         * @return
         */
        @Override
        @Transactional
        public CommonResult<String> updateJob(RecordsParam param) {
        
                if(param!=null){
        
                    //删除之前的任务
                    deleteJob(param);
                    //创建新的任务
                    addJob(param);
                    return CommonResult.success("修改任务成功");
                }
                return CommonResult.fail(CodeEnum.ILLEGAL_PARAMETER);
    
        }
    
        /**
         * 删除任务
         * @param param
         * @return
         */
        @Override
        public CommonResult<String> deleteJob(RecordsParam param) {
        
            try {
        
                if(param!=null){
        
                    //设置任务名称，任务组名称
                    scheduler.pauseTrigger(TriggerKey.triggerKey(param.getJobName(), param.getJobGroupName()));
                    scheduler.unscheduleJob(TriggerKey.triggerKey(param.getJobName(), param.getJobGroupName()));
                    scheduler.deleteJob(JobKey.jobKey(param.getJobName(), param.getJobGroupName()));
                    return CommonResult.success("删除任务成功");
                }
                return CommonResult.fail(CodeEnum.ILLEGAL_PARAMETER);
    
            } catch (SchedulerException e) {
        
                log.info("删除任务失败{}" , e.getMessage());
                return CommonResult.fail("删除任务失败："+e.getMessage());
            }
        }
    
        @Override
        public CommonResult<List<QuartzJobVO>> getJobAndTriggerDetails(RecordsParam param) {
        
            param.setPageIndex((param.getPage() - 1) * param.getSize());
            //查询任务列表
            return CommonResult.success(quartzJobMapper.getJobAndTriggerDetails(param));
        }
    
    
    }

*  编写controller

`TestQuartzController`

package com.wf.test_quartz_demo.controller;
    
    
    
    import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    import com.wf.test_quartz_demo.bean.CommonResult;
    import com.wf.test_quartz_demo.bean.QuartzJobVO;
    import com.wf.test_quartz_demo.bean.RecordsParam;
    import com.wf.test_quartz_demo.service.TestQuartzJobInfoService;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.web.bind.annotation.*;
    
    import java.util.List;
    
    
    /**
     * @Description: 测试任务调度
     */
    @RestController
    @RequestMapping("/quartz/")
    @Slf4j
    public class TestQuartzController {
        
    
        @Autowired
        TestQuartzJobInfoService  testQuartzJobInfoService;
    
        /**
         * 添加任务
         * @param param
         * @return
         */
        @PostMapping(path = "/add")
        @ResponseBody
        public CommonResult<String> addJob(@RequestBody RecordsParam param) {
        
          return   testQuartzJobInfoService.addJob(param);
        }
    
    
        /**
         * 暂停任务
         * @param param
         * @return
         */
        @PostMapping(path = "/pause")
        @ResponseBody
        public CommonResult<String> pauseJob(@RequestBody RecordsParam param) {
        
            return   testQuartzJobInfoService.pauseJob(param);
        }
    
        /**
         * 恢复任务
         * @param param
         * @return
         */
        @PostMapping(path = "/resume")
        @ResponseBody
        public CommonResult<String> resumeJob(@RequestBody  RecordsParam param) {
        
            return   testQuartzJobInfoService.resumeJob(param);
        }
    
        /**
         * 修改任务
         *
         */
        @PostMapping(path = "/update")
        @ResponseBody
        public CommonResult<String> updateJob(@RequestBody  RecordsParam param) {
        
            return   testQuartzJobInfoService.updateJob(param);
        }
    
        /**
         * 删除任务
         *
         */
        @PostMapping(path = "/delete")
        @ResponseBody
        public CommonResult<String> deleteJob(@RequestBody  RecordsParam param) {
        
            return   testQuartzJobInfoService.deleteJob(param);
        }
    
        /**
         * 查询任务
         */
        @PostMapping(path = "/query")
        @ResponseBody
        public CommonResult<List<QuartzJobVO>> queryJob(@RequestBody  RecordsParam param) {
        
            return   testQuartzJobInfoService.getJobAndTriggerDetails(param);
    
        }
    
    }

*  编写具体任务

`MyJobOne`

package com.wf.test_quartz_demo.job;
    
    import cn.hutool.core.date.DateUtil;
    
    import cn.hutool.extra.spring.SpringUtil;
    import com.wf.test_quartz_demo.bean.CommonResult;
    import com.wf.test_quartz_demo.bean.QuartzJobVO;
    import com.wf.test_quartz_demo.bean.RecordsParam;
    import com.wf.test_quartz_demo.mapper.QuartzJobInfoMapper;
    import com.wf.test_quartz_demo.service.impl.TestQuartzJobServiceImpl;
    
    import lombok.extern.slf4j.Slf4j;
    import org.quartz.Job;
    import org.quartz.JobDataMap;
    import org.quartz.JobExecutionContext;
    
    import javax.annotation.Resource;
    import java.util.List;
    
    
    /**
     * @Description: 任务一
     */
    @Slf4j
    public class MyJobOne implements Job {
        
    
        @Override
        public void execute(JobExecutionContext jobExecutionContext) {
        
            //获取传递过来的参数
            JobDataMap jobDataMap = jobExecutionContext.getJobDetail().getJobDataMap();
            //此处无法通过spring获取mapper
            QuartzJobInfoMapper quartzJobMapper = SpringUtil.getBean("quartzJobInfoMapper");
    
            //查询任务列表
            List<QuartzJobVO> result = quartzJobMapper.getJobAndTriggerDetails(new RecordsParam());
            log.info("任务列表总数为：{}" , result.size());
            log.info("MyJobOne执行时间--->: {}" , DateUtil.now());
            jobDataMap.forEach((key,value)->{
        
                log.info("MyJobOne接收到的参数Key---value--->{}--{}",key,value);
    
            });
    
        }
    
    }

`MyJobTwo`

package com.wf.test_quartz_demo.job;
    
    import cn.hutool.core.date.DateUtil;
    import com.baomidou.mybatisplus.core.metadata.IPage;
    import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    import com.wf.test_quartz_demo.bean.QuartzJobVO;
    import lombok.extern.slf4j.Slf4j;
    import org.quartz.Job;
    import org.quartz.JobDataMap;
    import org.quartz.JobExecutionContext;
    
    /**
     * @Description: 任务2
     */
    @Slf4j
    public class MyJobTwo implements Job {
        
        @Override
        public void execute(JobExecutionContext jobExecutionContext) {
        
            //获取传递过来的参数
            JobDataMap jobDataMap = jobExecutionContext.getJobDetail().getJobDataMap();
    
            log.info("MyJobTwo执行时间--->: {}" , DateUtil.now());
            jobDataMap.forEach((key,value)->{
        
                log.info("MyJobTwo接收到的参数Key---value--->{}--{}",key,value);
            });
        }
    }

*  测试运行  
    ![在这里插入图片描述][8ec33720d9d24cdf9dae02a3e8958268.png]

运行效果：  
![在这里插入图片描述][b707dd381fbd4bd390b111df2e68e20c.png]  
`注：其余接口全部测试过都能正常运行，此处不在测试`

*  完整代码  
    [Gitee地址][Gitee]

[Link 1]: https://blog.csdn.net/weixin_38192427/article/details/121111677?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167626714816800186559211%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=167626714816800186559211&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_ecpm_v1~hot_rank-1-121111677-null-null.142%5Ev73%5Einsert_down2,201%5Ev4%5Eadd_ask,239%5Ev1%5Econtrol&utm_term=Quartz&spm=1018.2226.3001.4187
[Link 2]: http://quartz-scheduler.org/
[a712e72f6cfb4adc97434e31729517f6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/22bd06464a2747d3ba326810af788ee6.png
[Cron]: https://cron.qqe2.com/
[SQL]: http://www.quartz-scheduler.org/downloads/
[473561e3009c40a08f6e1a2d847cfb2a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/5e81ac16e31d4a8a9b6516f2aa122f10.png
[4d255e2dc9a64f54ad8a980ce3afd71a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/7ec3dbec46da4ee791c9dc4cb214e2a8.png
[8ec33720d9d24cdf9dae02a3e8958268.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/89ba953b1c264f0a95791c1b7658b1b3.png
[b707dd381fbd4bd390b111df2e68e20c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/d57192ce087c4985a2c132f0a2ba9685.png
[Gitee]: https://gitee.com/wang-fei-admin/test_quartz_demo