【任务调度】Quartz入门

Quartz 入门

代码仓库地址：

• GitHub：chenmeng-test-demos/demo8-task at master · cmty256/chenmeng-test-demos
• Gitee：demo8-task · chenmeng/chenmeng-test-demos - 码云 - 开源中国

基本介绍

Quartz 是一个开源的作业调度框架，它完全由 Java 写成。

Quartz 自带了集群方案。它通过将作业信息存储到关系数据库中，并使用关系数据库的行锁来实现执行作业的竞争，从而保证多个进程下，同一个任务在相同时刻，不能重复执行。

在 Quartz 体系结构中，有三个组件非常重要：

1. Scheduler ：调度器
2. Trigger ：触发器
3. Job ：任务

Quartz 分成【单机模式】和【集群模式】。在生产环境下，一定一定一定要使用 Quartz 的集群模式，保证定时任务的高可用。

JobStore 的存储方式

有两种：

• RAMJobStore：将 scheduler 存储在内存中，但是重启服务器信息会丢失。
• JDBCJobStore：将 scheduler 存储在数据库中。

类型	优点	缺点
RAMJobStore	不要外部数据库，配置容易，运行速度快	因为调度程序信息是存储在被分配给 JVM 的内存里面，所以，当应用程序停止运行时，所有调度信息将被丢失。另外因为存储到 JVM 内存里面，所以可以存储多少个 Job 和 Trigger 将会受到限制
JDBC 作业存储	支持集群，因为所有的任务信息都会保存到数据库中，可以控制事物，还有就是如果应用服务器关闭或者重启，任务信息都不会丢失，并且可以恢复因服务器关闭或者重启而导致执行失败的任务	运行速度的快慢取决与连接数据库的快慢

Quartz 单机入门示例

引入依赖

<dependencies><!-- 实现对 Spring MVC 的自动化配置 --><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></dependency></dependencies>

应用配置文件

spring:application:name:task-quartz-memory# Quartz 的配置，对应 QuartzProperties 配置类quartz:job-store-type: memory # Job 存储器类型。默认为 memory 表示内存，可选 jdbc 使用数据库。auto-startup: true # Quartz 是否自动启动startup-delay: 0 # 延迟 N 秒启动wait-for-jobs-to-complete-on-shutdown: true # 应用关闭时，是否等待定时任务执行完成。默认为 false ，建议设置为 trueoverwrite-existing-jobs: false # 是否覆盖已有 Job 的配置properties: # 添加 Quartz Scheduler 附加属性，更多可以看 http://www.quartz-scheduler.org/documentation/2.4.0-SNAPSHOT/configuration.html 文档org:quartz:threadPool:threadCount: 25 # 线程池大小。默认为 10 。threadPriority: 5 # 线程优先级class: org.quartz.simpl.SimpleThreadPool # 线程池类型
#    jdbc: # 这里暂时不说明，使用 JDBC 的 JobStore 的时候，才需要配置

创建任务类

/*** 每次 DemoJob01 都会被 Quartz 创建出一个新的 Job 对象，执行任务。** @author chenmeng*/
public class DemoJob01 extends QuartzJobBean {private final Logger logger = LoggerFactory.getLogger(getClass());// 计数器private final AtomicInteger counts = new AtomicInteger();@Resourceprivate DemoService demoService;@Overrideprotected void executeInternal(JobExecutionContext context) throws JobExecutionException {// counts.incrementAndGet() 的值一直为 1，说明每次 DemoJob01 都是新创建的。logger.info("[executeInternal][定时第 ({}) 次执行, demoService 为 ({})]", counts.incrementAndGet(),demoService);}}/*** @author chenmeng*/
public class DemoJob02 extends QuartzJobBean {private final Logger logger = LoggerFactory.getLogger(getClass());@Overrideprotected void executeInternal(JobExecutionContext context) throws JobExecutionException {logger.info("[DemoJob02-executeInternal][我每第10秒执行一次]");}}

新增配置类

@Configuration
public class ScheduleConfiguration {public static class DemoJob01Configuration {/*** 创建 DemoJob01 的 JobDetail Bean 对象** @return JobDetail*/@Beanpublic JobDetail demoJob01() {return JobBuilder.newJob(DemoJob01.class).withIdentity("demoJob01") // 名字为 demoJob01.storeDurably() // 没有 Trigger 关联的时候任务是否被保留。因为创建 JobDetail 时，还没 Trigger 指向它，所以需要设置为 true ，表示保留。.build();}/*** 创建 DemoJob01 的 Trigger Bean 对象。* 其中，我们使用 SimpleScheduleBuilder 简单的调度计划的构造器，创建了每 5 秒执行一次，无限重复的调度计划** @return Trigger*/@Beanpublic Trigger demoJob01Trigger() {// 简单的调度计划的构造器SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(5) // 频率 - 每 5 秒。.repeatForever(); // 次数 - 无限重复。// Trigger 构造器return TriggerBuilder.newTrigger().forJob(demoJob01()) // 对应 Job 为 demoJob01.withIdentity("demoJob01Trigger") // 名字为 demoJob01Trigger.withSchedule(scheduleBuilder) // 对应 Schedule 为 scheduleBuilder.build();}}public static class DemoJob02Configuration {/*** 创建 DemoJob02 的 JobDetail Bean 对象** @return JobDetail*/@Beanpublic JobDetail demoJob02() {return JobBuilder.newJob(DemoJob02.class).withIdentity("demoJob02") // 名字为 demoJob02.storeDurably() // 没有 Trigger 关联的时候任务是否被保留。因为创建 JobDetail 时，还没 Trigger 指向它，所以需要设置为 true ，表示保留。.build();}/*** 创建 DemoJob02 的 Trigger Bean 对象。* 其中，我们使用 CronScheduleBuilder 基于 Quartz Cron 表达式的调度计划的构造器，* 创建了每第 10 秒执行一次的调度计划。** @return Trigger*/@Beanpublic Trigger demoJob02Trigger() {//  基于 Quartz Cron 表达式的调度计划的构造器CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0/10 * * * * ? *");// Trigger 构造器return TriggerBuilder.newTrigger().forJob(demoJob02()) // 对应 Job 为 demoJob02.withIdentity("demoJob02Trigger") // 名字为 demoJob02Trigger.withSchedule(scheduleBuilder) // 对应 Schedule 为 scheduleBuilder.build();}}}

最后启动运行测试。

Quartz 集群入门示例

引入依赖

    <dependencies><!-- 实现对数据库连接池的自动化配置 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId></dependency><!-- 本示例，我们使用 MySQL --><dependency><groupId>com.mysql</groupId><artifactId>mysql-connector-j</artifactId></dependency><!-- 实现对 Spring MVC 的自动化配置 --><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></dependency><!-- 单元测试 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></dependencies>

应用配置文件

spring:application:name:task-quartz-jdbcdatasource:user: # 这里主要目的是，为了模拟我们一般项目，使用到的业务数据库。url: jdbc:mysql://127.0.0.1:3306/chenmeng_test?useSSL=false&useUnicode=true&characterEncoding=UTF-8driver-class-name: com.mysql.cj.jdbc.Driverusername: rootpassword: quartz: # 这里主要目的是，Quartz 会使用单独的数据库。如果我们有多个项目需要使用到 Quartz 数据库的话，可以统一使用一个，但是要注意配置 spring.quartz.scheduler-name 设置不同的 Scheduler 名字，形成不同的 Quartz 集群。url: jdbc:mysql://127.0.0.1:3306/chenmeng_quartz?useSSL=false&useUnicode=true&characterEncoding=UTF-8driver-class-name: com.mysql.cj.jdbc.Driverusername: rootpassword: # Quartz 的配置，对应 QuartzProperties 配置类quartz:scheduler-name: clusteredScheduler # Scheduler 名字。默认为 schedulerNamejob-store-type: jdbc # Job 存储器类型。默认为 memory 表示内存，可选 jdbc 使用数据库。auto-startup: true # Quartz 是否自动启动startup-delay: 0 # 延迟 N 秒启动wait-for-jobs-to-complete-on-shutdown: true # 应用关闭时，是否等待定时任务执行完成。默认为 false ，建议设置为 trueoverwrite-existing-jobs: false # 是否覆盖已有 Job 的配置properties: # 添加 Quartz Scheduler 附加属性，更多可以看 http://www.quartz-scheduler.org/documentation/2.4.0-SNAPSHOT/configuration.html 文档org:quartz:# JobStore 相关配置jobStore:# 数据源名称dataSource: quartzDataSource # 使用的数据源# Spring Boot 2.6.0+ 中，job-store-type: jdbc 会自动选择 JobStoreTX，无需显式指定 org.quartz.jobStore.class。# 如果指定了，项目运行会报错。
#            class: org.quartz.impl.jdbcjobstore.JobStoreTX # JobStore 实现类driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegatetablePrefix: QRTZ_ # Quartz 表前缀isClustered: true # 是集群模式clusterCheckinInterval: 1000useProperties: false# 线程池相关配置threadPool:threadCount: 25 # 线程池大小。默认为 10 。threadPriority: 5 # 线程优先级class: org.quartz.simpl.SimpleThreadPool # 线程池类型jdbc: # 使用 JDBC 的 JobStore 的时候，JDBC 的配置initialize-schema: never # 是否自动使用 SQL 初始化 Quartz 表结构。这里设置成 never ，我们手动创建表结构。

注意事项：

• Spring Boot 2.6.0+ 中，job-store-type: jdbc 会自动选择 JobStoreTX，无需显式指定 org.quartz.jobStore.class。
• 如果手动指定 class: org.quartz.impl.jdbcjobstore.JobStoreTX，需要注意配置冲突，可能需要禁用 Spring Boot 的自动配置。
• 最佳实践是依赖 Spring Boot 的自动配置，减少手动干预。

初始化 Quartz 表结构

Quartz 下载：

在 Quartz Download 地址，下载对应版本的发布包。

• 解压后，我们可以在 src/org/quartz/impl/jdbcjobstore/ 目录，看到各种数据库的 Quartz 表结构的初始化脚本。
• 这里，因为我们使用 MySQL，所以使用 tables_mysql_innodb.sql 脚本。

Quartz 表结构的说明：

(详细说明参见下面的 [表结构详解])

1. qrtz_job_details：记录每个任务的详细信息。
2. qrtz_triggers：记录每个触发器的详细信息。
3. qrtz_corn_triggers：记录 cornTrigger 的信息。
4. qrtz_simple_triggers：存储 SimpleTrigger 类型触发器的时间信息。
5. qrtz_simprop_triggers：记录带有简单属性的触发器信息（仅在需要时使用）。
6. qrtz_blob_triggers：存储复杂触发器（如可能包含序列化对象的触发器）。
7. qrtz_calendars：记录调度器使用的日历信息（用于排除任务触发时间，如节假日）。
8. qrtz_fired_triggers：记录每个正在执行的触发器。
9. qrtz_paused_trigger_grps：记录被暂停的触发器分组。
10. qrtz_scheduler_state：记录 调度器（每个机器节点）的生命状态。
11. qrtz_locks：记录程序的悲观锁（防止多个节点同时执行同一个定时任务）。

我们会发现，每个表都有一个 SCHED_NAME 字段，Quartz Scheduler 名字。

这样就实现了每个 Quartz 集群，在数据层面的拆分。

数据源配置类

@Configuration
public class DataSourceConfiguration {/*** 创建 user 数据源的配置对象*/@Primary@Bean(name = "userDataSourceProperties")@ConfigurationProperties(prefix = "spring.datasource.user") // 读取 spring.datasource.user 配置到 DataSourceProperties 对象public DataSourceProperties userDataSourceProperties() {return new DataSourceProperties();}/*** 创建 user 数据源*/@Primary@Bean(name = "userDataSource")@ConfigurationProperties(prefix = "spring.datasource.user.hikari")// 读取 spring.datasource.user 配置到 HikariDataSource 对象public DataSource userDataSource() {// 获得 DataSourceProperties 对象DataSourceProperties properties = this.userDataSourceProperties();// 创建 HikariDataSource 对象return createHikariDataSource(properties);}/*** 创建 quartz 数据源的配置对象*/@Bean(name = "quartzDataSourceProperties")@ConfigurationProperties(prefix = "spring.datasource.quartz")// 读取 spring.datasource.quartz 配置到 DataSourceProperties 对象public DataSourceProperties quartzDataSourceProperties() {return new DataSourceProperties();}/*** 创建 quartz 数据源*/@Bean(name = "quartzDataSource")@ConfigurationProperties(prefix = "spring.datasource.quartz.hikari")@QuartzDataSourcepublic DataSource quartzDataSource() {// 获得 DataSourceProperties 对象DataSourceProperties properties = this.quartzDataSourceProperties();// 创建 HikariDataSource 对象return createHikariDataSource(properties);}private static HikariDataSource createHikariDataSource(DataSourceProperties properties) {// 创建 HikariDataSource 对象HikariDataSource dataSource = properties.initializeDataSourceBuilder().type(HikariDataSource.class).build();// 设置线程池名if (StringUtils.hasText(properties.getName())) {dataSource.setPoolName(properties.getName());}return dataSource;}}

创建任务类

@DisallowConcurrentExecution // 保证相同 JobDetail 在多个 JVM 进程中，有且仅有一个节点在执行
public class DemoJob01 extends QuartzJobBean {private final Logger logger = LoggerFactory.getLogger(getClass());@Resourceprivate DemoService demoService;@Overrideprotected void executeInternal(JobExecutionContext context) throws JobExecutionException {logger.info("[executeInternal][我开始执行了, demoService 为 ({})]", demoService);}}public class DemoJob02 extends QuartzJobBean {private final Logger logger = LoggerFactory.getLogger(getClass());@Overrideprotected void executeInternal(JobExecutionContext context) throws JobExecutionException {logger.info("[DemoJob02-executeInternal][我开始执行了]");}}

注意事项：

1. @DisallowConcurrentExecution 注解 不是以 Quartz Job 为维度，保证在多个 JVM 进程中，有且仅有一个节点在执行，而是以 JobDetail 为维度。
   • 虽然说，绝大多数情况下，我们会保证一个 Job 和 JobDetail 是一一对应。
   • 所以，搞不清楚这个概念的胖友，最好搞清楚这个概念。实在有点懵逼，保证一个 Job 和 JobDetail 是一一对应就对了。
2. JobDetail 的唯一标识是 JobKey ，使用 name + group 两个属性。
   • 一般情况下，我们只需要设置 name 即可，而 Quartz 会默认 group = DEFAULT。
   • 在 Quartz 中，相同 Scheduler 名字的节点，形成一个 Quartz 集群。
   • 我们可以通过 spring.quartz.scheduler-name 配置项，设置 Scheduler 的名字。
3. 通过在 Job 实现类上添加 @DisallowConcurrentExecution 注解，实现在相同的 Quartz Scheduler 集群中，相同 JobKey 的 JobDetail，保证在多个 JVM 进程中，有且仅有一个节点在执行。

定时任务配置

Bean 自动设置

/*** Bean 自动设置** @author chenmeng*/
@Configuration
public class ScheduleConfiguration {public static class DemoJob01Configuration {/*** 创建 DemoJob01 的 JobDetail Bean 对象** @return JobDetail*/@Beanpublic JobDetail demoJob01() {return JobBuilder.newJob(DemoJob01.class).withIdentity("demoJob01") // 名字为 demoJob01.storeDurably() // 没有 Trigger 关联的时候任务是否被保留。因为创建 JobDetail 时，还没 Trigger 指向它，所以需要设置为 true ，表示保留。.build();}/*** 创建 DemoJob01 的 Trigger Bean 对象。* 其中，我们使用 SimpleScheduleBuilder 简单的调度计划的构造器，创建了每 5 秒执行一次，无限重复的调度计划** @return Trigger*/@Beanpublic Trigger demoJob01Trigger() {// 简单的调度计划的构造器SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(5) // 频率 - 每 5 秒。.repeatForever(); // 次数 - 无限重复。// Trigger 构造器return TriggerBuilder.newTrigger().forJob(demoJob01()) // 对应 Job 为 demoJob01.withIdentity("demoJob01Trigger") // 名字为 demoJob01Trigger.withSchedule(scheduleBuilder) // 对应 Schedule 为 scheduleBuilder.build();}}public static class DemoJob02Configuration {/*** 创建 DemoJob02 的 JobDetail Bean 对象** @return JobDetail*/@Beanpublic JobDetail demoJob02() {return JobBuilder.newJob(DemoJob02.class).withIdentity("demoJob02") // 名字为 demoJob02.storeDurably() // 没有 Trigger 关联的时候任务是否被保留。因为创建 JobDetail 时，还没 Trigger 指向它，所以需要设置为 true ，表示保留。.build();}/*** 创建 DemoJob02 的 Trigger Bean 对象。* 其中，我们使用 CronScheduleBuilder 基于 Quartz Cron 表达式的调度计划的构造器，* 创建了每第 10 秒执行一次的调度计划。** @return Trigger*/@Beanpublic Trigger demoJob02Trigger() {//  基于 Quartz Cron 表达式的调度计划的构造器CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0/10 * * * * ? *");// Trigger 构造器return TriggerBuilder.newTrigger().forJob(demoJob02()) // 对应 Job 为 demoJob02.withIdentity("demoJob02Trigger") // 名字为 demoJob02Trigger.withSchedule(scheduleBuilder) // 对应 Schedule 为 scheduleBuilder.build();}}}

Schedule 手动设置

/*** Scheduler 手动设置* 执行之前，需要确保项目中只有一个 @SpringBootApplication 注解 或者 指定扫描范围** @author chenmeng*/
@SpringBootTest(classes = QuartzJdbcApplication.class)
public class QuartzSchedulerTest {@Autowiredprivate Scheduler scheduler;@Testpublic void addDemoJob01Config() throws SchedulerException {// 创建 JobDetailJobDetail jobDetail = JobBuilder.newJob(DemoJob01.class).withIdentity("demoJob01") // 名字为 demoJob01.storeDurably() // 没有 Trigger 关联的时候任务是否被保留。因为创建 JobDetail 时，还没 Trigger 指向它，所以需要设置为 true ，表示保留。.build();// 创建 TriggerSimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(5) // 频率。.repeatForever(); // 次数。Trigger trigger = TriggerBuilder.newTrigger().forJob(jobDetail) // 对应 Job 为 demoJob01.withIdentity("demoJob01Trigger") // 名字为 demoJob01Trigger.withSchedule(scheduleBuilder) // 对应 Schedule 为 scheduleBuilder.build();// 添加调度任务（将 JobDetail 和 Trigger 持久化到数据库）scheduler.scheduleJob(jobDetail, trigger);}@Testpublic void addDemoJob02Config() throws SchedulerException {// 创建 JobDetailJobDetail jobDetail = JobBuilder.newJob(DemoJob02.class).withIdentity("demoJob02") // 名字为 demoJob02.storeDurably() // 没有 Trigger 关联的时候任务是否被保留。因为创建 JobDetail 时，还没 Trigger 指向它，所以需要设置为 true ，表示保留。.build();// 创建 TriggerCronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0/10 * * * * ? *");Trigger trigger = TriggerBuilder.newTrigger().forJob(jobDetail) // 对应 Job 为 demoJob01.withIdentity("demoJob02Trigger") // 名字为 demoJob01Trigger.withSchedule(scheduleBuilder) // 对应 Schedule 为 scheduleBuilder.build();// 添加调度任务（将 JobDetail 和 Trigger 持久化到数据库）scheduler.scheduleJob(jobDetail, trigger);// 如果想要覆盖数据库中的 Quartz 定时任务的配置，可以调用此方法，传入 replace = true 进行覆盖配置。// scheduler.scheduleJob(jobDetail, Sets.newSet(trigger), true);}}

启动测试

第一个服务：

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

第二个服务：

/*** 测试集群下的运行情况** @author chenmeng*/
@SpringBootApplication
public class QuartzJdbcApplication02 {public static void main(String[] args) {// 设置 Tomcat 随机端口System.setProperty("server.port", "0");// 启动 Spring Boot 应用SpringApplication.run(QuartzJdbcApplication02.class, args);}}

Bug 记录

异常信息：

# 找不到数据源
Failed to obtain DB connection from data source 'quartzDataSource': java.sql.SQLException: There is no DataSource named 'quartzDataSource'

解决方案：

配置文件：

• 移除或注释掉 class: org.quartz.impl.jdbcjobstore.JobStoreTX 配置项

原因分析

为什么注释掉 class: org.quartz.impl.jdbcjobstore.JobStoreTX 能解决问题？

在 Spring Boot 2.6.0 及以上版本中，Quartz 的配置机制进行了增强，尤其是对于 JobStore 的自动配置：

1. Spring Boot 自动管理 JobStore 类型：
   • Spring Boot 会根据 spring.quartz.job-store-type 属性自动推断 JobStore的实现类：
     • memory：使用内存存储（RAMJobStore）。
     • jdbc：使用数据库存储（JobStoreTX）。
   • 如果你显式指定了 org.quartz.jobStore.class，则会覆盖 Spring Boot 的默认行为，可能导致配置不兼容或冲突。
2. Spring Boot Quartz Starter 的改进：
   • Spring Boot 的 spring-boot-starter-quartz 在 2.6.0+ 中已经内置了对 JobStoreTX 的支持，
   • 只需要正确配置 job-store-type: jdbc，无需手动设置 org.quartz.jobStore.class。
3. 手动配置 class: org.quartz.impl.jdbcjobstore.JobStoreTX 会冲突：
   • 如果手动配置了 org.quartz.jobStore.class，Spring Boot 的自动配置逻辑可能会重复设置 JobStore，从而引发问题，例如无法正确初始化数据源或 JobStore。

表结构详解

以下是 Quartz 2.3.0 官方脚本中 11 张表的说明及其功能描述：

1、qrtz_job_details（QRTZ_JOB_DETAILS）

• 功能：记录每个定时任务的详细信息。
• 主要字段：
  • JOB_NAME 和 JOB_GROUP：任务名称和任务分组，联合主键。
  • DESCRIPTION：任务的描述信息。
  • JOB_CLASS_NAME：执行任务的类的全限定名。
  • IS_DURABLE：是否是持久任务（即任务是否在没有触发器时保留）。
  • JOB_DATA：任务附加的键值对数据。

2、qrtz_triggers（QRTZ_TRIGGERS）

• 功能：记录每个触发器的详细信息。
• 主要字段：
  • TRIGGER_NAME 和 TRIGGER_GROUP：触发器名称和分组，联合主键。
  • JOB_NAME 和 JOB_GROUP：关联的任务名称和分组。
  • TRIGGER_STATE：触发器当前的状态（如等待、暂停、阻塞等）。
  • TRIGGER_TYPE：触发器的类型（如 Cron、Simple、Blob 等）。
  • START_TIME 和 END_TIME：触发器的起始时间和结束时间。
  • MISFIRE_INSTR：触发器的误操作策略。

3、qrtz_corn_triggers（QRTZ_CRON_TRIGGERS）

• 功能：存储 CronTrigger 类型触发器的时间表达式。
• 主要字段：
  • TRIGGER_NAME 和 TRIGGER_GROUP：触发器名称和分组（外键关联 QRTZ_TRIGGERS 表）。
  • CRON_EXPRESSION：Cron 表达式。
  • TIME_ZONE_ID：时区 ID。

4、qrtz_simple_triggers（QRTZ_SIMPLE_TRIGGERS）

• 功能：存储 SimpleTrigger 类型触发器的时间信息。
• 主要字段：
  • TRIGGER_NAME 和 TRIGGER_GROUP：触发器名称和分组（外键关联 QRTZ_TRIGGERS 表）。
  • REPEAT_COUNT：触发次数。
  • REPEAT_INTERVAL：触发间隔。
  • TIMES_TRIGGERED：已触发次数。

5、qrtz_simprop_triggers（QRTZ_SIMPROP_TRIGGERS）

• 功能：记录带有简单属性的触发器信息（仅在需要时使用）。
• 主要字段：
  • TRIGGER_NAME 和 TRIGGER_GROUP：触发器名称和分组（外键关联 QRTZ_TRIGGERS 表）。
  • STR_PROP_1 ~ STR_PROP_4：自定义字符串属性。
  • INT_PROP_1 ~ INT_PROP_2：自定义整数属性。
  • DEC_PROP_1 ~ DEC_PROP_2：自定义小数属性。
  • BOOL_PROP_1：自定义布尔属性。

6、qrtz_blob_triggers（QRTZ_BLOB_TRIGGERS）

• 功能：存储复杂触发器（如可能包含序列化对象的触发器）。
• 主要字段：
  • TRIGGER_NAME 和 TRIGGER_GROUP：触发器名称和分组（外键关联 QRTZ_TRIGGERS 表）。
  • BLOB_DATA：二进制大对象数据。

7、qrtz_calendars（QRTZ_CALENDARS）

• 功能：记录调度器使用的日历信息（用于排除任务触发时间，如节假日）。
• 主要字段：
  • CALENDAR_NAME：日历名称。
  • CALENDAR：序列化后的日历数据。

8、qrtz_fired_triggers（QRTZ_FIRED_TRIGGERS）

• 功能：记录每个正在执行的触发器实例。
• 主要字段：
  • ENTRY_ID：执行条目的唯一标识。
  • TRIGGER_NAME 和 TRIGGER_GROUP：触发器名称和分组。
  • INSTANCE_NAME：触发器所属的调度器实例。
  • FIRED_TIME：触发时间。
  • PRIORITY：触发器优先级。

9、qrtz_paused_trigger_grps（QRTZ_PAUSED_TRIGGER_GRPS）

• 功能：记录被暂停的触发器分组。
• 主要字段：
  • TRIGGER_GROUP：被暂停的触发器分组名称。

10、qrtz_scheduler_state（QRTZ_SCHEDULER_STATE）

• 功能：记录调度器（每个机器节点）的运行状态。
• 主要字段：
  • INSTANCE_NAME：调度器实例的名称。
  • LAST_CHECKIN_TIME：调度器最后一次心跳的时间。
  • CHECKIN_INTERVAL：心跳间隔。

11、qrtz_locks（QRTZ_LOCKS）

• 功能：记录调度器的全局锁（用于悲观锁，防止多节点竞争执行同一个任务）。
• 主要字段：
  • SCHED_NAME：调度器名称。
  • LOCK_NAME：锁的名称。

表之间的关系

• QRTZ_JOB_DETAILS 是核心任务表，记录任务基本信息。
• QRTZ_TRIGGERS 与任务相关联，存储触发器的基本信息。
• QRTZ_CRON_TRIGGERS、QRTZ_SIMPLE_TRIGGERS、QRTZ_BLOB_TRIGGERS 等扩展触发器表，存储不同类型触发器的详细信息。
• QRTZ_SCHEDULER_STATE 和 QRTZ_LOCKS 用于调度器的分布式协调。

这 11 张表共同支撑了 Quartz 的任务调度功能，既支持单机调度，也支持分布式集群环境。

学习参考

• Quartz 入门详解
• 芋道 Spring Boot 定时任务入门
• Quartz框架（二）——jobstore数据库表字段详解 - 简书
• springboot升级2.6.x,Quartz2.3.2找不到数据源_there is no datasource named 'quartzdatasource-CSDN博客