双峰网站建设,个人域名推荐,wordpress关于本站,网页前端设计流程Java 定时任务学习
定时任务概述 定时任务的应用场景非常广泛, 如果说 我们想要在某时某地去尝试的做某件事 就需要用到定时任务来通知我们 #xff0c;大家可以看下面例子 如果需要明天 早起#xff0c;哪我们一般会去定一个闹钟去通知我们, 而在编程中 有许许多多的…Java 定时任务学习
定时任务概述 定时任务的应用场景非常广泛, 如果说 我们想要在某时某地去尝试的做某件事 就需要用到定时任务来通知我们 大家可以看下面例子 如果需要明天 早起哪我们一般会去定一个闹钟去通知我们, 而在编程中 有许许多多的场景就需要用到类似的功能 例如我们的花呗借款之后她需要提示你一个还款日期 、又或者 当我们购物下单之后 它需要会在一定的时间内去通知 你支付 这些个 需要用到 具体 时间通知倒计时的 场景 在 Java中 我们如果想实现最简单的定时任务我们正常的思路应该是这样的去创建一个线程 举例我们借款后需要在30秒内还款我们调用了下面的方法当然只是为了举例业务场景并不严谨只是为了演示 我们之后了他会停顿30 秒 等待你下单完毕
而你如果点击取消借款 哪我们就使用Thread.stop() 关闭掉了 线程
// 下单后调用还花呗 方法Testpublic 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 {Testvoid contextLoads() {// 3. 创建一个定时任务TimerTask timerTask new TimerTask() {Overridepublic 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自带的类使用简单缺点是该方案仅适用于单机环境。
我们可以 来过一下它的方法
: scheduleAtFixedRate
以给定的间隔去执行任务,当任务的执行时间过长,超过间隔时间后,下一次定时任务的执行会顺延至当前定时任务执行完毕之后.否则严格按照间隔时间去执行. */public class Task2 {public static void main(String[] args) throws ExecutionException, InterruptedException {//创建一个线程池,以JVM可以利用的CPU数为核心线程数,并指定拒绝策略ScheduledThreadPoolExecutor scheduledExecutor new ScheduledThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),new RejectedExecutionHandler() {Overridepublic void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {System.out.println(当前任务执行失败 r);}});// 在指定0秒延迟后执行,之后每两秒执行一次,此时任务指定时间是大于间隔时间的scheduledExecutor.scheduleAtFixedRate(new ThreadRunnable(), 0, 2, TimeUnit.SECONDS);}}class ThreadRunnable implements Runnable{Overridepublic void run() {//设定执行时间间隔时间System.out.println(线程:Thread.currentThread().getName(),执行任务时间: LocalDateTime.now());try {Thread.sleep(10000);} catch (InterruptedException e) {e.printStackTrace();}}}
scheduleWithFixedDelay
以给定的间隔去执行任务,当任务的执行时间过长,超过间隔时间后,下一次定时任务的执行会顺延至当前定时任务执行完毕之后.否则严格按照间隔时间去执行. public class Task3 {public static void main(String[] args) throws ExecutionException, InterruptedException {//创建一个线程池,以JVM可以利用的CPU数为核心线程数,并指定拒绝策略ScheduledThreadPoolExecutor scheduledExecutor new ScheduledThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),new RejectedExecutionHandler() {Overridepublic void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {System.out.println(当前任务执行失败 r);}});// 在指定1秒延迟后执行,之后每两秒执行一次,此时任务指定时间是大于间隔时间的scheduledExecutor.scheduleWithFixedDelay(new ThreadRunnable(), 0, 2, TimeUnit.SECONDS);}}class ThreadRunnable implements Runnable{Overridepublic void run() {//设定执行时间间隔时间System.out.println(线程:Thread.currentThread().getName(),执行任务时间: LocalDateTime.now());try {Thread.sleep(10000);} catch (InterruptedException e) {e.printStackTrace();}}}
我们通过上面两种方式实现了定时任务,接下来来讲讲我们最常用的 一种方式
导入依赖 dependencies!-- 下一节需要用到的定时任务依赖--dependencygroupIdorg.springframework.boot/groupIdartifactIdspring-boot-starter-quartz/artifactId/dependency!-- Spring 官方自带了依赖--dependencygroupIdorg.springframework.boot/groupIdartifactIdspring-boot-starter-web/artifactId/dependencydependencygroupIdorg.projectlombok/groupIdartifactIdlombok/artifactIdoptionaltrue/optional/dependencydependencygroupIdorg.springframework.boot/groupIdartifactIdspring-boot-starter-test/artifactIdscopetest/scope/dependency/dependencies从上面的方式当中我们导入 了 下节的依赖和 Spring 官方自带的Task
Spring Task EnableScheduling : 我们通过 这个注解开启 定时任务 EnableAsync : 开启 异步任务多线程执行 # 配置springtask 定时任务相关的配置spring:task:scheduling:pool:size: 10thread-name-prefix: hanhanexecution: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);}/*** 半小时执行一次*/AsyncScheduled(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 秒*/AsyncScheduled(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秒执行一次);}Beanpublic static void setSchdule() {TimerTask timerTask new TimerTask() {Overridepublic 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 注解 就说明了 这个方法是支持多线程执行的 AsyncScheduled(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 1SUN 或 SUNMONTUEWEDTHUFRISAT 年份19702099 常用的表达式为: 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)] https://cron.qqe2.com/ https://www.pppet.net/ Cron表达式生成器_quartz、Cron等在线生成执行时间 定时任务整合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实现的任务调度框架用于执行你想要执行的任何任务。 官方网址www.quartz-scheduler.org/ 官方文档www.quartz-scheduler.org/documenta
在上面引入了一个 spring-boot-starter-quartz 的包 当然我们也直接把原生的引入进行一样可以去使用
dependencies!-- Quartz 核心包--dependencygroupIdorg.quartz-scheduler/groupIdartifactIdquartz/artifactId/dependency!-- Quartz 工具包 --dependencygroupIdorg.quartz-scheduler/groupIdartifactIdquartz-jobs/artifactId/dependency
/dependencies
首先我们需要去创建一个配置类 专门用来配置我们的 Quartz
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;/*** 创建一个定时器*/
public class TestQuartz extends QuartzJobBean {Overrideprotected void executeInternal(JobExecutionContext context) throws JobExecutionException {
// System.out.println(context.getJobRunTime());
// System.out.println(这是我们定时任务、、、、、、);}
}
创建好这个 配置类之后我们可以看到有个 JobExecutionContext 的类 通过这个类我们可以用来执行定时任务 接下来我们需要让配置类去加载它
编写一个具体的 任务详情 然后通过构造器的构建者模式 去 将他加载进去
SimpleScheduleBuilder 通过这个类我们可以去进行设置 我们的 定时的周期
// 全栈小刘
Configuration
public class QuartzConfig {Beanpublic JobDetail teatQuartzDetail() {return JobBuilder.newJob(TestQuartz.class).withIdentity(testQuartz).storeDurably().build();}Beanpublic 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 {Overrideprotected void executeInternal(JobExecutionContext context) throws JobExecutionException {System.out.println(我们是定时任务);}
}
再次配置 这里重复的配置只是想告诉大家 我们实现 定时任务的方式有很多不同的方式例如下面这种
Configuration
public class QuartzConfig {
Beanpublic JobDetail jobDetail(){//在这里工作明细要绑定一个job//现在这个工作就完成了这里必须要加上storeDurably,这个作用是当这个任务没有被执行也会一直存在保持持久化return JobBuilder.newJob(Myquartz.class).storeDurably().build();}Beanpublic Trigger trigger(){//这里触发器要绑定一个工作明细JobDetail 同时要完成调度//这里要说明一下withSchedule是完成调度的下面这行代码是实现时间调度的要
//要说明一下0 0 0 0 0 0分别代表 秒 分 时 日 月 星期 其中日 和星期会有冲突通常我们都只配一个 另一个用代替//ScheduleBuilder? extends Trigger schduleCronScheduleBuilder.cronSchedule(0 0 0 0 0 0) ;//如CronScheduleBuilder.cronSchedule(0 0 0 1 2 )这就代表了2月的第一天0秒0分0时 我们还可以配*代表任意 ;//还可以如CronScheduleBuilder.cronSchedule(0/15 * * * * )代表没个15秒执行一次ScheduleBuilder schduleCronScheduleBuilder.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 {Overridepublic 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对象实例会被释放释放的实例会被垃圾回收机制回收。JobDetailJobDetail为Job实例提供了许多设置属性以及JobDataMap成员变量属性它用来存储特定Job实例的状态信息调度器需要借助JobDetail对象来添加Job实例。JobDetail重要属性name、group、jobClass、JobDataMap
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 {Overridepublic void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {Trigger trigger jobExecutionContext.getTrigger(); //获取TriggerJobDetail jobDetail jobExecutionContext.getJobDetail(); //获取JobDetailScheduler scheduler jobExecutionContext.getScheduler(); //获取Schedulertrigger.getKey().getName(); //获取Trigger名字trigger.getKey().getGroup(); //获取Trigger组名默认为 DEFAULTjobExecutionContext.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. 调度器SchedulerScheduler defaultScheduler StdSchedulerFactory.getDefaultScheduler();JobDataMap jobDataMap2 new JobDataMap();jobDataMap2.put(message, JobDetailMessage);//2. 任务实例JobDetailJobDetail jobDetail JobBuilder.newJob(HelloJob.class).withIdentity(job1, jobGroup1).usingJobData(jobDataMap2).build();// 定义 JobDataMapJobDataMap jobDataMap new JobDataMap();jobDataMap.put(message, TriggerMessage);//3. 触发器TriggerTrigger 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 {Overridepublic void execute(JobExecutionContext jobExecutionContext) hrows JobExecutionException {System.out.println(jobExecutionContext.getTrigger().getJobDataMap().get(message)); //TriggerMessageSystem.out.println(jobExecutionContext.getJobDetail().getJobDataMap().get(message)); //JobDetailMessageSystem.out.println(jobExecutionContext.getMergedJobDataMap().get(message)); //TriggerMessageSystem.out.println(new Date());}
}使用 Setter 方法获取
Job实现类中添加setter方法对应JobDataMap的键值Quartz框架默认的JobFactory实现类在初始化Job实例对象时会自动调用这些setter方法。
HelloScheduler 类和上面一样。
Data
public class HelloJob implements Job {private String mesage;Overridepublic void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {System.out.println(message); //TriggerMessageSystem.out.println(new Date());}
}*注意如果遇到同名的 keyTrigger 中 JobDataMap 的值会覆盖 JobDetail 中 JobDataMap 同名的 Key
更多具体的细节 大家可以关注 :
使用 Quartz_w3cschool
