SpringBoot 整合 Quartz + MySQL

package com.vipsoft.web.entity;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size;
import java.io.Serializable;

/**
 * 定時任務排程
 */
public class QuartzJob implements Serializable {

    private static final long serialVersionUID = -6798153039624729495L;

    /**
     * 任務序號
     */
    private int jobId;

    /**
     * 任務名稱
     */
    @NotBlank(message = "任務名稱不能為空")
    @Size(max = 10, message = "任務名稱不能超過10個字元")
    private String jobName;

    /**
     * 任務組名
     */
    @NotBlank(message = "任務組名不能為空")
    @Size(max = 10, message = "任務組名不能超過10個字元")
    private String jobGroup;

    /**
     * 呼叫目標字串
     */
    private String invokeTarget;

    /**
     * 執行表示式
     */
    private String cronExpression;

    /**
     * cron計劃策略 0=預設,1=立即觸發執行,2=觸發一次執行,3=不觸發立即執行
     */
    private String misfirePolicy = "0";

    /**
     * 並行執行 0=允許,1=禁止
     */
    private String concurrent;

    /**
     * 描述 -- 任務說明
     */
    private String description;


    /**
     * 任務狀態（0正常 1暫停）
     */
    private String status;


    public int getJobId() {
        return jobId;
    }

    public void setJobId(int jobId) {
        this.jobId = jobId;
    }

    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 getInvokeTarget() {
        return invokeTarget;
    }

    public void setInvokeTarget(String invokeTarget) {
        this.invokeTarget = invokeTarget;
    }

    public String getCronExpression() {
        return cronExpression;
    }

    public void setCronExpression(String cronExpression) {
        this.cronExpression = cronExpression;
    }

    public String getMisfirePolicy() {
        return misfirePolicy;
    }

    public void setMisfirePolicy(String misfirePolicy) {
        this.misfirePolicy = misfirePolicy;
    }

    public String getConcurrent() {
        return concurrent;
    }

    public void setConcurrent(String concurrent) {
        this.concurrent = concurrent;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

package com.vipsoft.web.service.impl;

import cn.hutool.core.util.StrUtil;
import com.vipsoft.web.config.ScheduleConstants;
import com.vipsoft.web.entity.QuartzJob;
import com.vipsoft.web.exception.CustomException;
import com.vipsoft.web.job.CommonJob;

import com.vipsoft.web.service.IQuartzJobService;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

@Service
public class QuartzJobServiceImpl implements IQuartzJobService {

    @Autowired
    Scheduler scheduler;


    /**
     * 新增任務
     *
     * @param job 排程資訊
     * @return 結果
     */
    @Override
    public void clearAll(QuartzJob job) throws SchedulerException {
        scheduler.clear();
    }
    /**
     * 新增任務
     *
     * @param job 排程資訊
     * @return 結果
     */
    @Override
    public void addJob(QuartzJob job) throws SchedulerException {
        if (StrUtil.isEmpty(job.getStatus())) {
            // 如果沒值，設定暫停
            job.setStatus(ScheduleConstants.Status.PAUSE.getValue());
        }
        Class<? extends Job> jobClass = CommonJob.class;
        // 構建job資訊
        int jobId = job.getJobId();
        String jobName = job.getJobName();
        String jobGroup = job.getJobGroup();
        JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
        TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);

        JobDetail jobDetail = JobBuilder.newJob(jobClass)
                .withIdentity(jobKey)
                .build();
        // 放入引數，執行時的方法可以獲取
        jobDetail.getJobDataMap().put(ScheduleConstants.TASK_PROPERTIES, job);



        // 表示式排程構建器
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
        cronScheduleBuilder = handleCronScheduleMisfirePolicy(job.getMisfirePolicy(), cronScheduleBuilder);

        // 按新的cronExpression表示式構建一個新的trigger
        CronTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(triggerKey)
                .withSchedule(cronScheduleBuilder)
                .build();

        // 判斷是否存在
        if (scheduler.checkExists(jobKey)) {
            // 防止建立時存在資料問題 先移除，然後在執行建立操作
            scheduler.deleteJob(jobKey);
        }

        scheduler.scheduleJob(jobDetail, trigger);

        // 暫停任務
        if (job.getStatus().equals(ScheduleConstants.Status.PAUSE.getValue())) {
            scheduler.pauseJob(jobKey);
        }
    }

    /**
     * 設定定時任務策略
     */
    public static CronScheduleBuilder handleCronScheduleMisfirePolicy(String misfirePolicy, CronScheduleBuilder cb)  {
        switch (misfirePolicy) {
            case ScheduleConstants.MISFIRE_DEFAULT:
                return cb;
            case ScheduleConstants.MISFIRE_IGNORE_MISFIRES:
                return cb.withMisfireHandlingInstructionIgnoreMisfires();
            case ScheduleConstants.MISFIRE_FIRE_AND_PROCEED:
                return cb.withMisfireHandlingInstructionFireAndProceed();
            case ScheduleConstants.MISFIRE_DO_NOTHING:
                return cb.withMisfireHandlingInstructionDoNothing();
            default:
                throw new CustomException(60001, "策略設定異常 " + misfirePolicy);
        }
    }

    /**
     * 更新任務
     *
     * @param job 排程資訊
     * @return 結果
     */
    @Override
    public void updateJob(QuartzJob job) throws SchedulerException {
        // 判斷是否存在
        JobKey jobKey = JobKey.jobKey(job.getJobName(), job.getJobGroup());
        if (scheduler.checkExists(jobKey)) {
            // 防止建立時存在資料問題 先移除，然後在執行建立操作
            scheduler.deleteJob(jobKey);
        }
        addJob(job);
    }

    /**
     * 刪除任務
     *
     * @param job
     * @Date 2016年1月16日
     * @since 2.0.0
     */
    @Override
    public void deleteJob(QuartzJob job) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(job.getJobName(), job.getJobGroup());
        if (this.scheduler.checkExists(jobKey)) {
            this.scheduler.deleteJob(jobKey);
        }
    }

    /**
     * 立即執行任務
     *
     * @param job 排程資訊
     * @return 結果
     */
    @Override
    public void run(QuartzJob job) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(job.getJobName(), job.getJobGroup());
        scheduler.triggerJob(jobKey);
    }

    /**
     * 暫停任務
     *
     * @param job 排程資訊
     * @return 結果
     */
    @Override
    public void pauseJob(QuartzJob job) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(job.getJobName(), job.getJobGroup());
        this.scheduler.pauseJob(jobKey);
    }

    /**
     * 恢復任務
     *
     * @param job 排程資訊
     * @return 結果
     */
    @Override
    public void restartJob(QuartzJob job) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(job.getJobName(), job.getJobGroup());
        this.scheduler.resumeJob(jobKey);
    }

    /**
     * 獲取quartz排程器的計劃任務
     *
     * @param job 排程資訊
     * @return 排程任務集合
     */
    @Override
    public List<QuartzJob> listJob(QuartzJob job) throws SchedulerException {
        List<QuartzJob> scheduleJobVOList = new ArrayList<>();
        GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
        Set<JobKey> jobKeys = this.scheduler.getJobKeys(matcher);
        for (JobKey jobKey : jobKeys) {
            List<? extends Trigger> triggers = this.scheduler.getTriggersOfJob(jobKey);
            for (Trigger trigger : triggers) {
                JobDetail jobDetail = this.scheduler.getJobDetail(jobKey);
                QuartzJob scheduleJobVO = (QuartzJob) jobDetail.getJobDataMap().get(ScheduleConstants.TASK_PROPERTIES);
                Trigger.TriggerState triggerState = this.scheduler.getTriggerState(trigger.getKey());
                scheduleJobVO.setStatus(triggerState.name());
                // 判斷trigger
                if (trigger instanceof SimpleTrigger) {
                    SimpleTrigger simple = (SimpleTrigger) trigger;
                    scheduleJobVO.setCronExpression("重複次數:" + (simple.getRepeatCount() == -1 ? "無限" : simple.getRepeatCount()) + ",重複間隔:"
                            + (simple.getRepeatInterval() / 1000L));
                    scheduleJobVO.setDescription(simple.getDescription());
                }
                if (trigger instanceof CronTrigger) {
                    CronTrigger cron = (CronTrigger) trigger;
                    scheduleJobVO.setCronExpression(cron.getCronExpression());
                    scheduleJobVO.setDescription(cron.getDescription() == null ? ("觸發器:" + trigger.getKey()) : cron.getDescription());
                }
                scheduleJobVOList.add(scheduleJobVO);
            }
        }
        return scheduleJobVOList;
    }
}

package com.vipsoft.web.config;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration; 
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import javax.sql.DataSource;
import java.util.Properties;

@Configuration
public class ScheduleConfig {

    /**
     * 設定屬性
     */
    private Properties quartzProperties() {
        // quartz引數
        Properties prop = new Properties();
        prop.put("org.quartz.scheduler.instanceName", "VipSoftScheduler");
        prop.put("org.quartz.scheduler.instanceId", "AUTO");
        // 執行緒池設定
        prop.put("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");
        prop.put("org.quartz.threadPool.threadCount", "20");
        prop.put("org.quartz.threadPool.threadPriority", "5");
        // JobStore設定
        prop.put("org.quartz.jobStore.class", "org.quartz.impl.jdbcjobstore.JobStoreTX");
        // 叢集設定
        prop.put("org.quartz.jobStore.isClustered", "true");
        prop.put("org.quartz.jobStore.clusterCheckinInterval", "15000");
        prop.put("org.quartz.jobStore.maxMisfiresToHandleAtATime", "1");
        prop.put("org.quartz.jobStore.txIsolationLevelSerializable", "true");

        // sqlserver 啟用
        // prop.put("org.quartz.jobStore.selectWithLockSQL", "SELECT * FROM {0}LOCKS UPDLOCK WHERE LOCK_NAME = ?");
        prop.put("org.quartz.jobStore.misfireThreshold", "12000");
        prop.put("org.quartz.jobStore.tablePrefix", "QRTZ_");
        return prop;
    }


    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource) {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setDataSource(dataSource);

//        //獲取設定屬性--通過載入組態檔的方式獲取設定
//        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
//        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
//        //在quartz.properties中的屬性被讀取並注入後再初始化物件
//        propertiesFactoryBean.afterPropertiesSet();
//        factory.setQuartzProperties(propertiesFactoryBean.getObject());

        //用於quartz叢集,載入quartz資料來源設定
        factory.setQuartzProperties(this.quartzProperties());

        factory.setSchedulerName("VipSoftScheduler");
        //QuartzScheduler 延時啟動，應用啟動完10秒後 QuartzScheduler 再啟動
        factory.setStartupDelay(10);
        // 可選，QuartzScheduler
        // 啟動時更新己存在的Job，這樣就不用每次修改targetObject後刪除qrtz_job_details表對應記錄了
        factory.setOverwriteExistingJobs(true);
        // 設定自動啟動，預設為true
        factory.setAutoStartup(true);
        factory.setApplicationContextSchedulerContextKey("applicationContextKey");

        return factory;
    }
}