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

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

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

 

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

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

代码 :

ColorJob.java

[java]  view plain copy

1. /** 
2.  * <p> 这只是一个简单的工作,接收参数和维护状态  </p> 
3.  */  
4. <span style="color:#660000;"><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. }  

JobStateExample.java

[java]  view plain copy

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. }  

执行结果 :

[plain]  view plain copy

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.  

 

说明 :

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