springboot整合quartz

已于 2024-07-12 17:10:19 修改
阅读量75 收藏 2
点赞数 1
分类专栏： 工作 文章标签： spring boot java 后端
于 2024-07-12 15:26:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46085253/article/details/140378826
版权

一、使用步骤

1.引入依赖

代码如下（示例）：

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-quartz -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
    <version>2.3.12.RELEASE</version>
</dependency>

2.定义一个jobInfo类

用来封装定时任务参数

import lombok.Data;
import org.quartz.JobDataMap;
import org.springframework.util.ObjectUtils;

/**
 * @Description 定时任务参数类
 */
@Data
public class JobInfo {

    /*
    任务名
    */
    private String jobName;

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

    /*
    任务组
    */
    private String jobGroup;

    /*
    定时器名(创建任务时自动组织, 格式为 Trigger_用户名_任务名)
    */
    private String triggerName;

    /*
    定时器组
    */
    private String triggerGroup;

    /*
    需要定时执行的 job(如果需要自定义自己的特殊方法, 可以自己添加一个 *Job 实现 Job 接口即可)
    */
    private String jobClassName;

    /*
    参数(可为空, 有的定时任务逻辑中可能需要调用其他方法或者传递参数, 可以设置在此处)
    */
    private JobDataMap jobDataMap;
}

3.QuartzService

用来封装定时任务的新增、编辑、删除、立即触发一次等方法

import com.google.common.base.Preconditions;
import lombok.extern.slf4j.Slf4j;
import newdt.quartz.bean.JobInfo;
import newdt.quartz.util.QuartzUtil;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

import java.util.UUID;

/**
 * @Description 定时任务 service 包括定时任务的增删改方法等
 */
@Service
@Slf4j
public class QuartzService {

    @Autowired
    private Scheduler scheduler;

    private static final String DEFAULT_JOB_GROUP = "default_job_group";

    private static final String DEFAULT_TRIGGER_GROUP = "default_trigger_group";

    private static final String TRIGGER_PRE = "Trigger_";

    /**
     * 添加定时任务
     *
     * @param jobInfo  定时任务信息
     * @param userName 当前登录用户名
     * @return 是否添加成功 success 代表成功, 其他都是失败
     */
    public String createJob(JobInfo jobInfo, String userName) {
        /*
         逻辑:
         1. 参数校验
         2. 参数处理, 如果未指定任务组名和触发器组名就是用默认的
         3. 当前任务不存在才进行添加
         4. 构建 Job
         5. cron表达式定时构造器
         6. 构建 Trigger
         7. 启动调度器
         */

        // [1] 参数校验
        Preconditions.checkArgument(jobInfo.getJobName() != null, "定时任务名不能为空");
        Preconditions.checkArgument(jobInfo.getCron() != null, "cron 表达式不能为空");
        Preconditions.checkArgument(jobInfo.getJobClassName() != null, "需要定时执行的 job 不能为空");
        QuartzUtil.checkCronExpression(jobInfo.getCron());

        // [2] 参数处理, 如果未指定任务组名和触发器组名就是用默认的
        String jobGroup = ObjectUtils.isEmpty(jobInfo.getJobGroup()) ? DEFAULT_JOB_GROUP : jobInfo.getJobGroup();
        String triggerGroup = ObjectUtils.isEmpty(jobInfo.getTriggerGroup()) ? DEFAULT_TRIGGER_GROUP : jobInfo.getTriggerGroup();

        try {
            // [3] 当前任务不存在才进行添加
            JobKey jobKey = JobKey.jobKey(jobInfo.getJobName(), jobGroup);
            if (scheduler.checkExists(jobKey)) {
                log.warn("[添加定时任务]已存在该作业, jobkey为: {}", jobKey);
                throw new RuntimeException("[添加定时任务]已存在该作业, jobkey为: " + jobKey);
            }

            // [4] 构建 Job
            JobDetail job = JobBuilder.newJob(getClass(jobInfo.getJobClassName()).getClass()).withIdentity(jobKey)
                    .setJobData(ObjectUtils.isEmpty(jobInfo.getJobDataMap()) ? new JobDataMap() : jobInfo.getJobDataMap())
                    .build();

            // [5] cron表达式定时构造器
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(jobInfo.getCron());

            // [6] 构建 Trigger
            String triggerName = TRIGGER_PRE + userName + "_" + jobInfo.getJobName();
            Trigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity(TriggerKey.triggerKey(triggerName, triggerGroup))
//                .startAt(DateUtil.parseDate(start))
//                .endAt(DateUtil.parseDate(end))
                    .withSchedule(cronScheduleBuilder).build();

            // [7] 启动调度器
            scheduler.scheduleJob(job, trigger);
            scheduler.start();
            log.info("[添加定时任务]jobName: {}, jobGroup: {}, triggerName: {}, triggerGroup: {}, jobClassName: {}, 添加成功--------------",
                    jobInfo.getJobName(), jobInfo.getJobGroup(), triggerName, jobInfo.getTriggerGroup(), jobInfo.getJobClassName());

            return "success";
        } catch (Exception e) {
            log.error("[添加定时任务]失败, 报错: ", e);
            throw new RuntimeException("[添加定时任务]失败, 报错: " + e.getMessage());
        }

    }

    /**
     * 修改定时任务
     *
     * @param jobInfo  定时任务信息
     * @param userName 当前登录用户名
     * @return 是否更新成功 success 代表成功, 其他都是失败
     */
    public String editJob(JobInfo jobInfo, String userName) {
        /*
        逻辑:
        1. 参数校验
        2. 判断任务是否存在
        3. 更新任务
        */

        // [1] 参数校验
        Preconditions.checkArgument(jobInfo.getJobName() != null, "定时任务名不能为空");
        Preconditions.checkArgument(jobInfo.getJobGroup() != null, "定时任务组名不能为空");
        Preconditions.checkArgument(jobInfo.getCron() != null, "cron 表达式不能为空");
        Preconditions.checkArgument(jobInfo.getTriggerGroup() != null, "触发器组名不能为空");
        Preconditions.checkArgument(jobInfo.getJobClassName() != null, "需要定时执行的 job 不能为空");
        QuartzUtil.checkCronExpression(jobInfo.getCron());

        try {
            // [2] 判断任务是否存在
            JobKey jobKey = JobKey.jobKey(jobInfo.getJobName(), jobInfo.getJobGroup());
            if (!scheduler.checkExists(jobKey)) {
                log.error("[更新定时任务]该作业不存在, jobkey为: {}", jobKey);
                throw new RuntimeException("[更新定时任务]该作业不存在, jobkey为: " + jobKey);
            }

            // [3] 更新任务
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(jobInfo.getCron());
            String newTriggerName = TRIGGER_PRE + userName + "_" + jobInfo.getJobName();
            Trigger newTrigger = TriggerBuilder.newTrigger()
                    .withIdentity(TriggerKey.triggerKey(newTriggerName, jobInfo.getTriggerGroup()))
                    .withSchedule(cronScheduleBuilder).build();

            scheduler.rescheduleJob(TriggerKey.triggerKey(newTriggerName, jobInfo.getTriggerGroup()), newTrigger);

            log.info("[更新定时任务]jobName: {}, jobGroup: {}, triggerName: {}, triggerGroup: {}, jobClassName: {}, 更新成功--------------",
                    jobInfo.getJobName(), jobInfo.getJobGroup(), newTriggerName, jobInfo.getTriggerGroup(), jobInfo.getJobClassName());

            return "success";
        } catch (Exception e) {
            log.error("[更新定时任务]失败, 报错: ", e);
            throw new RuntimeException("[更新定时任务]失败, 报错: " + e.getMessage());
        }
    }

    /**
     * 删除定时定时任务
     *
     * @param jobInfo 定时任务信息
     * @return 是否删除成功 success 代表成功, 其他都是失败
     */
    public String deleteJob(JobInfo jobInfo) {
        /*
         逻辑:
         1. 参数校验
         2. 参数处理, 根据触发器名和触发器组名查询校验是否存在该触发器
         3. 暂停触发器
         4. 移除触发器
         5. 删除任务
         */

        // [1] 参数校验
        Preconditions.checkArgument(jobInfo.getJobName() != null, "定时任务名不能为空");
        Preconditions.checkArgument(jobInfo.getJobGroup() != null, "定时任务组名不能为空");
        Preconditions.checkArgument(jobInfo.getTriggerName() != null, "触发器名不能为空");
        Preconditions.checkArgument(jobInfo.getTriggerGroup() != null, "触发器组名不能为空");

        try {
            // [2] 参数处理, 根据触发器名和触发器组名查询校验是否存在该触发器
            TriggerKey triggerKey = TriggerKey.triggerKey(jobInfo.getTriggerName(), jobInfo.getTriggerGroup());
            Trigger trigger = scheduler.getTrigger(triggerKey);
            if (null == trigger) {
                log.info("[删除定时任务]根据 triggerName: {}和 triggerGroup: {}未查询到相应的 trigger", jobInfo.getTriggerName(), jobInfo.getTriggerGroup());
                throw new RuntimeException("[删除定时任务]根据 triggerName: " + jobInfo.getTriggerName() + "和 triggerGroup: " + jobInfo.getTriggerGroup() + "未查询到相应的 trigger");
            }

            // [3] 暂停触发器
            scheduler.pauseTrigger(triggerKey);

            // [4] 移除触发器
            scheduler.unscheduleJob(triggerKey);

            // [5] 删除任务
            JobKey jobKey = JobKey.jobKey(jobInfo.getJobName(), jobInfo.getJobGroup());
            scheduler.deleteJob(jobKey);

            log.info("[停止定时任务]jobName: {}, jobGroup: {}, triggerName: {}, triggerGroup: {}, 停止--------------",
                    jobInfo.getJobName(), jobInfo.getJobGroup(), jobInfo.getTriggerName(), jobInfo.getTriggerGroup());

            return "success";
        } catch (SchedulerException e) {
            log.error("[停止定时任务]失败, 报错: ", e);
            throw new RuntimeException("[停止定时任务]失败, 报错: " + e.getMessage());
        }
    }

    /**
     * 立即执行一次指定的定时任务
     *
     * @param jobInfo  定时任务信息
     * @return 是否执行成功 success 代表成功, 其他都是失败
     */
    public String executeImmediately(JobInfo jobInfo) {
        /*
         逻辑:
         1. 参数校验
         2. 如果本次执行的 job 需要使用 jobData, 则必须传 jobName 和 jobGroup, 组装 jobKey 查询该 job 原始的 jobData
         3. 组装临时的 job 和 trigger
         4. 启动调度器
         */

        // [1] 参数校验
        Preconditions.checkArgument(jobInfo.getJobClassName() != null, "需要定时执行的 job 不能为空");

        try {
            // [2] 如果本次执行的 job 需要使用 jobData, 则必须传 jobName 和 jobGroup, 组装 jobKey 查询该 job 原始的 jobData
            JobDataMap jobDataMap = new JobDataMap();
            if(StringUtils.hasText(jobInfo.getJobName()) && StringUtils.hasText(jobInfo.getJobGroup())){
                JobKey jobKey = JobKey.jobKey(jobInfo.getJobName(), jobInfo.getJobGroup());
                jobDataMap = scheduler.getJobDetail(jobKey).getJobDataMap();
            }

            // [3] 组装临时的 job 和 trigger
            JobDetail job = JobBuilder.newJob(getClass(jobInfo.getJobClassName()).getClass())
                    .setJobData(jobDataMap)
                    .withIdentity(JobKey.jobKey(UUID.randomUUID().toString(), DEFAULT_JOB_GROUP)).build();

            Trigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity(TriggerKey.triggerKey(UUID.randomUUID().toString(), DEFAULT_TRIGGER_GROUP))
                    .build();

            // [4] 启动调度器
            scheduler.scheduleJob(job, trigger);
            scheduler.start();

            log.info("[立即执行一次任务, 不定时]成功, jobName: {}, jobGroup: {}, triggerName: {}, triggerGroup: {},  jobClassName: {}, 执行成功--------------",
                    jobInfo.getJobName(), jobInfo.getJobGroup(), jobInfo.getTriggerName(), jobInfo.getTriggerGroup(), jobInfo.getJobClassName());

            return "success";
        } catch (Exception e) {
            log.error("[立即执行一次任务, 不定时]失败, 报错: ", e);
            throw new RuntimeException("[立即执行一次任务, 不定时]失败, 报错: " + e.getMessage());
        }
    }

    public static Job getClass(String className) throws Exception {
        Class<?> classTemp = Class.forName(className);
        return (Job) classTemp.newInstance();
    }

    /**
     * 暂停定时任务
     *
     * @param jobInfo 定时任务信息
     * @return 是否暂停成功 success 代表成功, 其他都是失败
     */
    public String pauseJob(JobInfo jobInfo) {
        /*
         逻辑:
         1. 参数校验
         2. 根据定时任务名和定时任务组名暂停该任务
         */

        // [1] 参数校验
        Preconditions.checkArgument(jobInfo.getJobName() != null, "定时任务名不能为空");
        Preconditions.checkArgument(jobInfo.getJobGroup() != null, "定时任务组名不能为空");

        try {
            // [2] 根据定时任务名和定时任务组名暂停该任务
            JobKey jobKey = JobKey.jobKey(jobInfo.getJobName(), jobInfo.getJobGroup());
            scheduler.pauseJob(jobKey);
            log.info("[暂停定时任务]成功, jobName: {}, jobGroup: {}", jobInfo.getJobName(), jobInfo.getJobGroup());

            return "success";
        } catch (SchedulerException e) {
            log.error("[暂停定时任务]失败, 报错: ", e);
            throw new RuntimeException("[暂停定时任务]失败, 报错: " + e.getMessage());
        }
    }

    /**
     * 恢复定时任务
     *
     * @param jobInfo 定时任务信息
     * @return 是否恢复成功 success 代表成功, 其他都是失败
     */
    public String resumeJob(JobInfo jobInfo) {
         /*
         逻辑:
         1. 参数校验
         2. 根据定时任务名和定时任务组名恢复该任务
         */

        // [1] 参数校验
        Preconditions.checkArgument(jobInfo.getJobName() != null, "定时任务名不能为空");
        Preconditions.checkArgument(jobInfo.getJobGroup() != null, "定时任务组名不能为空");

        try {
            // [2] 根据定时任务名和定时任务组名恢复该任务
            JobKey jobKey = JobKey.jobKey(jobInfo.getJobName(), jobInfo.getJobGroup());
            scheduler.resumeJob(jobKey);
            log.info("[恢复定时任务]成功, jobName: {}, jobGroup: {}", jobInfo.getJobName(), jobInfo.getJobGroup());

            return "success";
        } catch (SchedulerException e) {
            log.error("[恢复定时任务]失败, 报错: ", e);
            throw new RuntimeException("[恢复定时任务]失败, 报错: " + e.getMessage());
        }
    }
}

4.Job接口实现类

Job接口实现类里面写定时任务要执行的业务代码



import lombok.extern.slf4j.Slf4j;
import newdt.dsc.service.BaseService;
import newdt.review.bean.ReviewType;
import newdt.review.bean.review.DatabaseReviewTask;
import newdt.review.service.review.DatabaseReviewServiceImpl;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


/**
 * 定时任务 Job 实现类
 */
@Component
@Slf4j
public class DataBaseReviewTaskJob extends BaseService implements Job {
    @Autowired
    DatabaseReviewServiceImpl databaseReviewService;


    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // [1] 获取 jobId
        JobDataMap jobDataMap = context.getMergedJobDataMap();

        // [2] 封装一个 DatabaseReviewTask 对象
        long jobId = jobDataMap.getLong("jobId");
        DatabaseReviewTask databaseReviewTask = new DatabaseReviewTask();
        databaseReviewTask.setJobId(jobId);
        databaseReviewTask.setTriggerType(1);

        // [3] 创建任务
        databaseReviewService.submitReviewTask(databaseReviewTask, ReviewType.DATABASE);
    }
}

5.封装一个JobInfo对象，调用quartzService的方法即可

    public JobInfo getJobInfo(ReviewJob reviewJob) {
        // [1] 获取审核类型
        log.info("[开始] 构建 jobInfo 对象);
        ReviewType reviewType = reviewJob.getReviewType();

        // [2] 根据审核类型组建不同的 JobInfo
        JobInfo jobInfo = new JobInfo();
        jobInfo.setJobName(LOG_JOB_NAME_PRE + reviewJob.getJobId());
        jobInfo.setJobGroup(LOG_JOB_GROUP);
        jobInfo.setTriggerGroup(LOG_TRIGGER_GROUP);
        jobInfo.setJobClassName(LOG_JOB_CLASS_NAME);
        jobInfo.setTriggerName(TRIGGER_PRE + reviewJob.getCreator() + "_" + jobInfo.getJobName());
        jobInfo.setCron(reviewJob.getScheduleCron());
        jobInfo.setTriggerName(TRIGGER_PRE + reviewJob.getCreator() + "_" + jobInfo.getJobName());

        // [3] 返回 jobInfo
        log.info("[结束] 构建 jobInfo 对象成功, 对象信息 [{}]", jobInfo);
        return jobInfo;
    }
李小枫
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【微服务】springboot整合quartz使用详解
congge_study的博客
12-07 6036
springboot整合quartz详解
Springboot 整合Quartz
yang_fei9264的博客
07-04 6716
springboot整合quartz相关基本配置
SpringBoot整合Quartz
热门推荐
桐花思雨
11-02 4万+
目录`Quartz` 简介 Quartz 简介 Quartz 是一款功能强大的开源任务调度框架，几乎可以集成到任何 Java 应用程序中（小到单机应用，大到分布式应用）。Quartz 可用于创建简单或复杂的任务调度，用以执行数以万计的任务。任务被定义为标准化的 Java 组件，Java 编写的任务都可以被执行 Quartz 是一个任务日程管理系统，一个在预先确定（被纳入日程）的时间到达时，负责执行（或者通知）其他软件组件的系统 Quartz 用一个小 Java 库发布文件（.jar文件），这个库文件包含了所
Springboot整合quartz
swimming_in_IT_的博客
12-22 1041
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。官网地址:https://www.quartz-scheduler.org/
SpringBoot 整合 Quartz
杨巅峰的博客
06-10 2245
SpringBoot 整合 Quartz持久化到数据库
springboot 整合 quartz
weixin_55175040的博客
08-18 310
springboot 集成 quartz
SpringBoot整合Quartz实现动态定时任务
这河里吗l的博客
06-29 1405
Quartz是一个开源的任务调度服务，它可以独立使用，也可与其它的Java EE，Java SE应用整合使用。无论是执行十个，一百个工作的简单任务，还是执行成百上千个工作的复杂调度任务都可以使用Quartz来实现，此外，Quartz还提供了很多企业级应用的特色，如JTA事务支持及集群。如果你的应用中有任务需要在特定的时间执行，亦或周期循环执行，则Quartz也许是你理想的选择。
springboot整合quartz完整项目
11-02
SpringBoot整合Quartz是一个常见的企业级应用开发场景，主要用于实现定时任务管理。Quartz是一个开源的作业调度框架，而SpringBoot则是一个简化Spring应用初始搭建以及开发过程的框架。将两者结合，我们可以轻松地在...
SpringBoot 整合Quartz（集群）实现定时任务调度
02-14
SpringBoot整合Quartz实现定时任务调度是企业级应用中常见的需求，主要用于自动化执行某些周期性的任务，例如数据备份、报表生成、系统维护等。Quartz是一个功能强大的开源作业调度框架，能够灵活地定义任务和调度...
Springboot整合Quartz实现定时任务数据库动态配置
03-17
本篇文章将详细探讨如何在Spring Boot项目中整合Quartz，并通过MySQL数据库实现定时任务的动态配置。 首先，我们需要在项目中添加依赖。在Spring Boot的`pom.xml`文件中，引入Spring Boot的`spring-boot-starter-...
使用Spring Boot实现服务发现和注册
微赚淘客开发者博客
07-12 337
Eureka Server作为服务注册中心，所有客户端服务将自己的信息注册到Eureka Server上，并通过Eureka Server查找其他服务。通过Eureka Server管理服务实例，通过Eureka Client实现服务注册，并使用Feign客户端进行服务调用，可以有效地简化微服务的开发和维护工作。至此，我们已经通过Spring Boot和Eureka实现了服务发现和注册，并使用Feign进行服务调用。接下来，我们创建一个Eureka Client项目，注册到Eureka Server中。
SPring Boot整合第三方框架
最新发布
qq_59099003的博客
07-12 624
整合MyBatis，整合定时器，整合Swagger2，整合MyBatis-Plus
Spring Boot单体服务之间用feign调用
木槿
07-09 136
会定义路径和url等信息，用于指定服务调用服务调用启动feign配置调用url。
使用 Spring Boot + POI 实现动态 DOCX 模版导出
失忆老幺
07-12 180
在企业级应用开发中，根据业务逻辑动态生成Word文档（如报告、合同、通知等）的需求十分常见。Apache POI 是一个强大的 Java 库，能读写 Microsoft Office 格式的文件，包括 DOCX。结合 Spring Boot 的特性，可以轻松实现基于模板的动态文档生成。下面是如何使用 Spring Boot 和 Apache POI 创建一个简单的动态 DOCX 模版导出应用的指南。
科普文：spring boot中常用的接口、工具栏、注解整理
为无为，事无事，味无味。
07-08 1161
如果容器中存在ApplicationListener的Bean，当ApplicationContext调用publishEvent方法时，对应的Bean会被触发。
spring boot的学习--Springboot的Web开发(3)
你我约定有三的博客
07-06 1156
1.1 创建springboot应用,选中我们需要的模块1.2 springBoot已经默认将这些场景配置好了,只需要在配置文件中指定少量配置就可以运行起来1.3 自己编写业务代码顺便回顾下上一篇的自动装配这个场景SpringBoot帮我们配置了什么？能不能修改？能修改哪些配置？能不能扩展？2 springBoot对静态资源的映射规则2.1 Springboot对静态资源的映射规则//可以设置和静态资源有关的参数，缓存时间等@Overrideif (!return;if (!

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

李小枫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值