Listeners是您创建的对象，用于根据调度程序中发生的事件执行操作。

1. JobListenser

job相关事件包括：job即将执行的通知，以及job完成执行时的通知。
org.quartz.JobListener接口：

  1. public interface JobListener {
  3.     public String getName();
  5.     public void jobToBeExecuted(JobExecutionContext context);
  7.     public void jobExecutionVetoed(JobExecutionContext context);
  9.     public void jobWasExecuted(JobExecutionContext context,
  10.                                JobExecutionException jobException);
  12. }

（1）创建一个JobListenser接口

要创建一个listener，只需创建一个实现org.quartz.JobLitenser接口的对象。然后，listener在运行时会向调度程序注册，并且必须给出一个名称（或者，他们必须通过他们的getName（）方法来获得自己的名字）。

  1. import org.quartz.JobExecutionContext;
  2. import org.quartz.JobExecutionException;
  3. import org.quartz.JobListener;
  5. public class MyJobListener implements JobListener {
  7.     private String name;
  9.     public MyJobListener(String name) {
  10.         this.name = name;
  11.     }
  13.     public String getName() {
  14.         return name;
  15.     }
  17.     public void jobToBeExecuted(JobExecutionContext context) {
  18.         // do something with the event
  19.     }
  21.     public void jobWasExecuted(JobExecutionContext context,
  22.             JobExecutionException jobException) {
  23.         // do something with the event
  24.     }
  26.     public void jobExecutionVetoed(JobExecutionContext context) {
  27.         // do something with the event
  28.     }
  29. }

为了方便起见，实现这些接口，类也可以扩展JobListenerSuppor类，并且只需覆盖感兴趣的事件。

  1. import org.quartz.JobExecutionContext;
  2. import org.quartz.JobExecutionException;
  3. import org.quartz.listeners.JobListenerSupport;
  5. public class MyOtherJobListener extends JobListenerSupport {
  7.     private String name;
  9.     public MyOtherJobListener(String name) {
  10.         this.name = name;
  11.     }
  13.     public String getName() {
  14.         return name;
  15.     }
  16.     @Override
  17.     public void jobWasExecuted(JobExecutionContext context,
  18.             JobExecutionException jobException) {
  19.         // do something with the event
  20.     }
  21. }

（2）使用JobListenser

listener与调度程序的ListenerManager一起注册，并配有描述listener希望接收事件的job的Matcher。 :::info Listener在运行时间内与调度程序一起注册，并且不与jobs和触发器一起存储在JobStore中。这是因为Listenser通常是与应用程序的集成点。因此，每次运行应用程序时，都需要重新注册该调度程序。 ::: 需要为匹配器和关键类使用静态导入，这将使定义匹配器更简洁：

  1. import static org.quartz.JobKey.*;
  2. import static org.quartz.impl.matchers.KeyMatcher.*;
  3. import static org.quartz.impl.matchers.GroupMatcher.*;
  4. import static org.quartz.impl.matchers.AndMatcher.*;
  5. import static org.quartz.impl.matchers.OrMatcher.*;
  6. import static org.quartz.impl.matchers.EverythingMatcher.*;

  • 向调度程序注册一个作业监听器，以侦听所有作业

    1. scheduler.getListenerManager().addJobListener(myJobListener, allJobs());

  • 向调度程序注册一个作业监听器，以侦听特定的作业

    1. scheduler.getListenerManager().addJobListener(myJobListener, jobKeyEquals(jobKey("myJobName", "myJobGroup")));

  • 向调度程序注册一个作业监听器，以侦听两个特定的作业

    1. scheduler.getListenerManager().addJobListener(myJobListener, or(jobGroupEquals("myJobGroup"), jobGroupEquals("yourGroup")));

  • 向调度程序注册一个作业监听器，以侦听一个特定组的所有作业

    1. scheduler.getListenerManager().addJobListener(myJobListener, jobGroupEquals("myJobGroup"));

2. TriggerListenser

（1）创建一个TriggerListenser接口

要创建一个listener，只需创建一个实现org.quartz.TriggerListener接口的对象。然后，listener在运行时会向调度程序注册，并且必须给出一个名称（或者，他们必须通过他们的getName（）方法来获得自己的名字）。

  1. import org.quartz.JobExecutionContext;
  2. import org.quartz.Trigger;
  3. import org.quartz.TriggerListener;
  4. import org.quartz.Trigger.CompletedExecutionInstruction;
  6. public class MyTriggerListener implements TriggerListener {
  8.     private String name;
  10.     public MyTriggerListener(String name) {
  11.         this.name = name;
  12.     }
  14.     public String getName() {
  15.         return name;
  16.     }
  18.     public void triggerComplete(Trigger trigger, JobExecutionContext context,
  19.             CompletedExecutionInstruction triggerInstructionCode) {
  20.         // do something with the event
  22.     }
  24.     public void triggerFired(Trigger trigger, JobExecutionContext context) {
  25.         // do something with the event
  26.     }
  28.     public void triggerMisfired(Trigger trigger) {
  29.         // do something with the event
  30.     }
  32.     public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context) {
  33.         // do something with the event
  34.         return false;
  35.     }
  37. }

为了方便起见，实现这些接口，类也可以扩展TriggerListenerSupport类，并且只需覆盖感兴趣的事件。

  1. import org.quartz.JobExecutionContext;
  2. import org.quartz.Trigger;
  3. import org.quartz.listeners.TriggerListenerSupport;
  5. public class MyOtherTriggerListener extends TriggerListenerSupport {
  7.     private String name;
  9.     public MyOtherTriggerListener(String name) {
  10.         this.name = name;
  11.     }
  13.     public String getName() {
  14.         return name;
  15.     }
  17.     @Override
  18.     public void triggerFired(Trigger trigger, JobExecutionContext context) {
  19.         // do something with the event
  20.     }
  21. }

（2）使用TriggerListenser

listener与调度程序的TriggerManager一起注册，并配有描述listener希望接收事件的触发器的Matcher。
需要为匹配器和关键类使用静态导入，这将使定义匹配器更简洁：

  1. import static org.quartz.TriggerKey.*;
  2. import static org.quartz.impl.matchers.KeyMatcher.*;
  3. import static org.quartz.impl.matchers.GroupMatcher.*;
  4. import static org.quartz.impl.matchers.AndMatcher.*;
  5. import static org.quartz.impl.matchers.OrMatcher.*;
  6. import static org.quartz.impl.matchers.EverythingMatcher.*;

  • 向调度程序注册一个trigger监听器，以侦听所有trigger

    1. scheduler.getListenerManager().addTriggerListener(myTriggerListener, allTriggers());

  • 向调度程序注册一个trigger监听器，以侦听特定的trigger

    1. scheduler.getListenerManager().addTriggerListener(myTriggerListener, triggerKeyEquals(triggerKey("myTriggerName", "myTriggerGroup")));

  • 向调度程序注册一个trigger监听器，以侦听一个特定组的所有trigger

    1. scheduler.getListenerManager().addTriggerListener(myTriggerListener, triggerGroupEquals("myTriggerGroup"));

3. SchedulerListenser

SchedulerListeners非常类似于TriggerListeners和JobListeners，除了它们在Scheduler本身中接收到事件的通知 - 不一定与特定触发器（trigger）或job相关的事件。
与计划程序相关的事件包括：添加job/触发器，删除job/触发器，调度程序中的严重错误，关闭调度程序的通知等。
org.quartz.SchedulerListener接口：

  1. public interface SchedulerListener {
  3.     public void jobScheduled(Trigger trigger);
  5.     public void jobUnscheduled(String triggerName, String triggerGroup);
  7.     public void triggerFinalized(Trigger trigger);
  9.     public void triggersPaused(String triggerName, String triggerGroup);
  11.     public void triggersResumed(String triggerName, String triggerGroup);
  13.     public void jobsPaused(String jobName, String jobGroup);
  15.     public void jobsResumed(String jobName, String jobGroup);
  17.     public void schedulerError(String msg, SchedulerException cause);
  19.     public void schedulerStarted();
  21.     public void schedulerInStandbyMode();
  23.     public void schedulerShutdown();
  25.     public void schedulingDataCleared();
  26. }

（1）创建SchedulerListenser

继承SchedulerListenerSupport并重写它的方法：

  1. import org.quartz.Trigger;
  2. import org.quartz.listeners.SchedulerListenerSupport;
  4. public class MyOtherSchedulerListener extends SchedulerListenerSupport {
  6.     @Override
  7.     public void schedulerStarted() {
  8.         // do something with the event
  9.     }
  11.     @Override
  12.     public void schedulerShutdown() {
  13.         // do something with the event
  14.     }
  16.     @Override
  17.     public void jobScheduled(Trigger trigger) {
  18.         // do something with the event
  19.     }
  21. }

（2）使用SchedulerListener

SchedulerListeners注册到调度程序的ListenerManager。SchedulerListeners几乎可以实现任何实现org.quartz.SchedulerListener接口的对象。

  • 添加SchedulerListener：

    1. scheduler.getListenerManager().addSchedulerListener(mySchedListener);

  • 删除SchedulerListener：

    1. scheduler.getListenerManager().removeSchedulerListener(mySchedListener);

4.