任务调度：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);
}