Java定时任务调度工具详解（4）— Quartz 之 Job/JobDetail/JobExecutionContext/JobDataMap

最新推荐文章于 2023-10-25 10:52:39 发布
最新推荐文章于 2023-10-25 10:52:39 发布
阅读量1.5k 收藏 3
点赞数
分类专栏： Quartz 文章标签： JobDetail JobExecutionContext JobDataMap Quartz
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liupeifeng3514/article/details/79462678
版权

三、浅谈Job&JobDetail

Job定义

实现业务逻辑的任务接口

浅谈Job

Job接口非常容易实现，只有一个execute方法，类似TimerTask的run方法，在里面编写业务逻辑。
Job接口源码
public interface Job {
    void execute(JobExecutionContext context) throws JobExecutionException;
}

Job实例在Quartz中的生命周期

每次调度器执行job时，它在调用execute方法前会创建一个新的job实例
当调用完成后，关联的job对象实例会被释放，释放的实例会被垃圾回收机制回收

浅谈JobDetail

JobDetail为Job实例提供了许多设置属性，以及JobDetailMap成员变量属性，
它用来存储特定Job实例的状态信息，调度器需要借助JobDetail对象来添加Job实例。

JobDetail属性

name：任务名称
group：任务所属组
jobClass：任务实现类
jobDataMap：传参的作用

四、浅谈JobExecutionContext&JobDataMap

JobExecutionContext是什么

当Scheduler调用一个Job，就会将JobExecutionContext传递给Job的execute()方法；
Job能通过JobExecutionContext对象访问到Quartz运行时候的环境以及Job本身的明细数据。

JobDataMap是什么

在进行任务调度时JobDataMap存储在JobExecutionContext中，非常方便获取。
JobDataMap可以用来装载任务可序列化的数据对象，当job实例对象被执行时这些参数对象会传递给它。
JobDataMap实现了JDK的Map接口，并且添加了一些非常方便的方法用来存取基本数据类型。

获取JobDataMap的两种方式

从Map中直接获取
Job实现类中添加setter方法对应JobDataMap的键值
（Quartz框架默认的JobFactory实现类在初始化job实例对象时会自动地调用这些setter方式）

代码演示

源码地址：https://gitee.com/liupeifeng3514/Timer-Quartz

HelloScheduler类改造

package helloquartz.two;

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

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

/**
 * 编写 任务调度类
 */
public class HelloScheduler {

    public static void main(String[] args) throws SchedulerException {

        // 创建一个 JobDetail 实例，将该实例与 HelloJob 实例绑定
        JobDetail jobDeatil = JobBuilder.newJob(HelloJob.class)
                .withIdentity("myjob", "jobgroup1")// 定义标识符
                .usingJobData("message", "hello myjob1")// 传入自定义参数
                .usingJobData("floatJobValue", 3.14F)// 传入自定义参数
                .build();

        System.out.println("--------jobDetail's name : " + jobDeatil.getKey().getName());
        System.out.println("--------jobDetail's group : " + jobDeatil.getKey().getGroup());
        System.out.println("--------jobDetail's jobClass : " + jobDeatil.getJobClass().getName());

        // 创建一个 Trigger 实例，定义该 job 立即执行，并且每隔两秒重复执行一次，直到永远
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger","trigroup1")// 定义标识符
                .usingJobData("message", "hello mytrigger1")// 传入自定义参数
                .usingJobData("doubleTriggerValue", 2.0D)// 传入自定义参数
                .startNow()// 定义立即执行
                .withSchedule(SimpleScheduleBuilder
                        .simpleSchedule()
                        .withIntervalInSeconds(2)
                        .repeatForever())// 定义执行频度
                .build();

        // 创建 Scheduler 实例
        SchedulerFactory sfact = new StdSchedulerFactory();
        Scheduler scheduler = sfact.getScheduler();

        // 绑定 JobDetail 和 trigger
        scheduler.scheduleJob(jobDeatil, trigger);

        // 执行任务
        scheduler.start();

        // 打印当前的执行时间，格式为2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("--------Current Time Is : " + sf.format(date) + "\n");
    }
}

HelloJob类改造

package helloquartz.two;

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

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobKey;
import org.quartz.TriggerKey;

/**
 * 编写 自定义任务
 */
public class HelloJob implements Job{

    // 方式二：getter和setter获取
    // 成员变量 与 传入参数的key一致
    private String message;
    private Float floatJobValue;
    private Double doubleTriggerValue;

    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
    public Float getFloatJobValue() {
        return floatJobValue;
    }
    public void setFloatJobValue(Float floatJobValue) {
        this.floatJobValue = floatJobValue;
    }
    public Double getDoubleTriggerValue() {
        return doubleTriggerValue;
    }
    public void setDoubleTriggerValue(Double doubleTriggerValue) {
        this.doubleTriggerValue = doubleTriggerValue;
    }
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 打印当前的执行时间，格式为2017-01-01 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("--------Current Exec Time Is : " + sf.format(date));

        // 编写具体的业务逻辑
        //System.out.println("Hello World!");

        JobKey key = context.getJobDetail().getKey();
        System.out.println("--------My name and group are : " + key.getName() + " : " + key.getGroup());

        TriggerKey trkey = context.getTrigger().getKey();
        System.out.println("--------My Trigger name and group are : " + trkey.getName() + " : " + trkey.getGroup());

        // 方式一：Map中直接  获取自定义参数
        JobDataMap jdataMap = context.getJobDetail().getJobDataMap();
        JobDataMap tdataMap = context.getTrigger().getJobDataMap();
        String jobMsg = jdataMap.getString("message");
        Float jobFloatValue = jdataMap.getFloat("floatJobValue");

        String triMsg = tdataMap.getString("message");
        Double triDoubleValue = tdataMap.getDouble("doubleTriggerValue");

        System.out.println("--------方式一：Map中直接  获取自定义参数---------");
        System.out.println("--------jobMsg is : " + jobMsg);
        System.out.println("--------jobFloatValue is : " + jobFloatValue);
        System.out.println("--------triMsg is : " + triMsg);
        System.out.println("--------triDoubleValue is : " + triDoubleValue);

        // 方式一：Map中直接获取 获取自定义参数
        JobDataMap jobDataMap = context.getMergedJobDataMap();
        jobMsg = jobDataMap.getString("message");
        jobFloatValue = jobDataMap.getFloat("floatJobValue");

        triMsg = jobDataMap.getString("message");
        triDoubleValue = jobDataMap.getDouble("doubleTriggerValue");

        System.out.println("--------方式一：Map中直接获取 获取自定义参数：context.getMergedJobDataMap()---------");
        System.out.println("--------jobMsg is : " + jobMsg);
        System.out.println("--------jobFloatValue is : " + jobFloatValue);
        System.out.println("--------triMsg is : " + triMsg);
        System.out.println("--------triDoubleValue is : " + triDoubleValue);

        // 方式二：getter和setter获取
        System.out.println("--------方式二：getter和setter获取---------");
        System.out.println("--------message is : " + this.message);
        System.out.println("--------jobFloatValue is : " + this.floatJobValue);
        System.out.println("--------triDoubleValue is : " + this.doubleTriggerValue + "\n");
    }
}

执行结果：

--------jobDetail's name : myjob
--------jobDetail's group : jobgroup1
--------jobDetail's jobClass : helloquartz.two.HelloJob
2018-03-06 19:36:37,692 [INFO ][main] Using default implementation for ThreadExecutor  (org.quartz.impl.StdSchedulerFactory:StdSchedulerFactory.java:1172) 
2018-03-06 19:36:37,696 [INFO ][main] Job execution threads will use class loader of thread: main  (org.quartz.simpl.SimpleThreadPool:SimpleThreadPool.java:268) 
2018-03-06 19:36:37,710 [INFO ][main] Initialized Scheduler Signaller of type: class org.quartz.core.SchedulerSignalerImpl  (org.quartz.core.SchedulerSignalerImpl:SchedulerSignalerImpl.java:61) 
2018-03-06 19:36:37,710 [INFO ][main] Quartz Scheduler v.2.2.3 created.  (org.quartz.core.QuartzScheduler:QuartzScheduler.java:240) 
2018-03-06 19:36:37,711 [INFO ][main] RAMJobStore initialized.  (org.quartz.simpl.RAMJobStore:RAMJobStore.java:155) 
--------Current Time Is : 2018-03-06 19:36:37

2018-03-06 19:36:37,712 [INFO ][main] Scheduler meta-data: Quartz Scheduler (v2.2.3) 'DefaultQuartzScheduler' with instanceId 'NON_CLUSTERED'
  Scheduler class: 'org.quartz.core.QuartzScheduler' - running locally.
  NOT STARTED.
  Currently in standby mode.
  Number of jobs executed: 0
  Using thread pool 'org.quartz.simpl.SimpleThreadPool' - with 10 threads.
  Using job-store 'org.quartz.simpl.RAMJobStore' - which does not support persistence. and is not clustered.
  (org.quartz.core.QuartzScheduler:QuartzScheduler.java:305) 
2018-03-06 19:36:37,712 [INFO ][main] Quartz scheduler 'DefaultQuartzScheduler' initialized from default resource file in Quartz package: 'quartz.properties'  (org.quartz.impl.StdSchedulerFactory:StdSchedulerFactory.java:1327) 
2018-03-06 19:36:37,712 [INFO ][main] Quartz scheduler version: 2.2.3  (org.quartz.impl.StdSchedulerFactory:StdSchedulerFactory.java:1331) 
2018-03-06 19:36:37,713 [INFO ][main] Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED started.  (org.quartz.core.QuartzScheduler:QuartzScheduler.java:575) 
--------Current Exec Time Is : 2018-03-06 19:36:37
--------My name and group are : myjob : jobgroup1
--------My Trigger name and group are : myTrigger : trigroup1
--------方式一：Map中直接  获取自定义参数---------
--------jobMsg is : hello myjob1
--------jobFloatValue is : 3.14
--------triMsg is : hello mytrigger1
--------triDoubleValue is : 2.0
--------方式一：Map中直接获取 获取自定义参数：context.getMergedJobDataMap()---------
--------jobMsg is : hello mytrigger1
--------jobFloatValue is : 3.14
--------triMsg is : hello mytrigger1
--------triDoubleValue is : 2.0
--------方式二：getter和setter获取---------
--------message is : hello mytrigger1
--------jobFloatValue is : 3.14
--------triDoubleValue is : 2.0

--------Current Exec Time Is : 2018-03-06 19:36:39
--------My name and group are : myjob : jobgroup1
--------My Trigger name and group are : myTrigger : trigroup1
--------方式一：Map中直接  获取自定义参数---------
--------jobMsg is : hello myjob1
--------jobFloatValue is : 3.14
--------triMsg is : hello mytrigger1
--------triDoubleValue is : 2.0
--------方式一：Map中直接获取 获取自定义参数：context.getMergedJobDataMap()---------
--------jobMsg is : hello mytrigger1
--------jobFloatValue is : 3.14
--------triMsg is : hello mytrigger1
--------triDoubleValue is : 2.0
--------方式二：getter和setter获取---------
--------message is : hello mytrigger1
--------jobFloatValue is : 3.14
--------triDoubleValue is : 2.0
挖坑埋你
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Quartz Job实现java任务调度
03-27
Quartz是功能强大的开源作业调度库，几乎可以集成到任何Java应用程序中-从最小的独立应用程序到最大的电子商务系统。Quartz可用于创建简单或复杂的计划，以执行数以万计，数以万计的工作；任务定义为标准Java组件的...
任务调度框架 Quartz 用法指南
ITERCHARLIE的博客
06-07 1036
任务调度框架 Quartz 用法指南（超详细）
quartz 中JobExecutionContext的使用
iteye_15985的博客
02-24 164
假如execute方法中需要一些额外的数据怎么办？比如说execute 中希望发送一封邮件，但是我需要知道邮件的发送者、接收者等信息? 存在两种解决方案： 1.JobDataMap类： 每个JobDetail都关联了一个JobDataMap实例，JobDataMap是java.util.Map的子类，基本上是提供key-value形式的数据，并提供了一些便利方法（...
浅谈Quartz的JobExecutionContext和JobDataMap
实践求真知
11-16 5153
一 点睛 1 JobExecutionContext是什么 当Scheduler调用一个Job，就会将JobExecutionContext传递给Job的execute()方法 Job能通过JobExecutionContext对象访问到Quartz运行时候的环境以及Job对象的明细数据。 2 JobDataMap是什么 在进行任务调度时JobDataMap存储在Job...
解决org.quartz.SchedulerException: Job threw an unhandled exception.
最新发布
念兮为美
10-25 2169
解决org.quartz.SchedulerException: Job threw an unhandled exception.
Quartz任务调度JobExecutionContext介绍
小徐的博客
01-16 5783
当Scheduler调用一个job,就会将JobExecutionContext传递给Job的execution()方法 Job能通过JobExecutionContext对象访问到Quartz运行时候的环境以及Job本身的明细数据 JobDataMap介绍 使用Map获取 在进行任务调度时,jobDataMap存储在JobExecutionContext中,非常方便获取, jobDataMap可...
Quartz 之 JobExecutionContext 解读
我是小坏
01-27 7768
查看源码注释可以得知： JobExecutionContext是一个包含了各种上下文信息的句柄，指向执行中的JobDetail 实例 和 执行完成的Trigger实例. JobExecutionContext中有一个简便的方法可以获取执行上下文中的JobDataMap , 它是JobDetail 中的JobDataMap 和 Trigger 中的JobDataMap 的合并，后者的Job...
Java 定时任务--Quartz框架
Dora的专栏
08-09 1574
Quartz是一个定时任务调度框架，可以将其理解为一个闹钟，可以设置在具体的某个时间，同样可以设置是否按某种规则循环。
Quartz定时任务框架(一)：概述和Job、JobDetail详解
qq_42682745的博客
04-27 4077
详解quartz定时任务框架，死磕
【Quartz】深入Job、JobDetail、JobDataMap、Trigger
热门推荐
Evankaka的专栏
04-29 2万+
Quartz API核心接口有： Scheduler – 与scheduler交互的主要API； Job – 你通过scheduler执行任务，你的任务类需要实现的接口； JobDetail – 定义Job的实例； Trigger – 触发Job的执行； JobBuilder – 定义和创建JobDetail实例的接口; TriggerBuilder – 定义和创建Trigger实例的接口；
Quartz实现JAVA定时任务的动态配置的方法
08-27
主要介绍了Quartz实现JAVA定时任务的动态配置的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
java定时任务框架elasticjob详解
08-25
主要介绍了java定时任务框架elasticjob详解，Elastic-Job是ddframe中dd-job的作业模块中分离出来的分布式弹性作业框架。该项目基于成熟的开源产品Quartz和Zookeeper及其客户端Curator进行二次开发。,需要的朋友可以...
quartz动态控制定时任务
10-19
Quartz是一个开源的任务调度框架，可以用来实现定时任务的调度，如定时发送邮件、定时备份数据等。Quartz具有很高的可靠性和灵活性，支持集群部署和分布式调度，并且提供了丰富的API和插件，可以轻松实现复杂的调度...
(动态多)定时任务源码自动运行调度后台执行
04-10
2、定时任务(xxl-job)（XXL-JOB是一个分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。） 3、SpringCloudSchedule定时任务（使用...
解决quartz 定时任务报错问题
JUNY_JAVA的博客
01-16 8982
定时任务运行提示： java.lang.ClassCastException: bdhj.modules.job.entity.ScheduleJobEntity cannot be cast to bdhj.modules.job.entity.ScheduleJobEntity at bdhj.modules.job.utils.ScheduleJob.executeInterna...
Quartz的重要接口API(二)
两个蝴蝶飞
04-28 1662
>勿以恶小而为之，勿以善小而不为--------------------------刘备 >劝诸君，多行善事积福报，莫作恶 主要内容: API的讲解
针对xxl-job执行定时任务时，本地异常报错，但是却没有打印异常信息
weixin_51430302的博客
01-16 3069
针对xxl-job执行定时任务时，本地异常报错，但是却没有打印异常信息
Quartz任务调度简介---03（浅谈JobExecutionContext)
菜鸟在进步
08-04 8902
定义JobExecutionContext: 当Schedule调用一个Job时，就会将JobExecutionContext传递给Job的exceute()方法。 Job能够通过JobExecutionContext对象访问到Quartz运行时候的环境以及Job本身的数据明细。 JobDataMap： 定义： 在进行任务调度时，JobDa...
springboot+vue+quartz 动态定时任务
05-22
好的，动态定时任务一般需要以下几个步骤： 1. 在后端使用 SpringBoot 和 Quartz，定义一个定时任务类，继承自 Quartz 的 Job 接口，并实现其中的 execute 方法。 2. 在定时任务类中，编写需要执行的任务逻辑。 3. 在定时任务类中，添加一些参数，用于动态设置定时任务的执行时间和执行频率。这些参数可以通过注解或者配置文件进行设置。 4. 在前端使用 Vue，创建一个页面，用于展示所有已经添加的定时任务，并且可以动态添加、修改和删除定时任务。 5. 在前端页面中，使用 axios 或者其他 AJAX 库，向后端发送添加、修改和删除定时任务的请求。 6. 后端接收到前端的请求后，根据请求的参数，动态创建、修改或删除 Quartz 定时任务。 具体实现可以参照以下步骤： 1. 在后端使用 SpringBoot 和 Quartz，定义一个定时任务类，如下所示： ``` @Component public class MyJob implements Job { @Override public void execute(JobExecutionContext context) throws JobExecutionException { // 编写需要执行的任务逻辑 } } ``` 2. 在定时任务类中，添加一些参数，用于动态设置定时任务的执行时间和执行频率，如下所示： ``` @Component public class MyJob implements Job { @Value("${job.trigger.cron}") private String cronExpression; @Override public void execute(JobExecutionContext context) throws JobExecutionException { // 编写需要执行的任务逻辑 } public void setCronExpression(String cronExpression) { this.cronExpression = cronExpression; } } ``` 在这里，我们使用了 @Value 注解来从配置文件中读取 cron 表达式，然后通过 setter 方法将其设置到定时任务类中。 3. 在前端使用 Vue，创建一个页面，用于展示所有已经添加的定时任务，并且可以动态添加、修改和删除定时任务。具体实现可以参考以下代码： ``` <template> <div> <h2>定时任务列表</h2> <table> <thead> <tr> <th>ID</th> <th>名称</th> <th>状态</th> <th>操作</th> </tr> </thead> <tbody> <tr v-for="job in jobs" :key="job.id"> <td>{{ job.id }}</td> <td>{{ job.name }}</td> <td>{{ job.status }}</td> <td> <button @click="editJob(job)">编辑</button> <button @click="deleteJob(job)">删除</button> </td> </tr> </tbody> </table> <button @click="addJob()">添加定时任务</button> <div v-if="showEditDialog"> <h3>{{ dialogTitle }}</h3> <form> <div> <label>名称：</label> <input type="text" v-model="job.name"> </div> <div> <label>状态：</label> <select v-model="job.status"> <option value="启用">启用</option> <option value="停用">停用</option> </select> </div> <div> <label>执行时间：</label> <input type="text" v-model="job.trigger.cron"> </div> <button @click="saveJob()">保存</button> <button @click="closeDialog()">关闭</button> </form> </div> </div> </template> <script> import axios from 'axios' export default { data() { return { jobs: [], job: { id: null, name: '', status: '启用', trigger: { cron: '' } }, showEditDialog: false, dialogTitle: '' } }, created() { this.getJobs() }, methods: { getJobs() { axios.get('/api/jobs') .then(response => { this.jobs = response.data }) .catch(error => { console.log(error) }) }, addJob() { this.job.id = null this.job.name = '' this.job.status = '启用' this.job.trigger.cron = '' this.dialogTitle = '添加定时任务' this.showEditDialog = true }, editJob(job) { this.job.id = job.id this.job.name = job.name this.job.status = job.status this.job.trigger.cron = job.trigger.cron this.dialogTitle = '编辑定时任务' this.showEditDialog = true }, saveJob() { if (this.job.id == null) { axios.post('/api/jobs', this.job) .then(response => { this.getJobs() this.showEditDialog = false }) .catch(error => { console.log(error) }) } else { axios.put('/api/jobs/' + this.job.id, this.job) .then(response => { this.getJobs() this.showEditDialog = false }) .catch(error => { console.log(error) }) } }, deleteJob(job) { axios.delete('/api/jobs/' + job.id) .then(response => { this.getJobs() }) .catch(error => { console.log(error) }) }, closeDialog() { this.showEditDialog = false } } } </script> ``` 在这里，我们使用了 axios 库来向后端发送 HTTP 请求，并且使用了 v-for 和 v-model 指令来实现页面数据的绑定和循环展示。 4. 在后端使用 SpringBoot 和 Quartz，创建一个 RESTful API，用于接收前端页面发送的添加、修改和删除定时任务的请求。具体实现可以参考以下代码： ``` @RestController @RequestMapping("/api/jobs") public class JobController { @Autowired private Scheduler scheduler; @GetMapping("") public List<JobDetail> getAllJobs() throws SchedulerException { List<JobDetail> jobs = new ArrayList<>(); for (String groupName : scheduler.getJobGroupNames()) { for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName))) { JobDetail jobDetail = scheduler.getJobDetail(jobKey); jobs.add(jobDetail); } } return jobs; } @PostMapping("") public void addJob(@RequestBody JobDetail jobDetail) throws SchedulerException { JobDataMap jobDataMap = jobDetail.getJobDataMap(); String jobName = jobDataMap.getString("jobName"); String jobGroup = jobDataMap.getString("jobGroup"); String jobClass = jobDataMap.getString("jobClass"); String cronExpression = jobDataMap.getString("cronExpression"); JobDetail newJob = JobBuilder.newJob() .withIdentity(jobName, jobGroup) .ofType((Class<? extends Job>) Class.forName(jobClass)) .build(); Trigger trigger = TriggerBuilder.newTrigger() .withIdentity(jobName + "Trigger", jobGroup) .withSchedule(CronScheduleBuilder.cronSchedule(cronExpression)) .build(); scheduler.scheduleJob(newJob, trigger); } @PutMapping("/{id}") public void updateJob(@PathVariable("id") String id, @RequestBody JobDetail jobDetail) throws SchedulerException { JobDataMap jobDataMap = jobDetail.getJobDataMap(); String jobName = jobDataMap.getString("jobName"); String jobGroup = jobDataMap.getString("jobGroup"); String jobClass = jobDataMap.getString("jobClass"); String cronExpression = jobDataMap.getString("cronExpression"); JobKey jobKey = new JobKey(jobName, jobGroup); JobDetail oldJob = scheduler.getJobDetail(jobKey); JobDetail newJob = JobBuilder.newJob() .withIdentity(jobName, jobGroup) .ofType((Class<? extends Job>) Class.forName(jobClass)) .build(); newJob.getJobDataMap().putAll(oldJob.getJobDataMap()); TriggerKey triggerKey = new TriggerKey(jobName + "Trigger", jobGroup); Trigger oldTrigger = scheduler.getTrigger(triggerKey); Trigger newTrigger = TriggerBuilder.newTrigger() .withIdentity(jobName + "Trigger", jobGroup) .withSchedule(CronScheduleBuilder.cronSchedule(cronExpression)) .build(); scheduler.scheduleJob(newJob, newTrigger); } @DeleteMapping("/{id}") public void deleteJob(@PathVariable("id") String id) throws SchedulerException { String[] ids = id.split(":"); String jobName = ids[0]; String jobGroup = ids[1]; JobKey jobKey = new JobKey(jobName, jobGroup); scheduler.deleteJob(jobKey); } } ``` 在这里，我们使用了 Quartz 的 Scheduler 接口来动态创建、修改和删除定时任务，并且使用了 @RequestBody、@PostMapping、@PutMapping 和 @DeleteMapping 注解来接收前端页面发送的请求。 5. 最后，在 SpringBoot 应用程序的配置文件中，添加 Quartz 的相关配置，如下所示： ``` quartz: job-store-type: memory properties: org: quartz: scheduler: instanceName: myScheduler instanceId: AUTO jobFactory: class: org.springframework.scheduling.quartz.SpringBeanJobFactory jobStore: class: org.quartz.simpl.RAMJobStore threadPool: class: org.quartz.simpl.SimpleThreadPool threadCount: 10 threadPriority: 5 threadsInheritContextClassLoaderOfInitializingThread: true ``` 在这里，我们设置了 Quartz 的存储类型为内存存储，以及一些基本的配置项，如线程池大小和线程优先级等。 以上就是动态定时任务的实现步骤，希望对你有所帮助！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值