`
scnujie
  • 浏览: 127769 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

spring里quartz调度的连续触发

阅读更多
   作法是通过spring在执行的触发器的监听器的里面注入下一个要执行的监听器实例,这

样就可以达到连续地触发,而至于具体怎样的触发:比如说什么时候触发,下一个相隔多久才

触发这些则可以通过配置文件进行配置。
 
    这是用于连续触发的Listener:

package com.sww.quartz.listeners;

import org.apache.log4j.Logger;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.Scheduler;
import org.quartz.Trigger;
import org.quartz.listeners.TriggerListenerSupport;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.scheduling.quartz.SimpleTriggerBean;

public class NextJobTriggerListener extends TriggerListenerSupport {
	private  Logger logger = Logger.getLogger(getClass());
	private String name;
	public String getName() {
		return this.name;
	}
	public void setName(String name)
	{
		this.name=name;
	}
	private SimpleTriggerBean nextTrigger;
	public void setNextTrigger(SimpleTriggerBean nextTrigger) {
		this.nextTrigger = nextTrigger;
	}
	@Override
	public void triggerComplete(Trigger trigger, JobExecutionContext context, int code) {
		try{
		logger.debug("Trigger :"+trigger.getGroup()+"."+trigger.getName()+" completed with code:"+code+",next trigger is "+nextTrigger.getGroup()+"."+nextTrigger.getName());
		if(code!=3)return;
		Scheduler schduler=context.getScheduler();
		JobDetail nextJob=nextTrigger.getJobDetail();
		//查找名称和即将加入的任务一样的任务
		JobDetail oldJob=schduler.getJobDetail(nextJob.getName(),nextJob.getGroup());
		//查找名称和即将加入的触发器一样的触发器
		Trigger oldTrigger=schduler.getTrigger( nextTrigger.getName(),nextTrigger.getGroup());
		
		if(oldJob==null&&oldTrigger==null)//同名的任务和触发器都不存在
		{
			logger.debug("inside scheduleJob."+code);
			schduler.scheduleJob(nextJob,nextTrigger);
		}else//同名的任务或触发器
		{
			
			logger.debug("oldJob==null:"+(oldJob==null));
			logger.debug("oldTrigger==null:"+(oldTrigger==null));	
		}
		super.triggerComplete(trigger, context, code);
		}catch(Exception e)
		{
			e.printStackTrace();
		}
	}
	

}


  这是具体怎样触发的spring的配置文件:

 
<?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:jee="http://www.springframework.org/schema/jee"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
           http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.0.xsd">
    
     <bean
		class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
		<property name="quartzProperties">
			<props>
				<prop key="org.quartz.threadPool.class">
					org.quartz.simpl.SimpleThreadPool
				</prop>
				<prop key="org.quartz.threadPool.threadCount">10</prop>
				<prop key="org.quartz.threadPool.threadPriority">
					5
				</prop>
				<prop
					key="org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread">
					true
				</prop>
			</props>
		</property>
		<property name="triggers">
			<list>
				 <ref bean="provinceTrigger"/>
			</list>
		</property>
		<property name="triggerListeners">
			<list>
				<ref bean="provinceTriggerListener"/>
				<ref bean="cityTriggerListener"/>
				<ref bean="linkTriggerListener"/>
			</list>
		</property>
	</bean>     
     
     <bean id="provinceJob"
		class="org.springframework.scheduling.quartz.JobDetailBean">
		<property name="jobClass">
			<value>com.tms.quartz.jobs.ProvinceJob</value>
		</property>
	</bean>
	<bean id="provinceTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
	   <property name="jobDetail">
        <ref bean="provinceJob" />
    </property>
    <property name="cronExpression">
        <value>0 30 0 * * ?</value>
    </property>
    <property name="triggerListenerNames">
        <list>
           <value>provinceTriggerListener</value>
        </list>
    </property>
	</bean>
	<bean id="provinceTriggerListener" class="com.tms.quartz.listeners.NextJobTriggerListener">
	    <property name="nextTrigger" ref="cityTrigger"></property>
		<property name="name" value="provinceTriggerListener"></property>
	</bean>	
	
	
	<bean id="cityJob"
		class="org.springframework.scheduling.quartz.JobDetailBean">
		<property name="jobClass">
			<value>com.tms.quartz.jobs.CityJob</value>
		</property>
	</bean>
	<bean id="cityTrigger"
		class="org.springframework.scheduling.quartz.SimpleTriggerBean">
		<property name="jobDetail">
			<ref bean="cityJob" />
		</property>
		<property name="startDelay">
			<value>60000</value>
		</property>
		<property name="repeatCount">
			<value>0</value>
		</property>
		<property name="repeatInterval">
			<value>60000</value>
		</property>
		<property name="triggerListenerNames">
		    <list>
		       <value>cityTriggerListener</value>
		    </list>
		</property>
	</bean>	 
	<bean id="cityTriggerListener" class="com.tms.quartz.listeners.NextJobTriggerListener">
	    <property name="nextTrigger" ref="linkTrigger"></property>
		<property name="name" value="cityTriggerListener"></property>
	</bean>	
	
	<!-- 
	<bean id="linkJob"
		class="org.springframework.scheduling.quartz.JobDetailBean">
		<property name="jobClass">
			<value>com.tms.quartz.jobs.CityLinkJob</value>
		</property>
	</bean>
	<bean id="linkTrigger"
		class="org.springframework.scheduling.quartz.SimpleTriggerBean">
		<property name="jobDetail">
			<ref bean="linkJob" />
		</property>
		<property name="startDelay">
			<value>60000</value>
		</property>
		<property name="repeatCount">
			<value>0</value>
		</property>
		<property name="repeatInterval">
			<value>60000</value>
		</property>
		<property name="triggerListenerNames">
		    <list>
		       <value>linkTriggerListener</value>
		    </list>
		</property>
	</bean>	 
	<bean id="linkTriggerListener" class="com.tms.quartz.listeners.NextJobTriggerListener">
	    <property name="nextTrigger" ref="sightTrigger"></property>
		<property name="name" value="linkTriggerListener"></property>
	</bean>	
	 -->
	
	<bean id="sightJob"
		class="org.springframework.scheduling.quartz.JobDetailBean">
		<property name="jobClass">
			<value>com.tms.quartz.jobs.SightJob</value>
		</property>
	</bean>
	<bean id="sightTrigger"
		class="org.springframework.scheduling.quartz.SimpleTriggerBean">
		<property name="jobDetail">
			<ref bean="sightJob" />
		</property>
		<property name="startDelay">
			<value>60000</value>
		</property>
		<property name="repeatCount">
			<value>0</value>
		</property>
		<property name="repeatInterval">
			<value>60000</value>
		</property>
	</bean>	 
</beans>
1
0
分享到:
评论

相关推荐

    Spring中Quartz调度器的使用

    Spring 中 Quartz 调度器的使用 Spring 中 Quartz 调度器的使用是指在 Spring 框架中使用 Quartz 调度器来实现任务调度。Quartz 是一个功能强大且灵活的开源任务调度器,能够满足复杂的任务调度需求。在 Spring 中...

    Spring中Quartz调度器的使用 示例代码

    在Spring框架中集成Quartz调度器,可以实现定时任务的高效管理。Quartz是一个开源的作业调度框架,它允许程序创建、调度和执行任务。在本示例中,我们将探讨如何在Spring应用中配置和使用Quartz,以及通过示例代码来...

    spring任务调度(Quartz )

    3. **调度器配置**:`SchedulerFactoryBean`是Spring对Quartz调度器的包装,它管理所有的触发器和任务。在这里,我们将`cron`触发器添加到调度器中,使得任务与触发器关联起来。 接下来,我们看下服务类和服务的...

    Spring Quartz 调度器

    总结来说,Spring Quartz调度器是企业级应用中实现定时任务的重要工具,通过Spring的管理和Quartz的调度能力,可以方便地创建、调整和监控定时任务,提升系统的自动化程度。通过以上步骤,你可以快速掌握Spring集成...

    spring+quartz任务调度代码版

    Spring框架和Quartz是两个在Java世界里广泛应用的任务调度库。本项目"spring+quartz任务调度代码版"显然是一个结合了这两者的实践案例,旨在展示如何在Spring环境下集成和使用Quartz进行任务调度。 Spring框架是一...

    spring整合quartz定时任务调度

    Spring框架作为Java领域广泛使用的轻量级框架,提供了与第三方库Quartz的整合,使得开发者能够轻松地在Spring应用中实现复杂的定时任务调度。Quartz是一款开源的作业调度框架,支持丰富的调度策略,可以满足各种定时...

    Spring Quartz 任务调度实例

    Spring Quartz 是一个强大的任务调度框架,它允许开发者在Java应用程序中定义和执行定时任务。结合Spring框架,可以方便地在企业级应用中实现复杂的时间触发逻辑。本实例提供了可以直接运行的任务调度解决方案,既...

    spring quartz 任务调度

    Spring框架作为一个全面的企业级应用开发解决方案,提供了强大的任务调度支持,而Quartz则是一个流行的开源作业调度库,能够与Spring很好地集成。现在,我们就来深入探讨"spring quartz 任务调度"这一主题。 首先,...

    Spring+Quartz定时调度

    ### 三、Quartz调度策略 Quartz提供了多种调度策略,包括: - **简单触发器(SimpleTrigger)**:按固定间隔重复执行任务。 - **Cron触发器(CronTrigger)**:基于Cron表达式来定义触发时间,支持复杂的定时规则...

    Spring Quartz 任务调度

    **Spring Quartz 任务调度** Spring Quartz 是一个基于 Java 的任务调度框架,它允许开发者定义定时任务并在应用程序中灵活地调度这些任务。这个框架是 Spring 和 Quartz Scheduler 的集成,提供了与 Spring 框架的...

    Spring+Quartz实现任务调度的小例子

    Spring框架和Quartz是两个广泛使用的工具,它们可以协同工作以实现复杂和灵活的任务调度。本篇文章将深入探讨如何使用Spring与Quartz结合来创建一个任务调度的小例子。 首先,Spring是一个开源的Java企业级应用开发...

    spring+quartz使用jar包

    Spring 集成 Quartz 的目的是为了利用Quartz的调度能力,使应用可以按需执行定时任务。以下是一些关键的知识点: 1. **Spring与Quartz的整合**:Spring 提供了对Quartz的集成支持,通过`org.springframework....

    Java_Spring与Quartz的整合

    而Quartz是一款强大的开源作业调度框架,可以用于在特定时间执行任务,比如定时发送邮件、数据同步等。 在Java Spring中整合Quartz,可以利用Spring的管理能力来控制Quartz的作业和触发器,使得整个系统更加灵活和...

    定时框架spring+quartz

    Spring框架是Java领域最流行的应用框架之一,而Quartz则是广受欢迎的定时任务调度库。"定时框架spring+quartz"的结合,就是将Quartz的定时功能与Spring的强大集成能力完美融合,为开发者提供了一种高效、灵活的定时...

    SpringQuartz的使用文档

    SpringQuartz是一个强大的任务调度框架,它在Java应用程序中用于自动化执行特定任务,如定时生成文件、统计数据或执行后台清理工作。Quartz是开源的,具有高度灵活的调度功能,能够根据预定义的时间表触发任务,同时...

    关于spring中quartz的配置

    在Spring框架中集成Quartz是一款常见的任务调度解决方案,它允许开发者在应用中安排定时任务的执行。Quartz是一个开源的作业调度框架,可以用来在Java应用程序中安排复杂的作业任务。以下将详细介绍如何在Spring中...

    spring整合quartz文档

    Spring 整合 Quartz 是一种常见的任务调度解决方案,用于在应用程序中安排和执行周期性的任务。Quartz 是一个功能丰富的开源任务调度库,适用于 Java 平台,尤其适用于 J2EE 和 J2SE 应用。它允许开发人员精确地定义...

    Spring quartz任务调度

    标题“Spring quartz任务调度”指的是在Java开发中利用Spring框架集成Quartz库来实现应用程序的任务调度功能。Quartz是一款开源的作业调度框架,它允许开发者安排任务在特定时间执行,而Spring框架则提供了与Quartz...

    封装通用的Spring3+Struts2+MyBatis3的CRUD+条件分页查询,Spring+Quartz调度,FunctionCharts图像化工具

    封装通用的Spring3+Struts2+MyBatis3的CRUD+条件分页查询,Spring+Quartz调度,FunctionCharts图像化工具 &lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi=...

    spring的quartz使用实例

    Spring整合Quartz是一款常见的任务调度解决方案,它允许开发者在应用程序中安排定时任务的执行。Quartz是一个开源的作业调度框架,而Spring通过提供一个简洁的API使得与Quartz的集成变得简单。以下是对Spring整合...

Global site tag (gtag.js) - Google Analytics