天天看點
傳回

Springboot Quartz定時任務的動态排程使用，實戰詳解

前言

用到過Quartz定時任務架構的，第一眼看到Quartz就肯定會想起，排程工廠JobFactory、觸發器 Trigger、任務執行個體Job。

那麼該篇，就會結合實戰案例來一步一步讓大家都了解，怎麼玩弄這個Quartz架構，能實作 所謂的動态排程 。

内容：

1.随項目啟動即運作的 定時任務

2.動态觸發的定時任務 ，包括：

随時建立新的定時任務；

随時執行指定的某個定時任務；

随時暫停指定的某個定時任務；

随時重新開機指定的某個定時任務；

随時删除指定的某個定時任務；

随時檢視指定的某個定時任務；

3.動态傳參到任務執行個體

4.可結合資料庫擴充

正文

慣例，在開始實戰案例前，先看一眼最終的項目目錄結構：

Springboot Quartz定時任務的動态排程使用，實戰詳解

接下來開始編碼，

首先是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包自己提供的：

Springboot Quartz定時任務的動态排程使用，實戰詳解
Springboot Quartz定時任務的動态排程使用，實戰詳解

簡單瞅一眼：

Springboot Quartz定時任務的動态排程使用，實戰詳解

相關參數什麼作用，不懂的對着英文查詢翻譯即可，該篇不做展開。

接着，咱們實作一個排程方法類，類似于我們使用别的架構的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秒一次：

Springboot Quartz定時任務的動态排程使用，實戰詳解

再看一眼線程名裡面，可以看到quartz加載了預設配置，線程數量10：

Springboot Quartz定時任務的動态排程使用，實戰詳解

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任務執行結束******");
    }

}

把項目重新開機一下，為了給大家展示這個動态排程效果，我自己先把監聽啟動的定時任務先注釋了。

調用建立定時任務接口：

Springboot Quartz定時任務的動态排程使用，實戰詳解
{
  
  "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"}
  
  
}

執行效果： 

Springboot Quartz定時任務的動态排程使用，實戰詳解

繼續把任務二也建立一下啟動起來：

Springboot Quartz定時任務的動态排程使用，實戰詳解
{
  
  "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"}
  
  
}

效果，可以看到兩個定時任務都在執行：

Springboot Quartz定時任務的動态排程使用，實戰詳解

暫停指定任務，調用/quartz/pause接口 ：

ps：注意該篇是展示的通過接口去暫停，實際上很多業務場景是定時任務處理業務邏輯的代碼端裡面，根據某些值去判斷去操作目前定時任務，選擇停止還是删除，還是先停止到達某個值再喚醒等等，或者是符合某個條件去開啟别的定時任務，這些都是根據業務場景可以自己擴充。

可以看到暫停方法裡面需要使用到的相關參數是：

Springboot Quartz定時任務的動态排程使用，實戰詳解

是以我們接口傳參隻需要：

{
  
  "jobId":"1111111JCccc1111",
  "jobName":"testJobF",
  "jobGroup":"testGroupF"
  
  
}
Springboot Quartz定時任務的動态排程使用，實戰詳解

效果，可以看到第一個任務暫停成功後，剩下第二個任務在繼續執行： 

Springboot Quartz定時任務的動态排程使用，實戰詳解

那麼還有

喚醒指定定時任務接口 /quartz/resume

删除指定定時任務接口 /quartz/delete

更新指定定時任務接口 /quartz/update

檢視指定定時任務狀态接口 /quartz/query

都是一樣的調用方法接口，就不一一做截圖展示了。

最後，還是建議排程任務的執行個體資料存入資料庫，這樣跟資料庫挂鈎起來運用就靈活更多了。不管是結合mysql，oracle或者說redis，都可以有更多擴充，解決分布式排程等等。

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

那麼該篇就先到此。

springboot quartz 動态排程 Job spring
上一篇: JAVA程式運作順序怎麼看_java程式中的運作順序
下一篇: iperf3怎麼看結果_iperf3 的結果分析疑問

繼續閱讀