使用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还拥有完善的事件体系，允许你注册各种事件 的监听器。