简介

Quartz是一个完全由Java开发的开源任务日程管理系统（或称为作业调度框架），它能够集成于任何Java应用，小到独立的应用，大至电子商务系统。
Quartz提供了丰富的调度功能和灵活的配置选项，帮助开发者实现复杂的任务调度和定时任务功能。

适用场景

Quartz广泛应用于各种企业级应用系统中，如电子商务、金融、物流等领域。
无论是简单的定时任务（如定时发送邮件、定时清理临时文件等），还是复杂的分布式任务（如分布式定时任务调度、任务依赖关系管理等），Quartz都能够胜任。

Quartz核心概念

Job（作业）

Quartz中的任务，是一个需要被调度执行的接口，任务类需要实现该接口，并在execute方法中编写具体的业务逻辑。

JobDetail

JobDetail用来绑定Job，并为Job实例提供许多属性，如名称、组名、Job类名以及JobDataMap等。
JobDetail定义的是任务数据，而真正的执行逻辑是在Job中。

Trigger（触发器）

Trigger是Quartz的触发器，它描述了触发Job执行的时间触发规则。
Trigger最常用的触发器类型：SimpleTrigger和CronTrigger。

Scheduler（调度器）

Scheduler是Quartz的调度器，它负责基于Trigger设定的时间执行Job。Scheduler是一个容器，它装载着任务和触发器。

Quartz 存储方式

Quartz 存储方式有两种：MEMORY 和 JDBC。

• MEMORY（或RAMJobStore）：这是Quartz的默认存储方式，它将任务调度的运行信息保存在内存中。这种方式提供了最佳的性能，因为内存中数据访问最快。然而，它的不足之处在于缺乏数据的持久性，当程序中途停止或系统崩溃时，所有运行的信息都会丢失。
• JDBC：这种存储方式允许Quartz通过JDBC将任务调度的运行信息保存到数据库中。使用数据库保存任务调度信息后，即使系统崩溃后重新启动，任务的调度信息也将得到恢复。因此，JDBC存储方式提供了数据的持久性。

Quartz 版本类型

Quartz 版本类型有两种：单机版 和 集群版

• 单机版：这是Quartz的默认版本类型 ，Quartz运行在一个单一的Java虚拟机（JVM）实例中。它通常使用MEMORY存储方式，因为这种方式配置容易且运行速度快。然而，单机版Quartz存在单点故障的风险，如果应用程序所在的服务器出现故障，任务调度将会停止。

• 集群版：集群版Quartz可以在多个JVM实例中运行，实现高可用性和负载均衡。在集群版中，通常使用JDBC存储方式，以便在多个节点之间共享任务调度的数据。这样，即使其中一个节点出现故障，其他节点仍然可以继续工作，从而保证了任务调度的连续性和可靠性。

引入相关依赖

<!--quartz定时任务-->
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

开始集成

方式一：内存方式(MEMORY)存储实现定时任务

1. 定义任务类

可以通过实现 Job 接口来定义任务，也可以通过继承 QuartzJobBean 这个抽象类来定义任务，其实 QuartzJobBean 本身也实现了 Job 接口，其本质都是实现 Job 接口来定义任务。

我这边定义了两个任务，用于后续来说明一下关于调度器Scheduler绑定的不同方式
Scheduler绑定有两种方式，一种是使用bena的自动配置，一种是Scheduler手动配置。

FirstJob 类

package com.example.springbootfull.quartztest;import lombok.extern.slf4j.Slf4j;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;@Slf4j
public class FirstJob extends QuartzJobBean {@Overrideprotected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {String now = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(LocalDateTime.now());log.info("手动-FirstJob, 当前的时间: " + now);}
}

SecondJob 类

package com.example.springbootfull.quartztest;import lombok.extern.slf4j.Slf4j;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;@Slf4j
public class SecondJob extends QuartzJobBean {@Overrideprotected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {String now = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(LocalDateTime.now());log.info("自动-SecondJob, 当前的时间: " + now);}
}

2. 定义任务描述及创建任务触发器

方式一：Scheduler手动配置

这个例子使用的是触发器类型为Cron

package com.example.springbootfull.quartztest.config;import com.example.springbootfull.quartztest.FirstJob;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;@Component
public class JobInit implements ApplicationRunner {private static final String ID = "MANUAL";@Autowiredprivate Scheduler scheduler;@Overridepublic void run(ApplicationArguments args) throws Exception {// 配置定时任务的信息，例如配置定时任务的名字，群组之类的JobDetail jobDetail = JobBuilder.newJob(FirstJob.class).withIdentity(ID + " 01")// 设置Job的标识符.storeDurably()// 使JobDetail持久化.build();//触发器类型CronScheduleBuilder scheduleBuilder =CronScheduleBuilder.cronSchedule("0/5 * * * * ? *");// 创建任务触发器Trigger trigger = TriggerBuilder.newTrigger().forJob(jobDetail) //指定 定时任务.withIdentity(ID + " 01Trigger") // 设置Trigger的标识符.withSchedule(scheduleBuilder) //配置触发器类型.startNow() //立即執行一次任務.build();// 手动将触发器与任务绑定到调度器内scheduler.scheduleJob(jobDetail, trigger);}
}

方式二：使用bena的自动配置（建议这种）

这个例子使用的是触发器类型为Simple

package com.example.springbootfull.quartztest.config;import com.example.springbootfull.quartztest.SecondJob;
import org.quartz.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class QuartzConfig {private static final String ID = "AUTOMATIC";//配置定时任务的信息，例如配置定时任务的名字，群组之类的@Beanpublic JobDetail jobDetail1() {return JobBuilder.newJob(SecondJob.class).withIdentity(ID + " 01")// 设置Job的标识符.storeDurably()// 使JobDetail持久化.build();}//创建任务触发器@Beanpublic SimpleTrigger trigger1() {// 简单的调度计划的构造器SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(6) // 频率.repeatForever(); // 无限期地重复执行return TriggerBuilder.newTrigger().forJob(jobDetail1())//指定 定时任务.withIdentity(ID + " 01Trigger").withSchedule(scheduleBuilder).build();}
}

运行启动类以后，可以看到如下情况

3. Quartz的yml配置（按需配置）

yml配置可以更为精细化的，调整 存储配置 及 线程池配置

spring:# 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 附加属性org:quartz:threadPool:threadCount: 25 # 线程池大小。默认为 10 。threadPriority: 5 # 线程优先级class: org.quartz.simpl.SimpleThreadPool # 线程池类型
#    jdbc: # 这里暂时不说明，使用 JDBC 的 JobStore 的时候，才需要配置

方式二：数据库(JDBC)方式存储实现定时任务

1. 创建相关表

首先确定maven拉取了 spring-boot-starter-quartz 的依赖，再接着到私仓下面找到
"你的私仓地址\org\quartz-scheduler\quartz\2.3.2"把这个下面的quartz-2.3.2.jar 给解压
然后到这个文件的 “quartz-2.3.2\org\quartz\impl\jdbcjobstore” 下面就可以可以看到

我这边选择的是“tables_mysql_innodb.sql”脚本
内容如下，执行以后会出现11张表

#
# In your Quartz properties file, you'll need to set
# org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#
#
# By: Ron Cordell - roncordell
#  I didn't see this anywhere, so I thought I'd post it here. This is the script from Quartz to create the tables in a MySQL database, modified to use INNODB instead of MYISAM.DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
DROP TABLE IF EXISTS QRTZ_LOCKS;
DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
DROP TABLE IF EXISTS QRTZ_CALENDARS;CREATE TABLE QRTZ_JOB_DETAILS(
SCHED_NAME VARCHAR(120) NOT NULL,
JOB_NAME VARCHAR(190) NOT NULL,
JOB_GROUP VARCHAR(190) NOT NULL,
DESCRIPTION VARCHAR(250) NULL,
JOB_CLASS_NAME VARCHAR(250) NOT NULL,
IS_DURABLE VARCHAR(1) NOT NULL,
IS_NONCONCURRENT VARCHAR(1) NOT NULL,
IS_UPDATE_DATA VARCHAR(1) NOT NULL,
REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
JOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;CREATE TABLE QRTZ_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
JOB_NAME VARCHAR(190) NOT NULL,
JOB_GROUP VARCHAR(190) NOT NULL,
DESCRIPTION VARCHAR(250) NULL,
NEXT_FIRE_TIME BIGINT(13) NULL,
PREV_FIRE_TIME BIGINT(13) NULL,
PRIORITY INTEGER NULL,
TRIGGER_STATE VARCHAR(16) NOT NULL,
TRIGGER_TYPE VARCHAR(8) NOT NULL,
START_TIME BIGINT(13) NOT NULL,
END_TIME BIGINT(13) NULL,
CALENDAR_NAME VARCHAR(190) NULL,
MISFIRE_INSTR SMALLINT(2) NULL,
JOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;CREATE TABLE QRTZ_SIMPLE_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
REPEAT_COUNT BIGINT(7) NOT NULL,
REPEAT_INTERVAL BIGINT(12) NOT NULL,
TIMES_TRIGGERED BIGINT(10) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;CREATE TABLE QRTZ_CRON_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
CRON_EXPRESSION VARCHAR(120) NOT NULL,
TIME_ZONE_ID VARCHAR(80),
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;CREATE TABLE QRTZ_SIMPROP_TRIGGERS(SCHED_NAME VARCHAR(120) NOT NULL,TRIGGER_NAME VARCHAR(190) NOT NULL,TRIGGER_GROUP VARCHAR(190) NOT NULL,STR_PROP_1 VARCHAR(512) NULL,STR_PROP_2 VARCHAR(512) NULL,STR_PROP_3 VARCHAR(512) NULL,INT_PROP_1 INT NULL,INT_PROP_2 INT NULL,LONG_PROP_1 BIGINT NULL,LONG_PROP_2 BIGINT NULL,DEC_PROP_1 NUMERIC(13,4) NULL,DEC_PROP_2 NUMERIC(13,4) NULL,BOOL_PROP_1 VARCHAR(1) NULL,BOOL_PROP_2 VARCHAR(1) NULL,PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;CREATE TABLE QRTZ_BLOB_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
BLOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;CREATE TABLE QRTZ_CALENDARS (
SCHED_NAME VARCHAR(120) NOT NULL,
CALENDAR_NAME VARCHAR(190) NOT NULL,
CALENDAR BLOB NOT NULL,
PRIMARY KEY (SCHED_NAME,CALENDAR_NAME))
ENGINE=InnoDB;CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;CREATE TABLE QRTZ_FIRED_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
ENTRY_ID VARCHAR(95) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
INSTANCE_NAME VARCHAR(190) NOT NULL,
FIRED_TIME BIGINT(13) NOT NULL,
SCHED_TIME BIGINT(13) NOT NULL,
PRIORITY INTEGER NOT NULL,
STATE VARCHAR(16) NOT NULL,
JOB_NAME VARCHAR(190) NULL,
JOB_GROUP VARCHAR(190) NULL,
IS_NONCONCURRENT VARCHAR(1) NULL,
REQUESTS_RECOVERY VARCHAR(1) NULL,
PRIMARY KEY (SCHED_NAME,ENTRY_ID))
ENGINE=InnoDB;CREATE TABLE QRTZ_SCHEDULER_STATE (
SCHED_NAME VARCHAR(120) NOT NULL,
INSTANCE_NAME VARCHAR(190) NOT NULL,
LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
CHECKIN_INTERVAL BIGINT(13) NOT NULL,
PRIMARY KEY (SCHED_NAME,INSTANCE_NAME))
ENGINE=InnoDB;CREATE TABLE QRTZ_LOCKS (
SCHED_NAME VARCHAR(120) NOT NULL,
LOCK_NAME VARCHAR(40) NOT NULL,
PRIMARY KEY (SCHED_NAME,LOCK_NAME))
ENGINE=InnoDB;CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY ON QRTZ_JOB_DETAILS(SCHED_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_J_GRP ON QRTZ_JOB_DETAILS(SCHED_NAME,JOB_GROUP);CREATE INDEX IDX_QRTZ_T_J ON QRTZ_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_JG ON QRTZ_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_C ON QRTZ_TRIGGERS(SCHED_NAME,CALENDAR_NAME);
CREATE INDEX IDX_QRTZ_T_G ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_T_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_G_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME ON QRTZ_TRIGGERS(SCHED_NAME,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME);
CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_FT_J_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_JG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_T_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_FT_TG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);commit;

表的说明

表名称	说明
qrtz_blob_triggers	blog类型存储triggers
qrtz_calendars	以blog类型存储Calendar信息
qrtz_cron_triggers	存储cron trigger信息
qrtz_fired_triggers	存储已触发的trigger相关信息
qrtz_job_details	存储每一个已配置的job details
qrtz_locks	存储悲观锁的信息
qrtz_paused_trigger_grps	存储已暂停的trigger组信息
qrtz_scheduler_state	存储Scheduler状态信息
qrtz_simple_triggers	存储simple trigger信息
qrtz_simprop_triggers	存储其他几种trigger信息
qrtz_triggers	存储已配置的trigger信息

所有的表中都含有一个SCHED_NAME字段，对应我们配置的scheduler-name，相同 Scheduler-name的节点，形成一个 Quartz 集群。

2. 引入mysql相关依赖

<!-- MySQL连接 -->
<dependency><groupId>com.mysql</groupId><artifactId>mysql-connector-j</artifactId>
</dependency>
<!--mybatis-plus 这个版本需要指定了，因为场景启动器里面没有 -->
<dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-boot-starter</artifactId><version>3.5.7</version>
</dependency>

3. 添加yml配置及相关配置类

spring:datasource:quartz:driver-class-name: com.mysql.cj.jdbc.Driverurl: jdbc:mysql://localhost:3306/quartz?serverTimezone=GMT%2B8username: rootpassword: rootquartz:job-store-type: jdbc # 使用数据库存储scheduler-name: hyhScheduler # 相同 Scheduler 名字的节点，形成一个 Quartz 集群wait-for-jobs-to-complete-on-shutdown: true # 应用关闭时，是否等待定时任务执行完成。默认为 false ，建议设置为 truejdbc:initialize-schema: never # 是否自动使用 SQL 初始化 Quartz 表结构。这里设置成 never ，表示我们手动创建表结构。properties:org:quartz:# JobStore 相关配置jobStore:# 使用的数据源 (和配置类DataSourceConfiguration的 @Bean(name = "quartzDataSource") 存在直接关系)dataSource: quartzDataSource #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 # 线程池类型

新建DataSourceConfiguration 配置类

该类为数据源配置类
目前只是配置了quartz 数据源，暂不支持多数据源
如需多数据源配置，请往下看

package com.example.springbootfull.quartztest.config;import com.zaxxer.hikari.HikariDataSource;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.autoconfigure.quartz.QuartzDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.util.StringUtils;import javax.sql.DataSource;/*** 该类为数据源配置类* 目前只是配置了quartz 数据源，暂不支持多数据源* 如需多数据源配置，请自行补充*/
@Configuration
public class DataSourceConfiguration {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;}/*** 创建 quartz 数据源的配置对象*/@Primary@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);}}

启动查看

启动启动类后，发现数据库表里面有数据了

防止并发执行：上一周期还没执行完，下一周期又开始了

使用 @DisallowConcurrentExecution 注解：这可以确保同一时间只有一个该任务的实例在执行，从而避免并发执行带来的问题。
但是，这可能会导致任务执行的延迟，因为新实例必须等待前一个实例完成。

举例：

@Slf4j
@DisallowConcurrentExecution
public class SecondJob extends QuartzJobBean {@Overrideprotected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {JobDetail jobDetail = jobExecutionContext.getJobDetail();log.info("------任务名：" + jobDetail.getKey().getName() + ",组名：" +jobDetail.getKey().getGroup() + "------我是要执行的定时任务工作内容！");}
}

遇到的问题及解决

问题1：更改 Quartz 的 默认连接池配置

Quartz 2.0 以前 需要使用的 DBCP 作为数据库连接池
Quartz 2.0 以后 C3P0（包含2.0）需要使用 C3P0 作为数据库连接池

这个时候我们就需要更改这个连接池，改用 HikariCP 或者 Druid

方式一：关键属性 provider ：

#指定的数据源名称
spring.quartz.properties.org.quartz.jobStore.dataSource=quartz_jobs
#指定数据库连接池
spring.quartz.properties.org.quartz.dataSource.quartz_jobs.provider=hikaricp

方式二：初始化为 HikariDataSource 的数据源

 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;}

问题2：找不到名为 quartzDataSource 的数据源

当你的spring版本为spring 2.6.x 版本的 集成Quartz时，如果启动时报错如下

Failed to obtain DB connection from data source ‘quartzDataSource’: java.sql.SQLException: There is no DataSource named ‘quartzDataSource’

解决方法一：去掉配置的org.quartz.jobStore.class属性即可解决该问题。
解决方法二：把 org.quartz.impl.jdbcjobstore.JobStoreTX 改成 org.springframework.scheduling.quartz.LocalDataSourceJobStore

问题3：jdbcUrl is required with driverClassName

使用了HikariCP连接池时，spring.datasource.jdbc-url 才是有效属性

问题4：url is required with driverClassName

没有使用HikariCP连接池时，spring.datasource.url 才是有效属性

参考文章如下：
【1】SpringBoot整合任务调度框架Quartz及持久化配置
【2】玩转 Spring Boot 集成篇（定时任务框架Quartz）
【3】springboot升级2.6.x,Quartz2.3.2找不到数据源
【4】springboot升级到2.7.17后，quartz集群模式配置修改
【5】Quartz配置Springboot自带连接池Hikaricp
【6】定时任务Quartz总结