【Quartz】springBoot集成定时任务框架的简单使用_spring: quartz: #相关属性配置 properties: org: quartz: s-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_47645367/article/details/117327401

本文详细介绍了如何在SpringBoot中集成Quartz定时框架，包括依赖引入、配置项解析、定时任务的创建与配置，以及通过配置类和测试用例的方式来实现定时任务的执行。此外，还提及了Quartz数据库表的创建和多数据源配置。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

【前言】

这里简单展示下Quartz定时框架的使用示例，以下是持久化到数据库的配置，如果不想持久化，就引入依赖就行了，啥都不需要配置。
因为我这里引的是springBoot的，比较简单，约定大于配置！！！

【实现】

1.依赖

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

2.pom.xml（基本配置，省略其余配置）

spring:
  quartz:
    #相关属性配置
    properties:
      org:
        quartz:
          scheduler:
            instanceName: clusteredScheduler
            instanceId: AUTO
          jobStore:
            dataSource: querazDB
            class: org.quartz.impl.jdbcjobstore.JobStoreTX
            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
            tablePrefix: QRTZ_
            isClustered: true
            clusterCheckinInterval: 10000
            useProperties: false
          threadPool:
            class: org.quartz.simpl.SimpleThreadPool
            threadCount: 10
            threadPriority: 5
            threadsInheritContextClassLoaderOfInitializingThread: true
    #数据库方式
    job-store-type: jdbc
    #初始化表结构
    jdbc:
      initialize-schema: never

3.用配置类配置定时任务的方式

很简单，就是创建好任务，再创建定时器，把任务设置到定时器里，然后启动项目就可以了。
简单注释了下，应该都能看懂的！

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.QuartzJobBean;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

@Configuration
public class QuartzConfig {

    /**
     * 配置定时任务
     * @return
     */
    @Bean
    public JobDetail jobDetai00l() {
        // 创建定时任务
        QuartzJobBean quartzJob = new QuartzJobBean() {
            @Override
            protected void executeInternal(JobExecutionContext jobExecutionContext) {
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                System.out.println("第一个定时任务！----" + sdf.format(new Date()));
            }
        };
        // 给任务配置并返回
        return JobBuilder.newJob(quartzJob.getClass())
                // job描述
                .withDescription("这是第一个定时任务")
                // job名称和分组
                .withIdentity("job001", "job1")
                // 结束后是否依然保存在数据库
                .storeDurably(true)
                // 恢复操作，类似断点续传。
                .requestRecovery()
                .build();
    }

    /**
     * 配置定时器
     *  常用定时器：
     *      SimpleTrigger：用来触发只需执行一次或者在给定时间触发并且重复N次且每次执行延迟一定时间的任务。
     *      CronTrigger：按照日历触发，例如“每个周五”，每个月10日中午或者10：15分。
     * @return
     */
    @Bean
    public SimpleTrigger trigger0011() {
        // SimpleTrigger定时器
        SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule()
                // 一共执行4+1次
                .withRepeatCount(4)
                // 每2秒执行一次
                .withIntervalInSeconds(2);
        return TriggerBuilder.newTrigger()
                .withDescription("第一个定时器")
                .withIdentity("trigger0011", "trigger1")
                // 默认当前时间启动，可设置什么时间启动该定时器
                // .startAt(statTime)
                .forJob(jobDetai00l())
                .withSchedule(scheduleBuilder)
                .build();
    }

    @Bean
    public CronTrigger trigger0012() {
//        // CronTrigger定时器 两秒执行一次
//        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/2 * * * * ?");
//        return TriggerBuilder.newTrigger()
//                .withDescription("第二个定时器")
//                .withIdentity("trigger0012", "trigger1")
//                .forJob(jobDetai00l())
//                .withSchedule(cronScheduleBuilder)
//                // 优先级
//                //.withPriority(1)
//                .build();
        return null;
    }
}

结果：
在这里插入图片描述

4.测试（不用配置类的方式）

创建任务类：在这里插入图片描述
测试：

	@Test
    void contextLoads7() throws SchedulerException {
        try {
            // 1、创建一个任务实例，指定任务对象
            JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
                    .withIdentity("job1_1", "jGroup1")
                    .build();

            // 创建定时器/触发器
            SimpleScheduleBuilder builder = SimpleScheduleBuilder
                    // 设置执行次数
                    .repeatSecondlyForTotalCount(5);
            // CronScheduleBuilder builder = CronScheduleBuilder.cronSchedule("0/2 * * * * ?");
            Trigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity("trigger1_1", "tGroup1").startNow()
                    .withSchedule(builder)
                    .build();

            // 3、创建调度器
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
            scheduler.start();
            // 4、把任务/定时器传进去
            scheduler.scheduleJob(jobDetail, trigger);
            try {
                // 睡一会，要不然看不到测试结果。。
                Thread.sleep(60000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //关闭调度器
            scheduler.shutdown();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

结果：
在这里插入图片描述

【Quartz手动建表语句】

定时任务持久化到数据库是要建Quartz表的，有11张。
可以配置自动生成表，我没试。因为我表建好了。。。
在这里插入图片描述

create table qrtz_job_details(
	sched_name varchar(120) not null,
	job_name varchar(80) not null,
	job_group varchar(80) not null,
	description varchar(120),
	job_class_name varchar(128) not null,
	is_durable integer not null,
	is_nonconcurrent integer not null,
	is_update_data integer not null,
	requests_recovery integer not null,
	job_data blob(2000),
	primary key (sched_name,job_name,job_group)
);

create table qrtz_triggers(
	sched_name varchar(120) not null,
	trigger_name varchar(80) not null,
	trigger_group varchar(80) not null,
	job_name varchar(80) not null,
	job_group varchar(80) not null,
	description varchar(120),
	next_fire_time bigint,
	prev_fire_time bigint,
	priority integer,
	trigger_state varchar(16) not null,
	trigger_type varchar(8) not null,
	start_time bigint not null,
	end_time bigint,
	calendar_name varchar(80),
	misfire_instr smallint,
	job_data blob(2000),
	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)
);

create table qrtz_simple_triggers(
	sched_name varchar(120) not null,
	trigger_name varchar(80) not null,
	trigger_group varchar(80) not null,
	repeat_count bigint not null,
	repeat_interval bigint not null,
	times_triggered bigint 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)
);

create table qrtz_cron_triggers(
	sched_name varchar(120) not null,
	trigger_name varchar(80) not null,
	trigger_group varchar(80) 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)
);

CREATE TABLE qrtz_simprop_triggers(          
    sched_name varchar(120) not null,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) 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)
);

create table qrtz_blob_triggers(
	sched_name varchar(120) not null,
	trigger_name varchar(80) not null,
	trigger_group varchar(80) not null,
	blob_data blob(2000),
	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)
);

create table qrtz_calendars(
	sched_name varchar(120) not null,
	calendar_name varchar(80) not null,
	calendar blob(2000) not null,
	primary key (calendar_name)
);

create table qrtz_fired_triggers(
	sched_name varchar(120) not null,
	entry_id varchar(95) not null,
	trigger_name varchar(80) not null,
	trigger_group varchar(80) not null,
	instance_name varchar(80) not null,
	fired_time bigint not null,
	sched_time bigint not null,
	priority integer not null,
	state varchar(16) not null,
	job_name varchar(80),
	job_group varchar(80),
	is_nonconcurrent integer,
	requests_recovery integer,
	primary key (sched_name,entry_id)
);

create table qrtz_paused_trigger_grps(
	sched_name varchar(120) not null,
	trigger_group varchar(80) not null,
	primary key (sched_name,trigger_group)
);

create table qrtz_scheduler_state(
	sched_name varchar(120) not null,
	instance_name varchar(80) not null,
	last_checkin_time bigint not null,
	checkin_interval bigint not null,
	primary key (sched_name,instance_name)
);

create table qrtz_locks(
	sched_name varchar(120) not null,
	lock_name varchar(40) not null,
	primary key (sched_name,lock_name)
);

quartz中表及其表字段的意义

【配置多数据源】

如果想要把Quartz的表跟业务上的数据库区分可以参考下以下配置。
yml:

spring:
  datasource:
    # 业务数据源
    business:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/test1?serverTimezone=Asia/Shanghai
      username: root
      password: 123456
    # 任务调度数据源
    queraz:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/test1_quartz?serverTimezone=Asia/Shanghai
      username: root
      password: 123456

配置类：

import com.alibaba.druid.pool.DruidDataSource;
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 javax.sql.DataSource;

/**
 * 多数据源配置
 */
@Configuration
public class DataSourceConfig {
    
    private static final String DATASOURCE_NAME = "dbDataSource";

    private static final String BUSINESS_DATASOURCE_PREFIX = "spring.datasource.business";

    private static final String QUARTZ_DATASOURCE_PREFIX = "spring.datasource.queraz";

    @Primary
    @Bean(name = DATASOURCE_NAME)
    @ConfigurationProperties(prefix = BUSINESS_DATASOURCE_PREFIX)
    public DruidDataSource druidDataSource() {
        return new DruidDataSource();
    }

    /**
     * @QuartzDataSource 注解则是配置Quartz独立数据源的配置
     */
    @Bean
    @QuartzDataSource
    @ConfigurationProperties(prefix = QUARTZ_DATASOURCE_PREFIX)
    public DataSource quartzDataSource(){
        return new DruidDataSource();
    }
}