Spring Boot中Quartz JobScheduler遇异常删除触发器问题解决

针对你遇到的Quartz任务带@Transactional无法捕获异常，最终导致QRTZ_TRIGGERS表数据被删、调度器故障的问题，可从以下几个方向解决：

1. 隔离Quartz与业务的事务边界 #

这是核心问题之一：如果Quartz和业务共用同一个数据源，且任务方法的@Transactional传播级别为默认的REQUIRED，Quartz更新触发器状态的操作会被纳入任务的事务中。当任务抛出异常触发事务回滚时，Quartz对触发器的更新/插入操作也会被回滚，甚至触发删除逻辑。

解决方法：

• 为Quartz单独配置独立数据源，确保其JobStore操作在自身事务中执行，不受业务事务影响。
  在Spring Boot中可通过配置两个DataSource实现：

  // 业务数据源配置
  @Configuration
  @Primary
  public class BusinessDataSourceConfig {
      @Bean(name = "businessDataSource")
      @ConfigurationProperties(prefix = "spring.datasource.business")
      public DataSource businessDataSource() {
          return DataSourceBuilder.create().build();
      }
  
      @Bean(name = "businessTransactionManager")
      public PlatformTransactionManager businessTransactionManager(@Qualifier("businessDataSource") DataSource dataSource) {
          return new DataSourceTransactionManager(dataSource);
      }
  }
  
  // Quartz数据源配置
  @Configuration
  public class QuartzDataSourceConfig {
      @Bean(name = "quartzDataSource")
      @ConfigurationProperties(prefix = "spring.datasource.quartz")
      public DataSource quartzDataSource() {
          return DataSourceBuilder.create().build();
      }
  
      @Bean
      public SchedulerFactoryBean schedulerFactoryBean(@Qualifier("quartzDataSource") DataSource quartzDataSource) {
          SchedulerFactoryBean factory = new SchedulerFactoryBean();
          factory.setDataSource(quartzDataSource);
          // 其他Quartz配置...
          return factory;
      }
  }
  

2. 调整@Transactional的使用方式 #

不要将@Transactional直接标注在Quartz任务的execute方法上，避免事务范围覆盖Quartz的调度逻辑：

• 将事务逻辑封装到单独的业务方法中，任务方法在外层调用并捕获异常：

  public class MyQuartzJob implements Job {
      @Autowired
      private BusinessService businessService;
  
      @Override
      public void execute(JobExecutionContext context) throws JobExecutionException {
          try {
              businessService.doTransactionalBusiness(); // 该方法带@Transactional
          } catch (Exception e) {
              // 处理异常，比如记录日志、标记任务失败
              log.error("任务执行失败", e);
              // 可选：手动触发重试，而非让Quartz删除触发器
              // JobExecutionException e = new JobExecutionException(e);
              // e.setRefireImmediately(true);
              // throw e;
          }
      }
  }
  

• 若必须在任务方法中使用事务，改用TransactionTemplate手动控制事务，确保异常可被捕获：

  public class MyQuartzJob implements Job {
      @Autowired
      private TransactionTemplate transactionTemplate;
  
      @Override
      public void execute(JobExecutionContext context) throws JobExecutionException {
          try {
              transactionTemplate.execute(status -> {
                  // 事务内的业务逻辑
                  doBusiness();
                  return null;
              });
          } catch (Exception e) {
              log.error("任务执行异常", e);
          }
      }
  }
  

3. 配置Quartz的触发器异常处理策略 #

Quartz默认在任务多次失败或失火时，可能会删除触发器，需调整触发器的失火处理规则：

• 创建触发器时，指定合适的失火处理指令，避免触发器被删除：

  // 对于CronTrigger
  CronTrigger trigger = TriggerBuilder.newTrigger()
          .withIdentity("myTrigger", "myGroup")
          .withSchedule(CronScheduleBuilder.cronSchedule("0 0/5 * * * ?")
                  // 失火时不删除触发器，而是忽略失火继续执行
                  .withMisfireHandlingInstructionDoNothing())
          .build();
  
  // 对于SimpleTrigger
  SimpleTrigger trigger = TriggerBuilder.newTrigger()
          .withIdentity("myTrigger", "myGroup")
          .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                  .withIntervalInMinutes(5)
                  .repeatForever()
                  // 失火时立即执行一次，之后按原计划继续
                  .withMisfireHandlingInstructionFireNow())
          .build();
  

• 在quartz.properties中调整全局配置：

  # 设置失火阈值，避免短时间内的任务延迟被判定为失火
  org.quartz.jobStore.misfireThreshold=60000
  

4. 全局捕获Quartz任务异常 #

实现Quartz的JobListener，统一捕获任务执行异常，阻止异常扩散导致触发器被删除：

@Component
public class GlobalJobListener implements JobListener {
    private static final Logger log = LoggerFactory.getLogger(GlobalJobListener.class);

    @Override
    public String getName() {
        return "GlobalJobListener";
    }

    @Override
    public void jobToBeExecuted(JobExecutionContext context) {
        // 任务执行前的处理
    }

    @Override
    public void jobExecutionVetoed(JobExecutionContext context) {
        // 任务被否决的处理
    }

    @Override
    public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {
        if (jobException != null) {
            log.error("任务{}执行失败", context.getJobDetail().getKey(), jobException);
            // 可选：重置触发器状态，避免被删除
            try {
                Trigger trigger = context.getTrigger();
                context.getScheduler().rescheduleJob(trigger.getKey(), trigger);
            } catch (SchedulerException e) {
                log.error("重置触发器失败", e);
            }
        }
    }
}

然后将监听器注册到Scheduler：

@Configuration
public class QuartzConfig {
    @Autowired
    private GlobalJobListener globalJobListener;

    @Bean
    public Scheduler scheduler(SchedulerFactoryBean schedulerFactoryBean) throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        scheduler.getListenerManager().addJobListener(globalJobListener);
        return scheduler;
    }
}

5. 检查Quartz版本与集群配置 #

• 确保使用的Quartz版本无已知的触发器误删bug，建议使用稳定版本（如2.3.x或更高）。
• 若开启集群模式，需确保org.quartz.jobStore.isClustered=true，且所有节点的org.quartz.scheduler.instanceId配置正确（建议使用AUTO），避免集群节点间的触发器状态冲突导致误删。

内容的提问来源于stack exchange，提问作者Mehdi Varse