quartz监听器使用

你的名字 2022-12-20 08:52 125阅读 0赞

## 前言 ##

和许多框架类似，quartz也提供了监听器即listener的功能，通过监听器可以达到在被调度的任务之前，之后，或者任务执行过程中，得到人为的干预的效果，举例来说，我们希望在某个job执行前过滤一部分数据，或者在job完成时给系统管理员发一封邮件，甚至我们希望调度任务跳过节假日的执行等，在类似的业务场景下，我们就可以考虑使用quartz提供的监听器功能

## Quartz监听器类型 ##

**Quartz主要提供了3种类型的监听器，分别是**：

JobListener、TriggerListener、SchedulerListener三种，顾名思义，可分别理解为任务、触发器、调度器对应的监听器

三者的使用方法类似，quartz提供了各自的接口，我们只需要实现相应的方法即可。

在开始介绍三种监听器之前，需要掌握两个概念：全局监听器与非全局监听器，二者的区别在于：全局监听器能够接收到所有的Job/Trigger的事件通知，非全局监听器只能接收到在其上注册的Job或Trigger的事件，不在其上注册的Job或Trigger则不会进行监听。这个在：scheduler.getListenerManager().addJobListener 对应的API中会得到体现，下面通过代码分别演示下各个监听器的使用

## 1、JobListener ##

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被执行之后调用这个方法

**演示demo**

@Slf4j
    public class MyJobTriggerListener implements JobListener {
    
        /**
         * 获取job名称
         * @return
         */
        @Override
        public String getName() {
            String name = getClass().getSimpleName();
            log.info(name);
            return name;
        }
    
        /**
         * job将要被执行时调用的方法
         * @param jobExecutionContext
         */
        @Override
        public void jobToBeExecuted(JobExecutionContext jobExecutionContext) {
            log.info("2 ===  jobToBeExecuted");
        }
    
        @Override
        public void jobExecutionVetoed(JobExecutionContext jobExecutionContext) {
            System.out.println("jobExecutionVetoed");
        }
    
        /**
         * job执行完毕之后执行的方法
         * @param jobExecutionContext
         * @param e
         */
        @Override
        public void jobWasExecuted(JobExecutionContext jobExecutionContext, JobExecutionException e) {
            log.info("5 ========== jobWasExecuted");
        }
    }

public class DemoTest1 {
    
        private static SchedulerFactory schedulerFactory = new StdSchedulerFactory();
    
        public static void main(String[] args) throws Exception {
            Scheduler scheduler = schedulerFactory.getScheduler();
            JobDetail job = JobBuilder.newJob(MyJob.class)
                    .withIdentity("myJob", "myJobGroup")
                    //.requestRecovery() // 执行中应用发生故障，需要重新执行
                    .build();
            Trigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity("myFirstTrigger", "myFirstTriggerGroup")
                    .startNow()
                    .withSchedule(CronScheduleBuilder.cronSchedule("0/3 * * * * ?"))
                    .build();
            //关联job和trigger对象
            scheduler.scheduleJob(job, trigger);
            scheduler.getListenerManager().addJobListener(new MyJobTriggerListener(), EverythingMatcher.allJobs());
            if(!scheduler.isShutdown()){
                scheduler.start();
            }
        }
    }

最后再提供一个实现job接口的类即可

@Slf4j
    public class MyJob implements Job {
    
        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
          log.info("job task begin");
        }
    }

本段代码基本上没有什么逻辑，仅仅就是在之前的demo篇的最后，通过scheduler这个对象将监听器调用起来即可，运行这段代码，观察控制台效果，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY29uZ3lpNDIw_size_16_color_FFFFFF_t_70_pic_center]

个人理解，其实把监听器类比servlet的生命周期函数可能更好理解，即在job执行之前，之后或者执行过程中动态去添加一些额外的动作

## 2、TriggerListener ##

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);
    }

**简单解释下几个方法：**

*  triggerFired方法：当与监听器相关联的Trigger被触发，Job上的execute()方法将被执行时，Scheduler就调用该方法
 *  vetoJobExecution方法：在 Trigger 触发后，Job 将要被执行时由 Scheduler 调用这个方法。TriggerListener 给了一个选择去否决 Job 的执行。假如这个方法返回 true，这个 Job 将不会为此次 Trigger 触发而得到执行
 *  triggerMisfired方法：Scheduler 调用这个方法是在 Trigger 错过触发时。你应该关注此方法中持续时间长的逻辑：在出现许多错过触发的 Trigger 时，长逻辑会导致骨牌效应。你应当保持这上方法尽量的小
 *  triggerComplete方法：Trigger 被触发并且完成了 Job 的执行时，Scheduler 调用这个方法

总体的使用和jobTrigger类似，下面看具体代码，

public class TriggerListener1 implements TriggerListener {
    
        Logger logger = LoggerFactory.getLogger(TriggerListener1.class);
    
        private String timerTriggerName = "";
    
        public TriggerListener1(String timerTriggerName) {
            this.timerTriggerName = timerTriggerName;
        }
    
        @Override
        public String getName() {
            logger.info("1 -----> 触发器名称 :" + timerTriggerName);
            return timerTriggerName;
        }
    
        @Override
        public void triggerFired(Trigger trigger, JobExecutionContext jobExecutionContext) {
            logger.info("2 -----> Trigger被激发 它关联的job即将被运行");
        }
    
        @Override
        public boolean vetoJobExecution(Trigger trigger, JobExecutionContext jobExecutionContext) {
            return false;
        }
    
        @Override
        public void triggerMisfired(Trigger trigger) {
            logger.info("触发器错过执行时候被执行");
        }
    
        @Override
        public void triggerComplete(Trigger trigger, JobExecutionContext jobExecutionContext, Trigger.CompletedExecutionInstruction completedExecutionInstruction) {
            logger.info("5 ====== triggerComplete ----------");
        }
    
    }

public class DemoTest2 {
    
        private static SchedulerFactory schedulerFactory = new StdSchedulerFactory();
    
        public static void main(String[] args) throws Exception{
            Scheduler scheduler = schedulerFactory.getScheduler();
            JobDetail job = JobBuilder.newJob(MyJob.class)
                    .withIdentity("myJob1", "myJobGroup1")
                    //.requestRecovery() // 执行中应用发生故障，需要重新执行
                    .build();
            Trigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity("myFirstTrigger1", "myFirstTriggerGroup1")
                    .startNow()
                    .withSchedule(CronScheduleBuilder.cronSchedule("0/3 * * * * ?"))
                    .build();
            scheduler.scheduleJob(job, trigger);
            scheduler.getListenerManager().addTriggerListener(new TriggerListener1("myFirstTrigger1"), EverythingMatcher.allTriggers());
    
            if(!scheduler.isShutdown()){
                scheduler.start();
            }
        }
    
    }

其实我们在阅读listener的接口实现代码时，可以发现在它的实现类中，有一个TriggerListenerSupport的抽象类，即我们也可以继承这个类，只实现其中的部分业务关注的方法  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY29uZ3lpNDIw_size_16_color_FFFFFF_t_70_pic_center 1]

运行这段代码，观察控制台效果，和上面的效果差不多  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY29uZ3lpNDIw_size_16_color_FFFFFF_t_70_pic_center 2]

## 3、SchedulerListener ##

SchedulerListener会在Scheduler的生命周期关键事件发生时被调用。与Scheduler有关的事件包括：增加一个job/trigger，删除一个job/trigger，scheduler发生严重错误，关闭scheduler等

参考前面两种的方式，有兴趣的同学可以点击进去看看具体的方法，这里对其中涉及到的几个方法简单解释下

*  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中的数据被清除时，调用该方法

在接口实现上，可以实现SchedulerListener，也可以继承SchedulerListenerSupport抽象类，下面看具体的代码实现

@Slf4j
    public class SchedulerTrigger1 extends SchedulerListenerSupport {
    
        @Override
        public void jobAdded(JobDetail jobDetail) {
            log.info("1 === 监听到有一个job准备加入进去");
        }
    
        @Override
        public void jobScheduled(Trigger trigger) {
            log.info("job准备被调度 jobScheduled");
        }
    
        @Override
        public void schedulerShutdown() {
            log.info("job 调度准备停止的时候 schedulerShutdown");
        }
    
        @Override
        public void schedulerStarted() {
            log.info("job 调度要开始了 schedulerStarted");
        }
    
        @Override
        public void schedulerStarting() {
            super.schedulerStarting();
        }
    }

public class DemoTest3 {
    
        private static SchedulerFactory schedulerFactory = new StdSchedulerFactory();
    
        public static void main(String[] args) throws Exception {
            Scheduler scheduler = schedulerFactory.getScheduler();
            JobDetail job = JobBuilder.newJob(MyJob.class)
                    .withIdentity("myJob3", "myJobGroup3")
                    //.requestRecovery() // 执行中应用发生故障，需要重新执行
                    .build();
            Trigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity("myFirstTrigger3", "myFirstTriggerGroup3")
                    .startNow()
                    .withSchedule(CronScheduleBuilder.cronSchedule("0/3 * * * * ?"))
                    .build();
            scheduler.scheduleJob(job, trigger);
            scheduler.getListenerManager().addSchedulerListener(new SchedulerTrigger1());
            scheduler.start();
            Thread.sleep(12000);
            scheduler.shutdown();
        }
    
    }

运行上面的代码，效果和上面的类似  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY29uZ3lpNDIw_size_16_color_FFFFFF_t_70_pic_center 3]

## quartz监听器与springboot的整合 ##

在上一篇中我们讲解了与springboot的整合，这里简单的再走一遍

**1、添加依赖**

<dependencies>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>org.quartz-scheduler</groupId>
                <artifactId>quartz</artifactId>
                <version>2.3.1</version>
            </dependency>
    
            <dependency>
                <groupId>org.quartz-scheduler</groupId>
                <artifactId>quartz-jobs</artifactId>
                <version>2.3.1</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-quartz</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>

**2、两个主要的配置类**

@Configuration
    public class SchedulerConfig {
    
        @Autowired
        private SpringJobFactory springJobFactory;
    
        @Bean(name="SchedulerFactory")
        public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
            SchedulerFactoryBean factory = new SchedulerFactoryBean();
            factory.setAutoStartup(true);
            factory.setStartupDelay(5);//延时5秒启动
            factory.setQuartzProperties(quartzProperties());
            factory.setJobFactory(springJobFactory);
            return factory;
        }
    
        @Bean
        public Properties quartzProperties() throws IOException {
            PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
            propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
            propertiesFactoryBean.afterPropertiesSet();
            return propertiesFactoryBean.getObject();
        }
    
        /*
         * quartz初始化监听器
         */
        @Bean
        public QuartzInitializerListener executorListener() {
            return new QuartzInitializerListener();
        }
    
        /*
         * 通过SchedulerFactoryBean获取Scheduler的实例
         */
        @Bean(name="Scheduler")
        public Scheduler scheduler() throws IOException {
            return schedulerFactoryBean().getScheduler();
        }
    
    }

import org.quartz.spi.TriggerFiredBundle;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
    import org.springframework.scheduling.quartz.AdaptableJobFactory;
    import org.springframework.stereotype.Component;
    /**
     * 解决spring bean注入Job的问题
     */
    @Component
    public class SpringJobFactory extends AdaptableJobFactory  {
        @Autowired
        private AutowireCapableBeanFactory capableBeanFactory;
    
        @Override
        protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
            // 调用父类的方法
            Object jobInstance = super.createJobInstance(bundle);
            // 进行注入
            capableBeanFactory.autowireBean(jobInstance);
            return jobInstance;
        }
    }

在实际开发中，最好再在资源目录下添加quartz.properties配置文件，控制quartz运行时的相关参数，比如分配线程数等，在之前的篇章中有介绍这里就不再罗列了

**3、提供一个任务类，用于初始化调度任务**

@Component
    public class TaskRunner implements ApplicationRunner {
    
        private final static Logger LOGGER = LoggerFactory.getLogger(TaskRunner.class);
    
        @Autowired
        @Qualifier("Scheduler")
        private Scheduler scheduler;
    
        @Override
        public void run(ApplicationArguments var) throws Exception {
            LOGGER.info("初始化测试任务");
            Date date = DateBuilder.futureDate(7, DateBuilder.IntervalUnit.SECOND);
    
            //构建job信息
            JobDetail job = JobBuilder
                    .newJob(QuartzDemo.class)
                    .withIdentity("triggerJob", "triggerJobGroup")
                    .withDescription("测试任务")
                    .build();
    
            // 触发时间点
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/3 * * * * ?");
    
            Trigger trigger = TriggerBuilder
                    .newTrigger()
                    .withIdentity("triggerJob", "triggerJobGroup")
                    .startAt(date)
                    .withSchedule(cronScheduleBuilder).build();
            //交由Scheduler安排触发
            scheduler.scheduleJob(job, trigger);
    
            //安排一个监听器
            scheduler.getListenerManager().addJobListener(new MyJobTriggerListener());
            if (!scheduler.isShutdown()) {
                scheduler.start();
            }
        }
    
    }

启动项目，设置的是7秒之后任务开始调度，观察控制台执行效果，到这里，与springboot的整合也完成  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY29uZ3lpNDIw_size_16_color_FFFFFF_t_70_pic_center 4]

**本篇主要讲述了quartz监听器的基本使用以及与springboot的整合，有兴趣的同学可以继续深入研究，本篇到此结束，最后感谢观看！**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY29uZ3lpNDIw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/2c875af40a5d43de93ca2f060bc0c0b1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY29uZ3lpNDIw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/d3e5cc40c4f04d21b2bc2e297952fbdb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY29uZ3lpNDIw_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201111175159293.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY29uZ3lpNDIw,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY29uZ3lpNDIw_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/2020111117574299.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY29uZ3lpNDIw,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY29uZ3lpNDIw_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20201111190655193.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nY29uZ3lpNDIw,size_16,color_FFFFFF,t_70#pic_center