Quartz 使用教程

首先说说，为什么要写这篇文章：

• Quartz 的 v2.3.2 版本改动比较大，目前网上的资料都是旧版本，很缺乏相关资料
• 很多资料讲解非常不全面，例如 Quartz Listener 的介绍和使用基本缺失
• Springboot 整合 Quartz 是目前普遍的使用场景，但是 Quartz 官方没有相关资料
• 网上很少关于基于 Springboot 整合的 Quartz 搭建集群环境，而且大多无法运行

为了避免让大家重复踩坑，综上所述就是我要写本篇文章的目的了

本文档编写时间 23.1.17，基于目前最新的稳定版 quartz 2.3.2 实现

概述

简单介绍：

Quartz 是目前 Java 领域应用最为广泛的任务调度框架之一，目前很多流行的分布式调度框架，例如 xxl-job 都是基于它衍生出来的，所以了解和掌握 Quartz 的使用，对于平时完成一些需要定时调度的工作会更有帮助

快速开始

我们通过一个最简单的示例，先快速上手 Quartz 最基本的用法，然后再逐步讲解 Quartz 每个模块的功能点

第一步：添加依赖

在 pom.xml 文件添加 Quart 依赖：

<!-- 引入 quartz 基础依赖：可取当前最新版本 -->
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.2</version>
</dependency>

<!-- 引入 quartz 所需的日志依赖：可取当前最新版本 -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.26</version>
    <scope>compile</scope>
</dependency>

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-simple</artifactId>
    <version>1.7.26</version>
    <scope>compile</scope>
</dependency>

第二步：配置文件

在项目的 classpath 路径下创建 Quartz 默认的 quartz.properties 配置文件，它看起来像这样：

# 调度程序的名称
org.quartz.scheduler.instanceName = MyScheduler
# 线程数量
org.quartz.threadPool.threadCount = 3
# 内存数据库（推荐刚上手时使用）
org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

第三步：定义任务类

实现 Job 接口，然后在覆盖的 execute 函数内定义任务逻辑，如下：

package org.example.quartz.tutorial;

import org.quartz.Job;
import org.quartz.JobExecutionContext;

public class HelloJob implements Job {

    @Override
    public void execute(JobExecutionContext context) {
        System.out.println("hello quartz!");
    }
}

第四步：任务调度

我们简单的使用 main() 方法即可运行 Quartz 任务调度示例：

package org.example.quartz.tutorial;

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.SimpleTrigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class QuartzTest {

    public static void main(String[] args) {
        try {
            // 获取默认的调度器实例
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

            // 打开调度器
            scheduler.start();

            // 定义一个简单的任务
            JobDetail job = JobBuilder.newJob(HelloJob.class)
                    .withIdentity("job11", "group1")
                    .build();

            // 定义一个简单的触发器: 每隔 1 秒执行 1 次，任务永不停止
            SimpleTrigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity("trigger1", "group1")
                    .startNow()
                    .withSchedule(SimpleScheduleBuilder
                            .simpleSchedule()
                            .withIntervalInSeconds(1)
                            .repeatForever()
                    ).build();

            // 开始调度任务
            scheduler.scheduleJob(job, trigger);

            // 等待任务执行一些时间
            Thread.sleep(3000);

            // 关闭调度器
            scheduler.shutdown();
        } catch (Exception se) {
            se.printStackTrace();
        }
    }
}

最后控制台会输出任务运行的全过程，然后关闭进程，如下：

[main] INFO org.quartz.impl.StdSchedulerFactory - Using default implementation for ThreadExecutor
[main] INFO org.quartz.core.SchedulerSignalerImpl - Initialized Scheduler Signaller of type: class org.quartz.core.SchedulerSignalerImpl
[main] INFO org.quartz.core.QuartzScheduler - Quartz Scheduler v.2.3.2 created.
[main] INFO org.quartz.simpl.RAMJobStore - RAMJobStore initialized.
[main] INFO org.quartz.core.QuartzScheduler - Scheduler meta-data: Quartz Scheduler (v2.3.2) 'MyScheduler' with instanceId 'NON_CLUSTERED'
  Scheduler class: 'org.quartz.core.QuartzScheduler' - running locally.
  NOT STARTED.
  Currently in standby mode.
  Number of jobs executed: 0
  Using thread pool 'org.quartz.simpl.SimpleThreadPool' - with 3 threads.
  Using job-store 'org.quartz.simpl.RAMJobStore' - which does not support persistence. and is not clustered.

[main] INFO org.quartz.impl.StdSchedulerFactory - Quartz scheduler 'MyScheduler' initialized from default resource file in Quartz package: 'quartz.properties'
[main] INFO org.quartz.impl.StdSchedulerFactory - Quartz scheduler version: 2.3.2
[main] INFO org.quartz.core.QuartzScheduler - Scheduler MyScheduler_$_NON_CLUSTERED started.
hello quartz!
hello quartz!
hello quartz!
hello quartz!
[main] INFO org.quartz.core.QuartzScheduler - Scheduler MyScheduler_$_NON_CLUSTERED shutting down.
[main] INFO org.quartz.core.QuartzScheduler - Scheduler MyScheduler_$_NON_CLUSTERED paused.
[main] INFO org.quartz.core.QuartzScheduler - Scheduler MyScheduler_$_NON_CLUSTERED shutdown complete.

Process finished with exit code 0

可以看到，到这里一个最基本简单的 Quartz 使用示例基本就 OK 了，接下来介绍更多核心概念和深入使用的场景

核心概念

触发器和作业

基本概念

掌握 Quartz 之前，先来了解它框架的 3 个核心组件和概念，如下：

• Schduler：调度器，主要用于管理作业（JobDetail），触发器（Trigger）
• JobDetail：作业实例，内部包含作业运行的具体逻辑
• Trigger：触发器实例，内部包含作业执行的实践计划

工作流程

如上所示，使用 Quartz 的工作流程也很简单，大致如下：

1. 首页基于 Job 接口定义你的作业 JobDetail 实例和触发器 Trigger 实例对象
2. 将定义的作业和触发器实例对象通过调度器 scheduleJob，开始调度执行
3. 调度器启动工作线程开始执行 JobDetail 实例的 execute 方法内容
4. 任务运行时所需信息通过，JobExecutionContext 对象传递到工作线程，也可以在多个工作线程中跨线程传递

示意图：

唯一标识

关于创建 JobDetail 作业实例和 Trigger 触发器的几个注意事项：

1. 创建作业和触发器都需要通过（JobKey 和 TriggerKey + Group）组合创建唯一标识
2. 你可以通过唯一标识在 Schduler 中获取作业对象，并且管理和维护他们
3. 引入 Group 标识的目的也是了更好的让你管理作业环境：例如：通过不同的 Group 来区分：【测试作业，生产作业】等

JobDetail 的更多细节

通过示例可以看到，定义和使用 Job 都非常简单，但是如果要深入使用，你可能需要了解关于 Job 的更多细节

先看看 Quartz 对于 JobDetail 的处理策略：

1. 每次执行任务都会创建一个新的 JobDetail 实例对象，意味每次执行的 JobDetail 都是新对象，JobDetail 对象也是无状态的
2. JobDetail 实例对象任务完成后 （execute 方法），调度器 Schduler 会将作业实例对象删除，然后进行垃圾回收
3. JobDetail 实例之间的状态数据，只能通过 JobExecutionContext（实际上是 JobDataMap） 进行跨作业传递

JobDataMap

jobDataMap 的使用主要分 2 步：

1：在 execute() 函数内，使用 jobDataMap 获取数据

public class HelloJob implements Job {

    @Override
    public void execute(JobExecutionContext context) {
        // 通过 JobDataMap 对象，可以在作业的执行逻辑中，获取参数
        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
        String name = jobDataMap.getString("name");

        System.out.println("hello " + name);
    }
}

2：jobDataMao 添加参数

// 定义作业时，通过 usingJobData 将参数放入 JobDataMap
JobDetail job = JobBuilder.newJob(HelloJob.class)
    .withIdentity("job11", "group1")
    .usingJobData("name", "phoenix")
    .build();

最后运行效果如下：

[main] INFO org.quartz.core.QuartzScheduler - Scheduler MyScheduler_$_NON_CLUSTERED started.
hello phoenix
[main] INFO org.quartz.core.QuartzScheduler - Scheduler MyScheduler_$_NON_CLUSTERED shutting down.
# ....

关于 JobDataMap 的使用，需要关注以下的注意事项：

1. 虽然 JobDataMap 可以传递任意类型的数据，对象的反序列化在版本迭代中容易遇到类版本控制的问题
2. 如果从长远的安全性考虑，尽可能的将 jobDataMap 设置为只允许存放基本类型和字符串（通过 jobStore.useProperties 设置）
3. Quartz 会自动通过 Job 类的 setter 方法和 JobDataMap 主键匹配，帮助你自动注入属性到 Job 类中

并发性和持久化

Quartz 对于 Job 提供几个注释，合理的使用可以更好的控制 Quartz 的调度行为，具体如下：

• @DisallowConcurrentExecution：添加到 Job 类中，告诉 Job 防止相同定义的任务并发执行，例如：任务 A 实例未完成任务，则任务 B 实例不会开始执行（Quartz 默认策略是不会等待，启用新线程并发调度）

• @PersistJobDataAfterExecution：添加到 Job 类中，默认情况下 Job 作业运行逻辑不会影响到 JobDataMap （既每个 JobDetail 拿到的都是初始化的 JobDataMap 内容），开启该注解后，Job 的 execute() 方法完成后，对于 JobDataMap 的更新，将会被持久化到 JobDataMap 中，从而供其他的 JobDetail 使用，这对于任务 B 依赖任务 A 的运行结果的场景下，非常有用，所以强烈建议和 @DisallowConcurrentExecution 注解一起使用，会让任务运行结果更加符合预期

使用示例如下：

@DisallowConcurrentExecution
@PersistJobDataAfterExecution
public class QuartzTest {

    public static void main(String[] args) {
        //.....
    }
}

Trigger 的更多细节

和 Job 类似，触发器的定义和使用也非常简单，但是如果想充分的利用它来工作，你还需要了解关于触发器的更多细节

在 Quartz 中 Trigger 触发器有很多种类型，但是他们都有几个共同的属性，如下：

• startTime：触发器首次生效的时间
• endTime：触发器失效时间

以上共同属性的值都是 java.util.Date 对象

关于 Trigger 的其他几个概念：

• Priority 优先权：当调度器遇到多个同时执行的 Trigger 时候，会根据优先权大小排序，然后先后调度
• Misfire 错过触发：Trigger 达到触发时间，但因为外部原因无法执行，Trigger 开始计算 Misfire 时间
  • 常见的外部原因有哪些？例如：调度程序被关闭，线程池无可用工作线程等
• Calendar 日历（不是 java.util.calendar 对象）：用于排除执行日期非常有用
  • 例如：定义一个每天 9 点执行 Trigger ，但是排除所有法定节假日

SimpleTrigger

SimpleTrigger 是适用于大多数场景的触发器，它可以指定特定时间，重复间隔，重复次数等简单场景，它主要设定参数如下：

1. 开始时间
2. 结束时间
3. 重复次数
4. 间隔时间

具体的 API 可以参考 Quartz 的 Java Doc 文档，这里就不赘述了

misfire 处理策略：

我们上面说过 Quartz Misfire 的概念，从源码 SimpleScheduleBuilder 类中可以看到 MISFIRE_INSTRUCTION_SMART_POLICY 是默认的触发策略，但是也我们也可以在创建 Trigger 时候设置我们期望的错过触发策略，如下：

SimpleTrigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity("trigger1", "group1")
                    .withSchedule(SimpleScheduleBuilder
                            .simpleSchedule()
                            .withIntervalInSeconds(1)
                            .repeatForever()
                            // misfireInstruction = SimpleTrigger.MISFIRE_INSTRUCTION_FIRE_NOW;
                            .withMisfireHandlingInstructionFireNow()
                    ).build();

在 SimpleTrigger 类中的常量可以看到所有错过触发（misfire）处理逻辑：

MISFIRE_INSTRUCTION_FIRE_NOW
MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT
MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_REMAINING_REPEAT_COUNT
MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT
MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_EXISTING_COUNT

关于 misfire 的具体的行为，可以查阅 Quartz 的 Java Doc 文档

CronTrigger

相比 SimpleTrigger 可以指定更为复杂的执行计划，CRON 是来自 UNIX 基于时间的任务管理系统，相关内容就不再展开，可以参阅 Cron - (wikipedia.org) 文档进一步了解，

Cron 也有类似 SimpleTrigger 的相同属性，设置效果如下：

• startTime：触发器首次生效的时间
• endTime：触发器失效时间

看看 CronTrigger 的使用示例：

CronTrigger cronTrigger = TriggerBuilder.newTrigger()
    .withIdentity("trigger1", "group1")
    .withSchedule(CronScheduleBuilder
                  .cronSchedule("0 0/2 8-17 * * ?")
                  .withMisfireHandlingInstructionFireAndProceed()
                 )
    .build();

scheduler.scheduleJob(job, cronTrigger);

上述代码完成以下几件事情：

1. 创建 Cron 表达式：每天上午 8 点到下午 5 点之间每隔一分钟触发一次
2. 指定 MISFIRE_INSTRUCTION_FIRE_NOW 为 CronTrigger 的处理策略
3. 通过 Schduler 对任务开始进行调度

CronTrigger Misfire 策略定义在 CronTrigger 常量中，可以在 Java Doc 文档中查看其具体的行为

Linstener 监听器

监听器用于监听 Quartz 任务事件执行对应的操作，大致分类如下：

• JobListener：用于监听 JobDetail 相关事件
• TriggerListener：用于监听 Trigger 相关事件
• SchdulerListener：用于监听 Schduler 相关事件

在常见的 JobListener 接口中，提供以下事件监听：

public interface JobListener {

    public String getName();
    // 作业即将开始执行时触发
    public void jobToBeExecuted(JobExecutionContext context);
    // 作业即将取消时通知
    public void jobExecutionVetoed(JobExecutionContext context);
    // 作业执行完成后通知
    public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException);
}

想要实现监听，需要以下几步：

1. 自定义监听类，实现 *Listener 监听接口
2. 在你感兴趣的事件，加入你的逻辑代码
3. 将自定义监听类，在任务调度前，注册到 Schduler 中即可

在 Schduler 中注册一个对所有任务生效的 Listener 的示例：

scheduler.getListenerManager().addJobListener(myJobListener, allJobs());

关于使用 Listener 的建议：

• 在最新的 2.3.2 Listener 不会存储在 JobStore 中，所以在持久化模式下，每次启动都需要重新注册监听
• 大多数场景下 Quartz 用户不会使用 Listener，除非非常必要的情况才使用

JobStore 作业存储

JobStore 属性在 Quartz 配置文件中声明，用于定义 Quartz 所有运行时任务的存储方式，目前主要有两种方式

RAMJobStore

RAMJobStore 是基于内存的存储模式，其特点如下：

• 优点：使用，配置简单，性能最高
• 缺点：程序关闭后，任务信息会丢失

配置方式如下:

org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

JDBCJobStore

JDBCJobStore 是基于数据的存储模式，其特点如下：

• 优点：支持常见的数据库，可以持久化保存任务信息
• 缺点：配置繁琐，性能不高（取决于数据库）

使用示例

使用 JDBCJobStore 需要以下 3 步完成：

第一步：在项目中添加相关数据库依赖：

<!-- 添加数据库依赖 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.29</version>
</dependency>

第二步：在数据库执行 [Quartz 官方的 SQL DDL 脚本](quartz/tables_mysql_innodb.sql at master · quartz-scheduler/quartz (github.com))，创建数据库表结构，Quartz 核心的表结构如下：

Table Name	Description
QRTZ_CALENDARS	存储Quartz的Calendar信息
QRTZ_CRON_TRIGGERS	存储CronTrigger，包括Cron表达式和时区信息
QRTZ_FIRED_TRIGGERS	存储与已触发的Trigger相关的状态信息，以及相联Job的执行信息
QRTZ_PAUSED_TRIGGER_GRPS	存储已暂停的Trigger组的信息
QRTZ_SCHEDULER_STATE	存储少量的有关Scheduler的状态信息，和别的Scheduler实例
QRTZ_LOCKS	存储程序的悲观锁的信息
QRTZ_JOB_DETAILS	存储每一个已配置的Job的详细信息
QRTZ_JOB_LISTENERS	存储有关已配置的JobListener的信息
QRTZ_SIMPLE_TRIGGERS	存储简单的Trigger，包括重复次数、间隔、以及已触的次数
QRTZ_BLOG_TRIGGERS	Trigger作为Blob类型存储
QRTZ_TRIGGERS	存储已配置的Trigger的信息

第三步：配置文件修改为 JDBCJobStore 模式，配置数据源，并且将 jobStore 指定为该数据源，如下

# quartz scheduler config
org.quartz.scheduler.instanceName = MyScheduler
org.quartz.threadPool.threadCount = 3
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.tablePrefix = QRTZ_
org.quartz.jobStore.dataSource = myDS

# dataSource
org.quartz.dataSource.myDS.driver = com.mysql.cj.jdbc.Driver
org.quartz.dataSource.myDS.URL = jdbc:mysql://127.0.0.1:3306/quartz_demo
org.quartz.dataSource.myDS.user = root
org.quartz.dataSource.myDS.password = test123456
org.quartz.dataSource.myDS.maxConnections = 30

最后运行 QuartzTest 后可以看到数据库 QRTZ_JOB_DETAILS 表已经添加数据，如下：

注意事项

在使用 JDBCJobStore 时，需要注意以下事项：

• Quartz 的 JobStoreTX 默认是独立示例，如果需要和其他事务一起工作（例如 J2EE 服务器），可以选择 JobStoreCMT
• 默认表前缀是 QRTZ_，可进行配置，使用多个不同的前缀有助于实现同一数据库的任务调度多组表结构
• JDBC 委托驱动 StdJDBCDelegate 适用于大多数数据库，目前只针对测试 StdJDBCDelegate 时出现问题的类型进行特定的委托
  • DB2v6Delegate：适用于 DB2 版本 6 及更早版本
  • HSQLDBDelegate：适用于 HSQLDB 数据库
  • MSSQLDelegate：适用于 Microsoft SQLServer 数据库
  • PostgreSQLDelegate：适用于 PostgreSQL 数据库
  • WeblogicDelegate：由 Weblogic 制作的驱动程序
  • OracleDelegate：适用于 Oracle 数据库
  • …………
• 将 org.quartz.jobStore.useProperties 设置为 True，避免将非基础类型数据存储到数据库的 BLOB 字段

springboot 集成

Quartz 整合 Springboot 非常普遍的场景，整合 Spring 可以带来好处：

• 更加简洁的配置，开箱即用
• 和 Spring 的 IOC 容器融合，使用更便捷

添加依赖

可以在现有项目上添加 springboot 官方提供的 starter-quartz 依赖，如下：

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

如果是新项目，可以直接在 Spring Initializr 添加 Quartz Schduler 如下：

启动 Springboot 会发现，无需任何配置就已经整合 Quartz 模块了：

使用示例

现在基于整合模式实现刚才的 Demo 示例，首先定义任务，这里不再是实现 Job 类：

public class HelloJob extends QuartzJobBean {

    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
        String name = jobDataMap.getString("name");
        System.out.println("Hello :" + name);
    }
}

这里实现由 Springboot 提供的 QuartzJobBean，实现 executerInternal() 方法，这是一个经过 Spring 容器包装后的任务类，可以在任务类使用 Spring 容器的实例

在 Demo 示例里面，我们调度启动都是在 Main 方法启动，在本地测试没有问题，但在生产环境就不建议了，和 springboot 整合后关于任务执行，现在可以有 2 中选项：

1. 在控制层 Controller 提供接口，手动接收任务指定
2. 监听 Spring 容器，在容器启动后，自动加载任务，并且注册为 Bean

手动执行

我们先看看第一种实现方式，我们创建控制器，然后接收参数，创建任务，如下：

@RestController
public class HelloController {

    @Autowired
    private Scheduler scheduler;

    @GetMapping("/hello")
    public void helloJob(String name) throws SchedulerException {
        // 定义一个的任务
        JobDetail job = JobBuilder.newJob(HelloJob.class)
                .withIdentity("job11", "group1")
                .usingJobData("name", name)
                .build();

        // 定义一个简单的触发器: 每隔 1 秒执行 1 次，任务永不停止
        SimpleTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1")
                .withSchedule(SimpleScheduleBuilder
                        .simpleSchedule()
                        .withIntervalInSeconds(1)
                        .repeatForever()
                ).build();

        // 开始调度
        scheduler.scheduleJob(job, trigger);
    }
}

然后启动服务器，访问接口传入参数：

$curl --location --request GET 'http://localhost:8080/hello?name=phoenix'

然后控制台会输出：

2023-01-21 22:03:03.213  INFO 23832 --- [nio-8080-exec-2] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2023-01-21 22:03:03.213  INFO 23832 --- [nio-8080-exec-2] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2023-01-21 22:03:03.214  INFO 23832 --- [nio-8080-exec-2] o.s.web.servlet.DispatcherServlet        : Completed initialization in 1 ms
Hello :phoenix
Hello :phoenix
#....

自动执行

将 JobDetail 注册 Bean，任务就会随 Spring 启动自动触发执行，这对于需要随程序启动执行的作业非常有效，配置如下：

先创建一个配置类：

@Configuration
public class QuartzConfig {

    @Bean
    public JobDetail jobDetail() {
        JobDetail job = JobBuilder.newJob(HelloJob.class)
                .withIdentity("job11", "group1")
                .usingJobData("name", "springboot")
                .storeDurably()
                .build();

        return job;
    }

    @Bean
    public Trigger trigger() {
        SimpleTrigger trigger = TriggerBuilder.newTrigger()
                .forJob(jobDetail())
                .withIdentity("trigger1", "group1")
                .withSchedule(SimpleScheduleBuilder
                        .simpleSchedule()
                        .withIntervalInSeconds(1)
                        .repeatForever()
                ).build();

        return trigger;
    }
}

然后在 springboot 启动后，任务就自动执行：

2023-01-21 22:29:51.962  INFO 46376 --- [           main] org.quartz.core.QuartzScheduler          : Scheduler quartzScheduler_$_NON_CLUSTERED started.
Hello :springboot
Hello :springboot
Hello :springboot
# ....

集群模式

对于生产环境来说，高可用，负载均衡，故障恢复，这些分布式的能力是必不可少的，Quartz 天生支持基于数据库的分布式：

要启用集群模式，需要注意以下事项：

1. 需要启用 JDBCStore 或者 TerracottaJobStore 运行模式
2. 需要将 jobStore.isClustered 属性设置为 True
3. 每个单独实例需要设置唯一的 instanceId （Quartz 提供参数让这点很容易实现）

配置集群

下面看看 springboot 集成的模式下如何配置 quartz 集群模式：

在 application.yml 添加 quartz 集群配置信息：

spring:
  datasource:
    driverClassName: com.mysql.cj.jdbc.Driver
    password: 123456
    url: jdbc:mysql://127.0.0.1:3306/quartz_demo
    username: root
  quartz:
    job-store-type: jdbc
    properties:
      org:
        quartz:
          scheduler:
            instanceName: ClusteredScheduler   # 集群名，若使用集群功能，则每一个实例都要使用相同的名字
            instanceId: AUTO    # 若是集群下，每个 instanceId 必须唯一，设置 AUTO 自动生成唯一 Id
          threadPool:
            class: org.quartz.simpl.SimpleThreadPool
            threadCount: 25
            threadPriority: 5
          jobStore:
            class: org.springframework.scheduling.quartz.LocalDataSourceJobStore
            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
            tablePrefix: QRTZ_
            useProperties: true   # 使用字符串参数，避免了将非 String 类序列化为 BLOB 的类版本问题
            isClustered: true     # 打开集群模式
            clusterCheckinInterval: 5000     # 集群存活检测间隔
            misfireThreshold: 60000 # 最大错过触发事件时间

使用集群模式需要添加数据库依赖，如下：

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

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

然后创建 SchedulerConfig 配置类，将相关的配置信息加载到 SchedulerFactoryBean 中才能生效：

@Configuration
public class SchedulerConfig {

	@Autowired
	private DataSource dataSource;

	@Autowired
	private QuartzProperties quartzProperties;

	@Bean
	public SchedulerFactoryBean schedulerFactoryBean() {
		Properties properties = new Properties();
		properties.putAll(quartzProperties.getProperties());

		SchedulerFactoryBean factory = new SchedulerFactoryBean();
		factory.setOverwriteExistingJobs(true);
		factory.setDataSource(dataSource);
		factory.setQuartzProperties(properties);
		return factory;
	}
}

最后在启动日志内，可以看到 Quartz 启动集群模式运行：

注意事项

使用集群模式，需要注意以下事项：

• 不要在单机模式下使用集群模式，不然会出现时钟同步问题，具体参考 NIST Internet Time Service (ITS) | NIST
• 不要在集群示例中，运行单机示例，不然会出现数据混乱和不稳定的情况
• 关于任务的运行节点是随机的（哪个节点抢到锁就可以执行），尤其对大量情人的情况
• 如果不想依赖 JDBC 数据库实现集群，可以看看 TerracottaJobStore 模式

以上对于 Quartz 的总结就到这里了，有什么不当之处，欢迎交流指正。