Quartz入门教程

本文参考文章编写

Quartz

官网

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

应用场景

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

组成部分

• 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传递给该Job的execute()中，Job就可以通过JobExecutionContext对象获取信息。

Cron 表达式

Cron表达式在线生成

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

• Cron 语法

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

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

• Cron 语法中特殊字符说明

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

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

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

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

• 解压下载后的quartz-2.3.0-distribution.tar.gz文件，在quartz-2.3.0-distribution\quartz-2.3.0-SNAPSHOT\src\org\quartz\impl\jdbcjobstore目录下得到各类型数据库的SQL脚本
  

• 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><!-- quartz --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-quartz</artifactId><version>2.3.5.RELEASE</version></dependency><!--druid连接池--><dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-starter</artifactId><version>1.1.10</version></dependency><!-- mybatis-plus --><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 {@Beanpublic Properties properties() throws IOException {PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();// 对quartz.properties文件进行读取propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));// 在quartz.properties中的属性被读取并注入后再初始化对象propertiesFactoryBean.afterPropertiesSet();return propertiesFactoryBean.getObject();}@Beanpublic SchedulerFactoryBean schedulerFactoryBean() throws IOException {SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();schedulerFactoryBean.setQuartzProperties(properties());return schedulerFactoryBean;}/** 通过SchedulerFactoryBean获取Scheduler的实例*/@Beanpublic Scheduler scheduler() throws IOException {return schedulerFactoryBean().getScheduler();}/*** 使用阿里的druid作为数据库连接池*/@Overridepublic 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;@Overridepublic Connection getConnection() throws SQLException {return datasource.getConnection();}@Overridepublic void shutdown() {datasource.close();}@Overridepublic 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);elsedatasource.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">SELECTtqjd.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 cronExpressionFROMqrtz_job_details tqjdLEFT JOIN qrtz_triggers tqt ON tqjd.SCHED_NAME = tqt.SCHED_NAMEAND tqjd.JOB_NAME = tqt.JOB_NAMEAND tqjd.JOB_GROUP = tqt.JOB_GROUPLEFT JOIN qrtz_cron_triggers tqct ON tqt.SCHED_NAME = tqct.SCHED_NAMEAND tqt.TRIGGER_NAME = tqct.TRIGGER_NAMEAND tqt.TRIGGER_GROUP = tqct.TRIGGER_GROUPWHEREtqt.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 {@Resourceprivate QuartzJobInfoMapper quartzJobMapper;@Resourceprivate Scheduler scheduler;/*** 添加任务* @param param* @return*/@Overridepublic CommonResult<String> addJob(RecordsParam param) {try {if(param!=null){//动态控制job,根据job的类路径，创建JobDetailClass 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*/@Overridepublic 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*/@Overridepublic 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@Transactionalpublic CommonResult<String> updateJob(RecordsParam param) {if(param!=null){//删除之前的任务deleteJob(param);//创建新的任务addJob(param);return CommonResult.success("修改任务成功");}return CommonResult.fail(CodeEnum.ILLEGAL_PARAMETER);}/*** 删除任务* @param param* @return*/@Overridepublic 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());}}@Overridepublic 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 {@AutowiredTestQuartzJobInfoService  testQuartzJobInfoService;/*** 添加任务* @param param* @return*/@PostMapping(path = "/add")@ResponseBodypublic CommonResult<String> addJob(@RequestBody RecordsParam param) {return   testQuartzJobInfoService.addJob(param);}/*** 暂停任务* @param param* @return*/@PostMapping(path = "/pause")@ResponseBodypublic CommonResult<String> pauseJob(@RequestBody RecordsParam param) {return   testQuartzJobInfoService.pauseJob(param);}/*** 恢复任务* @param param* @return*/@PostMapping(path = "/resume")@ResponseBodypublic CommonResult<String> resumeJob(@RequestBody  RecordsParam param) {return   testQuartzJobInfoService.resumeJob(param);}/*** 修改任务**/@PostMapping(path = "/update")@ResponseBodypublic CommonResult<String> updateJob(@RequestBody  RecordsParam param) {return   testQuartzJobInfoService.updateJob(param);}/*** 删除任务**/@PostMapping(path = "/delete")@ResponseBodypublic CommonResult<String> deleteJob(@RequestBody  RecordsParam param) {return   testQuartzJobInfoService.deleteJob(param);}/*** 查询任务*/@PostMapping(path = "/query")@ResponseBodypublic 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 {@Overridepublic void execute(JobExecutionContext jobExecutionContext) {//获取传递过来的参数JobDataMap jobDataMap = jobExecutionContext.getJobDetail().getJobDataMap();//此处无法通过spring获取mapperQuartzJobInfoMapper 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 {@Overridepublic 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);});}
}

• 测试运行
  

运行效果：

注：其余接口全部测试过都能正常运行，此处不在测试

• 完整代码
  Gitee地址