quartz由浅入深学习：简单的quartz，动态添加修改任务和触发器quartz；扫盲必备

Qrartz学习---基于springboot从入门到实现对于触发器定时任务的动态增删改查；

一、 quartz：

   在学习quartz之前，我们先来认识一下quartz，它到底是个什么东西，我们为什么要学它；

• 看一下官方的解释：

• 再来看一些比较通俗一点的解释：
• 

说的比较通俗一点，quartz就是一个定时器，用来完成复杂一点的定时任务的，它的使用也是非常的简单，下边我们将由浅入深的介绍quartz这个框架；

二、quartz的一些使用属性和概念的介绍：

     要了解一个框架之前，我们首先要知道它里边最基本的一些类的属性是什么：

说的比较通俗一点：

1. job：就是你的定时器需要完成的任务是什么；
2. jobDetail：有的时候，我们的job定义的任务可能会比较的抽象，这个时候jobDetail就发挥作用了，它是你的一个job的实例。job和jobDetail是不分家的。
3. trigger：触发器 ，他的作用是什么时候来触发这个定时任务，比如说每三天执行一次，每周末执行一次等等，触发器一共分两种，分别是简单的触发器和cron触发器；
4. scheduler：调度器，它的作用就是将trigger和job联系起来，因为不管怎么说，触发器还是要作用在job身上才是有用的嘛；

他们之间的关系如下图所示：

简单点的关系：

复杂点的关系：

从上图我们可以看出，触发器可以绑定job（也可以用scheduler绑定），而scheduler和绑定触发器，进而将三者绑定在一起，同时呢，一个job是可以对应多个jobDetail的；

而一个jobDetail也是可以对应多个trigger的；

关于job和jobDetail的关系：

好的，概念扫盲暂时到这里，接下来让我们来看一点简单的实例把！

三、简单的quartz定时任务的使用：

前置pom：

 <!-- quartz -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>

3.1、spring的注解@Bean方式：

    @Bean
    public JobDetailFactoryBean jobDetailFactoryBean() {
        JobDetailFactoryBean factoryBean = new JobDetailFactoryBean();
        // 关联我们自己的job类
        factoryBean.setJobClass(QuartzDemo.class);// 这里他将job对象创建仅仅是反射，没有加入到spring容器里边
        return factoryBean;
    }
    
    @Bean
    public CronTriggerFactoryBean cronTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean) {
        CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean();
        String cronExpress = "0/4 * * * * ? *";
        factoryBean.setCronExpression(cronExpress);
        return factoryBean;
    }

    /*     * 创建scheduler对象*/

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(CronTriggerFactoryBean CronTriggerFactoryBean, MyAdptableFactory myAdptableFactory) {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        // 关联trigger
        schedulerFactoryBean.setTriggers(CronTriggerFactoryBean.getObject());
        // 用自己写的jobFactory覆盖本来的factory实现将job加入到spring容器中
        schedulerFactoryBean.setJobFactory(myAdptableFactory);
        return schedulerFactoryBean;
    }

3.2、为什么要自己重写工厂类覆盖quartz本来的；

其中这里我们在最后创建scheduler的时候，说到了将自己写的jobFactory覆盖quartz本来的jobFactory，这是为什么呢？

其实我们的job的创建过程是在AdaptableJobFactory这个类中完成的，我们来看一下这个类的源码：

public class AdaptableJobFactory implements JobFactory {
    public AdaptableJobFactory() {
    }

    public Job newJob(TriggerFiredBundle bundle, Scheduler scheduler) throws SchedulerException {
        try {
            Object jobObject = this.createJobInstance(bundle);
            return this.adaptJob(jobObject);
        } catch (Throwable var4) {
            throw new SchedulerException("Job instantiation failed", var4);
        }
    }

    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        Class<?> jobClass = bundle.getJobDetail().getJobClass();
        return ReflectionUtils.accessibleConstructor(jobClass, new Class[0]).newInstance();
    }

    protected Job adaptJob(Object jobObject) throws Exception {
        if (jobObject instanceof Job) {
            return (Job)jobObject;
        } else if (jobObject instanceof Runnable) {
            return new DelegatingJob((Runnable)jobObject);
        } else {
            throw new IllegalArgumentException("Unable to execute job class [" + jobObject.getClass().getName() + "]: only [org.quartz.Job] and [java.lang.Runnable] supported.");
        }
    }
}

它的重点就在createJobInstance 这个方法中，通过这个方法我们可以看到，job的创建仅仅就是一个反射的过程，并不是通过spring的动态代理代理出来的，这样的话就会造成很多问题，比如说：事务的失效，不能在job中用@AutoWire注解来注入别的类使用等等；

所以我们要自己重写他的一个实例过程，将他加入到spring容器中去；代码如下：

@Component("MyAdptableFactory")
public class MyAdptableFactory extends AdaptableJobFactory {
    /**
     * 改方法需要将实例话的任务对象否手动的添加到springIOC容器中并且完成对象的注入
     * 因为quartz的本来的创建job只是用反射创建对象加入这种情况是不能呗spirng容器所管理的
     * @param bundle
     * @return
     * @throws Exception
     */
    //AutowireCapableBeanFactory 可以将一个对象添加到spring IOC容器中，并且完成该对象的注入
    @Autowired
    private AutowireCapableBeanFactory autowireCapableBeanFactory;
    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        Object object=super.createJobInstance(bundle);
         //将object添加到spring容器中
        this.autowireCapableBeanFactory.autowireBean(object);
        return object;
    }
}

这样的话，我们就可以在job中用 @Autowired注解来注入别的bean了，但是需要注意即使这样，我们自己实现的job类，还是无法应用事务的，因为这是我们手动将自己创建出来的类；

3.3、原生的写法实现简单定时任务：

在这个里边我们实现了将一个job里边绑定多个触发器；

这里对其中某些方法做一些解释：

其中withIdentity（绑定身份）：作用是对于你创建的触发器或者job进行命名分组，作用是好管理；

usingJobData：作用是给job或者trigger一个属性值，这个属性值你可以在job中进行调用；

withSchedule：作用是给触发器一个触发事件，有两种，分别是简单的和cron的；

getJobDataMap：也是给job或者trigger进行注入属性；

forJob：给触发器绑定一个job；

//创建一个scheduler
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        scheduler.getContext().put("skey", "svalue");

        //创建一个Trigger
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1") //进行触发器的命名分组
                .usingJobData("t1", "第一个触发器")  // 注入属性
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(10)
                        .repeatForever()).build(); // 进行时间间隔的设置
        trigger.getJobDataMap().put("t2", "tv2");


        Trigger trigger1=TriggerBuilder.newTrigger()
                         .withIdentity("trigger2","group2")
                         .forJob("myjob","mygroup")
                         .usingJobData("t3","第二个触发")
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(3)
                        .repeatForever()).build();
        Trigger trigger2=TriggerBuilder.newTrigger()
                .withIdentity("trigger2","group3")
                .forJob("myjob","mygroup")
                .usingJobData("t3","第二次触发修改")
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).repeatForever()).build();


        //创建一个job
        JobDetail job = JobBuilder.newJob(jobDemo1.class)
                .usingJobData("j1", "jv1") // 注入属性
                .withIdentity("myjob", "mygroup").build();//进行job的命名分组
        job.getJobDataMap().put("j2", "jv2");// 注入属性

        //注册trigger并启动scheduler
        scheduler.scheduleJob(job,trigger);
        scheduler.scheduleJob( trigger1);
        scheduler.scheduleJob(trigger2);
        scheduler.start();

3.3.1、上述代码中，jobDetail和trigger都创建好了，呢么job如何创建呢？我们看下边的代码---（只演示原生写法的job）

从代码中可以看出，我们可以把创建jobDetail和trigger时注入的属性一一拿出来，其中呢，getMergedJobDataMap是综合了jobDetail和trigger的属性并集，并且优先选取trigger中的属性；

public class jobDemo1 implements Job {
    public jobDemo1() {
    }

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
//        Object tv1 = context.getTrigger().getJobDataMap().get("t1");
//        Object tv2 = context.getTrigger().getJobDataMap().get("t2");
//        Object jv1 = context.getJobDetail().getJobDataMap().get("j1");
//        Object jv2 = context.getJobDetail().getJobDataMap().get("j2");
//        Object sv = null;
//        try {
//            sv = context.getScheduler().getContext().get("skey");
//        } catch (SchedulerException e) {
//            e.printStackTrace();
//        }
//        System.out.println(tv1+":"+tv2);
//        System.out.println(jv1+":"+jv2);
//        System.out.println(sv);
//        System.out.println("hello:"+ LocalDateTime.now());
        JobKey key = context.getJobDetail().getKey();//获取jobDetail的分组和命名
        TriggerKey key1 = context.getTrigger().getKey();
        JobDataMap dataMap=context.getMergedJobDataMap();
        String j1 = dataMap.getString("j1");
        System.out.println("key = " + key);
        System.out.println("key1 = " + key1);
        System.out.println("dataMap = " + dataMap.get("t3"));
        System.out.println("j1 = " + j1);


    }
    }

恭喜你，如果你看到这里的话，呢么你对quartz的基本操作已经了解的差不多了，接下来的篇幅，就让我们去了解进阶的篇幅把!

四、略微复杂的quartz的使用：动态添加修改定时任务

     设想一个项目场景：

在一个项目中，我需要动态的向项目中添加或者修改定时任务，还有暂停和启动的操作，相当于动态的添加定时任务，如果有这种需求 的话呢？你打算怎么做？

4.1、quartz的固化（本案例不使用，仅作为学习）

 这样的话，我们就需要将定时任务集成到数据库中了，在这方面，quartz给我们做了固化，具体的操作很简单：

在项目的配置文件（application.yml）中加入如下配置；

其中，always，代表每次启动项目都会给数据库添加quartz的表，它里边还有另外两个属性：never、embedded；

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test?serverTimezone=UTC
    username: root
    password: 123456
  quartz:
    job-store-type: jdbc
    jdbc:
      initialize-schema: always

加入之后，我们再启动项目的时候，会看到：日志中会有这么几行字：具体的意思就是，现在的quartz是以本地持久化的形式来的，不是在内存中的，并且没有集群；

现在的话，你的数据库中，就会多了几张表：分别存储着不同的信息；

4.2、自己创建表进行jobDetail和trigger的动态添加修改：

先给大家贴出一个实体 SettleTaskPlan ，后续说明作用：

public class SettleTaskPlan extends EntityBase implements Serializable {    
private static final long serialVersionUID = 1L;
	@TableId(value="SETTLE_TASK_ID", type = IdType.INPUT)
	@ExcelProperty(value = "序号",index = 0)
	private java.lang.Long settleTaskId;
	@TableField("APP_CODE")
	@ExcelProperty(value = "应用编码",index = 19)
	private java.lang.String appCode;
	@TableField("CHECK_REMARK")
	@ExcelProperty(value = "审核意见",index = 13)
	private java.lang.String checkRemark;
	@TableField("CHECK_STATE")
	@ExcelProperty(value = "审核状态",index = 14)
	private java.lang.String checkState;

	@TableField("CHECK_TIME")
	@ExcelProperty(value = "审核时间",index = 15)
	@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
	private java.util.Date checkTime;
	@TableField("CHECK_USER_ID")
	@ExcelProperty(value = "审核人id",index = 12)
	private java.lang.Long checkUserId;
	@TableField("CRON_EXPRESS")
	@ExcelProperty(value = "执行表达式",index = 3)
	private java.lang.String cronExpress;
	@TableField("DEL_FLAG")
	@ExcelProperty(value = "删除标记",index = 16)
	private java.lang.String delFlag;
	@TableField("DISABLE_FLAG")
	@ExcelProperty(value = "禁用标记",index = 17)
	private java.lang.String disableFlag;
	@TableField("EXEC_TIMES")
	@ExcelProperty(value = "执行次数",index = 9)
	private java.lang.Long execTimes;
	@TableField("EXECUTE_FUN")
	private java.lang.String executeFun;
	@TableField("EXECUTE_JSON_PARAM")
	private java.lang.String executeJsonParam;
	@TableField("FAILED_TIMES")
	@ExcelProperty(value = "失败次数",index = 10)
	private java.lang.Long failedTimes;
	@TableField("LAST_EXECUTED")
	@ExcelProperty(value = "最后一次执行时间",index = 7)
	@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
	private java.util.Date lastExecuted;
	@TableField("LAST_STATE")
	@ExcelProperty(value = "最后一次执行状态",index = 8)
	private java.lang.String lastState;
	@TableField("REMARK")
	@ExcelProperty(value = "备注",index = 18)
	private java.lang.String remark;
	@TableField("START_EXECUTED")
	@ExcelProperty(value = "开始时间",index = 4)
	@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
	private java.util.Date startExecuted;
	@TableField("SUCCESS_TIMES")
	@ExcelProperty(value = "成功次数",index = 11)
	private java.lang.Long successTimes;
	@TableField("TASK_CODE")
	@ExcelProperty(value = "计划编码",index = 1)
	private java.lang.String taskCode;
	@TableField("TASK_NAME")
	@ExcelProperty(value = "计划名称",index = 2)
	private java.lang.String taskName;
	@TableField("TASK_TYPE")
	@ExcelProperty(value = "计划类型",index = 5)
	private java.lang.String taskType;
	@TableField("TRIGGER_FUN")
	@ExcelProperty(value = "模块代码",index = 6)
	private java.lang.String triggerFun;

	@TableField("SETTLE_OBJECT")
	private String settleObject;

 

 

前边已经介绍了简单的quartz的应用，相信大家肯定都可以自己手动创建一个定时任务并且跑起来了；

但是想要完成动态的添加修改，呢么应该怎么做呢？

我们可以想一下我们的需求，动态的添加修改；我们再看看前边文章的内容，前边的文章，我们介绍了如何在springboot里边添加一个定时任务，呢么是不是我们只需要再知道如何去修改和删除定时任务，呢么我们的需求就完成了呢？

下边介绍一下如何对程序中的定时任务进行修改和删除：

定时任务的修改：

 /**
     * 根据核算计划修改定时任务
     *
     * @param settleTaskPlan
     * @return
     * @throws SchedulerException
     */
    public boolean updateQuartzPlan(SettleTaskPlan settleTaskPlan) throws SchedulerException {
        TriggerKey triggerKey = TriggerKey.triggerKey(settleTaskPlan.getSettleTaskId().toString());
        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        Trigger trigger1 = trigger.getTriggerBuilder()
                .withIdentity(triggerKey)
                .withSchedule(CronScheduleBuilder.cronSchedule(settleTaskPlan.getCronExpress()))
                .build();
        scheduler.rescheduleJob(triggerKey, trigger1);
        return true;
    }

定时任务的添加：

  /**
     * 根据核算计划新增一个定时任务详情到quartz中
     *
     * @param settleTaskPlan
     * @return
     * @throws SchedulerException
     */
    public boolean addQuartzPlan(SettleTaskPlan settleTaskPlan) throws SchedulerException {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        schedulerFactoryBean.setJobFactory(new MyAdptableFactory());
        //创建一个jobDetail
        JobDetail jobDetail = JobBuilder.newJob(QuartzDemo.class)
                .withIdentity(settleTaskPlan.getSettleTaskId().toString())
                .build();

        //创建对应的触发器
        Trigger trigger = TriggerBuilder.newTrigger()
                .startNow()
                .withIdentity(settleTaskPlan.getSettleTaskId().toString())
                .usingJobData("settleTaskId", settleTaskPlan.getSettleTaskId().toString())
                .withSchedule(CronScheduleBuilder.cronSchedule(settleTaskPlan.getCronExpress()))
                .build();
        //将触发器和jobDetail联合起来
        scheduler.scheduleJob(jobDetail, trigger);
        return true;
    }

定时任务的删除：

 /**
     * 按照核算计划主键将定时计划从quartz中剔除掉
     *
     * @param settleTaskPlans
     * @return
     */
    public boolean deleteQuartzPlan(List<SettleTaskPlan> settleTaskPlans) throws SchedulerException {
        for (SettleTaskPlan settleTaskPlan : settleTaskPlans) {
            //将对应的jobdetail删除掉
            JobKey jobKey = JobKey.jobKey(settleTaskPlan.getSettleTaskId().toString());
            scheduler.deleteJob(jobKey);
        }
        return true;
    }

 

同时我们应该再去思考一个问题，我们如何将这些定时任务存储起来呢？总不能我添加完在下次启动的时候就没有了吧？这是不合理的。

所以我们要在数据库建立一张表SettleTaskPlan ，将定时任务存储起来，定时任务的分组命名信息就是表的主键，这样我们就可以根据表的主键创建修改删除对应的定时任务了；

表中最主要的信息就是两个：标识符（主键），cron表达式，其余的可以根据自己的需要自行添加；

建立好表之后，我们只需要在系统的每次启动前，循环访问数据库添加对应的定时任务就可以了：

public class QuartzConfig {
    //TODO:两种思路，一种是给每一个事件都创建一个jobDetail和一个触发器，另一种是给一个jobDetail创建多个触发器
    @Autowired
    SettleTaskPlanService settleTaskPlanService;

    @Autowired
    public Scheduler scheduler;
    //在每次启动项目的时候，去循环数据库中的定时任务然后启动这些定时任务
    @PostConstruct
    public void initJob()throws Exception{
        //从数据库中查询所有的定时任务并且一个一个启动
        QueryWrapper<SettleTaskPlan> queryWrapper=new QueryWrapper();
        queryWrapper.eq("DEL_FLAG","0");
        queryWrapper.eq("DISABLE_FLAG","0");
        queryWrapper.eq("CHECK_STATE","1");
        List<SettleTaskPlan> list = settleTaskPlanService.list(queryWrapper);
        //用自己写的jobFactory覆盖本来的factory实现将job加入到spring容器中
            SchedulerFactoryBean schedulerFactoryBean=new SchedulerFactoryBean();
            schedulerFactoryBean.setJobFactory(new MyAdptableFactory());
            for (SettleTaskPlan taskPlan : list) {
                //创建一个jobDetail
                JobDetail jobDetail= JobBuilder.newJob(QuartzDemo.class)
                        .withIdentity(taskPlan.getSettleTaskId().toString())
                        .build();

                //创建对应的触发器
                Trigger trigger=TriggerBuilder.newTrigger()
                        .startNow()
                        .withIdentity(taskPlan.getSettleTaskId().toString())
                        .usingJobData("settleTaskId",taskPlan.getSettleTaskId().toString())
                        .withSchedule(CronScheduleBuilder.cronSchedule(taskPlan.getCronExpress()))
                        .build();
                //将触发器和jobDetail联合起来
                scheduler.scheduleJob(jobDetail, trigger);
                scheduler.start();
            }
    }
}

以上就是quartz的动态添加修改；