Quartz框架中的监听器

• Quartz框架中的监听器

  quartz框架中有三个主要的监听器，分别为JobListener,TriggerListener和SchedulerListener,下面详细介绍一下这三个监听器

  • JobListener

    • JobListener为一个接口，里面定义了一些方法，所有实现该接口的类都需要实现该方法

      public interface JobListener {
      
          /**
           * Job监听器的名字
           *
           * @return
           */
          String getName();
          
          /**
           * Scheduler在JobeDetail将要被执行的时候调用该方法
           *
           * @param context
           */
          void jobToBeExecuted(JobExecutionContext context);
          
          /**
           * Scheduler在JobeDetail将要被执行，但是被TriggerListener取消的时候调用该方法
           *
           * @param context
           */
          void jobExecutionVetoed(JobExecutionContext context);
      
      
          /**
           * Scheduler在JobDetail被执行后调用该方法
           *
           * @param context
           * @param jobException
           */
          void jobWasExecuted(JobExecutionContext context,
                              JobExecutionException jobException);
      
      }
      

    • 自定义Job监听器

      public class Job1Listener implements JobListener {
          /**
           * @return JobListener 名称
           */
          @Override
          public String getName() {
              return "job1_to_job2";
          }
      
          /**
           * @param context
           */
          @Override
          public void jobToBeExecuted(JobExecutionContext context) {
      
              JobDetail jobDetail = context.getJobDetail();
              System.out.println("Job1Listener says: " + jobDetail + "Job Is about to be executed.");
          }
      
          @Override
          public void jobExecutionVetoed(JobExecutionContext context) {
              JobDetail jobDetail = context.getJobDetail();
              System.out.println("Job1Listener says: " + jobDetail + "Job Execution was vetoed.");
          }
      
          @Override
          public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {
              JobDetail jobDetail = context.getJobDetail();
              System.out.println("Job1Listener says: " + jobDetail + "Job was executed.");
      
              // Simple job #2
      //        JobDetail job2 = newJob(SimpleJob2.class).withIdentity("job2").build();
      //
      //        Trigger trigger = newTrigger().withIdentity("job2Trigger").startNow().build();
      //
      //        try {
      //            // schedule the job to run!
      //            context.getScheduler().scheduleJob(job2, trigger);
      //        } catch (SchedulerException e) {
      //            System.out.println("Unable to schedule job2!");
      //            e.printStackTrace();
      //        }
          }
      }
      

      public class ListenerJobMain {
      
          public static void main(String[] args) throws Exception {
              SchedulerFactory sf = new StdSchedulerFactory();
              Scheduler sched = sf.getScheduler();
          
              JobDetail job = newJob(SimpleJob1.class).withIdentity("job1","group1").build();
              Trigger trigger = newTrigger().withIdentity("trigger1").startNow().build();
          
              // 针对特定的JobDetail进行监听
              JobListener listener = new Job1Listener();
              Matcher<JobKey> matcher = KeyMatcher.keyEquals(job.getKey());
              sched.getListenerManager().addJobListener(listener, matcher);
          
              //设置全局监听
              //sched.getListenerManager().addJobListener(listener);
      
      
      
              // schedule the job to run
              sched.scheduleJob(job, trigger);
      
      
              sched.start();
          
              Thread.sleep(30L * 1000L);
          
          }
      
      }
      

      上面采用KeyMatcher和ListerManager来对我们的任务进行监听，其实在Quartz框架中，可以通过组合来实现不同的方式对job进行监听 。如：

      通过ListenerManager向scheduler中添加监听器。针对JobDtail方法有

      /**
       * 添加全局监听器
       */
      public void addJobListener(JobListener jobListener);
      /**
       * 添加带条件匹配监听器
       */
      public void addJobListener(JobListener jobListener, Matcher<JobKey> matcher);
      
      /**
       * 添加不定参数带条件匹配监听器
       */
      public void addJobListener(JobListener jobListener, Matcher<JobKey> ... matchers);
      
      /**
       * 添加不定参数带条件匹配监听器
       */
      public void addJobListener(JobListener jobListener, List<Matcher<JobKey>> matchers);
      
      /**
       * 添加匹配名字的监听器
       */
      public boolean addJobListenerMatcher(String listenerName, Matcher<JobKey> matcher);
      
      /**
       * 删除匹配名字的监听器
       */
      public boolean removeJobListenerMatcher(String listenerName, Matcher<JobKey> matcher);
      
      /**
       *设置匹配名字的监听器
       */
      public boolean setJobListenerMatchers(String listenerName, List<Matcher<JobKey>> matchers);
      
      /**
       * 根据监听名字获取匹配监听器
       */
      public List<Matcher<JobKey>> getJobListenerMatchers(String listenerName);
      
      /**
       * 根据名字删除监听器
       */
      public boolean removeJobListener(String name);
      
      /**
       * 获取所有的监听器
       */
      public List<JobListener> getJobListeners();
      
      /**
       * 根据名字获取监听器
       */
      public JobListener getJobListener(String name);
      

      Matcher:通过Matcher监听不同的任务，具体实现类如下：

      KeyMatcher:根据JobKey进行匹配

      GroupMatcher:跟组名信息进行匹配

      AndMatcher:对两个匹配器做交际

      OrMatcher:对两个匹配器做并集

      EveryThingMatcher:局部全局匹配

    • TriggerListener

      • TriggerListener接口中的方法

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

      • 自定义TriggerListener

        public class Job1TriggerListener implements TriggerListener {
            @Override
            public String getName() {
                return "Job1Trigger";
            }
        
            @Override
            public void triggerFired(Trigger trigger, JobExecutionContext context) {
                System.out.println("triggerFired");
            
            }
            
            @Override
            public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context) {
                System.out.println("vetoJobExecution");
                return false;
            }
            
            @Override
            public void triggerMisfired(Trigger trigger) {
                System.out.println("triggerMisfired");
            
            }
            
            @Override
            public void triggerComplete(Trigger trigger, JobExecutionContext context, Trigger.CompletedExecutionInstruction triggerInstructionCode) {
            
                System.out.println("triggerComplete");
            
            }
        
        }
        

        在ListenerJobMain代码中添加如下代码，即可看到自定义TriggerListener的运行效果

            //设定局部监听
            TriggerListener TriggerListener = new Job1TriggerListener();
            KeyMatcher<TriggerKey> tkeyMatcher = KeyMatcher.keyEquals(trigger.getKey());
            sched.getListenerManager().addTriggerListener(TriggerListener, tkeyMatcher);
        
            //设置全局监听
            //sched.getListenerManager().addTriggerListener(TriggerListener);
        

        其实TriggerListener和JobListener的接口定义的方法大同小异，可以自行学习一下

    • SchedulerListener

      SchedulerListener 是在 Scheduler 级别的事件产生时得到通知，不管是增加还是移除 Scheduler 中的 Job，或者是 Scheduler 遭遇到了严重的错误时。那些事件多是关于对 Scheduler 管理的，而不是专注于 Job 或 Trigger 的。 org.quartz.SchedulerListener 接口包含了一系列的回调方法，它们会在 Scheduler 的生命周期中有关键事件发生时被调用

      SchedulerListener的自定义实现跟上面TriggerListener和JobListener大同小异，可以自行学习一下

      相关源码参考： https://github.com/albert-liu435/springquartz