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

java8

帖子摘要：看了好多文章都只讲了基础的demo用法也就是简单的创建运行定时任务对定时任务的管理却很少。 我这里从0开始搭建一个简单的demo包括定时任务的各种操作以及API的一些用法可以实现大多场景的需求。如  ......
$ T+ Z2 @: o: J7 u/ E
+ T- S$ d, |8 T. m! F, f/ D7 g大家好，欢迎来到Java吧（www.java8.com），交流、学习Java技术、获取Java资源无任何套路，今天说一说：“SpringBoot集成Quartz实现定时任务的动态创建、启动、暂停、恢复、删除”
( `% E5 L2 B/ P# _# \- X3 k

        
               
; {  r* A! {- C) p                    看了好多文章都只讲了基础的demo用法也就是简单的创建运行定时任务对定时任务的管理却很少。

我这里从0开始搭建一个简单的demo包括定时任务的各种操作以及API的一些用法可以实现大多场景的需求。如

[ol]

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

动态创建定时任务如创建一个订单5分钟后执行某某操作。
[/ol]
4 L( ], e8 N% D8 m$ A7 y5 G- b一、整个 Quartz 的代码流程基本基本如下
[ol]

首先需要创建我们的任务(Job)比如取消订单、定时发送短信邮件之类的这是我们的任务主体也是写业务逻辑的地方。
0 O: h9 x$ m: D7 q0 H+ |5 `0 K

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

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

创建触发器(Trigger)触发器是来定义任务的规则的比如几点执行几点结束几分钟执行一次等等。这里触发器主要有两大类(SimpleTrigger和CronTrigger)。
$ ?4 R* F/ h( v; T3 K

根据Scheduler来启动JobDetail与Trigger
/ c) K* p  }' x8 L9 S6 q [/ol]
4 j3 j7 p/ l- n( Y二、进入正题引入依赖
& Q- H: T* g5 M* U$ |) N/ f( D

  
   org.springframework.boot
   spring-boot-starter-quartz
  
# q5 b" A' R# M# M6 A7 V; e% C
复制代码

三、创建Job
% K3 Z, R' z5 ]需实现Job接口这个接口就一个execute()方法需要重写方法内容就是具体的业务逻辑。如果是动态任务呢比如取消订单每次执行都是不同的订单号。
% |9 `. Z) J2 [0 q6 G/ ^# w
0 Z" g8 M; K3 Y. Z这个时候就需要在创建任务(JobDetail)或者创建触发器(Trigger)的那里传入参数然后在这里通过JobExecutionContext来获取参数进行处理
; y; B/ t. [+ M- p! }8 M

import com.dy.utils.DateUtil;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
/ o6 O3 i: j1 V
import java.util.Date;
( H0 R' h! W: I
 
/**
/ v, t; B8 q9 e6 j" \* @
 * @program: xiudo-ota
 * @description: 测试定时任务
 * @author: zhang yi
 * @create: 2020-10-09 14:38
 */
1 A: a4 Z9 K# s# p
@DisallowConcurrentExecution//Job中的任务有可能并发执行例如任务的执行时间过长而每次触发的时间间隔太短则会导致任务会被并发执行。如果是并发执行就需要一个数据库锁去避免一个数据被多次处理。
" ]3 Z  B2 @8 d7 w9 d9 M" ~
public class TestJob implements Job {
4 N: Z4 X9 \5 [* I) t3 s+ v7 U
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.err.println(jobExecutionContext.getJobDetail().getJobDataMap().get("name"));
' a+ o0 `* \  A# T7 X" ]
        System.err.println(jobExecutionContext.getJobDetail().getJobDataMap().get("age"));
        System.err.println(jobExecutionContext.getTrigger().getJobDataMap().get("orderNo"));
        System.err.println("定时任务执行当前时间"+ DateUtil.formatDateTime(new Date()));
( O+ A9 u( Z2 w8 y
    }
: I8 |% ~" d5 Y/ g' Z
}
0 N: c, t& p* B; H# @  P% C' f
复制代码

四、创建任务调度器(Scheduler)
这里采用Spring IOC所以直接注入完事。如果是普通的则需通过工厂创建。
0 B+ i1 Q1 ]  ^0 m0 W! V
- y8 Y* I3 n; ^6 n, ^; y$ w工厂

SchedulerFactory schedulerFactory = new StdSchedulerFactory();
$ I5 d  ~$ E- Z; u0 k
Scheduler scheduler = schedulerFactory.getScheduler();
复制代码

IOC

1 Q+ P: ~6 F8 l& q" Y

@Autowired
private Scheduler scheduler;
5 c9 |2 J; S. g# Y% u
复制代码

$ L+ Z* W5 t8 M五、创建任务明细(JobDetail)
2 H) q4 y! S+ Y- \

/**通过JobBuilder.newJob()方法获取到当前Job的具体实现(以下均为链式调用)
5 r3 Y. `0 g3 Q" q
 * 这里是固定Job创建所以代码写死XXX.class
# y+ x5 C. @6 m: t/ }
 * 如果是动态的根据不同的类来创建Job则 ((Job)Class.forName("com.zy.job.TestJob").newInstance()).getClass()
5 A2 ^( p: m# R1 t3 I1 ?
 * 即是 JobBuilder.newJob(((Job)Class.forName("com.zy.job.TestJob").newInstance()).getClass())
  s0 U/ D* r% y% L
 * */
2 m! y9 K7 t+ B8 o. V0 d( V
JobDetail jobDetail = JobBuilder.newJob(TestJob.class)
- d4 [6 E( o" n# ~
        /**给当前JobDetail添加参数K V形式*/
        .usingJobData("name","zy")
        /**给当前JobDetail添加参数K V形式链式调用可以传入多个参数在Job实现类中可以通过jobExecutionContext.getJobDetail().getJobDataMap().get("age")获取值*/
        .usingJobData("age",23)
        /**添加认证信息有3种重写的方法我这里是其中一种可以查看源码看其余2种*/
3 M: ^$ ~( e  t2 R4 Z# ]" b# m( O
        .withIdentity("我是name","我是group")
        .build();//执行
复制代码

六、创建触发器(Trigger)
这里主要分为两大类SimpleTrigger、CronTrigger。
9 D4 ~9 U7 i+ e
SimpleTrigger是根据它自带的api方法设置规则比如每隔5秒执行一次、每隔1小时执行一次。

; `3 P( E9 `% b; o9 D, u5 V! ^. ?

Trigger trigger = TriggerBuilder.newTrigger()
: |: V: i9 h# }  [% t& @
        /**给当前JobDetail添加参数K V形式链式调用可以传入多个参数在Job实现类中可以通过jobExecutionContext.getTrigger().getJobDataMap().get("orderNo")获取值*/
        .usingJobData("orderNo", "123456")
4 W% d2 V0 O8 _8 k& q+ w+ V
        /**添加认证信息有3种重写的方法我这里是其中一种可以查看源码看其余2种*/
        .withIdentity("我是name","我是group")
        /**立即生效*/
//      .startNow()
        /**开始执行时间*/
$ ]  [! p' o% c3 q* P5 O! x$ r
        .startAt(start)
2 }2 Q# Q. h& Z
        /**结束执行时间,不写永久执行*/
7 V! R8 Z& u( V" z( e
        .endAt(start)
        /**添加执行规则SimpleTrigger、CronTrigger的区别主要就在这里*/
        .withSchedule(
                SimpleScheduleBuilder.simpleSchedule()
* p, t0 |$ T) K
                /**每隔3s执行一次,api方法有好多规则自行查看*/
+ [- n! G- o7 M7 G) j( q% k
                .withIntervalInSeconds(3)
* _5 O6 i$ m% T1 Z7 M( R) E0 O
                /**一直执行,如果不写,定时任务就执行一次*/
. d8 b; [/ Z4 `# X+ T& ?  N/ m' e
                .repeatForever()
        )
0 N9 j' ^  d4 F! F) Z
        .build();//执行
- ?0 P5 A' @9 C' x/ }
复制代码

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

$ u+ Q5 k& e# a0 r7 Q7 c* ]5 G

CronTrigger  trigger = TriggerBuilder.newTrigger()
) q% E! d7 E3 V0 }7 s
        /**给当前JobDetail添加参数K V形式链式调用可以传入多个参数在Job实现类中可以通过jobExecutionContext.getTrigger().getJobDataMap().get("orderNo")获取值*/
        .usingJobData("orderNo", "123456")
  K! R) d7 ~; y  E5 K6 O; [5 ?
        /**添加认证信息有3种重写的方法我这里是其中一种可以查看源码看其余2种*/
        .withIdentity("我是name","我是group")
        /**立即生效*/
& i$ C  x, C* j* x# K
//      .startNow()
) e/ h! \# V8 T6 o
        /**开始执行时间*/
        .startAt(start)
0 z: h8 C: ]' @* d6 l$ v6 Z: [$ {
        /**结束执行时间,不写永久执行*/
        .endAt(start)
0 U7 U0 z1 I7 C; \: O+ O2 {
        /**添加执行规则SimpleTrigger、CronTrigger的区别主要就在这里,我这里是demo写了个每2分钟执行一次*/
        .withSchedule(CronScheduleBuilder.cronSchedule("0 0/2 * * * ?"))
        .build();//执行
# H4 B2 ?# l. O- H. K2 x+ n8 }. b
复制代码

) a  G8 R) F% w, a3 R* Y1 v* t$ g注意.startNow( )和.startAt( )这里有个坑这两个方法是对同一个成员变量进行修改的 也就是说startAt和startNow同时调用的时候任务开始的时间是按后面调用的方法为主的谁写在后面用谁

: A* `% Q; I4 M- P. d4 ~' ?

51f7f719130d40859aebba12b031d709.png (73.8 KB, 下载次数: 0, 售价: 4 金钱)

2023-1-19 12:26 上传

点击文件名下载附件
51f7f719130d40859aebba12b031d709.png

七、启动任务

/**添加定时任务*/
scheduler.scheduleJob(jobDetail, trigger);
, Q6 `5 f/ R4 u, p" e9 F, j% B
if (!scheduler.isShutdown()) {
    /**启动*/
    scheduler.start();
% s% e" |1 b6 z8 M- Y
}
+ I" E5 w3 f( V, f1 F
复制代码

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

八、任务的暂停

scheduler.pauseTrigger(TriggerKey.triggerKey("我是刚才写的name","我是刚才写的group"));
  _9 C) I0 I) R; e1 W# T
复制代码

' F; g( B$ W3 S! C: Z九、任务的恢复

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

615e454f16282d3584291f105677dcc4.png (16.56 KB, 下载次数: 0, 售价: 3 金钱)

2023-1-19 12:26 上传

点击文件名下载附件
615e454f16282d3584291f105677dcc4.png

( w6 r  f* {' s2 r2 y0 V
+ p( Y" j5 r  L4 ^9 Y: J1 \根据你写的方式来获取。
  q- j5 l/ e% U, F* I& O5 u2 E
十、任务的删除

scheduler.pauseTrigger(TriggerKey.triggerKey("我是刚才写的name","我是刚才写的group"));//暂停触发器
scheduler.unscheduleJob(TriggerKey.triggerKey("我是刚才写的name","我是刚才写的group"));//移除触发器
+ o1 W3 b; C0 I! y" }6 u
scheduler.deleteJob(JobKey.jobKey("我是刚才写的name","我是刚才写的group"));//删除Job
复制代码

最后附上基本代码Job实现在上面

: v+ i8 k$ M0 f, d  q/ k% s! x

    @Autowired
' E+ h; I6 b: D3 ]
    private Scheduler scheduler;
! B' ]# s! Z' e. i0 s" H& A
 
    @PostMapping("/Quartz")
    @ApiOperation(value = "定时任务_创建", notes = "创建")
' Z; z/ P# o" J
    @ResponseBody
8 t" m6 {+ V% B" }& |% S
    public Object quartz(@RequestParam("orderNo")  String orderNo) throws Exception {
        Date start=new Date(System.currentTimeMillis() + 7 * 1000);//当前时间7秒之后
 
        /**通过JobBuilder.newJob()方法获取到当前Job的具体实现(以下均为链式调用)
         * 这里是固定Job创建所以代码写死XXX.class
! F; F$ H; L* s0 J: o
         * 如果是动态的根据不同的类来创建Job则 ((Job)Class.forName("com.zy.job.TestJob").newInstance()).getClass()
         * 即是 JobBuilder.newJob(((Job)Class.forName("com.zy.job.TestJob").newInstance()).getClass())
         * */
        JobDetail jobDetail = JobBuilder.newJob(TestJob.class)
/ Q/ ]# ]0 s: z; K) D0 U
                /**给当前JobDetail添加参数K V形式*/
                .usingJobData("name","zy")
! v: p1 \- t4 D( b) p0 M
                /**给当前JobDetail添加参数K V形式链式调用可以传入多个参数在Job实现类中可以通过jobExecutionContext.getJobDetail().getJobDataMap().get("age")获取值*/
; H+ n: I  a% C1 f' J. V! |+ K
                .usingJobData("age",23)
                /**添加认证信息有3种重写的方法我这里是其中一种可以查看源码看其余2种*/
                .withIdentity(orderNo)
1 V5 ~/ Q6 S9 a- d3 O6 R
                .build();//执行
 
" j2 ^2 C0 b" |3 Y$ X
 
        Trigger trigger = TriggerBuilder.newTrigger()
                /**给当前JobDetail添加参数K V形式链式调用可以传入多个参数在Job实现类中可以通过jobExecutionContext.getTrigger().getJobDataMap().get("orderNo")获取值*/
6 _, h, G' F+ _2 a$ J
                .usingJobData("orderNo", orderNo)
                /**添加认证信息有3种重写的方法我这里是其中一种可以查看源码看其余2种*/
( l/ u6 o% z8 l* Q! N% y' Q9 ?
                .withIdentity(orderNo)
                /**立即生效*/
//      .startNow()
                /**开始执行时间*/
                .startAt(start)
+ _# g- X, F1 C# L' \$ V0 Y
                /**结束执行时间*/
" i7 a0 h9 {) S" \- ^( h& g1 d! Y# m) \
//        .endAt(start)
                /**添加执行规则SimpleTrigger、CronTrigger的区别主要就在这里*/
2 ]2 E  x8 ~+ e
                .withSchedule(
                        SimpleScheduleBuilder.simpleSchedule()
. c- h2 q& H2 R; m& y
                                /**每隔1s执行一次*/
                                .withIntervalInSeconds(3)
                                /**一直执行*/
8 A' |8 [: c. i
                                .repeatForever()
3 t- F! O# d3 M1 j; C
                )
5 U1 l8 Y' K0 o3 \8 W
                .build();//执行
 
//CronTrigger  trigger = TriggerBuilder.newTrigger()
//        /**给当前JobDetail添加参数K V形式链式调用可以传入多个参数在Job实现类中可以通过jobExecutionContext.getTrigger().getJobDataMap().get("orderNo")获取值*/
( t, G  u' K& s3 a" z1 Z" I; X
//        .usingJobData("orderNo", orderNo)
! A- J& r( U) y8 z: d& {, ~
//        /**添加认证信息有3种重写的方法我这里是其中一种可以查看源码看其余2种*/
# N( ~: A  a% q1 z! Z; ]7 ]
//        .withIdentity(orderNo)
//        /**开始执行时间*/
//        .startAt(start)
//        /**结束执行时间*/
//        .endAt(start)
//        /**添加执行规则SimpleTrigger、CronTrigger的区别主要就在这里*/
//        .withSchedule(CronScheduleBuilder.cronSchedule("* 30 10 ? * 1/5 2018"))
; Z4 k" N1 j3 W# e
//        .build();//执行
+ F; A/ M8 \; D/ ?9 j; c
 
 
        /**添加定时任务*/
: K" T5 Y5 G4 Z4 m3 O/ U
        scheduler.scheduleJob(jobDetail, trigger);
! q) N) |8 D8 ?* Z3 G
        if (!scheduler.isShutdown()) {
            /**启动*/
            scheduler.start();
        }
( M5 C% h9 A' K9 {0 p
        System.err.println("--------定时任务启动成功 "+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+" ------------");
        return "ok";
    }
/ T7 i' s2 l, s, a( z
 
    @PostMapping("/shutdown")
    @ApiOperation(value = "定时任务_停止", notes = "停止")
5 u( q7 U! R  c/ F) b
    @ResponseBody
1 t9 [$ D0 s* R& c3 F
    public Object shutdown(@RequestParam("orderNo")  String orderNo) throws IOException, SchedulerException {
( }* Y; L9 V( d+ G( v" a7 {* j* p
        scheduler.pauseTrigger(TriggerKey.triggerKey(orderNo));//暂停Trigger
        return "";
3 H7 j# L& E' _% [. `6 r
    }
 
# E, \# u7 T$ ~& ^0 ~2 H
    @PostMapping("/resume")
: X; R2 A0 o% g; v
    @ApiOperation(value = "定时任务_恢复", notes = "恢复")
    @ResponseBody
    public Object resume(@RequestParam("orderNo")  String orderNo) throws IOException, SchedulerException {
) x6 i" e6 `  v0 e7 z& p& W
        scheduler.resumeTrigger(TriggerKey.triggerKey(orderNo));//恢复Trigger
        return "ok";
1 k8 w: m+ {, t' [2 P* |. {, Z2 Q
    }
4 m" x  D. i+ N/ [& C- b
 
. N! k5 R5 j# v5 w# l; z8 m7 J
    @PostMapping("/del")
    @ApiOperation(value = "定时任务_删除", notes = "删除")
, s+ M+ i  o: u" L0 m. _
    @ResponseBody
; P( M! P! v( \; g# B
    public Object del(@RequestParam("orderNo")  String orderNo) throws IOException, SchedulerException {
        scheduler.pauseTrigger(TriggerKey.triggerKey(orderNo));//暂停触发器
        scheduler.unscheduleJob(TriggerKey.triggerKey(orderNo));//移除触发器
" V! ^! Q+ ^5 h8 l
        scheduler.deleteJob(JobKey.jobKey(orderNo));//删除Job
7 e" C  h/ `3 l, U& t
        return "ok";
  q/ Q5 G$ _2 s$ `) [8 s- n
    }
复制代码

完事。。。。。。如果想让定时任务在启动项目后自动启动则需要持久化任务可以把基本信息保存在数据库项目启动时启动完或者做分布式任务
2 n- L5 S3 r8 T- a/ F3 _
本文来源csdn，由Java吧转载发布，观点不代表Java吧的立场，转载请标明来源出处：https://www.java8.com