Quartz

博客分类：
• 第三方依赖

一、各种企业几乎都会碰到任务调度需求，就拿论坛来说，每个半个小时生成精华文章的RRS文件，每天凌晨统计用户的积分排名，没个30分钟执行锁定任务解锁任务。和 现今许多在用的开源项目一样，Quartz之初也只是为个人开发者提供了一个简单的实现方案。但是随着日益增多的关键人员的积极参与和慷慨的贡 献，Quartz 已经成为了一个为众人所知，并且能帮助人们解决更大问题的框架。 Quartz 项目 是由 James House 创立的，它在1998年就有该框架最初的构思。包括作业队列的概念，使用线程池来处理作业，也许它最早的模型已不为现今的Quartz使用者所知了。 下载地址http://www.quartz-scheduler.org/

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

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

2、JobDetail ：Quartz在每次执行Job时，都重新创建一个Job实例，所以它不直接接受一个Job的实例，相反它接收一个Job实现类，以便运行时通过newInstance()的反射机制实例化Job。因此需要通过一个类来描述Job的实现类及其它相关的静态信息 ，如Job名字、描述、关联监听器等信息，JobDetail承担了这一角色。通过该类的构造函数可以更具体地了解它的功用：JobDetail(java.lang.String name, java.lang.String group, java.lang.Class jobClass)，该构造函数要求指定Job的实现类，以及任务在Scheduler中的组名和Job名称；

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

4、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分别针对每年、每月和每周 进行定义；

5、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实例。

三、下面就举例说明，要加入的包：

<
dependency
>
    <
groupId
>
org.quartz-scheduler
</
groupId
>
    <
artifactId
>
quartz
</
artifactId
>
    <
version
>
1.8.5
</
version
>
</
dependency
>

package
 com.yt.manager.quartz;

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

/**
 * @Description: 该类是定时任务具体执行的类，实现Job接口
 * @ClassName: SayHelloWorldJob
 * @Project: base-info
 * @Author: zxf
 * @Date: 2011-8-22
 */
public
 
class
 SimpleJob 
implements
 Job {

    @Override
    public
 
void
 execute(JobExecutionContext context)
            throws
 JobExecutionException {
        System.out.println(context.getTrigger().getName()
                + " triggered. time is:"
 + (
new
 Date()));
    }
}

 

 (1)、使用简单的simpleTrigger

package
 com.yt.manager.quartz;

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

/**
 * @Description: 使用simpleTrigger
 * @ClassName: SimpleTriggerRunner
 * @Project: base-info
 * @Author: zxf
 * @Date: 2011-8-22
 */
public
 
class
 SimpleTriggerRunner {

    public
 
static
 
void
 main(String args[]) {

        try
 {

            // ①创建一个JobDetail实例，指定SimpleJob
            JobDetail jobDetail = new
 JobDetail(
"job1_1"
, 
"jGroup1"
,
                    SimpleJob.class
);

            // ②通过SimpleTrigger定义调度规则：马上启动，每2秒运行一次，共运行100次
            SimpleTrigger simpleTrigger = new
 SimpleTrigger(
"trigger1_1"
,
                    "tgroup1"
);
            simpleTrigger.setStartTime(new
 Date());
            simpleTrigger.setRepeatInterval(2000
);
            simpleTrigger.setRepeatCount(100
);

            // ③通过SchedulerFactory获取一个调度器实例
            SchedulerFactory schedulerFactory = new
 StdSchedulerFactory();
            Scheduler scheduler = schedulerFactory.getScheduler();
            // ④ 注册并进行调度
            scheduler.scheduleJob(jobDetail, simpleTrigger);

            // ⑤调度启动
            scheduler.start();

        } catch
 (Exception e) {

            e.printStackTrace();

        }

    }
}

  (2)、CronTrigger 能够提供比 SimpleTrigger 更有具体实际意义的调度方案，调度规则基于 Cron 表达式，CronTrigger 支持日历相关的重复时间间隔（比如每月第一个周一执行），而不是简单的周期时间间隔。因此，相对于SimpleTrigger而 言，CronTrigger在使用上也要复杂一些。

package
 com.yt.manager.quartz;

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.Trigger;
import
 org.quartz.impl.StdSchedulerFactory;
import
 org.springframework.stereotype.Component;

/**
 * 使用CronTrigger
 * @Description:
 * @ClassName: CronTriggerRunner
 * @Project: quartz
 * @Author: zxf
 * @Date: 2011-8-23
 */
@Component
(
"cronTriggerRunner"
)
public
 
class
 CronTriggerRunner {

    SchedulerFactory schedulerFactory = new
 StdSchedulerFactory();
    private
 
static
 
final
 String TRIGGER_GROUP_NAME = 
"tgroup"
;
    private
 
static
 
final
 String JOB_GROUP_NAME = 
"jGroup"
;

    /**
     * 创建触发器
     * @param express 时间规则
     * @param triggerName 触发器名称
     * @return
     */
    public
 CronTrigger createTrigger(String triggerName,String express){
        CronTrigger cronTrigger = null
;
        try
 {
            cronTrigger = new
 CronTrigger(triggerName, TRIGGER_GROUP_NAME);
            CronExpression cexp = null
;
            cexp = new
 CronExpression(express);
            cronTrigger.setCronExpression(cexp);
        }catch
(Exception e){
            e.printStackTrace();
        }
        return
 cronTrigger;
    }

    /**
     * 创建一个定时任务
     * @param quartzName 任务名称
     */
    public
 
void
 createQuartz(String quartzName) {
        try
 {
            JobDetail jobDetail = new
 JobDetail(quartzName, JOB_GROUP_NAME,
                    SimpleJob.class
);
            Scheduler scheduler = schedulerFactory.getScheduler();
            scheduler.scheduleJob(jobDetail, this
.createTrigger(quartzName+
"_trigger"
,
"0/2 * * * * ?"
));
            scheduler.start();
        } catch
 (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 移除一个定时任务
     * @param quartzName 任务名称
     */
    public
 
void
 removeQuartz(String quartzName) {
        try
 {
            Scheduler scheduler = schedulerFactory.getScheduler();
            scheduler.pauseTrigger(quartzName+"_trigger"
, TRIGGER_GROUP_NAME);
// 停止触发器
            scheduler.unscheduleJob(quartzName+"_trigger"
, TRIGGER_GROUP_NAME);
// 移除触发器
            scheduler.deleteJob(quartzName, JOB_GROUP_NAME);// 删除任务
        } catch
 (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 恢复任务
     * @throws SchedulerException
     */
    public
 
void
 task() 
throws
 SchedulerException {

        Scheduler scheduler = schedulerFactory.getScheduler();

        String[] triggerGroups;
        String[] triggers;

        triggerGroups = scheduler.getTriggerGroupNames();
        for
 (
int
 i = 
0
; i < triggerGroups.length; i++) {
            triggers = scheduler.getTriggerNames(triggerGroups[i]);
            for
 (
int
 j = 
0
; j < triggers.length; j++) {
                Trigger tg = scheduler.getTrigger(triggers[j], triggerGroups[i]);
                //重新安排任务
                scheduler.rescheduleJob(triggers[j], triggerGroups[i], tg);
            }
        }
        // start the scheduler
        scheduler.start();
    }

    public
 
static
 
void
 main(String args[]) {
        CronTriggerRunner r = new
 CronTriggerRunner();
        r.createQuartz("001"
);
    }
}

 

Cron表达式

Quartz使用类似于Linux下的Cron表达式定义时间规则，Cron表达式由6或7个由空格分隔的时间字段组成，如表1所示：

表 1 Cron表达式时间字段

 

位置	时间域名	允许值	允许的特殊字符
1	秒	0-59	, - * /
2	分钟	0-59	, - * /
3	小时	0-23	, - * /
4	日期	1-31	, - * ? / L W C
5	月份	1-12	, - * /
6	星期	1-7	, - * ? / L C #
7	年(可选)	空值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表达式对特殊字符的大小写不敏感，对代表星期的缩写英文大小写也不敏感。

表2下面给出一些完整的Cron表示式的实例：

表 2 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分运行。

 

四、任务的持久化

1、到quartz-1.8.5\docs\dbTables找到对应的数据库导入

2、加入quartz.properties资源文件配置数据源

org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 10
org.quartz.threadPool.threadPriority = 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true

# Using RAMJobStore
## if using RAMJobStore, please be sure that you comment out the following
## - org.quartz.jobStore.tablePrefix,
## - org.quartz.jobStore.driverDelegateClass,
## - org.quartz.jobStore.dataSource
#org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

# Using JobStoreTX
## Be sure to run the appropriate script(under docs/dbTables) first to create tables
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX

# Configuring JDBCJobStore with the Table Prefix
org.quartz.jobStore.tablePrefix = QRTZ_

# Using DriverDelegate
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate

# Using datasource
org.quartz.jobStore.dataSource = myDS

# Define the datasource to use
org.quartz.dataSource.myDS.driver = oracle.jdbc.driver.OracleDriver
org.quartz.dataSource.myDS.URL = jdbc:oracle:thin:@127.0
.
0.1
:
1521
:orcl
org.quartz.dataSource.myDS.user = oracle_test1
org.quartz.dataSource.myDS.password = zhouxufeng
org.quartz.dataSource.myDS.maxConnections = 30

五、spring整合Quartz

<?
xml
 
version
=
"1.0"
 
encoding
=
"UTF-8"
?>
<
beans
 
xmlns
=
"http://www.springframework.org/schema/beans"
    xmlns:xsi
=
"http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p
=
"http://www.springframework.org/schema/p"
    xsi:schemaLocation
="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 通过JobDetailBean实现jobDetail -->
    <
bean
 
name
=
"jobDetail"
        class
=
"org.springframework.scheduling.quartz.JobDetailBean"
>
        <
property
 
name
=
"jobClass"
 
value
=
"com.yt.manager.quartzspring.MyJob"
 
/>
        <!--传递的参数 -->
        <
property
 
name
=
"jobDataAsMap"
>
            <
map
>
                <
entry
 
key
=
"size"
 
value
=
"10"
 
/>
            </
map
>
        </
property
>
        <!--可以在MyJob中获取applicationContext信息-->
        <
property
 
name
=
"applicationContextJobDataKey"
            value
=
"applicationContext"
 
/>
    </
bean
>

    <!-- 通过封装服务类方法实现jobDetail -->
    <
bean
 
id
=
"jobDetail_1"
        class
=
"org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"
>
        <
property
 
name
=
"targetObject"
 
ref
=
"quartzService"
 
/>
        <
property
 
name
=
"targetMethod"
 
value
=
"work"
 
/>
    </
bean
>

    <
bean
 
id
=
"quartzService"
 
class
=
"com.yt.manager.quartzspring.QuartzServiceImpl"
>
</
bean
>

    <!--创建simpleTrigger触发器-->
    <
bean
 
id
=
"simpleTrigger"
        class
=
"org.springframework.scheduling.quartz.SimpleTriggerBean"
>
        <
property
 
name
=
"jobDetail"
 
ref
=
"jobDetail"
 
/>
        <
property
 
name
=
"startDelay"
 
value
=
"1000"
 
/>
        <
property
 
name
=
"repeatInterval"
 
value
=
"2000"
 
/>
        <
property
 
name
=
"repeatCount"
 
value
=
"100"
 
/>
        <!--传递的参数 -->
        <
property
 
name
=
"jobDataAsMap"
>
            <
map
>
                <
entry
 
key
=
"count"
 
value
=
"10"
 
/>
            </
map
>
        </
property
>
    </
bean
>

    <!--创建CronTrigger触发器  -->
    <
bean
 
id
 =
"cronTrigger"
  
class
 =
"org.springframework.scheduling.quartz.CronTriggerBean"
 
>
        <
property
  
name
 =
"jobDetail"
 
>
            <
ref
  
bean
 =
"jobDetail_1"
 
/>
        </
property
 
>
        <!--  cron表达式  -->
        <
property
  
name
 =
"cronExpression"
 
>
            <
value
>
 0/2 * * * * ? 
</
value
 
>
        </
property
 
>
    </
bean
 
>

    <!--  总管理类 如果将lazy-init='false'那么容器启动就会执行调度程序   -->
    <
bean
 
id
=
"scheduler"
        class
=
"org.springframework.scheduling.quartz.SchedulerFactoryBean"
>
        <
property
 
name
=
"triggers"
>
            <
list
>
                <
ref
 
bean
=
"simpleTrigger"
 
/>
                <
ref
 
bean
=
"cronTrigger"
 
/>
            </
list
>
        </
property
>
        <
property
 
name
=
"schedulerContextAsMap"
>
            <
map
>
                <
entry
 
key
=
"timeout"
 
value
=
"30"
 
/>
            </
map
>
        </
property
>
        <
property
 
name
=
"quartzProperties"
>
            <
props
>
                <
prop
 
key
=
"org.quartz.threadPool.class"
>
                    org.quartz.simpl.SimpleThreadPool
                </
prop
>
                <
prop
 
key
=
"org.quartz.threadPool.threadCount"
>
10
</
prop
>
            </
props
>
        </
property
>
    </
bean
>

</
beans
>

package
 com.yt.manager.quartzspring;

public
 
class
 QuartzServiceImpl {

    public
 
void
 work() {
        System.out.println(" Quartz的任务调度！！！ "
);
    }
}

package
 com.yt.manager.quartzspring;

import
 java.util.Map;
import
 org.quartz.JobExecutionContext;
import
 org.quartz.JobExecutionException;
import
 org.quartz.StatefulJob;
import
 org.springframework.context.ApplicationContext;

public
 
class
 MyJob 
implements
 StatefulJob {
    public
 
void
 execute(JobExecutionContext jctx) 
throws
 JobExecutionException {
        //获取JobDetail属性
        Map dataMap = jctx.getJobDetail().getJobDataMap();
        //获取Trigger属性
    //  Map dataMap = jctx.getTrigger().getJobDataMap();
        String size =(String)dataMap.get("size"
);
        //获取applicationContext信息
        ApplicationContext ctx = (ApplicationContext)dataMap.get("applicationContext"
);
        System.out.println("size:"
+size);

        String count =(String)dataMap.get("count"
);
        System.out.println("count:"
+count);
    }
}

package
 com.yt.manager.quartzspring;

import
 org.springframework.context.ApplicationContext;
import
 org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @Description:测试类
 * @ClassName: MainTest
 * @Project: quartz
 * @Author: zxf
 * @Date: 2011-8-23
 */
public
 
class
 Test {

    /**
     * @param args
     */
    public
 
static
 
void
 main(String[] args) {
        System.out.println(" Test start . "
);
        ApplicationContext context = new
 ClassPathXmlApplicationContext(
                "quartz-config.xml"
);
        // 如果配置文件中将scheduler bean的lazy-init设置为false 则不用实例化
        context.getBean("scheduler"
);
        System.out.print(" Test end .. "
);

    }

}

 小结：

Quartz提供了最为丰富的任务调度功能，不但可以制定周期性运行的任务调度方案，还可以让你按照日历相关的方式进行任务调度。Quartz框架 的重要组件包括Job、JobDetail、Trigger、Scheduler以及辅助性的JobDataMap和SchedulerContext。

Quartz拥有一个线程池，通过线程池为任务提供执行线程，你可以通过配置文件对线程池进行参数定制。Quartz的另 一个重要功能是可将任务调度信息持久化到数据库中，以便系统重启时能够恢复已经安排的任务。此外，Quartz还拥有完善的事件体系，允许你注册各种事件 的监听器。