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

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

如果你想在 某个job执行的时候传入参数,参数在job执行过程中对参数有所修改,并且在job执行完毕后把参数返回

那么你需要学习一下现在的这个例子了,因为它正是你所想要的 ......

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

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

代码 :

ColorJob.java

/**
* <p> 这只是一个简单的工作,接收参数和维护状态  </p>
*/
//小心,这里的注释很重要
@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

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执行完毕后把参数返回
那么你需要学习一下现在的这个例子了,因为它正是你所想要的
*/
}

}

执行结果 :

--------------- 初始化 -------------------
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