SpringBoot定时任务——Quartz (2) 监听器

一、TriggerListener 触发器监听器

跟触发器有关的事件包括**：触发器被触发，触发器触发失败，以及触发器触发完成**（触发器完成后作业任务开始运行）

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

getName 方法：用于获取触发器的名称
① triggerFired 方法（触发器被触发）：当与监听器相关联的Trigger被触发，Job上的execute()方法将被执行时，Scheduler就调用该方法，它关联的job即将被运行
② vetoJobExecution 方法（Trigger被激发）：Trigger被激发它关联的job即将被运行,先执行(1)，在执行(2) 如果返回TRUE 那么任务job会被终止
③ triggerMisfired 方法（触发器触发失败）：当Trigger错过被激发时执行,比如当前时间有很多触发器都需要执行，但是线程池中的有效线程都在工作，那么有的触发器就有可能超时，错过这一轮的触发
④ triggerComplete 方法（触发器触发完成）：任务完成时触发

2. 代码案例

2.1 创建监听器

@Slf4j
public class TimerTriggerListener  implements TriggerListener {

    private String timerTriggerName="";

    public TimerTriggerListener(String timerTriggerName) {
        this.timerTriggerName = timerTriggerName;
    }

    @Override
    public String getName() {
        // TODO Auto-generated method stub
        log.info(timerTriggerName);
        System.out.println(timerTriggerName);
        return timerTriggerName;
    }

    //触发器触发完成
    //(4) 任务完成时触发
    @Override
    public void triggerComplete(Trigger arg0, JobExecutionContext arg1, Trigger.CompletedExecutionInstruction arg2) {
        // TODO Auto-generated method stub
        log.info("触发器触发完成");
        System.out.println("触发器触发完成");
    }
    //触发器被触发
    //(1)Trigger被激发 它关联的job即将被运行
    @Override
    public void triggerFired(Trigger arg0, JobExecutionContext arg1) {
        // TODO Auto-generated method stub
        log.info("Trigger被激发 它关联的job即将被运行");
        System.out.println("触发器被触发");
    }
    //触发器触发失败
    //(3) 当Trigger错过被激发时执行,比如当前时间有很多触发器都需要执行，但是线程池中的有效线程都在工作，那么有的触发器就有可能超时，错过这一轮的触发。
    @Override
    public void triggerMisfired(Trigger arg0) {
        // TODO Auto-generated method stub
        log.info("触发器触发失败");
        System.out.println("触发器触发失败");
    }
    //(2)Trigger被激发 它关联的job即将被运行,先执行(1)，在执行(2) 如果返回TRUE 那么任务job会被终止
    @Override
    public boolean vetoJobExecution(Trigger arg0, JobExecutionContext arg1) {
        // TODO Auto-generated method stub
        return false;
    }
}

2.2 创建需要定时完成的任务

public class JobTest2 implements Job {
    private static int count = 1;
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("定时任务执行第"+ count++ +"次");
    }
}

2.3 启动定时器的代码

public class TimerExample {
    // 创建 schedulerFactory 工厂
    private static SchedulerFactory scheduleFactory= new StdSchedulerFactory();

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String[] data= {"s","t","r","i","n","g"};
        addJob("HelloJob","HelloJobGroup","HelloTrigger","HelloTriggerGroup",JobTest2.class,"0/1 * * * * ?",data);
    }

    public static void addJob(String jobName,String jobGroupName,String triggerName,String triggerGroupName
            ,Class<? extends Job> jobClass,String cron,String[] data) {
        try {
            // 1. 创建调度器
            Scheduler scheduler = scheduleFactory.getScheduler();

            //创建 jobDetail 实例，绑定 Job 实现类
            // 指明 job 的名称，所在组的名称，以及绑定 job 类
            JobDetail jobDetail = JobBuilder.newJob(jobClass)
                    .withIdentity(jobName, jobGroupName)
                    //.requestRecovery() // 执行中应用发生故障，需要重新执行
                    .build();
            // 初始化参数传递到 job
            jobDetail.getJobDataMap().put("data", data);

            // 定义调度触发规则CronTrigger

            Trigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity(triggerName, triggerGroupName)  //指明 CronTrigger 的名称，所在组的名称，触发时间
                    .startNow()
                    .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                    .build();
            // 把作业和触发器注册到任务调度中
            scheduler.scheduleJob(jobDetail, trigger);
            // 创建并注册一个全局的TriggerListener
            scheduler.getListenerManager().addTriggerListener(new TimerTriggerListener("TimerTrigger"), EverythingMatcher.allTriggers());
            // 创建并注册一个局部的TriggerListener
//	        scheduler.getListenerManager().addTriggerListener(new TimerTriggerListener("TimerTrigger"), KeyMatcher.keyEquals(TriggerKey.triggerKey(triggerName, triggerGroupName)));
            // 创建并注册一个特定组的TriggerListener
//	        scheduler.getListenerManager().addTriggerListener(new TimerTriggerListener("TimerTrigger"), GroupMatcher.groupEquals(triggerGroupName));
            //启动
            if (!scheduler.isShutdown()) {
                scheduler.start();
                System.out.println("开始调度任务");
            }
        } catch (SchedulerException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

运行结果：

在这里插入图片描述

二. JobListener 任务监听器

任务相关的事件包括：job开始要执行的提示; job执行完成的提示灯

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

2. 代码案例

2.1 创建监听器

@Slf4j
public class TimerJobListener implements JobListener {
    
    //获取该JobListener的名称
    @Override
    public String getName() {
        // TODO Auto-generated method stub
        String name = getClass().getSimpleName();
        log.info(name);
        return name;
    }
    //：Scheduler在JobDetail即将被执行，但又被TriggerListerner否决时会调用该方法
    @Override
    public void jobExecutionVetoed(JobExecutionContext arg0) {
        // TODO Auto-generated method stub
        log.info("Scheduler在JobDetail即将被执行，但又被TriggerListerner否决");
        System.out.println("jobExecutionVetoed");
    }
    //Scheduler在JobDetail将要被执行时调用这个方法。
    @Override
    public void jobToBeExecuted(JobExecutionContext arg0) {
        // TODO Auto-generated method stub
        log.info("Scheduler在JobDetail将要被执行");
        System.out.println("jobToBeExecuted");
    }
    //Scheduler在JobDetail被执行之后调用这个方法
    @Override
    public void jobWasExecuted(JobExecutionContext arg0, JobExecutionException arg1) {
        // TODO Auto-generated method stub
        log.info("Scheduler在JobDetail被执行之后");
        System.out.println("jobWasExecuted");
    }
}

2.2 创建需要定时完成的任务

public class JobTest2 implements Job {
    private static int count = 1;
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("定时任务执行第"+ count++ +"次");
    }
}

2.3 启动定时器

public class TimerExample {
    // 创建 schedulerFactory 工厂
    private static SchedulerFactory scheduleFactory= new StdSchedulerFactory();

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String[] data= {"s","t","r","i","n","g"};
        addJob("HelloJob","HelloJobGroup","HelloTrigger","HelloTriggerGroup",JobTest2.class,"0/1 * * * * ?",data);
    }

    public static void addJob(String jobName,String jobGroupName,String triggerName,String triggerGroupName
            ,Class<? extends Job> jobClass,String cron,String[] data) {
        try {
            // 1. 创建调度器
            Scheduler scheduler = scheduleFactory.getScheduler();

            //创建 jobDetail 实例，绑定 Job 实现类
            // 指明 job 的名称，所在组的名称，以及绑定 job 类
            JobDetail jobDetail = JobBuilder.newJob(jobClass)
                    .withIdentity(jobName, jobGroupName)
                    //.requestRecovery() // 执行中应用发生故障，需要重新执行
                    .build();
            // 初始化参数传递到 job
            jobDetail.getJobDataMap().put("data", data);

            // 定义调度触发规则CronTrigger

            Trigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity(triggerName, triggerGroupName)  //指明 CronTrigger 的名称，所在组的名称，触发时间
                    .startNow()
                    .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                    .build();

            // 把作业和触发器注册到任务调度中
            scheduler.scheduleJob(jobDetail, trigger);
            // 创建并注册一个全局的Job Listener
            scheduler.getListenerManager().addJobListener(new TimerJobListener(), EverythingMatcher.allJobs());
            // 创建并注册一个指定任务的Job Listener
            //scheduler.getListenerManager().addJobListener(new TimerJobListener(), KeyMatcher.keyEquals(JobKey.jobKey(jobName,jobGroupName)));

            //启动
            if (!scheduler.isShutdown()) {
                scheduler.start();
                System.out.println("开始调度任务");
            }
        } catch (SchedulerException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

运行结果：

在这里插入图片描述

三. SchedulerListener 调度器监听器

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

1. SchedulerListener接口源码

void jobScheduled(Trigger var1);

    void jobUnscheduled(TriggerKey var1);

    void triggerFinalized(Trigger var1);

    void triggerPaused(TriggerKey var1);

    void triggersPaused(String var1);

    void triggerResumed(TriggerKey var1);

    void triggersResumed(String var1);

    void jobAdded(JobDetail var1);

    void jobDeleted(JobKey var1);

    void jobPaused(JobKey var1);

    void jobsPaused(String var1);

    void jobResumed(JobKey var1);

    void jobsResumed(String var1);

    void schedulerError(String var1, SchedulerException var2);

    void schedulerInStandbyMode();

    void schedulerStarted();

    void schedulerStarting();

    void schedulerShutdown();

    void schedulerShuttingdown();

    void schedulingDataCleared();

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

2. 代码案例

2.1 创建监听器

@Slf4j
public class TimerSchedulerListener implements SchedulerListener {
    @Override
    public void jobScheduled(Trigger trigger) {
        String jobName = trigger.getJobKey().getName();
        log.info(jobName +"部署");
        System.out.println(jobName + "部署s");
    }

    @Override
    public void jobUnscheduled(TriggerKey triggerKey) {
        log.info(triggerKey + "卸载");
        System.out.println(triggerKey + "卸载");
    }

    @Override
    public void triggerFinalized(Trigger trigger) {
        log.info("触发完成" + trigger.getJobKey().getName());
        System.out.println("触发完成" + trigger.getJobKey().getName());
    }

    @Override
    public void triggerPaused(TriggerKey triggerKey) {
        log.info(triggerKey + "暂停");
        System.out.println(triggerKey + "暂停");
    }

    @Override
    public void triggersPaused(String triggerGroup) {
        log.info("trigger group "+triggerGroup + "暂停");
        System.out.println("trigger group "+triggerGroup + "暂停");
    }

    @Override
    public void triggerResumed(TriggerKey triggerKey) {
        log.info(triggerKey + "从暂停中恢复");
        System.out.println(triggerKey + "从暂停中恢复");
    }

    @Override
    public void triggersResumed(String triggerGroup) {
        log.info("trigger group "+triggerGroup + "从暂停中恢复");
        System.out.println("trigger group "+triggerGroup + "从暂停中恢复");
    }

    @Override
    public void jobAdded(JobDetail jobDetail) {
        log.info(jobDetail.getKey()+"增加");
        System.out.println(jobDetail.getKey()+"增加");
    }

    @Override
    public void jobDeleted(JobKey jobKey) {
        log.info(jobKey+"删除");
        System.out.println(jobKey+"删除");
    }

    @Override
    public void jobPaused(JobKey jobKey) {
        log.info(jobKey+"暂停");
        System.out.println(jobKey+"暂停");
    }

    @Override
    public void jobsPaused(String jobGroup) {
        log.info("job group "+jobGroup+"暂停");
        System.out.println("job group "+jobGroup+"暂停");
    }

    @Override
    public void jobResumed(JobKey jobKey) {
        log.info(jobKey+"从暂停上恢复");
        System.out.println(jobKey+"从暂停上恢复");
    }

    @Override
    public void jobsResumed(String jobGroup) {
        log.info("job group "+jobGroup+"从暂停上恢复");
        System.out.println("job group "+jobGroup+"从暂停上恢复");
    }

    @Override
    public void schedulerError(String msg, SchedulerException cause) {
        log.error(msg, cause.getUnderlyingException());
        log.info("正常运行期间产生一个严重错误");
        System.out.println("正常运行期间产生一个严重错误");
    }

    @Override
    public void schedulerInStandbyMode() {
        log.info("Scheduler处于StandBy模式");
        System.out.println("Scheduler处于StandBy模式");
    }

    @Override
    public void schedulerStarted() {
        log.info("scheduler开启完成");
        System.out.println("scheduler开启完成");
    }

    @Override
    public void schedulerStarting() {
        log.info("scheduler正在开启");
        System.out.println("scheduler正在开启");
    }

    @Override
    public void schedulerShutdown() {
        log.info("scheduler停止");
        System.out.println("scheduler停止");
    }

    @Override
    public void schedulerShuttingdown() {
        log.info("scheduler正在停止");
        System.out.println("scheduler正在停止");
    }

    @Override
    public void schedulingDataCleared() {
        log.info("Scheduler中的数据被清除");
        System.out.println("Scheduler中的数据被清除");
    }
}

2.2 创建需要定时完成的任务

public class JobTest2 implements Job {
    private static int count = 1;
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("定时任务执行第"+ count++ +"次");
    }
}

2.3 启动定时器

public class TimerExample {
    // 创建 schedulerFactory 工厂
    private static SchedulerFactory scheduleFactory= new StdSchedulerFactory();

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String[] data= {"s","t","r","i","n","g"};
        addJob("HelloJob","HelloJobGroup","HelloTrigger","HelloTriggerGroup",JobTest2.class,"0/1 * * * * ?",data);
    }

    public static void addJob(String jobName,String jobGroupName,String triggerName,String triggerGroupName
            ,Class<? extends Job> jobClass,String cron,String[] data) {
        try {
            // 1. 创建调度器
            Scheduler scheduler = scheduleFactory.getScheduler();

            //创建 jobDetail 实例，绑定 Job 实现类
            // 指明 job 的名称，所在组的名称，以及绑定 job 类
            JobDetail jobDetail = JobBuilder.newJob(jobClass)
                    .withIdentity(jobName, jobGroupName)
                    //.requestRecovery() // 执行中应用发生故障，需要重新执行
                    .build();
            // 初始化参数传递到 job
            jobDetail.getJobDataMap().put("data", data);

            // 定义调度触发规则CronTrigger

            Trigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity(triggerName, triggerGroupName)  //指明 CronTrigger 的名称，所在组的名称，触发时间
                    .startNow()
                    .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                    .build();

            // 把作业和触发器注册到任务调度中
            scheduler.scheduleJob(jobDetail, trigger);

            // 创建SchedulerListener
            scheduler.getListenerManager().addSchedulerListener(new TimerSchedulerListener());

            // 移除对应的SchedulerListener
//	        scheduler.getListenerManager().removeSchedulerListener(new TimerSchedulerListener());
            //启动
            if (!scheduler.isShutdown()) {
                scheduler.start();
                System.out.println("开始调度任务");
            }
        } catch (SchedulerException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

运行结果：

在这里插入图片描述

SpringBoot定时任务——Quartz (2) 监听器

一、TriggerListener 触发器监听器

1. TriggerListener 接口源码

2. 代码案例

2.1 创建监听器

2.2 创建需要定时完成的任务

2.3 启动定时器的代码

二. JobListener 任务监听器

1. JobListener接口源码

2. 代码案例

2.1 创建监听器

2.2 创建需要定时完成的任务

2.3 启动定时器

三. SchedulerListener 调度器监听器

1. SchedulerListener接口源码

2. 代码案例

2.1 创建监听器

2.2 创建需要定时完成的任务

2.3 启动定时器

猜你喜欢