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

posted on 2020-01-20 11:10  海之浪子  阅读(654)  评论(0)  编辑  收藏  举报

导航