Quartz 任务调度

1.实现一个管理类 ，对计时的程序进行管理

import
 java.text.ParseException;
import
 org.quartz.CronTrigger;
import
 org.quartz.JobDetail;
import
 org.quartz.Scheduler;
import
 org.quartz.SchedulerException;
import
 org.quartz.SchedulerFactory;
import
 org.quartz.impl.StdSchedulerFactory;

/**
 * 定时任务管理类
 */
public
 
class
 QuartzManager {
    //SchedulerFactory 是创建定时任务的工厂
    private
 
static
 SchedulerFactory gSchedulerFactory = 
new
 StdSchedulerFactory();
    private
 
static
 String JOB_GROUP_NAME = 
"EXTJWEB_JOBGROUP_NAME"
;
//默认的任务组
    private
 
static
 String TRIGGER_GROUP_NAME = 
"EXTJWEB_TRIGGERGROUP_NAME"
;
//默认计时器组

    /**
     * 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
     *
     * @param jobName   任务名
     * @param jobClass  任务
     * @param time      时间设置，参考quartz说明文档
     * @throws SchedulerException
     * @throws ParseException
     */
    public
 
static
 
void
 addJob(String jobName, String jobClass, String time) {
        try
 {
            //获取一个Scheduler
            Scheduler sched = gSchedulerFactory.getScheduler();
            //创建一个任务  JobDetail
            /**
             * 参数1  任务名称
             * 参数2  任务组名
             * 参数3  任务执行的类
             */
            JobDetail jobDetail = new
 JobDetail(jobName, JOB_GROUP_NAME, Class.forName(jobClass));
// 任务名，任务组，任务执行类
            // 触发器 CronTrigger
            /**
             * 参数1 任务名称
             * 参数2 触发器组名
             */
            CronTrigger trigger = new
 CronTrigger(jobName, TRIGGER_GROUP_NAME);
// 触发器名,触发器组
            trigger.setCronExpression(time);// 触发器时间设定
            //将 任务  和触发器 装进Scheduler
            sched.scheduleJob(jobDetail, trigger);
            // 启动
            if
 (!sched.isShutdown()){
                sched.start();
            }
        } catch
 (Exception e) {
            e.printStackTrace();
            throw
 
new
 RuntimeException(e);
        }
    }

    /**
     * 添加一个定时任务
     *
     * @param jobName           任务名
     * @param jobGroupName      任务组名
     * @param triggerName       触发器名
     * @param triggerGroupName  触发器组名
     * @param jobClass          任务
     * @param time              时间设置，参考quartz说明文档
     * @throws SchedulerException
     * @throws ParseException
     */
    public
 
static
 
void
 addJob(String jobName, String jobGroupName,
            String triggerName, String triggerGroupName, String jobClass, String time){
        try
 {
            Scheduler sched = gSchedulerFactory.getScheduler();
            JobDetail jobDetail = new
 JobDetail(jobName, jobGroupName, Class.forName(jobClass));
// 任务名，任务组，任务执行类
            // 触发器
            CronTrigger trigger = new
 CronTrigger(triggerName, triggerGroupName);
// 触发器名,触发器组
            trigger.setCronExpression(time);// 触发器时间设定
            sched.scheduleJob(jobDetail, trigger);
        } catch
 (Exception e) {
            e.printStackTrace();
            throw
 
new
 RuntimeException(e);
        }
    }

    /**
     * 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
     *
     * @param jobName
     * @param time
     */
    @SuppressWarnings
(
"unchecked"
)
    public
 
static
 
void
 modifyJobTime(String jobName, String time) {
        try
 {
            Scheduler sched = gSchedulerFactory.getScheduler();
            CronTrigger trigger = (CronTrigger) sched.getTrigger(jobName, TRIGGER_GROUP_NAME);
            if
(trigger == 
null
) {
                return
;
            }
            String oldTime = trigger.getCronExpression();
            if
 (!oldTime.equalsIgnoreCase(time)) {
                JobDetail jobDetail = sched.getJobDetail(jobName, JOB_GROUP_NAME);
                Class objJobClass = jobDetail.getJobClass();
                String jobClass = objJobClass.getName();
                removeJob(jobName);

                addJob(jobName, jobClass, time);
            }
        } catch
 (Exception e) {
            e.printStackTrace();
            throw
 
new
 RuntimeException(e);
        }
    }

    /**
     * 修改一个任务的触发时间
     *
     * @param triggerName
     * @param triggerGroupName
     * @param time
     */
    public
 
static
 
void
 modifyJobTime(String triggerName,
            String triggerGroupName, String time) {
        try
 {
            Scheduler sched = gSchedulerFactory.getScheduler();
            CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerName, triggerGroupName);
            if
(trigger == 
null
) {
                return
;
            }
            String oldTime = trigger.getCronExpression();
            if
 (!oldTime.equalsIgnoreCase(time)) {
                CronTrigger ct = (CronTrigger) trigger;
                // 修改时间
                ct.setCronExpression(time);
                // 重启触发器
                sched.resumeTrigger(triggerName, triggerGroupName);
            }
        } catch
 (Exception e) {
            e.printStackTrace();
            throw
 
new
 RuntimeException(e);
        }
    }

    /**
     * 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
     *
     * @param jobName
     */
    public
 
static
 
void
 removeJob(String jobName) {
        try
 {
            Scheduler sched = gSchedulerFactory.getScheduler();
            sched.pauseTrigger(jobName, TRIGGER_GROUP_NAME);// 停止触发器
            sched.unscheduleJob(jobName, TRIGGER_GROUP_NAME);// 移除触发器
            sched.deleteJob(jobName, JOB_GROUP_NAME);// 删除任务
        } catch
 (Exception e) {
            e.printStackTrace();
            throw
 
new
 RuntimeException(e);
        }
    }

    /**
     * 移除一个任务
     *
     * @param jobName
     * @param jobGroupName
     * @param triggerName
     * @param triggerGroupName
     */
    public
 
static
 
void
 removeJob(String jobName, String jobGroupName,
            String triggerName, String triggerGroupName) {
        try
 {
            Scheduler sched = gSchedulerFactory.getScheduler();
            sched.pauseTrigger(triggerName, triggerGroupName);// 停止触发器
            sched.unscheduleJob(triggerName, triggerGroupName);// 移除触发器
            sched.deleteJob(jobName, jobGroupName);// 删除任务
        } catch
 (Exception e) {
            e.printStackTrace();
            throw
 
new
 RuntimeException(e);
        }
    }

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

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

2.供定时程序调用的接口

import
 org.quartz.Job;

/**
 *
 * 供需要定时的程序调用
 */
public
 
interface
 InitiativeCollector 
extends
 Job {

    /**
     * 获得Job定时时间
     * ----------------------------
     * 【位置说明】：
     *  1 - 秒(0–59)
     *  2 - 分(0–59)
     *  3 - 时(0–23)
     *  4 - 日(1–31)
     *  5 - 月(1–12)
     *  6 - 星期(SUN–SAT or 1–7)
     *  7 - 年(可选, 1970–2099)
     *  --------------------------------
     *  【符号说明】
     *  0 0 12 * * ?---------------在每天中午12：00触发
     *  0 15 10 ? * *---------------每天上午10:15 触发
     *  0 15 10 * * ?---------------每天上午10:15 触发
     *  0 15 10 * * ? *---------------每天上午10:15 触发
     *  0 15 10 * * ? 2005---------------在2005年中的每天上午10:15 触发
     *  0 * 14 * * ?---------------每天在下午2：00至2：59之间每分钟触发一次
     *  0 0/5 14 * * ?---------------每天在下午2：00至2：59之间每5分钟触发一次
     *  0 0/5 14,18 * * ?---------------每天在下午2：00至2：59和6：00至6：59之间的每5分钟触发一次
     *  0 0-5 14 * * ?---------------每天在下午2：00至2：05之间每分钟触发一次
     *  0 10,44 14 ? 3 WED---------------每三月份的星期三在下午2：00和2：44时触发
     *  0 15 10 ? * MON-FRI---------------从星期一至星期五的每天上午10：15触发
     *  0 15 10 15 * ?---------------在每个月的每15天的上午10：15触发
     *  0 15 10 L * ?---------------在每个月的最后一天的上午10：15触发
     *  0 15 10 ? * 6L---------------在每个月的最后一个星期五的上午10：15触发
     *  0 15 10 ? * 6L 2002-2005---------------在2002, 2003, 2004 and 2005年的每个月的最后一个星期五的上午10：15触发
     *  0 15 10 ? * 6#3---------------在每个月的第三个星期五的上午10:15触发
     *  0 0 12 1/5 * ?---------------从每月的第一天起每过5天的中午12:00时触发
     *  0 11 11 11 11 ?---------------在每个11月11日的上午11：11时触发
     * @return
     */
    String getTimer();

}

3.需要调用时只需要实现接口传入所需启动的时间即可 和复写 Job中的execute()方法执行所需的操作 。

import
 org.quartz.JobExecutionContext;
import
 org.quartz.JobExecutionException;

public
 
class
 Collector 
implements
 InitiativeCollector {

    @Override
    public
 String getTimer() {
        //每周日的晚上23:30转上周的周统计数据
        return
 
"0 30 23 ? * SUN"
;
    }

    @Override
    public
 
void
 execute(JobExecutionContext arg0) 
throws
 JobExecutionException {
    <span style="white-space:pre"
>  </span>
// 执行操作
    }


}

4.调用addJob

void
 addJob(String name,InitiativeCollector collector){
<span style="white-space:pre"
>      </span>QuartzManager.addJob(name, collector.getClass().getName(), collector.getTimer());
}