作业调度框架 Quartz 学习笔记(四) -- 接收参数和维护状态

最新推荐文章于 2022-04-21 22:49:36 发布
最新推荐文章于 2022-04-21 22:49:36 发布
阅读量843 收藏
点赞数
分类专栏： JAVA

<<Quartz中Job的参数传递和状态保存>>

如果你想在 某个job执行的时候传入参数,参数在job执行过程中对参数有所修改,并且在job执行完毕后把参数返回
那么你需要学习一下现在的这个例子了,因为它正是你所想要的 ......

 

我的建议是先把代码运行起来看结果,然后再去看代码.

还是老套路,两个类 一个job类:ColorJob.java   一个调度类: JobStateExample.java

代码 :

ColorJob.java

[java] view plain copy print ?
  1. /** 
  2.  * <p> 这只是一个简单的工作,接收参数和维护状态  </p> 
  3.  */  
  4. <span style="color: rgb(102, 0, 0);"><span style="background-color: rgb(255, 204, 255);">//小心,这里的注释很重要</span>  
  5. </span>@PersistJobDataAfterExecution    
  6. @DisallowConcurrentExecution  
  7. public class ColorJob implements Job {  
  8.     // 静态变量  
  9.     public static final String FAVORITE_COLOR = "favorite color";  
  10.     public static final String EXECUTION_COUNT = "count";  
  11.   
  12.     // Quartz 将每次将会重新实例化对象 ，非静态的成员变量不能用来保持状态  
  13.     private int _counter = 1;  
  14.   
  15.     @Override   
  16.     public void execute(JobExecutionContext context)  
  17.             throws JobExecutionException {  
  18.         // job 的名字  
  19.         String jobName = context.getJobDetail().getKey().getName();  
  20.         // 任务执行的时间  
  21.         SimpleDateFormat dateFormat = new SimpleDateFormat(  
  22.                 "yyyy 年 MM 月 dd 日  HH 时 mm 分 ss 秒");  
  23.         String jobRunTime = dateFormat.format(Calendar.getInstance().getTime());  
  24.   
  25.         // 获取 JobDataMap , 并从中取出参数   
  26.         JobDataMap data = context.getJobDetail().getJobDataMap();  
  27.         String favoriteColor = data.getString(FAVORITE_COLOR);  
  28.         int count = data.getInt(EXECUTION_COUNT);  
  29.         System.out  
  30.                 .println("ColorJob: " + jobName + " 在 " + jobRunTime + " 执行了 ...  \n"  
  31.                         + "      喜欢的颜色是：  " + favoriteColor + "\n"  
  32.                         + "      执行次数统计(from job jobDataMap)： " + count + "\n"  
  33.                         + "      执行次数统计( from job 类的成员变 量 ): "  
  34.                         + _counter+ " \n ");  
  35.         // 每次+1 并放回Map 中  
  36.         count++;  
  37.         data.put(EXECUTION_COUNT, count);  
  38.         // 成员变量的增加没有意义，每次实例化对象的时候会 同时初始化该变量  
  39.         _counter++;  
  40.     }  
  41. }  
/**
 * <p> 这只是一个简单的工作,接收参数和维护状态  </p>
 */
<span style="color: rgb(102, 0, 0);"><span style="background-color: rgb(255, 204, 255);">//小心,这里的注释很重要</span>
</span>@PersistJobDataAfterExecution  
@DisallowConcurrentExecution
public class ColorJob implements Job {
	// 静态变量
	public static final String FAVORITE_COLOR = "favorite color";
	public static final String EXECUTION_COUNT = "count";

	// Quartz 将每次将会重新实例化对象 ，非静态的成员变量不能用来保持状态
	private int _counter = 1;

	@Override 
	public void execute(JobExecutionContext context)
			throws JobExecutionException {
		// job 的名字
		String jobName = context.getJobDetail().getKey().getName();
		// 任务执行的时间
		SimpleDateFormat dateFormat = new SimpleDateFormat(
				"yyyy 年 MM 月 dd 日  HH 时 mm 分 ss 秒");
		String jobRunTime = dateFormat.format(Calendar.getInstance().getTime());

		// 获取 JobDataMap , 并从中取出参数 
		JobDataMap data = context.getJobDetail().getJobDataMap();
		String favoriteColor = data.getString(FAVORITE_COLOR);
		int count = data.getInt(EXECUTION_COUNT);
		System.out
				.println("ColorJob: " + jobName + " 在 " + jobRunTime + " 执行了 ...  \n"
						+ "      喜欢的颜色是：  " + favoriteColor + "\n"
						+ "      执行次数统计(from job jobDataMap)： " + count + "\n"
						+ "      执行次数统计( from job 类的成员变 量 ): "
						+ _counter+ " \n ");
		// 每次+1 并放回Map 中
		count++;
		data.put(EXECUTION_COUNT, count);
		// 成员变量的增加没有意义，每次实例化对象的时候会 同时初始化该变量
		_counter++;
	}
}

JobStateExample.java

[java] view plain copy print ?
  1. import static org.quartz.DateBuilder.nextGivenSecondDate;  
  2. import static org.quartz.JobBuilder.newJob;  
  3. import static org.quartz.SimpleScheduleBuilder.simpleSchedule;  
  4. import static org.quartz.TriggerBuilder.newTrigger;  
  5. import java.text.SimpleDateFormat;  
  6. import java.util.Date;  
  7. import org.quartz.JobDetail;  
  8. import org.quartz.Scheduler;  
  9. import org.quartz.SchedulerFactory;  
  10. import org.quartz.SchedulerMetaData;  
  11. import org.quartz.SimpleTrigger;  
  12. import org.quartz.impl.StdSchedulerFactory;  
  13.   
  14. public class JobStateExample {  
  15.   
  16.     public static void main(String[] args) throws Exception {  
  17.         JobStateExample example = new JobStateExample();  
  18.         example.run();  
  19.     }  
  20.   
  21.     public void run() throws Exception {  
  22.   
  23.         // 日期格式化  
  24.         SimpleDateFormat dateFormat = new SimpleDateFormat(  
  25.                 "yyyy 年 MM 月 dd 日  HH 时 mm 分 ss 秒");  
  26.         SchedulerFactory sf = new StdSchedulerFactory();  
  27.         Scheduler sched = sf.getScheduler();  
  28.         System.out.println("--------------- 初始化 -------------------");  
  29.   
  30.         // 下一个10秒，不懂的去查API  
  31.         Date startTime = nextGivenSecondDate(null, 10);  
  32.   
  33.         // job1 第10秒执行一次，共执行5次  
  34.         JobDetail job1 = newJob(ColorJob.class).withIdentity("job1", "group1")  
  35.                 .build();  
  36.   
  37.         SimpleTrigger trigger1 = newTrigger()  
  38.                 .withIdentity("trigger1", "group1")  
  39.                 .startAt(startTime)  
  40.                 .withSchedule(  
  41.                         simpleSchedule().withIntervalInSeconds(10)  
  42.                                 .withRepeatCount(4)).build();  
  43.   
  44.         // 初始化传入的参数  
  45.         job1.getJobDataMap().put(ColorJob.FAVORITE_COLOR, "######  绿   #####");  
  46.         job1.getJobDataMap().put(ColorJob.EXECUTION_COUNT, 1);  
  47.   
  48.         Date scheduleTime1 = sched.scheduleJob(job1, trigger1);  
  49.         System.out.println(job1.getKey().getName() + " 将在 : "  
  50.                 + dateFormat.format(scheduleTime1) + " 执行, 并重复 : "  
  51.                 + trigger1.getRepeatCount() + " 次, 每次间隔   "  
  52.                 + trigger1.getRepeatInterval() / 1000 + " 秒");  
  53.   
  54.         // job2 每10秒执行一次，共执行5次  
  55.         JobDetail job2 = newJob(ColorJob.class).withIdentity("job2", "group1")  
  56.                 .build();  
  57.   
  58.         SimpleTrigger trigger2 = newTrigger()  
  59.                 .withIdentity("trigger2", "group1")  
  60.                 .startAt(startTime)  
  61.                 .withSchedule(  
  62.                         simpleSchedule().withIntervalInSeconds(10)  
  63.                                 .withRepeatCount(4)).build();  
  64.   
  65.         // 初始化传入的参数  
  66.         job2.getJobDataMap().put(ColorJob.FAVORITE_COLOR, "######  红   #####");  
  67.         job2.getJobDataMap().put(ColorJob.EXECUTION_COUNT, 1);  
  68.   
  69.         Date scheduleTime2 = sched.scheduleJob(job2, trigger2);  
  70.         System.out.println(job2.getKey().getName() + " 将在 : "  
  71.                 + dateFormat.format(scheduleTime2) + " 执行, 并重复 : "  
  72.                 + trigger2.getRepeatCount() + " 次, 每次间隔   "  
  73.                 + trigger2.getRepeatInterval() / 1000 + " 秒");  
  74.   
  75.         System.out.println("------- 开始调度 (调用.start()方法) ----------------");  
  76.         sched.start();  
  77.   
  78.         System.out.println("------- 等待60秒 ... -------------");  
  79.         try {  
  80.             Thread.sleep(60L * 1000L);  
  81.         } catch (Exception e) {  
  82.         }  
  83.   
  84.         sched.shutdown(true);  
  85.         System.out.println("------- 调度已关闭 ---------------------");  
  86.   
  87.         // 显示一下 已经执行的任务信息  
  88.         SchedulerMetaData metaData = sched.getMetaData();  
  89.         System.out.println("~~~~~~~~~~  执行了 "  
  90.                 + metaData.getNumberOfJobsExecuted() + " 个 jobs.");  
  91.   
  92.         /* 
  93.         如果你想在 某个job执行的时候传入参数,参数在job执行过程中对参数有所修改,并且在job执行完毕后把参数返回 
  94.         那么你需要学习一下现在的这个例子了,因为它正是你所想要的 
  95.          */  
  96.     }  
  97.   
  98. }  
import static org.quartz.DateBuilder.nextGivenSecondDate;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
import static org.quartz.TriggerBuilder.newTrigger;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.SchedulerMetaData;
import org.quartz.SimpleTrigger;
import org.quartz.impl.StdSchedulerFactory;

public class JobStateExample {

	public static void main(String[] args) throws Exception {
		JobStateExample example = new JobStateExample();
		example.run();
	}

	public void run() throws Exception {

		// 日期格式化
		SimpleDateFormat dateFormat = new SimpleDateFormat(
				"yyyy 年 MM 月 dd 日  HH 时 mm 分 ss 秒");
		SchedulerFactory sf = new StdSchedulerFactory();
		Scheduler sched = sf.getScheduler();
		System.out.println("--------------- 初始化 -------------------");

		// 下一个10秒，不懂的去查API
		Date startTime = nextGivenSecondDate(null, 10);

		// job1 第10秒执行一次，共执行5次
		JobDetail job1 = newJob(ColorJob.class).withIdentity("job1", "group1")
				.build();

		SimpleTrigger trigger1 = newTrigger()
				.withIdentity("trigger1", "group1")
				.startAt(startTime)
				.withSchedule(
						simpleSchedule().withIntervalInSeconds(10)
								.withRepeatCount(4)).build();

		// 初始化传入的参数
		job1.getJobDataMap().put(ColorJob.FAVORITE_COLOR, "######  绿   #####");
		job1.getJobDataMap().put(ColorJob.EXECUTION_COUNT, 1);

		Date scheduleTime1 = sched.scheduleJob(job1, trigger1);
		System.out.println(job1.getKey().getName() + " 将在 : "
				+ dateFormat.format(scheduleTime1) + " 执行, 并重复 : "
				+ trigger1.getRepeatCount() + " 次, 每次间隔   "
				+ trigger1.getRepeatInterval() / 1000 + " 秒");

		// job2 每10秒执行一次，共执行5次
		JobDetail job2 = newJob(ColorJob.class).withIdentity("job2", "group1")
				.build();

		SimpleTrigger trigger2 = newTrigger()
				.withIdentity("trigger2", "group1")
				.startAt(startTime)
				.withSchedule(
						simpleSchedule().withIntervalInSeconds(10)
								.withRepeatCount(4)).build();

		// 初始化传入的参数
		job2.getJobDataMap().put(ColorJob.FAVORITE_COLOR, "######  红   #####");
		job2.getJobDataMap().put(ColorJob.EXECUTION_COUNT, 1);

		Date scheduleTime2 = sched.scheduleJob(job2, trigger2);
		System.out.println(job2.getKey().getName() + " 将在 : "
				+ dateFormat.format(scheduleTime2) + " 执行, 并重复 : "
				+ trigger2.getRepeatCount() + " 次, 每次间隔   "
				+ trigger2.getRepeatInterval() / 1000 + " 秒");

		System.out.println("------- 开始调度 (调用.start()方法) ----------------");
		sched.start();

		System.out.println("------- 等待60秒 ... -------------");
		try {
			Thread.sleep(60L * 1000L);
		} catch (Exception e) {
		}

		sched.shutdown(true);
		System.out.println("------- 调度已关闭 ---------------------");

		// 显示一下 已经执行的任务信息
		SchedulerMetaData metaData = sched.getMetaData();
		System.out.println("~~~~~~~~~~  执行了 "
				+ metaData.getNumberOfJobsExecuted() + " 个 jobs.");

		/*
		如果你想在 某个job执行的时候传入参数,参数在job执行过程中对参数有所修改,并且在job执行完毕后把参数返回
		那么你需要学习一下现在的这个例子了,因为它正是你所想要的
		 */
	}

}


执行结果 :

[plain] view plain copy print ?
  1. --------------- 初始化 -------------------  
  2. job1 将在 : 2013 年 03 月 07 日  14 时 02 分 00 秒 执行, 并重复 : 4 次, 每次间隔   10 秒  
  3. job2 将在 : 2013 年 03 月 07 日  14 时 02 分 00 秒 执行, 并重复 : 4 次, 每次间隔   10 秒  
  4. ------- 开始调度 (调用.start()方法) ----------------  
  5. ------- 等待60秒 ... -------------  
  6. ColorJob: job2 在 2013 年 03 月 07 日  14 时 02 分 00 秒 执行了 ...    
  7.       喜欢的颜色是：  ######  红   #####  
  8.       执行次数统计(from job jobDataMap)： 1  
  9.       执行次数统计( from job 类的成员变 量 ): 1   
  10.    
  11. ColorJob: job1 在 2013 年 03 月 07 日  14 时 02 分 00 秒 执行了 ...    
  12.       喜欢的颜色是：  ######  绿   #####  
  13.       执行次数统计(from job jobDataMap)： 1  
  14.       执行次数统计( from job 类的成员变 量 ): 1   
  15.    
  16. ColorJob: job1 在 2013 年 03 月 07 日  14 时 02 分 10 秒 执行了 ...    
  17.       喜欢的颜色是：  ######  绿   #####  
  18.       执行次数统计(from job jobDataMap)： 2  
  19.       执行次数统计( from job 类的成员变 量 ): 1   
  20.    
  21. ColorJob: job2 在 2013 年 03 月 07 日  14 时 02 分 10 秒 执行了 ...    
  22.       喜欢的颜色是：  ######  红   #####  
  23.       执行次数统计(from job jobDataMap)： 2  
  24.       执行次数统计( from job 类的成员变 量 ): 1   
  25.    
  26. ColorJob: job1 在 2013 年 03 月 07 日  14 时 02 分 20 秒 执行了 ...    
  27.       喜欢的颜色是：  ######  绿   #####  
  28.       执行次数统计(from job jobDataMap)： 3  
  29.       执行次数统计( from job 类的成员变 量 ): 1   
  30.    
  31. ColorJob: job2 在 2013 年 03 月 07 日  14 时 02 分 20 秒 执行了 ...    
  32.       喜欢的颜色是：  ######  红   #####  
  33.       执行次数统计(from job jobDataMap)： 3  
  34.       执行次数统计( from job 类的成员变 量 ): 1   
  35.    
  36. ColorJob: job1 在 2013 年 03 月 07 日  14 时 02 分 30 秒 执行了 ...    
  37.       喜欢的颜色是：  ######  绿   #####  
  38.       执行次数统计(from job jobDataMap)： 4  
  39.       执行次数统计( from job 类的成员变 量 ): 1   
  40.    
  41. ColorJob: job2 在 2013 年 03 月 07 日  14 时 02 分 30 秒 执行了 ...    
  42.       喜欢的颜色是：  ######  红   #####  
  43.       执行次数统计(from job jobDataMap)： 4  
  44.       执行次数统计( from job 类的成员变 量 ): 1   
  45.    
  46. ColorJob: job1 在 2013 年 03 月 07 日  14 时 02 分 40 秒 执行了 ...    
  47.       喜欢的颜色是：  ######  绿   #####  
  48.       执行次数统计(from job jobDataMap)： 5  
  49.       执行次数统计( from job 类的成员变 量 ): 1   
  50.    
  51. ColorJob: job2 在 2013 年 03 月 07 日  14 时 02 分 40 秒 执行了 ...    
  52.       喜欢的颜色是：  ######  红   #####  
  53.       执行次数统计(from job jobDataMap)： 5  
  54.       执行次数统计( from job 类的成员变 量 ): 1   
  55.    
  56. ------- 调度已关闭 ---------------------  
  57. ~~~~~~~~~~  执行了 10 个 jobs.  
--------------- 初始化 -------------------
job1 将在 : 2013 年 03 月 07 日  14 时 02 分 00 秒 执行, 并重复 : 4 次, 每次间隔   10 秒
job2 将在 : 2013 年 03 月 07 日  14 时 02 分 00 秒 执行, 并重复 : 4 次, 每次间隔   10 秒
------- 开始调度 (调用.start()方法) ----------------
------- 等待60秒 ... -------------
ColorJob: job2 在 2013 年 03 月 07 日  14 时 02 分 00 秒 执行了 ...  
      喜欢的颜色是：  ######  红   #####
      执行次数统计(from job jobDataMap)： 1
      执行次数统计( from job 类的成员变 量 ): 1 
 
ColorJob: job1 在 2013 年 03 月 07 日  14 时 02 分 00 秒 执行了 ...  
      喜欢的颜色是：  ######  绿   #####
      执行次数统计(from job jobDataMap)： 1
      执行次数统计( from job 类的成员变 量 ): 1 
 
ColorJob: job1 在 2013 年 03 月 07 日  14 时 02 分 10 秒 执行了 ...  
      喜欢的颜色是：  ######  绿   #####
      执行次数统计(from job jobDataMap)： 2
      执行次数统计( from job 类的成员变 量 ): 1 
 
ColorJob: job2 在 2013 年 03 月 07 日  14 时 02 分 10 秒 执行了 ...  
      喜欢的颜色是：  ######  红   #####
      执行次数统计(from job jobDataMap)： 2
      执行次数统计( from job 类的成员变 量 ): 1 
 
ColorJob: job1 在 2013 年 03 月 07 日  14 时 02 分 20 秒 执行了 ...  
      喜欢的颜色是：  ######  绿   #####
      执行次数统计(from job jobDataMap)： 3
      执行次数统计( from job 类的成员变 量 ): 1 
 
ColorJob: job2 在 2013 年 03 月 07 日  14 时 02 分 20 秒 执行了 ...  
      喜欢的颜色是：  ######  红   #####
      执行次数统计(from job jobDataMap)： 3
      执行次数统计( from job 类的成员变 量 ): 1 
 
ColorJob: job1 在 2013 年 03 月 07 日  14 时 02 分 30 秒 执行了 ...  
      喜欢的颜色是：  ######  绿   #####
      执行次数统计(from job jobDataMap)： 4
      执行次数统计( from job 类的成员变 量 ): 1 
 
ColorJob: job2 在 2013 年 03 月 07 日  14 时 02 分 30 秒 执行了 ...  
      喜欢的颜色是：  ######  红   #####
      执行次数统计(from job jobDataMap)： 4
      执行次数统计( from job 类的成员变 量 ): 1 
 
ColorJob: job1 在 2013 年 03 月 07 日  14 时 02 分 40 秒 执行了 ...  
      喜欢的颜色是：  ######  绿   #####
      执行次数统计(from job jobDataMap)： 5
      执行次数统计( from job 类的成员变 量 ): 1 
 
ColorJob: job2 在 2013 年 03 月 07 日  14 时 02 分 40 秒 执行了 ...  
      喜欢的颜色是：  ######  红   #####
      执行次数统计(from job jobDataMap)： 5
      执行次数统计( from job 类的成员变 量 ): 1 
 
------- 调度已关闭 ---------------------
~~~~~~~~~~  执行了 10 个 jobs.

 

说明 :

JobStateExample.java 类中 的 47/48 、68/69 行代码 向JobDataMap 中放入值


ColorJob.java 类的 38-49 行对其进行了操作,然后又将参数放回到 JobDataMap中 

 对于单个任务来说：

  • 普通私有成员变量的操作不会影响到下次执行结果，_counter每次执行都是初始值1
  • JobDataMap容器中保存的favorite color 、count  可以保持状态和参数传递

参数传递和状态处理方式：

 1.参数传递。使用job.getJobDataMap().put()方式向Job当中传递参数，JobDataMap类实际上最终继承了实现Map接口的"DirtyFlagMap"类，而DirtyFlagMap内部又保存了一个HashMap的引用，操作都是针对这个HashMap进行的。

2.JobDataMap的持久化 即PersistJobDataAfterExecution这个注解的使用。加上注解之后，每次执行完，JobDataMap都会被序列化，上次任务执行放入的值都会保存下来。

关于ColorJob.java   17/18  行的注解:

@PersistJobDataAfterExecution   保存在JobDataMap传递的参数

   
@DisallowConcurrentExecution   保证多个任务间不会同时执行.所以在多任务执行时最好加上

    英文好的可以 去看看这个 http://forums.terracotta.org/forums/posts/list/6777.page

蜗牛大侠
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用Quartz配置动态定时任务(总结)
qq_38940088的博客
09-21 414
应用场景:需要在一个指定日期的前一天的23点59分来触发这个定时任务 这里分为三个主要的步骤: 1.编写一个定时任务工具类:ScheduleUtils 2.编写一个执行任务类(实现job类):CheckInocPlanJob implements Job 3.调用定时工具类的方法来触发定时任务 1.编写一个定时任务工具类:ScheduleUtils package com.zhite.
学习笔记_Quartz作业调度框架，使用corn表达式
04-08
NULL 博文链接：https://403018322.iteye.com/blog/1613610
quartz有状态Job和无状态Job
11-16
有状态Job和无状态Job 描述>=20个字符,不支持HTML标签。 详细的资源描述有机会获得我们的推荐，更有利于他人下载，赚取更多积分。
Quartz.NET开源作业调度框架系列(三):IJobExecutionContext 参数传递
weixin_34062329的博客
12-03 572
　　前面写了关于Quartz.NET开源作业调度框架的入门和Cron Trigger , 这次继续这个系列, 这次想讨论一下Quartz.NET中的Job如何通过执行上下文(Execution Contex)进行参数传递 , 有些参数想保存状态该如何处理 . 在Quartz.NET中可以用JobDataMap进行参数传递.本例用Quartz.NET的任务来定期轮询数据库表,当数据库的条目达到一定的...
Quartz 之 处理Job 异常
我是小坏
07-10 5434
此示例旨在演示如何处理作业执行异常。允许Quartz中的作业抛出jobexecutionexception异常。当抛出此异常时，您可以指示quartz采取什么操作。 程序将执行以下操作: 启动Quartz调度器 调度两个作业，每个作业将不确定地每三秒执行一次 作业将抛出一个异常，quartz将采取适当的操作 程序将等待60秒，以便两个作业有足够的时间运行 关闭调度程序 代码位置在包：com.example07 BadJob1是一个简单的任务，它只创建一个人工异常(除以0)。当捕获此异常时，..
springBoot整合Quartz定时任务
袁小懒
03-01 489
1.Quartz简介(可参考官方文档https://www.w3cschool.cn/quartz_doc/quartz_doc-1xbu2clr.html) //DSL静态导入 import static org.quartz.JobBuilder.newJob; import static org.quartz.TriggerBuilder.newTrigger; //下面的事调度器的接口...
Quartz一个开源的作业调度框架
08-20
Quartz是一个开源的作业调度框架
Quartz开源作业调度库-其他
06-12
Quartz是功能强大的开源作业调度库，几乎可以集成到任何Java应用程序中-从最小的独立应用程序到最大的电子商务系统。Quartz可用于创建简单或复杂的计划，以执行数以万计，数以万计的工作。任务定义为标准Java组件的...
Quartz - 作业调度框架
05-14
Quartz，作业调度框架，简单的作业调度，定时,junit测试quartz
任务调度开源框架Quartz动态添加、修改和删除定时任务
07-07
Quartz框架包含了调度器监听、作业和触发器监听。你可以配置作业和触发器监听为全局监听或者是特定于作业和触发器的监听。Quartz 允许开发人员根据时间间隔（或天）来调度作业。它实现了作业和触发器的多对多关系，...
使用quartz时，传入参数到job中使用记录
qq_37461349的博客
11-14 3759
在使用quartz的时候不免会遇到需要在触发定时任务的时候需要传入对应参数进去，刚好遇到这个问题，随手记录下： 例子： 在调用的时候直接传入map类型的参数（此处是封装了，故可以直接调用） @PostConstruct public void test(){ try { Map param = new HashMap(); param.put("tok...
Quartz 之 Job参数 和 Job状态
我是小坏
03-24 2005
项目地址： https://github.com/yuleiqq/quartz_example/tree/master/quartz_study 此示例旨在演示如何将运行时参数传递给quartz作业，以及如何维护作业中的状态。 程序将执行以下操作: 启动Quartz调度器 调度两个作业，每个作业将执行总共10秒一次 调度程序将向第一个作业实例传...
spring使用quartz定时调用
anrenxiao9916的博客
07-24 204
建sql语句，用来建表的 1 CREATE TABLE `QRTZ_BLOB_TRIGGERS` ( `SCHED_NAME` varchar(120) NOT NULL, `TRIGGER_NAME` varchar(200) NOT NULL, `TRIGGER_GROUP` varchar(200) NOT NULL, `BLOB_DATA` blo...
定时任务Quartz
weixin_39819880的博客
12-04 181
定时任务Quartz 1.简单java项目中使用Quartz 项目结构 只需要引入4个jar包即可 QuartzUtils.java (工具类) package com.lbl.quartz.utils; import static org.quartz.JobBuilder.newJob; import static org.quartz.JobKey.jobKey; import sta...
java quartz JobBuilder
Claroja
02-23 686
JobBuilder主要主要用来创建JobDetail,常用两个属性: .withIdentity("job1", "group1") //设置job的名称和分组,以便后期的查找 .usingJobData("key","value") // 使用JobData向job中传递参数 完整代码演示: package com; import org.quartz.*; import org.quartz.impl.StdSchedulerFactory; import java.io.IOException;
[springboot]集成org.quartz-scheduler进行任务调度(定时任务)
s_156的博客
11-30 2815
前言 springboot内置有org.springframework.scheduling.annotation.Scheduled可以让我们进行简单快速的任务调度（例如定时执行的任务），当我们一些和任务调度有关的业务开始复杂的时候，极其需要非常灵活的任务调度策略；在这种情况，博主使用了quartz，写下此文以记； 依赖（gradle） compile group: 'org.quartz-scheduler', name: 'quartz', version: '2.2.1' quartz的配置文件
quartz 中JobExecutionContext的使用
气自华
04-26 1579
假如execute方法中需要一些额外的数据怎么办？比如说execute  中希望发送一封邮件，但是我需要知道邮件的发送者、接收者等信息?  存在两种解决方案：  1.JobDataMap类：     每个JobDetail都关联了一个JobDataMap实例，JobDataMap是java.util.Map的子类，基本上是提供key- value形式的数据，并提供了一些便利方法（主
C#中Quartz的简单易懂定时任务实现
无名指的约定
04-21 1963
作为一个优秀的开源调度框架，Quartz 具有以下特点： 强大的调度功能，例如支持丰富多样的调度方法，可以满足各种常规及特殊需求； 灵活的应用方式，例如支持任务和调度的多种组合方式，支持调度数据的多种存储方式； 分布式和集群能力，Terracotta 收购后在原来功能基础上作了进一步提升。 另外，作为 Spring 默认的调度框架，Quartz 很容易与 Spring 集成实现灵活可配置的调度功能。 quartz调度核心元素： Scheduler:任务调度器，是实际执行任务调度...
Quartz任务调度Job有无状态
小徐的博客
01-16 1248
有状态的job和无状态的job @PersistJobDataAfterExecution注解的使用 有状态的job可以理解为多次Job调用期间可以持有一些状态信息,这些状态信息存储在JobDataMap中,而默认的无状态job每次调用时都会创建一个新的jobDataMap 添加count的setter和getter方法 public Integer getCount() { return...
Quartz.NET开源作业调度框架系列(三):IJobExecutionContext 参数传递-转
最新发布
05-25
Quartz.NET是一个开源的作业调度框架，它可以帮助我们实现定时任务和作业调度。在Quartz.NET中，我们可以通过实现IJob接口来定义一个作业，并且可以通过JobDataMap来传递参数。这篇文章将介绍如何在Quartz.NET中使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值