回答

收藏

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

知识点 知识点 26 人阅读 | 0 人回复 | 2023-01-19

帖子摘要:看了好多文章都只讲了基础的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
2 U, y- L( i4 x3 t7 J
& o: f" X  J: [3 Q. D8 ^) A: d
        ; _: K% x2 v, l% Q+ J8 i
               
; {  r* A! {- C) p                    看了好多文章都只讲了基础的demo用法也就是简单的创建运行定时任务对定时任务的管理却很少。0 l5 D0 r+ }# i' O- F0 q
! e4 q, x% K% x" J$ O
我这里从0开始搭建一个简单的demo包括定时任务的各种操作以及API的一些用法可以实现大多场景的需求。如1 U* c5 t. e! Q$ Q& M  q
* o/ p: ]3 j) i9 F8 D1 ?9 u
[ol]
  • 普通定时任务的创建、启动、停止。+ d3 E: x, V) U; Q
  • 动态创建定时任务如创建一个订单5分钟后执行某某操作。1 R, @! H; ~/ s8 }; i2 A5 U
    [/ol]
    4 L( ], e8 N% D8 m$ A7 y5 G- b一、整个 Quartz 的代码流程基本基本如下 , g; d3 J5 F/ s9 o% v$ E
    [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)关联起来便于执行。8 o$ Z: W2 j/ }
  • 创建触发器(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
    1.   
    2.    org.springframework.boot
    3.    spring-boot-starter-quartz
    4.    # q5 b" A' R# M# M6 A7 V; e% C
    复制代码
    5 ^. T5 r( z4 P; \
    三、创建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 " z8 C+ L4 `* B1 n' s
    1. import com.dy.utils.DateUtil;
    2. import org.quartz.DisallowConcurrentExecution;
    3. import org.quartz.Job;
    4. import org.quartz.JobExecutionContext;
    5. import org.quartz.JobExecutionException; / o6 O3 i: j1 V
    6. import java.util.Date; ( H0 R' h! W: I
    7. /** / v, t; B8 q9 e6 j" \* @
    8. * @program: xiudo-ota
    9. * @description: 测试定时任务
    10. * @author: zhang yi
    11. * @create: 2020-10-09 14:38
    12. */ 1 A: a4 Z9 K# s# p
    13. @DisallowConcurrentExecution//Job中的任务有可能并发执行例如任务的执行时间过长而每次触发的时间间隔太短则会导致任务会被并发执行。如果是并发执行就需要一个数据库锁去避免一个数据被多次处理。 " ]3 Z  B2 @8 d7 w9 d9 M" ~
    14. public class TestJob implements Job { 4 N: Z4 X9 \5 [* I) t3 s+ v7 U
    15.     @Override
    16.     public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
    17.         System.err.println(jobExecutionContext.getJobDetail().getJobDataMap().get("name")); ' a+ o0 `* \  A# T7 X" ]
    18.         System.err.println(jobExecutionContext.getJobDetail().getJobDataMap().get("age"));
    19.         System.err.println(jobExecutionContext.getTrigger().getJobDataMap().get("orderNo"));
    20.         System.err.println("定时任务执行当前时间"+ DateUtil.formatDateTime(new Date())); ( O+ A9 u( Z2 w8 y
    21.     } : I8 |% ~" d5 Y/ g' Z
    22. } 0 N: c, t& p* B; H# @  P% C' f
    复制代码
      v) E6 ~- [$ {- K9 e' S: R
    四、创建任务调度器(Scheduler) 5 s4 T9 x* H. w- B
    这里采用Spring IOC所以直接注入完事。如果是普通的则需通过工厂创建。
    0 B+ i1 Q1 ]  ^0 m0 W! V
    - y8 Y* I3 n; ^6 n, ^; y$ w工厂% v, `( v, H* s; l  L! U
    ! d' O) a! n$ d: o* `+ ~
    1. SchedulerFactory schedulerFactory = new StdSchedulerFactory(); $ I5 d  ~$ E- Z; u0 k
    2. Scheduler scheduler = schedulerFactory.getScheduler();
    复制代码
    4 ]6 e- c4 }7 q+ Y
    IOC% G% W9 a9 t9 _! Z# K0 m- g

    1 Q+ P: ~6 F8 l& q" Y
    1. @Autowired
    2. private Scheduler scheduler; 5 c9 |2 J; S. g# Y% u
    复制代码

    $ L+ Z* W5 t8 M五、创建任务明细(JobDetail)
    2 H) q4 y! S+ Y- \
    1. /**通过JobBuilder.newJob()方法获取到当前Job的具体实现(以下均为链式调用) 5 r3 Y. `0 g3 Q" q
    2. * 这里是固定Job创建所以代码写死XXX.class # y+ x5 C. @6 m: t/ }
    3. * 如果是动态的根据不同的类来创建Job则 ((Job)Class.forName("com.zy.job.TestJob").newInstance()).getClass() 5 A2 ^( p: m# R1 t3 I1 ?
    4. * 即是 JobBuilder.newJob(((Job)Class.forName("com.zy.job.TestJob").newInstance()).getClass())   s0 U/ D* r% y% L
    5. * */ 2 m! y9 K7 t+ B8 o. V0 d( V
    6. JobDetail jobDetail = JobBuilder.newJob(TestJob.class) - d4 [6 E( o" n# ~
    7.         /**给当前JobDetail添加参数K V形式*/
    8.         .usingJobData("name","zy")
    9.         /**给当前JobDetail添加参数K V形式链式调用可以传入多个参数在Job实现类中可以通过jobExecutionContext.getJobDetail().getJobDataMap().get("age")获取值*/
    10.         .usingJobData("age",23)
    11.         /**添加认证信息有3种重写的方法我这里是其中一种可以查看源码看其余2种*/ 3 M: ^$ ~( e  t2 R4 Z# ]" b# m( O
    12.         .withIdentity("我是name","我是group")
    13.         .build();//执行
    复制代码
    8 A! U& R+ z$ W  p
    六、创建触发器(Trigger) 6 S- a0 R3 S* ?8 G6 M+ M
    这里主要分为两大类SimpleTrigger、CronTrigger。
    9 D4 ~9 U7 i+ e ) Y* I$ m7 L  d# @
    SimpleTrigger是根据它自带的api方法设置规则比如每隔5秒执行一次、每隔1小时执行一次。+ T; J% Z0 s$ D6 O, B3 D4 l

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

    $ u+ Q5 k& e# a0 r7 Q7 c* ]5 G
    1. CronTrigger  trigger = TriggerBuilder.newTrigger() ) q% E! d7 E3 V0 }7 s
    2.         /**给当前JobDetail添加参数K V形式链式调用可以传入多个参数在Job实现类中可以通过jobExecutionContext.getTrigger().getJobDataMap().get("orderNo")获取值*/
    3.         .usingJobData("orderNo", "123456")   K! R) d7 ~; y  E5 K6 O; [5 ?
    4.         /**添加认证信息有3种重写的方法我这里是其中一种可以查看源码看其余2种*/
    5.         .withIdentity("我是name","我是group")
    6.         /**立即生效*/ & i$ C  x, C* j* x# K
    7. //      .startNow() ) e/ h! \# V8 T6 o
    8.         /**开始执行时间*/
    9.         .startAt(start) 0 z: h8 C: ]' @* d6 l$ v6 Z: [$ {
    10.         /**结束执行时间,不写永久执行*/
    11.         .endAt(start) 0 U7 U0 z1 I7 C; \: O+ O2 {
    12.         /**添加执行规则SimpleTrigger、CronTrigger的区别主要就在这里,我这里是demo写了个每2分钟执行一次*/
    13.         .withSchedule(CronScheduleBuilder.cronSchedule("0 0/2 * * * ?"))
    14.         .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同时调用的时候任务开始的时间是按后面调用的方法为主的谁写在后面用谁4 k+ h( m( e4 O) H4 d+ c9 S* e

    : A* `% Q; I4 M- P. d4 ~' ?
    51f7f719130d40859aebba12b031d709.png (73.8 KB, 下载次数: 0, 售价: 4 金钱)
  • 分享到:
    回复

    使用道具 举报

    您需要登录后才可以回帖 登录 | 立即注册

    本版积分规则