`
Java_大猫
  • 浏览: 173111 次
  • 性别: Icon_minigender_1
  • 来自: 大连
社区版块
存档分类
最新评论

【转】 quartz在集群环境下的最终解决方案

阅读更多
原文地址:http://blog.csdn.net/lifetragedy/article/details/6212831

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

大家想象一下,现在有 A , B , C3 台机器同时作为集群服务器对外统一提供 SERVICE :

A , B , C 3 台机器上各有一个 QUARTZ ,他们会按照即定的 SCHEDULE 自动执行各自的任务。

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

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

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

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

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

本方案优点:

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

2.       QUARTZ 的 TASK ( 12 张表)实例化如数据库,基于数据库引擎及 High-Available 的策略(集群的一种策略)自动协调每个节点的 QUARTZ ,当任一一节点的 QUARTZ 非正常关闭或出错时,另几个节点的 QUARTZ 会自动启动;

3.       无需开发人员更改原已经实现的 QUARTZ ,使用 SPRING+ 类反射的机制对原有程序作切面重构;

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

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

解决方案:



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

2.       生成 quartz.properties 文件,把它放在工程的 src 目录下,使其能够被编译时纳入 class path 。

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



Quartz.xml 文件的内容 :



<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd ">

<beans>

                <bean id="mapScheduler" lazy-init="false" autowire="no"

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

                                <property name="configLocation" value="classpath:quartz.properties" />

                                <property name="triggers">

                                                <list>

                                                                <ref bean="cronTrigger" />

                                                </list>

                                </property>

                                <!— 就是下面这句,因为该 bean 只能使用类反射来重构

                                <property name="applicationContextSchedulerContextKey" value="applicationContext" />         

</bean>



quartz.properties 文件的内容:



org.quartz.scheduler.instanceName = mapScheduler 

org.quartz.scheduler.instanceId = AUTO

org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX

org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.oracle.weblogic.WebLogicOracleDelegate

org.quartz.jobStore.dataSource = myXADS

org.quartz.jobStore.tablePrefix = QRTZ_

org.quartz.jobStore.isClustered = true

 

org.quartz.dataSource.myXADS.jndiURL=jdbc/TestQuartzDS

org.quartz.dataSource.myXADS.jndiAlwaysLookup = DB_JNDI_ALWAYS_LOOKUP

org.quartz.dataSource.myXADS.java.naming.factory.initial = weblogic.jndi.WLInitialContextFactory

org.quartz.dataSource.myXADS.java.naming.provider.url = t3://localhost:7020

org.quartz.dataSource.myXADS.java.naming.security.principal = weblogic

org.quartz.dataSource.myXADS.java.naming.security.credentials = weblogic

3.       重写 quartz 的 QuartzJobBean 类

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

<bean id="jobtask" class="org.springframework.scheduling.quartz. MethodInvokingJobDetailFactoryBean ">

                                <property name="targetObject">

                                                <ref bean="quartzJob"/>

                                </property>

                                <property name="targetMethod">

                                                <value>execute</value>

                                </property>

</bean>

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

必须根据 QuartzJobBean 来重写一个自己的类,然后使用 SPRING 把这个重写的类(我们就名命它为: MyDetailQuartzJobBean )注入 appContext 中后,再使用 AOP 技术反射出原有的 quartzJobx( 就是开发人员原来已经做好的用于执行 QUARTZ 的 JOB 的执行类 ) 。

下面来看 MyDetailQuartzJobBean 类:



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 {



                                                logger.info("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 void setTargetObject(String targetObject) {

                                this.targetObject = targetObject;

                }



                public void setTargetMethod(String targetMethod) {

                                this.targetMethod = targetMethod;

                }



}

再来看完整的 quartz.xml (注意红色加粗部分尤为重要):

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd ">

<beans>

                <bean id="mapScheduler" lazy-init="false" autowire="no"

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

                                <property name="configLocation" value="classpath:quartz.properties" />

                                <property name="triggers">

                                                <list>

                                                                <ref bean="cronTrigger" />

                                                </list>

                                </property>

                                <property name=" applicationContextSchedulerContextKey " value=" applicationContext " />

                              

                </bean>

              





                <bean id="quartzJob" class="com.testcompany.framework.quartz.QuartzJob">

                </bean>



                <bean id="jobTask" class="org.springframework.scheduling.quartz.JobDetailBean">

                                <property name="jobClass">

                                                <value>com.testcompany.framework.quartz. MyDetailQuartzJobBean </value>

                                </property>

                                <property name="jobDataAsMap">

                                                <map>

                                                                <entry key="quartzJob" value="quartzJob" />

                                                                <entry key="targetMethod" value="execute" />

                                                </map>

                                </property>

                </bean>



                <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">

                                <property name="jobDetail">

                                                <ref bean="jobTask" />

                                </property>

                                <property name="cronExpression">

                                                <value>0/5 * * * * ?</value>

                                </property>

                </bean>

</beans>

4.       下载最新的 quartz1.8 版,把 quartz-all-1.8.4.jar, quartz-oracle-1.8.4.jar,quartz-weblogic-1.8.4.jar 这三个包放到 web-inf/lib 目录下,布署。





测试:



几个节点都带有 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 的集群与自动错误冗余。
分享到:
评论

相关推荐

    quartz在集群环境下的最终解决方案

    ### quartz在集群环境下的最终解决方案 #### 背景与挑战 随着系统复杂度的提高以及业务需求的变化,越来越多的应用程序需要支持高可用性和可扩展性。为了满足这些需求,通常会选择将应用程序部署在集群环境中。...

    quartz 集群解决方法

    在集群环境下,需要设置`org.quartz.scheduler.instanceId`为`AUTO`,让Quartz自动分配唯一的实例ID。同时,配置`org.quartz.jobStore.isClustered`为`true`,启用集群功能。 6. **故障转移和恢复**: 当一个正在...

    Spring Quartz Job 集群 终极解决方案

    最近公司项目上线,需要把app部署在多台服务器上,但只能让其中一台服务器的job执行,一台服务器挂了,另一台还能继续执行job,通过网上查找资料,都是java工程的方式,不好部署并测试,经过二天辛苦整合,终于整理成...

    quartz集群完整应用实例

    在单机环境下,Quartz已经足够强大,但当需要高可用性和负载均衡时,就需要搭建Quartz集群。 集群是多个独立的Quartz实例共同工作,它们共享同一份任务和触发器配置,以实现任务的分布式执行。Quartz的集群主要依赖...

    spring quartz集群配置

    本文将深入探讨如何在Spring中配置Quartz以实现集群环境下的任务调度。 首先,我们需要理解Quartz集群的基本概念。在Quartz集群中,多个Quartz服务器共享同一个“作业存储”(Job Store),这个存储可以是关系...

    spring4.0.6+quartz 2.2.3 集群示例

    1. **配置Quartz**: 在`quartz.properties`文件中,设置`org.quartz.scheduler.instanceName`以区别各个集群节点,同时启用集群模式,如`org.quartz.jobStore.isClustered=true`。 2. **Spring配置**: 创建一个...

    SpringBoot 整合Quartz(集群)实现定时任务调度

    为了确保集群环境下Quartz的正常工作,你需要在数据库中创建Quartz所需的表。Quartz提供了`org.quartz.impl.jdbcjobstore.CreateTableUtils`工具类来帮助你完成这一操作。此外,确保所有服务器共享相同的数据库,...

    quartz+spring分布式集群调度

    本文将深入探讨如何在分布式环境中利用Quartz和Spring构建一个高可用的集群调度系统。 一、Quartz简介 Quartz是Java平台上的作业调度库,它可以被用来创建、调度和执行计划任务。Quartz的核心是Job和Trigger。Job...

    quartz集群Sql大放送

    Quartz是一款开源的作业调度框架,广泛应用于Java企业级应用中,用于自动化任务的执行,如定时触发数据备份、报表...总之,理解和掌握这些SQL脚本以及Quartz集群的工作原理,是确保Quartz在复杂环境下稳定运行的关键。

    spring quartz 集群模式

    标题 "spring quartz 集群模式" 涉及到的是Spring框架与Quartz调度器在集群环境下的集成和配置。Quartz是一个开源任务调度框架,而Spring则提供了与Quartz的无缝集成,使得在Java应用中管理和执行定时任务变得更加...

    spring3+quartz1.6.4 集群示例

    本示例"spring3+quartz1.6.4 集群示例"是将两者结合,以实现一个能够支持集群的定时任务管理解决方案。 1. **Spring 3.x 框架** Spring 3.x 是Spring框架的一个版本,它引入了许多新特性,包括对Java 5和6的支持,...

    完美解决多应用服务器负载均衡环境下spring quartz同一定时任务重复执行问题

    综上所述,解决Spring Quartz在负载均衡环境下的重复执行问题,需要综合运用Quartz的集群特性、数据库Job Store、公平调度以及应用层面的设计策略。通过这些方法,可以确保在多服务器环境中,定时任务的执行有序且...

    spring+quartz定时集群支持

    在集群环境下,Spring+Quartz的配置需要考虑如何处理多个服务器节点可能同时执行同一任务的问题。为了解决这个问题,Quartz提供了一种集群模式。当配置为集群模式时,每个节点会共享相同的任务存储(通常是数据库)...

    Quartz2.2.1和Spring3.1.1集群

    总的来说,将Quartz2.2.1与Spring3.1.1集成并在集群环境中运行,需要深入理解Quartz的配置和Spring的bean管理,同时关注集群的稳定性和容错性。通过合理配置和编程,我们可以创建一个高效、可靠的定时任务执行系统。...

    quartz 集群配置

    当需要在分布式环境中运行多个Quartz实例以实现高可用性和负载均衡时,就需要进行Quartz集群配置。 在Spring集成Quartz的过程中,主要涉及以下几个核心概念和步骤: 1. **Job与Trigger**:Job是Quartz中的任务接口...

    spring集成quartz集群配置

    本文将深入探讨如何在Spring环境中集成Quartz以实现集群配置,以便于在分布式环境中进行高效的任务调度。 首先,理解Spring集成Quartz的核心在于Spring的Job接口和Quartz的Scheduler。Spring提供了`org.spring...

    SSH框架+Quartz集群

    Quartz集群则是在多台服务器上部署Quartz,以提高任务调度的可用性和可靠性。当一台服务器出现问题时,其他服务器能够接管任务,保证服务的连续性。 集成Quartz集群需要配置Quartz的集群模式,包括共享的数据存储...

    Springboot集成quartz集群

    本文章是关于springboot集成quartz集群的步骤,LZ亲测。

Global site tag (gtag.js) - Google Analytics