示例6 - 处理作业异常

说明

没有作业是完美的。参考此示例，了解如何让调度器知道如何处理作业引发的异常。

解析

本示例旨在演示如何处理作业执行异常。Quartz中的作业允许抛出作业执行异常（JobExecutionExceptions）。当抛出此异常时，您可以指示Quartz采取什么操作。

该程序将执行以下操作：

• 启动Quartz调度器

• 安排2个作业，每个作业每3秒执行1次，无限期运行

• 作业将抛出一个异常，Quartz将采取适当的行动

• 程序将等待60秒，以便2个作业有足够的时间运行

• 关闭调度器程序

运行示例

此示例可以从examples/example6目录中执行。有两种开箱即用的方法来运行此示例：

• example6.sh——UNIX/Linux shell脚本

• example6.bat——Windows批处理文件

代码

此示例的代码位于org.quartz.examples.example6包中。

本示例中的代码由以下类组成：

类名	描述
JobExceptionExample	主程序
BadJob1	一个简单的作业，它将抛出异常并指示Quartz立即重新启动触发器
BadJob2	一个简单的作业，它将抛出异常并指示Quartz不再安排作业

BadJob1

BadJob1是一个简单的作业，只需创造一个人工异常（除以零）。捕获此异常时，将抛出作业执行异常（JobExecutionException），并将其设置为立即重新启动作业。

try {
    int zero = 0;
    int calculation = 4815 / zero;
}
catch (Exception e) {
       _log.info("--- Error in job!");
       JobExecutionException e2 = new JobExecutionException(e);
       //此作业将立即重新开始
       e2.refireImmediately();
       throw e2;
}

这将迫使Quartz一次又一次地执行该作业。

BadJob2

BadJob2是一个简单的作业，只需创造一个人工异常（除以零）。捕获此异常时，将抛出作业执行异常（JobExecutionException），并将其设置为确保Quartz不再运行该作业。

try {
    int zero = 0;
    int calculation = 4815 / zero;
}
catch (Exception e) {
       _log.info("--- Error in job!");
       JobExecutionException e2 = new JobExecutionException(e);
       //Quartz将自动取消计划与此作业关联的所有触发器，使其不再运行
       e2.setUnscheduleAllTriggers(true);
       throw e2;
}

这将迫使Quartz关闭此作业，使其不再运行。

JobExceptionExample

程序从获取调度器（Scheduler）的实例开始。这是通过创建标准调度器工厂（StdSchedulerFactory），然后使用它创建调度器来完成的。这将创建一个简单的基于RAM的调度器。

SchedulerFactory sf = new StdSchedulerFactory();
Scheduler sched = sf.getScheduler();

作业#1计划无限期地每3秒运行1次。此作业将触发BadJob1。

JobDetail job = newJob(BadJob1.class)
    .withIdentity("badJob1", "group1")
    .build();

SimpleTrigger trigger = newTrigger()
    .withIdentity("trigger1", "group1")
    .startAt(startTime)
    .withSchedule(simpleSchedule()
            .withIntervalInSeconds(3)
            .repeatForever())
    .build();

Date ft = sched.scheduleJob(job, trigger);

作业#2计划无限期地每3秒运行1次。此作业将触发BadJob2。

job = newJob(BadJob2.class)
    .withIdentity("badJob2", "group1")
    .build();

trigger = newTrigger()
    .withIdentity("trigger2", "group1")
    .startAt(startTime)
    .withSchedule(simpleSchedule()
            .withIntervalInSeconds(3)
            .repeatForever())
    .build();

ft = sched.scheduleJob(job, trigger);

然后启动调度器。

sched.start();

为了让程序有机会运行作业，我们会休眠1分钟（60秒）

Thread.sleep(60L * 1000L);

此调度器将同时运行2个作业（BadJob1和BadJob2）。这2个作业都将抛出异常。作业1应尝试立即重新执行。作业2不应再次运行。

最后，我们将优雅地关闭调度器：

sched.shutdown(true);

注意：在关闭消息中传递true会告诉Quartz调度器等待所有作业完成运行后再从方法调用返回。

BadJob1.java源码

package org.quartz.examples.example6;

import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobKey;
import org.quartz.PersistJobDataAfterExecution;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Date;

/**
 * 将引发作业执行异常的缺陷作业
 * 作者：Bill Kratzer
 */
@PersistJobDataAfterExecution
@DisallowConcurrentExecution
public class BadJob1 implements Job {

  //日志
  private static Logger _log = LoggerFactory.getLogger(BadJob1.class);
  private int calculation;

  /**
   * 用于作业初始化的空参构造函数
   */
  public BadJob1() {
  }

  /**
   * 当与此作业相关联的触发器触发时，由调度器调用此方法
   * Throws：作业执行异常（JobExecutionException）-当执行作业时产生异常
   */
  public void execute(JobExecutionContext context) throws JobExecutionException {
    JobKey jobKey = context.getJobDetail().getKey();
    JobDataMap dataMap = context.getJobDetail().getJobDataMap();

    int denominator = dataMap.getInt("denominator");
    _log.info("---" + jobKey + " executing at " + new Date() + " with denominator " + denominator);

    //一个为了产生异常设计的例子，此异常由该作业因零除错误产生（仅在第一次运行时）
    try {
      calculation = 4815 / denominator;
    } catch (Exception e) {
      _log.info("--- Error in job!");
      JobExecutionException e2 = new JobExecutionException(e);

      //修正分母，以便下次执行该作业时不会再次失败
      dataMap.put("denominator", "1");

      //该作业将立即重新开始
      e2.setRefireImmediately(true);
      throw e2;
    }

    _log.info("---" + jobKey + " completed at " + new Date());
  }

}

BadJob2.java源码

package org.quartz.examples.example6;

import java.util.Date;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobKey;
import org.quartz.PersistJobDataAfterExecution;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 将引发作业执行异常的缺陷作业
 * 作者：Bill Kratzer
 */
@PersistJobDataAfterExecution
@DisallowConcurrentExecution
public class BadJob2 implements Job {

    //日志
    private static Logger _log = LoggerFactory.getLogger(BadJob2.class);
    private int calculation;

    /**
     * 用于作业初始化的空参构造函数
     */
    public BadJob2() {
    }

    /**
     * 当与此作业相关联的触发器触发时，由调度器调用此方法
     * Throws：作业执行异常（JobExecutionException）-当执行作业时产生异常
     */
    public void execute(JobExecutionContext context)
        throws JobExecutionException {
        JobKey jobKey = context.getJobDetail().getKey();
        _log.info("---" + jobKey + " executing at " + new Date());

        //一个为了产生异常设计的例子，此异常由此作业因零除错误产生
        try {
            int zero = 0;
            calculation = 4815 / zero;
        } catch (Exception e) {
            _log.info("--- Error in job!");
            JobExecutionException e2 = new JobExecutionException(e);
            //Quartz将自动取消计划与此作业关联的所有触发器，使其不再运行
            e2.setUnscheduleAllTriggers(true);
            throw e2;
        }

        _log.info("---" + jobKey + " completed at " + new Date());
    }

}

JobExceptionExample.java源码

package org.quartz.examples.example6;

import static org.quartz.DateBuilder.nextGivenSecondDate;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
import static org.quartz.TriggerBuilder.newTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.SchedulerMetaData;
import org.quartz.SimpleTrigger;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Date;

/**
 * 此作业演示Quartz如何处理作业引发的作业执行异常（JobExecutionExceptions）
 * 作者：Bill Kratzer
 */
public class JobExceptionExample {

  public void run() throws Exception {
    Logger log = LoggerFactory.getLogger(JobExceptionExample.class);

    log.info("------- Initializing ----------------------");

    //首先，我们必须获得对调度器的引用
    SchedulerFactory sf = new StdSchedulerFactory();
    Scheduler sched = sf.getScheduler();

    log.info("------- Initialization Complete ------------");

    log.info("------- Scheduling Jobs -------------------");

    //可以在sched.start()方法调用前安排作业

    //在未来15秒后获得1次不错的轮转时间（开始执行所有作业）
    Date startTime = nextGivenSecondDate(null, 15);

    //badJob1将每10秒运行1次，此作业将引发异常并立即重新启动
    JobDetail job = newJob(BadJob1.class).withIdentity("badJob1", "group1").usingJobData("denominator", "0").build();

    SimpleTrigger trigger = newTrigger().withIdentity("trigger1", "group1").startAt(startTime)
        .withSchedule(simpleSchedule().withIntervalInSeconds(10).repeatForever()).build();

    Date ft = sched.scheduleJob(job, trigger);
    log.info(job.getKey() + " will run at: " + ft + " and repeat: " + trigger.getRepeatCount() + " times, every "
             + trigger.getRepeatInterval() / 1000 + " seconds");

    //badJob2将每5秒运行1次，此作业将引发异常，并且永远不会重新启动
    job = newJob(BadJob2.class).withIdentity("badJob2", "group1").build();

    trigger = newTrigger().withIdentity("trigger2", "group1").startAt(startTime)
        .withSchedule(simpleSchedule().withIntervalInSeconds(5).repeatForever()).build();

    ft = sched.scheduleJob(job, trigger);
    log.info(job.getKey() + " will run at: " + ft + " and repeat: " + trigger.getRepeatCount() + " times, every "
             + trigger.getRepeatInterval() / 1000 + " seconds");

    log.info("------- Starting Scheduler ----------------");

    //在调度器启动之前，所有作业都不会执行
    sched.start();

    log.info("------- Started Scheduler -----------------");

    try {
      //睡眠30秒
      Thread.sleep(30L * 1000L);
    } catch (Exception e) {
      //
    }

    log.info("------- Shutting Down ---------------------");

    sched.shutdown(false);

    log.info("------- Shutdown Complete -----------------");

    SchedulerMetaData metaData = sched.getMetaData();
    log.info("Executed " + metaData.getNumberOfJobsExecuted() + " jobs.");
  }

  public static void main(String[] args) throws Exception {

    JobExceptionExample example = new JobExceptionExample();
    example.run();
  }

}

控制台输出

[main] INFO org.quartz.examples.example6.JobExceptionExample - ------- Initializing ----------------------
[main] INFO org.quartz.impl.StdSchedulerFactory - Using default implementation for ThreadExecutor
[main] INFO org.quartz.simpl.SimpleThreadPool - Job execution threads will use class loader of thread: main
[main] INFO org.quartz.core.SchedulerSignalerImpl - Initialized Scheduler Signaller of type: class org.quartz.core.SchedulerSignalerImpl
[main] INFO org.quartz.core.QuartzScheduler - Quartz Scheduler v.2.3.0 created.
[main] INFO org.quartz.simpl.RAMJobStore - RAMJobStore initialized.
[main] INFO org.quartz.core.QuartzScheduler - Scheduler meta-data: Quartz Scheduler (v2.3.0) 'DefaultQuartzScheduler' with instanceId 'NON_CLUSTERED'
  Scheduler class: 'org.quartz.core.QuartzScheduler' - running locally.
  NOT STARTED.
  Currently in standby mode.
  Number of jobs executed: 0
  Using thread pool 'org.quartz.simpl.SimpleThreadPool' - with 10 threads.
  Using job-store 'org.quartz.simpl.RAMJobStore' - which does not support persistence. and is not clustered.

[main] INFO org.quartz.impl.StdSchedulerFactory - Quartz scheduler 'DefaultQuartzScheduler' initialized from default resource file in Quartz package: 'quartz.properties'
[main] INFO org.quartz.impl.StdSchedulerFactory - Quartz scheduler version: 2.3.0
[main] INFO org.quartz.examples.example6.JobExceptionExample - ------- Initialization Complete ------------
[main] INFO org.quartz.examples.example6.JobExceptionExample - ------- Scheduling Jobs -------------------
[main] INFO org.quartz.examples.example6.JobExceptionExample - group1.badJob1 will run at: Wed Nov 30 23:54:15 CST 2022 and repeat: -1 times, every 10 seconds
[main] INFO org.quartz.examples.example6.JobExceptionExample - group1.badJob2 will run at: Wed Nov 30 23:54:15 CST 2022 and repeat: -1 times, every 5 seconds
[main] INFO org.quartz.examples.example6.JobExceptionExample - ------- Starting Scheduler ----------------
[main] INFO org.quartz.core.QuartzScheduler - Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED started.
[main] INFO org.quartz.examples.example6.JobExceptionExample - ------- Started Scheduler -----------------
[DefaultQuartzScheduler_Worker-1] INFO org.quartz.examples.example6.BadJob1 - ---group1.badJob1 executing at Wed Nov 30 23:54:15 CST 2022 with denominator 0
[DefaultQuartzScheduler_Worker-1] INFO org.quartz.examples.example6.BadJob1 - --- Error in job!
[DefaultQuartzScheduler_Worker-1] INFO org.quartz.core.JobRunShell - Job group1.badJob1 threw a JobExecutionException: 
org.quartz.JobExecutionException: java.lang.ArithmeticException: / by zero [See nested exception: java.lang.ArithmeticException: / by zero]
	at org.quartz.examples.example6.BadJob1.execute(BadJob1.java:75)
	at org.quartz.core.JobRunShell.run(JobRunShell.java:202)
	at org.quartz.simpl.SimpleThreadPool$WorkerThread.run(SimpleThreadPool.java:573)
Caused by: java.lang.ArithmeticException: / by zero
	at org.quartz.examples.example6.BadJob1.execute(BadJob1.java:72)
	... 2 more
[DefaultQuartzScheduler_Worker-2] INFO org.quartz.examples.example6.BadJob2 - ---group1.badJob2 executing at Wed Nov 30 23:54:15 CST 2022
[DefaultQuartzScheduler_Worker-2] INFO org.quartz.examples.example6.BadJob2 - --- Error in job!
[DefaultQuartzScheduler_Worker-2] INFO org.quartz.core.JobRunShell - Job group1.badJob2 threw a JobExecutionException: 
org.quartz.JobExecutionException: java.lang.ArithmeticException: / by zero [See nested exception: java.lang.ArithmeticException: / by zero]
	at org.quartz.examples.example6.BadJob2.execute(BadJob2.java:74)
	at org.quartz.core.JobRunShell.run(JobRunShell.java:202)
	at org.quartz.simpl.SimpleThreadPool$WorkerThread.run(SimpleThreadPool.java:573)
Caused by: java.lang.ArithmeticException: / by zero
	at org.quartz.examples.example6.BadJob2.execute(BadJob2.java:71)
	... 2 more
[DefaultQuartzScheduler_Worker-1] INFO org.quartz.examples.example6.BadJob1 - ---group1.badJob1 executing at Wed Nov 30 23:54:15 CST 2022 with denominator 1
[DefaultQuartzScheduler_Worker-1] INFO org.quartz.examples.example6.BadJob1 - ---group1.badJob1 completed at Wed Nov 30 23:54:15 CST 2022
[DefaultQuartzScheduler_Worker-3] INFO org.quartz.examples.example6.BadJob1 - ---group1.badJob1 executing at Wed Nov 30 23:54:25 CST 2022 with denominator 1
[DefaultQuartzScheduler_Worker-3] INFO org.quartz.examples.example6.BadJob1 - ---group1.badJob1 completed at Wed Nov 30 23:54:25 CST 2022
[DefaultQuartzScheduler_Worker-4] INFO org.quartz.examples.example6.BadJob1 - ---group1.badJob1 executing at Wed Nov 30 23:54:35 CST 2022 with denominator 1
[DefaultQuartzScheduler_Worker-4] INFO org.quartz.examples.example6.BadJob1 - ---group1.badJob1 completed at Wed Nov 30 23:54:35 CST 2022
[main] INFO org.quartz.examples.example6.JobExceptionExample - ------- Shutting Down ---------------------
[main] INFO org.quartz.core.QuartzScheduler - Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED shutting down.
[main] INFO org.quartz.core.QuartzScheduler - Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED paused.
[main] INFO org.quartz.core.QuartzScheduler - Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED shutdown complete.
[main] INFO org.quartz.examples.example6.JobExceptionExample - ------- Shutdown Complete -----------------
[main] INFO org.quartz.examples.example6.JobExceptionExample - Executed 5 jobs.

Process finished with exit code 0