Quartz 作业调度

最新推荐文章于 2023-12-23 10:32:07 发布

coolxiaoqi

最新推荐文章于 2023-12-23 10:32:07 发布

阅读量364

点赞数 2

文章标签： spring boot Powered by 金山文档

本文链接：https://blog.csdn.net/coolxiaoqi/article/details/129150126

版权

Quartz（ [kwɔːrts]）是一个开源的作业调度框架，它完全由 Java 写成，并设计用于 J2SE 和 J2EE 应用中。它提供了巨大的灵活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。Quartz是 OpenSymphony 开源组织在Job scheduling（工作调度/工作安排）领域又一个开源项目，Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。

Quartz的最新版本为Quartz 2.3.2。

一、Quartz 核心组件

调度器：Scheduler

代表一个 quartz 的独立运行容器。Trigger 和 JobDetail 可以注册到 Scheduler 中。Scheduler 可以将 Trigger 绑定到某一 JobDetail 上，这样当 Trigger 被触发时，对应的 Job 就会执行。一个 Job 可以对应多个 Trigger，但一个 Trigger 只能对应一个 Job 。

任务：Job

是一个接口，有一个方法 void execute()，可以通过实现该接口来定义需要执行的任务。

触发器：Trigger，包括 SimpleTrigger 和 CronTrigger

描述触发 Job 执行的时间触发规则，实现类 SimpleTrigger 和 CronTrigger 可以通过crom 表达式定义出各种复杂的调度方案。

二、CronTrigger 表达式规则

格式：[秒] [分] [小时] [日] [月] [周] [年]

序号	说明	是否必填	允许填写的值	允许的通配符
1	秒	是	0-59	, - * /
2	分	是	0-59	, - * /
3	小时	是	0-23	, - * /
4	日	是	1-31	, - * ? / L W
5	月	是	1-12	, - * /
6	周	是	1-7	, - * ? / L #
7	年	是	empty 或 1970-2099	, - * /

可以通过在线生成cron表达式的工具：https://cron.qqe2.com/ 来生成自己想要的表达式。

常用cron表达式例子：

三、案例

3.1、第一个整合例子（SpringBoot 整合 Quartz）

3.1.1、添加依赖

<dependency>
  <groupId>org.quartz-scheduler</groupId>
  <artifactId>quartz</artifactId>
  <version>2.3.2</version>
</dependency>

3.1.2、实现Job接口

在execute方法中实现业务逻辑：

public class TestJob implements Job {

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("===========成功运行定时任务===========");
        System.out.println(jobExecutionContext.getJobDetail().getKey());
    }
}

3.1.3、创建启动加载类

创建 JobDetail 实例、Trigger 触发器注册到 scheduler, 并开启调度：

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

@Component
public class TestRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        //创建scheduler调度器
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();

        //创建TestJob的JobDetail实例，并设置name
        JobDetail jobDetail = JobBuilder.newJob(TestJob.class)
                .withIdentity("testDetail111111111")
                .build();

        //cron表达式，每2秒执行一次
        String cron = "0/2 * * * * ? ";

        //创建Trigger触发器,使用cronSchedule方式调度
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("testTrigger")
                .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                .build();

        //注册JobDetail实例到scheduler,并使用对应的trigger触发
        scheduler.scheduleJob(jobDetail, trigger);
        //启动scheduler
        scheduler.start();
    }
}

3.2、第二个整合例子（SpringBoot 整合 Quartz—使用Starter）

3.2.1、添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

3.2.2、使用 Job 和 Trigger

3.2.2.1、新建一个 Job 类 WelcomeJob（实现 Job）

public class WelcomeJob implements Job {
    @Override
    public void execute(JobExecutionContext arg0) throws JobExecutionException {
       System.out.println("这是一个quartz 任务");
    }
}

3.2.2.2、在启动类中调用 WelcomeJob

@SpringBootApplication
public class SpringbootquartzApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootquartzApplication.class, args);
        try {
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
            //启动
            scheduler.start();
            //新建一个 Job WelcomeJob
            JobDetail job = JobBuilder.newJob(WelcomeJob.class)
                    .withIdentity("mySimpleJob", "simpleGroup")
                    .build();
            // 触发器 定义多长时间触发 JobDetail
            Trigger trigger = org.quartz.TriggerBuilder.newTrigger()
                    .withIdentity("simpleTrigger", "simpleGroup")
                    .startNow()
                    .withSchedule(simpleSchedule()
                            .withIntervalInSeconds(5)
                            .repeatForever())
                    .build();
            scheduler.scheduleJob(job,trigger);
            //关闭
            //scheduler.shutdown();

        } catch (SchedulerException se) {
            se.printStackTrace();
        }
    }
}

四、深入

SpringBoot集成Quartz实现定时任务的动态创建、启动、暂停、恢复、删除。

从0开始搭建一个例子，包括定时任务的各种操作，以及API的一些用法，可以实现大多场景的需求，主要包括的内容：

普通定时任务的创建、启动、停止。

动态创建定时任务，如创建一个订单，5分钟后执行某某操作。

4.1、整个 Quartz 的代码流程基本基本如下：

首先需要创建我们的任务(Job)，比如取消订单、定时发送短信邮件之类的，这是我们的任务主体，也是写业务逻辑的地方。

创建任务调度器(Scheduler)，这是用来调度任务的,主要用于启动、停止、暂停、恢复等操作，也就是那几个api的用法。

创建任务明细(JobDetail)，最开始我们编写好任务(Job)后，只是写好业务代码，并没有触发，这里需要用JobDetail来和之前创建的任务(Job)关联起来，便于执行。

创建触发器(Trigger)，触发器是来定义任务的规则的，比如几点执行，几点结束，几分钟执行一次等等。这里触发器主要有两大类(SimpleTrigger和CronTrigger)。

根据Scheduler来启动JobDetail与Trigger

4.2、引入依赖

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-quartz</artifactId>
  </dependency>

4.3、创建 Job

需实现Job接口，这个接口就一个execute()方法需要重写，方法内容就是具体的业务逻辑。如果是动态任务呢，比如取消订单，每次执行都是不同的订单号。这个时候就需要在创建任务(JobDetail)或者创建触发器(Trigger)的那里传入参数，然后在这里通过JobExecutionContext来获取参数进行处理，

import com.dy.utils.DateUtil;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import java.util.Date;
 
/**
 * @description: 测试定时任务
 */
@DisallowConcurrentExecution//Job中的任务有可能并发执行，例如任务的执行时间过长，而每次触发的时间间隔太短，则会导致任务会被并发执行。如果是并发执行，就需要一个数据库锁去避免一个数据被多次处理。
public class TestJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.err.println(jobExecutionContext.getJobDetail().getJobDataMap().get("name"));
        System.err.println(jobExecutionContext.getJobDetail().getJobDataMap().get("age"));
        System.err.println(jobExecutionContext.getTrigger().getJobDataMap().get("orderNo"));
        System.err.println("定时任务执行，当前时间："+ DateUtil.formatDateTime(new Date()));
    }
}

4.4、创建任务调度器(Scheduler)

可以采用Spring IOC，所以直接注入完事。如果是普通的，则需通过工厂创建。

工厂：

SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();

IOC：

@Autowired
private Scheduler scheduler;

4.5、创建任务明细（JobDetail）

/**通过JobBuilder.newJob()方法获取到当前Job的具体实现(以下均为链式调用)
 * 这里是固定Job创建，所以代码写死XXX.class
 * 如果是动态的，根据不同的类来创建Job，则 ((Job)Class.forName("com.chenxin.job.TestJob").newInstance()).getClass()
 * 即是 JobBuilder.newJob(((Job)Class.forName("com.chenxin.job.TestJob").newInstance()).getClass())
 * */
JobDetail jobDetail = JobBuilder.newJob(TestJob.class)
        /**给当前JobDetail添加参数，K V形式*/
        .usingJobData("name","zy")
        /**给当前JobDetail添加参数，K V形式，链式调用，可以传入多个参数，在Job实现类中，可以通过jobExecutionContext.getJobDetail().getJobDataMap().get("age")获取值*/
        .usingJobData("age",23)
        /**添加认证信息，有3种重写的方法，这里是其中一种，可以查看源码看其余2种*/
        .withIdentity("我是name","我是group")
        .build();//执行

4.6、创建触发器

这里主要分为两大类SimpleTrigger、CronTrigger。SimpleTrigger：是根据它自带的api方法设置规则，比如每隔5秒执行一次、每隔1小时执行一次。

Trigger trigger = TriggerBuilder.newTrigger()
        /**给当前JobDetail添加参数，K V形式，链式调用，可以传入多个参数，在Job实现类中，可以通过jobExecutionContext.getTrigger().getJobDataMap().get("orderNo")获取值*/
        .usingJobData("orderNo", "123456")
        /**添加认证信息，有3种重写的方法，我这里是其中一种，可以查看源码看其余2种*/
        .withIdentity("我是name","我是group")
        /**立即生效*/
//      .startNow()
        /**开始执行时间*/
        .startAt(start)
        /**结束执行时间,不写永久执行*/
        .endAt(start)
        /**添加执行规则，SimpleTrigger、CronTrigger的区别主要就在这里*/
        .withSchedule(
                SimpleScheduleBuilder.simpleSchedule()
                /**每隔3s执行一次,api方法有好多规则自行查看*/
                .withIntervalInSeconds(3)
                /**一直执行,如果不写,定时任务就执行一次*/
                .repeatForever()
        )
        .build();//执行

CronTrigger：这就比较常用了，是基于Cron表达式来实现的。

CronTrigger  trigger = TriggerBuilder.newTrigger()
        /**给当前JobDetail添加参数，K V形式，链式调用，可以传入多个参数，在Job实现类中，可以通过jobExecutionContext.getTrigger().getJobDataMap().get("orderNo")获取值*/
        .usingJobData("orderNo", "123456")
        /**添加认证信息，有3种重写的方法，我这里是其中一种，可以查看源码看其余2种*/
        .withIdentity("我是name","我是group")
        /**立即生效*/
//      .startNow()
        /**开始执行时间*/
        .startAt(start)
        /**结束执行时间,不写永久执行*/
        .endAt(start)
        /**添加执行规则，SimpleTrigger、CronTrigger的区别主要就在这里,我这里是demo，写了个每2分钟执行一次*/
        .withSchedule(CronScheduleBuilder.cronSchedule("0 0/2 * * * ?"))
        .build();//执行

注意：.startNow( )和.startAt( )这里有个坑，这两个方法是对同一个成员变量进行修改的也就是说startAt和startNow同时调用的时候任务开始的时间是按后面调用的方法为主的，谁写在后面用谁

4.7、启动任务

/**添加定时任务*/
scheduler.scheduleJob(jobDetail, trigger);
if (!scheduler.isShutdown()) {
    /**启动*/
    scheduler.start();
}

以上，任务的创建启动都完事了，后面就是任务的暂停、恢复、删除。比较简单，大致原理就是我们在创建任务明细(JobDetail)和创建触发器(Trigger)时，会调用.withIdentity(key,group)来传入认证信息，后续就是根据这些认证信息来管理任务(通过api方法)

4.8、任务的暂停

scheduler.pauseTrigger(TriggerKey.triggerKey("我是刚才写的name","我是刚才写的group"));

4.9、任务的恢复

scheduler.resumeTrigger(TriggerKey.triggerKey("我是刚才写的name","我是刚才写的group"));

4.10、任务的删除

scheduler.pauseTrigger(TriggerKey.triggerKey("我是刚才写的name","我是刚才写的group"));//暂停触发器
scheduler.unscheduleJob(TriggerKey.triggerKey("我是刚才写的name","我是刚才写的group"));//移除触发器
scheduler.deleteJob(JobKey.jobKey("我是刚才写的name","我是刚才写的group"));//删除Job

4.11、整体案例

public class QuartzJob implements Job {

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println(jobExecutionContext.getJobDetail().getKey() + "开始执行...");
    }
}

package com.example.bootquartz.controller;

import com.example.bootquartz.config.QuartzJob;
import io.swagger.annotations.ApiOperation;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

@RestController
public class QuartzHandler {
    SchedulerFactory schedulerFactory = null;
    Scheduler scheduler = null;

    public QuartzHandler() throws SchedulerException {
        schedulerFactory = new StdSchedulerFactory();
        scheduler = schedulerFactory.getScheduler();
    }

    @PostMapping("/quartz")
    @ApiOperation(value = "定时任务_创建", notes = "创建")
    @ResponseBody
    public Object quartz(@RequestParam("orderNo")  String orderNo) throws Exception {
        Date start=new Date(System.currentTimeMillis() + 7 * 1000);//当前时间7秒之后

        /**通过JobBuilder.newJob()方法获取到当前Job的具体实现(以下均为链式调用)
         * 这里是固定Job创建，所以代码写死XXX.class
         * 如果是动态的，根据不同的类来创建Job，则 ((Job)Class.forName("com.chenxin.job.TestJob").newInstance()).getClass()
         * 即是 JobBuilder.newJob(((Job)Class.forName("com.chenxin.job.TestJob").newInstance()).getClass())
         * */
        JobDetail jobDetail = JobBuilder.newJob(QuartzJob.class)
                /**给当前JobDetail添加参数，K V形式*/
                .usingJobData("name","zy")
                /**给当前JobDetail添加参数，K V形式，链式调用，可以传入多个参数，在Job实现类中，可以通过jobExecutionContext.getJobDetail().getJobDataMap().get("age")获取值*/
                .usingJobData("age",23)
                /**添加认证信息，有3种重写的方法，这里是其中一种，可以查看源码看其余2种*/
                .withIdentity(orderNo)
                .build();//执行


        Trigger trigger = TriggerBuilder.newTrigger()
                /**给当前JobDetail添加参数，K V形式，链式调用，可以传入多个参数，在Job实现类中，可以通过jobExecutionContext.getTrigger().getJobDataMap().get("orderNo")获取值*/
                .usingJobData("orderNo", orderNo)
                /**添加认证信息，有3种重写的方法，我这里是其中一种，可以查看源码看其余2种*/
                .withIdentity(orderNo)
                /**立即生效*/
//      .startNow()
                /**开始执行时间*/
                .startAt(start)
                /**结束执行时间*/
//        .endAt(start)
                /**添加执行规则，SimpleTrigger、CronTrigger的区别主要就在这里*/
                .withSchedule(
                        SimpleScheduleBuilder.simpleSchedule()
                                /**每3s执行一次*/
                                .withIntervalInSeconds(3)
                                /**一直执行，*/
                                .repeatForever()
                )
                .build();//执行

        /**添加定时任务*/
        scheduler.scheduleJob(jobDetail, trigger);
        if (!scheduler.isShutdown()) {
            /**启动*/
            scheduler.start();
        }
        System.err.println("--------定时任务启动成功 "+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+" ------------");
        return "ok";
    }

    @PostMapping("/shutdown")
    @ApiOperation(value = "定时任务_停止", notes = "停止")
    @ResponseBody
    public Object shutdown(@RequestParam("orderNo")  String orderNo) throws IOException, SchedulerException {
        scheduler.pauseTrigger(TriggerKey.triggerKey(orderNo));//暂停Trigger
        return "";
    }

    @PostMapping("/resume")
    @ApiOperation(value = "定时任务_恢复", notes = "恢复")
    @ResponseBody
    public Object resume(@RequestParam("orderNo")  String orderNo) throws IOException, SchedulerException {
        scheduler.resumeTrigger(TriggerKey.triggerKey(orderNo));//恢复Trigger
        return "ok";
    }

    @PostMapping("/del")
    @ApiOperation(value = "定时任务_删除", notes = "删除")
    @ResponseBody
    public Object del(@RequestParam("orderNo")  String orderNo) throws IOException, SchedulerException {
        scheduler.pauseTrigger(TriggerKey.triggerKey(orderNo));//暂停触发器
        scheduler.unscheduleJob(TriggerKey.triggerKey(orderNo));//移除触发器
        scheduler.deleteJob(JobKey.jobKey(orderNo));//删除Job
        return "ok";
    }
}