Springboot Quartz定时任务的动态调度使用，实战详解

于 2024-05-07 15:34:37 发布
阅读量316 收藏 10
点赞数 4
分类专栏： 程序员 文章标签： spring boot 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84049061/article/details/138534260
版权

return cronExpression;

}

public void setCronExpression(String cronExpression) {

this.cronExpression = cronExpression;

}

public String getJobName() {

return jobName;

}

public void setJobName(String jobName) {

this.jobName = jobName;

}

public String getJobGroup() {

return jobGroup;

}

public void setJobGroup(String jobGroup) {

this.jobGroup = jobGroup;

}

public String getTriggerName() {

return triggerName;

}

public void setTriggerName(String triggerName) {

this.triggerName = triggerName;

}

public String getTriggerGroup() {

return triggerGroup;

}

public void setTriggerGroup(String triggerGroup) {

this.triggerGroup = triggerGroup;

}

public String getDescription() {

return description;

}

public void setDescription(String description) {

this.description = description;

}

public JSONObject getData() {

return data;

}

public void setData(JSONObject data) {

this.data = data;

}

public Boolean getPauseStatus() {

return pauseStatus;

}

public void setPauseStatus(Boolean pauseStatus) {

this.pauseStatus = pauseStatus;

}

public Boolean getDeleteStatus() {

return deleteStatus;

}

public void setDeleteStatus(Boolean deleteStatus) {

this.deleteStatus = deleteStatus;

}

public Date getCreateTime() {

return createTime;

}

public void setCreateTime(Date createTime) {

this.createTime = createTime;

}

public Date getUpdateTime() {

return updateTime;

}

public void setUpdateTime(Date updateTime) {

this.updateTime = updateTime;

}

}

创建JobFactory.java （job实例工厂）：

import org.quartz.spi.TriggerFiredBundle;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.config.AutowireCapableBeanFactory;

import org.springframework.scheduling.quartz.AdaptableJobFactory;

import org.springframework.stereotype.Component;

/**

  • @Author : JCccc

  • @CreateTime : 2020/3/21

  • @Description : 创建job实例工厂,使用默认的也许会出现spring的@Autowired 无法注入问题

**/

@Component

public class JobFactory extends AdaptableJobFactory {

@Autowired

private AutowireCapableBeanFactory beanFactory;

@Override

protected Object createJobInstance(TriggerFiredBundle bundle)

throws Exception {

Object jobInstance = super.createJobInstance(bundle);

//Job实例注入到Job工厂

beanFactory.autowireBean(jobInstance);

return jobInstance;

}

}

创建QuartzConfig.java （一些属性配置项）：

import org.quartz.Scheduler;

import org.quartz.ee.servlet.QuartzInitializerListener;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.config.PropertiesFactoryBean;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import java.io.IOException;

import java.util.Properties;

/**

  • @Author : JCccc

  • @CreateTime : 2020/3/21

  • @Description : 调度工厂,线程池属性等等配置

**/

@Configuration

public class QuartzConfig {

@Autowired

private JobFactory jobFactory;

/**

  • 调度类FactoryBean

  • @return

  • @throws IOException

*/

@Bean(“schedulerFactory”)

public SchedulerFactoryBean schedulerFactoryBean() throws IOException {

SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();

//设置调度类quartz属性

schedulerFactoryBean.setQuartzProperties(quartzProperties());

//设置jobFactory

schedulerFactoryBean.setJobFactory(jobFactory);

return schedulerFactoryBean;

}

/**

  • 解析quartz.properties文件，填充属性

  • @return

  • @throws IOException

*/

@Bean

public Properties quartzProperties() throws IOException{

PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();

//若不做额外配置,会有默认的配置文件加载 在jar org.quartz里面 有一份quartz.properties

//propertiesFactoryBean.setLocation(new ClassPathResource(“/quartz.properties”));

propertiesFactoryBean.afterPropertiesSet();

return propertiesFactoryBean.getObject();

}

/**

  • quartz初始化监听器

  • @return

*/

@Bean

public QuartzInitializerListener initializerListener(){

return new QuartzInitializerListener();

}

/**

  • 根据调度类工厂bean获取调度

  • @return

  • @throws IOException

*/

@Bean(“scheduler”)

public Scheduler scheduler() throws IOException{

return schedulerFactoryBean().getScheduler();

}

}

ps：这里的配置项，特别是关于quartz的配置项，可以自己去写配置文件配置，但是该篇就使用默认的就够，默认的是jar包自己提供的：

简单瞅一眼：

相关参数什么作用，不懂的对着英文查询翻译即可，该篇不做展开。

接着，咱们实现一个调度方法类，类似于我们使用别的框架的Template一样。

新建QuartzService.java：

import com.alibaba.fastjson.JSONObject;

import com.bsapple.vshop.quartz.config.JobEntity;

/**

  • @Author : JCccc

  • @CreateTime : 2020/3/21

  • @Description :

**/

public interface QuartzService {

/**

  • 创建Job

  • @param job

*/

Boolean addJob(JobEntity job);

/**

  • 执行Job

  • @param job

*/

Boolean runJob(JobEntity job);

/**

  • 修改Job

  • @param job

*/

Boolean updateJob(JobEntity job);

/**

  • 暂定Job

  • @param job

*/

Boolean pauseJob(JobEntity job);

/**

  • 唤醒Job

  • @param job

*/

Boolean resumeJob(JobEntity job);

/**

  • 删除Job

  • @param job

*/

Boolean deleteJob(JobEntity job);

/**

  • 获取Job

  • @param job

*/

JSONObject queryJob(JobEntity job);

}

对应的impl，QuartzServiceImpl.java：

import com.alibaba.fastjson.JSONObject;

import com.bsapple.vshop.quartz.config.JobEntity;

import org.quartz.*;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.stereotype.Service;

/**

  • @Author : JCccc

  • @CreateTime : 2020/3/21

  • @Description :

**/

@Service

public class QuartzServiceImpl implements QuartzService {

private static Logger log = LoggerFactory.getLogger(QuartzServiceImpl.class);

@Autowired

@Qualifier(“scheduler”)

private Scheduler scheduler;

@Override

public Boolean addJob(JobEntity job) {

try {

JSONObject data = job.getData();

log.info(“当前任务携带的业务参数={}”, data.toJSONString());

JobDataMap jobDataMap = new JobDataMap();

jobDataMap.put(“myValue”, data);

String jobId = job.getJobId();

String jobName = job.getJobName();

String jobUnique = jobId + jobName;

JobDetail jobDetail = JobBuilder

.newJob((Class<? extends Job>) Class.forName(job.getClassName()))

// 指定执行类

.withIdentity(jobUnique, job.getJobGroup())

// 指定name和group

.requestRecovery().withDescription(job.getDescription())

.setJobData(jobDataMap)

.build();

// 创建表达式调度构建器

CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder

.cronSchedule(job.getCronExpression());

// 创建触发器

CronTrigger cronTrigger = TriggerBuilder.newTrigger()

.withIdentity(job.getTriggerName(), job.getTriggerGroup())

.withDescription(job.getDescription())

.withSchedule(cronScheduleBuilder).build();

scheduler.scheduleJob(jobDetail, cronTrigger);

scheduler.start();

log.info(“定时任务[{}]创建成功,开始执行”, jobId + jobName);

return true;

} catch (Exception e) {

e.printStackTrace();

}

return false;

}

@Override

public Boolean runJob(JobEntity job) {

try {

String jobId = job.getJobId();

String jobName = job.getJobName();

String jobUnique = jobId + jobName;

scheduler.triggerJob(JobKey.jobKey(jobUnique,

job.getJobGroup()));

log.info(“定时任务[{}]执行成功”, jobUnique);

return true;

} catch (Exception e) {

e.printStackTrace();

}

return false;

}

@Override

public Boolean updateJob(JobEntity job) {

try {

String jobId = job.getJobId();

String jobName = job.getJobName();

String jobUnique = jobId + jobName;

TriggerKey triggerKey = new TriggerKey(job.getTriggerName(),

job.getTriggerGroup());

CronTrigger cronTrigger = (CronTrigger) scheduler

.getTrigger(triggerKey);

CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder

.cronSchedule(job.getCronExpression());

// 重新构件表达式

CronTrigger trigger = cronTrigger.getTriggerBuilder()

.withIdentity(triggerKey).withSchedule(cronScheduleBuilder)

.withDescription(job.getDescription())

.build();

scheduler.rescheduleJob(triggerKey, trigger);

log.info(“定时任务[{}]更新成功”, jobUnique);

return true;

} catch (Exception e) {

e.printStackTrace();

}

return false;

}

@Override

public Boolean pauseJob(JobEntity job) {

try {

String jobId = job.getJobId();

String jobName = job.getJobName();

String jobUnique = jobId + jobName;

scheduler.pauseJob(JobKey.jobKey(jobUnique,

job.getJobGroup()));

log.info(“定时任务[{}]暂停成功”, jobUnique);

return true;

} catch (Exception e) {

e.printStackTrace();

}

return false;

}

@Override

public Boolean resumeJob(JobEntity job) {

try {

String jobId = job.getJobId();

String jobName = job.getJobName();

String jobUnique = jobId + jobName;

scheduler.resumeJob(JobKey.jobKey(jobUnique,

job.getJobGroup()));

log.info(“定时任务[{}]唤醒成功”, jobUnique);

return true;

} catch (Exception e) {

e.printStackTrace();

}

return false;

}

@Override

public Boolean deleteJob(JobEntity job) {

try {

String jobId = job.getJobId();

String jobName = job.getJobName();

String jobUnique = jobId + jobName;

scheduler.deleteJob(JobKey.jobKey(jobUnique, job.getJobGroup()));

log.info(“定时任务[{}]删除成功”, jobUnique);

return true;

} catch (Exception e) {

e.printStackTrace();

}

return false;

}

@Override

public JSONObject queryJob(JobEntity job) {

TriggerKey triggerKey = new TriggerKey(job.getTriggerName(),

job.getTriggerGroup());

try {

CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);

if (null == cronTrigger) {

return null;

}

JSONObject jsonObject = new JSONObject();

jsonObject.put(“expression”, cronTrigger.getCronExpression());

jsonObject.put(“state”, scheduler.getTriggerState(triggerKey));

jsonObject.put(“description”, cronTrigger.getDescription());

return jsonObject;

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

}

到这，其实动态的调度定时任务条件，我们都已经准备充分了。

接下来是使用环节：

1.随着项目启动就启动的定时任务

之所以能随着项目启动就跟着启动，那么显然，就跟监听项目启动有关系。

创建MyJobAuto.java ，继承job，做为定时任务示例：

/**

  • @Author : JCccc

  • @CreateTime : 2020/3/21

  • @Description :

**/

import com.alibaba.fastjson.JSONObject;

import org.quartz.Job;

import org.quartz.JobDataMap;

import org.quartz.JobExecutionContext;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

@Component

public class MyJobAuto implements Job {

private static Logger log = LoggerFactory.getLogger(MyJobAuto.class);

private void before() {

log.info(“MyJobAuto任务开始执行”);

}

@Override

public void execute(JobExecutionContext context) {

before();

//定时任务处理的业务逻辑

//…

//…

String name = context.getJobDetail().getKey().getName();

log.info(“MyJobAuto任务[{}]正在执行”,name);

JobDataMap jobDataMap=context.getJobDetail().getJobDataMap();

JSONObject jsonObject = (JSONObject) jobDataMap.get(“myValue”);

log.info(“MyJobAuto任务[{}]携带的参数[{}]”,name,jsonObject.toString());

String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern(“yyyy-MM-dd HH:mm:ss”));

log.info(“当前时间[{}],MyJobAuto任务[{}]的线程名[{}]”,time,name,Thread.currentThread().getName());

after();

}

private void after() {

log.info(“MyJobAuto任务执行结束”);

}

}

然后是项目启动监听器，创建ApplicationStartListener.java：

import com.alibaba.fastjson.JSONObject;

import com.bsapple.vshop.quartz.config.JobEntity;

import com.bsapple.vshop.quartz.jobManage.QuartzService;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.ApplicationListener;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.event.ContextRefreshedEvent;

import java.util.UUID;

/**

  • @Author : JCccc

  • @CreateTime : 2020/3/21

  • @Description :

**/

@Configuration

public class ApplicationStartListener implements ApplicationListener {

private static Logger log = LoggerFactory.getLogger(ApplicationStartListener.class);

@Autowired

private QuartzService quartzService;

@Override

public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {

JobEntity job=new JobEntity();

job.setJobId(UUID.randomUUID().toString().replaceAll(“-”,“”));

job.setClassName(“com.bsapple.vshop.quartz.taskJob.MyJobAuto”);//注意,这里的路径请改成你自己的

job.setCronExpression(“0/3 * * * * ?”);

job.setJobName(“AutoJob”);

job.setJobGroup(“AutoJobGroup”);

job.setTriggerName(“AutoJobTrigger”);

job.setTriggerGroup(“AutoJobTriggerGroup”);

job.setDescription(“AutoJob-随项目启动”);

//可以将任务跟数据库挂钩,做个任务管理模块,获取需要自启动的任务,记录各个参数等

JSONObject jsonObject=new JSONObject();

jsonObject.put(“testKey”,“测试即启动”);

job.setData(jsonObject);

quartzService.addJob(job);

log.info(“即触发定时任务已经开始执行… .”);

log.info(“application已经启动完毕”);

}

}

事不宜迟，先把项目启动起来看看效果，成功执行，根据cron表达式，3秒一次：

再看一眼线程名里面，可以看到quartz加载了默认配置，线程数量10：

2.动态调度定时任务

我们在前面已经把调度方法的模版已经写了，那么实现调度场景就非常简单了。

创建QuartzController.java：

import com.alibaba.fastjson.JSONObject;

import com.bsapple.vshop.quartz.config.JobEntity;

import com.bsapple.vshop.quartz.jobManage.QuartzService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.*;

/**

  • @Author : JCccc

  • @CreateTime : 2020/3/21

  • @Description :

**/

@RestController

@RequestMapping(“/quartz”)

public class QuartzController {

@Autowired

private QuartzService quartzService;

@PostMapping(“/add”)

public String addJob(@RequestBody JobEntity job) {

Boolean result = quartzService.addJob(job);

if (!result) {

return “创建定时任务失败”;

}

return “创建定时任务成功:”+job.getJobId()+job.getJobName();

}

@PostMapping(“/run”)

public String runJob(@RequestBody JobEntity job) {

Boolean result = quartzService.runJob(job);

if (!result) {

return “启动定时任务失败”;

}

return “启动定时任务成功:”+job.getJobId()+job.getJobName();

}

@PostMapping(“/update”)

public String updateJob(@RequestBody JobEntity job) {

Boolean result = quartzService.updateJob(job);

if (!result) {

return “修改定时任务失败”;

}

return “修改定时任务成功:”+job.getJobId()+job.getJobName();

}

@PostMapping(“/pause”)

public String pauseJob(@RequestBody JobEntity job) {

Boolean result = quartzService.pauseJob(job);

if (!result) {

return “暂停定时任务失败”;

}

return “暂停定时任务成功:”+job.getJobId()+job.getJobName();

}

@PostMapping(“/resume”)

public String resumeJob(@RequestBody JobEntity job) {

Boolean result = quartzService.resumeJob(job);

if (!result) {

return “唤醒定时任务失败”;

}

return “唤醒定时任务成功:”+job.getJobId()+job.getJobName();

}

@PostMapping(“/delete”)

public String deleteJob(@RequestBody JobEntity job) {

Boolean result = quartzService.deleteJob(job);

if (!result) {

return “删除定时任务失败”;

}

return “删除定时任务成功:”+job.getJobId()+job.getJobName();

}

@GetMapping(“/query”)

public String queryJob(@RequestBody JobEntity job) {

JSONObject result = quartzService.queryJob(job);

if (null == result) {

return “不存在对应的任务:”+job.getJobId()+job.getJobName();

}

return result.toString();

}

}

简单写两个定时任务，模拟多定时任务调度处理不同业务：

MyJobFirst.java：

/**

  • @Author : JCccc

  • @CreateTime : 2020/3/21

  • @Description :

**/

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import com.alibaba.fastjson.JSONObject;

import org.quartz.Job;

import org.quartz.JobDataMap;

import org.quartz.JobExecutionContext;

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
teJob(job);

if (!result) {

return “删除定时任务失败”;

}

return “删除定时任务成功:”+job.getJobId()+job.getJobName();

}

@GetMapping(“/query”)

public String queryJob(@RequestBody JobEntity job) {

JSONObject result = quartzService.queryJob(job);

if (null == result) {

return “不存在对应的任务:”+job.getJobId()+job.getJobName();

}

return result.toString();

}

}

简单写两个定时任务，模拟多定时任务调度处理不同业务：

MyJobFirst.java：

/**

  • @Author : JCccc

  • @CreateTime : 2020/3/21

  • @Description :

**/

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import com.alibaba.fastjson.JSONObject;

import org.quartz.Job;

import org.quartz.JobDataMap;

import org.quartz.JobExecutionContext;

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-AZIgr8lz-1715067265158)]

[外链图片转存中…(img-EJ4RBnl8-1715067265159)]

[外链图片转存中…(img-bvnIp1jL-1715067265159)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

2401_84049061
关注
  • 4
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot Quartz定时任务的动态调度使用，实战详解，java教学管理系统的实现技术
m0_54865014的博客
12-19 716
private Date updateTime; //更新时间 @Override public String toString() { return “JobEntity{” + “jobId=’” + jobId + ‘’’ + “, className=’” + className + ‘’’ + “, cronExpression=’” + cronExpression + ‘’’ + “, jobName=’” + jobName + ‘’’ + “, jobGroup=’” + jobGroup
Springboot Quartz定时任务的动态调度使用，实战详解(1)
最新发布
A1867350的博客
04-17 698
外链图片转存中…(img-GmIlretJ-1713306734256)][外链图片转存中…(img-LgY1JA9V-1713306734257)][外链图片转存中…(img-6pJe9KxJ-1713306734257)]
SpringBoot集成Quartz实现动态定时任务
微微~
05-19 2168
一、Quartz 简介 Quartz 是 OpenSymphony 开源组织在 Job Scheduling 领域又一个开源项目，是完全由 Java 开发的一个开源任务日程管理系统，“任务进度管理器”就是一个在预先确定（被纳入日程）的时间到达时，负责执行（或者通知）其他软件组件的系统。 Quartz 是一个开源的作业调度框架，它完全由 Java 写成，并设计用于 J2SE 和 J2EE 应用中，它提供了巨大的灵活性而不牺牲简单性 当定时任务愈加复杂时，使用 Spring 注解 @Schedule 已经不能满
SpringBoot Quartz 动态定时任务
qq_22074337的博客
06-08 1979
SpringBoot Quartz 动态定时任务
Springboot2-Quartz 后台可动态配置的定时任务
02-28
本项目“Springboot2-Quartz 后台可动态配置的定时任务”是基于SpringBoot 2.x版本与Quartz Scheduler整合的一个示例，它展示了如何在后台管理系统中动态地创建、更新和删除定时任务，以及监控这些任务的状态，为...
SpringBoot整合Quartz任务定时调度
06-08
本篇文章将详细探讨如何在Spring Boot项目中整合Quartz实现任务定时调度。 首先，我们需要理解Spring Boot与Quartz的整合基础。Spring Boot简化了Quartz的集成过程，我们可以通过添加相应的依赖来引入Quartz。在`...
springboot+quartz实现动态定时任务调度
12-08
基于SpringBoot+Quartz实现动态任务调度，可作为单独模块镶嵌到项目中，同时还支持多数据源配置。项目运行中就可实现定时任务的动态增删改查，不用启停项目，摆脱了普通SpringBoot定时任务注解，需要重启才能生效...
springboot+Quartz实现任务调度的示例代码
08-28
本文主要介绍如何使用 SpringBoot 和 Quartz 实现任务调度的示例代码。Quartz 是一个功能强大且灵活的开源任务调度框架，广泛应用于各类 Java 项目中。下面将详细介绍如何使用 SpringBoot 和 Quartz 实现任务调度。 ...
Springboot2.0.1整合Quartz动态定时任务
09-15
本文将深入探讨如何在SpringBoot 2.0.1版本中整合Quartz，实现动态定时任务，并结合MyBatis-Plus进行数据操作。 首先，我们要在SpringBoot项目中引入Quartz和MyBatis-Plus的依赖。在`pom.xml`文件中，添加如下依赖...
springboot整合quartz定时器实现定时任务详解
热门推荐
小糖豆
06-08 2万+
最近需要 做一个按照时间，定时初始化一些信息的功能，研究了一下quartz，也简单了解一下TimerTask，废话不多说。 quartz和TimerTask的区别： timer是jdk自带的（可想而知，肯定是不怎么好用）。 Quartz可以通过cron表达式精确到特定时间执行，而TimerTask不能。Quartz拥有TimerTask所有的功能，而TimerTask则没有...
Spring Boot 实现定时任务动态管理
程序员子龙
03-25 2058
本文主要介绍了SpringBoot架构下动态定时任务的使用，定时任务表达式配置在数据库中，通过反射执行到目标方法。Quartz定时任务默认都是并发执行的，不会等待上一次任务执行完毕，只要间隔时间到就会执行, 如果定时任执行太长，会长时间占用资源，导致其它任务堵塞。一般设置都是禁止并发执行//禁止并发执行@Override/*** 线程本地变量*/@Overridetry {if (sysJob!= null)log.error("任务执行异常 - ：", e);/**
基于Quartz实现动态定时任务
Laity
11-10 2975
本文带各位学习下Quartz的基本使用及业务中的整合，包括基本概念以及如何动态地对定时任务进行CRUD，并且如何实现定时任务的持久化以及任务恢复；其中分享下本人在使用时遇到的问题，和解决方案。
springboot之quartz动态可控定时任务
qq_14926283的博客
10-19 869
Quartz是一个开源的任务调度框架，可以用来实现定时任务的调度，如定时发送邮件、定时备份数据等。Quartz具有很高的可靠性和灵活性，支持集群部署和分布式调度，并且提供了丰富的API和插件，可以轻松实现复杂的调度需求。Quartz的工作原理是通过Job和Trigger两个核心概念来实现的，Job是具体需要执行的任务，Trigger用来触发任务的执行时机。在Quartz中，可以通过定义各种Trigger来实现不同的调度策略，如简单调度、Cron调度等。
Spring + Quartz动态任务调度
it_lihongmin的博客
09-09 928
一、任务调用的实现        1、配置文件方式 <bean id="userTask" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"> execute 0/5 *
SpringBoot Quartz使用
Andy's Blog
10-20 689
Pom中引用quartz <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLoca...
springboot quartz使用
lanwp5302的博客
10-13 144
springboot quartz使用 Spring Boot使用Quartz定时任务 https://blog.csdn.net/gnail_oug/article/details/80825302 这里 springboot 简单使用quartz例子 版本 springboot 2.1.x 1. 引入依赖 <dependency> <groupId>org.springframework.boot</groupId>
quartz动态定时任务
Frank-Fu
08-21 2057
场景： 需求： 支付的二维码，超过两个小时以后，如果还未支付，则自动转为取消支付，或者支付超时的状态 需求分析： 1，动态定时任务： 每个支付的二维码创建的时候，创建一个动态的定时任务，两个小时候自动执行，更新支付状态，可以解决这个问题。 （1）持久化： 如果服务重启了，动态定时任务会丢失，导致部分数据没办法更新状态。 （2）分布式： 如果当服务重启时，自动扫描数据，重新计算时间，再次创建动态定时任务。可以解决（1）的问题，但是当分布式，多个节点的时候，都会重新加载所有的任务，这样性能上不
springboot quartz 定时任务
08-27
Spring Boot Quartz定时任务是一种在Spring Boot项目中实现定时任务调度的方法。它可以根据设定的时间间隔或者Cron表达式来执行任务。通过引用中提供的源代码和配置文件，可以直接导入Spring Boot项目并配置好数据库即可使用。 为了实现定时任务，需要在项目中创建一个继承自QuartzJobBean的Job类，并重写executeInternal方法。该方法定义了定时任务的具体逻辑，可以在其中执行需要定时执行的业务操作。 另外，还需要创建一个Quartz定时任务的配置类，其中使用@Configuration注解标记为配置类，配置相关的定时任务信息。在该配置类中，可以通过@Bean注解创建JobDetail和Trigger实例，分别定义任务的具体细节和触发器的配置信息。在这个配置类中，我提供了一个示例，用于演示如何配置一个定时任务。 综上所述，Spring Boot Quartz定时任务是一种灵活可靠的定时任务调度方法，可以通过Spring Boot的特性方便地实现任务的定时执行。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [springboot+quartz定时任务实现 纯代码](https://download.csdn.net/download/qq_38971617/12284286)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* *3* [SpringBoot整合Quartz实现定时任务](https://blog.csdn.net/qq_29305715/article/details/123517569)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值