一、TriggerListener 触发器监听器
跟触发器有关的事件包括**:触发器被触发,触发器触发失败,以及触发器触发完成**(触发器完成后作业任务开始运行)
1. TriggerListener 接口源码
public interface TriggerListener {
String getName();
void triggerFired(Trigger var1, JobExecutionContext var2);
boolean vetoJobExecution(Trigger var1, JobExecutionContext var2);
void triggerMisfired(Trigger var1);
void triggerComplete(Trigger var1, JobExecutionContext var2, CompletedExecutionInstruction var3);
}
- getName 方法:用于获取触发器的名称
- ① triggerFired 方法(触发器被触发):当与监听器相关联的Trigger被触发,Job上的execute()方法将被执行时,Scheduler就调用该方法, 它关联的job即将被运行
- ② vetoJobExecution 方法(Trigger被激发):Trigger被激发 它关联的job即将被运行,先执行(1),在执行(2) 如果返回TRUE 那么任务job会被终止
- ③ triggerMisfired 方法(触发器触发失败):当Trigger错过被激发时执行,比如当前时间有很多触发器都需要执行,但是线程池中的有效线程都在工作,那么有的触发器就有可能超时,错过这一轮的触发
- ④ triggerComplete 方法(触发器触发完成): 任务完成时触发
2. 代码案例
2.1 创建监听器
@Slf4j
public class TimerTriggerListener implements TriggerListener {
private String timerTriggerName="";
public TimerTriggerListener(String timerTriggerName) {
this.timerTriggerName = timerTriggerName;
}
@Override
public String getName() {
// TODO Auto-generated method stub
log.info(timerTriggerName);
System.out.println(timerTriggerName);
return timerTriggerName;
}
//触发器触发完成
//(4) 任务完成时触发
@Override
public void triggerComplete(Trigger arg0, JobExecutionContext arg1, Trigger.CompletedExecutionInstruction arg2) {
// TODO Auto-generated method stub
log.info("触发器触发完成");
System.out.println("触发器触发完成");
}
//触发器被触发
//(1)Trigger被激发 它关联的job即将被运行
@Override
public void triggerFired(Trigger arg0, JobExecutionContext arg1) {
// TODO Auto-generated method stub
log.info("Trigger被激发 它关联的job即将被运行");
System.out.println("触发器被触发");
}
//触发器触发失败
//(3) 当Trigger错过被激发时执行,比如当前时间有很多触发器都需要执行,但是线程池中的有效线程都在工作,那么有的触发器就有可能超时,错过这一轮的触发。
@Override
public void triggerMisfired(Trigger arg0) {
// TODO Auto-generated method stub
log.info("触发器触发失败");
System.out.println("触发器触发失败");
}
//(2)Trigger被激发 它关联的job即将被运行,先执行(1),在执行(2) 如果返回TRUE 那么任务job会被终止
@Override
public boolean vetoJobExecution(Trigger arg0, JobExecutionContext arg1) {
// TODO Auto-generated method stub
return false;
}
}
2.2 创建需要定时完成的任务
public class JobTest2 implements Job {
private static int count = 1;
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
System.out.println("定时任务执行第"+ count++ +"次");
}
}
2.3 启动定时器的代码
public class TimerExample {
// 创建 schedulerFactory 工厂
private static SchedulerFactory scheduleFactory= new StdSchedulerFactory();
public static void main(String[] args) {
// TODO Auto-generated method stub
String[] data= {"s","t","r","i","n","g"};
addJob("HelloJob","HelloJobGroup","HelloTrigger","HelloTriggerGroup",JobTest2.class,"0/1 * * * * ?",data);
}
public static void addJob(String jobName,String jobGroupName,String triggerName,String triggerGroupName
,Class<? extends Job> jobClass,String cron,String[] data) {
try {
// 1. 创建调度器
Scheduler scheduler = scheduleFactory.getScheduler();
//创建 jobDetail 实例,绑定 Job 实现类
// 指明 job 的名称,所在组的名称,以及绑定 job 类
JobDetail jobDetail = JobBuilder.newJob(jobClass)
.withIdentity(jobName, jobGroupName)
//.requestRecovery() // 执行中应用发生故障,需要重新执行
.build();
// 初始化参数传递到 job
jobDetail.getJobDataMap().put("data", data);
// 定义调度触发规则CronTrigger
Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity(triggerName, triggerGroupName) //指明 CronTrigger 的名称,所在组的名称,触发时间
.startNow()
.withSchedule(CronScheduleBuilder.cronSchedule(cron))
.build();
// 把作业和触发器注册到任务调度中
scheduler.scheduleJob(jobDetail, trigger);
// 创建并注册一个全局的TriggerListener
scheduler.getListenerManager().addTriggerListener(new TimerTriggerListener("TimerTrigger"), EverythingMatcher.allTriggers());
// 创建并注册一个局部的TriggerListener
// scheduler.getListenerManager().addTriggerListener(new TimerTriggerListener("TimerTrigger"), KeyMatcher.keyEquals(TriggerKey.triggerKey(triggerName, triggerGroupName)));
// 创建并注册一个特定组的TriggerListener
// scheduler.getListenerManager().addTriggerListener(new TimerTriggerListener("TimerTrigger"), GroupMatcher.groupEquals(triggerGroupName));
//启动
if (!scheduler.isShutdown()) {
scheduler.start();
System.out.println("开始调度任务");
}
} catch (SchedulerException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
运行结果:
二. JobListener 任务监听器
任务相关的事件包括:job开始要执行的提示; job执行完成的提示灯
1. JobListener接口源码
public interface JobListener {
String getName();
void jobToBeExecuted(JobExecutionContext var1);
void jobExecutionVetoed(JobExecutionContext var1);
void jobWasExecuted(JobExecutionContext var1, JobExecutionException var2);
}
- getName方法:用于获取该JobListener的名称。
- jobToBeExecuted方法:Scheduler在JobDetail将要被执行时调用这个方法。
- jobExecutionVetoed方法:Scheduler在JobDetail即将被执行,但又被TriggerListerner否决时会调用该方法
- jobWasExecuted方法:Scheduler在JobDetail被执行之后调用这个方法
2. 代码案例
2.1 创建监听器
@Slf4j
public class TimerJobListener implements JobListener {
//获取该JobListener的名称
@Override
public String getName() {
// TODO Auto-generated method stub
String name = getClass().getSimpleName();
log.info(name);
return name;
}
//:Scheduler在JobDetail即将被执行,但又被TriggerListerner否决时会调用该方法
@Override
public void jobExecutionVetoed(JobExecutionContext arg0) {
// TODO Auto-generated method stub
log.info("Scheduler在JobDetail即将被执行,但又被TriggerListerner否决");
System.out.println("jobExecutionVetoed");
}
//Scheduler在JobDetail将要被执行时调用这个方法。
@Override
public void jobToBeExecuted(JobExecutionContext arg0) {
// TODO Auto-generated method stub
log.info("Scheduler在JobDetail将要被执行");
System.out.println("jobToBeExecuted");
}
//Scheduler在JobDetail被执行之后调用这个方法
@Override
public void jobWasExecuted(JobExecutionContext arg0, JobExecutionException arg1) {
// TODO Auto-generated method stub
log.info("Scheduler在JobDetail被执行之后");
System.out.println("jobWasExecuted");
}
}
2.2 创建需要定时完成的任务
public class JobTest2 implements Job {
private static int count = 1;
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
System.out.println("定时任务执行第"+ count++ +"次");
}
}
2.3 启动定时器
public class TimerExample {
// 创建 schedulerFactory 工厂
private static SchedulerFactory scheduleFactory= new StdSchedulerFactory();
public static void main(String[] args) {
// TODO Auto-generated method stub
String[] data= {"s","t","r","i","n","g"};
addJob("HelloJob","HelloJobGroup","HelloTrigger","HelloTriggerGroup",JobTest2.class,"0/1 * * * * ?",data);
}
public static void addJob(String jobName,String jobGroupName,String triggerName,String triggerGroupName
,Class<? extends Job> jobClass,String cron,String[] data) {
try {
// 1. 创建调度器
Scheduler scheduler = scheduleFactory.getScheduler();
//创建 jobDetail 实例,绑定 Job 实现类
// 指明 job 的名称,所在组的名称,以及绑定 job 类
JobDetail jobDetail = JobBuilder.newJob(jobClass)
.withIdentity(jobName, jobGroupName)
//.requestRecovery() // 执行中应用发生故障,需要重新执行
.build();
// 初始化参数传递到 job
jobDetail.getJobDataMap().put("data", data);
// 定义调度触发规则CronTrigger
Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity(triggerName, triggerGroupName) //指明 CronTrigger 的名称,所在组的名称,触发时间
.startNow()
.withSchedule(CronScheduleBuilder.cronSchedule(cron))
.build();
// 把作业和触发器注册到任务调度中
scheduler.scheduleJob(jobDetail, trigger);
// 创建并注册一个全局的Job Listener
scheduler.getListenerManager().addJobListener(new TimerJobListener(), EverythingMatcher.allJobs());
// 创建并注册一个指定任务的Job Listener
//scheduler.getListenerManager().addJobListener(new TimerJobListener(), KeyMatcher.keyEquals(JobKey.jobKey(jobName,jobGroupName)));
//启动
if (!scheduler.isShutdown()) {
scheduler.start();
System.out.println("开始调度任务");
}
} catch (SchedulerException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
运行结果:
三. SchedulerListener 调度器监听器
SchedulerListener会在Scheduler的生命周期中关键事件发生时被调用。与Scheduler有关的事件包括:增加一个job/trigger,删除一个job/trigger,scheduler发生严重错误,关闭scheduler等
1. SchedulerListener接口源码
void jobScheduled(Trigger var1);
void jobUnscheduled(TriggerKey var1);
void triggerFinalized(Trigger var1);
void triggerPaused(TriggerKey var1);
void triggersPaused(String var1);
void triggerResumed(TriggerKey var1);
void triggersResumed(String var1);
void jobAdded(JobDetail var1);
void jobDeleted(JobKey var1);
void jobPaused(JobKey var1);
void jobsPaused(String var1);
void jobResumed(JobKey var1);
void jobsResumed(String var1);
void schedulerError(String var1, SchedulerException var2);
void schedulerInStandbyMode();
void schedulerStarted();
void schedulerStarting();
void schedulerShutdown();
void schedulerShuttingdown();
void schedulingDataCleared();
- jobScheduled方法:用于部署JobDetail时调用
- jobUnscheduled方法:用于卸载JobDetail时调用
- triggerFinalized方法:当一个 Trigger 来到了再也不会触发的状态时调用这个方法。除非这个 Job 已设置成了持久性,否则它就会从 Scheduler 中移除
- triggersPaused方法:Scheduler 调用这个方法是发生在一个 Trigger 或 Trigger 组被暂停时。假如是Trigger 组的话,triggerName 参数将为 null
- triggersResumed方法:Scheduler 调用这个方法是发生成一个 Trigger 或 Trigger 组从暂停中恢复时。假如是 Trigger 组的话,假如是 Trigger 组的话,triggerName 参数将为 null。参数将为 null
- jobsPaused方法:当一个或一组 JobDetail 暂停时调用这个方法
- jobsResumed方法:当一个或一组 Job 从暂停上恢复时调用这个方法。假如是一个 Job 组,jobName 参数将为 null
- schedulerError方法:在 Scheduler 的正常运行期间产生一个严重错误时调用这个方法
- schedulerStarted方法:当Scheduler 开启时,调用该方法
- schedulerInStandbyMode方法: 当Scheduler处于StandBy模式时,调用该方法
- schedulerShutdown方法:当Scheduler停止时,调用该方法
- schedulingDataCleared方法:当Scheduler中的数据被清除时,调用该方法
2. 代码案例
2.1 创建监听器
@Slf4j
public class TimerSchedulerListener implements SchedulerListener {
@Override
public void jobScheduled(Trigger trigger) {
String jobName = trigger.getJobKey().getName();
log.info(jobName +"部署");
System.out.println(jobName + "部署s");
}
@Override
public void jobUnscheduled(TriggerKey triggerKey) {
log.info(triggerKey + "卸载");
System.out.println(triggerKey + "卸载");
}
@Override
public void triggerFinalized(Trigger trigger) {
log.info("触发完成" + trigger.getJobKey().getName());
System.out.println("触发完成" + trigger.getJobKey().getName());
}
@Override
public void triggerPaused(TriggerKey triggerKey) {
log.info(triggerKey + "暂停");
System.out.println(triggerKey + "暂停");
}
@Override
public void triggersPaused(String triggerGroup) {
log.info("trigger group "+triggerGroup + "暂停");
System.out.println("trigger group "+triggerGroup + "暂停");
}
@Override
public void triggerResumed(TriggerKey triggerKey) {
log.info(triggerKey + "从暂停中恢复");
System.out.println(triggerKey + "从暂停中恢复");
}
@Override
public void triggersResumed(String triggerGroup) {
log.info("trigger group "+triggerGroup + "从暂停中恢复");
System.out.println("trigger group "+triggerGroup + "从暂停中恢复");
}
@Override
public void jobAdded(JobDetail jobDetail) {
log.info(jobDetail.getKey()+"增加");
System.out.println(jobDetail.getKey()+"增加");
}
@Override
public void jobDeleted(JobKey jobKey) {
log.info(jobKey+"删除");
System.out.println(jobKey+"删除");
}
@Override
public void jobPaused(JobKey jobKey) {
log.info(jobKey+"暂停");
System.out.println(jobKey+"暂停");
}
@Override
public void jobsPaused(String jobGroup) {
log.info("job group "+jobGroup+"暂停");
System.out.println("job group "+jobGroup+"暂停");
}
@Override
public void jobResumed(JobKey jobKey) {
log.info(jobKey+"从暂停上恢复");
System.out.println(jobKey+"从暂停上恢复");
}
@Override
public void jobsResumed(String jobGroup) {
log.info("job group "+jobGroup+"从暂停上恢复");
System.out.println("job group "+jobGroup+"从暂停上恢复");
}
@Override
public void schedulerError(String msg, SchedulerException cause) {
log.error(msg, cause.getUnderlyingException());
log.info("正常运行期间产生一个严重错误");
System.out.println("正常运行期间产生一个严重错误");
}
@Override
public void schedulerInStandbyMode() {
log.info("Scheduler处于StandBy模式");
System.out.println("Scheduler处于StandBy模式");
}
@Override
public void schedulerStarted() {
log.info("scheduler开启完成");
System.out.println("scheduler开启完成");
}
@Override
public void schedulerStarting() {
log.info("scheduler正在开启");
System.out.println("scheduler正在开启");
}
@Override
public void schedulerShutdown() {
log.info("scheduler停止");
System.out.println("scheduler停止");
}
@Override
public void schedulerShuttingdown() {
log.info("scheduler正在停止");
System.out.println("scheduler正在停止");
}
@Override
public void schedulingDataCleared() {
log.info("Scheduler中的数据被清除");
System.out.println("Scheduler中的数据被清除");
}
}
2.2 创建需要定时完成的任务
public class JobTest2 implements Job {
private static int count = 1;
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
System.out.println("定时任务执行第"+ count++ +"次");
}
}
2.3 启动定时器
public class TimerExample {
// 创建 schedulerFactory 工厂
private static SchedulerFactory scheduleFactory= new StdSchedulerFactory();
public static void main(String[] args) {
// TODO Auto-generated method stub
String[] data= {"s","t","r","i","n","g"};
addJob("HelloJob","HelloJobGroup","HelloTrigger","HelloTriggerGroup",JobTest2.class,"0/1 * * * * ?",data);
}
public static void addJob(String jobName,String jobGroupName,String triggerName,String triggerGroupName
,Class<? extends Job> jobClass,String cron,String[] data) {
try {
// 1. 创建调度器
Scheduler scheduler = scheduleFactory.getScheduler();
//创建 jobDetail 实例,绑定 Job 实现类
// 指明 job 的名称,所在组的名称,以及绑定 job 类
JobDetail jobDetail = JobBuilder.newJob(jobClass)
.withIdentity(jobName, jobGroupName)
//.requestRecovery() // 执行中应用发生故障,需要重新执行
.build();
// 初始化参数传递到 job
jobDetail.getJobDataMap().put("data", data);
// 定义调度触发规则CronTrigger
Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity(triggerName, triggerGroupName) //指明 CronTrigger 的名称,所在组的名称,触发时间
.startNow()
.withSchedule(CronScheduleBuilder.cronSchedule(cron))
.build();
// 把作业和触发器注册到任务调度中
scheduler.scheduleJob(jobDetail, trigger);
// 创建SchedulerListener
scheduler.getListenerManager().addSchedulerListener(new TimerSchedulerListener());
// 移除对应的SchedulerListener
// scheduler.getListenerManager().removeSchedulerListener(new TimerSchedulerListener());
//启动
if (!scheduler.isShutdown()) {
scheduler.start();
System.out.println("开始调度任务");
}
} catch (SchedulerException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
运行结果: