Quartz(四) -- 接收参数和维护状态

墨蓝 2022-03-10 15:20 188阅读 0赞

[https://blog.csdn.net/persistencegoing/article/details/84376427][https_blog.csdn.net_persistencegoing_article_details_84376427]

<<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  
  
原文：https://blog.csdn.net/lnara/article/details/8646155

[https_blog.csdn.net_persistencegoing_article_details_84376427]: https://blog.csdn.net/persistencegoing/article/details/84376427