Quartz

最新推荐文章于 2022-06-29 10:49:37 发布

alvinchen1010

最新推荐文章于 2022-06-29 10:49:37 发布

阅读量119

点赞数

分类专栏： JAVA/J2EE 文章标签： java 数据库

本文链接：https://blog.csdn.net/alvinchen1010/article/details/84017076

版权

JAVA/J2EE 专栏收录该内容

31 篇文章 0 订阅

订阅专栏

博客分类： 第三方依赖

一、各种企业几乎都会碰到任务调度需求，就拿论坛来说，每个半个小时生成精华文章的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实例。

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

Xml代码

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

Java代码

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

Java代码

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在使用上也要复杂一些。

Java代码

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资源文件配置数据源

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代码

<? 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">
< 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 >
< property name = "applicationContextJobDataKey"
value = "applicationContext" />
</ bean >
< 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 >
< 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 >
< bean id = "cronTrigger" class = "org.springframework.scheduling.quartz.CronTriggerBean" >
< property name = "jobDetail" >
< ref bean = "jobDetail_1" />
</ property >
< property name = "cronExpression" >
< value > 0/2 * * * * ? </ value >
</ property >
</ bean >
< 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 >

Java代码

package com.yt.manager.quartzspring;
public class QuartzServiceImpl {
public void work() {
System.out.println(" Quartz的任务调度！！！ " );
}
}

Java代码

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);
}
}