springboot整合quartz定时任务并持久化到数据库

最新推荐文章于 2024-07-18 22:29:48 发布
最新推荐文章于 2024-07-18 22:29:48 发布
阅读量947 收藏 7
点赞数
分类专栏： SpringBoot 文章标签： quartz java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43173523/article/details/107110328
版权

springboot整合定时任务quartz
1、定时任务的的相关方法：

package org.springeos.modules.quartz.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.quartz.*;
import org.springeos.core.tool.api.R;
import org.springeos.modules.quartz.mapper.QuartzMapper;
import org.springeos.modules.quartz.service.QuartzService;
import org.springeos.modules.quartz.vo.QuartzVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;


@Slf4j
@Service
public class QuartzServiceImpl implements QuartzService {

	@Autowired
	private Scheduler scheduler;
	@Autowired
	private QuartzMapper quartzMapper;

	@Override
	public R addJob(String jobClassName, String jobName, String groupName, String cronExpression) {
		R<Object> r = new R<>();
		try {
			//构建job信息
			JobDetail jobDetail =
				JobBuilder.newJob((Class<? extends Job>)Class.forName(jobClassName))
					.withIdentity(jobName, groupName)
					.build();
			//表达式调度构建器(即任务执行的时间)
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
			//按新的cronExpression表达式构建一个新的trigger
			CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName, groupName)
				.startNow().withSchedule(scheduleBuilder).build();
			scheduler.scheduleJob(jobDetail, trigger);
			// 启动调度器
			scheduler.start();
			log.info("创建定时任务成功！");
			r.setSuccess(true);
			r.setMsg("创建定时任务成功！");
		} catch (SchedulerException | ClassNotFoundException e) {
			log.error("创建定时任务失败"+e);
			r.setMsg("创建定时任务失败！");
			r.setSuccess(false);
		}finally {
			return r;
		}
	}

	@Override
	public R pauseJob(String jobName, String jobGroupName) {
		R<Object> r = new R<>();
		try {
			scheduler.pauseJob(JobKey.jobKey(jobName, jobGroupName));
			log.info("暂停定时任务成功！");
			r.setSuccess(true);
			r.setMsg("暂停定时任务成功！");
		} catch (SchedulerException e) {
			log.error("暂停定时任务失败"+e);
			e.printStackTrace();
			r.setSuccess(false);
			r.setMsg("暂停定时任务失败！");
		}finally {
			return r;
		}
	}

	@Override
	public R resumeJob(String jobName, String jobGroupName) {
		R<Object> r = new R<>();
		try {
			scheduler.resumeJob(JobKey.jobKey(jobName, jobGroupName));
			r.setSuccess(true);
			r.setMsg("恢复定时任务成功！");
		} catch (SchedulerException e) {
			log.error("恢复定时任务失败"+e);
			e.printStackTrace();
			r.setSuccess(true);
			r.setMsg("恢复定时任务失败！");
		}finally {
			return r;
		}
	}

	@Override
	public R rescheduleJob(String jobName, String triggerGroupName, String cronExpression) {
		R<Object> r = new R<>();
		try {
			TriggerKey triggerKey = TriggerKey.triggerKey(jobName, triggerGroupName);
			// 表达式调度构建器
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
			CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
			// 按新的cronExpression表达式重新构建trigger
			trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
			// 按新的trigger重新设置job执行
			scheduler.rescheduleJob(triggerKey, trigger);
			r.setSuccess(true);
			r.setMsg("更新定时任务成功！");;
		} catch (SchedulerException e) {
			log.error("更新定时任务失败"+e);
			r.setSuccess(true);
			r.setMsg("更新定时任务失败！");
		}finally {
			return r;
		}
	}

	@Override
	public R deleteJob(String jobName, String jobGroupName) {
		R<Object> r = new R<>();
		try {
			scheduler.pauseTrigger(TriggerKey.triggerKey(jobName, jobGroupName));
			scheduler.unscheduleJob(TriggerKey.triggerKey(jobName, jobGroupName));
			scheduler.deleteJob(JobKey.jobKey(jobName, jobGroupName));
			r.setSuccess(true);
			r.setMsg("删除定时任务成功！");
		} catch (SchedulerException e) {
			log.error("删除定时任务失败"+e);
			e.printStackTrace();
			r.setSuccess(true);
			r.setMsg("删除定时任务失败！");
		}finally {
			return r;
		}
	}


	@Override
	public boolean checkExists(String jobName, String jobGroupName) {
		try {
			JobDetail jobDetail = scheduler.getJobDetail(new JobKey(jobName, jobGroupName));
			return jobDetail!=null;
		} catch (SchedulerException e) {
			log.error("根据jobName和groupName检查job是否存在失败"+e);
			e.printStackTrace();
		}
		return false;
	}

	@Override
	public IPage<QuartzVO> pageJob(Page page) {
		List<QuartzVO> pageJob = quartzMapper.pageJob(page);
		return page.setRecords(pageJob);
	}

}

2、需要的依赖：

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
 </dependency>

3、配置文件：
表11张，第一次启动的时候配置initialize-schema: never会自动生成表，然后改成never即可，否则后续还会初始化表，删掉原来的数据
表：
在这里插入图片描述

#数据源配置
spring:
  #  redis:
  #    ##redis 单机环境配置
  #    host: xxx
  #    port: 6379
  #    password: xxx
  #    database: 0
  #    ssl: false
  datasource:
    # Oracle
    url: xxx
    username: xx
    password: xx
  quartz:
    jdbc:
      #  初始化Quartz表结构,项目第一次启动配置程always,然后改成never 否则已生成的job会被初始化掉
      initialize-schema: never
    #   作业存储类型
    job-store-type: jdbc
    #   调度程序的名称
    scheduler-name: hrCleanScheduler
    properties:
      org:
        quartz:
          scheduler:
            instanceName: etlCleanScheduler
            instanceId: AUTO
          jobStore:
            #数据保存方式为持久化
            class: org.quartz.impl.jdbcjobstore.JobStoreTX
            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
            #Quartz表前缀
            tablePrefix: QRTZ_
            #是否加入集群
            isClustered: false
            clusterCheckinInterval: 10000
            useProperties: false
          #            调度器线程池配置
          threadPool:
            class: org.quartz.simpl.SimpleThreadPool
            #线程数
            threadCount: 20
            #线程优先级
            threadPriority: 5
            threadsInheritContextClassLoaderOfInitializingThread: true

4、自己写一个controller,service来方便接口调用，，自己写的分页方法，
controller:

package org.springeos.modules.quartz.controller;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springeos.core.launch.constant.AppConstant;
import org.springeos.core.tool.api.R;
import org.springeos.modules.quartz.service.QuartzService;
import org.springeos.modules.quartz.vo.QuartzVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * 关于job的管理
 *
 * @author wangk
 * @date 2019-08-13
 */
@Slf4j
@Api(value = "关于job的管理接口",tags = "定时任务接口")
@RestController
@RequestMapping(value = AppConstant.APPLICATION_SYSTEM_NAME+"/job")
public class  QuartzController{

	@Autowired
	private QuartzService jobService;


	@PostMapping(value = "/addJob")
	@ApiOperation(value = "添加job",notes = "jobClassName请使用类的全路径名" )
	public R addJob(
		@RequestParam(value = "jobClassName") String jobClassName,
		@RequestParam(value = "jobName") String jobName,
		@RequestParam(value = "jobGroupName") String jobGroupName,
		@RequestParam(value = "cronExpression") String cronExpression) {
		log.info("添加job---jobName:"+jobName+"---jobGroupName:"+jobGroupName);
		return jobService.addJob(jobClassName, jobName, jobGroupName, cronExpression);
	}

	@PostMapping(value="/pauseJob")
	@ApiOperation(value = "暂停job")
	public R pauseJob(
		@RequestParam(value="jobName")String jobName,
		@RequestParam(value="jobGroupName")String jobGroupName){
		log.info("暂停job---jobName:"+jobName+"---jobGroupName:"+jobGroupName);
		return jobService.pauseJob(jobName, jobGroupName);
	}

	@PostMapping(value="/resumeJob")
	@ApiOperation(value = "恢复job")
	public R resumeJob(
		@RequestParam(value="jobName")String jobName,
		@RequestParam(value="jobGroupName")String jobGroupName){
		log.info("恢复job---jobName:"+jobName+"---jobGroupName:"+jobGroupName);
		return jobService.resumeJob(jobName, jobGroupName);
	}

	@PostMapping(value="/rescheduleJob")
	@ApiOperation(value = "更新job")
	public R rescheduleJob(
		@RequestParam(value="jobName")String jobName,
		@RequestParam(value="triggerGroupName")String triggerGroupName,
		@RequestParam(value="cronExpression")String cronExpression){
		log.info("更新job---jobName:"+jobName);
		return jobService.rescheduleJob(jobName, triggerGroupName,cronExpression);
	}

	@PostMapping(value = "/deleteJob")
	@ApiOperation(value = "删除job")
	public R deleteJob(
		@RequestParam(value = "jobName") String jobName,
		@RequestParam(value = "jobGroupName") String jobGroupName) {
		log.info("删除job---jobName:"+jobName+"---jobGroupName:"+jobGroupName);
		return jobService.deleteJob(jobName, jobGroupName);
	}

	//分页查询
	@PostMapping("/page")
	@ApiOperation(value = "分页查询")
	public R<IPage<QuartzVO>> pageJob(Page page) {
		log.info("分页查询");
		IPage<QuartzVO> result = jobService.pageJob(page);
		return R.data(result);
	}

}

service:

package org.springeos.modules.quartz.service;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springeos.core.tool.api.R;
import org.springeos.modules.quartz.vo.QuartzVO;

public interface QuartzService{

	R addJob(String jobClassName, String jobName, String groupName, String cronExpression);

	R pauseJob(String jobName, String jobGroupName);

	R resumeJob(String jobName, String jobGroupName);

	R rescheduleJob(String jobName, String triggerGroupName, String cronExpression);

	R deleteJob(String jobName, String jobGroupName);

	boolean checkExists(String jobName, String jobGroupName);

	IPage<QuartzVO> pageJob(Page page);

}

mapper:

package org.springeos.modules.quartz.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Select;
import org.springeos.modules.quartz.vo.QuartzVO;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface QuartzMapper extends BaseMapper<QuartzVO> {

	@Select("SELECT DISTINCT j.JOB_NAME AS jobName, j.JOB_GROUP AS jobGroupName, j.JOB_CLASS_NAME AS jobClassName, c.CRON_EXPRESSION AS cronExpression, q.TRIGGER_STATE AS triggerState, q.TRIGGER_NAME AS triggerName, q.TRIGGER_GROUP AS triggerGroup FROM QRTZ_JOB_DETAILS j INNER JOIN QRTZ_CRON_TRIGGERS c ON j.JOB_NAME = c.TRIGGER_NAME INNER JOIN QRTZ_TRIGGERS q ON j.JOB_NAME = q.JOB_NAME")
	List<QuartzVO> pageJob(Page page);
}

5、测试job：

package org.springeos.modules.quartz.job;


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

public class HelloJob extends QuartzJobBean {

	@Override
	protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
		System.err.println("定时任务正在执行----------------------------------");
	}
}

postman调用新增定时任务的接口：
任务名和组名可以任意写，配置好任务类所在的路径和定时表达式，访问即可
http://localhost:80/eos-system/job/addJob
在这里插入图片描述
通过控制台发现定时任务可发现定时任务可以正常执行
在这里插入图片描述
去表中查看，QRTZ_JOB_DETAILS表中已经插入数据
在这里插入图片描述
corn触发器表中也正常插入数据
在这里插入图片描述

没事放放牛、
关注
专栏目录
quartz mysql 初始化_SpringBoot整合Quartz定时任务（持久化到数据库）
weixin_33241808的博客
01-19 1152
背景最近在做项目，项目中有个需求：需要使用定时任务，这个定时任务需要即时生效。查看Quartz官网之后发现：Quartz提供两种基本作业存储类型：RAMJobStore ：RAM也就是内存，默认情况下Quartz会将任务调度存在内存中，这种方式性能是最好的，因为内存的速度是最快的。不好的地方就是数据缺乏持久性，但程序崩溃或者重新发布的时候，所有运行信息都会丢失JDBC作业存储：存到数据库之后，可以...
springboot整合quartz实现任务持久化(下)
On the road to profession
11-11 2679
主要介绍 spring-boot-starter-quartz 的使用技巧
SpringBoot整合Quartz定时任务（持久化到数据库）
热门推荐
我是你妹她哥的博客
12-27 6万+
背景 最近在做项目，项目中有个需求：需要使用定时任务，这个定时任务需要即时生效。 查看Quartz官网之后发现：Quartz提供两种基本作业存储类型： RAMJobStore ：RAM也就是内存，默认情况下Quartz会将任务调度存在内存中，这种方式性能是最好的，因为内存的速度是最快的。不好的地方就是数据缺乏持久性，但程序崩溃或者重新发布的时候，所有运行信息都会丢失 JDBC作业存储：存到数据库...
springboot2.3集成quartz定时任务持久化数据库,支持集群
07-13
执行resources中的sql脚本,修改数据库连接参数,亲测完美运行-----------------------------------------------------
IDEA SpringBoot实现定时任务（保姆级教程，超详细！！！）
最新发布
当觉得自己菜的时候，就应该静下心来学习
07-18 1724
本教程将带您逐步了解Spring Boot定时任务的实现过程，包括基本的配置和注解使用、常见的执行计划设置、以及高级功能如动态定时任务、多线程定时任务等。通过本教程的学习，您将能够掌握在Spring Boot中高效实现定时任务的方法和技巧，为您的应用增添更多自动化和智能化的功能。
springboot整合quartz并持久化到数据库
zuixiaoyao_001的博客
02-28 955
springboot整合quartz并持久化到数据库 首先，这里的持久化是是如果当服务器宕机时，任务还在为我们保存。并且在启动服务器之后仍然可以自动执行 一、创建quartz 建表语句mysql的，quartz 2.3.0版本 DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS; DROP TABLE I...
springboot+quartz调度持久化
shursulei的博客
06-28 367
最近在使用springboot+quartz+postgresql+jpa结合做定时调度持久化。 出现的几个问题 1、配置 2、jpa和实体转换问题 org.hibernate.PropertyNotFoundException: Could not resolve PropertyAccess 解决办法：在sql查询语句中，给表字段起别名，别名为对应实体类属性名 参考链接 3、quartz持久化的表 说明以及哪些可以二次修改 ...
SpringBoot2.x集成Quartz实现定时任务管理（持久化到数据库）
C3Stones
09-25 928
1. Quartz简介   Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目。   Quartz是一个完全由Java编写的开源作业调度框架，为在Java应用程序中进行作业调度提供了简单却强大的机制。   Quartz可以与J2EE与J2SE应用程序相结合也可以单独使用。   Quartz允许程序开发人员根据时间的间隔来调度作业。   Quar...
SpringBoot2.0整合Quartz定时任务（持久化到数据库，更为简单的方式）
我是你妹她哥的博客
12-27 1万+
背景 仔细回想一下，上一篇文章中集成Quartz并且持久化到数据库的方式，稍微有一点烦人，那么springboot有没有提供给我们这种相对快捷的方式么？我们可以去springboot的官方看看 https://docs.spring.io/spring-boot/docs/2.1.1.RELEASE/reference/htmlsingle/#boot-features-quartz 这里就有讲，...
springboot整合quartz定时任务yml文件配置方式
03-23
在Spring Boot应用中整合Quartz定时任务是一种常见的需求，它可以帮助我们执行周期性的后台任务，如数据同步、报表生成等。Spring Boot与Quartz的结合提供了便捷的配置方式，特别是通过YAML（YAML Ain't Markup ...
springboot+quartz以持久化的方式实现定时任务的代码
08-18
主要介绍了springboot+quartz以持久化的方式实现定时任务的相关知识，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
springboot整合quartz，实现数据库方式执行定时任务
11-19
总结，通过Spring Boot整合Quartz，我们可以利用数据库存储定时任务，实现任务的灵活管理和持久化。这使得在分布式环境中，多个实例可以共享同一个任务列表，避免重复执行。同时，通过数据库的方式，我们还能方便地...
springboot+quartz以持久化的方式实现定时任务
weixin_47082274的博客
07-27 707
篇幅较长，耐心的人总能得到最后的答案 第一次用quartz做定时任务，不足之处多多谅解。 首先 在springboot项目里做定时任务是比较简单的，最简单的实现方式是使用**@Scheduled注解， 然后在application启动类上使用@EnableScheduling**开启定时任务。 示例 @SpringBootApplication @EnableScheduling public class Application { public static void main(String.
SpringBoot 数据访问
Dj19983160703的博客
10-07 170
一、JDBC <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>my
Springboot+Quartz（三）-- springboot简化与持久化
weixin_39724194的博客
01-17 496
Springboot自动注入scheduler 我们看下springboot官方文档（中文版，英文版我已经找不到quartz相关内容了）： Spring Boot 提供了几种使用 Quartz 调度器的便捷方式，它们来自 spring-boot-starter-quartz starter。如果 Quartz 可用，则 Spring Boot 将自动配置 Scheduler（通过 SchedulerFactoryBean 抽象）。 自动选取以下类型的 Bean 并将其与 Scheduler 关联起来： J
Spring Quartz 持久化解决方案
犀利的代码总是很精炼
03-09 171
[img]http://dl.iteye.com/upload/attachment/432366/703af1f4-22dd-3962-888e-e6da206d27e3.jpg[/img] Quartz是实现了序列化接口的，包括接口，所以可以使用标准方式序列化到数据库。 而Spring2.5.6在集成Quartz时却未能考虑持久化问题。 [img]http://dl.iteye....
Springboot 集成Quartz,支持持久化，支持动态启停定时任务
ys_code的博客
12-09 603
一.Quartz基本流程 首先需要创建任务(Job)，比如定时发送短信邮件之类的，这是任务主体，也就是写业务逻辑的地方。 创建任务调度器(Scheduler)，调用任务的主要API,主要用于启动、停止、暂停、恢复等操作。 创建任务明细(JobDetail)，最开始编写好任务(Job)后，只是写好业务代码，并没有触发，这里需要用JobDetail来和之前创建的任务(Job)关联起来，便于执行。 创建触发器(Trigger)，触发器是来定义任务的规则的，比如几点执行，几点结束
SpringBoot+Quartz：动态配置数据库驱动的定时任务实现
"本文档详细介绍了如何在Spring Boot项目中整合Quartz框架，实现动态配置定时任务。首先，你需要在项目中引入必要的依赖，包括Spring Boot的JPA起步器以支持数据访问，H2内存数据库用于测试，以及Quartz和Spring对...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值