Quartz和spring 集群定时任务整合

Quartz和Spring整合

1.集群定时任务使用Quartz 和spring 整合

在集群环境下，大家会碰到一直困扰的问题，即多个 APP 下如何用 quartz 协调处理自动化 JOB 。

A ，

B ，

C 3 台机器上各有一个 QUARTZ ，他们会按照即定的 SCHEDULE 自动

执行各自的任务。

我们先不说实现什么功能，就说这样的架构其实有点像多线程。

那多线程里就会存在“资源竞争”的问题，即可能产生脏读，脏写，由于三台 APP SERVER 里都有 QUARTZ ，因此会存在重复处理 TASK 的现象。

一般外面的解决方案是只在一台 APP 上装 QUARTZ ，其它两台不装，这样集群就形同虚设了；

另一种解决方案是动代码，这样就要影响到原来已经写好的 QUARTZ JOB 的代码了，这对程序开发人员来说比较痛苦；

本人仔细看了一下 Spring 的结构和 QUARTZ 的文档，结合 Quartz 自身可以实例化进数据的特性找到了相关的解决方案。

每台作为集群点的 APP SERVER 上都可以布署 QUARTZ ；

2.QUARTZ 的 TASK （ 12 张表）实例化如数据库，基于数据库引擎

及 High-Available 的策略（集群的一种策略）自动协调每个节点的 QUARTZ ，当任一一节点的 QUARTZ 非正常关闭或出错时，另几个节点的 QUARTZ 会自动启动；

3.

3. 无需开发人员更改原已经实现的 QUARTZ ，使用 SPRING+ 类反射的机制

对原有程序作切面重构；

本人也事先搜索了一些资料，发觉所有目前在 GOOGLE 上或者在各大论坛里提供的解决方案，要么是只解决了一部分，要么是错误的，要么是版本太老，要么就是完全抄别人的。

尤其是在使用 QUARTZ+SPRING 对数据库对象作实例化时会抛错（源于 SPRING 的一个 BUG ），目前网上的解决方案全部是错的或者干脆没说，本人在此方案中也会提出如何解决。

解决方案：

1.把 QUARTZ 的 TASK 实例化进数据库，

QUARTZ 只有实例化进入数据库后才能做集群，外面的解决方案说实例化在内存里全部是错的，把quartz-1.8.4/docs/dbTables/tables_oracle.sql 在 ORACLE9I2 及以上版本中执行一下会生成 12 张表；

--

-- A hint submitted by a user: Oracle DB MUST be created as "shared" and the

-- job_queue_processes parameter must be greater than 2, otherwise a DB lock

-- will happen. However, these settings are pretty much standard after any

-- Oracle install, so most users need not worry about this.

--

-- Many other users (including the primary author of Quartz) have had success

-- runing in dedicated mode, so only consider the above as a hint ;-)

--

delete from qrtz_job_listeners;

delete from qrtz_trigger_listeners;

delete from qrtz_fired_triggers;

delete from qrtz_simple_triggers;

delete from qrtz_cron_triggers;

delete from qrtz_blob_triggers;

delete from qrtz_triggers;

delete from qrtz_job_details;

delete from qrtz_calendars;

delete from qrtz_paused_trigger_grps;

delete from qrtz_locks;

delete from qrtz_scheduler_state;

drop table qrtz_calendars;

drop table qrtz_fired_triggers;

drop table qrtz_trigger_listeners;

drop table qrtz_blob_triggers;

drop table qrtz_cron_triggers;

drop table qrtz_simple_triggers;

drop table qrtz_triggers;

drop table qrtz_job_listeners;

drop table qrtz_job_details;

drop table qrtz_paused_trigger_grps;

drop table qrtz_locks;

drop table qrtz_scheduler_state;

CREATE TABLE qrtz_job_details

(

JOB_NAME VARCHAR2(200) NOT NULL,

JOB_GROUP VARCHAR2(200) NOT NULL,

DESCRIPTION VARCHAR2(250) NULL,

JOB_CLASS_NAME VARCHAR2(250) NOT NULL,

IS_DURABLE VARCHAR2(1) NOT NULL,

IS_VOLATILE VARCHAR2(1) NOT NULL,

IS_STATEFUL VARCHAR2(1) NOT NULL,

REQUESTS_RECOVERY VARCHAR2(1) NOT NULL,

JOB_DATA BLOB NULL,

PRIMARY KEY (JOB_NAME,JOB_GROUP)

);

CREATE TABLE qrtz_job_listeners

(

JOB_NAME VARCHAR2(200) NOT NULL,

JOB_GROUP VARCHAR2(200) NOT NULL,

JOB_LISTENER VARCHAR2(200) NOT NULL,

PRIMARY KEY (JOB_NAME,JOB_GROUP,JOB_LISTENER),

FOREIGN KEY (JOB_NAME,JOB_GROUP)

REFERENCES QRTZ_JOB_DETAILS(JOB_NAME,JOB_GROUP) );

CREATE TABLE qrtz_triggers

(

TRIGGER_NAME VARCHAR2(200) NOT NULL,

TRIGGER_GROUP VARCHAR2(200) NOT NULL,

JOB_NAME VARCHAR2(200) NOT NULL,

JOB_GROUP VARCHAR2(200) NOT NULL,

IS_VOLATILE VARCHAR2(1) NOT NULL,

DESCRIPTION VARCHAR2(250) NULL,

NEXT_FIRE_TIME NUMBER(13) NULL,

PREV_FIRE_TIME NUMBER(13) NULL,

PRIORITY NUMBER(13) NULL,

TRIGGER_STATE VARCHAR2(16) NOT NULL,

TRIGGER_TYPE VARCHAR2(8) NOT NULL,

START_TIME NUMBER(13) NOT NULL,

END_TIME NUMBER(13) NULL,

CALENDAR_NAME VARCHAR2(200) NULL,

MISFIRE_INSTR NUMBER(2) NULL,

JOB_DATA BLOB NULL,

PRIMARY KEY (TRIGGER_NAME,TRIGGER_GROUP),

FOREIGN KEY (JOB_NAME,JOB_GROUP)

REFERENCES QRTZ_JOB_DETAILS(JOB_NAME,JOB_GROUP) );

CREATE TABLE qrtz_simple_triggers

(

TRIGGER_NAME VARCHAR2(200) NOT NULL,

TRIGGER_GROUP VARCHAR2(200) NOT NULL,

REPEAT_COUNT NUMBER(7) NOT NULL,

REPEAT_INTERVAL NUMBER(12) NOT NULL,

TIMES_TRIGGERED NUMBER(10) NOT NULL,

PRIMARY KEY (TRIGGER_NAME,TRIGGER_GROUP),

FOREIGN KEY (TRIGGER_NAME,TRIGGER_GROUP)

REFERENCES QRTZ_TRIGGERS(TRIGGER_NAME,TRIGGER_GROUP) );

CREATE TABLE qrtz_cron_triggers

(

TRIGGER_NAME VARCHAR2(200) NOT NULL,

TRIGGER_GROUP VARCHAR2(200) NOT NULL,

CRON_EXPRESSION VARCHAR2(120) NOT NULL,

TIME_ZONE_ID VARCHAR2(80),

PRIMARY KEY (TRIGGER_NAME,TRIGGER_GROUP),

FOREIGN KEY (TRIGGER_NAME,TRIGGER_GROUP)

REFERENCES QRTZ_TRIGGERS(TRIGGER_NAME,TRIGGER_GROUP) );

CREATE TABLE qrtz_blob_triggers

(

TRIGGER_NAME VARCHAR2(200) NOT NULL,

TRIGGER_GROUP VARCHAR2(200) NOT NULL,

BLOB_DATA BLOB NULL,

PRIMARY KEY (TRIGGER_NAME,TRIGGER_GROUP),

FOREIGN KEY (TRIGGER_NAME,TRIGGER_GROUP)

REFERENCES QRTZ_TRIGGERS(TRIGGER_NAME,TRIGGER_GROUP) );

CREATE TABLE qrtz_trigger_listeners

(

TRIGGER_NAME VARCHAR2(200) NOT NULL,

TRIGGER_GROUP VARCHAR2(200) NOT NULL,

TRIGGER_LISTENER VARCHAR2(200) NOT NULL,

PRIMARY KEY (TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_LISTENER), FOREIGN KEY (TRIGGER_NAME,TRIGGER_GROUP)

REFERENCES QRTZ_TRIGGERS(TRIGGER_NAME,TRIGGER_GROUP) );

CREATE TABLE qrtz_calendars

(

CALENDAR_NAME VARCHAR2(200) NOT NULL,

CALENDAR BLOB NOT NULL,

PRIMARY KEY (CALENDAR_NAME)

);

CREATE TABLE qrtz_paused_trigger_grps

(

TRIGGER_GROUP VARCHAR2(200) NOT NULL,

PRIMARY KEY (TRIGGER_GROUP)

);

CREATE TABLE qrtz_fired_triggers

(

ENTRY_ID VARCHAR2(95) NOT NULL,

TRIGGER_NAME VARCHAR2(200) NOT NULL,

TRIGGER_GROUP VARCHAR2(200) NOT NULL,

IS_VOLATILE VARCHAR2(1) NOT NULL,

INSTANCE_NAME VARCHAR2(200) NOT NULL,

FIRED_TIME NUMBER(13) NOT NULL,

PRIORITY NUMBER(13) NOT NULL,

STATE VARCHAR2(16) NOT NULL,

JOB_NAME VARCHAR2(200) NULL,

JOB_GROUP VARCHAR2(200) NULL,

IS_STATEFUL VARCHAR2(1) NULL,

REQUESTS_RECOVERY VARCHAR2(1) NULL,

PRIMARY KEY (ENTRY_ID)

);

CREATE TABLE qrtz_scheduler_state

(

INSTANCE_NAME VARCHAR2(200) NOT NULL,

LAST_CHECKIN_TIME NUMBER(13) NOT NULL,

CHECKIN_INTERVAL NUMBER(13) NOT NULL,

PRIMARY KEY (INSTANCE_NAME)

);

CREATE TABLE qrtz_locks

(

LOCK_NAME VARCHAR2(40) NOT NULL,

PRIMARY KEY (LOCK_NAME)

);

INSERT INTO qrtz_locks values('TRIGGER_ACCESS');

INSERT INTO qrtz_locks values('JOB_ACCESS');

INSERT INTO qrtz_locks values('CALENDAR_ACCESS');

INSERT INTO qrtz_locks values('STATE_ACCESS');

INSERT INTO qrtz_locks values('MISFIRE_ACCESS');

create index idx_qrtz_j_req_recovery on qrtz_job_details(REQUESTS_RECOVERY);

create index idx_qrtz_t_next_fire_time on qrtz_triggers(NEXT_FIRE_TIME);

create index idx_qrtz_t_state on qrtz_triggers(TRIGGER_STATE);

create index idx_qrtz_t_nft_st on qrtz_triggers(NEXT_FIRE_TIME,TRIGGER_STATE);

create index idx_qrtz_t_volatile on qrtz_triggers(IS_VOLATILE);

create index idx_qrtz_ft_trig_name on qrtz_fired_triggers(TRIGGER_NAME);

create index idx_qrtz_ft_trig_group on qrtz_fired_triggers(TRIGGER_GROUP);

create index idx_qrtz_ft_trig_nm_gp on qrtz_fired_triggers(TRIGGER_NAME,TRIGGER_GROUP);

create index idx_qrtz_ft_trig_volatile on qrtz_fired_triggers(IS_VOLATILE);

create index idx_qrtz_ft_trig_inst_name on qrtz_fired_triggers(INSTANCE_NAME);

create index idx_qrtz_ft_job_name on qrtz_fired_triggers(JOB_NAME);

create index idx_qrtz_ft_job_group on qrtz_fired_triggers(JOB_GROUP);

create index idx_qrtz_ft_job_stateful on qrtz_fired_triggers(IS_STATEFUL);

create index idx_qrtz_ft_job_req_recovery on qrtz_fired_triggers(REQUESTS_RECOVERY);

commit;

2.生成 quartz.properties 文件

把它放在工程的 src 目录下，使其能够被编译时纳入 class path 。

一般我们的开发人员都喜欢使用 SPRING+QUARTZ ，因此这个 quartz.properties 都不用怎么去写，但是在集群方案中 quartz.properties 必写，如果不写 quartz 会调用自身 jar 包中的 quartz.properties 作为默认属性文件，同时修改 quartz.xml 文件。

3.配置quartz.properties

#============================================================= ===============

# Configure Main Scheduler Properties

#============================================================= ===============

org.quartz.scheduler.instanceName = DefaultQuartzScheduler org.quartz.scheduler.instanceId = AUTO

#============================================================= ===============

# Configure ThreadPool

#============================================================= ===============

org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool org.quartz.threadPool.threadCount = 10

org.quartz.threadPool.threadPriority = 5

org.quartz.threadPool.threadsInheritContextClassLoaderOfInitia lizingThread = true

#============================================================= ===============

# Configure JobStore

#============================================================= ===============

需要注释掉，使用系统配置的数据库

#org.quartz.jobStore.class =

org.quartz.impl.jdbcjobstore.JobStoreTX

#org.quartz.jobStore.driverDelegateClass =

org.quartz.impl.jdbcjobstore.oracle.OracleDelegate

org.quartz.jobStore.misfireThreshold = 60000

org.quartz.jobStore.tablePrefix = QRTZ_

org.quartz.jobStore.maxMisfiresToHandleAtATime=10

org.quartz.jobStore.isClustered = true

org.quartz.jobStore.clusterCheckinInterval = 15000

4.重写 quartz 的 QuartzJobBean 类

原因是在使用 quartz+spring 把 quartz 的 task 实例化进入数据库时，会产生： serializable 的错误，原因在于：

class="org.springframework.scheduling.quartz. MethodInvokingJo bDetailFactoryBean ">

execute

这个 MethodInvokingJobDetailFactoryBean 类中的 methodInvoking 方法，是不支持序列化的，因此在把 QUARTZ 的 TASK 序列化进入数据库时就会抛错。网上有说把 SPRING 源码拿来，修改一下这个方案，然后再打包

成 SPRING.jar 发布，这些都是不好的方法，是不安全的。

必须根据 QuartzJobBean 来重写一个自己的类，然后使用 SPRING 把这个重

写的类（我们就名命它为： MyDetailQuartzJobBean ）注入 appContext 中后，再使用 AOP 技术反射出原有的 quartzJobx( 就是开发人员原来已经做好的用于执行 QUARTZ 的 JOB 的执行类 ) 。

import https://www.360docs.net/doc/c78839140.html,ng.reflect.Method;

import https://www.360docs.net/doc/c78839140.html,mons.logging.Log;

import https://www.360docs.net/doc/c78839140.html,mons.logging.LogFactory;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

import org.springframework.context.ApplicationContext;

import org.springframework.scheduling.quartz.QuartzJobBean; public class MyDetailQuartzJobBean extends QuartzJobBean { protected final Log logger = LogFactory.getLog(getClass());

private String targetObject;

private String targetMethod;

private ApplicationContext ctx;

protected void executeInternal(JobExecutionContext context) throws JobExecutionException {

try {

https://www.360docs.net/doc/c78839140.html,("execute [" + targetObject + "] at once>>>>>>");

Object otargetObject = ctx.getBean(targetObject);

Method m = null;

try {

m =

otargetObject.getClass().getMethod(targetMethod,new Class[] {});

m.invoke(otargetObject, new Object[] {});

} catch (SecurityException e) {

logger.error(e);

} catch (NoSuchMethodException e) {

logger.error(e);

}

} catch (Exception e) {

throw new JobExecutionException(e);

}

}

public void setApplicationContext(ApplicationContext applicationContext) {

this.ctx = applicationContext;

}

public String getTargetObject() {

return targetObject;

}

public void setTargetObject(String targetObject) { this.targetObject = targetObject;

}

public String getTargetMethod() {

return targetMethod;

}

public void setTargetMethod(String targetMethod) { this.targetMethod = targetMethod;

}

}

5.再来看完整的 quartz.xml （注意红色加粗部分尤为重要）：applicationContext-quartz.xml

"https://www.360docs.net/doc/c78839140.html,/dtd/spring-beans-2.0.dtd">

class="org.springframework.scheduling.quartz.SchedulerFacto ryBean">

value="applicationContextKey" /> -->

value="classpath:quartz.properties" />

class="com.huarui.web.servlet.QuartzJob">

class="org.springframework.scheduling.quartz.JobDetailBean">

https://www.360docs.net/doc/c78839140.html,mon.MyDetailQuartzJobBean

class="org.springframework.scheduling.quartz.CronTriggerBean">

0 0/1 * * * ? //一分钟执行一次

6.在web.xml 中导入

contextConfigLocation

/WEB-INF/applicationContext.xml,/WEB-INF/applicationContext -quartz.xml

7.结尾

几个节点都带有 quartz 任务，此时只有一台 quartz 在运行，另几个节点上的 quartz 没有运行。

此时手动 shutdown 那台运行 QUARTZ （在程序里

加system.out.println(“execute once…”),运行 quartz 的那个节点在后台会打印 execute once ）的节点，过了 7 秒左右，另一个节点

的 quartz 自动监测到了集群中运行着的 quartz 的 instance 已

经 shutdown ，因此 quartz 集群会自动把任一台可用的APP 上启动起一

个 quartz job 的任务。

自此， QUARTZ 使用 HA 策略的集群大功告成，不用改原有代码，配置一下我们就可作到 QUARTZ 的集群与自动错误冗余。