Quartz-2.2.1 调度框架实现新增、修改、删除定时任务

如果需要对 Quartz 任务调度框架的相关 API 进行了解的，可以参看本篇相对简单的博客:

http://blog.youkuaiyun.com/hello_world_qwp/article/details/79021281

以下为 Java 项目中使用 Quartz-2.2.1 任务调度框架时，实现参数的传递，以及定时任务的 新增、修改、删除操作：

Job :

package com.etc.clear.data.job;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 定义导出数据任务
 * <p>
 * 
 * @ClassName : ExpDataJob
 *            </p>
 *            <p>
 * @Description : TODO
 *              </p>
 *              <p>
 * @Author : HuaZai
 *         </p>
 *         <p>
 * @ContactInformation : 1461522031@qq.com/huazai6789@aliyun.com
 *                     </p>
 * 
 * @Date : 2018年1月4日 下午4:05:10
 * @Version : V1.0.0
 *
 */
public class ExpDataJob implements Job {

    private static final Logger log = LoggerFactory.getLogger(ExpDataJob.class);

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {

        log.info("============= 进入数据《导出》阶段 ...."+context.getJobDetail().getJobDataMap().getString("param"));
    }


}

Utils :

package com.etc.clear.data.utils;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.etc.clear.img.utils.ImgQuartzUtils;

/**
 * 数据任务调度工具类（增、刪、改、查）
 * <p>
 * 
 * @ClassName : DataQuartzUtils
 *            </p>
 *            <p>
 * @Description : TODO
 *              </p>
 *              <p>
 * @Author : HuaZai
 *         </p>
 *         <p>
 * @ContactInformation : 1461522031@qq.com/huazai6789@aliyun.com
 *                     </p>
 * 
 * @Date : 2018年1月5日 下午4:37:08
 * @Version : V1.0.0
 *
 */
public class DataQuartzUtils {

    // 定义变量
    private static final String JOB_GROUP_NAME = "JOB_DATAJOBGROUP_NAME"; // 任务组
    private static final String TRIGGER_GROUP_NAME = "TRIGGER_DATATRIGGERGROUP_NAME"; // 触发器组
    private static final Logger log = LoggerFactory.getLogger(ImgQuartzUtils.class);// 日志打印
    private static SchedulerFactory factory = new StdSchedulerFactory(); // 初始化调度容器

    /**
     * 新增定时任务
     * <p>
     * 
     * @Title : addJobToSecheduler
     *        </p>
     *        <p>
     * @Description : TODO
     *              </p>
     *              <p>
     * @Author : HuaZai
     *         </p>
     * 
     * @Date : 2018年1月10日 上午11:54:53
     */
    public static void addJobToSecheduler(String jobName, String triggerName, Class<? extends Job> jobClass,
            String cron) {
        try {

            // 通过SchedulerFactory工厂构建Scheduler容器对象
            Scheduler scheduler = factory.getScheduler();

            // 构建一个jobDetail 作业实例
            JobDetail detail = JobBuilder.newJob(jobClass) // 构建一个新任务
                    .withIdentity(jobName, JOB_GROUP_NAME) // 给新任务起名和分组
                    .build(); // 绑定作业

            // 通过 JobDataMap 实现参数传递
            detail.getJobDataMap().put("param", "huazai");

            // 构建一个 CronSchedule 的触发器
            Trigger trigger = TriggerBuilder.newTrigger()// 创建一个新的TriggerBuilder
                    .withIdentity(triggerName, TRIGGER_GROUP_NAME)// 给触发器起名和分组
                    .startNow()// 立即执行
                    .withSchedule(
                            // 定义触发规则
                            CronScheduleBuilder.cronSchedule(cron))
                    .build();// 绑定出发规则

            // 将job任务和trigger触发器添加到Scheduler容器中
            scheduler.scheduleJob(detail, trigger);

        } catch (Exception e) {
            e.printStackTrace();
            log.info(e.toString());
        }
    }

    /**
     * 修改一个任务的触发时间
     * <p>
     * 
     * @Title : updateJobToSecheduler
     *        </p>
     *        <p>
     * @Description : TODO
     *              </p>
     *              <p>
     * @Author : HuaZai
     *         </p>
     * 
     * @Date : 2018年1月10日 下午2:30:35
     */
    public static void updateJobToSecheduler(String jobName, String triggerName, String cron) {

        try {
            // 通过SchedulerFactory工厂构建Scheduler容器对象
            Scheduler scheduler = factory.getScheduler();

            // 获取指定任务的触发规则
            TriggerKey key = TriggerKey.triggerKey(triggerName, TRIGGER_GROUP_NAME);
            CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(key);
            if (cronTrigger != null) {
                // 一、先在任务组中删除任务，再重新添加一个新的任务
               /*
               JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
               JobDetail jobDetail = scheduler.getJobDetail(jobKey); 
               Class<? extends Job> jobClass = jobDetail.getJobClass(); // 移除指定任务
               removeJobToScheduler(jobName, triggerName); // 新增任务
               addJobToSecheduler(jobName, triggerName, jobClass, cron);
               */


                // 二、重新构建一个触发器
                // 构建一个 CronSchedule 的触发器
                Trigger trigger = TriggerBuilder.newTrigger()// 创建一个新的TriggerBuilder
                        .withIdentity(triggerName, TRIGGER_GROUP_NAME)// 给触发器起名和分组
                        .startNow()// 立即执行
                        .withSchedule(
                                // 定义触发规则
                                CronScheduleBuilder.cronSchedule(cron))
                        .build();// 绑定出发规则
                // 调用 rescheduleJob 实现任务触发规则的重置
                scheduler.rescheduleJob(key, trigger);

            } else {
                log.info("============= 未找到修改对象  =============");
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.info(e.toString());
        }
    }

    /**
     * 移除指定任务
     * <p>
     * 
     * @Title : removeJobToScheduler
     *        </p>
     *        <p>
     * @Description : TODO
     *              </p>
     *              <p>
     * @Author : HuaZai
     *         </p>
     * 
     * @Date : 2018年1月10日 下午3:30:56
     */
    public static void removeJobToScheduler(String jobName, String triggerName) {

        try {
            // 通过SchedulerFactory工厂构建Scheduler容器对象
            Scheduler scheduler = factory.getScheduler();
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, TRIGGER_GROUP_NAME);

            // 注意：移除指定任务前，需要先停止，然后再从Scheduler容器中移除，最后在任务组中删除该任务
            scheduler.pauseTrigger(triggerKey);// 暂停触发器
            scheduler.unscheduleJob(triggerKey);// 移除触发器
            JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
            scheduler.deleteJob(jobKey);// 删除指定任务

            // 模拟数据处理
            Thread.sleep(3000);

        } catch (Exception e) {
            e.printStackTrace();
            log.info(e.toString());
        }
    }

    /**
     * 启动任务
     * <p>
     * 
     * @Title : startJobToScheduler
     *        </p>
     *        <p>
     * @Description : TODO
     *              </p>
     *              <p>
     * @Author : HuaZai
     *         </p>
     * 
     * @Date : 2018年1月10日 下午4:43:11
     */
    public static void startJobToScheduler() {
        try {
            // 通过SchedulerFactory工厂构建Scheduler容器对象
            Scheduler scheduler = factory.getScheduler();
            if (!scheduler.isShutdown()) {
                scheduler.start();// 启动任务
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 关闭任务
     * <p>
     * 
     * @Title : shutdowJobToScheduler
     *        </p>
     *        <p>
     * @Description : TODO
     *              </p>
     *              <p>
     * @Author : HuaZai
     *         </p>
     * 
     * @Date : 2018年1月10日 下午4:44:55
     */
    public static void shutdowJobToScheduler() {
        try {
            // 通过SchedulerFactory工厂构建Scheduler容器对象
            Scheduler scheduler = factory.getScheduler();
            scheduler.shutdown(true);// 关闭任务
            log.info("============= 任务关闭成功  =============");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

Commons :

package com.etc.clear.data.common;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.etc.clear.data.job.ExpDataJob;
import com.etc.clear.data.utils.DataQuartzUtils;

/**
 * 初始化数据清理任务
 * <p>
 * 
 * @ClassName : InitDataQuartzCommon
 *            </p>
 *            <p>
 * @Description : TODO
 *              </p>
 *              <p>
 * @Author : HuaZai
 *         </p>
 *         <p>
 * @ContactInformation : 1461522031@qq.com/huazai6789@aliyun.com
 *                     </p>
 * 
 * @Date : 2018年1月4日 下午3:45:09
 * @Version : V1.0.0
 *
 */
public class InitDataQuartzCommon {

    private static String JOB_NAME = "ExpDataJob";
    private static String TRIGGER_NAME = "ExpDataTrigger";
    private static String EXP_DATA_CRON_START = "0/3 * * * * ?";
    private static String EXP_DATA_CRON_UPDATE = "0/5 * * * * ?";
    private static Logger log = LoggerFactory.getLogger(InitDataQuartzCommon.class);

    /**
     * 初始化数据清除任务
     * <p>
     * 
     * @Title : startClearData
     *        </p>
     *        <p>
     * @Description : TODO
     *              </p>
     *              <p>
     * @Author : HuaZai
     *         </p>
     * 
     * @Date : 2018年1月10日 下午5:00:09
     */
    public void startClearData() {

        try {

            log.info("============= 构建并添加新任务  =============");
            DataQuartzUtils.addJobToSecheduler(JOB_NAME, TRIGGER_NAME, ExpDataJob.class, EXP_DATA_CRON_START);

            log.info("============= 启动定时任务  =============");
            DataQuartzUtils.startJobToScheduler();

            Thread.sleep(9000);// 模拟数据处理时间

            log.info("============= 修改任务时间  =============");
            DataQuartzUtils.updateJobToSecheduler(JOB_NAME, TRIGGER_NAME, EXP_DATA_CRON_UPDATE);

            Thread.sleep(10000);// 模拟数据处理时间

            log.info("============= 移除定时任务  =============");
            DataQuartzUtils.removeJobToScheduler(JOB_NAME, TRIGGER_NAME);

            log.info("============= 关闭定时任务  =============");
            DataQuartzUtils.shutdowJobToScheduler();

            Thread.sleep(5000);// 模拟关闭定时器

            log.info("============= 任务周期结束  =============");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Main :

package com.etc.clear;

import com.etc.clear.data.common.InitDataQuartzCommon;

/**
 * 程序启动入口/调用任务的类
 * <p>
 * 
 * @ClassName : ClsMain
 *            </p>
 *            <p>
 * @Description : TODO
 *              </p>
 *              <p>
 * @Author : HuaZai
 *         </p>
 *         <p>
 * @ContactInformation : 1461522031@qq.com/huazai6789@aliyun.com
 *                     </p>
 * 
 * @Date : 2018年1月3日 下午1:21:56
 * 
 * @Version : V1.0.0
 *
 */
public class ApplicationMain {

    public static void main(String[] args) {

        // 初始化清理数据任务
        InitDataQuartzCommon dataQuartzCommon = new InitDataQuartzCommon();
        // 启动数据清理任务
         dataQuartzCommon.startClearData();

    }

}

运行效果如下图：

本实例源码下载地址：
http://download.youkuaiyun.com/download/hello_world_qwp/10208195