Springboot Quartz定时任务的动态调度使用，实战详解(1)

*/

@Bean

public Properties quartzProperties() throws IOException{

PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();

//若不做额外配置,会有默认的配置文件加载 在jar org.quartz里面 有一份quartz.properties

//propertiesFactoryBean.setLocation(new ClassPathResource(“/quartz.properties”));

propertiesFactoryBean.afterPropertiesSet();

return propertiesFactoryBean.getObject();

}

/**

• quartz初始化监听器

• @return

*/

@Bean

public QuartzInitializerListener initializerListener(){

return new QuartzInitializerListener();

}

/**

• 根据调度类工厂bean获取调度

• @return

• @throws IOException

*/

@Bean(“scheduler”)

public Scheduler scheduler() throws IOException{

return schedulerFactoryBean().getScheduler();

}

}

ps：这里的配置项，特别是关于quartz的配置项，可以自己去写配置文件配置，但是该篇就使用默认的就够，默认的是jar包自己提供的：

简单瞅一眼：

相关参数什么作用，不懂的对着英文查询翻译即可，该篇不做展开。

接着，咱们实现一个调度方法类，类似于我们使用别的框架的Template一样。

新建QuartzService.java：

import com.alibaba.fastjson.JSONObject;

import com.bsapple.vshop.quartz.config.JobEntity;

/**

• @Author : JCccc

• @CreateTime : 2020/3/21

• @Description :

**/

public interface QuartzService {

/**

• 创建Job

• @param job

*/

Boolean addJob(JobEntity job);

/**

• 执行Job

• @param job

*/

Boolean runJob(JobEntity job);

/**

• 修改Job

• @param job

*/

Boolean updateJob(JobEntity job);

/**

• 暂定Job

• @param job

*/

Boolean pauseJob(JobEntity job);

/**

• 唤醒Job

• @param job

*/

Boolean resumeJob(JobEntity job);

/**

• 删除Job

• @param job

*/

Boolean deleteJob(JobEntity job);

/**

• 获取Job

• @param job

*/

JSONObject queryJob(JobEntity job);

}

对应的impl，QuartzServiceImpl.java：

import com.alibaba.fastjson.JSONObject;

import com.bsapple.vshop.quartz.config.JobEntity;

import org.quartz.*;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.stereotype.Service;

/**

• @Author : JCccc

• @CreateTime : 2020/3/21

• @Description :

**/

@Service

public class QuartzServiceImpl implements QuartzService {

private static Logger log = LoggerFactory.getLogger(QuartzServiceImpl.class);

@Autowired

@Qualifier(“scheduler”)

private Scheduler scheduler;

@Override

public Boolean addJob(JobEntity job) {

try {

JSONObject data = job.getData();

log.info(“当前任务携带的业务参数={}”, data.toJSONString());

JobDataMap jobDataMap = new JobDataMap();

jobDataMap.put(“myValue”, data);

String jobId = job.getJobId();

String jobName = job.getJobName();

String jobUnique = jobId + jobName;

JobDetail jobDetail = JobBuilder

.newJob((Class<? extends Job>) Class.forName(job.getClassName()))

// 指定执行类

.withIdentity(jobUnique, job.getJobGroup())

// 指定name和group

.requestRecovery().withDescription(job.getDescription())

.setJobData(jobDataMap)

.build();

// 创建表达式调度构建器

CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder

.cronSchedule(job.getCronExpression());

// 创建触发器

CronTrigger cronTrigger = TriggerBuilder.newTrigger()

.withIdentity(job.getTriggerName(), job.getTriggerGroup())

.withDescription(job.getDescription())

.withSchedule(cronScheduleBuilder).build();

scheduler.scheduleJob(jobDetail, cronTrigger);

scheduler.start();

log.info(“定时任务[{}]创建成功,开始执行”, jobId + jobName);

return true;

} catch (Exception e) {

e.printStackTrace();

}

return false;

}

@Override

public Boolean runJob(JobEntity job) {

try {

String jobId = job.getJobId();

String jobName = job.getJobName();

String jobUnique = jobId + jobName;

scheduler.triggerJob(JobKey.jobKey(jobUnique,

job.getJobGroup()));

log.info(“定时任务[{}]执行成功”, jobUnique);

return true;

} catch (Exception e) {

e.printStackTrace();

}

return false;

}

@Override

public Boolean updateJob(JobEntity job) {

try {

String jobId = job.getJobId();

String jobName = job.getJobName();

String jobUnique = jobId + jobName;

TriggerKey triggerKey = new TriggerKey(job.getTriggerName(),

job.getTriggerGroup());

CronTrigger cronTrigger = (CronTrigger) scheduler

.getTrigger(triggerKey);

CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder

.cronSchedule(job.getCronExpression());

// 重新构件表达式

CronTrigger trigger = cronTrigger.getTriggerBuilder()

.withIdentity(triggerKey).withSchedule(cronScheduleBuilder)

.withDescription(job.getDescription())

.build();

scheduler.rescheduleJob(triggerKey, trigger);

log.info(“定时任务[{}]更新成功”, jobUnique);

return true;

} catch (Exception e) {

e.printStackTrace();

}

return false;

}

@Override

public Boolean pauseJob(JobEntity job) {

try {

String jobId = job.getJobId();

String jobName = job.getJobName();

String jobUnique = jobId + jobName;

scheduler.pauseJob(JobKey.jobKey(jobUnique,

job.getJobGroup()));

log.info(“定时任务[{}]暂停成功”, jobUnique);

return true;

} catch (Exception e) {

e.printStackTrace();

}

return false;

}

@Override

public Boolean resumeJob(JobEntity job) {

try {

String jobId = job.getJobId();

String jobName = job.getJobName();

String jobUnique = jobId + jobName;

scheduler.resumeJob(JobKey.jobKey(jobUnique,

job.getJobGroup()));

log.info(“定时任务[{}]唤醒成功”, jobUnique);

return true;

} catch (Exception e) {

e.printStackTrace();

}

return false;

}

@Override

public Boolean deleteJob(JobEntity job) {

try {

String jobId = job.getJobId();

String jobName = job.getJobName();

String jobUnique = jobId + jobName;

scheduler.deleteJob(JobKey.jobKey(jobUnique, job.getJobGroup()));

log.info(“定时任务[{}]删除成功”, jobUnique);

return true;

} catch (Exception e) {

e.printStackTrace();

}

return false;

}

@Override

public JSONObject queryJob(JobEntity job) {

TriggerKey triggerKey = new TriggerKey(job.getTriggerName(),

job.getTriggerGroup());

try {

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

if (null == cronTrigger) {

return null;

}

JSONObject jsonObject = new JSONObject();

jsonObject.put(“expression”, cronTrigger.getCronExpression());

jsonObject.put(“state”, scheduler.getTriggerState(triggerKey));

jsonObject.put(“description”, cronTrigger.getDescription());

return jsonObject;

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

}

到这，其实动态的调度定时任务条件，我们都已经准备充分了。

接下来是使用环节：

---

1.随着项目启动就启动的定时任务

---

之所以能随着项目启动就跟着启动，那么显然，就跟监听项目启动有关系。

创建MyJobAuto.java ，继承job，做为定时任务示例：

/**

• @Author : JCccc

• @CreateTime : 2020/3/21

• @Description :

**/

import com.alibaba.fastjson.JSONObject;

import org.quartz.Job;

import org.quartz.JobDataMap;

import org.quartz.JobExecutionContext;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

@Component

public class MyJobAuto implements Job {

private static Logger log = LoggerFactory.getLogger(MyJobAuto.class);

private void before() {

log.info(“MyJobAuto任务开始执行”);

}

@Override

public void execute(JobExecutionContext context) {

before();

//定时任务处理的业务逻辑

//…

//…

String name = context.getJobDetail().getKey().getName();

log.info(“MyJobAuto任务[{}]正在执行”,name);

JobDataMap jobDataMap=context.getJobDetail().getJobDataMap();

JSONObject jsonObject = (JSONObject) jobDataMap.get(“myValue”);

log.info(“MyJobAuto任务[{}]携带的参数[{}]”,name,jsonObject.toString());

String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern(“yyyy-MM-dd HH:mm:ss”));

log.info(“当前时间[{}],MyJobAuto任务[{}]的线程名[{}]”,time,name,Thread.currentThread().getName());

after();

}

private void after() {

log.info(“MyJobAuto任务执行结束”);

}

}

然后是项目启动监听器，创建ApplicationStartListener.java：

import com.alibaba.fastjson.JSONObject;

import com.bsapple.vshop.quartz.config.JobEntity;

import com.bsapple.vshop.quartz.jobManage.QuartzService;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.ApplicationListener;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.event.ContextRefreshedEvent;

import java.util.UUID;

/**

• @Author : JCccc

• @CreateTime : 2020/3/21

• @Description :

**/

@Configuration

public class ApplicationStartListener implements ApplicationListener {

private static Logger log = LoggerFactory.getLogger(ApplicationStartListener.class);

@Autowired

private QuartzService quartzService;

@Override

public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {

JobEntity job=new JobEntity();

job.setJobId(UUID.randomUUID().toString().replaceAll(“-”,“”));

job.setClassName(“com.bsapple.vshop.quartz.taskJob.MyJobAuto”);//注意,这里的路径请改成你自己的

job.setCronExpression(“0/3 * * * * ?”);

job.setJobName(“AutoJob”);

job.setJobGroup(“AutoJobGroup”);

job.setTriggerName(“AutoJobTrigger”);

job.setTriggerGroup(“AutoJobTriggerGroup”);

job.setDescription(“AutoJob-随项目启动”);

//可以将任务跟数据库挂钩,做个任务管理模块,获取需要自启动的任务,记录各个参数等

JSONObject jsonObject=new JSONObject();

jsonObject.put(“testKey”,“测试即启动”);

job.setData(jsonObject);

quartzService.addJob(job);

log.info(“即触发定时任务已经开始执行… .”);

log.info(“application已经启动完毕”);

}

}

事不宜迟，先把项目启动起来看看效果，成功执行，根据cron表达式，3秒一次：

再看一眼线程名里面，可以看到quartz加载了默认配置，线程数量10：

2.动态调度定时任务

---

我们在前面已经把调度方法的模版已经写了，那么实现调度场景就非常简单了。

创建QuartzController.java：

import com.alibaba.fastjson.JSONObject;

import com.bsapple.vshop.quartz.config.JobEntity;

import com.bsapple.vshop.quartz.jobManage.QuartzService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.*;

/**

• @Author : JCccc

• @CreateTime : 2020/3/21

• @Description :

**/

@RestController

@RequestMapping(“/quartz”)

public class QuartzController {

@Autowired

private QuartzService quartzService;

@PostMapping(“/add”)

public String addJob(@RequestBody JobEntity job) {

Boolean result = quartzService.addJob(job);

if (!result) {

return “创建定时任务失败”;

}

return “创建定时任务成功:”+job.getJobId()+job.getJobName();

}

@PostMapping(“/run”)

public String runJob(@RequestBody JobEntity job) {

Boolean result = quartzService.runJob(job);

if (!result) {

return “启动定时任务失败”;

}

return “启动定时任务成功:”+job.getJobId()+job.getJobName();

}

@PostMapping(“/update”)

public String updateJob(@RequestBody JobEntity job) {

Boolean result = quartzService.updateJob(job);

if (!result) {

return “修改定时任务失败”;

}

return “修改定时任务成功:”+job.getJobId()+job.getJobName();

}

@PostMapping(“/pause”)

public String pauseJob(@RequestBody JobEntity job) {

Boolean result = quartzService.pauseJob(job);

if (!result) {

return “暂停定时任务失败”;

}

return “暂停定时任务成功:”+job.getJobId()+job.getJobName();

}

@PostMapping(“/resume”)

public String resumeJob(@RequestBody JobEntity job) {

Boolean result = quartzService.resumeJob(job);

if (!result) {

return “唤醒定时任务失败”;

}

return “唤醒定时任务成功:”+job.getJobId()+job.getJobName();

}

@PostMapping(“/delete”)

public String deleteJob(@RequestBody JobEntity job) {

Boolean result = quartzService.deleteJob(job);

if (!result) {

return “删除定时任务失败”;

}

return “删除定时任务成功:”+job.getJobId()+job.getJobName();

}

@GetMapping(“/query”)

public String queryJob(@RequestBody JobEntity job) {

JSONObject result = quartzService.queryJob(job);

if (null == result) {

return “不存在对应的任务:”+job.getJobId()+job.getJobName();

}

return result.toString();

}

}

简单写两个定时任务，模拟多定时任务调度处理不同业务：

MyJobFirst.java：

/**

• @Author : JCccc

• @CreateTime : 2020/3/21

• @Description :

**/

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import com.alibaba.fastjson.JSONObject;

import org.quartz.Job;

import org.quartz.JobDataMap;

import org.quartz.JobExecutionContext;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.stereotype.Component;

@Component

public class MyJobFirst implements Job {

private static Logger log = LoggerFactory.getLogger(MyJobFirst.class);

private void before() {

log.info(“MyJobFirst任务开始执行”);

}

@Override

public void execute(JobExecutionContext context) {

before();

//定时任务处理的业务逻辑

//…

//…

String name = context.getJobDetail().getKey().getName();

log.info(“MyJobFirst任务[{}]正在执行”,name);

JobDataMap jobDataMap=context.getJobDetail().getJobDataMap();

JSONObject jsonObject = (JSONObject) jobDataMap.get(“myValue”);

log.info(“MyJobFirst任务[{}]携带的参数[{}]”,name,jsonObject.toString());

String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern(“yyyy-MM-dd HH:mm:ss”));

log.info(“当前时间[{}],MyJobFirst任务[{}]的线程名[{}]”,time,name,Thread.currentThread().getName());

after();

}

private void after() {

log.info(“MyJobFirst任务执行结束”);

}

}

MyJobSecond.java：

/**

• @Author : JCccc

• @CreateTime : 2020/3/21

• @Description :

**/

import com.alibaba.fastjson.JSONObject;

import org.quartz.Job;

import org.quartz.JobDataMap;

import org.quartz.JobExecutionContext;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import java.util.Date;

@Component

public class MyJobSecond implements Job {

private static Logger log = LoggerFactory.getLogger(MyJobSecond.class);

private void before() {

log.info(“MyJobSecond任务开始执行”);

}

@Override

public void execute(JobExecutionContext context) {

before();

//定时任务处理的业务逻辑

//…

//…

String name = context.getJobDetail().getKey().getName();

log.info(“MyJobSecond任务[{}]正在执行”,name);

JobDataMap jobDataMap=context.getJobDetail().getJobDataMap();

JSONObject jsonObject = (JSONObject) jobDataMap.get(“myValue”);

log.info(“MyJobSecond任务[{}]携带的参数[{}]”,name,jsonObject.toString());

String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern(“yyyy-MM-dd HH:mm:ss”));

log.info(“当前时间[{}],MyJobSecond任务[{}]的线程名[{}]”,time,name,Thread.currentThread().getName());

after();

}

private void after() {

log.info(“MyJobSecond任务执行结束”);

}

}

把项目重启一下，为了给大家展示这个动态调度效果，我自己先把监听启动的定时任务先注释了。

调用创建定时任务接口：

{

“jobId”:“1111111JCccc1111”,

“className”:“com.bsapple.vshop.quartz.taskJob.MyJobFirst”,

“cronExpression”:“0/7 * * * * ?”,

“jobName”:“testJobF”,

“jobGroup”:“testGroupF”,

“triggerName”:“trF”,

“triggerGroup”:“trGroupF”,

“description”:“test JcAAAA”,

“data”:{“v1”:“A”,“v2”:“AAA”,“v3”:“AAAA”}

}

执行效果：

继续把任务二也创建一下启动起来：

{

“jobId”:“22222JCccc22222”,

“className”:“com.bsapple.vshop.quartz.taskJob.MyJobSecond”,

“cronExpression”:“0/5 * * * * ?”,

“jobName”:“testJobS”,

“jobGroup”:“testGroupS”,

“triggerName”:“trS”,

“triggerGroup”:“trGroupS”,

“description”:“test JcBBBBB”,

“data”:{“v1”:“B”,“v2”:“B”,“v3”:“B”}

}

效果，可以看到两个定时任务都在执行：

暂停指定任务，调用/quartz/pause接口 ：

ps：注意该篇是展示的通过接口去暂停，实际上很多业务场景是定时任务处理业务逻辑的代码端里面，根据某些值去判断去操作当前定时任务，选择停止还是删除，还是先停止到达某个值再唤醒等等，或者是符合某个条件去开启别的定时任务，这些都是根据业务场景可以自己扩展。

可以看到暂停方法里面需要使用到的相关参数是：

所以我们接口传参只需要：

{

“jobId”:“1111111JCccc1111”,

“jobName”:“testJobF”,

“jobGroup”:“testGroupF”

}

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
n/20200630165507642.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70)

暂停指定任务，调用/quartz/pause接口 ：

ps：注意该篇是展示的通过接口去暂停，实际上很多业务场景是定时任务处理业务逻辑的代码端里面，根据某些值去判断去操作当前定时任务，选择停止还是删除，还是先停止到达某个值再唤醒等等，或者是符合某个条件去开启别的定时任务，这些都是根据业务场景可以自己扩展。

可以看到暂停方法里面需要使用到的相关参数是：

所以我们接口传参只需要：

{

“jobId”:“1111111JCccc1111”,

“jobName”:“testJobF”,

“jobGroup”:“testGroupF”

}

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-lsYxUcuh-1715067232629)]

[外链图片转存中…(img-tolzUr8Y-1715067232629)]

[外链图片转存中…(img-P8n29ViR-1715067232630)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！