Quartz2 动态使用

Quartz, 是一个企业级调度工作的框架，帮助Java应用程序到调度工作/任务在指定的日期和时间运行。

这里使用的是2.3.0 版本

        <!--quartz石英调度 -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.0</version>
        </dependency>

学习Quartz需要明白几个概念

JobDetail 作业：运行什么 在java中无非就是一个方法

// 作业的JobKey 为本次作业的身份标示 
JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);

//创建作业 jobClass为Job接口的实现类 里面只有一个方法就是我们的作业的方法
JobDetail jobDetailt = JobBuilder
                //指定作业类
                .newJob(jobClass)
                //指定身份标示
                .withIdentity(jobKey)
                //构建作业
                .build();

Trigger触发器:在什么时候运行指定作业

//触发器的triggerKey 本触发器的身份标示
TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, TriggerGroupName);

     Trigger trigger = TriggerBuilder
                    //创建触发器的构建器
                    .newTrigger()
                    //指定身份标示
                    .withIdentity(triggerKey)
                    //绑定作业
                    .forJob(jobKey)
                    //指定作业时间
                    .withSchedule(CronScheduleBuilder.cronSchedule(cron表达式))
                    //现在启动
                    .startNow()
                    //构建触发器
                    .build();

Scheduler调度器：有了作业和触发器并不能运行 作业与触发器必须注册到调度器中才会开始工作

    //获取调度器 注意这是单例模式每次获取的调度器都是同一个对象
    Scheduler scheduler = new StdSchedulerFactory().getScheduler();
    //向调度器中注册作业和触发器
    scheduler.scheduleJob(job, trigger);
    //也可以单独注册触发器
    scheduler.scheduleJob(trigger);
    //启动调度器
    scheduler.start();

重点

jobKey和triggerKey分别为作业和触发器的身份标示
注意一个作业只可以被添加到所述调度器一次，并且必须和触发器器一起添加。 一起添加时调度器会为触发器绑定该作业。触发器可以单独添加到调度器，
单独添加触发器时， 该触发器必须自己绑定作业，且绑定的作业已经在调度器中注册过。一个作业可以有多个触发器
一个触发器只能被添加到所属调度器一次

---

一个完整的例子

//创建作业的实现
public class HelloJob implements Job
{
    @Override
    public void execute(JobExecutionContext context)
    throws JobExecutionException {

        System.out.println("本作业开始执行了！！！");  

    }
}



public class QtTest {

    // 一个简单的例子
    public static void main(String[] args) throws SchedulerException {
        // 创建作业的key
        JobKey jobKey = JobKey.jobKey("作业一号", "作业分组一");
        // 创建触发器的key
        TriggerKey triggerKey = TriggerKey.triggerKey("触发器一号", "触发器分组一");
        //创建作业
        JobDetail job = JobBuilder.newJob(HelloJob.class).withIdentity(jobKey).build();
        //创建触发器（）
        Trigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerKey)
                .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ?")).build();
        //创建调度器
        Scheduler scheduler = new StdSchedulerFactory().getScheduler();
        //注册作业与触发器
        scheduler.scheduleJob(job, trigger);
        //启动调度器
        scheduler.start();

    }
}

之前重点中说过一个作业可以有多个触发器
我们可以写一个试试 同时为作业与触发器绑定一下参数

    public class QtTest {

    // 一个比较简单的例子
    public static void main(String[] args) throws SchedulerException {
        // 创建作业的key
        JobKey jobKey = JobKey.jobKey("作业一号", "作业分组一");
        // 创建触发器的key
        TriggerKey triggerKey = TriggerKey.triggerKey("触发器一号", "触发器分组一");
        //创建作业
        JobDetail job = JobBuilder.newJob(HelloJob.class).withIdentity(jobKey)
                .usingJobData("id", "123")//绑定参数
                .build();
        //创建触发器
        Trigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerKey)
                .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ?"))
                .usingJobData("name", "xiaobai")//绑定参数
                .build();


        // 创建触发器的key
        TriggerKey triggerKey2 = TriggerKey.triggerKey("触发器二号", "触发器分组一");

        //创建触发器 单独添加触发器时必须为触发器绑定作业
        Trigger trigger2 = TriggerBuilder.newTrigger().withIdentity(triggerKey2)
                .withSchedule(CronScheduleBuilder.cronSchedule("0/7 * * * * ?"))
                .usingJobData("age", "18")//绑定参数
                .forJob(jobKey)//绑定作业
                .startNow().build();



        //创建调度器
        Scheduler scheduler = new StdSchedulerFactory().getScheduler();
        //注册作业与触发器
        scheduler.scheduleJob(job, trigger);
        //单独添加触发器
        scheduler.scheduleJob(trigger2);
        //启动调度器
        scheduler.start();

    }
}


//作业实现类 石英调度的目标任务
public class HelloJob implements Job{

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        //这里顺便演示一下JobExecutionContext类的使用
        System.out.println();
        System.out.println(">>>>>>>>>>>>>>>>>>>>>>>");
        //获取作业器
        JobDetail jobDetail = context.getJobDetail();
        //获取触发器
        CronTrigger trigger = (CronTrigger) context.getTrigger();
        //获取作业器参数
        JobDataMap jobDataMap = jobDetail.getJobDataMap();
        //获取触发器参数
        JobDataMap triggerDataMap = trigger.getJobDataMap();
        //获取作业器key
        JobKey jobKey = jobDetail.getKey();
        //获取触发器key
        TriggerKey triggerKey = trigger.getKey();

        System.out.println("作业名称 : "+jobKey.getName()+"  作业分组 : "+jobKey.getGroup());

        System.out.println("触发器名称 : "+triggerKey.getName()+"  触发器分组 : "+triggerKey.getGroup());

        System.out.println("cron表达式 : "+trigger.getCronExpression());

        for (String string : jobDataMap.getKeys()) {
            System.out.println("作业器参数key : "+string+"  value : "+jobDataMap.get(string));
        }


        for (String string : triggerDataMap.getKeys()) {
            System.out.println("触发器参数key : "+string+"  value : "+triggerDataMap.get(string));
        }

//      System.out.println("本作业第一次开始时间： "+Tools.dateToStr(trigger.getStartTime(), "yyyy-MM-dd HH:mm:ss"));
//      System.out.println("本次作业开始时间"+Tools.dateToStr(trigger.getPreviousFireTime(), "yyyy-MM-dd HH:mm:ss"));
//      System.out.println("下一次作业开始时间："+Tools.dateToStr(trigger.getNextFireTime(), "yyyy-MM-dd HH:mm:ss"));
//      System.out.println("获取指定时间后的作业时间："+Tools.dateToStr(trigger.getFireTimeAfter(new Date()), "yyyy-MM-dd HH:mm:ss"));

        //throw new JobExecutionException("测试异常");


    }

---

以上是基础用法
下面是我封装的一个工具类。有增删改 暂停 恢复等功能 可以查看更多的用法

import java.util.List;
import java.util.Map;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.Job;
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 org.quartz.impl.matchers.GroupMatcher;

/**
 * 
 * @Description: 定时作业管理类
 * @author: Qin YunFei
 * @date: 2017年11月6日 下午8:23:13
 * @version V1.0
 */
public class QuartzUtil {
    public static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory(); // 创建一个SchedulerFactory工厂实例
    public static String JOB_GROUP_NAME = "作业组一"; // 作业组
    public static String TRIGGER_GROUP_NAME = "触发器组一"; // 触发器组

    /*
     * 必须搞清楚 jobKey和triggerKey分别为作业和触发器的身份证
     * 注意一个作业（jobKey）只可以被添加到所述调度器一次并且必须和触发器器一起添加 一起添加时调度器会为触发器绑定该作业 触发器可以单独添加到调度器
     * 单独添加调度器时 该触发器必须自己绑定作业（jobKey） 一个作业可以有多个触发器（triggerKey）
     * 一个触发器（triggerKey）只能被添加到所属调度器一次
     * 
     */

    /**
     * 添加一个定时作业，使用默认的作业组名,触发器组名
     * 
     * @param jobName
     *            作业名
     * @param triggerName
     *            触发器名
     * @param jobClass
     *            作业
     * @param cron
     *            时间设置，参考quartz说明文档
     */
    public static void addJob(String jobName, String triggerName, Class<? extends Job> jobClass, String cron) {
        try {
            // 作业的JobKey
            JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
            // 触发器的triggerKey
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, TRIGGER_GROUP_NAME);

            // 创建作业
            JobDetail jobDetail = QuartzHelp.createJobDetail(jobKey, jobClass);
            ; // 用于描叙Job实现类及其他的一些静态信息，构建一个作业实例
                // 创建触发器
            CronTrigger trigger = (CronTrigger) QuartzHelp.createTrigger(jobKey, triggerKey, cron);

            // 获取调度器
            Scheduler sched = gSchedulerFactory.getScheduler(); // 通过SchedulerFactory构建Scheduler对象
            // 注册作业和触发器
            sched.scheduleJob(jobDetail, trigger);
            if (!sched.isShutdown()) {
                sched.start(); // 启动
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 添加一个定时作业，使用默认的作业组名，触发器名，触发器组名 （触发器带参数）
     * 
     * @param jobName
     *            作业名
     * @param triggerName
     *            触发器名
     * @param cls
     *            作业
     * @param cron
     *            时间设置，参考quartz说明文档
     * @param parameter
     *            参数map
     */
    public static void addJob(String jobName, String triggerName, Class<? extends Job> jobClass, String cron,
            Map<String, Object> parameter) {
        try {
            // 作业的JobKey
            JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
            // 触发器的triggerKey
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, TRIGGER_GROUP_NAME);

            // 创建作业
            JobDetail jobDetail = QuartzHelp.createJobDetail(jobKey, jobClass);
            ; // 用于描叙Job实现类及其他的一些静态信息，构建一个作业实例
                // 创建带参数带触发器
            CronTrigger trigger = (CronTrigger) QuartzHelp.createTrigger(jobKey, triggerKey, cron, parameter);

            // 获取调度器
            Scheduler sched = gSchedulerFactory.getScheduler(); // 通过SchedulerFactory构建Scheduler对象
            // 注册作业和触发器
            sched.scheduleJob(jobDetail, trigger);
            if (!sched.isShutdown()) {
                sched.start(); // 启动
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 添加一个定时作业
     * 
     * @param jobName
     *            作业名
     * @param jobGroupName
     *            作业组名
     * @param triggerName
     *            触发器名
     * @param triggerGroupName
     *            触发器组名
     * @param jobClass
     *            作业
     * @param cron
     *            时间设置，参考quartz说明文档
     */
    public static void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName,
            Class<? extends Job> jobClass, String cron) {
        try {
            // 作业的JobKey
            JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
            // 触发器的triggerKey
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);

            // 创建作业
            JobDetail jobDetail = QuartzHelp.createJobDetail(jobKey, jobClass);
            ; // 用于描叙Job实现类及其他的一些静态信息，构建一个作业实例
                // 创建触发器
            CronTrigger trigger = (CronTrigger) QuartzHelp.createTrigger(jobKey, triggerKey, cron);

            // 获取调度器
            Scheduler sched = gSchedulerFactory.getScheduler(); // 通过SchedulerFactory构建Scheduler对象
            // 注册作业和触发器
            sched.scheduleJob(jobDetail, trigger);
            if (!sched.isShutdown()) {
                sched.start(); // 启动
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 添加一个定时作业 （触发器带参数）
     * 
     * @param jobName
     *            作业名
     * @param jobGroupName
     *            作业组名
     * @param triggerName
     *            触发器名
     * @param triggerGroupName
     *            触发器组名
     * @param jobClass
     *            作业
     * @param cron
     *            时间设置，参考quartz说明文档
     * @param parameter
     *            参数map
     */
    public static void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName,
            Class<? extends Job> jobClass, String cron, Map<String, Object> parameter) {
        try {
            // 作业的JobKey
            JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
            // 触发器的triggerKey
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);

            // 创建作业
            JobDetail jobDetail = QuartzHelp.createJobDetail(jobKey, jobClass);
            ; // 用于描叙Job实现类及其他的一些静态信息，构建一个作业实例
                // 创建触发器
            CronTrigger trigger = (CronTrigger) QuartzHelp.createTrigger(jobKey, triggerKey, cron, parameter);

            // 获取调度器
            Scheduler sched = gSchedulerFactory.getScheduler(); // 通过SchedulerFactory构建Scheduler对象
            // 注册作业和触发器
            sched.scheduleJob(jobDetail, trigger);
            if (!sched.isShutdown()) {
                sched.start(); // 启动
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 为一个作业添加触发器， 前提为该作业必须在调度器中注册过
     * 
     * @param jobName
     *            作业名
     * @param jobGroupName
     *            作业组名
     * @param triggerName
     *            触发器名
     * @param triggerGroupName
     *            触发器组名
     * @param cron
     *            时间设置，参考quartz说明文档
     */
    public static void addTrigger(String jobName, String jobGroupName, String triggerName, String triggerGroupName,
            String cron) {
        try {
            // 作业的JobKey
            JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
            // 触发器的triggerKey
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
            // 创建触发器
            CronTrigger trigger = (CronTrigger) QuartzHelp.createTrigger(jobKey, triggerKey, cron);

            // 获取调度器
            Scheduler sched = gSchedulerFactory.getScheduler(); // 通过SchedulerFactory构建Scheduler对象
            // 注册作业和触发器
            sched.scheduleJob(trigger);
            if (!sched.isShutdown()) {
                sched.start(); // 启动
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 为一个作业添加触发器，(带参数) 前提为该作业必须在调度器中注册过
     * 
     * @param jobName
     *            作业名
     * @param jobGroupName
     *            作业组名
     * @param triggerName
     *            触发器名
     * @param triggerGroupName
     *            触发器组名
     * @param cron
     *            时间设置，参考quartz说明文档
     * @param parameter
     *            参数map
     */
    public static void addTrigger(String jobName, String jobGroupName, String triggerName, String triggerGroupName,
            String cron, Map<String, Object> parameter) {
        try {
            // 作业的JobKey
            JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
            // 触发器的triggerKey
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
            // 创建触发器
            CronTrigger trigger = (CronTrigger) QuartzHelp.createTrigger(jobKey, triggerKey, cron, parameter);

            // 获取调度器
            Scheduler sched = gSchedulerFactory.getScheduler(); // 通过SchedulerFactory构建Scheduler对象
            // 注册作业和触发器
            sched.scheduleJob(trigger);
            if (!sched.isShutdown()) {
                sched.start(); // 启动
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 为一个作业添加触发器，使用默认的作业组名,触发器组名 前提为该作业必须在调度器中注册过
     * 
     * @param jobName
     *            作业名
     * @param triggerName
     *            触发器名
     * @param cron
     *            时间设置，参考quartz说明文档
     */
    public static void addTrigger(String jobName, String triggerName, String cron) {
        try {
            // 作业的JobKey
            JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
            // 触发器的triggerKey
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, TRIGGER_GROUP_NAME);
            // 创建触发器
            CronTrigger trigger = (CronTrigger) QuartzHelp.createTrigger(jobKey, triggerKey, cron);

            // 获取调度器
            Scheduler sched = gSchedulerFactory.getScheduler(); // 通过SchedulerFactory构建Scheduler对象
            // 注册作业和触发器
            sched.scheduleJob(trigger);
            if (!sched.isShutdown()) {
                sched.start(); // 启动
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 为一个作业添加触发器，使用默认的作业组名,触发器组名(带参数) 前提为该作业必须在调度器中注册过
     * 
     * @param jobName
     *            作业名
     * @param triggerName
     *            触发器名
     * @param cron
     *            时间设置，参考quartz说明文档
     * @param parameter
     *            参数map
     */
    public static void addTrigger(String jobName, String triggerName, String cron, Map<String, Object> parameter) {
        try {
            // 作业的JobKey
            JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
            // 触发器的triggerKey
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, TRIGGER_GROUP_NAME);
            // 创建触发器
            CronTrigger trigger = (CronTrigger) QuartzHelp.createTrigger(jobKey, triggerKey, cron, parameter);

            // 获取调度器
            Scheduler sched = gSchedulerFactory.getScheduler(); // 通过SchedulerFactory构建Scheduler对象
            // 注册作业和触发器
            sched.scheduleJob(trigger);
            if (!sched.isShutdown()) {
                sched.start(); // 启动
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 修改一个触发器的触发时间(使用默认的触发器组名)
     * 
     * @param jobName
     *            作业名
     * @param newcron
     *            新的时间设置
     */
    public static void modifyTriggerTime(String triggerName, String newcron) {
        // 创建TriggerKey
        TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, TRIGGER_GROUP_NAME);

        try {

            // 获取调度器
            Scheduler sched = gSchedulerFactory.getScheduler();
            // 获取指定触发器
            CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
            if (trigger == null) {
                throw new NullPointerException(triggerKey + "不存在");
            }

            if (!trigger.getCronExpression().equalsIgnoreCase(newcron)) {
                JobKey jobKey = trigger.getJobKey();
                // 获取原触发器的构造器设置新的时间
                CronTrigger newbuild = trigger.getTriggerBuilder()
                        .withSchedule(CronScheduleBuilder.cronSchedule(newcron)).build();

                // 判断目前调度器的该作业所有触发器
                @SuppressWarnings("unchecked")
                List<CronTrigger> list = (List<CronTrigger>) sched.getTriggersOfJob(jobKey);

                // 注意如果作业只有一个触发器 删除触发器的同时会同时删除作业 所以这里要进行判断
                if (list.size() > 1) {
                    // 移除触发器指定触发器
                    sched.unscheduleJob(triggerKey);
                    // 注册触发器
                    sched.scheduleJob(newbuild);

                } else {
                    JobDetail jobDetail = sched.getJobDetail(jobKey);
                    // 移除触发器指定触发器
                    sched.unscheduleJob(triggerKey);
                    // 注册作业与触发器
                    sched.scheduleJob(jobDetail, newbuild);

                }

            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 修改一个触发器的触发时间
     * 
     * @param triggerName
     *            触发器名称
     * @param triggerGroupName
     *            触发器名称分组名称
     * @param time
     *            更新后的时间规则
     */
    public static void modifyTriggerTime(String triggerName, String triggerGroupName, String newcron) {
        // 创建TriggerKey
        TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);

        try {

            // 获取调度器
            Scheduler sched = gSchedulerFactory.getScheduler();
            // 获取指定触发器
            CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
            if (trigger == null) {
                throw new NullPointerException(triggerKey + "不存在");
            }

            if (!trigger.getCronExpression().equalsIgnoreCase(newcron)) {
                JobKey jobKey = trigger.getJobKey();
                // 获取原触发器的构造器设置新的时间
                CronTrigger newbuild = trigger.getTriggerBuilder()
                        .withSchedule(CronScheduleBuilder.cronSchedule(newcron)).build();

                // 判断目前调度器的该作业所有触发器
                @SuppressWarnings("unchecked")
                List<CronTrigger> list = (List<CronTrigger>) sched.getTriggersOfJob(jobKey);

                // 注意如果作业只有一个触发器 删除触发器的同时会同时删除作业 所以这里要进行判断
                if (list.size() > 1) {
                    // 移除触发器指定触发器
                    sched.unscheduleJob(triggerKey);
                    // 注册触发器
                    sched.scheduleJob(newbuild);

                } else {
                    JobDetail jobDetail = sched.getJobDetail(jobKey);
                    // 移除触发器指定触发器
                    sched.unscheduleJob(triggerKey);
                    // 注册作业与触发器
                    sched.scheduleJob(jobDetail, newbuild);

                }

            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 删除指定触发器(默认的触发器组名)
     * 
     * @param triggerName
     *            触发器名称
     */
    public void removeTrigger(String triggerName) {
        TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, TRIGGER_GROUP_NAME);
        QuartzHelp.resumeTrigger(triggerKey);
    }

    /**
     * 删除指定触发器
     * 
     * @param triggerName
     *            触发器名称
     * @param triggerGroupName
     *            触发器名称分组名称
     */
    public void removeTrigger(String triggerName, String triggerGroupName) {
        TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, TRIGGER_GROUP_NAME);
        QuartzHelp.unscheduleJob(triggerKey);
    }

    /**
     * 暂停指定触发器(默认的触发器组名)
     * 
     * @param triggerName
     *            触发器名称
     */
    public void pauseTrigger(String triggerName) {
        TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, TRIGGER_GROUP_NAME);
        QuartzHelp.pauseTrigger(triggerKey);
    }

    /**
     * 暂停指定触发器(默认的触发器组名)
     * 
     * @param triggerName
     *            触发器名称
     * @param triggerGroupName
     *            触发器名称分组名称
     */
    public void pauseTrigger(String triggerName, String triggerGroupName) {
        TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
        QuartzHelp.pauseTrigger(triggerKey);
    }

    /**
     * 恢复指定触发器(默认的触发器组名)
     * 
     * @param triggerName
     *            触发器名称
     */
    public void reinstateTrigger(String triggerName) {
        TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, TRIGGER_GROUP_NAME);
        QuartzHelp.resumeTrigger(triggerKey);
    }

    /**
     * 恢复指定触发器(默认的触发器组名)
     * 
     * @param triggerName
     *            触发器名称
     * @param triggerGroupName
     *            触发器名称分组名称
     */
    public void reinstateTrigger(String triggerName, String triggerGroupName) {
        TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
        QuartzHelp.resumeTrigger(triggerKey);
    }

    /**
     * 移除一个作业(使用默认的作业组名) 注移除作业的同时会移除绑定该作业的所有触发器
     * 
     * @param jobName
     *            作业名称
     */
    public static void deleteJob(String jobName) {
        // 通过作业名和组名获取JobKey
        JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
        QuartzHelp.deleteJob(jobKey);
    }

    /**
     * 移除一个作业
     * 
     * @param jobName
     *            作业名
     * @param jobGroupName
     *            作业组名
     */

    public static void deleteJob(String jobName, String jobGroupName) {
        // 通过作业名和组名获取JobKey
        JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
        QuartzHelp.deleteJob(jobKey);
    }

    /**
     * 判断作业是否在调度器中注册过(使用默认的作业组名)
     * 
     * @param jobName
     *            作业名称
     */
    public static Boolean isJobKeyToScheduler(String jobName) {
        JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
        return QuartzHelp.isJobKeyToScheduler(jobKey);
    }

    /**
     * 判断作业是否在调度器中注册过
     * 
     * @param jobName
     *            作业名
     * @param jobGroupName
     *            作业组名
     */
    public static Boolean isJobKeyToScheduler(String jobName, String jobGroupName) {
        JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
        return QuartzHelp.isJobKeyToScheduler(jobKey);
    }

    /**
     * 
     * 判断触发器是否在调度器中注册过（使用默认的触发器组名）
     * 
     * @param triggerName
     *            触发器名
     */
    public static Boolean isTriggerToScheduler(String triggerName) {
        TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, TRIGGER_GROUP_NAME);
        return QuartzHelp.isTriggerToScheduler(triggerKey);
    }

    /**
     * 
     * 判断触发器是否在调度器中注册过
     * 
     * @param triggerName
     *            触发器名
     * @param triggerGroupName
     *            触发器组名
     */
    public static Boolean isTriggerToScheduler(String triggerName, String triggerGroupName) {
        TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
        return QuartzHelp.isTriggerToScheduler(triggerKey);

    }

    // 列出所有Quartz的作业状态（测试用）
    public static void showlist() throws SchedulerException {
        Scheduler scheduler = new StdSchedulerFactory().getScheduler();

        List<String> jobGroupNames = scheduler.getJobGroupNames();

        for (String string : jobGroupNames) {
            for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.jobGroupEquals(string))) {
                System.out.println();
                System.out.println("-------同一jobKey开始-------");
                List<? extends Trigger> triggersOfJob = scheduler.getTriggersOfJob(jobKey);
                for (Trigger trigger : triggersOfJob) {
                    TriggerKey triggerKey = trigger.getKey();
                    System.out.println(jobKey + ">>>>>>>>>" + triggerKey);
                }
                System.out.println("-------同一jobKey结束-------");
            }
        }

    }

    /**
     * 启动所有定时作业
     */
    public static void startJobs() {
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            sched.start();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 关闭所有定时作业
     */
    public static void shutdownJobs() {
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            if (!sched.isShutdown()) {
                sched.shutdown();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    // 简单封装作为QuartzUtil 的工具类
    private static class QuartzHelp {

        /**
         * 移除一个作业
         * 
         * @param jobKey
         *            作业KEY
         */
        public static void deleteJob(JobKey jobKey) {
            try {

                // 获取调度器
                Scheduler sched = gSchedulerFactory.getScheduler();
                // 删除作业 的同时会删除所有的触发器
                sched.deleteJob(jobKey);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        /**
         * 
         * Description : 暂停触发器 <br>
         * ParamKeys :() <br>
         * return : void
         */
        public static void pauseTrigger(TriggerKey triggerKey) {
            try {
                Scheduler sched = gSchedulerFactory.getScheduler();
                sched.pauseTrigger(triggerKey); // 暂停触发器
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        /**
         * 
         * Description : 恢复触发器 <br>
         * ParamKeys :() <br>
         * return : void
         */
        public static void resumeTrigger(TriggerKey triggerKey) {
            try {
                Scheduler sched = gSchedulerFactory.getScheduler();
                sched.unscheduleJob(triggerKey);// 移除触发器
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        /**
         * 
         * Description : 移除触发器 <br>
         * ParamKeys :() <br>
         * return : void
         */
        public static void unscheduleJob(TriggerKey triggerKey) {
            try {
                Scheduler sched = gSchedulerFactory.getScheduler();
                sched.unscheduleJob(triggerKey);// 移除触发器
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        /**
         * 
         * Description : 创建作业 <br>
         * ParamKeys :() <br>
         * return : JobDetail
         */
        public static JobDetail createJobDetail(JobKey jobKey, Class<? extends Job> jobClass) {
            JobDetail jobDetailt = JobBuilder.newJob(jobClass).withIdentity(jobKey).build();
            return jobDetailt;
        }

        /**
         * 
         * Description : 判断作业是否在调度器中注册过<br>
         * ParamKeys :(JobKey:作业key) <br>
         * return : void
         */
        public static Boolean isJobKeyToScheduler(JobKey jobKey) {
            boolean checkExists = false;
            // 获取调度器
            try {
                Scheduler sched = gSchedulerFactory.getScheduler();
                checkExists = sched.checkExists(jobKey);
            } catch (SchedulerException e) {
                e.printStackTrace();
            } // 通过SchedulerFactory构建Scheduler对象

            return checkExists;
        }

        /**
         * 
         * Description : 判断触发器是否在调度器中注册过<br>
         * ParamKeys :(TriggerKey:触发器key) <br>
         * return : void
         */
        public static Boolean isTriggerToScheduler(TriggerKey triggerKey) {
            boolean checkExists = false;
            // 获取调度器
            try {
                Scheduler sched = gSchedulerFactory.getScheduler();
                checkExists = sched.checkExists(triggerKey);
            } catch (SchedulerException e) {

                e.printStackTrace();
            } // 通过SchedulerFactory构建Scheduler对象

            return checkExists;
        }

        /**
         * 
         * Description : 创建带参数作业 注很少有作业带参数 所以下面使用的都是触发器带参数 <br>
         * ParamKeys :() <br>
         * return : JobDetail
         */
        public static JobDetail createJobDetail(JobKey jobKey, Class<? extends Job> jobClass, Map<String, Object> map) {
            JobDetail jobDetailt = JobBuilder.newJob(jobClass).withIdentity(jobKey).usingJobData(new JobDataMap(map))
                    .build();
            return jobDetailt;
        }

        /**
         * 
         * Description : 创建触发器 <br>
         * ParamKeys :() <br>
         * return : Trigger
         */
        public static Trigger createTrigger(JobKey jobKey, TriggerKey triggerKey, String cron) {
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerKey).startNow().forJob(jobKey)
                    .withSchedule(CronScheduleBuilder.cronSchedule(cron)// 时间
                    ).build();
            return trigger;
        }

        /**
         * 
         * Description : 创建带参数的触发器 <br>
         * ParamKeys :() <br>
         * return : Trigger
         */
        public static Trigger createTrigger(JobKey jobKey, TriggerKey triggerKey, String cron,
                Map<String, Object> map) {
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerKey).startNow().forJob(jobKey)
                    .withSchedule(CronScheduleBuilder.cronSchedule(cron)// 时间
                    ).usingJobData(new JobDataMap(map)).build();
            return trigger;
        }

    }

}