任務調度：Scheduler

使用Scheduler開啟，移除，修改任務的工具類：

package com.googosoft.until;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.StdSchedulerFactory;
import com.googosoft.job.EvaluationPlanJob;
import com.googosoft.model.EvaluationPlan;

/**
 * 
 * @author songyan
 * @date 2020年3月31日 下午1:19:25
 * @desc 定時任務工具類
 */
public class SchedulerUtil {
    
    /**
     * 單例
     */
    private static Scheduler scheduler = createScheduler();
    
    /**
     * 保證單例
     */
    private SchedulerUtil() {}
    private static final String JOB_GROUP = "jobGroup";
    private static final String TRIGGER_GROUP = "triggerGroup";
    private static final Class<EvaluationPlanJob> clazz = EvaluationPlanJob.class;

    /**
     * 創建一個觸發器
     * @param cron
     * @param triggerKeyName
     * @param endDate
     * @return
     */
    private static  Trigger createTrigger( String cron, String triggerKeyName, Date endDate) {
        return TriggerBuilder.newTrigger().withIdentity(triggerKeyName,TRIGGER_GROUP)
                .withSchedule(CronScheduleBuilder.cronSchedule(cron)
                .withMisfireHandlingInstructionDoNothing()).endAt(endDate).build();
    }
    
    /**
     * 創建一個調度器
     */
    private static  Scheduler createScheduler() {
        SchedulerFactory schedulerfactory = new StdSchedulerFactory();
        try {
            return schedulerfactory.getScheduler();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return null;
    }
    
    /**
     * 創建作業
     * @param jobName
     * @param dataMap
     * @return
     */
    private static JobDetail getJob( String jobName, JobDataMap dataMap) {
        return JobBuilder.newJob(clazz).setJobData(dataMap).withIdentity(jobName,JOB_GROUP).build();
    }
    
    /**
     * 獲取Job信息
     * @param key
     * @return
     */
    private static JobDetail getDetail(String key) {
        JobKey jobKey = JobKey.jobKey(key, JOB_GROUP);
        JobDetail detail =null;
        try {
            detail = scheduler.getJobDetail(jobKey);
        } catch (SchedulerException e1) {
            e1.printStackTrace();
        }
        return detail;
    }
    
    /**
     * 開啟一次調度
     * @param scheduler
     * @param jobDetail
     * @param trigger
     */
    private static void startScheduler(Scheduler scheduler, JobDetail jobDetail, Trigger trigger) {
        try {
            scheduler.scheduleJob(jobDetail, trigger);
            scheduler.start();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 添加一個調度
     * @param scheduler
     * @param jobDetail
     * @param trigger
     */
    private static void addScheduler(Scheduler scheduler, JobDetail jobDetail, Trigger trigger) {
        try {
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 將作業的字符串類型keyId轉成對象類型集合
     * @param keyArray JobKey數組
     * @return JobKey對象集合
     */
    private static List<JobKey> getJobKeys(String[] keyArray) {
        List<JobKey> jobKeys = new ArrayList<>();
        for (int i = 0; i < keyArray.length; i++) {
            String key = keyArray[i];
            jobKeys.add(JobKey.jobKey(key, JOB_GROUP));
        }
        return jobKeys;
    }
    
    /**
     * 將作業的字符串類型TriggerKey轉成對象類型集合
     * @param keyArray TriggerKey數組
     * @return TriggerKey對象集合
     */
    private static List<TriggerKey> getTriggerKeys(String[] keyArray) {
        List<TriggerKey> triggerKeys = new ArrayList<>();
        for (int i = 0; i < keyArray.length; i++) {
            String key = keyArray[i];
            triggerKeys.add(TriggerKey.triggerKey(key, TRIGGER_GROUP));
        }
        return triggerKeys;
    }
    
    /**
     * 啟動一個作業
     * @param cron
     * @param endDate
     * @param dataMap
     * @param key
     */
    public static void start(String cron, Date endDate,  String schemeSchedulId,EvaluationPlan evaluationPlan) {
        String key = evaluationPlan.getGid()+schemeSchedulId;
        JobDataMap dataMap = new JobDataMap();
        dataMap.put("GID", evaluationPlan.getGid());
        dataMap.put("DBMETAGID", evaluationPlan.getDbMetaGid());
        JobDetail job = getJob(key,dataMap);
        Trigger trigger = createTrigger(cron,key,endDate);
        startScheduler(scheduler, job, trigger);
    }
    
    /**
     * 啟動多個作業
     * @param cron
     * @param endDate
     * @param dataMap
     * @param keyArray
     */
    public static void start(String cron, Date endDate, String schemeSchedulId,List<EvaluationPlan> evaluationPlanList) {
        for (EvaluationPlan evaluationPlan : evaluationPlanList) {
            start(cron, endDate, schemeSchedulId,evaluationPlan);
        }
    }
    
    /**
     * 添加一個作業
     * @param cron
     * @param endDate
     * @param dataMap
     * @param key
     */
    public static void add(String cron, Date endDate, JobDataMap dataMap, String key) {
        JobDetail job = getJob(key,dataMap);
        Trigger trigger = createTrigger(cron,key,endDate);
        addScheduler(scheduler, job, trigger);
    }
    
    /**
     * 添加多個作業
     * @param cron
     * @param endDate
     * @param dataMap
     * @param key
     */
    public static void add(String cron, Date endDate, JobDataMap dataMap, String keyArray[]) {
        for (String key : keyArray) {
            add(cron, endDate, dataMap, key);
        }
    }
    
    /**
     * 更新作業的表達式，截止時間
     * @param key
     * @param cron
     * @param endDate
     */
    public static void update(String key, String cron, Date endDate){
        TriggerKey triggerKey = TriggerKey.triggerKey(key, TRIGGER_GROUP);
        Trigger newTrigger = createTrigger(cron, key, endDate) ;
        try {
            scheduler.rescheduleJob(triggerKey, newTrigger);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 更新作業的表達式，截止時間
     * @param keyArray
     * @param cron
     * @param endDate
     */
    public static void update(String[] keyArray, String cron, Date endDate){
        for (String key : keyArray) {
            update(key, cron, endDate);
        }
    }
    
    /**
     * 暫停一個作業調度
     * @param key 
     */
    public static void pause(String key) {
        try {
            scheduler.pauseJob(JobKey.jobKey(key, JOB_GROUP));
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 暫停多個作業調度
     * @param key 
     */
    public static void pause(String[] keyArray) {
        for (String key : keyArray) {
            pause(key);
        } 
    }
    
    /**
     * 恢復一個作業調度
     * @param key 
     */
    public static void resume(String key) {
        JobKey jobKey = JobKey.jobKey(key, JOB_GROUP);
        JobDetail detail = null;
        try {
            detail = scheduler.getJobDetail(jobKey);
        } catch (SchedulerException e1) {
            e1.printStackTrace();
        }
        if(detail==null){
            
        }else{
            try {
                scheduler.resumeJob(jobKey);
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * 恢復多個作業調度
     * @param keyArray 
     */
    public static void resume(String[] keyArray) {
        for (String key : keyArray) {
            resume(key);
        }
    }
    
    /**
     * 移除一個作業調度
     * @param key 
     */
    public static void remove(String key) {
        try {
            scheduler.unscheduleJob(TriggerKey.triggerKey(key, TRIGGER_GROUP));
            scheduler.deleteJob(JobKey.jobKey(key, JOB_GROUP));
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 移除多個作業調度
     * @param key 
     */
    public static void remove(String[] keyArray) {
        List<TriggerKey> triggerKeys = getTriggerKeys(keyArray);
        List<JobKey> jobKeys = getJobKeys(keyArray);
        for (int i = 0; i < keyArray.length; i++) {
            String key = keyArray[i];
            triggerKeys.add(TriggerKey.triggerKey(key, TRIGGER_GROUP));
            jobKeys.add(JobKey.jobKey(key, JOB_GROUP));
        }
        try {
            scheduler.unscheduleJobs(triggerKeys);
            scheduler.deleteJobs(jobKeys);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 啟動/恢復 一個作業
     * @param cron
     * @param endDate
     * @param dataMap
     * @param key
     */
    public static void run(String cron, Date endDate,  String schemeSchedulId,EvaluationPlan evaluationPlan) {
        String key = schemeSchedulId+evaluationPlan.getGid();
        JobDetail detail = getDetail(key);
        if(detail==null){
            start(cron, endDate, schemeSchedulId,evaluationPlan);
        }else{
            resume(key);
        }
    } 
    
    /**
     * 啟動/恢復 多個作業
     * @param cron
     * @param endDate
     * @param dataMap
     * @param keyArray
     */
    public static void run(String cron, Date endDate, String schedulerId, List<EvaluationPlan> evaluationPlanList) {
        for (EvaluationPlan evaluationPlan : evaluationPlanList) {
            run(cron, endDate, schedulerId,evaluationPlan);
        }
    }
    
}

 

作業類(可以將作業中的參數通過JobDataMap傳遞)：

package com.googosoft.job;

import javax.annotation.Resource;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import com.googosoft.service.QualityEvaluationService;
import com.googosoft.until.SpringUtil;
import com.googosoft.util.PageData;

/**
 * @author songyan
 * @date 2020年3月31日 下午1:51:33
 * @desc 作業
 */
public class EvaluationPlanJob implements Job {
    
    @Resource
    private QualityEvaluationService service = (QualityEvaluationService) SpringUtil.getBean("qualityEvaluationService");

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
       JobDataMap data = context.getJobDetail().getJobDataMap();
        PageData pd = new PageData();
        pd.put("GID", data.get("GID"));
        pd.put("DBMETAGID", data.get("DBMETAGID"));
        service.runEvaluationPlanList(pd);
    }

}

 

測試:

public static void main(String[] args) throws ParseException, InterruptedException {
     SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        
        Date endDate = sdf.parse("2020-04-05 12:00:00");
        Date endDate2 = sdf.parse("2020-04-02 14:52:00");
        String cron = "0/1 * * * * ? ";
        String cron2 = "0/2 * * * * ? ";
        String key =UuidUtil.get32UUID();
        JobDataMap dataMap= new JobDataMap();
        dataMap.put("name", "11111111111111111111111"); 
        dataMap.put("age", 18);
        
        //啟用
        SchedulerUtil.start(cron,endDate, dataMap,key);
        
        //暫停
        SchedulerUtil.pause(key);
        
        //恢復
        SchedulerUtil.resume(key);
        
        //修改
        SchedulerUtil.update(key, cron2, endDate2);
        
        //移除
        SchedulerUtil.remove(key);
}