Quartz任务调度，CronTrigger触发器的DemoOne

Quartz框架中最核心的是调度器Scheduler，其中框架中重要的三方面（调度器Scheduler、任务Job、触发器{SimpleTrigger、CronTrigger}）

1、DemoOne（使用的触发器是CronTrigger）

使用的触发器是CronTrigger，触发时间使用的是Cron表达式

其中的Cron表达式的规则是：秒分时日月周年

序号	说明	是否必填	允许填写的值	允许的通配符
1	秒	是	0-59	, - * /
2	分	是	0-59	, - * /
3	小时	是	0-23	, - * /
4	日	是	1-31	, - * ? / L W
5	月	是	1-12 or JAN-DEC	, - * /
6	周	是	1-7 or MON-TUES-WED-THUR-FRI-SUN-SAT	, - * ? / L #
7	年	否	empty 或 1970-2099	, - * /

其中常用的通配符使用范围及作用分别如下：

*：表示所有值，在某个字段上时，表示每，，如：在分钟字段上，表示每分钟。

？：表示不确定值，在这个字段上不关心具体设置的值（只有在日、周字段上设置），例如：在每月的1号触发，不关心具体是周几，那么在周的字段上就可以设　置为？

- ：表示在某个区间范围内，如：在周的字段上设置：MON-FRI表示周一、周二、周三、周四、周五触发；

，：表示允许指定多个值，在秒字段上设置：3，5，10表示：在3s，5，10s时触发

/ ：表示递增触发，如：在秒上面设置"5/15" 表示从5秒开始，每增15秒触发(5,20,35,50)。在月字段上设置'1/3'所示每月1号开始，每隔三天触发一次。

　　　　　　　　　　0/10表示：从0开始，然后每隔10s触发，出现的结果分别是（0，10，20，30，40，50）

DemoOne：

任务类：

package com.fdx.testThree;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class HelloJob implements Job{

	@Override
	public void execute(JobExecutionContext arg0) throws JobExecutionException {
		// TODO Auto-generated method stub
		//job名
		String jobName = arg0.getJobDetail().getKey().getName();
		//执行时间，
		SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒");
		String jobRunTime = sf.format(new Date());
		System.out.println("HelloJob类中的主任务内容如下："+jobName+"在时间："+jobRunTime+"执行");
		
	}
	
}

触发、调度类：

  1 package com.fdx.testThree;
  2 
  3 import java.text.SimpleDateFormat;
  4 import java.util.Date;
  5 
  6 import org.quartz.CronScheduleBuilder;
  7 import org.quartz.CronTrigger;
  8 import org.quartz.JobBuilder;
  9 import org.quartz.JobDetail;
 10 import org.quartz.Scheduler;
 11 import org.quartz.SchedulerException;
 12 import org.quartz.SchedulerFactory;
 13 import org.quartz.SchedulerMetaData;
 14 import org.quartz.SimpleScheduleBuilder;
 15 import org.quartz.TriggerBuilder;
 16 import org.quartz.impl.StdSchedulerFactory;
 17 
 18 public class CronTriggerTest {
 19     
 20     //main主函数
 21     public static void main(String[] args) throws SchedulerException {
 22         CronTriggerTest att = new CronTriggerTest();
 23         att.run();
 24     }
 25     
 26     public void run() throws SchedulerException{
 27         //日期格式化
 28         SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒");
 29         // 调度器的对象的实例化
 30         SchedulerFactory sf = new StdSchedulerFactory();
 31         Scheduler scheduler = sf.getScheduler();
 32 
 33         // 任务一：job1及相关触发器
 34         // JobDetail job =
 35         // JobBuilder.newJob(HelloJob.class).withIdentity("job1",
 36         // "group1").build();
 37         // CronTrigger trigger =
 38         // TriggerBuilder.newTrigger().withIdentity("trigger1",
 39         // "group1").withSchedule(CronScheduleBuilder.cronSchedule("0/30 * * * * ?")).build();
 40         // Date ft = scheduler.scheduleJob(job, trigger);
 41         // System.out.println(job.getKey().getName()+"任务将在"+sdf.format(ft)+"运行，其中包含Cron表达式"+trigger.getCronExpression()+"（含义：每30s运行一次）");
 42         //
 43         // //任务二：job2及相关触发器
 44         // JobDetail job2 =
 45         // JobBuilder.newJob(HelloJob.class).withIdentity("job2",
 46         // "group1").build();
 47         // CronTrigger trigger2 =
 48         // TriggerBuilder.newTrigger().withIdentity("trigger2",
 49         // "group1").withSchedule(CronScheduleBuilder.cronSchedule("15 0,1 * * * ?")).build();
 50         // Date ft1 = scheduler.scheduleJob(job2, trigger2);
 51         // System.out.println(job2.getKey().getName()+"任务将在"+sdf.format(ft1)+"运行，其中包含Cron表达式"+trigger2.getCronExpression()+"(意思是：（偶数分钟的15秒进行触发）)");
 52         //
 53         // 任务三：job3及相关触发器
 54         // JobDetail job3 =
 55         // JobBuilder.newJob(HelloJob.class).withIdentity("job3",
 56         // "group1").build();
 57         // CronTrigger trigger3 =
 58         // TriggerBuilder.newTrigger().withIdentity("trigger3",
 59         // "group1").withSchedule(CronScheduleBuilder.cronSchedule("0 0/2 15-16 * * ?")).build();
 60         // Date ft2 = scheduler.scheduleJob(job3, trigger3);
 61         // System.out.println(job3.getKey().getName()+"任务将在"+sdf.format(ft2)+"运行，其中包含Cron表达式"+trigger3.getCronExpression()+"意思是(在时间15-16间，每个偶数分钟数执行一次):0 0/2 15-16 * * ?");
 62         //
 63         // //任务四：job及相关触发器配置
 64         // JobDetail job4 =
 65         // JobBuilder.newJob(HelloJob.class).withIdentity("job4",
 66         // "group1").build();
 67         // CronTrigger trigger4 =
 68         // TriggerBuilder.newTrigger().withIdentity("trigger4",
 69         // "group1").withSchedule(CronScheduleBuilder.cronSchedule("0 0/3 15-18 * * ?")).build();
 70         // Date ft4 = scheduler.scheduleJob(job4, trigger4);
 71         // System.out.println(job4.getKey().getName()+"任务将在"+sdf.format(ft4)+"运行，包含的Cron表达式"+trigger4.getCronExpression()+"意思是(在时间15-17时间间，每3分钟执行一次):(0 0/3 15-17 * * ?)");
 72         //
 73         // 任务五：job及相关触发器配置
 74         // JobDetail job5 =
 75         // JobBuilder.newJob(HelloJob.class).withIdentity("job5",
 76         // "group5").build();
 77         // CronTrigger trigger5 =
 78         // TriggerBuilder.newTrigger().withIdentity("trigger5",
 79         // "group1").withSchedule(CronScheduleBuilder.cronSchedule("0 21 16 12,17 * ?")).build();
 80         // Date ft5 = scheduler.scheduleJob(job5, trigger5);
 81         // System.out.println(job5.getKey().getName()+"任务将在"+sdf.format(ft5)+"运行，其中包含Cron表达式"+trigger5.getCronExpression()+"意思是（每月的12、17号的10点运行一次(0 0 16pm 12,17 ?)）");
 82         // //
 83         // // //任务六：job及相关触发器配置
 84         // JobDetail job6 =
 85         // JobBuilder.newJob(HelloJob.class).withIdentity("job6",
 86         // "group1").build();
 87         // CronTrigger trigger6 =
 88         // TriggerBuilder.newTrigger().withIdentity("trigger6",
 89         // "group1").withSchedule(CronScheduleBuilder.cronSchedule("0,30 * * ? * THUR,FRI,SAT,SUN")).build();
 90         // Date ft6 = scheduler.scheduleJob(job6, trigger6);
 91         // System.out.println(job6.getKey().getName()+"任务将在"+sdf.format(ft6)+"运行，其中包含的Cron表达式"+trigger6.getCronExpression()+"意思是（在每周的周四、周五、周六日的每30秒执行一次）-------0，30 * * ? * THUR,FRI,SAT,SUN");
 92         //
 93         // //任务七：job及相关触发器配置
 94         // JobDetail job7 =
 95         // JobBuilder.newJob(HelloJob.class).withIdentity("job7",
 96         // "group1").build();
 97         // CronTrigger trigger7 =
 98         // TriggerBuilder.newTrigger().withIdentity("trigger7",
 99         // "group1").withSchedule(CronScheduleBuilder.cronSchedule("0,30 * * ? * MON-FRI")).build();
100         // Date ft7 = scheduler.scheduleJob(job7, trigger7);
101         // System.out.println(job7.getKey().getName()+"任务将在"+sdf.format(ft7)+"运行，其中包含的Cron表达式"+trigger7.getCronExpression()+"意思是：周一到周五时间，每30秒执行一次");
102 
103         // 任务八，job及相关触发器配置
104         // JobDetail job8 =
105         // JobBuilder.newJob(HelloJob.class).withIdentity("job8",
106         // "group1").build();
107         // CronTrigger trigger8 =
108         // TriggerBuilder.newTrigger().withIdentity("trigger8",
109         // "group1").withSchedule(CronScheduleBuilder.cronSchedule("5/15 * * * * ?")).build();
110         // Date ft8 = scheduler.scheduleJob(job8, trigger8);
111         // System.out.println(job8.getKey().getName()+"任务将在"+sdf.format(ft8)+"执行，其中包含的Cron表达式"+trigger8.getCronExpression()+"意思是：从5秒开始，然后每隔15秒执行一次，会出现的结果秒数分别是：5，20，35，50");
112         //
113         // 任务九，job及相关触发器配置
114 //        JobDetail job9 = JobBuilder.newJob(HelloJob.class)
115 //                .withIdentity("job9", "group1").build();
116 //        CronTrigger trigger9 = TriggerBuilder
117 //                .newTrigger()
118 //                .withIdentity("trigger9", "group1")
119 //                .withSchedule(
120 //                        CronScheduleBuilder.cronSchedule("3,15,34,40,54,58 * * * * ?"))
121 //                .build();
122 //        Date ft9 = scheduler.scheduleJob(job9, trigger9);
123 //        System.out.println(job9.getKey().getName() + "任务将在" + sdf.format(ft9)
124 //                + "执行，其中包含的Cron表达式" + trigger9.getCronExpression()
125 //                + "意思是：每3s,15s,34s,40s,54s,58s触发");
126         
127          JobDetail job10 = JobBuilder.newJob(HelloJob.class).withIdentity("job10","group1").build();
128          CronTrigger trigger10 = TriggerBuilder.newTrigger().withIdentity("trigger10","group1").withSchedule(CronScheduleBuilder.cronSchedule("0/10 * * * * ?")).build();
129          Date ft10 = scheduler.scheduleJob(job10, trigger10);
130          System.out.println(job10.getKey().getName()+"任务将在"+sdf.format(ft10)+"执行，其中包含的Cron表达式"+trigger10.getCronExpression()+"意思是：从5秒开始，然后每隔15秒执行一次，会出现的结果秒数分别是：0,10,20,30,40,50");
131                     
132         
133         scheduler.start();//启动调度器
134         System.out.println("~~~~~~~~~~~~~开始调度（调用.start（）方法）~~~~~~~~~~~~~~~~~"+sdf.format(new Date()));
135         System.out.println("~~~~~~~~~~~~~~~~~~休眠2分钟，给调度留有一定的时间~~~~~~~~~~~~");
136         try {
137             Thread.sleep(2*60*1000);
138         } catch (InterruptedException e) {
139             // TODO Auto-generated catch block
140             e.printStackTrace();
141         }
142         scheduler.shutdown(true);
143         //在休眠的一定时间内，显示执行的任务类个数【通过调度器获取到SchedulerMetaDate对象】
144         System.out.println("~~~~~~~~~~~~~~~~关闭调度~~~~~~~~~~~~~~");
145         SchedulerMetaData smd = scheduler.getMetaData();
146         System.out.println("总共执行了"+smd.getNumberOfJobsExecuted()+"个任务");
147     }
148     
149 
150 }

注意点：

1、整个执行过程：

　　在指定的休眠时间内进行调度触发任务，当休眠时间结束，那么也将无法再调度其指定的任务；

　　调度开始时间，是从当前系统时间算起的，然后根据Cron表达式，进行指定时间的触发，在休眠时间结束那么调度触发任务结束；

2、CronTrigger触发类中重要常用的方法如下：

CronTrigger trigger = TriggerBuilder.newTrigger()

.withIdentity("trigger1","group1").withSchedule(CronScheduleBuilder.cronSchedule("0/30 * * * * ?")).build();

使用TriggerBuilder.newTrigger()来获取到CronTrigger对象，然后进行Cron表达式的一些列的赋值；

CronScheduleBuilder.cronSchedule(String str)，其中str进行设置cron表达式，触发的具体的时间；

posted @ 2016-03-18 11:23 FanSunny 阅读(518) 评论(0) 收藏举报

刷新页面返回顶部

FanSunny

Quartz任务调度，CronTrigger触发器的DemoOne

公告