`
sundoctor
  • 浏览: 325557 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Quartz在Spring中集群

quartzSpringJDBC应用服务器MySQL 
阅读更多

概述

虽然单个Quartz实例能给予你很好的Job调度能力，但它不能满足典型的企业需求，如可伸缩性、高可靠性满足。假如你需要故障转移的能力并能运行日益增多的 Job，Quartz集群势必成为你应用的一部分了。使用 Quartz 的集群能力可以更好的支持你的业务需求，并且即使是其中一台机器在最糟的时间崩溃了也能确保所有的 Job 得到执行。

Quartz 中集群如何工作

一个 Quartz 集群中的每个节点是一个独立的 Quartz 应用，它又管理着其他的节点。意思是你必须对每个节点分别启动或停止。不像许多应用服务器的集群，独立的 Quartz 节点并不与另一其的节点或是管理节点通信。Quartz 应用是通过数据库表来感知到另一应用的。

图：表示了每个节点直接与数据库通信，若离开数据库将对其他节点一无所知


创建Quartz数据库表

因为Quartz 集群依赖于数据库，所以必须首先创建Quartz数据库表。Quartz 包括了所有被支持的数据库平台的 SQL 脚本。在 <quartz_home>/docs/dbTables 目录下找到那些 SQL 脚本，这里的 <quartz_home> 是解压 Quartz 分发包后的目录。
这里采用的Quartz 2.2.1版本，总共11张表，不同版本，表个数可能不同。数据库为mysql，用tables_mysql_innodb.sql创建数据库表。

配置数据库连接池

1.配置jdbc.properties文件

 

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/quartz?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true
jdbc.username=root
jdbc.password=kfs

 
2.配置applicationContext.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:jdbc="http://www.springframework.org/schema/jdbc"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="   
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
   http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
   http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
   ">

	<context:component-scan base-package="com.sundoctor" />

	<!-- 属性文件读入 -->
	<bean id="propertyConfigurer"
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<value>classpath:jdbc.properties</value>
			</list>
		</property>
	</bean>


	<!-- 数据源定义,使用c3p0 连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
		destroy-method="close">
		<property name="driverClass" value="${jdbc.driverClassName}" />
		<property name="jdbcUrl" value="${jdbc.url}" />
		<property name="user" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
		<property name="initialPoolSize" value="${cpool.minPoolSize}" />
		<property name="minPoolSize" value="${cpool.minPoolSize}" />
		<property name="maxPoolSize" value="${cpool.maxPoolSize}" />
		<property name="acquireIncrement" value="${cpool.acquireIncrement}" />
		<property name="maxIdleTime" value="${cpool.maxIdleTime}" />
	</bean>
</beans>

 

 

 

创建Job测试服务类

package com.sundoctor.quartz.cluster.example;

import java.io.Serializable;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;


@Service("simpleService")
public class SimpleService {
	
	private static final long serialVersionUID = 122323233244334343L;
	private static final Logger logger = LoggerFactory.getLogger(SimpleService.class);
	
	public void testMethod1(){
		//这里执行定时调度业务
		logger.info("testMethod1.......1");
	}
	
	public void testMethod2(){
		logger.info("testMethod2.......2");	
	}
}

 

 

 

创建两个Job类MyQuartzJobBean1、MyQuartzJobBean2

 

package com.sundoctor.quartz.cluster.example;

import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.PersistJobDataAfterExecution;
import org.quartz.SchedulerException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.quartz.QuartzJobBean;

@PersistJobDataAfterExecution
@DisallowConcurrentExecution// 不允许并发执行
public class MyQuartzJobBean1 extends QuartzJobBean {

	private static final Logger logger = LoggerFactory.getLogger(MyQuartzJobBean1.class);

	@Override
	protected void executeInternal(JobExecutionContext jobexecutioncontext) throws JobExecutionException {

		SimpleService simpleService = getApplicationContext(jobexecutioncontext).getBean("simpleService",
				SimpleService.class);
		simpleService.testMethod1();

	}

	private ApplicationContext getApplicationContext(final JobExecutionContext jobexecutioncontext) {
		try {
			return (ApplicationContext) jobexecutioncontext.getScheduler().getContext().get("applicationContextKey");
		} catch (SchedulerException e) {
			logger.error("jobexecutioncontext.getScheduler().getContext() error!", e);
			throw new RuntimeException(e);
		}
	}

}

 



配置 Quartz 使用集群

1.配置节点的 quartz.properties 文件

引用

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

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

org.quartz.jobStore.misfireThreshold = 60000
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.tablePrefix = QRTZ_
org.quartz.jobStore.maxMisfiresToHandleAtATime=10
org.quartz.jobStore.isClustered = true 
org.quartz.jobStore.clusterCheckinInterval = 20000


org.quartz.scheduler.instanceName属性可为任何值，用在 JDBC JobStore 中来唯一标识实例，但是所有集群节点中必须相同。

org.quartz.scheduler.instanceId　属性为 AUTO即可，基于主机名和时间戳来产生实例 ID。

org.quartz.jobStore.class属性为 JobStoreTX，将任务持久化到数据中。因为集群中节点依赖于数据库来传播 Scheduler 实例的状态，你只能在使用 JDBC JobStore 时应用 Quartz 集群。这意味着你必须使用 JobStoreTX 或是 JobStoreCMT 作为 Job 存储；你不能在集群中使用 RAMJobStore。

org.quartz.jobStore.isClustered 属性为 true，你就告诉了 Scheduler 实例要它参与到一个集群当中。这一属性会贯穿于调度框架的始终，用于修改集群环境中操作的默认行为。

org.quartz.jobStore.clusterCheckinInterval 属性定义了Scheduler 实例检入到数据库中的频率(单位：毫秒)。Scheduler 检查是否其他的实例到了它们应当检入的时候未检入；这能指出一个失败的 Scheduler 实例，且当前 Scheduler 会以此来接管任何执行失败并可恢复的 Job。通过检入操作，Scheduler 也会更新自身的状态记录。clusterChedkinInterval 越小，Scheduler 节点检查失败的 Scheduler 实例就越频繁。默认值是 15000 (即15 秒)。

2.配置applicationContext-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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean name="quartzScheduler"
		class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
		<property name="dataSource">
			<ref bean="dataSource" />
		</property>
		<property name="applicationContextSchedulerContextKey" value="applicationContextKey" />
		<property name="configLocation" value="classpath:quartz.properties" />		
		<property name="triggers">
			<list>
				<ref bean="trigger1" />
				<ref bean="trigger2" />
			</list>
		</property>
	</bean>

	<bean id="jobDetail1" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
		<property name="jobClass">
			<value>com.sundoctor.quartz.cluster.example.MyQuartzJobBean1</value>
		</property>	
		<property name="durability" value="true" />	
		<property name="requestsRecovery" value="true" />		
	</bean>
	<bean id="trigger1" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
		<property name="jobDetail" ref="jobDetail1" />
		<property name="cronExpression" value="0/30 * * ? * * *" />
	</bean>

	<bean id="jobDetail2" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
		<property name="jobClass">
			<value>com.sundoctor.quartz.cluster.example.MyQuartzJobBean2</value>
		</property>	
		<property name="durability" value="true" />	
		<property name="requestsRecovery" value="true" />		
	</bean>
	<bean id="trigger2" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
		<property name="jobDetail" ref="jobDetail2" />
		<property name="cronExpression" value="0/10 * * ? * * *" />
	</bean>	

</beans>

 

 


dataSource：项目中用到的数据源，里面包含了quartz用到的11张数据库表；

applicationContextSchedulerContextKey： 是org.springframework.scheduling.quartz.SchedulerFactoryBean这个类中把spring上下 文以key/value的方式存放在了SchedulerContext中了，可以用applicationContextSchedulerContextKey所 定义的key得到对应spring 的ApplicationContext；

configLocation：用于指明quartz的配置文件的位置

requestsRecovery
requestsRecovery属性必须设置为 true，当Quartz服务被中止后，再次启动或集群中其他机器接手任务时会尝试恢复执行之前未完成的所有任务。

运行Quartz集群

在相同或不同的机器上运行com.sundoctor.quartz.cluster.example.test.MainTest进行测试，在本例中只是简单打印一下日志。

package com.sundoctor.quartz.cluster.example.test;

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

public class MainTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		ApplicationContext springContext = new ClassPathXmlApplicationContext(new String[]{"classpath:applicationContext.xml","classpath:applicationContext-quartz.xml"});
	}

}



Quartz 实际并不关心你是在相同的还是不同的机器上运行节点。当集群是放置在不同的机器上时，通常称之为水平集群。节点是跑在同一台机器是，称之为垂直集群。对于垂直集群，存在着单点故障的问题。这对高可用性的应用来说是个坏消息，因为一旦机器崩溃了，所有的节点也就被有效的终止了。

当你运行水平集群时，时钟应当要同步，以免出现离奇且不可预知的行为。假如时钟没能够同步，Scheduler 实例将对其他节点的状态产生混乱。有几种简单的方法来保证时钟何持同步，而且也没有理由不这么做。最简单的同步计算机时钟的方式是使用某一个 Internet 时间服务器(Internet Time Server ITS)。

没什么会阻止你在相同环境中使用集群的和非集群的 Quartz 应用。唯一要注意的是这两个环境不要混用在相同的数据库表。意思是非集群环境不要使用与集群应用相同的一套数据库表；否则将得到希奇古怪的结果，集群和非集群的 Job 都会遇到问题。

假如你让一个非集群的 Quartz 应用与集群节点并行着运行，设法使用 JobInitializationPlugin和 RAMJobStore。

 

分享到：
| Quartz任务监控管理
评论
6 楼 mwmw 2009-10-15  
可以把几台Server cluster起来，之后配置HAsingleton，这样的话一台server挂了就会自动的调整到另外一台server上去做Quartz了。
5 楼 sundoctor 2009-10-14  
jssanshengshi 写道
楼主有没有方案可以解决quartz的数据源连接方式使用spring中 的数据源？


引用
<beans>
    <bean name="quartzScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="dataSource">
            <ref bean="dataSource"/>
        </property>
        <property name="applicationContextSchedulerContextKey" value="applicationContextKey"/>
        <property name="configLocation" value="classpath:quartz.properties"/>
<property name="triggers">
<list> 
<ref bean="trigger1"/>
<ref bean="trigger2"/>
</list>
</property>
    </bean>

在这里
引用
<property name="dataSource">
            <ref bean="dataSource"/>
</property>

quartz的数据源连接方式就是使用spring中的数据源
引用
<!-- 数据源定义,使用c3p0 连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
<property name="driverClass" value="${jdbc.driverClassName}" />
<property name="jdbcUrl" value="${jdbc.url}" />
<property name="user" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
<property name="initialPoolSize" value="5" />
<property name="minPoolSize" value="5" />
<property name="maxPoolSize" value="20" />
<property name="acquireIncrement" value="2" />
<property name="maxIdleTime" value="3600" />
<property name="idleConnectionTestPeriod"  value="180"/>
<property name="automaticTestTable" value="C3P0TESTTABLE"/>
</bean>
</beans>

红色的地方就是使用spring中的数据源
4 楼 jssanshengshi 2009-10-14  
楼主有没有方案可以解决quartz的数据源连接方式使用spring中 的数据源？
3 楼 whaosoft 2009-10-14  
没做过这方面得研究，项目中具体用到这种集群了吗
2 楼 sundoctor 2009-10-14  
putonyuer 写道
为了不让各集群上的quartz 发生紊乱， 那就是说 ， 还要quartz节点间还需要时钟和由哪一个节点来执行的信息通信咯？


每个Quartz节点都是直接与数据库通信，并不与任何其它的节点通信。需要所有节点服务器时钟同步，所有节点共享一套数据库表，每个节点是通过数据库表记录的时间来知道当前那些Trigger在执行。
1 楼 putonyuer 2009-10-13  
为了不让各集群上的quartz 发生紊乱， 那就是说 ， 还要quartz节点间还需要时钟和由哪一个节点来执行的信息通信咯？
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    quartz整合springbatch动态集群定时实现mysql参考

    在这个“quartz_springbatch_dynamic”项目中，我们将看到如何将这两个强大的工具结合起来，以实现动态集群环境中的定时任务执行，并使用MySQL作为数据存储。 Quartz是一个开源的作业调度框架，允许开发者创建、...

    quartz+spring分布式集群

    - 集群中节点的故障检测和恢复是重要的考虑因素，可以通过心跳机制来监控其他节点的状态。 5. **案例实践**： - 包含的"spring-quartz"可能包含了示例代码和配置文件，供学习者参考。这些示例通常会展示如何在...

    quartz+spring分布式集群调度

    3. **公平负载**: 使用Fair-Scheduler插件，确保任务在集群中的各个节点间公平分配。 4. **故障转移**: 当某个节点故障时，其负责的任务会由其他健康的节点接管。 五、Spring配置 在Spring的配置文件中，需要声明...

    quartz整合springbatch定时集群实现mysql参考模版

    通过JDBCJobStore，Quartz可以将作业和触发器的信息持久化到MySQL，实现集群中的任务同步。同时，SpringBatch可以利用MySQL存储批量处理的状态，便于在处理过程中或处理失败后进行恢复。 **模版的使用** 这个参考...

    Quartz2.2.1和Spring3.1.1集群

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

    spring quartz 集群模式

    4. **监听器**：可能需要配置`StatefulJob`和`StatefulTrigger`，以确保每个实例只执行一次任务，避免在集群中重复执行。 5. **Spring整合**：在Spring配置文件中，设置`SchedulerFactoryBean`的相关属性，比如`...

    spring集成quartz集群配置

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

    spring quartz集群配置

    在Quartz集群中，多个Quartz服务器共享同一个“作业存储”（Job Store），这个存储可以是关系数据库或者分布式的存储系统。当一个服务器触发一个作业时，其他服务器会看到这个作业已经被触发，因此不会重复执行。这...

    quartz与spring集群Demo

    针对Quartz与Spring做集群的Demo实例，主要解决了Quartz的JOB序列化问题。 源代码说明： support pkg：扩展Spring与Quartz集成的不足之处。 core pkg: 是自身调度业务的封装 实例运行依赖Oracle数据库，根据quartz...

    Quartz集群+spring data

    在Quartz集群中，多个Quartz实例可以协同工作，提高任务调度的可用性和容错性。当一个节点失败时，其他节点能够接管其任务，确保业务连续性。实现Quartz集群的关键在于共享调度信息，如JobStore，它通常使用数据库来...

    Spring+Quartz 集群

    Quartz支持多种持久化策略，如JDBC、RAMJobStore等，选择数据库存储能保证在集群中的任务状态一致性。 6. **集群节点间的协调**：在每个节点上启动调度器时，通过配置`org.quartz.properties`文件的`org.quartz....

    Spring集群整合Quartz

    在Spring集群中，需要处理以下问题： - 单例Job的冲突：在集群环境中，同一个Job可能会被多个节点同时启动。可以通过实现StatefulJob接口，或者使用DistributedJobDetailBean避免这个问题。 - 任务的幂等性：确保...

    spring + quartz 集群配置

    java + quartz实现定时任务,实现集群配置,在集群环境下多节点运行定时Quartz定任务，就会存在重复处理任务的现象，为解决这一问题，下面我将介绍使用 Quartz 的 TASK （ 12 张表）实例化到数据库，基于数据库自动...

    spring4.0.6+quartz 2.2.3 集群示例

    总之，结合Spring 4.0.6和Quartz 2.2.3构建集群示例，能够帮助你在大型分布式系统中实现灵活、可靠的定时任务调度。通过熟练掌握这一技术，你可以为企业的后台服务提供强大而稳定的定时任务处理能力。

    spring 集成quartz 用数据库实现quartz的集群

    这就要求在集群中的每个节点都配置相同的`quartz.properties`文件，并连接到同一个数据库。 在数据库中，Quartz会创建一系列的表，如`QRTZ_JOBS`, `QRTZ_TRIGGERS`, `QRTZ_CRON_TRIGGERS`等，用于存储job和trigger...

    quartz 在spring中使用服务定时执行的例子

    在Spring中，我们还可以利用`@Scheduled`注解在方法上直接声明定时任务，但这种方式无法享受到Quartz的高级特性，如并发控制、集群支持等。 最后，为了使定时任务在Spring Boot启动时自动运行，我们需要在主应用类...

    quartz2.2.1 spring3.1.1

    Quartz 2.2.1 和 Spring 3.1.1 是两个在企业级Java应用开发中常用的开源框架。Quartz 是一个强大的、完全可定制的作业调度库，而 Spring 则是Java应用程序的全面框架，它提供了依赖注入、AOP（面向切面编程）、事务...

    quartz与spring

    Spring可以帮助我们更好地管理这些集群中的Quartz实例，通过共享JobStore（如JDBCJobStore）来协调不同节点间的任务状态。 总的来说，Quartz与Spring的结合使用可以充分利用两者的优点，实现灵活、可靠且易于管理的...

Magicbox
Global site tag (gtag.js) - Google Analytics