前言

用到過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，都可以有更多擴展，解決分佈式調度等等。

不過該篇實戰案例介紹也應該滿足大多數使用場景了。

那麼該篇就先到此。

Springboot 一起了解Quartz定時任務的動態調度使用，實戰詳解

前言

正文

接下來是使用環節：

1.隨着項目啓動就啓動的定時任務

2.動態調度定時任務

Springboot 一起了解Quartz定時任務的動態調度使用，實戰詳解

JAVA 將日期字符串月份不足10月進行補0操作

Mybatis 查詢出來的List 集合數量正確，但是具體數據爲null

【硬着頭皮】停手，時間格式轉換不一定要在外面轉換

SSM 使用AOP註解方式，沒有生效

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結