飞道的博客

Spring Boot 整合定时任务完成 从0 到1

525人阅读  评论(0)

Java 定时任务学习

定时任务概述

>

定时任务的应用场景非常广泛, 如果说 我们想要在某时某地去尝试的做某件事 就需要用到定时任务来通知我们 ,大家可以看下面例子

如果需要明天 早起,哪我们一般会去定一个闹钟去通知我们, 而在编程中 有许许多多的场景就需要用到类似的功能 ,例如我们的花呗借款之后,她需要提示你一个还款日期 、又或者 当我们购物下单之后 它需要会在一定的时间内去通知 你支付, 这些个 需要用到 具体 时间通知倒计时的 场景

在 Java中 ,我们如果想实现最简单的定时任务,我们正常的思路应该是这样的,去创建一个线程 ,举例我们借款后,需要在30秒内还款,我们调用了下面的方法,当然只是为了举例,业务场景并不严谨,只是为了演示 ,我们之后了他会停顿30 秒 ,等待你下单完毕

而你如果点击取消借款, 哪我们就使用Thread.stop() 关闭掉了 线程

// 下单后调用还花呗 方法

@Test
  public void testFlowers() {
     
        // 单位: 毫秒 通知还花呗
        final long timeInterval = 30000
0;  
        Runnable runnable = new Runnable() {
     
            public void run() {
     
                while (true) {
     
                    // ------- code for task to run  
                    System.out.println("业务还款逻辑 伪代码!");  
                    // ------- ends here  
                    try {
     
                        Thread.sleep(timeInterval);  
                    } catch (InterruptedException e) {
     
                        e.printStackTrace();  
                    }  
                }  
            }  
        };  
        Thread thread = new Thread(runnable);  
        thread.start();  
    }

我们可以看到, 其实类似的场景还有非常多非常多,所以,正常思路我们可能会封装一个工具类,但是业务场景还会有非常多的安全问题, 例如 事务、保证数据的一致性等等、这都是我们考虑的范围,所以我们就需要一个 更完美的方案去解决这类统一的问题,于是定时任务的各种方案就腾空出世 ,相对而言 ,java.util 包 就存在一个解决这个类问题的原生类

java.util.Timer java的api Timer来完成一个定时任务

这个类出现的非常早,它也是最早专门用来解决这类问题的,我们可以来看一下是怎么使用的 ,通过Timer 对象传入了 一个任务进行触发定时任务

线程安全, 但只会单线程执行, 如果执行时间过长, 就错过下次任务了, 抛出异常时, timerWork会终止

@SpringBootTest
class SchduleTestApplicationTests {
   

    @Test
    void contextLoads() {
   
        // 3. 创建一个定时任务
        TimerTask timerTask = new TimerTask() {
   
            @Override
            public void run() {
   
                System.out.println("每三秒执行一次");
            }

        };
    //1. 创建一个Timer 对象 
        Timer timer = new Timer();
    // 2. 设置定时执行的任务 : schedule(TimerTask task, long delay, long period) 
        timer.schedule(timerTask, 10, 3000);

    }

}

通过上面的方法我们可以很正常的去使用 定时任务 ,解释一下这个里面的含义,首先task这个就是你要定时的一个任务,delay代表延迟多久执行,我们这里为了测试设置为0就就是不延迟,period就是每个多久执行一次,我们为了看到效果设置为3000,也就是3秒执行一次 延迟一毫秒的意思 我们可以从下面看到运行的结果

在了解了Timer后,我们知道它有些不足,是单线程去运行的,所以JDK又推出了一种结合线程池的定时任务类.即ScheduledExecutorService,针对每个线程任务,会指定线程池中的一个线程去执行.是Timer的更好的一个替代品.

当然我们也可以使用 线程池的方式去完成一样的结果 ,只是方式不同 ,大家参考学习即可,ScheduledExecutorService 内涵盖了 所有 Timer的功能

public class MyScheduledExecutor {
       
    public static void main(String[] args){
           
        // 创建任务队列   10 为线程数量      
        ScheduledExecutorService scheduledExecutorService = 
                Executors.newScheduledThreadPool(10); 
        // 执行任务      
        scheduledExecutorService.scheduleAtFixedRate(() -> {
             
            System.out.println("打印当前时间:" + new Date());      
        }, 1, 3, TimeUnit.SECONDS); // 1s 后开始执行,每 3s 执行一次   
 
  }
}

当程序初始化完成Timer后,定时任务就会按照我们设定的时间去执行,Timer提供了schedule方法,该方法有多中重载方式来适应不同的情况,如下:

  • schedule(TimerTask task, Date time) :在指定的时间内执行指定的任务。

    schedule(TimerTask task, Date firstTime, long period) :指定的任务在指定的时间开始进行重复的固定延迟执行。

    • schedule(TimerTask task, long delay) :在指定的延迟时间后执行指定的任务。

    • schedule(TimerTask task, long delay, long period) :指定的任务从指定的延迟时间后开始进行重复固定的执行。

      • scheduleAtFixedRate(TimerTask task, Date firstTime, long period) :指定的任务在指定的时间内开始进行重复固定速率的执行。

      • scheduleAtFixedRate(TimerTask task, long delay, long period) :指定的任务在指定的延迟时间后开始进行重复固定速率的执行。

ScheduledExecutorService 优缺点分析 :

优点是,该类是JDK1.5自带的类,使用简单,缺点是该方案仅适用于单机环境。

我们可以 来过一下它的方法

  1. : scheduleAtFixedRate

以给定的间隔去执行任务,当任务的执行时间过长,超过间隔时间后,下一次定时任务的执行会顺延至当前定时任务执行完毕之后.否则严格按照间隔时间去执行.

  */
    public class Task2 {
   
        public static void main(String[] args) throws ExecutionException, InterruptedException {
   
         //创建一个线程池,以JVM可以利用的CPU数为核心线程数,并指定拒绝策略
                ScheduledThreadPoolExecutor scheduledExecutor = new ScheduledThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),
                        new RejectedExecutionHandler() {
   
                            @Override
                            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
   
                                System.out.println("当前任务执行失败" + r);
                            }
                        });

                // 在指定0秒延迟后执行,之后每两秒执行一次,此时任务指定时间是大于间隔时间的
                scheduledExecutor.scheduleAtFixedRate(new ThreadRunnable(), 0, 2, TimeUnit.SECONDS);
        }
    }

    class ThreadRunnable implements Runnable{
   

        @Override
        public void run() {
   
            //设定执行时间>间隔时间
            System.out.println("线程:"+Thread.currentThread().getName()+",执行任务时间:"+ LocalDateTime.now());
            try {
   
                Thread.sleep(10000);
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        }
    }


  1. scheduleWithFixedDelay

以给定的间隔去执行任务,当任务的执行时间过长,超过间隔时间后,下一次定时任务的执行会顺延至当前定时任务执行完毕之后.否则严格按照间隔时间去执行.

 public class Task3 {
   
        public static void main(String[] args) throws ExecutionException, InterruptedException {
   
            //创建一个线程池,以JVM可以利用的CPU数为核心线程数,并指定拒绝策略
            ScheduledThreadPoolExecutor scheduledExecutor = new ScheduledThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),
                new RejectedExecutionHandler() {
   
                    @Override
                    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
   
                        System.out.println("当前任务执行失败" + r);
                    }
                });

            // 在指定1秒延迟后执行,之后每两秒执行一次,此时任务指定时间是大于间隔时间的
            scheduledExecutor.scheduleWithFixedDelay(new ThreadRunnable(), 0, 2, TimeUnit.SECONDS);
        }
    }

    class ThreadRunnable implements Runnable{
   

        @Override
        public void run() {
   
            //设定执行时间>间隔时间
            System.out.println("线程:"+Thread.currentThread().getName()+",执行任务时间:"+ LocalDateTime.now());
            try {
   
                Thread.sleep(10000);
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        }
    }


我们通过上面两种方式实现了定时任务,接下来来讲讲我们最常用的 一种方式

  1. 导入依赖
 <dependencies>
 
 <!--         下一节需要用到的定时任务依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>
 
<!--         Spring 官方自带了依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

从上面的方式当中,我们导入 了 下节的依赖和 Spring 官方自带的Task

Spring Task

@EnableScheduling : 我们通过 这个注解开启 定时任务

@EnableAsync : 开启 异步任务多线程执行

# 配置springtask 定时任务相关的配置

spring:
  task:
    scheduling:
      pool:
        size: 10
      thread-name-prefix: hanhan
    execution:
      shutdown:
#        线程关闭时是否等所有任务结束
        await-termination: false
#        线程最大的等待时间,防止线程陷入循环关不掉
        await-termination-period: 10s


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 *  全栈小刘
 */
@EnableScheduling
@EnableAsync
@SpringBootApplication
public class SchduleTestApplication {
   

    public static void main(String[] args) {
   
        SpringApplication.run(SchduleTestApplication.class, args);
    }


    /**
     * 半小时执行一次
     */
    @Async
    @Scheduled(fixedRate = 30 * 60 * 1000)
    public void plySth() {
   
        System.out.println(Thread.currentThread().getName() + "当前线程: \t");
        System.out.println("我是半小时执行一次");
    }

    /**
     * 30 秒
     */

    @Scheduled(fixedRate = 30 * 1000)
    public void plySyHello() {
   
        System.out.println(Thread.currentThread().getName() + "当前线程: \t");
        System.out.println("我是30秒执行一次");
    }

    /**
     * 2 秒
     */
    @Async
    @Scheduled(cron = "0/2 * * * * ? ")
    public void plySyCron() {
   
        System.out.println(Thread.currentThread().getName() + "当前线程: \t");
        System.out.println("我是2秒执行一次");
    }

    /**
     * 30 秒
     */
    @Scheduled(cron = "30 * * * * ? ")
    public void plySyCron43() {
   

        System.out.println("我是30秒执行一次");
    }


    @Bean
    public static void setSchdule() {
   
        TimerTask timerTask = new TimerTask() {
   
            @Override
            public void run() {
   
                System.out.println("setSchdule ---> 每三秒执行一次");
            }
        };

        Timer timer = new Timer();

        timer.schedule(timerTask, 10, 3000);
    }

//
//    @Bean
//    public static void setSchdule2() {
   
//        // 创建一个定时任务
//        ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
//        service.scheduleAtFixedRate(()->System.out.println("task ScheduledExecutorService "+new Date()), 0, 3, TimeUnit.SECONDS);
//    }


}

同时大家可以上面这边 也把 我们原先使用的线程池的方式定时任务 也使用进去 了

只需要将它注入Springboot ,这样 就可以正常使用了

在上面的每一个 被 @Scheduled(fixedRate = 30 * 60 * 1000) 所以修饰的方法都是一条异步任务 ,而当你在方法上加入了 @Async 注解 就说明了 这个方法是支持多线程执行的

    @Async
    @Scheduled(cron = "0/2 * * * * ? ")
    public void plySyCron() {
   
        System.out.println(Thread.currentThread().getName() + "当前线程: \t");
        System.out.println("我是2秒执行一次");
    }

我们注意到了其中有个属性叫做 cron ,这个cron代表的就是 我们可以定时去执行 ,我们可以大概看一下下面的参考,快速学习一下

1

时间表达式

一个cron表达式有至少6个(也可能7个)有空格分隔的时间元素。
按顺序依次为
秒(0~59)
分钟(0~59)
小时(0~23)
天(月)(0~31,但是你需要考虑你月的天数)
月(0~11)
天(星期)(1~7 1=SUN 或 SUN,MON,TUE,WED,THU,FRI,SAT)
年份(1970-2099)


常用的表达式为:

0 0 10,14,16 * * ? 每天上午10点,下午2点,4点
0 0/30 9-17 * * ? 朝九晚五工作时间内每半小时
0 0 12 ? * WED 表示每个星期三中午12点
“0 0 12 * * ?” 每天中午12点触发
“0 15 10 ? * *” 每天上午10:15触发
“0 15 10 * * ?” 每天上午10:15触发
“0 15 10 * * ? *” 每天上午10:15触发
“0 15 10 * * ? 2005” 2005年的每天上午10:15触发
“0 * 14 * * ?” 在每天下午2点到下午2:59期间的每1分钟触发
“0 0/5 14 * * ?” 在每天下午2点到下午2:55期间的每5分钟触发
“0 0/5 14,18 * * ?” 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发
“0 0-5 14 * * ?” 在每天下午2点到下午2:05期间的每1分钟触发
“0 10,44 14 ? 3 WED” 每年三月的星期三的下午2:10和2:44触发
“0 15 10 ? * MON-FRI” 周一至周五的上午10:15触发
“0 15 10 15 * ?” 每月15日上午10:15触发
“0 15 10 L * ?” 每月最后一日的上午10:15触发
“0 15 10 ? * 6L” 每月的最后一个星期五上午10:15触发
“0 15 10 ? * 6L 2002-2005” 2002年至2005年的每月的最后一个星期五上午10:15触发
“0 15 10 ? * 6#3” 每月的第三个星期五上午10:15触发

大家只需要把con= 换成上面的表达式就好了 ,如果费脑子的花

  @Scheduled(cron = "0/2 * * * * ? ")

当然如果 你需要特别定制化的 cron 表达式 ,大家可以通过下面的 网站进行生成

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z99XnSZU-1676120936929)(file://C:\Users\SpiritMark\AppData\Roaming\marktext\images\2023-02-11-19-37-50-image.png)]

cron 网址整理:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IW8FFcsX-1676120936929)(file://C:\Users\SpiritMark\AppData\Roaming\marktext\images\2023-02-11-19-38-25-image.png)]

定时任务整合Springboot

下面这节我们来学习一下如何使用 Springboot 来完成定时任务的整合

在springboot中整合这个技术,我们首先来学习几个词

  • 工作(job):用于执行具体的任务

  • 工作明细(jobDetail):用于定义定时工作的信息

  • 触发器(Trigger):用于描述触发工作的规则,和定义调度通常用Cron来进行定义调度的规则

  • 调度(scheduler):用于描述工作明细和触发器之间的

Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合,也可以单独使用。完全由Java开发,可以用来执行定时任务,类似于java.util.Timer 。但是相较于Timer, Quartz增加了很多功能:

  • 持久性作业 - 就是保持调度定时的状态;
  • 作业管理 - 对调度作业进行有效的管理;

Quartz是开源且具有丰富特性的“任务调度库”,能够集成于任何的Java应用,小到独立的应用,大至电子商业系统。Quartz能够创建亦简单亦复杂的调度,以执行上十、上百,甚至上万的任务。任务job被定义为标准的Java组件,能够执行任何你想要实现的功能。Quartz调度框架包含许多企业级的特性,如JTA事务、集群的支持。

简而言之,Quartz就是基于Java实现的任务调度框架,用于执行你想要执行的任何任务。

在上面引入了一个 spring-boot-starter-quartz 的包, 当然我们也直接把原生的引入进行一样可以去使用

<dependencies>
	<!-- Quartz 核心包-->
    <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz</artifactId>
    </dependency>

	<!-- Quartz 工具包 -->
    <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz-jobs</artifactId>
    </dependency>
</dependencies>

首先我们需要去创建一个配置类 ,专门用来配置我们的 Quartz

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

/**
 * 创建一个定时器
 */
public class TestQuartz extends QuartzJobBean {
   


    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
   
//        System.out.println(context.getJobRunTime());
//        System.out.println("这是我们定时任务、、、、、、");
    }
}

创建好这个 配置类之后,我们可以看到有个 JobExecutionContext 的类, 通过这个类,我们可以用来执行定时任务 ,接下来,我们需要让配置类去加载它

编写一个具体的 任务详情 ,然后通过构造器的构建者模式 去 将他加载进去

SimpleScheduleBuilder 通过这个类我们可以去进行设置 我们的 定时的周期

// 全栈小刘
@Configuration
public class QuartzConfig {
   


    @Bean
    public JobDetail teatQuartzDetail() {
   
        return JobBuilder.newJob(TestQuartz.class).withIdentity("testQuartz").storeDurably().build();
    }

    @Bean
    public Trigger testQuartzTrigger() {
   
        SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule()
                .withIntervalInSeconds(10)  //设置时间周期单位秒
                .repeatForever();
        return TriggerBuilder.newTrigger().forJob(teatQuartzDetail())
                .withIdentity("testQuartz")
                .withSchedule(scheduleBuilder)
                .build();

    }

}

接下来我们启动 Springboot ,可以从这里看到 每隔一段时间启动输出一下

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o8Nh4Rqw-1676120936930)(file://C:\Users\SpiritMark\AppData\Roaming\marktext\images\2023-02-11-20-26-38-image.png)]

当然我们 也可以用这种方式 定一个类

public class Myquartz extends QuartzJobBean {
   
    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
   
        System.out.println("我们是定时任务");
    }
}

再次配置 ,这里重复的配置只是想告诉大家 ,我们实现 定时任务的方式有很多不同的方式例如下面这种

@Configuration
public class QuartzConfig {
   
@Bean
    public JobDetail jobDetail(){
   
        //在这里工作明细要绑定一个job
        //现在这个工作就完成了这里必须要加上storeDurably,这个作用是当这个任务没有被执行也会一直存在保持持久化

    return JobBuilder.newJob(Myquartz.class).storeDurably().build();

    }
    @Bean
    public Trigger trigger(){
   

    //这里触发器要绑定一个工作明细JobDetail 同时要完成调度
       //这里要说明一下withSchedule是完成调度的下面这行代码是实现时间调度的要
//要说明一下0 0 0 0 0 0,分别代表 秒 分 时 日 月 星期 其中日 和星期会有冲突通常我们都只配一个 另一个用?代替
        //ScheduleBuilder<? extends Trigger> schdule=CronScheduleBuilder.cronSchedule("0 0 0 0 0 0") ;
        //如CronScheduleBuilder.cronSchedule("0 0 0 1 2 ?")这就代表了2月的第一天0秒0分0时 我们还可以配*代表任意 ;
        //还可以如CronScheduleBuilder.cronSchedule("0/15 * * * * ?")代表没个15秒执行一次
        ScheduleBuilder schdule=CronScheduleBuilder.cronSchedule("0/5 * * * * ?") ;
        //forJob就时绑定工作明细
        return TriggerBuilder.newTrigger().forJob(jobDetail()).withSchedule(schdule).build();
    }


}

我们再来设置定义一个 任务

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rA90e7zq-1676120936930)(file://C:\Users\SpiritMark\AppData\Roaming\marktext\images\2023-02-11-20-51-59-image.png)]

// 定义任务类
public class HelloJob implements Job {
   

   @Override
    public void execute(JobExecutionContext arg0) throws JobExecutionException {
   
        // 输出当前时间
        ystem.out.println(new Date());
    }
}

(2)创建任务调度类HelloSchedulerDemo

通过调度器去加载 我们的任务 ,在通过 触发器去触发

public class HelloSchedulerDemo {
   

    public static void main(String[] args) throws Exception {
   
        // 1、调度器(Scheduler),从工厂中获取调度的实例(默认:实例化new StdSchedulerFactory();)
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        // 2、任务实例(JobDetail)定义一个任务调度实例,将该实例与HelloJob绑定,任务类需要实现Job接口
        JobDetail jobDetail = JobBuilder.newJob() // 加载任务类,与HelloJob完成绑定,要求HelloJob实现Job接口
                .withIdentity("job1", "group1") // 参数1:任务的名称(唯一实例);参数2:任务组的名称
                .build();

        // 3、触发器(Trigger)定义触发器,马上执行,然后每5秒重复执行一次
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1") // 参数1:触发器的名称(唯一实例);参数2:触发器组的名称
                .startNow() // 马上启动触发器
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).repeatForever()) // 每2秒重复执行一次
                .build();

        // 4、让调度器关联任务和触发器,保证按照触发器定义的调整执行任务
        scheduler.scheduleJob(jobDetail, trigger);

        // 5、启动
        scheduler.start();
        // 关闭
        //scheduler.shutdown();
    }

}

关键信息:

  • Job:工作任务调度的接口,任务需要实现该接口。该接口中定义execute方法,类似JDK提供的TimeTask类的run方法。在里面编写任务执行的业务逻辑。
  • Job实例在Quartz中的生命周期:每次调度器执行Job时,它在调用execute方法前会创建一个新的 Job 实例,当调用完成后,关联的Job对象实例会被释放,释放的实例会被垃圾回收机制回收。
  • JobDetail:JobDetail为Job实例提供了许多设置属性,以及JobDataMap成员变量属性,它用来存储特定Job实例的状态信息,调度器需要借助JobDetail对象来添加Job实例。
  • JobDetail重要属性:namegroupjobClassJobDataMap
JobDetail job = JobBuilder.newJob(HelloJob.class)
        .withIdentity("job1", "group1") // 定义该实例唯一标识,并指定一个组
        .build();

System.out.println("name:" +job.getKey().getName());
System.out.println("group:" +job.getKey().getGroup());
System.out.println("jobClass:" +job.getJobClass().getName());

JobExecutionContext

  • 当 Scheduler 调用一个 Job,就会将 JobExecutionContext 传递给 Job 的 execute() 方法;
  • Job 能通过 JobExecutionContext 对象访问到 Quartz 运行时候的环境以及 Job 本身的明细数据。
public class HelloJob implements Job {
   
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
   

        Trigger trigger = jobExecutionContext.getTrigger(); //获取Trigger
        JobDetail jobDetail = jobExecutionContext.getJobDetail(); //获取JobDetail
        Scheduler scheduler = jobExecutionContext.getScheduler(); //获取Scheduler

        trigger.getKey().getName(); //获取Trigger名字
        trigger.getKey().getGroup(); //获取Trigger组名(默认为 DEFAULT)

        jobExecutionContext.getScheduledFireTime(); //触发器触发的预定时间。
        jobExecutionContext.getFireTime(); //实际触发时间。例如,计划时间可能是 10:00:00,但如果调度程序太忙,实际触发时间可能是 10:00:03。
        jobExecutionContext.getPreviousFireTime(); //上次触发时间
        jobExecutionContext.getNextFireTime(); //下次触发时间

        System.out.println(new Date());
    }
}

JobDataMap

  • 使用 Map进行获取

  • 在进行任务调度时,JobDataMap 存储在 JobExecutionContext 中,非常方便获取。

  • JobDataMap 可以用来装载任何可序列化的数据对象,当 Job 实例对象被执行时这些参数对象会传递给它。

  • JobDataMap 实现了 JDK 的 Map 接口,并且添加了非常方便的方法用来存取基本数据类型。

在定义 Trigger 或者 JobDetail 时,将 JobDataMap 传入,然后 Job 中便可以获取到 JobDataMap 中的参数

public class HelloScheduler {
   
    public static void main(String[] args) throws SchedulerException {
   
        //1. 调度器(Scheduler)
        Scheduler defaultScheduler = StdSchedulerFactory.getDefaultScheduler();
		
		JobDataMap jobDataMap2 = new JobDataMap();
        jobDataMap2.put("message", "JobDetailMessage");

        //2. 任务实例(JobDetail)
        JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
                .withIdentity("job1", "jobGroup1")
                .usingJobData(jobDataMap2)
                .build();

		// 定义 JobDataMap
        JobDataMap jobDataMap = new JobDataMap();
        jobDataMap.put("message", "TriggerMessage");

        //3. 触发器(Trigger)
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "triggerGroup1")
                .startNow()
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).repeatForever())
                .endAt(new Date(new Date().getTime() + 3000L))
                .usingJobData(jobDataMap) // 将 JobDataMap 放入 Trigger 中
                .build();

        defaultScheduler.scheduleJob(jobDetail, trigger);
        defaultScheduler.start();
    }
}

HelloJob.java

public class HelloJob implements Job {
   
    @Override
    public void execute(JobExecutionContext jobExecutionContext) hrows JobExecutionException {
   
    	System.out.println(jobExecutionContext.getTrigger().getJobDataMap().get("message")); //TriggerMessage
        System.out.println(jobExecutionContext.getJobDetail().getJobDataMap().get("message")); //JobDetailMessage

        System.out.println(jobExecutionContext.getMergedJobDataMap().get("message")); //TriggerMessage
        System.out.println(new Date());
    }
}

使用 Setter 方法获取

Job实现类中添加setter方法对应JobDataMap的键值,Quartz框架默认的JobFactory实现类在初始化Job实例对象时会自动调用这些setter方法。

HelloScheduler 类和上面一样。

@Data
public class HelloJob implements Job {
   

    private String mesage;

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
   
        System.out.println(message); //TriggerMessage
        System.out.println(new Date());
    }
}

*注意:如果遇到同名的 keyTriggerJobDataMap 的值会覆盖 JobDetailJobDataMap 同名的 Key

更多具体的细节 大家可以关注 :

使用 Quartz_w3cschool


转载:https://blog.csdn.net/qq_42897427/article/details/128989172
查看评论
* 以上用户言论只代表其个人观点,不代表本网站的观点或立场