`

Quartz实现固定执行次数

quartzSpringBeanXMLthread 
阅读更多
Quartz实现固定执行次数
虽然上一讲中说明,在实际应用中很少用到Quartz实现固定执行次数，但是我就是那个钻牛角尖的人.废话不多，代码如下:

实现思路:
1. 在上一讲中说明Quartz的JobDetail可以是无状态的，也可以是有状态的。Trigger无状态的，所以只能使用JobDetail有状态的子接口StatefulJob.Job代码如下: 
package test.quartz.spring;

import java.util.Date;

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.StatefulJob;

public class TJob implements StatefulJob {

	/**
	 * 不用挣扎了，Quartz都是无状态的，他不知道执行了几次。
	 * 如果想要记录状态就需要持久化到数据库.
	 */
	public void execute(JobExecutionContext cntxt) throws JobExecutionException {
		 
		JobDataMap jobDataMap = cntxt.getJobDetail().getJobDataMap();
		Integer count = (Integer) jobDataMap.get("count");
		if(count==null){
			count=0;
		}
		count++;
		 System.out.println("杨春龙,太帅了");
		 System.out.println("不是我说的");
		 System.out.println( " Generating report -  "
	            +  count
	            +  "-"
	            +   new  Date());
		 jobDataMap.put("count", count);
		 cntxt.getJobDetail().setJobDataMap(jobDataMap);
		 

	}

}

根据ApI描述，如果是有状态的Job，所有的Job都共享jobDataMap,所有把执行次数记录下来.虽然我记录了执行次数，但是因为Job是一个Thread，由ThreadPool来维持,那么如何监视Job的执行情况，在看源码中，发现有一个Listener，可以监听进程的执行，代码如下: 
package test.quartz.spring;

import org.quartz.CronTrigger;
import org.quartz.JobExecutionContext;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.listeners.TriggerListenerSupport;

public class TriggerListener extends TriggerListenerSupport {
	
	private String name;  
	
	private Integer count; 
	public void setName(String name)   
    {   
        this.name=name;   
    }   
	
	public String getName() {
		// TODO Auto-generated method stub
		return this.name;
	}
	

	public Integer getCount() {
		return count;
	}

	public void setCount(Integer count) {
		this.count = count;
	}

	@Override
	public void triggerComplete(Trigger trigger, JobExecutionContext context,
			int triggerInstructionCode) {
		System.out.println("Trigger :"+trigger.getGroup()+"."+trigger.getName()+" completed with code:"+triggerInstructionCode);
		Integer current = (Integer) context.getJobDetail().getJobDataMap().get("count");
		System.out.println("调用次数:"+current);  
		if(current == count){
			try {
				context.getScheduler().shutdown();
			} catch (SchedulerException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		super.triggerComplete(trigger, context, triggerInstructionCode);
	}

	

}

在Job的执行中设置执行次数，在监听器中得到执行次数，当执行次数到达count的时候退出执行.
JobQuartz.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="job" class="test.quartz.spring.TJob"></bean>
    <bean id="triggerListener" class="test.quartz.spring.TriggerListener">
    	<property name="name">
    		<value>triggerListener</value>
    	</property>
    	<property name="count">
    		<value>3</value>
    	</property> 
    </bean>
<!-- 定义目标bean和bean中的方法 -->
    <bean id="jobtask" class="org.springframework.scheduling.quartz.JobDetailBean">
    	<property name="jobClass">
    		<value>test.quartz.spring.TJob</value>
   		</property>

    </bean>
<!-- 定义触发的时间 -->
    <bean id = "cron" class = "org.springframework.scheduling.quartz.CronTriggerBean">
    	<!-- jobDetail中的name,group都已经设置 -->
        <property name="jobDetail">
            <ref bean="jobtask"/>
        </property>
        <property name="triggerListenerNames">  
	        <list>  
	           <value>triggerListener</value>  
	        </list>  
    	</property>   
        <property name="cronExpression">
            <value>0/10 * * * * ?</value>
        </property> 
    </bean>
<!-- 总管理 -->
    <bean autowire = "no" class = "org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref local ="cron"/>
            </list>
        </property>
        <!-- 添加监听器 -->
        <property name="triggerListeners">  
            <list>  
                <ref bean="triggerListener"/> 
            </list>  
        </property>  
        
    </bean>

</beans>

在SchedulerFactoryBean中配置监听器列表，在CronTriggerBean配置监听器名称，这样这个监听器就可以监听这个Trigger了，当执行了3次后自动退出
测试代码如下: 
package test.quartz.spring;

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

public class TestSpring {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		System.out.println("测试开始");
        ApplicationContext ctx = new ClassPathXmlApplicationContext("JobQuartz.xml");
        System.out.println("测试结束");

	}

}

测试输出如下:
测试开始 
2010-09-27 09:33:39,640 INFO [org.springframework.context.support.ClassPathXmlApplicationContext] - <Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@3e86d0: display name [org.springframework.context.support.ClassPathXmlApplicationContext@3e86d0]; startup date [Mon Sep 27 09:33:39 CST 2010]; root of context hierarchy>
2010-09-27 09:33:39,718 INFO [org.springframework.beans.factory.xml.XmlBeanDefinitionReader] - <Loading XML bean definitions from class path resource [JobQuartz.xml]>
2010-09-27 09:33:39,781 INFO [org.springframework.context.support.ClassPathXmlApplicationContext] - <Bean factory for application context [org.springframework.context.support.ClassPathXmlApplicationContext@3e86d0]: org.springframework.beans.factory.support.DefaultListableBeanFactory@197a37c>
2010-09-27 09:33:39,812 INFO [org.springframework.beans.factory.support.DefaultListableBeanFactory] - <Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@197a37c: defining beans [job,triggerListener,jobtask,cron,org.springframework.scheduling.quartz.SchedulerFactoryBean#0]; root of factory hierarchy>
2010-09-27 09:33:39,953 INFO [org.quartz.core.SchedulerSignalerImpl] - <Initialized Scheduler Signaller of type: class org.quartz.core.SchedulerSignalerImpl>
2010-09-27 09:33:39,953 INFO [org.quartz.core.QuartzScheduler] - <Quartz Scheduler v.1.8.3 created.>
2010-09-27 09:33:39,953 INFO [org.quartz.simpl.RAMJobStore] - <RAMJobStore initialized.>
2010-09-27 09:33:39,953 INFO [org.quartz.core.QuartzScheduler] - <Scheduler meta-data: Quartz Scheduler (v1.8.3) 'org.springframework.scheduling.quartz.SchedulerFactoryBean#0' with instanceId 'NON_CLUSTERED'
  Scheduler class: 'org.quartz.core.QuartzScheduler' - running locally.
  NOT STARTED.
  Currently in standby mode.
  Number of jobs executed: 0
  Using thread pool 'org.quartz.simpl.SimpleThreadPool' - with 10 threads.
  Using job-store 'org.quartz.simpl.RAMJobStore' - which does not support persistence. and is not clustered.
>
2010-09-27 09:33:39,953 INFO [org.quartz.impl.StdSchedulerFactory] - <Quartz scheduler 'org.springframework.scheduling.quartz.SchedulerFactoryBean#0' initialized from an externally provided properties instance.>
2010-09-27 09:33:39,953 INFO [org.quartz.impl.StdSchedulerFactory] - <Quartz scheduler version: 1.8.3>
2010-09-27 09:33:39,953 INFO [org.quartz.core.QuartzScheduler] - <JobFactory set to: org.springframework.scheduling.quartz.AdaptableJobFactory@1b09468>
2010-09-27 09:33:39,953 INFO [org.springframework.scheduling.quartz.SchedulerFactoryBean] - <Starting Quartz Scheduler now>
2010-09-27 09:33:39,953 INFO [org.quartz.core.QuartzScheduler] - <Scheduler org.springframework.scheduling.quartz.SchedulerFactoryBean#0_$_NON_CLUSTERED started.>
测试结束
杨春龙,太帅了
不是我说的
 Generating report -  1-Mon Sep 27 09:33:40 CST 2010
Trigger :DEFAULT.cron completed with code:0
调用次数:1
杨春龙,太帅了
不是我说的
 Generating report -  2-Mon Sep 27 09:33:50 CST 2010
Trigger :DEFAULT.cron completed with code:0
调用次数:2
杨春龙,太帅了
不是我说的
 Generating report -  3-Mon Sep 27 09:34:00 CST 2010
Trigger :DEFAULT.cron completed with code:0
调用次数:3
2010-09-27 09:34:00,000 INFO [org.quartz.core.QuartzScheduler] - <Scheduler org.springframework.scheduling.quartz.SchedulerFactoryBean#0_$_NON_CLUSTERED shutting down.>
2010-09-27 09:34:00,000 INFO [org.quartz.core.QuartzScheduler] - <Scheduler org.springframework.scheduling.quartz.SchedulerFactoryBean#0_$_NON_CLUSTERED paused.>
2010-09-27 09:34:00,000 INFO [org.quartz.core.QuartzScheduler] - <Scheduler org.springframework.scheduling.quartz.SchedulerFactoryBean#0_$_NON_CLUSTERED shutdown complete.>
分享到：
| Quartz入门(三)
评论
1 楼 chxiaowu 2016-10-08  
nice！
发表评论

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

相关推荐

    Quartz动态项目案例。

    3. **执行次数**：你可以指定任务应该执行多少次，或者持续执行直到被手动停止。这可以通过在触发器中设置重复计数和重复间隔来实现。 4. **执行间隔**：这是指两次任务执行之间的等待时间。可以设置为固定时间间隔...

    Quartz定时任务持久化数据表

    在Java应用中，Quartz常被用来实现后台任务的自动化，比如定时发送邮件、数据备份等。在分布式环境中，Quartz还支持集群，确保任务的高可用性。 Quartz的定时任务持久化是指将任务的相关信息（如触发器、作业详情）...

    quartz-job初始化数据表.zip

    使用Quartz，你可以轻松地实现复杂的定时任务调度，例如每天固定时间运行报表生成任务，或者在系统空闲时自动执行维护操作。通过Cron表达式，你可以定义任意精细的触发规则，使得Job能够按照你需要的任何时间模式...

    Quartz学习资料

    SimpleTrigger用于按固定间隔或特定次数重复执行Job，而CronTrigger则可以根据预定义的cron表达式（类似Linux cron服务）定时执行。 3. **Scheduler**: Scheduler是Quartz的中心管理实体，它负责管理和执行所有的...

    Quartz之SimpleTrigger

    - 当任务的执行时间不固定或者需要更复杂的调度逻辑时，可以考虑使用CronTrigger或CalendarIntervalTrigger替代SimpleTrigger。 - 调度器的线程池大小和并发执行策略需要根据实际需求调整，以避免资源争抢。 - ...

    详解.NET Core使用Quartz执行调度任务进阶

    .NET Core使用Quartz执行调度任务是一项常见的需求，尤其是在需要定期执行特定业务逻辑的场景中。Quartz.Net是一个功能丰富的开源任务调度框架，适用于多种.NET环境，包括.NET Core。本文将深入探讨如何在.NET Core ...

    quartz简单实例quartz简单实例

    Quartz 提供了丰富的调度选项，包括但不限于一次性任务、固定频率的任务以及基于日历的任务。 ### 二、代码解析 #### 1. 定义作业 (Job) 首先定义了一个实现了 `Job` 接口的类 `MyJob`。这个类包含了一个方法 `...

    Spring整合Quartz

    CronTrigger基于Cron表达式，而SimpleTrigger则按照固定间隔或特定次数触发。 ```xml &lt;bean id="myTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"&gt; * * * ?" /&gt; &lt;!-- 每5分钟执行一次...

    quartz

    你可以设定初始延迟、重复间隔以及最大执行次数。 4. **Scheduler**: Scheduler 是 Quartz 的核心组件，负责管理所有的 Job 和 Trigger，以及它们之间的关系。你可以通过 `Scheduler` 对象来安排 Job 的执行、暂停...

    Quartz的使用说明.doc

    - **SimpleTrigger**：适用于设置一次性或重复执行的简单定时任务，如在特定时间开始，每隔一定时间执行一次，总共执行固定次数。 - **CronTrigger**：使用 cron 表达式来定义更复杂的调度规则，如每月最后一个...

    定时器quartZ

    - **SimpleTrigger**：指定开始时间和重复次数，适合一次性或固定间隔的触发。 4. **并发控制**： - Quartz支持单实例或多实例模式，可以避免多个实例同时执行同一Job。 - `ConcurrentJobExecutionDisallowed`...

    Quartz2.2版本开发手册（JAVA）.doc

    5. **Quartz 手册 java 版-(五) SimpleTrigger**：SimpleTrigger 是一种基础的触发器，用于按照固定间隔重复执行 Job。开发者需要了解如何设置重复次数、间隔时间和结束时间。 6. **Quartz 手册 java 版-(六)...

    Quartz学习.doc

    - 重复执行（固定次数、固定时间、无限次、固定间隔） - **任务标识**：任务和触发器均可以设置名称和分组，方便管理和组织。 - **多触发器注册**：单个任务可由多个触发器触发执行。 #### 四、任务执行 - **任务...

    定时器Quartz使用说明

    - **固定间隔**：可以根据固定的间隔时间来重复执行任务。 #### 三、JobExecution（任务执行） - **自定义任务**：任务本身是由开发者实现的简单 Java 类，只需实现 `Job` 接口即可。 - **任务实例化**：任务类的...

    实现quartz定时器及quartz定时器原理介绍

    以下是一个使用Quartz实现的简单定时任务示例： ```java // 定义Job public class MyJob implements Job { public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException { ...

    quartz教程

    - **Job（任务）**：这是Quartz中执行的具体工作单元，开发者需要实现`Job`接口并重写`execute`方法，该方法将在任务被触发时执行。`JobExecutionContext`提供了一种方式来访问与调度相关的上下文信息。 - **...

    Quartz开发指南

    - **循环执行**：按照固定的次数或直到达到特定时间为止。 - **无限循环**：持续执行任务，除非手动停止。 - **固定频率**：每隔一段时间执行一次任务。 每个任务都有唯一的名字，并可以归属于特定的组，以便更好地...

    Quartz学习

    1. **Job**：在Quartz中，Job是一个实现了`org.quartz.Job`接口的类，代表一个可执行的任务。每个Job实例都有一个唯一的标识（JobKey），并可以通过`execute()`方法执行具体业务逻辑。 2. **Trigger**：Trigger定义...

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