springboot整合quartz定时任务

最新推荐文章于 2026-05-03 20:11:30 发布
原创 最新推荐文章于 2026-05-03 20:11:30 发布 · 2.1k 阅读 · 5 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#spring boot #java #spring
该篇博客介绍了如何在SpringBoot项目中集成Quartz，通过配置文件设置自动启动、集群模式等，并提供了数据库建表语句。同时，展示了创建定时任务的代码，以及如何实现任务的增删改查操作。内容涵盖Quartz的配置、数据库表结构、定时任务编写和管理接口。

开发板推荐：天空星STM32F407VET6开发板

超高性价比 STM32主控 | 超高主频 | 一板兼容百芯 | 比赛神器 | 沉金彩色丝印

点击查看

quartz简介：查看Quartz简介
获取本文完整demo请访问：git地址
springboot整合quartz，实现：

1.引入maven依赖

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

2.配置文件加入以下配置(在mysql,mybatis-plus等配置好的情况下，若没配置好，请下载完整demo)：

#quartz
#自启动，false则不执行定时任务
spring.quartz.auto-startup=true
spring.quartz.job-store-type=jdbc
spring.quartz.properties.org.quartz.scheduler.instanceName=clusteredScheduler
spring.quartz.properties.org.quartz.scheduler.instanceId=AUTO
spring.quartz.properties.org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
#持久化到数据库
spring.quartz.properties.org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
# 打开集群配置
spring.quartz.properties.org.quartz.jobStore.isClustered=true
# 设置集群检查间隔100s
spring.quartz.properties.org.quartz.jobStore.clusterCheckinInterval=10000
spring.quartz.properties.org.quartz.jobStore.useProperties=false
spring.quartz.properties.org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
spring.quartz.properties.org.quartz.threadPool.threadCount=15
spring.quartz.properties.org.quartz.threadPool.threadPriority=5
spring.quartz.properties.org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread=true

3.数据库建表,语句如下

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(200) NOT NULL,  
JOB_GROUP VARCHAR(200) 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(200) NOT NULL,  
TRIGGER_GROUP VARCHAR(200) NOT NULL,  
JOB_NAME VARCHAR(200) NOT NULL,  
JOB_GROUP VARCHAR(200) 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(200) 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(200) NOT NULL,  
TRIGGER_GROUP VARCHAR(200) 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(200) NOT NULL,  
TRIGGER_GROUP VARCHAR(200) 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(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))  
ENGINE=InnoDB;  
  
CREATE TABLE QRTZ_BLOB_TRIGGERS (  
SCHED_NAME VARCHAR(120) NOT NULL,  
TRIGGER_NAME VARCHAR(200) NOT NULL,  
TRIGGER_GROUP VARCHAR(200) 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(200) 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(200) 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(200) NOT NULL,  
TRIGGER_GROUP VARCHAR(200) NOT NULL,  
INSTANCE_NAME VARCHAR(200) 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(200) NULL,  
JOB_GROUP VARCHAR(200) 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(200) 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);

4.编写定时任务：注意需要实现Job接口并实现execute方法即可，需要定时任务相关数据可从JobExecutionContext中取，编写一个简单的定时打印指定字符串：

public class PrintWordTask implements Job {


    @Override
    public void execute(JobExecutionContext jobExecutionContext) {
        JobDetail jobDetail = jobExecutionContext.getJobDetail();
        JobKey key = jobDetail.getKey();
        String name = key.getName();
        String group = key.getGroup();
        String jobKey = name + group;
        String printTime = new SimpleDateFormat("yy-MM-dd HH-mm-ss").format(new Date());
        System.out.println(jobKey+"PrintWordsJob start at:" + printTime + ", prints: Hello Job-" + new Random().nextInt(100));
    }
}

5.实现定时任务列表，新增，删除，修改，中断，恢复，立即执行等功能

public interface QrtzJobDetailsService extends IService<QrtzJobDetails> {
    List<QrtzTriggers> listQuartzEntity(QrtzJobDetails quartz, Integer pageNo, Integer pageSize) ;
    
    boolean save(QrtzJobDetails quartz) ;

    boolean deleteJob(QrtzJobDetails quartz);

    boolean pauseJob(QrtzJobDetails quartz);

    void resumeJob(QrtzJobDetails qrtzJobDetails);

    void updateJob(QrtzJobDetails qrtzJobDetails);

    void triggerJob(QrtzJobDetails qrtzJobDetails);

@Slf4j
@Service
public class QrtzJobDetailsServiceImpl extends ServiceImpl<QrtzJobDetailsMapper, QrtzJobDetails> implements QrtzJobDetailsService {

    @Autowired
    private Scheduler scheduler ;
    @Resource
    private QrtzJobDetailsMapper qrtzJobDetailsMapper;

    @Override
    public List<QrtzTriggers> listQuartzEntity(QrtzJobDetails quartz, Integer pageNo, Integer pageSize) {
        return qrtzJobDetailsMapper.listQuartzEntity(quartz);
    }

    /**
     * 保存定时任务
     * @param quartz
     * @return
     */
    @Override
    @Transactional
    public boolean save(QrtzJobDetails quartz) {
        Assert.notNull(quartz.getCronExpression(), "cron表达式不能为空");
        Assert.notNull(quartz.getJobClassName(),"定时任务代码位置不能为空");
        //jobName+jobGroup不能重复,可以理解为jobName+jobGroup作为任务的唯一标识
        String uuid = "testQuartz"+ UUID.randomUUID().toString();
            quartz.setJobName(uuid);
            quartz.setJobGroup(uuid);
        try {
            //如果是修改  展示旧的 任务
            if (quartz.getOldJobGroup() != null) {
                JobKey key = new JobKey(quartz.getOldJobName(), quartz.getOldJobGroup());
                scheduler.deleteJob(key);
            }
            HashMap<String, Integer> map = new HashMap<>();
            map.put("id", 123);
            //通过这个可往定时任务传参，用处不大
            JobDataMap jobDataMap = new JobDataMap(map);
            Class cls = Class.forName(quartz.getJobClassName());
            cls.newInstance();
            //构建job信息
            JobDetail job = JobBuilder.newJob(cls)
                    .withIdentity(quartz.getJobName(), quartz.getJobGroup())
                    .withDescription(quartz.getDescription())
                    .usingJobData(jobDataMap)
                    .build();
            // 触发时间点
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(quartz.getCronExpression());
            Trigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity("trigger" + quartz.getJobName(), quartz.getJobGroup())
                    .withDescription(quartz.getDescription())
                    .startNow().withSchedule(cronScheduleBuilder).build();
            //交由Scheduler安排触发
            scheduler.scheduleJob(job, trigger);
            scheduler.start();
        } catch (Exception e) {
            log.error("定时任务新增失败:", e);
        }
        return true;
    }

    /**
     * 删除定时任务
     * @param quartz
     * @return
     */
    @Override
    @Transactional
    public boolean deleteJob(QrtzJobDetails quartz) {
        Assert.notNull(quartz.getJobName(), "jobName不能为空");
        Assert.notNull(quartz.getJobGroup(),"jobGroup不能为空");
        boolean res = true;
        try {
            String jobName = quartz.getJobName();
            String jobGroup = quartz.getJobGroup();
            JobKey jobKey = new JobKey(jobName, jobGroup);
            res = scheduler.deleteJob(jobKey);
        } catch (Exception e) {
            log.error("删除定时任务失败:", e);
        }
        return res;
    }

    /**
     * 暂停定时任务
     * @param quartz
     * @return
     */
    @Override
    public boolean pauseJob(QrtzJobDetails quartz) {
        Assert.notNull(quartz.getJobName(), "jobName不能为空");
        Assert.notNull(quartz.getJobGroup(),"jobGroup不能为空");
        boolean res = true;
        try {
            JobKey jobKey = new JobKey(quartz.getJobName(), quartz.getJobGroup());
            scheduler.pauseJob(jobKey);
        } catch (Exception e) {
            log.error("终止定时任务异常:", e);
        }
        return res;
    }

    /**
     * 恢复定时任务
     * @param quartz
     */
    @Override
    public void resumeJob(QrtzJobDetails quartz) {
        Assert.notNull(quartz.getJobName(), "jobName不能为空");
        Assert.notNull(quartz.getJobGroup(),"jobGroup不能为空");
        try {
            JobKey jobKey = new JobKey(quartz.getJobName(), quartz.getJobGroup());
            scheduler.resumeJob(jobKey);
        } catch (Exception e) {
            log.error("恢复定时任务异常:", e);
        }
    }


    /**
     * 更新定时任务；这里只更新description，jobClassName，cronExpression三个字段
     * @param quartz
     */
    @Override
    @Transactional
    public void updateJob(QrtzJobDetails quartz) {
        Assert.notNull(quartz.getJobName(), "jobName不能为空");
        Assert.notNull(quartz.getJobGroup(),"jobGroup不能为空");
        try {
            String jobName = quartz.getJobName();
            String jobGroup = quartz.getJobGroup();
            Assert.notNull(jobName, "jobName不能为空");
            Assert.notNull(jobGroup, "jobGroup不能为空");
            Assert.notNull(quartz.getCronExpression(), "cron表达式不能为空");
            QrtzTriggers qrtzTriggers = qrtzJobDetailsMapper.getTriggerByJobKey( jobName, jobGroup);
            Assert.notNull(qrtzTriggers, "trigger不存在,定时任务异常");
            String triggerName = qrtzTriggers.getTriggerName();
            String triggerGroup = qrtzTriggers.getTriggerGroup();
            TriggerKey triggerKey = new TriggerKey(triggerName, triggerGroup);
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(quartz.getCronExpression());
            CronTrigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity(triggerGroup).withSchedule(cronScheduleBuilder).withDescription(quartz.getDescription()).build();
            scheduler.rescheduleJob(triggerKey, trigger);
            QrtzJobDetails newQrtzJobDetails = new QrtzJobDetails();
            newQrtzJobDetails.setId(quartz.getId());
            newQrtzJobDetails.setDescription(quartz.getDescription());
            newQrtzJobDetails.setJobClassName(quartz.getJobClassName());
            QueryWrapper<QrtzJobDetails> wrapper = new QueryWrapper<>();
            wrapper.lambda().eq(QrtzJobDetails::getId, quartz.getId());
            super.update(newQrtzJobDetails, wrapper);
        } catch (Exception e) {
            log.error("修改定时任务异常:", e);
        }

    }

    @Override
    public void triggerJob(QrtzJobDetails quartz) {
        Assert.notNull(quartz.getJobName(), "jobName不能为空");
        Assert.notNull(quartz.getJobGroup(),"jobGroup不能为空");
        try{
            JobKey jobKey = new JobKey(quartz.getJobName(), quartz.getJobGroup());
            scheduler.triggerJob(jobKey);
        }catch (Exception e){
            log.error("触发定时任务失败:",e);
        }
    }

}

新增（每5妙执行一次打印任务）：postMan截图
在这里插入图片描述
在这里插入图片描述

开发板推荐：天空星STM32F407VET6开发板

超高性价比 STM32主控 | 超高主频 | 一板兼容百芯 | 比赛神器 | 沉金彩色丝印

点击查看
java匠
关注
SpringBoot 整合 Quartz 实现分布式调度
十指波课堂的博客
12-23 1574
一、摘要阅读完本文大概需要 10 分钟，本文主要分享内容如下：springboot + quartz + mysql 实现持久化分布式调度集群环境任务调度测试二、Quartz 集群架构Quartz 是 Java 领域最著名的开源任务调度工具。在上篇文章中，我们详细的介绍了 Quartz 的单体应用实践，如果只在单体环境中应用，Quartz 未必是最好的选择，例如Spring Scheduled一样...
SpringBoot整合Quartz实现任务定时
北漂码农有话说
06-07 340
SpringBoot整合Quartz实现任务定时 前言:由于我们本项目选用的Springboot来整合Quartz，官方给我们提供了启动器所以很简单。在以前的版本我们想要使用Quartz需要引入的依赖如下: <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.
Spring boot整合quartz方法
最新发布
jessecyj的博客
05-03 397
然后，定时任务继承TaskJob，并实现其方法。
解决springboot + quartz的分布式问题以及dolphinscheduler
secret_breathe的博客
11-16 2017
springboot + quartz将quartz存储默认在内存中 改成基于数据库的quartz分布式集群解决方案, 参考官方文档,需要为quartz单独配置dataSource, 在@Bean的方法上加上@QuartzDataSource注解 @Configuration public class QuartzConfiguration { @Value("${spring.datasource.driver-class-name}") private String dri...
SpringBoot（二）集成 Quartz
SpringHASh的博客
10-21 3846
Quartz是一个广泛使用的开源任务调度框架，用于在Java应用程序中执行定时任务和周期性任务。它提供了强大的调度功能，允许您计划、管理和执行各种任务，从简单的任务到复杂的任务。
定时调度框架——Quartz
qq_35599414的博客
09-22 2281
基于最新的稳定版本2.3 一、快速使用 1、导依赖： <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.0</version> </dependency> 2、默认配置文件： org.quartz.core 包下，...
SpringBoot整合Quartz实现定时任务
热门推荐
pan_junbiao的博客
11-08 3万+
1、Quartz简介 Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。 1.1 Quartz的三大核心组件 调度器：Scheduler。 任务：JobDetail。 触发器：Trigger，包括 SimpleTrigger 和 CronTrigger。 （1）Jo
【SpringBoot整合系列】SpringBoot整合定时任务【Quartz】
低调做人，低调编码，神码都是浮云
04-01 2446
SpringBoot整合定时任务
Springboot 整合 Quartz（定时任务框架）
m0_54851477的博客
02-21 1056
Quartz是 OpenSymphony 开源组织在 Job scheduling 领域又一个开源项目，完全由 Java 开发，可以用来执行定时任务，类似于 java.util.Timer。持久性作业 - 就是保持调度定时的状态;作业管理 - 对调度作业进行有效的管理;
若依学习——定时任务代码逻辑 详细梳理（springboot整合Quartz）
hwp_ing的博客
03-04 1万+
现在我们知道我们执行了传入的这个方法，那么这个方法的在哪呢？所以我们如果想在若依里面实现自己的定时任务，直接在这个包下面写要处理的逻辑就行啦，但是有一点要注意的是若依设置了个白名单，因此这些自定义的定时任务逻辑要卸载con.ruoyi包下。这是若依的定时任务模块，上面主要是有关这任务表sys_job和日志表sys_job_log一些crud，然后调用了untils包的关于定时任务的方法。主要的定时任务操作都是通过下面until包下的类实现的。不过若依当中为了实现一些自己的想要的功能写了非常多的逻辑。
2021-2-7[ springboot 集成Quartz定时任务 ]
AoLuo的博客
02-07 1016
引包 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-quartz</artifactId> </dependency> 相关配置 # spring boot 已集成Quartz,无需自己配置 #是否应用启动时,自动启动定.
Quartz定时任务配置参数的含义
m0_37742400的博客
05-18 5354
例如，在一个分布式系统中，可以为每个节点的Quartz调度器设置不同的instanceName，以避免节点之间的任务冲突和重复执行。该属性可以设置为整数类型的值，用于指定Quartz调度器的任务触发器在misfire时的处理方式。例如，在一个分布式系统中，可以为每个节点的Quartz调度器设置不同的instanceId，以避免节点之间的任务冲突和重复执行。需要注意的是，auto-startup属性只控制Quartz调度器在启动时是否自动启动定时任务，不影响已经添加到调度器中的任务。
刨根问底-修改源码之 设置springboot下quartz启动开关
成锰的博客
03-19 2641
之前有篇博客说到应用集群(2)-避免定时任务重复执行策略，现在记录一下做法吧。 众所周知，springBoot是自动装载的，只要你导入依赖，它就会运行，这很好，但又带来了麻烦 因为我们应用服务和定时任务服务是同一个项目，只是出厂的时候要分开部署，他们公用一个application.pro 和 一个quartz.pro文件，所以需要一个开关控制 quartz的启动 目前，当启动我们项目的时候，会自动蹦出这些quartz启动信息。 [INFO ] [2021-03-19 11:57:28,646]..
Spring Boot集成Quartz定时任务详解
lovelichao12的专栏
07-14 4086
在实际项目开发中，我们想在规定时间执行一些任务，所以会经常用到定时任务。当然定时任务有很多种，本文我来介绍下我在项目中用到的quartz定时任务，项目架构采用的是微服务，主要写Spring Boot集成Quartz详解。一、开发环境   MySql、Mybatis、PageHelper、Spring Boot、Quartz二、pom.xml依赖&lt;dependency&gt; ...
spring quartz自动定时任务配置
iteye_8029的博客
04-17 187
先来看一个例子，（在结合自己的项目来看。） Spring中可以通过配置方便的实现周期性定时任务管理,这需要用到以下几个类： org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean--配置需要调度的Bean的某个方法org.springframework.scheduling.quartz.Si...
SpringBoot + Quartz 框架的实现及源码的深究
Demo_Liu的博客
06-17 1967
定时任务 想必做程序的都或多或少的接触过,以便于我们以某个特定的 时间/频率 去执行所需要的程序,Quartz 是一个优秀的框架,可以根据我们的配置将 定时任务的执行 时间/频率持久化至数据库, 我们通过修改数据库中的任务下次执行时间,达到不需要等到任务配置执行的原始时间/频率,随时地运行定时任务; 并且可以看到任务的运行状态 WATING BLOCKING等,下文会有介绍 1.导入依赖▼ quartz自定义配置的数据源会使用C3P0创建连接,所以要引入C3P0依赖 &lt...
定时器
weixin_43524361的博客
02-27 374
/** 定时器配置 */ @EnableScheduling @Configuration public class SchedulerConfig { public static final String TARGET_METHOD = "execute"; /** * 康明斯UDS定时表达式 */ @Value("${spring.quartz.auto-startup}") pri...
quartz spring配置
LD的笔记本
06-28 419
CronTriggerFactoryBean：基于时间刻度，可以设置具体时间。类似与日历的定时方式 SimpleTriggerFactoryBean：基于调度间隔时间 ，有延时启动功能 定时器有三个要素： 1. job：具体需要定时执行的方法，需要具体到某一个类下的某一个具体方法。 2. trigger：触发器，一个触发器需要一个job来对应 3. schedule：调度
spring quartz 开发环境不启动定时任务问题探究
qq_42809802的博客
06-19 3435
项目中使用了springboot加quartz进行定时任务的管理及配置，但开发环境是不需要启动定时任务的，可能会造成定时任务对数据处理的异常。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值