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

绝地灬酷狼 2023-02-21 11:41 100阅读 0赞

# 前言 #

用到过Quartz定时任务框架的，第一眼看到Quartz就肯定会想起，调度工厂JobFactory、触发器 Trigger、任务实例Job。

那么该篇，就会结合实战案例来一步一步让大家都了解，怎么玩弄这个Quartz框架，能实现 所谓的动态调度 。

内容：

1.随项目启动即运行的 定时任务

2.动态触发的定时任务 ，包括：

随时创建新的定时任务；

随时执行指定的某个定时任务；

随时暂停指定的某个定时任务；

随时重启指定的某个定时任务；

随时删除指定的某个定时任务；

随时查看指定的某个定时任务；

3.动态传参到任务实例

4.可结合数据库扩展

# **正文** #

惯例，在开始实战案例前，先看一眼最终的项目目录结构：

![20200630142913101.png][]

接下来开始编码，

首先是pom.xml里的核心依赖包：

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.quartz-scheduler</groupId>
                <artifactId>quartz</artifactId>
                <version>2.2.3</version>
            </dependency>
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
            </dependency>
    
            
            <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包自己提供的：

![20200630155706821.png][]

![20200630155715528.png][]

简单瞅一眼：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70][]

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

接着，咱们实现一个调度方法类，类似于我们使用别的框架的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秒一次：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 1][]

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 2][]

## 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任务执行结束******");
        }
    
    }

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

调用创建定时任务接口：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 3][]

{
    	
    	"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"}
    	
    	
    }

执行效果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 4][]

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 5][]

{
    	
    	"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"}
    	
    	
    }

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 6][]

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

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

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

![20200630165918736.png][]

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

{
    	
    	"jobId":"1111111JCccc1111",
    	"jobName":"testJobF",
    	"jobGroup":"testGroupF"
    	
    	
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 7][]

效果，可以看到第一个任务暂停成功后，剩下第二个任务在继续执行：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 8][]

那么还有

唤醒指定定时任务接口 /quartz/resume

删除指定定时任务接口 /quartz/delete

更新指定定时任务接口 /quartz/update

查看指定定时任务状态接口 /quartz/query

都是一样的调用方法接口，就不一一做截图展示了。

最后，还是建议调度任务的实例数据存入数据库，这样跟数据库挂钩起来运用就灵活更多了。不管是结合mysql，oracle或者说redis，都可以有更多扩展，解决分布式调度等等。

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

那么该篇就先到此。

[20200630142913101.png]: https://img-blog.csdnimg.cn/20200630142913101.png
[20200630155706821.png]: https://img-blog.csdnimg.cn/20200630155706821.png
[20200630155715528.png]: https://img-blog.csdnimg.cn/20200630155715528.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200630155822698.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200630163213798.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200630163426487.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200630165205455.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200630165145851.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200630165422536.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200630165507642.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[20200630165918736.png]: https://img-blog.csdnimg.cn/20200630165918736.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200630170107386.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/2020063017005862.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70