SpringBoot 集成 quartz 动态配置定时任务

最新推荐文章于 2025-04-18 16:25:25 发布
最新推荐文章于 2025-04-18 16:25:25 发布
阅读量310 收藏
点赞数
分类专栏： java quartz 文章标签： 触发器 quartz cron java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_34720491/article/details/115376991
版权

1.添加maven依赖

2.添加自定义的任务类，注意要实现job接口

package com.seagetech.seismic.manager.timer.job;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.seagetech.common.util.SeageUtils;
import com.seagetech.seismic.common.entity.BasedParameter;
import com.seagetech.seismic.common.entity.Device;
import com.seagetech.seismic.common.entity.Task;
import com.seagetech.seismic.common.service.IBasedParameterService;
import com.seagetech.seismic.common.service.ITaskService;
import com.seagetech.seismic.common.utils.Constant;
import com.seagetech.seismic.common.utils.DaqRestTemplate;
import com.seagetech.seismic.common.utils.DaqUtils;
import com.seagetech.seismic.service.monitoring.DeviceService;
import org.quartz.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 校时job
 *
 * @Author tt_wang
 * @Description //TODO
 * @Date 2020/10/23 14:58
 * @Version 1.0
 **/
@DisallowConcurrentExecution //不允许多线程运行
@Component
public class CheckTimeJob implements Job {

    private static final Logger LOGGER = LoggerFactory.getLogger(CheckTimeJob.class);

    @Autowired
    private ITaskService taskService;

    @Autowired
    private DaqRestTemplate restTemplate;

    @Autowired
    private IBasedParameterService basedParameterService;


    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        JobKey key = jobExecutionContext.getJobDetail().getKey();

        LOGGER.info("校时任务【{}】-【{}】执行开始了--：{}", key.getName(), new Date());
        //获取当前任务
        Task task = taskService.findById(Integer.valueOf(key.getName()));


        //获取校时服务器地址
        BasedParameter obj = (BasedParameter) basedParameterService.getObj(new LambdaQueryWrapper<BasedParameter>().eq(BasedParameter::getParamName, "SNTP服务器"));
        String command;
        if (SeageUtils.isEmpty(obj) || SeageUtils.isEmpty(obj.getParamValue())) {
            command = "04";
        } else {
            command = "04 " + obj.getParamValue();
        }
        MultiValueMap<String, Object> paramMap = new LinkedMultiValueMap<String, Object>();
        paramMap.add("command", command);
        String deviceId = "-1";
        if (!SeageUtils.isEmpty(task.getDeviceStr())) {
            deviceId = task.getDeviceStr();
        }

        Map<String, Object> urlPar = new HashMap<>(1);
        urlPar.put("deviceId", deviceId);
        restTemplate.postForObject(DaqUtils.CHECK_TIME, paramMap, String.class, urlPar);

        if (Objects.equals(task.getRepetition(), Constant.REPEAT_ONE)) {
            task.setTaskStatus(3);
            taskService.updateById(task);
        }

    }
}

 

3.实例化job,将job添加到任务管理器

  ps:我这里通过传入的task对象，高度灵活化

package com.seagetech.seismic.common.utils;

import com.seagetech.seismic.common.entity.Task;
import org.quartz.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


@Component
public class QuartzManager {

    private static final Logger LOGGER = LoggerFactory.getLogger(QuartzManager.class);

    @Autowired
    private Scheduler scheduler;

    /**
     * 添加并启动任务
     * @param task
     */
    @SuppressWarnings("unchecked")
    public void addJob(Task task) throws Exception {
        //创建jobDetail实例，绑定job实现类
        Class<? extends Job> jobClass = (Class<? extends Job>) (Class.forName(task.getBeanClass()).newInstance()
                .getClass());
        JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(String.valueOf(task.getTaskId())).usingJobData("taskId",task.getTaskId()).build();
        //定义调度触发规则
        Trigger trigger = TriggerBuilder.newTrigger().withIdentity(String.valueOf(task.getTaskId()))// 触发器key
                .startAt(DateBuilder.futureDate(1, DateBuilder.IntervalUnit.SECOND))
                .withSchedule(CronScheduleBuilder.cronSchedule(task.getCronExpression())).startNow().build();
        //把作业和触发器注册到任务调度中
        scheduler.scheduleJob(jobDetail,trigger);
        //启动
        if (!scheduler.isShutdown()){
            scheduler.start();
        }
        LOGGER.info("添加任务"+task.getTaskId()+"到任务调度器");
    }


    /**
     * 暂停一个job
     * @param task
     * @throws SchedulerException
     */
    public void pauseJob(Task task) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(String.valueOf(task.getTaskId()));
        scheduler.pauseJob(jobKey);
    }

    /**
     * 恢复一个job
     * @param task
     * @throws SchedulerException
     */
    public void resumeJob(Task task) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(String.valueOf(task.getTaskId()));
        scheduler.resumeJob(jobKey);
    }

    /**
     * 删除一个job
     * @param task
     * @throws SchedulerException
     */
    public void deleteJob(Task task) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(String.valueOf(task.getTaskId()));
        scheduler.deleteJob(jobKey);
    }

    /**
     * 立即触发job
     * @param task
     * @throws SchedulerException
     */
    public void runJobNow(Task task) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(String.valueOf(task.getTaskId()));
        scheduler.triggerJob(jobKey);
    }

    /**
     * 更新job表达式
     * @param task
     * @throws SchedulerException
     */
    public void updateJobCron(Task task) throws SchedulerException {

        TriggerKey triggerKey = TriggerKey.triggerKey(String.valueOf(task.getTaskId()));

        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(task.getCronExpression());

        trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

        scheduler.rescheduleJob(triggerKey, trigger);
    }
}

 

task对象如下：

package com.seagetech.seismic.common.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.seagetech.web.validated.annotation.DateTime;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import org.hibernate.validator.constraints.Length;

import javax.validation.constraints.NotNull;
import java.io.Serializable;
import java.util.List;

/**
 * @Author wangZhou
 * @Date 2020/4/24 11:58
 * @company 矽甲（上海）信息科技有限公司
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("tb_task")
public class Task implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 任务ID
     */
    @TableId(value = "task_id", type = IdType.AUTO)
    private Integer taskId;

    /**
     * 控制功能,表tb_device_fun
     */
    @NotNull(message = "validated.paremter_task_funNotNull")
    private Integer deviceFunId;

    /**
     * 重复 1：单次  2：重复
     */
    @NotNull(message = "validated.paremter_task_repetitionNotNull")
    private Integer repetition;

    /**
     * 周期描述，用于列表显示
     */
    private String periodDetail;

    /**
     * 任务状态  0：未开始  1：已启动  2：已停止  3：已过期
     */
    private Integer taskStatus;

    /**
     * 创建时间，格式yyyy-MM-dd HH:mm:ss
     */
    private String createTime;

    /**
     * 节点id列表
     */
    @TableField(exist = false)
    private List<Integer> deviceIds;

    /**
    * 指标主键id列表
    */
    @TableField(exist = false)
    private List<Integer> deviceTargetIds;

    /**
     * 任务执行时调用哪个类的方法 包名+类名
     */
    private String beanClass;

    /**
     * cron表达式
     */
    private String cronExpression;

    /**
     * 设备id Str
     */
    private String deviceStr;



    //执行周期为单次的
    public String runTime;

    @TableField(exist = false)
    private String startTime;


    @TableField(exist = false)
    private String endTime;
}

 

task对象里面有cron表达式，执行的job的类名以及task的id作为job的key，这个key是之后启动、停止、更新、继续job的认证标识

4.自定义jobFactory,方便我们在job类调用spring注入的service,所以要自定义一个jobfactory， 让其在具体job 类实例化时 使用Spring 的API 来进行依赖注入。

package com.seagetech.seismic.manager.timer.comfig;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.stereotype.Component;

@Component
public class JobFactory extends AdaptableJobFactory {

    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        //调用父类的方法
        Object jobInstance = super.createJobInstance(bundle);
        //进行注入
        capableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

 

5.自定义一个监听类，Quartz的job在项目重启时，job都失效了，把每次启动的job都存放在数据库，然后项目启动时监听器读取数据库的job，然后添加job。

package com.seagetech.seismic.manager.timer.comfig;

import com.seagetech.seismic.common.entity.Task;
import com.seagetech.seismic.common.service.ITaskService;
import com.seagetech.seismic.common.utils.QuartzManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Component
@Order(1)
public class ScheduleJobInitListener implements CommandLineRunner {

    @Autowired
    private ITaskService takService;

    @Override
    public void run(String... args) throws Exception {
        initSchedule();
    }


    @Autowired
    private QuartzManager quartzManager;

    @Transactional(readOnly = true,propagation = Propagation.NOT_SUPPORTED)
    public void initSchedule() throws Exception {
        //获取任务信息
        List<Task> all = takService.findAll(new Task().setTaskStatus(JobStatusEnum.RUNNING.getStatus()));
        /**
         * 正在运行的
         */
        for (Task sysTask : all) {
            quartzManager.addJob(sysTask);
        }
    }
}

 

6.启动项目，会自动把数据库的定时任务添加到job中，也可以在web页面添加定时任务，并对定时任务执行各种操作

附：cron工具类

package com.seagetech.seismic.common.utils;

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

/**
 * @author bxf
 * @ClassName: CronUtil
 * @date 2020-6-30 16:09:09
 */
public class CronUtil {

    /**
     * 方法摘要：构建Cron表达式
     *
     * @param type   类型 0：每天一次；1：每周一次；2：每月一次
     * @param param1 下拉列表，根据type进行变换， type=0时，param1=0；type=1时，param1从1-7选；type=2时，param1从1-28选
     * @param param2 小时 0-23
     * @param param3 分钟 0-59
     * @return
     */
    public static String createLoopCronExpression(int type, int param1, int param2, int param3) {
        String cron = "";
        switch (type) {
            case 0:// 每天的param2时，param3分执行
                cron = "0 " + param3 + " " + param2 + " * * ? ";
                break;
            case 1:// 每周的param1的param2时，param3分执行
                cron = "0 " + param3 + " " + param2 + " ? * " + param1 + " *";
                break;
            case 2:// 每月的param1号的param2时，param3分执行
                cron = "0 " + param3 + " " + param2 + " " + param1 + " * ? *";
                break;
        }
        return cron;
    }


    /**
     * 方法摘要：构建Cron表达式
     *
     * @param rate  频率 0秒；1分；2小时；3日；4月
     * @param cycle 周期
     * @return String
     */
    public static String createLoopCronExpression(int rate, int cycle) {
        String cron = "";
        switch (rate) {
            case 0:// 每cycle秒执行一次
                cron = "0/" + cycle + " * * * * ?";
                break;
            case 1:// 每cycle分钟执行一次
                cron = "0 0/" + cycle + " * * * ?";
                break;
            case 2:// 每cycle小时执行一次
                cron = "0 0 0/" + cycle + " * * ?";
                break;
            default:// 默认每cycle秒执行一次
                cron = "0/1 * * * * ?";
                break;
        }
        return cron;

    }



    /**
     * 方法摘要：构建Cron表达式
     *
     * @param rate  频率 0秒；1分；2小时；3日；4月
     * @param cycle 周期
     * @return String
     */
    public static String createLoopCronDescription(int rate, int cycle) {
        String desc = "";
        switch (rate) {
            case 0:
                desc = " 每"+cycle+"秒执行一次";
                break;
            case 1:
                desc = " 每"+cycle+"分钟执行一次";
                break;
            case 2:
                desc = " 每"+cycle+"小时执行一次";
                break;
        }
        return desc;

    }

    /**
     * 方法摘要：构建Cron描述
     *
     * @param type   类型 0：每天一次；1：每周一次；2：每月一次
     * @param param1 下拉列表，根据type进行变换， type=0时，param1=0；type=1时，param1从1-7选；type=2时，param1从1-28选
     * @param param2 小时 0-23
     * @param param3 分钟 0-59
     * @return
     */
    public static String createLoopCronDescription(int type, int param1, int param2, int param3) {
        String desc = "";
        switch (type) {
            case 0:// 每天的param2时，param3分执行
                desc = "每天" + param2 + "点" + param3 + "分触发一次任务";
                break;
            case 1:// 每周的param1的param2时，param3分执行
                desc = "每周" + param1 + "的" + param2 + "点" + param3 + "分触发一次任务";
                break;
            case 2:// 每月的param1号的param2时，param3分执行
                desc = "每月" + param1 + "号的" + param2 + "点" + param3 + "分触发一次任务";
                break;
        }
        return desc;
    }

    /**
     * 通过输入指定日期时间生成cron表达式
     *
     * @param date
     * @return cron表达式
     */
    public static String getCron(Date date) {
        String dateFormat = "ss mm HH dd MM ? *";
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        String formatTimeStr = null;
        if (date != null) {
            formatTimeStr = sdf.format(date);
        }

        return formatTimeStr;
    }

    // 参考例子
    public static void main(String[] args) {

//        System.out.println(CronUtil.createLoopCronExpression(0, 0, 10, 50));
//        System.out.println(CronUtil.createLoopCronDescription(0, 0, 10, 50));
//
//        System.out.println(CronUtil.createLoopCronExpression(1, 2, 12, 40));
//        System.out.println(CronUtil.createLoopCronDescription(1, 2, 12, 40));
//
//        System.out.println(CronUtil.createLoopCronExpression(2, 30, 07, 30));
//        System.out.println(CronUtil.createLoopCronDescription(2, 30, 07, 30));
//
//        System.out.println(getCron(new Date()));

        System.out.println(createLoopCronExpression(1,3));

    }
}

 

 

参考文献:

https://blog.youkuaiyun.com/l18848956739/article/details/86597709,在此基础上进行改造实现。。。

【SpringBoot】82、SpringBoot集成Quartz实现动态管理定时任务
Asurplus
06-29 3万+
Quartz 是一个开源的作业调度框架，它完全由 Java 写成，并设计用于 J2SE 和 J2EE 应用中。它提供了巨大的灵 活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。它有很多特征，如：数据库支持，集群，插件，EJB 作业预构 建，JavaMail 及其它，支持 cron-like 表达式等等
SpringBoot集成quartz实现动态定时任务
xxgaojiashuo的博客
09-11 1533
SpringBoot集成quartz实现动态定时任务 （1）Quartz简介 Quartz三大组件： 一、调度器scheduler 二、任务job 三、触发器tigger 1、job：job是一个接口，通过实现job接口，可实现需要定时执行的代码逻辑。 2、JobDetail：JobDetail主要是用来描述job的相关信息，比如任务在scheduler中的组名等信息，job的子类。 2、tigger：可以通过cron表达式设置定时任务的触发时间。 3、scheduler：JobDetail和tigger需
springboot+quartz 动态化配置定时任务
07-25
springboot+quartz 动态化配置，可在页面操作，查看、添加、修改、删除，暂停等操作
springboot+quartz 动态定时器
BuildH的博客
01-14 1191
springboot框架+quartz动态定时器 单表 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录springboot框架+quartz动态定时器 单表前言一、建立定时任务表 和导入依赖表导入依赖二、代码quartz 配置ApplicationRunnerImpl 启动容器执行的类任务类定时任务工具类通过name获取bean 的工具类control
自定义定时任务功能详解
最新发布
无敌码农的博客
04-18 461
在商城系统开发中，我们经常需要自定义定时任务模块，今天主要给大家分享下基于ThinkPHP6框架深度优化，通过可视化配置界面实现零代码任务管理。该功能支持秒级到年度的多维度执行周期设定，并允许开发者直接注入业务逻辑代码，实现如自动发券、数据同步等高频操作。步骤1：基础配置点击添加定时任务→ 填写表单字段：•任务名称：赠送优惠券（需语义化命名）•执行周期：支持秒/分/时/天/周/月/年七种粒度示例：选择"每10秒执行" → 系统自动显示周期说明文字•开发密码：需在。
Springboot2-Quartz 后台可动态配置的定时任务
02-28
SpringBoot2 与 Quartz 整合的Demo。 后台可添加、修改、移除 定时任务。 也可查看当前任务的状态 灵活的定时任务
springboot quartz 动态配置_springboot集成quartz实现动态任务调度
weixin_39517868的博客
01-25 200
quartz是一个开源的作业调度框架，本文就是介绍下springboot框架下继承quartz的一些使用示例首先我们需要添加quartz的spring-boot-starter-quartz依赖org.springframework.bootspring-boot-starter-quartz我们需要做一些配置。quartz提供了基于内存(MEMORY)和基于jdbc的两种任务存储方式。具体的配置...
springboot jpa quartz动态定时任务
12-18
springboot jpa quartz 动态定时任务,任务增加，任务删除，任务修改demo,非常简单
SpringBoot整合Quartz实现动态定时任务
这河里吗l的博客
06-29 3712
Quartz是一个开源的任务调度服务，它可以独立使用，也可与其它的Java EE，Java SE应用整合使用。无论是执行十个，一百个工作的简单任务，还是执行成百上千个工作的复杂调度任务都可以使用Quartz来实现，此外，Quartz还提供了很多企业级应用的特色，如JTA事务支持及集群。如果你的应用中有任务需要在特定的时间执行，亦或周期循环执行，则Quartz也许是你理想的选择。
springboot整合quartz实现动态定时任务
baidu_41803888的博客
06-03 523
1、添加jar <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-quartz --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-quartz&l
Quartz+Spring Boot实现动态管理定时任务
08-26
最近做项目遇到动态管理定时任务的需求，刚拿到这个需求还真不知道从哪下手，经过一番思考，终于找出实现思路，接下来通过本文给大家介绍了Quartz+Spring Boot实现动态管理定时任务的相关知识,需要的朋友可以参考下
Springboot整个Quartz实现动态定时任务的示例代码
08-26
主要介绍了Springboot整个Quartz实现动态定时任务的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringBoot整合Quartz任务定时调度
06-08
SpringBoot整合Quartz任务定时调度，可以参考我的博客进行学习https://blog.youkuaiyun.com/sujin_/article/details/80615823
Spring Boot + Quartz实现任务动态配置
Bbb的博客
09-16 297
背景 最近帮别人开发一个数据定时导入的小项目时，需求中明确提出导入数据的时间为可配置式。所以写下这篇文章记录一下。 准备工作 准备mysql数据库，主要存储需要动态配置的cron表达式 执行SQL，需要先创建数据库：springbootdb DROP TABLE IF EXISTS `job_cron`; CREATE TABLE `job_cron` ( `id` int(10) ...
springboot 自定义配置Quartz动态定时器
万木林
09-30 3565
在整个项目规划中，有的时候需要定时的去执行某一段代码，触发时间能随时修改，并且不影响项目的整体运行。所以，定时器的设计就必须要灵活，能随时的增，删，改定时任务。 1. 数据库设计 CREATE TABLE `sys_task` ( `id` int(11) NOT NULL AUTO_INCREMENT, `created_at` datetime NOT NULL COMMENT ...
SpringBoot下用Quartz实现动态配置定时任务
wnjnfn的博客
09-11 398
相关概念就不介绍了，直接上代码。 pom.xml配置 <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.0</version> </dependency>
SpringBoot整合quartz动态配置定时任务
眠的博客
06-02 580
前言 在实际的开发工作中，大多定时任务不是写死的，一般都会配置动态参数并实例化存储到数据库中，从而实现定时任务的动态配置，下面通过一个简单的开发子模块实例来进行演示 代码实现 1.新建SpringBoot项目，引入quartz相关依赖 <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.2
SpringBoot 整合 Quartz 实现 JAVA 定时任务的动态配置
xmt1139057136的专栏
07-12 642
你知道的越多，不知道的就越多，业余的像一棵小草！你来，我们一起精进！你不来，我和你的竞争对手一起精进！编辑：业余草来源：cnblogs.com/laoyeye/p/9352002.htm...
SpringBoot2.0.1实现Quartz动态定时任务管理
整合SpringBoot和Quartz，可以让我们使用SpringBoot的简便特性来配置和运行Quartz定时任务。在此过程中，动态管理定时任务意味着我们可以在不重启应用程序的情况下，添加、暂停、删除定时任务。 下面，我们来详细...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值