SpringBoot集成Quartz定时任务（持久化到数据库）

前言

现在大多数项目都使用了springboot，所以本文主要讲springboot与quartz的完美整合，简化配置、持久化数据并自定义quartz数据源。

正文

一、增加依赖

我们使用的spring-boot-starter-quartz,所以不用显示指定版本号：

<!--quartz相关依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

二、yml配置信息

quartz:
  job-store-type: jdbc
  jdbc:
    initialize-schema: never
  properties:
    org:
      quartz:
        scheduler:
          #在集群中每个实例都必须有一个唯一的instanceId，但是应该有一个相同的instanceName
          instanceId: AUTO
          instanceName: um-scheduler
          skipUpdateCheck: true #是否跳过Quartz版本更新检查。如果检查并且找到更新，则会在Quartz的日志中报告它。生产部署要禁止
        jobStore:
          acquireTriggersWithinLock: true #获取trigger的时候是否上锁，默认false采用乐观锁，但有可能出现ABA导致重复调度
          #此存储机制用于Quartz独立于应用容器的事务管理，如果是Tomcat容器管理的数据源，那我们定义的事物也不会传播给Quartz框架内部。
          #通俗的讲就是不管我们的Service服务本身业务代码是否执行成功，只要代码中调用了Quartz API的数据库操作，那任务状态就永久持久化了，
          #就算业务代码抛出运行时异常任务状态也不会回滚到之前的状态。与之相反的是JobStoreCMT。
          class: org.quartz.impl.jdbcjobstore.JobStoreTX
          driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate #JDBC代理类
          useProperties: true #让JDBCJobStore将JobDataMaps中的所有值都作为字符串，因此可以作为键值对存储而不是在BLOB列中以其序列化形式存储，从而避免序列化的版本问题
          tablePrefix: QRTZ_ #数据库表前缀
          misfireThreshold: 60_000 #超过这个时间还未触发的trigger，就被认为发生了misfire，默认60s。job成功触发叫fire，misfire就是未成功触发。
          isClustered: true #是否开启群集，集群模式需要在多台服务器上做时间同步或者使用zookeeper去解决
          clusterCheckinInterval: 20_000 #定义了Scheduler实例检入到数据库中的频率(单位：毫秒)。
        threadPool:
          class: org.quartz.simpl.SimpleThreadPool #SimpleThreadPool这个线程池只是简单地在它的池中保持固定数量的线程，不增长也不缩小。但是它非常健壮且经过良好的测试，差不多每个Quartz用户都使用这个池
          threadCount: 10 #最大线程数，意味着最多有多少个job可以同时执行
          threadPriority: 5 #线程优先级
          threadsInheritContextClassLoaderOfInitializingThread: true #线程上下文类加载器是否继承自初始线程的加载器
        startup-delay: 60 #延时启动，要有足够长的时间让你的应用先启动完成后再让Scheduler启动（单位秒）
        overwrite-existing-jobs: true #是否每次系统运行都会清空数据库中的Job信息，重新进行初始化

数据源配置：

spring: 
  # 数据库配置
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    dynamic:
      primary: master #设置默认的数据源或者数据源组,默认值即为master
      datasource:
        master:
          url: xxx
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root
          password: xxx
        quartz:
          url: xxx
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root

自定生成表结构，需要配置如下信息：

spring.quartz.jdbc.initialize-schema: always
spring.quartz.job-store-type: jdbc

项目启动后生成的表信息：

三、定时任务逻辑封装

1.QuartzConfig定时任务配置类。

mport org.quartz.spi.JobFactory;
import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;

import javax.sql.DataSource;
import java.io.IOException;

/**
 * @version v1.0
 * @description:
 * @author: 47 on 2020/4/9 14:32
 */
@Configuration
public class QuartzConfig {


    public void setSchedulerFactoryBeanProperties(SchedulerFactoryBean schedulerFactoryBean, DataSource dataSource, JobFactory jobFactory) throws IOException {
        schedulerFactoryBean.setJobFactory(jobFactory);
        //设置数据源
        schedulerFactoryBean.setDataSource(dataSource);
    }

    /**
     * 自定义JobFactory，以便Job类里可以使用Spring类注入
     */
    @Bean
    public JobFactory jobFactory() {
        return new QuartzSpringBeanJobFactory();
    }


    private class QuartzSpringBeanJobFactory extends SpringBeanJobFactory {

        private AutowireCapableBeanFactory beanFactory;

        @Override
        public void setApplicationContext(ApplicationContext context) {
            beanFactory = context.getAutowireCapableBeanFactory();
        }

        @Override
        protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
            final Object job = super.createJobInstance(bundle);
            beanFactory.autowireBean(job);
            return job;
        }
    }
}

2.定义SchedulerJob计划任务类

/**
 * @version v1.0
 * @description:
 * @author: 47 on 2020/4/9 14:32
 */
public class SchedulerJob {

    private String name;
    private String group;
    private String cron;
    private String jobClass;
    private String desc;
    //间隔时长
    private Long interval;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGroup() {
        return group;
    }

    public void setGroup(String group) {
        this.group = group;
    }

    public String getCron() {
        return cron;
    }

    public void setCron(String cron) {
        this.cron = cron;
    }

    public String getJobClass() {
        return jobClass;
    }

    public void setJobClass(String jobClass) {
        this.jobClass = jobClass;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public Long getInterval() {
        return interval;
    }

    public void setInterval(Long interval) {
        this.interval = interval;
    }
}

3.定义SchedulerJobs （用来主要注入配置文件里多个定时任务）

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * @version v1.0
 * @description:
 * @author: 47 on 2020/4/9 14:26
 */
@Component
@ConfigurationProperties(prefix = "quartz")
public class SchedulerJobs {

    private List<SchedulerJob> jobs;

    public List<SchedulerJob> getJobs() {
        return jobs;
    }

    public void setJobs(List<SchedulerJob> jobs) {
        this.jobs = jobs;
    }
}

4.封装定时任务的方法 SchedulerManager 

import com.gamer.um.quartz.configure.SchedulerJob;
import com.gamer.um.quartz.jobs.MonitorCronJob;
import org.quartz.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * @version v1.0
 * @description:
 * @author: 47 on 2020/4/9 11:37
 */
@Component
public class SchedulerManager {

    private final static Logger logger = LoggerFactory.getLogger(SchedulerManager.class);


    @Autowired
    private Scheduler scheduler;

    /**
     * 激活任务
     * @param schedulerJob
     */
    public void activeJob(SchedulerJob schedulerJob){
        JobKey jobKey = JobKey.jobKey(schedulerJob.getName(), schedulerJob.getGroup());
        try {
            if (scheduler.checkExists(jobKey) && !MonitorCronJob.JOB_NAME.equals(schedulerJob.getName())) {
                updateJob(schedulerJob);
            }else {
                createJob(schedulerJob);
            }
        } catch (SchedulerException e) {
            logger.error("activeJob {}", e);
        }
    }

    /**
     * 创建任务并加入调度
     * @param schedulerJob
     */
    public void createJob(SchedulerJob schedulerJob){
        JobKey jobKey = JobKey.jobKey(schedulerJob.getName(), schedulerJob.getGroup());
        try {
            if (scheduler.checkExists(jobKey)) {
                return;
            }
            Class<?> clazz = Class.forName(schedulerJob.getJobClass());
            JobDetail jobDetail = getJobDetail(schedulerJob, (Class<Job>) clazz);
            Trigger cronTrigger = getCronTrigger(schedulerJob);
            //加入调度器
            scheduler.scheduleJob(jobDetail, cronTrigger);
        } catch (ClassNotFoundException | SchedulerException e) {
            logger.error("createJob {}", e);
        }
    }

    /**
     * 更新任务触发器
     * @param schedulerJob
     */
    public void updateJob(SchedulerJob schedulerJob){
        TriggerKey triggerKey = TriggerKey.triggerKey(schedulerJob.getName(), schedulerJob.getGroup());
        try {
            Trigger trigger = scheduler.getTrigger(triggerKey);
            if (trigger == null) {
                return;
            }
            JobKey jobKey = trigger.getJobKey();
            //查询cron
            String oldCron = ((CronTrigger)trigger).getCronExpression();
            //没有变化则返回
            if (oldCron.equals(schedulerJob.getCron())){
                return;
            }
            Trigger cronTrigger = getCronTrigger(schedulerJob);
            //加入调度器
            scheduler.rescheduleJob(triggerKey, cronTrigger);
        } catch (SchedulerException e) {
            logger.error("updateJob {}", e);
        }
    }

    public void deleteJobs(List<JobKey> jobKeys) {
        try {
            scheduler.deleteJobs(jobKeys);
        } catch (SchedulerException e) {
            logger.error("deleteJobs {}", e);
        }
    }

    /**
     * 创建任务
     * @param schedulerJob
     * @param clazz
     * @return
     */
    private JobDetail getJobDetail(SchedulerJob schedulerJob, Class<Job> clazz) {
        return JobBuilder.newJob()
                .ofType(clazz)
                .withIdentity(schedulerJob.getName(), schedulerJob.getGroup())
                .withDescription(schedulerJob.getDesc())
                .build();
    }

    /**
     * 创建触发器
     * @param schedulerJob
     * @return
     */
    private Trigger getCronTrigger(SchedulerJob schedulerJob) {
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(schedulerJob.getCron());
        if (!MonitorCronJob.JOB_NAME.equals(schedulerJob.getName())){
            //任务错过执行策略，以错过的第一个频率时间立刻开始执行，重做错过的所有频率周期后，当下一次触发频率发生时间大于当前时间后，再按照正常的Cron频率依次执行
            cronScheduleBuilder.withMisfireHandlingInstructionIgnoreMisfires();
        }
        return TriggerBuilder.newTrigger()
                .withIdentity(schedulerJob.getName(), schedulerJob.getGroup())
                .withDescription(schedulerJob.getDesc())
                .withSchedule(cronScheduleBuilder)
                .build();
    }

}

5.监控其他定时任务的总任务MonitorCronJob（用于监控cron的更新）

package com.gamer.um.quartz.jobs;

import com.gamer.um.quartz.SchedulerManager;
import com.gamer.um.quartz.configure.SchedulerJob;
import com.gamer.um.quartz.configure.SchedulerJobs;
import com.gamer.um.quartz.utils.LicUtil;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.context.refresh.ContextRefresher;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * @version v1.0
 * @description:
 * @author: 47 on 2020/4/9 15:07
 */
public class MonitorCronJob implements Job {

    private final static Logger logger = LoggerFactory.getLogger(MonitorCronJob.class);

    public static final String JOB_NAME = "monitor_cron";
    public static final String GROUP_NAME = "monitor";
    public static final String CRON = "0 0/10 * * * ?";
    public static final String DESC = "监控cron更新";

    @Autowired
    private SchedulerManager schedulerManager;
    @Autowired
    private SchedulerJobs schedulerJobs;
    @Autowired
    private ContextRefresher contextRefresher;

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //重新加载配置
        contextRefresher.refresh();
        Set<JobKey> oldJobKeys = null;
        try {
            oldJobKeys = jobExecutionContext.getScheduler().getJobKeys(GroupMatcher.anyJobGroup());
        } catch (SchedulerException e) {
            logger.error("MonitorCronJob {}", e);
        }

        List<String> newJobKeys = new ArrayList<>();
        for (SchedulerJob job : schedulerJobs.getJobs()) {
            //过滤掉monitor_cron任务
            if (job.getName().equals(JOB_NAME)) {
                continue;
            }
            newJobKeys.add(job.getName());
            logger.info("job【{}】,cron【{}】", job.getName(), job.getCron());
            schedulerManager.activeJob(job);
        }
        if (oldJobKeys == null) {
            return;
        }
        //删除没有配置的任务
        List<JobKey> shouldDeleteJobKeys = oldJobKeys.stream()
                .filter(jobKey -> !JOB_NAME.equals(jobKey.getName()) && !newJobKeys.contains(jobKey.getName()))
                .collect(Collectors.toList());
        logger.info("delete jobs {}", shouldDeleteJobKeys);
        schedulerManager.deleteJobs(shouldDeleteJobKeys);
    }
}

6.配置一个定时任务（以后其他都不管，直接在配置文件里新加其他的定时任务即可）

#定时任务
quartz:
  jobs:
    - name: myName #（随便取任务名）
      group: collect
      cron: 0 0/5 * * * ? *
      jobClass: com.gamer.me.quartz.jobs.MyJob #（自己的定时任务的执行类，也就是你写业务代码的类）
      desc: 我的任务

7.设置启动项目就初始化定时任务（主要是上面的监控cron的类需要初始化）

import com.gamer.um.quartz.configure.SchedulerJob;
import com.gamer.um.quartz.jobs.MonitorCronJob;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

/**
 * @version v1.0
 * @description:
 * @author: 47 on 2020/4/9 17:12
 */
@Component
public class Initialization implements ApplicationRunner {

    @Autowired
    private SchedulerManager schedulerManager;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        SchedulerJob schedulerJob = new SchedulerJob();
        schedulerJob.setName(MonitorCronJob.JOB_NAME);
        schedulerJob.setGroup(MonitorCronJob.GROUP_NAME);
        schedulerJob.setCron(MonitorCronJob.CRON);
        schedulerJob.setDesc(MonitorCronJob.DESC);
        schedulerJob.setJobClass(MonitorCronJob.class.getName());
        schedulerManager.activeJob(schedulerJob);
    }
}

8.测试

public class MyJob implements Job {

  @Autowired
  private SchedulerManager schedulerManager;

　测试时需要去过滤下当前Jobs里的job是当前执行的（下面会给出代码）

  .......你的业务代码    
}

@Override
public SchedulerJob getSchedulerJobDetail(Class jobClass) {
　　List<SchedulerJob> jobs = schedulerJobs.getJobs();
　　if (Objects.isNull(jobs)) {
　　　　return null;
　　}
　　SchedulerJob job = jobs.stream()
　　　　.filter(schedulerJob -> Objects.equals(schedulerJob.getJobClass(), jobClass.getName()))
　　　　.findFirst()
　　　　.orElse(null);
　　return job;
}