quartz使用(一)

使用quartz框架，开发定时任务，简单用法比较方便。写一个job,一个trigger,然后运行就ＯＫ了。例子以quartz-2.2.2的jar包

比如：　

package com.xsoft.job;

import java.util.Date;

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

/**
 * <p>
 * This is just a simple job that says "Hello" to the world.
 * </p>
 *
 * @author Bill Kratzer
 */
public class HelloJob implements Job {

    private static Logger _log = LoggerFactory.getLogger(HelloJob.class);

    /**
     * <p>
     * Empty constructor for job initilization
     * </p>
     * <p>
     * Quartz requires a public empty constructor so that the
     * scheduler can instantiate the class whenever it needs.
     * </p>
     */
    public HelloJob() {
    }

    /**
     * <p>
     * Called by the <code>{@link org.quartz.Scheduler}</code> when a
     * <code>{@link org.quartz.Trigger}</code> fires that is associated with
     * the <code>Job</code>.
     * </p>
     *
     * @throws JobExecutionException
     *             if there is an exception while executing the job.
     */
    public void execute(JobExecutionContext context)
        throws JobExecutionException {

        // Say Hello to the World and display the date/time
        _log.info("@@Hello World!@@ ---- " + new Date());
    }

}

package com.xsoft.task;

import static org.quartz.CronScheduleBuilder.cronSchedule;
import static org.quartz.DateBuilder.evenMinuteDate;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;
 
import java.util.Date;

import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Matcher;
import org.quartz.Scheduler;
import org.quartz.impl.matchers.KeyMatcher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.xsoft.core.quartz.QuartzScheduleMgr;
import com.xsoft.job.HelloJob;

public class QuartzSchedule {
 /**
     *
     * @throws Exception
     */
    public void run() throws Exception {
        Logger log = LoggerFactory.getLogger(QuartzSchedule.class);
 
        log.info("------- Initializing ----------------------");
 
        // First we must get a reference to a scheduler
        //从调度管理器中获取调度对象
        Scheduler sched = QuartzScheduleMgr.getInstanceScheduler();
        log.info("------- Initialization Complete -----------");
 
        // computer a time that is on the next round minute
        Date runTime = evenMinuteDate(new Date());
 
        log.info("------- Scheduling Job  -------------------");
 
        // define the job and tie it to our HelloJob class
        //创建相关的job信息
        JobDetail job = newJob(HelloJob.class)
            .withIdentity("jobtest1", "grouptest1")
            .build();
        
        // Trigger the job to run on the next round minute
        //创建一个触发器的名称
        CronTrigger trigger =  newTrigger()
              .withIdentity("triggertest1", "grouptest1")
              .withSchedule(cronSchedule("0/20 * * * * ?"))
              .startNow()
              .build();
        
        //job 级别　listener
        Matcher<JobKey> matcher = KeyMatcher.keyEquals(job.getKey().jobKey("jobtest1","grouptest1"));
       
       // JobListener listener = new MyJobListener();
       // sched.getListenerManager().addJobListener(listener, matcher);
       
        // Tell quartz to schedule the job using our trigger
        //设置调度相关的Job
        sched.scheduleJob(job, trigger);
        log.info(job.getKey() + " will run at: " + runTime); 
 
        // Start up the scheduler (nothing can actually run until the
        // scheduler has been started)
        //启动调度任务
        sched.start();
    }
 
    public static void main(String[] args) throws Exception {
     QuartzSchedule example = new QuartzSchedule();
        example.run();
    }
}

package com.xsoft.core.quartz;

import java.util.Date; 
import java.util.List; 
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.TriggerKey; 
import org.quartz.impl.StdSchedulerFactory; 
import org.quartz.impl.matchers.GroupMatcher; 

public class QuartzScheduleMgr {
 private static  Scheduler scheduler=getScheduler(); 
    /**
     * 创建一个调度对象
     * @return
     * @throws SchedulerException
     */ 
    private static Scheduler getScheduler() { 
            SchedulerFactory sf = new StdSchedulerFactory(); 
            Scheduler scheduler=null; 
            try { 
                scheduler = sf.getScheduler(); 
            } catch (SchedulerException e) { 
                e.printStackTrace(); 
            } 
            return scheduler; 
    } 
    public static Scheduler getInstanceScheduler(){ 
        return scheduler; 
    } 
 
    /**
     * 启动一个调度对象
     * @throws SchedulerException
     */ 
    public  void start() throws SchedulerException 
    {  
        scheduler.start(); 
    } 
     
    /**
     * 检查调度是否启动
     * @return
     * @throws SchedulerException
     */ 
    public  boolean isStarted() throws SchedulerException 
    { 
        return scheduler.isStarted(); 
    } 
 
    /**
     * 关闭调度信息
     * @throws SchedulerException
     */ 
    public  void shutdown() throws SchedulerException   { 
        scheduler.shutdown(); 
    } 
    /**
     * 添加调度的job信息
     * @param jobdetail
     * @param trigger
     * @return
     * @throws SchedulerException
     */ 
    public  Date scheduleJob(JobDetail jobdetail, Trigger trigger) 
            throws SchedulerException{ 
                return scheduler.scheduleJob(jobdetail, trigger);  
    } 
    /**
     * 添加相关的触发器
     * @param trigger
     * @return
     * @throws SchedulerException
     */ 
    public  Date scheduleJob(Trigger trigger) throws SchedulerException{ 
        return scheduler.scheduleJob(trigger); 
    } 
     /**
      * 添加多个job任务
      * @param triggersAndJobs
      * @param replace
      * @throws SchedulerException
      */ 
    /*
     public  void scheduleJobs(Map<JobDetail, List<Trigger>> triggersAndJobs, boolean replace) throws SchedulerException 
     { 
        scheduler.scheduleJobs(triggersAndJobs, replace); 
     }
    */
    /**
     * 停止调度Job任务
     * @param triggerkey
     * @return
     * @throws SchedulerException
     */ 
    public  boolean unscheduleJob(TriggerKey triggerkey) 
            throws SchedulerException{ 
        return scheduler.unscheduleJob(triggerkey); 
    } 
 
    /**
     * 停止调度多个触发器相关的job
     * @param list
     * @return
     * @throws SchedulerException
     */ 
    public  boolean unscheduleJobs(List<TriggerKey> triggerKeylist) throws SchedulerException{ 
        return scheduler.unscheduleJobs(triggerKeylist); 
    } 
    /**
     * 重新恢复触发器相关的job任务 
     * @param triggerkey
     * @param trigger
     * @return
     * @throws SchedulerException
     */ 
    public  Date rescheduleJob(TriggerKey triggerkey, Trigger trigger) 
    throws SchedulerException{ 
        return scheduler.rescheduleJob(triggerkey, trigger); 
    } 
    /**
     * 添加相关的job任务
     * @param jobdetail
     * @param flag
     * @throws SchedulerException
     */ 
    public  void addJob(JobDetail jobdetail, boolean flag) 
            throws SchedulerException   { 
        scheduler.addJob(jobdetail, flag); 
    } 
 
    /**
     * 删除相关的job任务
     * @param jobkey
     * @return
     * @throws SchedulerException
     */ 
    public  boolean deleteJob(JobKey jobkey) throws SchedulerException{ 
        return scheduler.deleteJob(jobkey); 
    } 
 
    /**
     * 删除相关的多个job任务
     * @param jobKeys
     * @return
     * @throws SchedulerException
     */ 
    public     boolean deleteJobs(List<JobKey> jobKeys) 
    throws SchedulerException{ 
        return scheduler.deleteJobs(jobKeys); 
    } 
    /**
     * 
     * @param jobkey
     * @throws SchedulerException
     */ 
    public  void triggerJob(JobKey jobkey) throws SchedulerException    { 
        scheduler.triggerJob(jobkey); 
    } 
    /**
     * 
     * @param jobkey
     * @param jobdatamap
     * @throws SchedulerException
     */ 
    public  void triggerJob(JobKey jobkey, JobDataMap jobdatamap) 
            throws SchedulerException   { 
        scheduler.triggerJob(jobkey, jobdatamap); 
    } 
    /**
     * 停止一个job任务
     * @param jobkey
     * @throws SchedulerException
     */ 
    public  void pauseJob(JobKey jobkey) throws SchedulerException  { 
        scheduler.pauseJob(jobkey); 
    } 
    /**
     * 停止多个job任务
     * @param groupmatcher
     * @throws SchedulerException
     */ 
    public  void pauseJobs(GroupMatcher<JobKey> groupmatcher) 
            throws SchedulerException   { 
        scheduler.pauseJobs(groupmatcher); 
    } 
    /**
     * 停止使用相关的触发器
     * @param triggerkey
     * @throws SchedulerException
     */ 
    public  void pauseTrigger(TriggerKey triggerkey) 
            throws SchedulerException   { 
        scheduler.pauseTrigger(triggerkey); 
    } 
 
    public  void pauseTriggers(GroupMatcher<TriggerKey> groupmatcher) 
            throws SchedulerException   { 
        scheduler.pauseTriggers(groupmatcher); 
    } 
    /**
     * 恢复相关的job任务
     * @param jobkey
     * @throws SchedulerException
     */ 
    public  void resumeJob(JobKey jobkey) throws SchedulerException { 
        scheduler.pauseJob(jobkey); 
    } 
     
    public  void resumeJobs(GroupMatcher<JobKey> matcher) 
            throws SchedulerException   { 
        scheduler.resumeJobs(matcher); 
    } 
 
    public  void resumeTrigger(TriggerKey triggerkey) 
            throws SchedulerException   { 
        scheduler.resumeTrigger(triggerkey); 
    } 
    
    public  void resumeTriggers(GroupMatcher<TriggerKey>  groupmatcher) 
            throws SchedulerException 
    { 
        scheduler.resumeTriggers(groupmatcher);  
    } 
    /**
     * 暂停调度中所有的job任务
     * @throws SchedulerException
     */ 
    public  void pauseAll() throws SchedulerException 
    { 
        scheduler.pauseAll(); 
    } 
    /**
     * 恢复调度中所有的job的任务
     * @throws SchedulerException
     */ 
    public  void resumeAll() throws SchedulerException 
    { 
        scheduler.resumeAll(); 
    } 

}

写这样两个简单的类，就可以运行定时程序~~　其中

CronTrigger　用于设置job的运行间隔时间，运行次数等信息。cronSchedule("0/20 * * * * ?")　可以参见cron表达式的写法。

QuartzScheduleMgr　这个类用于控制　job的暂时，删除，停止等功能。