前言
用到过Quartz定时任务框架的,第一眼看到Quartz就肯定会想起,调度工厂JobFactory、触发器 Trigger、任务实例Job。
那么该篇,就会结合实战案例来一步一步让大家都了解,怎么玩弄这个Quartz框架,能实现 所谓的动态调度 。
内容:
1.随项目启动即运行的 定时任务
2.动态触发的定时任务 ,包括:
随时创建新的定时任务;
随时执行指定的某个定时任务;
随时暂停指定的某个定时任务;
随时重启指定的某个定时任务;
随时删除指定的某个定时任务;
随时查看指定的某个定时任务;
3.动态传参到任务实例
4.可结合数据库扩展
正文
惯例,在开始实战案例前,先看一眼最终的项目目录结构:
接下来开始编码,
首先是pom.xml里的核心依赖包:
<!-- web-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- quartz -->
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>2.2.3</version>
</dependency>
<!-- spring集成quartz -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
</dependency>
<!--fastjson-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.58</version>
</dependency>
接着现在编码一些关于配置相关的,
创建JobEntity.java(定时任务使用的动态参数 实体类):
import com.alibaba.fastjson.JSONObject;
import java.util.Date;
/**
* @Author : JCccc
* @CreateTime : 2020/3/21
* @Description : 定时任务用到的参数
**/
public class JobEntity {
private String jobId; //唯一id
private String className; //定时任务示例的 class路径
private String cronExpression; //cron表达式
private String jobName; //定时任务名称
private String jobGroup; //所属组
private String triggerName; //触发器名称
private String triggerGroup; //触发器组
private String description; //备注
private JSONObject data; //携带参数
/**
* 预留的数据库字段 如果任务信息选择手动自己存入数据库的话,会使用到
*/
private Boolean pauseStatus; //是否暂停
private Boolean deleteStatus; //是否有效
private Date createTime; //创建时间
private Date updateTime; //更新时间
@Override
public String toString() {
return "JobEntity{" +
"jobId='" + jobId + '\'' +
", className='" + className + '\'' +
", cronExpression='" + cronExpression + '\'' +
", jobName='" + jobName + '\'' +
", jobGroup='" + jobGroup + '\'' +
", triggerName='" + triggerName + '\'' +
", triggerGroup='" + triggerGroup + '\'' +
", description='" + description + '\'' +
", data=" + data +
", pauseStatus=" + pauseStatus +
", deleteStatus=" + deleteStatus +
", createTime=" + createTime +
", updateTime=" + updateTime +
'}';
}
public String getJobId() {
return jobId;
}
public void setJobId(String jobId) {
this.jobId = jobId;
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public String getCronExpression() {
return cronExpression;
}
public void setCronExpression(String cronExpression) {
this.cronExpression = cronExpression;
}
public String getJobName() {
return jobName;
}
public void setJobName(String jobName) {
this.jobName = jobName;
}
public String getJobGroup() {
return jobGroup;
}
public void setJobGroup(String jobGroup) {
this.jobGroup = jobGroup;
}
public String getTriggerName() {
return triggerName;
}
public void setTriggerName(String triggerName) {
this.triggerName = triggerName;
}
public String getTriggerGroup() {
return triggerGroup;
}
public void setTriggerGroup(String triggerGroup) {
this.triggerGroup = triggerGroup;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public JSONObject getData() {
return data;
}
public void setData(JSONObject data) {
this.data = data;
}
public Boolean getPauseStatus() {
return pauseStatus;
}
public void setPauseStatus(Boolean pauseStatus) {
this.pauseStatus = pauseStatus;
}
public Boolean getDeleteStatus() {
return deleteStatus;
}
public void setDeleteStatus(Boolean deleteStatus) {
this.deleteStatus = deleteStatus;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getUpdateTime() {
return updateTime;
}
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
}
创建JobFactory.java (job实例工厂):
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;
/**
* @Author : JCccc
* @CreateTime : 2020/3/21
* @Description : 创建job实例工厂,使用默认的也许会出现spring的@Autowired 无法注入问题
*
**/
@Component
public class JobFactory extends AdaptableJobFactory {
@Autowired
private AutowireCapableBeanFactory beanFactory;
@Override
protected Object createJobInstance(TriggerFiredBundle bundle)
throws Exception {
Object jobInstance = super.createJobInstance(bundle);
//Job实例注入到Job工厂
beanFactory.autowireBean(jobInstance);
return jobInstance;
}
}
创建QuartzConfig.java (一些属性配置项):
import org.quartz.Scheduler;
import org.quartz.ee.servlet.QuartzInitializerListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import java.io.IOException;
import java.util.Properties;
/**
* @Author : JCccc
* @CreateTime : 2020/3/21
* @Description : 调度工厂,线程池属性等等配置
**/
@Configuration
public class QuartzConfig {
@Autowired
private JobFactory jobFactory;
/**
* 调度类FactoryBean
* @return
* @throws IOException
*/
@Bean("schedulerFactory")
public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
//设置调度类quartz属性
schedulerFactoryBean.setQuartzProperties(quartzProperties());
//设置jobFactory
schedulerFactoryBean.setJobFactory(jobFactory);
return schedulerFactoryBean;
}
/**
* 解析quartz.properties文件,填充属性
* @return
* @throws IOException
*/
@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<ContextRefreshedEvent> {
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"
}
效果,可以看到第一个任务暂停成功后,剩下第二个任务在继续执行:
那么还有
唤醒指定定时任务接口 /quartz/resume
删除指定定时任务接口 /quartz/delete
更新指定定时任务接口 /quartz/update
查看指定定时任务状态接口 /quartz/query
都是一样的调用方法接口,就不一一做截图展示了。
最后,还是建议调度任务的实例数据存入数据库,这样跟数据库挂钩起来运用就灵活更多了。不管是结合mysql,oracle或者说redis,都可以有更多扩展,解决分布式调度等等。
不过该篇实战案例介绍也应该满足大多数使用场景了。
那么该篇就先到此。