定时任务-动态定时任务(springboot+org.quartz)

已于 2022-02-10 15:23:22 修改
阅读量1.4k 收藏 3
点赞数
分类专栏： 笔记 文章标签： spring boot java spring
于 2022-02-09 15:28:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46202016/article/details/122838119
版权

添加依赖

<!-- Quartz定时任务 -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-quartz</artifactId>
	</dependency>

添加配置

  #quartz定时任务,采用数据库方式
 spring:
  quartz:
    job-store-type: jdbc    #数据持久化方式，可选值：MEMORY、JDBC
    initialize-schema: embedded
    #设置自动启动，默认为 true
    auto-startup: false
    #启动时更新己存在的Job
    overwrite-existing-jobs: true
    properties:
      org:
        quartz:
          scheduler:
            instanceName: MyScheduler
            instanceId: AUTO
          jobStore:
          	#如果不需要将调度命令（例如添加和删除triggers）绑定到其他事务，那么可以通过使用 JobStoreTX 管理事务
            class: org.quartz.impl.jdbcjobstore.JobStoreTX
            #设置数据库驱动代理，StdJDBCDelegate 是一个使用 JDBC 代码来执行其工作的代理. 其他代			  理可以在"org.quartz.impl.jdbcjobstore“包或其子包中找到
            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
            #通知 JobStore 使用的表前缀
            tablePrefix: QRTZ_
            #是否加入集群
            isClustered: true
            misfireThreshold: 60000
            ##容许的最大作业延长时间
            clusterCheckinInterval: 10000
          threadPool:
          	#quartz 使用的线程池类型，org.quartz.spi.ThreadPool
            class: org.quartz.simpl.SimpleThreadPool
            #线程池中的线程总个数，表示最多可以同时执行的个任务/作业个数
            threadCount: 10
            #线程优先级
            threadPriority: 5
            #线程继承初始化线程的上下文类加载器
            threadsInheritContextClassLoaderOfInitializingThread: true

表结构

在这里插入图片描述

具体代码

    ------------------------controller开始----------------------------
    

 1. 添加
 /**
	 * 添加定时任务
	 *
	 * @param quartzJob
	 * @return
	 */
	@RequestMapping(value = "/add", method = RequestMethod.POST)
	public Result<?> add(@RequestBody QuartzJob quartzJob) {
		String jobClassName = quartzJob.getJobClassName();
		if(isContainChinese(jobClassName)){
			return Result.error("JobClassName参数有误!");
		}
		quartzJobService.saveAndScheduleJob(quartzJob);
		return Result.ok("创建定时任务成功");
	}
 2. 修改
  /**
	 * 更新定时任务
	 *
	 * @param quartzJob
	 * @return
	 */
	@RequestMapping(value = "/edit", method = RequestMethod.PUT)
	public Result<?> eidt(@RequestBody QuartzJob quartzJob) {
		try {
			String jobClassName = quartzJob.getJobClassName();
			if(isContainChinese(jobClassName)){
				return Result.error("JobClassName参数有误!");
			}
			quartzJobService.editAndScheduleJob(quartzJob);
		} catch (SchedulerException e) {
			log.error(e.getMessage(),e);
			return Result.error("更新定时任务失败!");
		}
	    return Result.ok("更新定时任务成功!");
	}
 3. 删除
 	/**
	 * 通过id删除
	 *
	 * @param id
	 * @return
	 */
	@RequestMapping(value = "/delete", method = RequestMethod.DELETE)
	public Result<?> delete(@RequestParam(name = "id", required = true) String id) {
		QuartzJob quartzJob = quartzJobService.getById(id);
		if (quartzJob == null) {
			return Result.error("未找到对应实体");
		}
		quartzJobService.deleteAndStopJob(quartzJob);
        return Result.ok("删除成功!");

 4. 暂停任务
 /**
	 * 暂停定时任务
	 *
	 * @param id
	 * @return
	 */
	@GetMapping(value = "/pause")
	@ApiOperation(value = "暂停定时任务")
	public Result<Object> pauseJob(@RequestParam(name = "id") String id) {
		QuartzJob job = quartzJobService.getById(id);
		if (job == null) {
			return Result.error("定时任务不存在！");
		}
		quartzJobService.pause(job);
		return Result.ok("暂停定时任务成功");
	}
 5. 恢复任务
 /**
	 * 启动定时任务
	 *
	 * @param id
	 * @return
	 */
	@GetMapping(value = "/resume")
	@ApiOperation(value = "恢复定时任务")
	public Result<Object> resumeJob(@RequestParam(name = "id") String id) {
		QuartzJob job = quartzJobService.getById(id);
		if (job == null) {
			return Result.error("定时任务不存在！");
		}
		quartzJobService.resumeJob(job);
		//scheduler.resumeJob(JobKey.jobKey(job.getJobClassName().trim()));
		return Result.ok("恢复定时任务成功");
	}
 6. 立即执行
 /**
	 * 立即执行
	 * @param id
	 * @return
	 */
	@GetMapping("/execute")
	public Result<?> execute(@RequestParam(name = "id", required = true) String id) {
		QuartzJob quartzJob = quartzJobService.getById(id);
		if (quartzJob == null) {
			return Result.error("未找到对应实体");
		}
		try {
			quartzJobService.execute(quartzJob);
		} catch (Exception e) {
			//e.printStackTrace();
			log.info("定时任务 立即执行失败>>"+e.getMessage());
			return Result.error("执行失败!");
		}
		return Result.ok("执行成功!");
	}
  ---------------------controller结束---------------------------------
    
 -------------------------service开始----------------------------------------

 7. 保存

	/**
	 * 保存&启动定时任务
	 */
	@Override
	public boolean saveAndScheduleJob(QuartzJob quartzJob) {
		// DB设置修改
		quartzJob.setDelFlag(CommonConstant.DEL_FLAG_0);
		boolean success = this.save(quartzJob);
		if (success) {
			if (CommonConstant.STATUS_NORMAL.equals(quartzJob.getStatus())) {
				// 定时器添加
				this.schedulerAdd(quartzJob.getId(), quartzJob.getJobClassName().trim(), quartzJob.getCronExpression().trim(), quartzJob.getParameter());
			}
		}
		return success;
	}

 /**
	 * 添加定时任务
	 *
	 * @param jobClassName
	 * @param cronExpression
	 * @param parameter
	 */
	private void schedulerAdd(String id, String jobClassName, String cronExpression, String parameter) {
		try {
			// 启动调度器
			scheduler.start();

			// 构建job信息
			JobDetail jobDetail = JobBuilder.newJob(getClass(jobClassName).getClass()).withIdentity(id).usingJobData("parameter", parameter).build();

			// 表达式调度构建器(即任务执行的时间)
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

			// 按新的cronExpression表达式构建一个新的trigger
			CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(id).withSchedule(scheduleBuilder).build();

			scheduler.scheduleJob(jobDetail, trigger);
		} catch (SchedulerException e) {
			throw new JeecgBootException("创建定时任务失败", e);
		} catch (RuntimeException e) {
			throw new JeecgBootException(e.getMessage(), e);
		}catch (Exception e) {
			throw new JeecgBootException("后台找不到该类名：" + jobClassName, e);
		}
	}

 8. 编辑
    /**
	 * 编辑&启停定时任务
	 * @throws SchedulerException
	 */
	@Override
	public boolean editAndScheduleJob(QuartzJob quartzJob) throws SchedulerException {
		if (CommonConstant.STATUS_NORMAL.equals(quartzJob.getStatus())) {
			schedulerDelete(quartzJob.getId());
			schedulerAdd(quartzJob.getId(), quartzJob.getJobClassName().trim(), quartzJob.getCronExpression().trim(), quartzJob.getParameter());
		}else{
			//暂停任务
			scheduler.pauseJob(JobKey.jobKey(quartzJob.getId()));
		}
		return this.updateById(quartzJob);
	}

 9. 删除定时任务
    /**
	 * 删除定时任务
	 *
	 * @param id
	 */
	private void schedulerDelete(String id) {
		try {
			scheduler.pauseTrigger(TriggerKey.triggerKey(id));// 停止触发器
			scheduler.unscheduleJob(TriggerKey.triggerKey(id));// 移除触发器
			scheduler.deleteJob(JobKey.jobKey(id));// 删除任务
		} catch (Exception e) {
			log.error(e.getMessage(), e);
			throw new JeecgBootException("删除定时任务失败");
		}
	} 

 10. 暂停定时任务
     /**
	 * 暂停定时任务
	 * @param quartzJob
	 */
	@Override
	public void pause(QuartzJob quartzJob){
		schedulerDelete(quartzJob.getId());
		quartzJob.setStatus(CommonConstant.STATUS_DISABLE);
		this.updateById(quartzJob);
	}

 11. 恢复定时任务
    /**
	 * 恢复定时任务
	 */
	@Override
	public boolean resumeJob(QuartzJob quartzJob) {
		schedulerDelete(quartzJob.getId());
		schedulerAdd(quartzJob.getId(), quartzJob.getJobClassName().trim(), quartzJob.getCronExpression().trim(), quartzJob.getParameter());
		quartzJob.setStatus(CommonConstant.STATUS_NORMAL);
		return this.updateById(quartzJob);
	}

 12. 立即执行
     /**
	 * 执行定时任务
	 * @param quartzJob
	 * @throws Exception
	 */
	@Override
	public void execute(QuartzJob quartzJob) throws Exception {
		String jobName = quartzJob.getJobClassName().trim();
		Date startDate = new Date();
		String ymd = DateUtils.date2Str(startDate,DateUtils.yyyymmddhhmmss.get());
		String identity =  jobName + ymd;
		//0.1秒后执行 只执行一次
		startDate.setTime(startDate.getTime() + 100L);
		// 定义一个Trigger
		SimpleTrigger trigger = (SimpleTrigger)TriggerBuilder.newTrigger()
				.withIdentity(identity, JOB_TEST_GROUP)
				.startAt(startDate)
				.build();
		// 构建job信息
		JobDetail jobDetail = JobBuilder.newJob(getClass(jobName).getClass()).withIdentity(identity).usingJobData("parameter", quartzJob.getParameter()).build();
		// 将trigger和 jobDetail 加入这个调度
		scheduler.scheduleJob(jobDetail, trigger);
		// 启动scheduler
		scheduler.start();
	}

 -----------------------------service结束------------------------------------

执行的任务内容

/**
 * 定时任务内容
 *
 */
@Slf4j
public class BridgeDeviceJob implements Job {
	/**
	 * 当前任务内容
	 * @param jobExecutionContext
	 * @throws JobExecutionException
	 */
	@Override
	public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
		log.info(String.format(" 数据接收定时任务 !  时间:" + DateUtils.getTimestamp()));
		//具体任务内容
	}
}
注意:1.实现org.quartz.Job接口,重新execute()方法.方法中写任务具体内容.

补充点

CronTrigger

withMisfireHandlingInstructionDoNothing
——不触发立即执行
——等待下次Cron触发频率到达时刻开始按照Cron频率依次执行

withMisfireHandlingInstructionIgnoreMisfires
——以错过的第一个频率时间立刻开始执行
——重做错过的所有频率周期后
——当下一次触发频率发生时间大于当前时间后，再按照正常的Cron频率依次执行

withMisfireHandlingInstructionFireAndProceed
——以当前时间为触发频率立刻触发一次执行
——然后按照Cron频率依次执行
m0_46202016
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自定义任务调度实现-org.quartz-scheduler
qq_29365985的博客
09-09 4046
org.quartz-scheduler
动态定时任务
菜鸟程序员的成长之路
12-01 1779
SpringBoot动态定时任务
Quartz-scheduler 定时器概述、核心 API 与 快速入门
热门推荐
蚩尤后裔-汪茂雄
04-06 1万+
目录 quartz-scheduler 石英调度器概述 quartz-scheduler HelloWorld quartz-scheduler 石英调度器概述 1、Quartz 是功能强大的开源作业调度库，几乎可以集成到任何 Java 应用程序中，从最小的独立应用程序到最大的电子商务系统。Quartz 可用于创建简单或复杂的计划，以执行数以万计的工作；可以执行您编写的所有内容。 2、Q...
SpringBoot动态定时任务
客官不爱喝酒的博客
10-24 540
之前在SpringBoot项目中简单使用定时任务，不过由于要借助cron表达式且都提前定义好放在配置文件里，不能在项目运行中动态修改任务执行时间，实在不太灵活。现在我们就来实现可以动态修改cron表达式的定时任务。
springcloud系类代码：org.quartz-scheduler-spring-boot-starter-mail
BLOG域名:programb.blog.csdn.net
06-22 743
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。Quartz的最新版本为Quartz 2.3.2。 集群Quartz应用 Quartz应用能被集群，是水平集群还是垂直集群取决于你自己的需要。集群提供以下好处： ·伸缩性 ·高可用性 ·负载均衡 Quartz可以借助关系数据.
Springboot2-Quartz 后台可动态配置的定时任务
02-28
本项目“Springboot2-Quartz 后台可动态配置的定时任务”是基于SpringBoot 2.x版本与Quartz Scheduler整合的一个示例，它展示了如何在后台管理系统中动态地创建、更新和删除定时任务，以及监控这些任务的状态，为...
springboot+quartz 动态化配置定时任务
07-25
总结，SpringBoot+Quartz的动态化配置使得定时任务管理变得更加灵活和直观，结合前端页面，为开发者和运营人员提供了便捷的操作平台。通过理解上述步骤并实际操作，你可以轻松构建出自己的动态定时任务管理系统。在...
springboot+quartz以持久化的方式实现定时任务的代码
08-18
SpringBoot+Quartz实现定时任务的代码 本篇文章主要介绍了使用SpringBoot和Quartz实现定时任务的相关知识，并通过实例代码详细地介绍了相关实现方式。 Quartz简介 Quartz是一个开源的任务调度框架，提供了强大的...
springboot+quartz 定时处理数据任务
11-06
本文将详细解析如何利用SpringBoot和Quartz框架构建一个定时处理数据任务的项目，以及如何根据实际需求进行修改和扩展。 首先，SpringBoot是一个流行的Java微服务框架，它简化了Spring应用程序的开发过程，提供了...
springboot+quartz +mysql 核心代码
03-07
以上就是使用Spring Boot、Quartz和MySQL搭建动态定时任务系统的要点。这个核心代码包可能包含了这些关键组件的配置文件、任务类、数据库脚本以及API接口等，可以帮助开发者快速理解和实现类似的功能。通过这样的...
SpringBoot 实现定时任务动态管理，太爽了
欧菲丽的博客
06-19 597
SpringBoot的定时任务的加强工具，实现对SpringBoot原生的定时任务进行动态管理,完全兼容原生@Scheduled注解,无需对原本的定时任务进行修改。
【SpringBoot】82、SpringBoot集成Quartz实现动态管理定时任务
最新发布
Asurplus
06-29 3万+
Quartz 是一个开源的作业调度框架，它完全由 Java 写成，并设计用于 J2SE 和 J2EE 应用中。它提供了巨大的灵 活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。它有很多特征，如：数据库支持，集群，插件，EJB 作业预构 建，JavaMail 及其它，支持 cron-like 表达式等等
动态定时任务(动态定时器)
程序工厂
10-21 2286
需求 在不重启服务的情况下，动态添加定时任务 效果 启动项目（有一个已存在的定时任务） 添加一个定时任务 查看控制台（动态添入定时任务） 实现步骤 pom.xml引入依赖 很多无关依赖可以自己删除，主要依赖:spring-boot-starter-quartz <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" x
Quartz入门——定时任务动态添加修改及持久化与自动恢复
Robod的博客
08-16 5503
这篇文章就带小伙伴们了解一下Quartz的基本使用。包括基本概念以及如何动态地的定时任务进行CRUD，并且如何实现定时任务的持久化以及任务恢复
Spring Boot 整合定时任务，可以动态编辑的定时任务
江南一点雨的专栏
03-09 4530
定时任务，松哥之前写过多篇文章和大家介绍，上次还自己 DIY 了一个可以动态编辑的定时任务，还录了一个配套视频： 相关的资料链接戳这里： Spring 定时任务玩出花！ 手把手教你定制可编辑的定时任务！ 开发可配置的定时任务～第二弹 Vue非典型用法，一个简单的管理页面 不过我们当时自己写的这个不支持分布式环境，想要支持倒也不是啥难事，弄一个 zookeeper 或者 redis 作为公共的信息中心，里边记录了定时任务的各种运行情况，有了这个就能支持分布式环境了。 今天咱们不自己写了，我们来看一个现成
Quartz 基本使用,任务调度quartz详解,动态定时任务,job,Trigger,Scheduler
鹏神丶明月天
09-19 4524
如一个OA系统需要在每周五9点自动生成数据报表，或者想每月10号自动还款，又或者每周给暗恋的女生定时发送邮件等等。Quartz是什么？Quartz是一个强大任务调度。
java 实现动态定时任务
m0_47944994的博客
01-11 4369
java动态定时任务
动态定时任务的简单实现
New_CJ的博客
08-16 648
1.配置类 @Configuration public class ThreadPoolTaskSchedulerConf { @Bean public ThreadPoolTaskScheduler threadPoolTaskScheduler() { return new ThreadPoolTaskScheduler(); } } 2.具体逻辑类...
springboot+vue+quartz 动态定时任务
05-22
1. 在后端使用 SpringBoot 和 Quartz，定义一个定时任务类，继承自 Quartz 的 Job 接口，并实现其中的 execute 方法。 2. 在定时任务类中，编写需要执行的任务逻辑。 3. 在定时任务类中，添加一些参数，用于动态...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值