Java开源项目 Quartz

了解Quartz体系结构

Quartz对任务调度的领域问题进行了高度的抽象，提出了调度器、任务和触发器这3个核心的概念，并在org.quartz通过接口和类对重要的这些核心概念进行描述：

●Job：是一个接口，只有一个方法voidexecute(JobExecutionContextcontext)，开发者实现该接口定义运行任务，JobExecutionContext类提供了调度上下文的各种信息。Job运行时的信息保存在JobDataMap实例中；

●JobDetail：Quartz在每次执行Job时，都重新创建一个Job实例，所以它不直接接受一个Job的实例，相反它接收一个Job实现类，以便运行时通过newInstance()的反射机制实例化Job。因此需要通过一个类来描述Job的实现类及其它相关的静态信息，如Job名字、描述、关联监听器等信息，JobDetail承担了这一角色。

通过该类的构造函数可以更具体地了解它的功用：JobDetail(java.lang.String name, java.lang.String group, java.lang.ClassjobClass)，该构造函数要求指定Job的实现类，以及任务在Scheduler中的组名和Job名称；

●Trigger：是一个类，描述触发Job执行的时间触发规则。主要有SimpleTrigger和CronTrigger这两个子类。当仅需触发一次或者以固定时间间隔周期执行，SimpleTrigger是最适合的选择；而CronTrigger则可以通过Cron表达式定义出各种复杂时间规则的调度方案：如每早晨9:00执行，周一、周三、周五下午5:00执行等；

●Calendar：org.quartz.Calendar和java.util.Calendar不同，它是一些日历特定时间点的集合（可以简单地将org.quartz.Calendar看作java.util.Calendar的集合——java.util.Calendar代表一个日历时间点，无特殊说明后面的Calendar即指org.quartz.Calendar）。一个Trigger可以和多个Calendar关联，以便排除或包含某些时间点。

假设，我们安排每周星期一早上10:00执行任务，但是如果碰到法定的节日，任务则不执行，这时就需要在Trigger触发机制的基础上使用Calendar进行定点排除。针对不同时间段类型，Quartz在org.quartz.impl.calendar包下提供了若干个Calendar的实现类，如AnnualCalendar、MonthlyCalendar、WeeklyCalendar分别针对每年、每月和每周进行定义；

●Scheduler：代表一个Quartz的独立运行容器，Trigger和JobDetail可以注册到Scheduler中，两者在Scheduler中拥有各自的组及名称，组及名称是Scheduler查找定位容器中某一对象的依据，Trigger的组及名称必须唯一，JobDetail的组和名称也必须唯一（但可以和Trigger的组和名称相同，因为它们是不同类型的）。Scheduler定义了多个接口方法，允许外部通过组及名称访问和控制容器中Trigger和JobDetail。

Scheduler可以将Trigger绑定到某一JobDetail中，这样当Trigger触发时，对应的Job就被执行。一个Job可以对应多个Trigger，但一个Trigger只能对应一个Job。可以通过SchedulerFactory创建一个Scheduler实例。Scheduler拥有一个SchedulerContext，它类似于ServletContext，保存着Scheduler上下文信息，Job和Trigger都可以访问SchedulerContext内的信息。SchedulerContext内部通过一个Map，以键值对的方式维护这些上下文数据，SchedulerContext为保存和获取数据提供了多个put()和getXxx()的方法。可以通过Scheduler# getContext()获取对应的SchedulerContext实例；

●ThreadPool：Scheduler使用一个线程池作为任务运行的基础设施，任务通过共享线程池中的线程提高运行效率。

Job有一个StatefulJob子接口，代表有状态的任务，该接口是一个没有方法的标签接口，其目的是让Quartz知道任务的类型，以便采用不同的执行方案。无状态任务在执行时拥有自己的JobDataMap拷贝，对JobDataMap的更改不会影响下次的执行。而有状态任务共享共享同一个JobDataMap实例，每次任务执行对JobDataMap所做的更改会保存下来，后面的执行可以看到这个更改，也即每次执行任务后都会对后面的执行发生影响。

正因为这个原因，无状态的Job可以并发执行，而有状态的StatefulJob不能并发执行，这意味着如果前次的StatefulJob还没有执行完毕，下一次的任务将阻塞等待，直到前次任务执行完毕。有状态任务比无状态任务需要考虑更多的因素，程序往往拥有更高的复杂度，因此除非必要，应该尽量使用无状态的Job。

如果Quartz使用了数据库持久化任务调度信息，无状态的JobDataMap仅会在Scheduler注册任务时保持一次，而有状态任务对应的JobDataMap在每次执行任务后都会进行保存。

Trigger自身也可以拥有一个JobDataMap，其关联的Job可以通过JobExecutionContext#getTrigger().getJobDataMap()获取Trigger中的JobDataMap。不管是有状态还是无状态的任务，在任务执行期间对Trigger的JobDataMap所做的更改都不会进行持久，也即不会对下次的执行产生影响。

Quartz拥有完善的事件和监听体系，大部分组件都拥有事件，如任务执行前事件、任务执行后事件、触发器触发前事件、触发后事件、调度器开始事件、关闭事件等等，可以注册相应的监听器处理感兴趣的事件。

一个Scheduler可以拥有多个Triger组和多个JobDetail组，注册Trigger和JobDetail时，如果不显式指定所属的组，Scheduler将放入到默认组中，默认组的组名为Scheduler.DEFAULT_GROUP。组名和名称组成了对象的全名，同一类型对象的全名不能相同。

Scheduler本身就是一个容器，它维护着Quartz的各种组件并实施调度的规则。Scheduler还拥有一个线程池，线程池为任务提供执行线程——这比执行任务时简单地创建一个新线程要拥有更高的效率，同时通过共享节约资源的占用。通过线程池组件的支持，对于繁忙度高、压力大的任务调度，Quartz将可以提供良好的伸缩性。

提示： Quartz完整下载包examples目录下拥有10多个实例，它们是快速掌握Quartz应用很好的实例。

使用SimpleTrigger

SimpleTrigger拥有多个重载的构造函数，用以在不同场合下构造出对应的实例：

●SimpleTrigger(String name, String group)：通过该构造函数指定Trigger所属组和名称；

●SimpleTrigger(String name, String group, Date startTime)：除指定Trigger所属组和名称外，还可以指定触发的开发时间；

●SimpleTrigger(String name, String group,Date startTime, Date endTime, int repeatCount, longrepeatInterval)：除指定以上信息外，还可以指定结束时间、重复执行次数、时间间隔等参数；

●SimpleTrigger(String name, String group,String jobName, String jobGroup, Date startTime, Date endTime, intrepeatCount, longrepeatInterval)：这是最复杂的一个构造函数，在指定触发参数的同时，还通过jobGroup和jobName，让该Trigger和Scheduler中的某个任务关联起来。

看一个例子也许能更快的了解他的使用方法：

import org.quartz.*；

    public class QuartzReport implements Job {

    public void execute（JobExecutionContext cntxt） //必须实现的方法

    throws JobExecutionException {

    System.out.println（"Generating report - " +

    cntxt.getJobDetail（）.getJobDataMap（）.get（"type"））；

    //TODO Generate report

    }

    public static void main（String[] args） {

    try {

    SchedulerFactory schedFact

    new org.quartz.impl.StdSchedulerFactory（）；

    Scheduler sched = schedFact.getScheduler（）；

    sched.start（）；

    JobDetail jobDetail = new JobDetail（"Income Report"，       // 任务名

    "Report Generation"， // 任务组

    QuartzReport.class    //任务执行的类

    ）；

    jobDetail.getJobDataMap（）.put（"type"，"FULL"）；

    CronTrigger trigger new CronTrigger（

    "Income Report"，              //触发器名

    "Report Generation"          //触发器组

    ）；

    trigger.setCronExpression（     // 触发器时间设定

    "0 0 12 ？ * SUN"

    ）；

    sched.scheduleJob（jobDetail， trigger）； // 执行任务

    }

     catch （Exception e） {

    e.printStackTrace（）；

    }

这里面我们可以看到，当我们定义了任务执行 QuartzReport 类后，需要定一个Scheduler类用来执行计划任务。

    一个JobDetail 类来描述这个任务的信息，包括任务信息，任务所在组，任务执行的类。

    然后还要定义一个 触发器，类似的也包括触发器名，触发器所在组，触发器触发时间设定。

    最后是调度器Scheduler类执行计划任务。基本上一个计划任务执行的流程就完成了。

    当然，我们还看到这里使用了JobDataMap 类，它其实就是实现了map的特殊应用的一个类，使用方法与Map 很相似。我们可以用 put（） 输入参数。在Job类中使用cntxt.getJobDetail（）。getJobDataMap（）。get（"type"） 方法获取输入的参数的值。这里的cntxt 是 JobExecutionContext .就是包含任务执行上下文的一个信息类。这样我们的一个基本的任务执行就可以搞定了。

    触发器有两类：SimpleTrigger andCronTrigger. .SimpleTrigger主要提供了跟 java.util.Timer 类相似的功能……你可以在里面定义 任务的起始时间，终止时间，任务的执行次数，任务执行的中间间隔 . 而 CronTrigger类主要提供了更高级的任务调度时间设置，例如 每个星期天的早上7点  . CronTrigger的时间设置说明在最后来介绍。

下面分别是 SimpleTrigger  和 CronTrigger的列子

首先是一个实现了 job的类：

import java.util.Date;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 */
public class SimpleQuartzJob implements Job {

    public SimpleQuartzJob() {
    }

    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("In SimpleQuartzJob - executing its JOB at " 
                + new Date() + " by " + context.getTrigger().getName());
    }
}

SimpleTrigger  ：

import java.util.Date;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleTrigger;
import org.quartz.impl.StdSchedulerFactory;

/**
 */
public class SimpleTriggerRunner {

    public void task() throws SchedulerException
    {
        // Initiate a Schedule Factory
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        // Retrieve a scheduler from schedule factory
        Scheduler scheduler = schedulerFactory.getScheduler();
        
        // current time
        long ctime = System.currentTimeMillis(); 
        
        // Initiate JobDetail with job name, job group, and executable job class
        JobDetail jobDetail = new JobDetail("jobDetail-s1", "jobDetailGroup-s1", SimpleQuartzJob.class);
        // Initiate SimpleTrigger with its name and group name
        SimpleTrigger simpleTrigger = new SimpleTrigger("simpleTrigger", "triggerGroup-s1");
        // set its start up time
        simpleTrigger.setStartTime(new Date(ctime));
        // set the interval, how often the job should run (10 seconds here) 
        simpleTrigger.setRepeatInterval(10000);
        // set the number of excution of this job, set to 10 times. It will run 10 time and exhaust.
        simpleTrigger.setRepeatCount(100);
        // set the ending time of this job. We set it for 60 seconds from its startup time here
        // Even if we set its repeat count to 10, this will stop its process after 6 repeats 
        // as it gets it endtime by then.
        //simpleTrigger.setEndTime(new Date(ctime + 60000L));
        // set priority of trigger. If not set, the default is 5
        //simpleTrigger.setPriority(10);
        // schedule a job with JobDetail and Trigger
        scheduler.scheduleJob(jobDetail, simpleTrigger);
        
        // start the scheduler
        scheduler.start();
    }
    
    public static void main (String args[]) 
    {
        try {
            SimpleTriggerRunner qRunner = new SimpleTriggerRunner();
            qRunner.task();
        } catch (Exception e)
        {
            e.printStackTrace();
        }
    }
    
}

CronTrigger：

import org.quartz.CronExpression;
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 CronTriggerRunner {

    public void task() throws SchedulerException
    {
        // Initiate a Schedule Factory
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        // Retrieve a scheduler from schedule factory
        Scheduler scheduler = schedulerFactory.getScheduler();
        
        // current time
        long ctime = System.currentTimeMillis(); 
        
        // Initiate JobDetail with job name, job group, and executable job class
        JobDetail jobDetail = new JobDetail("jobDetail2", "jobDetailGroup2", SimpleQuartzJob.class);
        // Initiate CronTrigger with its name and group name
        CronTrigger cronTrigger = new CronTrigger("cronTrigger", "triggerGroup2");
        try {
            // setup CronExpression
            CronExpression cexp = new CronExpression("0/5 * * * * ?");
            // Assign the CronExpression to CronTrigger
            cronTrigger.setCronExpression(cexp);
        } catch (Exception e) {
            e.printStackTrace();
        }
        // schedule a job with JobDetail and Trigger
        scheduler.scheduleJob(jobDetail, cronTrigger);
        
        // start the scheduler
        scheduler.start();
    }
    
    public static void main (String args[]) 
    {
        try {
            CronTriggerRunner qRunner = new CronTriggerRunner();
            qRunner.task();
        } catch (Exception e)
        {
            e.printStackTrace();
        }
    }
    
}

另外补充一下， 需要有三个jar包 分别是 quartz-1.6.0.jar、jta.jar和commons-collections-3.1.jar 才能运行。

附：cronExpression配置说明

字段		允许值		允许的特殊字符
秒		0-59		, - * /
分		0-59		, - * /
小时		0-23		, - * /
日期		1-31		, - * ? / L W C
月份		1-12 或者 JAN-DEC		, - * /
星期		1-7 或者 SUN-SAT		, - * ? / L C #
年（可选）		留空, 1970-2099		, - * /

Cron表达式的时间字段除允许设置数值外，还可使用一些特殊的字符，提供列表、范围、通配符等功能，
细说如下：
●星号(*)：可用在所有字段中，表示对应时间域的每一个时刻，例如，*在分钟字段时，表示“每分钟”；
●问号（?）：该字符只在日期和星期字段中使用，它通常指定为“无意义的值”，相当于点位符；
●减号(-)：表达一个范围，如在小时字段中使用“10-12”，则表示从10到12点，即10,11,12；
●逗号(,)：表达一个列表值，如在星期字段中使用“MON,WED,FRI”，则表示星期一，星期三和星期五；
●斜杠(/)：x/y表达一个等步长序列，x为起始值，y为增量步长值。
如在分钟字段中使用0/15，则表示为0,15,30和45秒，而5/15在分钟字段中表示5,20,35,50，你也可以使用*/y，它等同于0/y；
●L：该字符只在日期和星期字段中使用，代表“Last”的意思，但它在两个字段中意思不同。
L在日期字段中，表示这个月份的最后一天，如一月的31号，非闰年二月的28号；
如果L用在星期中，则表示星期六，等同于7。
但是，如果L出现在星期字段里，而且在前面有一个数值X，则表示“这个月的最后X天”，例如，6L表示该月的最后星期五；
●W：该字符只能出现在日期字段里，是对前导日期的修饰，表示离该日期最近的工作日。
例如15W表示离该月15号最近的工作日，如果该月15号是星期六，则匹配14号星期五；
如果15日是星期日，则匹配16号星期一；如果15号是星期二，那结果就是15号星期二。
但必须注意关联的匹配日期不能够跨月，如你指定1W，如果1号是星期六，结果匹配的是3号星期一，而非上个月最后的那天。
W字符串只能指定单一日期，而不能指定日期范围；
●LW组合：在日期字段可以组合使用LW，它的意思是当月的最后一个工作日；
●井号(#)：该字符只能在星期字段中使用，表示当月某个工作日。
如6#3表示当月的第三个星期五(6表示星期五，#3表示当前的第三个)，而4#5表示当月的第五个星期三，
假设当月没有第五个星期三，忽略不触发；
●C：该字符只在日期和星期字段中使用，代表“Calendar”的意思。它的意思是计划所关联的日期，如果日期没有被关联，则相当于日历中所有日期。例如5C在日期字段中就相当于日历5日以后的第一天。1C在星期字段中相当于星期日后的第一天。Cron表达式对特殊字符的大小写不敏感，对代表星期的缩写英文大小写也不敏感。

表示式	说明
"0 0 12 * * ? "	每天12点运行
"0 15 10 ? * *"	每天10:15运行
"0 15 10 * * ?"	每天10:15运行
"0 15 10 * * ? *"	每天10:15运行
"0 15 10 * * ? 2008"	在2008年的每天10：15运行
"0 * 14 * * ?"	每天14点到15点之间每分钟运行一次，开始于14:00，结束于14:59。
"0 0/5 14 * * ?"	每天14点到15点每5分钟运行一次，开始于14:00，结束于14:55。
"0 0/5 14,18 * * ?"	每天14点到15点每5分钟运行一次，此外每天18点到19点每5钟也运行一次。
"0 0-5 14 * * ?"	每天14:00点到14:05，每分钟运行一次。
"0 10,44 14 ? 3 WED"	3月每周三的14:10分到14: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 2007-2009"	在2007,2008,2009年每个月的最后一个星期五的10:15分运行。
"0 15 10 ? * 6#3"	每月第三个星期五的10:15分运行。