Quartz的使用

import static org.quartz.TriggerBuilder.newTrigger;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import org.apache.commons.lang3.StringUtils;
import org.mybatis.spring.SqlSessionTemplate;
import org.quartz.CronExpression;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.TriggerKey;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.GroupMatcher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * quartz.properties org.quartz.scheduler.instanceName = MyScheduler
 * org.quartz.threadPool.threadCount = 3 
 * org.quartz.jobStore.class =org.quartz.simpl.RAMJobStore
 * 

 * 

 * Quartz API核心接口有： 
 *   Scheduler – 与scheduler交互的主要API； 
 *   Job – 你通过scheduler执行任务，你的任务类需要实现的接口；  
 *   JobDetail – 定义Job的实例； 
 *   Trigger – 触发Job的执行；
 *   JobBuilder – 定义和创建JobDetail实例的接口; 
 *   TriggerBuilder – 定义和创建Trigger实例的接口；
 */
public class QuartzManager {

    private static Logger log = LoggerFactory.getLogger(QuartzManager.class);
    public static Scheduler scheduler;

    static {
        // 静止检查更新
        System.setProperty("org.terracotta.quartz.skipUpdateCheck", "true");
        SchedulerFactory sf = new StdSchedulerFactory();
        try {
            scheduler = sf.getScheduler();
            scheduler.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 返回指定周期后的调度时间
     * */
    public static Date getNextFireTime(String cronExpression,Date startTime,int times) {
        CronExpression exp = null;
        try {
            // 初始化cron表达式解析器
            exp = new CronExpression(cronExpression);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        //下一次要执行的时间
        Date nextFireTime = startTime ;
        for(int i=0;i listExistJob() throws Exception {
        List quartzJobsVOList = new ArrayList();
        try {
            // 再获取Scheduler下的所有group
            List triggerGroupNames = scheduler.getTriggerGroupNames();
            for (String groupName : triggerGroupNames) {
                // 组装group的匹配，为了模糊获取所有的triggerKey或者jobKey
                GroupMatcher groupMatcher = GroupMatcher.groupEquals(groupName);
                // 获取所有的triggerKey
                Set triggerKeySet = scheduler.getTriggerKeys(groupMatcher);
                for (TriggerKey triggerKey : triggerKeySet) {
                    // 通过triggerKey在scheduler中获取trigger对象
                    CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
                    // 获取trigger拥有的Job
                    JobKey jobKey = trigger.getJobKey();
                    // JobDetailImpl jobDetail = (JobDetailImpl) scheduler.getJobDetail(jobKey);

                    // 组装页面需要显示的数据
                    String triggerGroup = triggerKey.getGroup();
                    String triggerName = triggerKey.getName();
                    String jobGroup = jobKey.getGroup();
                    String jobName = jobKey.getName();
                    quartzJobsVOList.add(
                            new ExistJob(triggerGroup, triggerName, jobGroup, jobName, trigger.getCronExpression()));
                }
            }
        } catch (Exception e) {
            log.error("获取定时任务信息出错", e);
        }
        return quartzJobsVOList;
    }

    /**
     * cronExpress : "0/20 * * * * ?" -> 秒、分钟、小时、一月的某天、某月、一周的某天、某年
     *
     * @throws SchedulerException
     */
    public static void addCronJob(AlarmRuleConfig ruleConf, SqlSessionTemplate sqlSessionTemplate) throws Exception {
        if (ruleConf == null || StringUtils.isBlank(ruleConf.getRuleId())) {
            return;
        }
        String cronexpress = ruleConf.getCronExp() ;
        if (StringUtils.isBlank(cronexpress)) {
            log.error("调度表达式不能为空");
            return;
        }
        JobDataMap newJobDataMap = new JobDataMap();

        JobKey jobKey = getJobKey(ruleConf.getRuleId(), ruleConf.getRuleId());
        TriggerKey triggerKey = getTriggerKey(ruleConf.getRuleId(), ruleConf.getRuleId());

        // 创建Job
        JobDetail job = JobBuilder.newJob(ScheduleJob.class).withIdentity(jobKey).usingJobData(newJobDataMap).build();
        // 构建触发器
        CronTrigger trigger = newTrigger().withIdentity(triggerKey)
                .withSchedule(CronScheduleBuilder.cronSchedule(cronexpress)).build();
        scheduler.scheduleJob(job, trigger);
    }

    private static final String JOB_GROUP_PREFIX = "job-";
    private static final String TRIGGER_GROUP_PREFIX = "trigger-";

    private static final JobKey getJobKey(String groupName, String name) {
        return new JobKey(name, JOB_GROUP_PREFIX + groupName);
    }

    private static final TriggerKey getTriggerKey(String groupName, String name) {
        return new TriggerKey(name, TRIGGER_GROUP_PREFIX + groupName);
    }

    /**
     * @Description: 根据规则ID删除任务
     */
    public static final void removeJob(String ruleId) {
        JobKey jobKey = getJobKey(ruleId, ruleId);
        TriggerKey triggerKey = getTriggerKey(ruleId, ruleId);
        try {
            scheduler.pauseTrigger(triggerKey);// 停止触发器
            scheduler.unscheduleJob(triggerKey);// 移除触发器
            scheduler.deleteJob(jobKey);// 删除任务
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public static class ScheduleJob implements org.quartz.Job {
        public void execute(JobExecutionContext context) throws JobExecutionException {
            log.debug("-------------执行调度任务-------------");
            JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
            Date fireTime = context.getFireTime();
        }
    }