作业调度框架 Quartz 学习笔记(二) -- 简单触发器(SimpleTrigger)

简单回顾一下上一节学习到的 "HelloWorld "

1 创建一个job类,实现Job接口,覆盖 public void execute(JobExecutionContext context) 方法,在方法中写入你要执行的操作(数据导入/备份,轮询检查文件等)代码

2 创建一个主线程类, 获得 Scheduler 对象

    SchedulerFactory sf = new StdSchedulerFactory();
    Scheduler sched = sf.getScheduler(); 

    获得要执行的对象  JobDetail job = newJob(HelloJob.class).withIdentity("job1", "group1").build();

    定义触发器 Trigger trigger = newTrigger().withIdentity("trigger1", "group1").startAt(runTime).build();

    将任务和Trigger放入scheduler   : 

        sched.scheduleJob(job, trigger);

    启动 和 停止
    sched.start();  sched.shutdown(true);

    注意 给job 留有足够长的时间,如果主线程类停止工作,job线程也会停止工作

 

------------------------------------------------我是分割线--------------------------------------------------------

经过了 "HelloWorld" 之后,您老人家可能对 Quartz 有所了解,下面让我们继续深入,学习下Quartz 重复执行任务该怎么做

简单的说就是 触发器(Trigger)的参数设置. 什么? 触发器(Trigger)不知道是什么?

出门左转  <<作业调度框架 Quartz 学习笔记(一)>>    不谢

还是老套路,一个job 类,一个主线程类

SimpleJob.java

[java]  view plain copy

1. public class SimpleJob implements Job {  
2.   
3.     @Override  
4.     public void execute(JobExecutionContext context)  
5.             throws JobExecutionException {  
6.         // job 的名字  
7.         String jobName = context.getJobDetail().getKey().getName();  
8.           
9.         // 任务执行的时间  
10.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy 年 MM 月 dd 日  HH 时 mm 分 ss 秒");  
11.         String jobRunTime = dateFormat.format(Calendar.getInstance().getTime());  
12.           
13.         // 输出任务执行情况  
14.         System.out.println("任务 : " + jobName + " 在  " +jobRunTime + " 执行了 ");  
15.     }  
16. }  

在这里 对输出 的日期进行了一小下 格式化,适应国人习惯.

其它没什么好说的 0.0

 

SimpleTriggerExample.java

[java]  view plain copy

1. import static org.quartz.DateBuilder.futureDate;  
2. import static org.quartz.JobBuilder.newJob;  
3. import static org.quartz.JobKey.jobKey;  
4. import static org.quartz.SimpleScheduleBuilder.simpleSchedule;  
5. import static org.quartz.TriggerBuilder.newTrigger;  
6.   
7. import java.text.SimpleDateFormat;  
8. import java.util.Date;  
9.   
10. import org.quartz.DateBuilder;  
11. import org.quartz.DateBuilder.IntervalUnit;  
12. import org.quartz.JobDetail;  
13. import org.quartz.Scheduler;  
14. import org.quartz.SchedulerFactory;  
15. import org.quartz.SchedulerMetaData;  
16. import org.quartz.SimpleTrigger;  
17. import org.quartz.impl.StdSchedulerFactory;  
18.   
19. /** 
20.  * Simple Triggers (简单触发器) 的使用. 
21.  */  
22. public class SimpleTriggerExample {  
23.   
24.     public static void main(String[] args) throws Exception {  
25.         SimpleTriggerExample example = new SimpleTriggerExample();  
26.         example.run();  
27.     }  
28.   
29.     public void run() throws Exception {  
30.         // 日期格式化  
31.         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy 年 MM 月 dd 日  HH 时 mm 分 ss 秒");  
32.           
33.         SchedulerFactory sf = new StdSchedulerFactory();  
34.         Scheduler sched = sf.getScheduler();  
35.         System.out.println("--------------- 初始化 -------------------");  
36.   
37.         // 下一个第15秒 例:  
38.         //           当前 10秒,则 执行时间为15秒  
39.         //           当前 16秒,则 执行时间为30秒  
40.         //           当前 33秒,则 执行时间为45秒  
41.         //           当前 48秒,则 执行时间为00秒  
42.         Date startTime = DateBuilder.nextGivenSecondDate(null, 15);  
43.   
44.         // job1 将只会执行一次   
45.         JobDetail job = newJob(SimpleJob.class).withIdentity("job1", "group1").build();  
46.         SimpleTrigger trigger = (SimpleTrigger) newTrigger()  
47.                 .withIdentity("trigger1", "group1")  
48.                 .startAt(startTime).build();  
49.         // 把job1 和 trigger加入计划   .  ft:此任务要执行的时间  
50.         Date ft = sched.scheduleJob(job, trigger);  
51.         System.out.println(job.getKey().getName() + " 将在 : " + dateFormat.format(ft) + " 时运行.并且重复: "  
52.                 + trigger.getRepeatCount() + " 次, 每次间隔 "  
53.                 + trigger.getRepeatInterval() / 1000 + " 秒");  
54.   
55.         // job2 将只会和执行一次(和job1一样一样的,吼~~)  
56.         job = newJob(SimpleJob.class).withIdentity("job2", "group1").build();  
57.         trigger = (SimpleTrigger) newTrigger()  
58.                 .withIdentity("trigger2", "group1").startAt(startTime).build();  
59.         ft = sched.scheduleJob(job, trigger);  
60.         System.out.println(job.getKey().getName() + " 将在 : " + dateFormat.format(ft) + " 时运行.并且重复: "  
61.                 + trigger.getRepeatCount() + " 次, 每次间隔 "  
62.                 + trigger.getRepeatInterval() / 1000 + " 秒");  
63.   
64.         // job3 将执行11次(执行1次,重复10次) ,每10秒重复一次  
65.         job = newJob(SimpleJob.class).withIdentity("job3", "group1").build();  
66.         trigger = newTrigger()  
67.                 .withIdentity("trigger3", "group1")  
68.                 .startAt(startTime)  
69.                 .withSchedule(  
70.                         simpleSchedule()  
71.                         .withIntervalInSeconds(10)// 重复间隔  
72.                         .withRepeatCount(10))     // 重复次数  
73.                         .build();  
74.         ft = sched.scheduleJob(job, trigger);  
75.         System.out.println(job.getKey().getName()+ " 将在 : " + dateFormat.format(ft) + " 时运行.并且重复: "  
76.                 + trigger.getRepeatCount() + " 次, 每次间隔 "  
77.                 + trigger.getRepeatInterval() / 1000 + " 秒");  
78.   
79.           
80.         // trigger3 改变了.  每隔10s重复.共重复2次  
81.         // 此处说明 , 上面job3已经 设定了 trigger3 重复10次,每次10s  
82.         //        在这里又改变了 trigger3的设置,不会对以前构成影响,而是当做一个新的来处理  
83.         trigger = newTrigger()  
84.                 .withIdentity("trigger3", "group2")  
85.                 .startAt(startTime)  
86.                 .withSchedule(  
87.                         simpleSchedule()  
88.                         .withIntervalInSeconds(10)  
89.                         .withRepeatCount(2))  
90.                         .forJob(job).build();  
91.         ft = sched.scheduleJob(trigger);  
92.         System.out.println(job.getKey().getName() + " 改变过trigger3属性的job3 : " + dateFormat.format(ft) + " 时运行.并且重复: "  
93.                 + trigger.getRepeatCount() + " 次, 每次间隔 "  
94.                 + trigger.getRepeatInterval() / 1000 + " 秒");  
95.   
96.         // job5 将在5分钟后运行一次  
97.         job = newJob(SimpleJob.class).withIdentity("job5", "group1").build();  
98.         trigger = (SimpleTrigger) newTrigger()  
99.                 .withIdentity("trigger5", "group1")  
100.                 .startAt(futureDate(5, IntervalUnit.MINUTE)) // 设定5分钟后运行  
101.                 .build();  
102.         ft = sched.scheduleJob(job, trigger);  
103.         System.out.println(job.getKey().getName()+ " 将在 : " + dateFormat.format(ft) + " 时运行.并且重复: "  
104.                 + trigger.getRepeatCount() + " 次, 每次间隔 "  
105.                 + trigger.getRepeatInterval() / 1000 + " 秒");  
106.   
107.         // job6  每40s运行一次,没有指定重复次数,则无下限的重复  
108.         job = newJob(SimpleJob.class).withIdentity("job6", "group1").build();  
109.         trigger = newTrigger()  
110.                 .withIdentity("trigger6", "group1")  
111.                 .startAt(startTime)  
112.                 .withSchedule(  
113.                         simpleSchedule().withIntervalInSeconds(40)  
114.                                 .repeatForever()).build();  
115.         ft = sched.scheduleJob(job, trigger);  
116.         System.out.println(job.getKey().getName() + " 将在 : " + dateFormat.format(ft) + " 时运行.并且重复: "  
117.                 + trigger.getRepeatCount() + " 次, 每次间隔 "  
118.                 + trigger.getRepeatInterval() / 1000 + " 秒");  
119.   
120.         // 所有的任务都被加入到了 scheduler中 ,但只有 schedulers.start(); 时才开始执行  
121.         sched.start();  
122.         System.out.println("------- 开始调度 (调用.start()方法) ----------------");  
123.         System.out.println("-------系统 启动 的 时间 :" + dateFormat.format(new Date()));  
124.   
125.         // 在 scheduled.start(); 之后,还可以将 jobs 添加到执行计划中  
126.         // job7 将重复20次 ,每5分钟重复一次  
127.         job = newJob(SimpleJob.class).withIdentity("job7", "group1").build();  
128.         trigger = newTrigger()  
129.                 .withIdentity("trigger7", "group1")  
130.                 .startAt(startTime)  
131.                 .withSchedule(  
132.                         simpleSchedule()  
133.                         .withIntervalInMinutes(5) // 5分钟   
134.                         .withRepeatCount(20))     // 重复20次  
135.                         .build();  
136.         ft = sched.scheduleJob(job, trigger);  
137.         System.out.println(job.getKey().getName() + " 将在 : " + dateFormat.format(ft) + " 时运行.并且重复: "  
138.                 + trigger.getRepeatCount() + " 次, 每次间隔 "  
139.                 + trigger.getRepeatInterval() / 1000 + " 秒");  
140.   
141.         // job8  可以立即执行. 无trigger注册  
142.         job = newJob(SimpleJob.class).withIdentity("job8", "group1")  
143.                 .storeDurably().build();  
144.         sched.addJob(job, true);  
145.         System.out.println("手动触发  job8...(立即执行)");  
146.         sched.triggerJob(jobKey("job8", "group1"));  
147.   
148.         System.out.println("------- 等待30 秒... --------------");  
149.   
150.         try {  
151.             Thread.sleep(30L * 1000L);  
152.         } catch (Exception e) { }  
153.   
154.         // job7 将马上执行,重复10次,每秒一次  
155.         System.out.println("-------  重新安排 ... --------------------");  
156.         trigger = newTrigger()  
157.                 .withIdentity("trigger7", "group1")  
158.                 .startAt(startTime)  
159.                 .withSchedule(  
160.                         simpleSchedule().withIntervalInMinutes(5)  
161.                                 .withRepeatCount(20)).build();  
162.   
163.         ft = sched.rescheduleJob(trigger.getKey(), trigger);  
164.         System.out.println("job7 被重新安排 在 : " + dateFormat.format(ft) +"  执行. \r   当前时间 :" + dateFormat.format(new Date())+"预定执行时间已过,任务立即执行");  
165.           
166.         try {  
167.             System.out.println("------- 等待5分钟  ... ------------");  
168.             Thread.sleep(300L * 1000L);  
169.         } catch (Exception e) { }  
170.   
171.         sched.shutdown(true);  
172.         System.out.println("------- 调度已关闭 ---------------------");  
173.   
174.         // 显示一下  已经执行的任务信息  
175.         SchedulerMetaData metaData = sched.getMetaData();  
176.         System.out.println("~~~~~~~~~~  执行了 " + metaData.getNumberOfJobsExecuted() + " 个 jobs.");  
177.   
178.     }  
179.   
180. }  

几点说明:

1 DateBuilder.nextGivenSecondDate 的意思代码中已经说明了,就是下一个你想要的时间,不懂的可以自己测试一下

2 同一个任务可以多次注册.

3 重复执行 需要设置

   trigger = newTrigger()
    .withIdentity("trigger3", "group1")
    .startAt(startTime)
    .withSchedule(
      simpleSchedule()
      .withIntervalInSeconds(10)// 重复间隔
      .withRepeatCount(10))     // 重复次数
      .build();

   如果需要一直重复:  

    trigger = newTrigger()
    .withIdentity("trigger6", "group1")
    .startAt(startTime)
    .withSchedule(
      simpleSchedule().withIntervalInSeconds(40)
        .repeatForever()).build();

4 无trigger注册,表示任务立即执行 : sched.addJob(job, true);

5 // 在scheduler.start之后调用，可以在job开始后重新定义trigger，然后重新注册

    sched.rescheduleJob(trigger.getKey(), trigger);

 

这个Example 还是比较简单的,主要 就是Trigger的参数设置,多看看代码,里面有注释的 0.0