前言

用到过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，都可以有更多扩展，解决分布式调度等等。

不过该篇实战案例介绍也应该满足大多数使用场景了。

那么该篇就先到此。