Quartz入门Demo（三）之TriggerListener 和 JobListener

介绍

Quartz框架是一个全功能、开源的任务调度服务，可以集成几乎任何的Java应用程序—从小的单片机系统到大型的电子商务系统。Quartz可以执行上千上万的任务调度。

TriggerListener

TriggerListener 是一个监听器，用于监听Trigger。可以通过实现TriggerListener重写各方法进行使用。

方法	说明
getName()	定义并返回监听器的名字
triggerFired()	当与监听器相关联的 Trigger 被触发，Job 上的 execute() 方法将要被执行时，Scheduler 就调用这个方法。在全局 TriggerListener 情况下，这个方法为所有 Trigger 被调用。
vetoJobExecution()	在Trigger 触发后，Job 将要被执行时由 Scheduler 调用这个方法。TriggerListener 给了一个选择去否决 Job 的执行。假如这个方法返回 true，这个 Job 将不会为此次 Trigger 触发而得到执行
triggerMisfired()	Scheduler 调用这个方法是在 Trigger 错过触发时。如这个方法的 JavaDoc 所指出的，你应该关注此方法中持续时间长的逻辑：在出现许多错过触发的 Trigger 时，长逻辑会导致骨牌效应。你应当保持这上方法尽量的小。
triggerComplete()	Trigger 被触发并且完成了 Job 的执行时，Scheduler 调用这个方法。这不是说这个 Trigger 将不再触发了，而仅仅是当前 Trigger 的触发(并且紧接着的 Job 执行) 结束时。这个 Trigger 也许还要在将来触发多次的。

---

JobListener

JobListener是用于监听Job状态的监听器

方法	说明
getName()	定义并返回监听器的名字
jobToBeExecuted()	在Job执行前调用
jobExecutionVetoed()	Job被否决运行后调用
jobWasExecuted	Job完成后调用

直接上代码

JobListenerDemo类

package com.v.listenertest;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class JobListenerDemo implements JobListener {
    Logger _log = LoggerFactory.getLogger(JobListenerDemo.class);
    @Override
    public String getName() {
        // TODO Auto-generated method stub
        return "MyJobListener";
    }

    @Override
    public void jobToBeExecuted(JobExecutionContext context) {
        // TODO Auto-generated method stub
        _log.info(" Job 被触发了，此时Job 上的 execute() 方法将要被执行");
    }

    @Override
    public void jobExecutionVetoed(JobExecutionContext context) {
        // TODO Auto-generated method stub
        _log.info("执行任务被否决了！");
    }

    @Override
    public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {
        // TODO Auto-generated method stub
        _log.info("Job 的执行完成了,此方法被调用----"+context.getJobDetail().getKey());
    }

}

TriggerListenerDemo类

package com.v.listenertest;

import org.quartz.JobExecutionContext;
import org.quartz.Trigger;
import org.quartz.Trigger.CompletedExecutionInstruction;
import org.quartz.TriggerListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


public class TriggerListenerDemo implements TriggerListener{
    Logger _log = LoggerFactory.getLogger(TriggerListenerDemo.class);
    @Override
    public String getName() {
        // TODO Auto-generated method stub
        return "MyTriggerListener";
    }

    @Override
    public void triggerFired(Trigger trigger, JobExecutionContext context) {
        // TODO Auto-generated method stub
        _log.info(" Trigger 被触发了，此时Job 上的 execute() 方法将要被执行");
    }

    @Override
    public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context) {
        // TODO Auto-generated method stub
        //返回false表示执行任务
        _log.info("拒绝执行任务！");
        return true;
    }

    @Override
    public void triggerMisfired(Trigger trigger) {
        // TODO Auto-generated method stub
        _log.info("当前触发错过了！");
    }

    @Override
    public void triggerComplete(Trigger trigger, JobExecutionContext context,
            CompletedExecutionInstruction triggerInstructionCode) {
        // TODO Auto-generated method stub
        _log.info("Trigger 被触发并且完成了 Job 的执行,此方法被调用----"+trigger.getKey());
    }

}

test类

package com.v.listenertest;

import static org.quartz.JobBuilder.newJob;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
import static org.quartz.TriggerBuilder.newTrigger;

import java.util.Date;

import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Matcher;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleTrigger;
import org.quartz.Trigger;
import org.quartz.TriggerKey;
import org.quartz.TriggerListener;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.KeyMatcher;

import com.v.paramtest.HelloJob2;

public class test {
    public static SimpleTrigger trigger1,trigger2 = null;

    public static void main(String[] args) {
        trigger1 = newTrigger().withIdentity("trigger1", "group1").startAt(new Date()).withSchedule(simpleSchedule()
                .withIntervalInSeconds(20).withRepeatCount(5).withMisfireHandlingInstructionNowWithExistingCount())
                .build();
        trigger2 = newTrigger().withIdentity("trigger2", "group2").startAt(new Date()).withSchedule(simpleSchedule()
                .withIntervalInSeconds(20).withRepeatCount(5).withMisfireHandlingInstructionNowWithExistingCount())
                .build();
        test1(trigger1,trigger2);
    }

    public static void test1(Trigger trigger1,Trigger trigger2) {
        try {
            SchedulerFactory schedulerFactory = new StdSchedulerFactory();
            Scheduler scheduler = null;
            scheduler = schedulerFactory.getScheduler();
            JobDetail job1 = newJob(HelloJob2.class).withIdentity("job1", "group1").build();
            JobDetail job2 = newJob(HelloJob2.class).withIdentity("job2", "group2").build();
            TriggerListenerDemo lisntener = new TriggerListenerDemo();
            JobListenerDemo jobListener = new JobListenerDemo();
//          直接添加为全局监听器
//          scheduler.getListenerManager().addTriggerListener(lisntener);
            Matcher<TriggerKey> matcher1 = KeyMatcher.keyEquals(trigger1.getKey());//局部监听
            scheduler.getListenerManager().addTriggerListener(lisntener, matcher1);
            Matcher<JobKey> matcher2 = KeyMatcher.keyEquals(job1.getKey());//局部监听
            scheduler.getListenerManager().addJobListener(jobListener, matcher2);
            job1.getJobDataMap().put("ExecutionDelay", 1000L);
            job2.getJobDataMap().put("ExecutionDelay", 1000L);
            scheduler.scheduleJob(job1, trigger1);
            scheduler.scheduleJob(job2, trigger2);
            scheduler.start();
        } catch (Exception se) {
            se.printStackTrace();
        }
    }
}

监听器可注册为局部监听和全局监听，全局监听顾名思义，TiggerListener则是监听所有Trigger。Job同理。

附上Demo：QuartzDemo