Quartz之CronTrigger

任务和触发器是quartz的两大块核心。触发器分CronTrigger 和SimpleTrigger 

CronTrigger 支持比 SimpleTrigger 更具体的调度，而且也不是很复杂。基于 cron 表达式，CronTrigger 支持类似日历的重复间隔，而不是单一的时间间隔 —— 这相对 SimpleTrigger 而言是一大改进。掌握CronTrigger，是非常必要,掌握Quartz cron 表达式是学习CronTrigger的关键所在! 

CronTriggerExample类:

package CronTrigger;

import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerMetaData;

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

import static org.quartz.CronScheduleBuilder.cronSchedule;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;

public class CronTriggerExample {

public void run() throws Exception {
Scheduler sched = SchedFacory.getScheduler();//得到调度器实例
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");//日期格式

JobDetail job = newJob(SimpleJob.class)     //创建任务实例
.withIdentity("job3", "group1")
.build();

CronTrigger trigger = newTrigger()                  //CronTrigger触发器实例
.withIdentity("trigger3", "group1")
.withSchedule(cronSchedule("0/10 0/1 8-17 * * ?")) //在8-17之间每1分钟执行一次,并且为10秒间隔
.build();

Date ft = sched.scheduleJob(job, trigger);
System.out.println(job.getKey() + " has been scheduled to run at: " + sdf.format(ft)
+ " and repeat based on expression: " + trigger.getCronExpression());
sched.start();
Thread.sleep(300L * 1000L);        //5分钟
sched.shutdown(true);
SchedulerMetaData metaData = sched.getMetaData();
System.out.println("Executed " + metaData.getNumberOfJobsExecuted() + " jobs.");//总共执行了多少个任务
}

public static void main(String[] args) throws Exception {
CronTriggerExample example = new CronTriggerExample();
example.run();
}
}
/* job = newJob(SimpleJob.class)
.withIdentity("job1", "group1")
.build();

//表示每20秒执行一次
trigger = newTrigger()
.withIdentity("trigger1", "group1")
.withSchedule(cronSchedule("0/20 * * * * ?"))
.build();*/

/*
job = newJob(SimpleJob.class)
.withIdentity("job2", "group1")
.build();

//每2分钟执行一次,并且启动时间为：15秒之后开始,例如: 2011-07-08 04:44:15,2011-07-08 04:46:15 ...
trigger = newTrigger()
.withIdentity("trigger2", "group1")
.withSchedule(cronSchedule("15 0/2 * * * ?"))
.build();*/
//在8-17之间每2分钟执行一次
/*trigger = newTrigger()
.withIdentity("trigger3", "group1")
.withSchedule(cronSchedule("0 0/2 8-17 * * ?"))
.build();*/

/* job = newJob(SimpleJob.class)
.withIdentity("job4", "group1")
.build();

//在16与23之间每3分钟执行一次
trigger = newTrigger()
.withIdentity("trigger4", "group1")
.withSchedule(cronSchedule("0 0/3 16-23 * * ?"))
.build();*/

/*job = newJob(SimpleJob.class)
.withIdentity("job5", "group1")
.build();

trigger = newTrigger()
.withIdentity("trigger5", "group1")
.withSchedule(cronSchedule("0 0 10am 1,15 * ?"))
.build();*/

/* job = newJob(SimpleJob.class)
.withIdentity("job6", "group1")
.build();

//2011-07-08 05:11:00,2011-07-08 05:11:02,2011-07-08 05:12:00,2011-07-08 05:12:02
//第二周到第六周之间执行并且：执行秒数为：0,2各执行一次,没有明白为什么要间隔1分钟后触发,如上.
trigger = newTrigger()
.withIdentity("trigger6", "group1")
.withSchedule(cronSchedule("0,2 * * ? * MON-FRI"))
.build();*/
/*
job = newJob(SimpleJob.class)
.withIdentity("job7", "group1")
.build();

trigger = newTrigger()
.withIdentity("trigger7", "group1")
.withSchedule(cronSchedule("0,30 * * ? * SAT,SUN"))
.build();*/

触发器线程监听类:

package CronTrigger;

import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerKey;

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

public class SchedEventLister implements Runnable {

private Scheduler sched = null;
private TriggerKey triggerKey = null;

public SchedEventLister(TriggerKey triggerKey) {
System.out.println("触发器线程监听启动....");
this.triggerKey = triggerKey;
try {
sched = SchedFacory.getScheduler();
} catch (SchedulerException e) {
e.printStackTrace();
}
}

public void run() {
System.out.println("触发器线程监听中。。。。"
+ new SimpleDateFormat("yyyy-MM-dd hh:mm:ss")
.format(new Date()));

// 获取当前触发器的状态
Trigger.TriggerState ts = null;
try {
ts = sched.getTriggerState(triggerKey);
} catch (SchedulerException e) {
e.printStackTrace();
}

// 如果为暂停状态就恢复
if (ts == Trigger.TriggerState.PAUSED) {

//暂停10秒在恢复
try {
System.out.println("暂停当前线程5秒钟后在恢复触发器...,触发器组名: " + triggerKey.getGroup()
+ ",触发器名称: " + triggerKey.getName());
Thread.sleep(5L*1000L);
} catch (InterruptedException e1) {
e1.printStackTrace();
}

// 恢复触发器
System.out.println("正在恢复了触发器...,触发器组名: " + triggerKey.getGroup()
+ ",触发器名称: " + triggerKey.getName());
try {
sched.resumeTrigger(triggerKey);
} catch (SchedulerException e) {
throw new RuntimeException(e);
}

} else if (ts == Trigger.TriggerState.NORMAL) {
System.out.println("触发器线程监听中。。。。,状态：正常 ");
} else if (ts == Trigger.TriggerState.NONE) {
System.out.println("触发器线程监听中。。。。,状态：没有触发器 ");
} else if (ts == Trigger.TriggerState.ERROR) {
System.out.println("触发器线程监听中。。。。,状态：错误 ");
} else if (ts == Trigger.TriggerState.BLOCKED) {
System.out.println("触发器线程监听中。。。。,状态：堵塞 ");
}
}
}

调度实例类:

package CronTrigger;

import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;

public class SchedFacory {
private static  SchedulerFactory sf = new StdSchedulerFactory();
public static Scheduler getScheduler() throws SchedulerException{
return sf.getScheduler();
}
}

作业类:

package CronTrigger;

import org.quartz.*;

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

public class SimpleJob implements Job {
private static int jobCount = 0;
private Scheduler sched = null;

public SimpleJob() throws SchedulerException {
sched = SchedFacory.getScheduler();
}

public void execute(JobExecutionContext context) throws JobExecutionException {

JobKey jobKey = context.getJobDetail().getKey();
TriggerKey triggerKey = context.getTrigger().getKey();
//启动线程监听触发器的状态
new Thread(new SchedEventLister(triggerKey)).start();       //这里才是重点啊

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
System.out.println("任务分组名称: " + jobKey.getGroup() + ",任务名称: " + jobKey.getName() + ",触发器组名称: " +
triggerKey.getGroup() + ",触发器名称: " + triggerKey.getName() + " 执行时间: " + sdf.format(new Date()) + ",计数: " + (++jobCount));
//如果任务执行超过20次就结束它
/*  if(jobCount > 5){
_log.warn("结束任务...");
try {
//Delete the identified Job from the Scheduler - and any associated Triggers.
//从调度器中删除这个唯一任务时同时会删除相关联的触发器^_^
sched.deleteJob(jobKey);
sched.resumeJob(jobKey);

} catch (SchedulerException e) {
e.printStackTrace();
}
}*/
if (jobCount == 15) {
System.out.println("已经暂停了触发器...,触发器组名: " + triggerKey.getGroup() + ",触发器名称: " + triggerKey.getName());
//暂停触发器
try {
sched.pauseTrigger(triggerKey);
} catch (SchedulerException e) {
throw new RuntimeException(e);
}

}

if (jobCount == 20) {
System.out.println("正在停止并且移除触发器...,触发器组名: " + triggerKey.getGroup() + ",触发器名称: " + triggerKey.getName());
try {
sched.resumeTrigger(triggerKey);//停止触发器
sched.unscheduleJob(triggerKey);//移除触发器
} catch (SchedulerException e) {
throw new RuntimeException(e);
}
}

}
}

项目结构: