任务调度开源框架Quartz动态添加、修改和删除定时任务

Quartz 是个开源的作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。Quartz框架包含了调度器监听、作业和触发器监听。你可以配置作业和触发器监听为全局监听或者是特定于作业和触发器的监听。Quartz 允许开发人员根据时间间隔（或天）来调度作业。它实现了作业和触发器的多对多关系，还能把多个作业与不同的触发器关联。整合了 Quartz 的应用程序可以重用来自不同事件的作业，还可以为一个事件组合多个作业。并且还能和spring配置整合使用。Quartz在功能上远远超越了JDK自带的Timer，很好很强大！好啦，直接上代码：

package com.zoki.module.timer;
import ch.qos.logback.classic.Logger;
import java.util.Date;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.LoggerFactory;
/**
 * 定时器任务调度管理器
 *
 * @author zhoukai
 */
public class QuartzManager {
    private final String jobGroupName;
    private final String triggerGroupName;
    private Scheduler sched;
    private final static SchedulerFactory sf = new StdSchedulerFactory();
    private final static Map<String, QuartzManager> instanceMap = new ConcurrentHashMap<>();
    private final static Logger logger = (Logger) LoggerFactory.getLogger(QuartzManager.class);
    /**
     * 构造方法，外部不能实例化
     *
     * @param jobGroupName 工作组名
     * @param triggerGroupName 触发器组名
     */
    private QuartzManager(String jobGroupName, String triggerGroupName) {
        this.jobGroupName = jobGroupName;
        this.triggerGroupName = triggerGroupName;
    }
    /**
     * 获取调度器
     *
     * @return 定时调度器
     * @throws SchedulerException 调度器内部执行异常
     */
    private Scheduler getScheduler() throws SchedulerException {
        if (sched == null) {
            sched = sf.getScheduler();
            //sched.getListenerManager().addTriggerListener(new QuartzTriggerListener());
            //sched.getListenerManager().addSchedulerListener(new QuartzSchedulerListener(sched));
        }
        return sched;
    }
    /**
     * 获取一个定时调度管理器
     *
     * @param jobGroupName 工作组名
     * @param triggerGroupName 触发器组名
     * @return 定时调度管理器
     */
    public static QuartzManager getInstance(String jobGroupName, String triggerGroupName) {
        String instanceKey = jobGroupName + "_" + triggerGroupName;
        if (instanceMap.containsKey(instanceKey)) {
            return instanceMap.get(instanceKey);
        }
        QuartzManager manager = new QuartzManager(jobGroupName, triggerGroupName);
        instanceMap.put(instanceKey, manager);
        return manager;
    }
    /**
     * 获取一个定时调度管理器
     *
     * @param groupName 工作组名和触发器组名相同
     * @return 定时调度管理器
     */
    public static QuartzManager getInstance(String groupName) {
        return getInstance(groupName, groupName);
    }
    /**
     * 关闭调度器
     *
     * @param waitForJobsToComplete 是否等候所有工作被调度完成后再关闭
     */
    public void shutdown(boolean waitForJobsToComplete) {
        String instanceKey = jobGroupName + "_" + triggerGroupName;
        if (instanceMap.containsKey(instanceKey)) {
            QuartzManager manager = instanceMap.get(instanceKey);
            if (manager != null && manager.sched != null) {
                try {
                    manager.sched.shutdown(waitForJobsToComplete);
                } catch (SchedulerException ex) {
                    logger.debug(ex.getLocalizedMessage(), ex);
                }
            }
        }
    }
    /**
     * 关闭调度器
     */
    public void shutdown() {
        shutdown(false);
    }
    
    /**
     * 添加一个调度任务
     *
     * @param jobName 任务名
     * @param cls 任务类型
     * @param start 任务执行的开始时间，null表示立刻执行
     * @param end 任务执行的结束时间，null表示任务在执行repeat次数后自动结束
     * @param jobBindData 绑定到job中的数据，可为null
     * @param intervalType 任务执行时间间隔类型，1、毫秒，2、秒，3、分，4、小时，默认为2
     * @param intervalValue 任务执行时间间隔
     * @param repeat 任务执行次数，0表示执行一次，实际执行次数为此值+1
     * @throws SchedulerException
     */
    public void addJob(String jobName, Class cls, Date start, Date end, Map<String, Object> jobBindData, int intervalType, long intervalValue, int repeat) throws SchedulerException {
        JobDetail jobDetail = JobBuilder.newJob(cls).withIdentity(jobName, jobGroupName).build();
        if (jobBindData != null) {
            for (Entry<String, Object> entry : jobBindData.entrySet()) {
                jobDetail.getJobDataMap().put(entry.getKey(), entry.getValue());
            }
        }
        SimpleScheduleBuilder simpleScheduleBuilder = SimpleScheduleBuilder.simpleSchedule();
        switch (intervalType) {
            case 1:
                //毫秒
                simpleScheduleBuilder.withIntervalInMilliseconds(intervalValue);
                break;
            case 3:
                //分
                simpleScheduleBuilder.withIntervalInMinutes((int) intervalValue);
                break;
            case 4:
                //时
                simpleScheduleBuilder.withIntervalInHours((int) intervalValue);
                break;
            default:
                //秒
                simpleScheduleBuilder.withIntervalInSeconds((int) intervalValue);
                break;
        }
        if(repeat >= 0) {
            simpleScheduleBuilder.withRepeatCount(repeat);
        }
        TriggerBuilder<Trigger> builder = TriggerBuilder.newTrigger()
                .withIdentity(jobName, triggerGroupName);
        if (start == null) {
            builder.startNow();
        } else {
            builder.startAt(start);
        }
        if (end != null) {
            builder.endAt(end);
        }
        Trigger trigger = builder.withSchedule(simpleScheduleBuilder).build();
        Scheduler scheduler = getScheduler();
        scheduler.scheduleJob(jobDetail, trigger);
        if (!scheduler.isShutdown()) {
            scheduler.start();
        }
    }
    
    /**
     * 添加一个调度任务，在start时间执行一次
     * @param jobName 任务名
     * @param cls 任务类型
     * @param start 任务执行的开始时间，null表示立刻执行
     * @param end 任务执行的结束时间，null表示任务在执行repeat次数后自动结束
     * @param jobBindData 绑定到job中的数据，可为null
     * @throws SchedulerException
     */
    public void addJob(String jobName, Class cls, Date start , Date end, Map<String, Object> jobBindData) throws SchedulerException {
        this.addJob(jobName, cls, start, end, jobBindData, 2, 1, 0);
    }
    
    /**
     * 添加一个调度任务，在start时间执行一次
     * @param jobName 任务名
     * @param cls 任务类型
     * @param start 任务执行的开始时间，null表示立刻执行
     * @param jobBindData 绑定到job中的数据，可为null
     * @throws SchedulerException
     */
    public void addJob(String jobName, Class cls, Date start, Map<String, Object> jobBindData) throws SchedulerException {
        this.addJob(jobName, cls, start, null, jobBindData);
    }
    /**
     * 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
     *
     * @param jobName 任务名
     * @param cls
     * @param time 时间设置，参考quartz说明文档
     * @throws SchedulerException 调度器内部执行异常
     */
    public void addJob(String jobName, Class cls, String time) throws SchedulerException {
        JobDetail jobDetail = JobBuilder.newJob(cls).withIdentity(jobName, jobGroupName).build();
        CronTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(jobName, triggerGroupName)//触发器名,触发器组
                .withSchedule(CronScheduleBuilder.cronSchedule(time))
                .build();
        Scheduler scheduler = getScheduler();
        scheduler.scheduleJob(jobDetail, trigger);
        if (!scheduler.isShutdown()) {
            scheduler.start();
        }
    }
    /**
     * 移除一个任务
     *
     * @param triggerKey 触发器键
     * @param jobKey 工作任务键
     * @throws SchedulerException 调度器内部执行异常
     */
    public void removeJob(TriggerKey triggerKey, JobKey jobKey) throws SchedulerException {
        Scheduler scheduler = getScheduler();
        scheduler.pauseTrigger(triggerKey);
        scheduler.unscheduleJob(triggerKey);
        scheduler.deleteJob(jobKey);
    }
    /**
     * 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
     *
     * @param jobName 工作任务名
     * @throws SchedulerException 调度器内部执行异常
     */
    public void removeJob(String jobName) throws SchedulerException {
        TriggerKey triggerKey = new TriggerKey(jobName, triggerGroupName);
        JobKey jobKey = new JobKey(jobName, jobGroupName);
        removeJob(triggerKey, jobKey);
    }
}

[java] view plain copy

在CODE上查看代码片
  1. /**
  2.  * @Description: 
  3.  *
  4.  * @Title: QuartzManager.java
  5.  * @Package com.joyce.quartz
  6.  * @Copyright: Copyright (c) 2014
  7.  *
  8.  * @author Comsys-LZP
  9.  * @date 2014-6-26 下午03:15:52
  10.  * @version V2.0
  11.  */
  12. package com.joyce.quartz;
  14. import org.quartz.CronTrigger;
  15. import org.quartz.JobDetail;
  16. import org.quartz.Scheduler;
  17. import org.quartz.SchedulerFactory;
  18. import org.quartz.impl.StdSchedulerFactory;
  20. /**
  21.  * @Description: 定时任务管理类
  22.  * 
  23.  * @ClassName: QuartzManager
  24.  * @Copyright: Copyright (c) 2014
  25.  * 
  26.  * @author Comsys-LZP
  27.  * @date 2014-6-26 下午03:15:52
  28.  * @version V2.0
  29.  */
  30. public class QuartzManager {
  31.     private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();
  32.     private static String JOB_GROUP_NAME = “EXTJWEB_JOBGROUP_NAME”;
  33.     private static String TRIGGER_GROUP_NAME = “EXTJWEB_TRIGGERGROUP_NAME”;
  35.     /**
  36.      * @Description: 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
  37.      * 
  38.      * @param jobName
  39.      *            任务名
  40.      * @param cls
  41.      *            任务
  42.      * @param time
  43.      *            时间设置，参考quartz说明文档
  44.      * 
  45.      * @Title: QuartzManager.java
  46.      * @Copyright: Copyright (c) 2014
  47.      * 
  48.      * @author Comsys-LZP
  49.      * @date 2014-6-26 下午03:47:44
  50.      * @version V2.0
  51.      */
  52.     @SuppressWarnings(“unchecked”)
  53.     public static void addJob(String jobName, Class cls, String time) {
  54.         try {
  55.             Scheduler sched = gSchedulerFactory.getScheduler();
  56.             JobDetail jobDetail = new JobDetail(jobName, JOB_GROUP_NAME, cls);// 任务名，任务组，任务执行类
  57.             // 触发器
  58.             CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);// 触发器名,触发器组
  59.             trigger.setCronExpression(time);// 触发器时间设定
  60.             sched.scheduleJob(jobDetail, trigger);
  61.             // 启动
  62.             if (!sched.isShutdown()) {
  63.                 sched.start();
  64.             }
  65.         } catch (Exception e) {
  66.             throw new RuntimeException(e);
  67.         }
  68.     }
  70.     /**
  71.      * @Description: 添加一个定时任务
  72.      * 
  73.      * @param jobName
  74.      *            任务名
  75.      * @param jobGroupName
  76.      *            任务组名
  77.      * @param triggerName
  78.      *            触发器名
  79.      * @param triggerGroupName
  80.      *            触发器组名
  81.      * @param jobClass
  82.      *            任务
  83.      * @param time
  84.      *            时间设置，参考quartz说明文档
  85.      * 
  86.      * @Title: QuartzManager.java
  87.      * @Copyright: Copyright (c) 2014
  88.      * 
  89.      * @author Comsys-LZP
  90.      * @date 2014-6-26 下午03:48:15
  91.      * @version V2.0
  92.      */
  93.     @SuppressWarnings(“unchecked”)
  94.     public static void addJob(String jobName, String jobGroupName,
  95.             String triggerName, String triggerGroupName, Class jobClass,
  96.             String time) {
  97.         try {
  98.             Scheduler sched = gSchedulerFactory.getScheduler();
  99.             JobDetail jobDetail = new JobDetail(jobName, jobGroupName, jobClass);// 任务名，任务组，任务执行类
  100.             // 触发器
  101.             CronTrigger trigger = new CronTrigger(triggerName, triggerGroupName);// 触发器名,触发器组
  102.             trigger.setCronExpression(time);// 触发器时间设定
  103.             sched.scheduleJob(jobDetail, trigger);
  104.         } catch (Exception e) {
  105.             throw new RuntimeException(e);
  106.         }
  107.     }
  109.     /**
  110.      * @Description: 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
  111.      * 
  112.      * @param jobName
  113.      * @param time
  114.      * 
  115.      * @Title: QuartzManager.java
  116.      * @Copyright: Copyright (c) 2014
  117.      * 
  118.      * @author Comsys-LZP
  119.      * @date 2014-6-26 下午03:49:21
  120.      * @version V2.0
  121.      */
  122.     @SuppressWarnings(“unchecked”)
  123.     public static void modifyJobTime(String jobName, String time) {
  124.         try {
  125.             Scheduler sched = gSchedulerFactory.getScheduler();
  126.             CronTrigger trigger = (CronTrigger) sched.getTrigger(jobName,TRIGGER_GROUP_NAME);
  127.             if (trigger == null) {
  128.                 return;
  129.             }
  130.             String oldTime = trigger.getCronExpression();
  131.             if (!oldTime.equalsIgnoreCase(time)) {
  132.                 JobDetail jobDetail = sched.getJobDetail(jobName,JOB_GROUP_NAME);
  133.                 Class objJobClass = jobDetail.getJobClass();
  134.                 removeJob(jobName);
  135.                 addJob(jobName, objJobClass, time);
  136.             }
  137.         } catch (Exception e) {
  138.             throw new RuntimeException(e);
  139.         }
  140.     }
  142.     /**
  143.      * @Description: 修改一个任务的触发时间
  144.      * 
  145.      * @param triggerName
  146.      * @param triggerGroupName
  147.      * @param time
  148.      * 
  149.      * @Title: QuartzManager.java
  150.      * @Copyright: Copyright (c) 2014
  151.      * 
  152.      * @author Comsys-LZP
  153.      * @date 2014-6-26 下午03:49:37
  154.      * @version V2.0
  155.      */
  156.     public static void modifyJobTime(String triggerName,
  157.             String triggerGroupName, String time) {
  158.         try {
  159.             Scheduler sched = gSchedulerFactory.getScheduler();
  160.             CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerName,triggerGroupName);
  161.             if (trigger == null) {
  162.                 return;
  163.             }
  164.             String oldTime = trigger.getCronExpression();
  165.             if (!oldTime.equalsIgnoreCase(time)) {
  166.                 CronTrigger ct = (CronTrigger) trigger;
  167.                 // 修改时间
  168.                 ct.setCronExpression(time);
  169.                 // 重启触发器
  170.                 sched.resumeTrigger(triggerName, triggerGroupName);
  171.             }
  172.         } catch (Exception e) {
  173.             throw new RuntimeException(e);
  174.         }
  175.     }
  177.     /**
  178.      * @Description: 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
  179.      * 
  180.      * @param jobName
  181.      * 
  182.      * @Title: QuartzManager.java
  183.      * @Copyright: Copyright (c) 2014
  184.      * 
  185.      * @author Comsys-LZP
  186.      * @date 2014-6-26 下午03:49:51
  187.      * @version V2.0
  188.      */
  189.     public static void removeJob(String jobName) {
  190.         try {
  191.             Scheduler sched = gSchedulerFactory.getScheduler();
  192.             sched.pauseTrigger(jobName, TRIGGER_GROUP_NAME);// 停止触发器
  193.             sched.unscheduleJob(jobName, TRIGGER_GROUP_NAME);// 移除触发器
  194.             sched.deleteJob(jobName, JOB_GROUP_NAME);// 删除任务
  195.         } catch (Exception e) {
  196.             throw new RuntimeException(e);
  197.         }
  198.     }
  200.     /**
  201.      * @Description: 移除一个任务
  202.      * 
  203.      * @param jobName
  204.      * @param jobGroupName
  205.      * @param triggerName
  206.      * @param triggerGroupName
  207.      * 
  208.      * @Title: QuartzManager.java
  209.      * @Copyright: Copyright (c) 2014
  210.      * 
  211.      * @author Comsys-LZP
  212.      * @date 2014-6-26 下午03:50:01
  213.      * @version V2.0
  214.      */
  215.     public static void removeJob(String jobName, String jobGroupName,
  216.             String triggerName, String triggerGroupName) {
  217.         try {
  218.             Scheduler sched = gSchedulerFactory.getScheduler();
  219.             sched.pauseTrigger(triggerName, triggerGroupName);// 停止触发器
  220.             sched.unscheduleJob(triggerName, triggerGroupName);// 移除触发器
  221.             sched.deleteJob(jobName, jobGroupName);// 删除任务
  222.         } catch (Exception e) {
  223.             throw new RuntimeException(e);
  224.         }
  225.     }
  227.     /**
  228.      * @Description:启动所有定时任务
  229.      * 
  230.      * 
  231.      * @Title: QuartzManager.java
  232.      * @Copyright: Copyright (c) 2014
  233.      * 
  234.      * @author Comsys-LZP
  235.      * @date 2014-6-26 下午03:50:18
  236.      * @version V2.0
  237.      */
  238.     public static void startJobs() {
  239.         try {
  240.             Scheduler sched = gSchedulerFactory.getScheduler();
  241.             sched.start();
  242.         } catch (Exception e) {
  243.             throw new RuntimeException(e);
  244.         }
  245.     }
  247.     /**
  248.      * @Description:关闭所有定时任务
  249.      * 
  250.      * 
  251.      * @Title: QuartzManager.java
  252.      * @Copyright: Copyright (c) 2014
  253.      * 
  254.      * @author Comsys-LZP
  255.      * @date 2014-6-26 下午03:50:26
  256.      * @version V2.0
  257.      */
  258.     public static void shutdownJobs() {
  259.         try {
  260.             Scheduler sched = gSchedulerFactory.getScheduler();
  261.             if (!sched.isShutdown()) {
  262.                 sched.shutdown();
  263.             }
  264.         } catch (Exception e) {
  265.             throw new RuntimeException(e);
  266.         }
  267.     }
  268. }

以上就是quartz任务调度对于任务的常用操作，封装起来以便在外部调用！这样我们就需要任务的执行了：

[java] view plain copy

在CODE上查看代码片
  1. /**
  2.  * @Description: 
  3.  *
  4.  * @Title: QuartzJob.java
  5.  * @Package com.joyce.quartz
  6.  * @Copyright: Copyright (c) 2014
  7.  *
  8.  * @author Comsys-LZP
  9.  * @date 2014-6-26 下午03:37:11
  10.  * @version V2.0
  11.  */
  12. package com.joyce.quartz;
  14. import java.text.SimpleDateFormat;
  15. import java.util.Date;
  17. import org.quartz.Job;
  18. import org.quartz.JobExecutionContext;
  19. import org.quartz.JobExecutionException;
  21. /**
  22.  * @Description: 任务执行类
  23.  *
  24.  * @ClassName: QuartzJob
  25.  * @Copyright: Copyright (c) 2014
  26.  *
  27.  * @author Comsys-LZP
  28.  * @date 2014-6-26 下午03:37:11
  29.  * @version V2.0
  30.  */
  31. public class QuartzJob implements Job {
  33.     @Override
  34.     public void execute(JobExecutionContext arg0) throws JobExecutionException {
  35.         System.out.println(new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”).format(new Date())+ “★★★★★★★★★★★”);
  36.     }
  37. }

Ok，我们来测试一下：

[java] view plain copy

在CODE上查看代码片派生到我的代码片

  1. /**
  2.  * @Description: 
  3.  *
  4.  * @Title: QuartzTest.java
  5.  * @Package com.joyce.quartz.main
  6.  * @Copyright: Copyright (c) 2014
  7.  *
  8.  * @author Comsys-LZP
  9.  * @date 2014-6-26 下午03:35:05
  10.  * @version V2.0
  11.  */
  12. package com.joyce.quartz.main;
  14. import com.joyce.quartz.QuartzJob;
  15. import com.joyce.quartz.QuartzManager;
  17. /**
  18.  * @Description: 测试类
  19.  *
  20.  * @ClassName: QuartzTest
  21.  * @Copyright: Copyright (c) 2014
  22.  *
  23.  * @author Comsys-LZP
  24.  * @date 2014-6-26 下午03:35:05
  25.  * @version V2.0
  26.  */
  27. public class QuartzTest {
  28.     public static void main(String[] args) {
  29.         try {
  30.             String job_name = “动态任务调度”;
  31.             System.out.println(“【系统启动】开始(每1秒输出一次)…”);
  32.             QuartzManager.addJob(job_name, QuartzJob.class, “0/1 * * * * ?”);
  34.             Thread.sleep(5000);
  35.             System.out.println(“【修改时间】开始(每2秒输出一次)…”);
  36.             QuartzManager.modifyJobTime(job_name, “10/2 * * * * ?”);
  37.             Thread.sleep(6000);
  38.             System.out.println(“【移除定时】开始…”);
  39.             QuartzManager.removeJob(job_name);
  40.             System.out.println(“【移除定时】成功”);
  42.             System.out.println(“【再次添加定时任务】开始(每10秒输出一次)…”);
  43.             QuartzManager.addJob(job_name, QuartzJob.class, “*/10 * * * * ?”);
  44.             Thread.sleep(60000);
  45.             System.out.println(“【移除定时】开始…”);
  46.             QuartzManager.removeJob(job_name);
  47.             System.out.println(“【移除定时】成功”);
  48.         } catch (Exception e) {
  49.             e.printStackTrace();
  50.         }
  51.     }
  52. }

运行一下，看看效果图：

Post Views: 414