Spring+Quartz 从数据库中获取定时任务和定时时间，动态实现对定时任务的增删改查

最新推荐文章于 2023-12-10 22:33:58 发布
最新推荐文章于 2023-12-10 22:33:58 发布
阅读量2.3w 收藏 28
点赞数 3
分类专栏： java基础 文章标签： quartz spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wwkms/article/details/48851005
版权

由于公司的新接得项目要实现一批数据的同步，通过外围厂商提供的一系列各个系统的webervices接口定时将数据同步到我们开发的共享平台上，由于厂商系统的数据是不断在变化以及各系统闲忙时的特点，所以定时同步任务的执行必须在时间上能够动态配置。因此，我们需要动态的从数据库中获取配置信息，以改变各个定时间的执行规则，废话不说了，上代码：(我利用的是ssh框架直接写的，框架搭建不再叙述)

1.创建数据表(我用的是mysql)

DROP TABLE IF EXISTS `t_wsdoc`;
CREATE TABLE `t_wsdoc` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `triggername` varchar(50) NOT NULL,
  `jobdetailname` varchar(50) NOT NULL,
  `cronexpression` varchar(50) NOT NULL,
  `targetobject` varchar(50) NOT NULL,
  `methodname` varchar(50) NOT NULL,
  `concurrent` char(10) NOT NULL DEFAULT '0',
  `state` char(10) NOT NULL DEFAULT '1',
  `isspringbean` char(10) NOT NULL DEFAULT '0',
  `readme` varchar(100) DEFAULT NULL,
  `reserved1` varchar(50) DEFAULT NULL,
  `reserved2` varchar(50) DEFAULT NULL,
  `reserved3` varchar(50) DEFAULT NULL,
  `reserved4` varchar(50) DEFAULT NULL,
  `reserved5` varchar(50) DEFAULT NULL,
  `reserved6` varchar(50) DEFAULT NULL,
  `reserved7` varchar(50) DEFAULT NULL,
  `reserved8` varchar(50) DEFAULT NULL,
  `reserved9` varchar(50) DEFAULT NULL,
  `reserved10` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
INSERT INTO `t_wsdoc` VALUES ('1', 'triggername', 'detailname', '0/5 * * * * ?', 'com.framework.timer.ISCSynAllData', 'run', '\'0\'', '\'1\'', '\'0\'', '说明', null, null, null, null, null, null, null, null, null, null);

2.创建表对应的实体类 

package ...自定义;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

import com.framework.model.AbstractEntity;


@Entity
@Table(name = "WSDOC", schema = "")
public class Wsdoc extends AbstractEntity{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private Long id;
	// 设置trigger名称
	private String triggername;  
	//设置表达式
	private String cronexpression;
	// 设置Job名称
	private String jobdetailname;
	//任务类名
	private String targetobject;
	//类名对应的方法名
	private String methodname;
	//设置是否并发启动任务 0是false 非0是true
	private String concurrent;
	// 如果计划任务不存则为1 存在则为0
	private String state;
	private String readme;
	//是否是已经存在的springBean 1是  0 否
	private String isspringbean;
	/** 预留字段1 */
	private String reserved1;
	/** 预留字段2 */
	private String reserved2;
	/** 预留字段3 */
	private String reserved3;
	/** 预留字段4 */
	private String reserved4;
	/** 预留字段5 */
	private String reserved5;
	/** 预留字段6 */
	private String reserved6;
	/** 预留字段7 */
	private String reserved7;
	/** 预留字段8 */
	private String reserved8;
	/** 预留字段9 */
	private String reserved9;
	/** 预留字段10 */
	private String reserved10;
	// Constructors

	/** default constructor */
	public Wsdoc() {
	}

	/** full constructor */
	public Wsdoc(String triggername, String cronexpression,
			String jobdetailname, String targetobject, String methodname,
			String concurrent, String state, String readme,String isspringbean) {
		this.triggername = triggername;
		this.cronexpression = cronexpression;
		this.jobdetailname = jobdetailname;
		this.targetobject = targetobject;
		this.methodname = methodname;
		this.concurrent = concurrent;
		this.state = state;
		this.readme = readme;
		this.isspringbean=isspringbean;
	}
	@Id
	@Column(name = "ID", unique = true, nullable = false, precision = 10, scale = 0)
	//@GeneratedValue(strategy = GenerationType.SEQUENCE,generator="WSDOC_ID") //如果为oracle则可以创建一个序列，便于插入数据用
	//@SequenceGenerator(initialValue=0,name="WSDOC_ID",sequenceName="WSDOC_ID",allocationSize=1)
	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}
    
	@Column(name = "TRIGGERNAME",nullable = false,length=100)
	public String getTriggername() {
		return this.triggername;
	}

	public void setTriggername(String triggername) {
		this.triggername = triggername;
	}
	
	@Column(name = "CRONEXPRESSION",nullable = false,length=100)
	public String getCronexpression() {
		return this.cronexpression;
	}

	public void setCronexpression(String cronexpression) {
		this.cronexpression = cronexpression;
	}
	
	@Column(name = "JOBDETAILNAME",nullable = false,length=100)
	public String getJobdetailname() {
		return this.jobdetailname;
	}

	public void setJobdetailname(String jobdetailname) {
		this.jobdetailname = jobdetailname;
	}
	@Column(name = "TARGETOBJECT",nullable = false,length=100)
	public String getTargetobject() {
		return this.targetobject;
	}

	public void setTargetobject(String targetobject) {
		this.targetobject = targetobject;
	}
	@Column(name = "METHODNAME",nullable = false,length=100)
	public String getMethodname() {
		return this.methodname;
	}

	public void setMethodname(String methodname) {
		this.methodname = methodname;
	}
	@Column(name = "CONCURRENT",nullable = false,length=100)
	public String getConcurrent() {
		return this.concurrent;
	}

	public void setConcurrent(String concurrent) {
		this.concurrent = concurrent;
	}
	@Column(name = "STATE",nullable = false,length=100)
	public String getState() {
		return this.state;
	}

	public void setState(String state) {
		this.state = state;
	}
	@Column(name = "README",nullable = false,length=100)
	public String getReadme() {
		return this.readme;
	}

	public void setReadme(String readme) {
		this.readme = readme;
	}
	@Column(name = "ISSPRINGBEAN",nullable = false,length=100)
	public String getIsspringbean() {
		return isspringbean;
	}

	public void setIsspringbean(String isspringbean) {
		this.isspringbean = isspringbean;
	}
	@Column(name = "RESERVED_1",length=100)
	public String getReserved1() {
		return reserved1;
	}

	public void setReserved1(String reserved1) {
		this.reserved1 = reserved1;
	}
	@Column(name = "RESERVED_2",length=100)
	public String getReserved2() {
		return reserved2;
	}

	public void setReserved2(String reserved2) {
		this.reserved2 = reserved2;
	}
	@Column(name = "RESERVED_3",length=100)
	public String getReserved3() {
		return reserved3;
	}

	public void setReserved3(String reserved3) {
		this.reserved3 = reserved3;
	}
	@Column(name = "RESERVED_4",length=100)
	public String getReserved4() {
		return reserved4;
	}

	public void setReserved4(String reserved4) {
		this.reserved4 = reserved4;
	}
	@Column(name = "RESERVED_5",length=100)
	public String getReserved5() {
		return reserved5;
	}

	public void setReserved5(String reserved5) {
		this.reserved5 = reserved5;
	}
	@Column(name = "RESERVED_6",length=100)
	public String getReserved6() {
		return reserved6;
	}

	public void setReserved6(String reserved6) {
		this.reserved6 = reserved6;
	}
	@Column(name = "RESERVED_7",length=100)
	public String getReserved7() {
		return reserved7;
	}

	public void setReserved7(String reserved7) {
		this.reserved7 = reserved7;
	}
	@Column(name = "RESERVED_8",length=100)
	public String getReserved8() {
		return reserved8;
	}

	public void setReserved8(String reserved8) {
		this.reserved8 = reserved8;
	}
	@Column(name = "RESERVED_9",length=100)
	public String getReserved9() {
		return reserved9;
	}

	public void setReserved9(String reserved9) {
		this.reserved9 = reserved9;
	}
	@Column(name = "RESERVED_10",length=100)
	public String getReserved10() {
		return reserved10;
	}

	public void setReserved10(String reserved10) {
		this.reserved10 = reserved10;
	}



}
3.核心Java代码  

package com.framework.timer;

import java.text.ParseException;
import java.util.Date;
import java.util.List;

import org.apache.log4j.Logger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.CronTriggerBean;
import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;

import cn.edu.svtcc.datas.model.Wsdoc;
import cn.edu.svtcc.datas.service.WsdocService;



public class QuartzManager implements BeanFactoryAware {
	private Logger log = Logger.getLogger(QuartzManager.class);
	private Scheduler scheduler;
	private static BeanFactory beanFactory = null;
   
	@Autowired
    private WsdocService wsdocService;

	@SuppressWarnings("unused")
	private void reScheduleJob() throws Exception, ParseException {
		// 通过查询数据库里计划任务来配置计划任务
		
		List<Wsdoc> quartzList = wsdocService.getAllTarger(); //从数据库中获取所有的配置信息，根据自己的获取方式来写，此不赘述
                Wsdoc tbcq=new Wsdoc();
		tbcq.setTriggername("triggername");
		tbcq.setCronexpression("0/5 * * * * ?");
		tbcq.setJobdetailname("detailname");
		tbcq.setTargetobject("com.framework.timer.ISCSynAllData");
		tbcq.setMethodname("run");
		tbcq.setConcurrent("1");
		tbcq.setState("1");
		tbcq.setReadme("readme");
		tbcq.setIsspringbean("0");
		quartzList.add(tbcq);*/
		//this.getConfigQuartz();
		if (quartzList != null && quartzList.size() > 0) {
			for (Wsdoc tbcq1 : quartzList) {
				configQuatrz(tbcq1);
			}
		}
	}

	public boolean configQuatrz(Wsdoc tbcq) {
		boolean result = false;
		try {
			// 运行时可通过动态注入的scheduler得到trigger
			CronTriggerBean trigger = (CronTriggerBean) scheduler.getTrigger(
					tbcq.getTriggername(), Scheduler.DEFAULT_GROUP);
			// 如果计划任务已存在则调用修改方法
			if (trigger != null) {
				change(tbcq, trigger);
			} else {
				// 如果计划任务不存在并且数据库里的任务状态为可用时,则创建计划任务
				if (tbcq.getState().equals("1")) {
					this.createCronTriggerBean(tbcq);
				}
			}
			result = true;
		} catch (Exception e) {
			result = false;
			e.printStackTrace();
		}

		return result;
	}

	public void change(Wsdoc tbcq, CronTriggerBean trigger)
			throws Exception {
		// 如果任务为可用
		if (tbcq.getState().equals("1")) {
			// 判断从DB中取得的任务时间和现在的quartz线程中的任务时间是否相等
			// 如果相等，则表示用户并没有重新设定数据库中的任务时间，这种情况不需要重新rescheduleJob
			if (!trigger.getCronExpression().equalsIgnoreCase(
					tbcq.getCronexpression())) {
				trigger.setCronExpression(tbcq.getCronexpression());
				scheduler.rescheduleJob(tbcq.getTriggername(),
						Scheduler.DEFAULT_GROUP, trigger);
				log.info(new Date() + ": 更新" + tbcq.getTriggername() + "计划任务");
			}
		} else {
			// 不可用
			scheduler.pauseTrigger(trigger.getName(), trigger.getGroup());// 停止触发器
			scheduler.unscheduleJob(trigger.getName(), trigger.getGroup());// 移除触发器
			scheduler.deleteJob(trigger.getJobName(), trigger.getJobGroup());// 删除任务
			log.info(new Date() + ": 删除" + tbcq.getTriggername() + "计划任务");

		}

	}

	/**
	 * 创建/添加计划任务
	 * 
	 * @param tbcq
	 *            计划任务配置对象
	 * @throws Exception
	 */
	public void createCronTriggerBean(Wsdoc tbcq) throws Exception {
		// 新建一个基于Spring的管理Job类
		MethodInvokingJobDetailFactoryBean mjdfb = new MethodInvokingJobDetailFactoryBean();
		mjdfb.setName(tbcq.getJobdetailname());// 设置Job名称
		// 如果定义的任务类为Spring的定义的Bean则调用 getBean方法
		if (tbcq.getIsspringbean().equals("1")) {
			mjdfb.setTargetObject(beanFactory.getBean(tbcq.getTargetobject()));// 设置任务类
		} else {
			// 否则直接new对象
			mjdfb.setTargetObject(Class.forName(tbcq.getTargetobject())
					.newInstance());// 设置任务类
		}

		mjdfb.setTargetMethod(tbcq.getMethodname());// 设置任务方法
		mjdfb.setConcurrent(tbcq.getConcurrent().equals("0") ? false : true); // 设置是否并发启动任务
		mjdfb.afterPropertiesSet();// 将管理Job类提交到计划管理类
		// 将Spring的管理Job类转为Quartz管理Job类
		JobDetail jobDetail = new JobDetail();
		jobDetail = (JobDetail) mjdfb.getObject();
		jobDetail.setName(tbcq.getJobdetailname());
		scheduler.addJob(jobDetail, true); // 将Job添加到管理类
		// 新一个基于Spring的时间类
		CronTriggerBean c = new CronTriggerBean();
		c.setCronExpression(tbcq.getCronexpression());// 设置时间表达式
		c.setName(tbcq.getTriggername());// 设置名称
		c.setJobDetail(jobDetail);// 注入Job
		c.setJobName(tbcq.getJobdetailname());// 设置Job名称
		scheduler.scheduleJob(c);// 注入到管理类
		scheduler.rescheduleJob(tbcq.getTriggername(), Scheduler.DEFAULT_GROUP,
				c);// 刷新管理类
		log.info(new Date() + ": 新建" + tbcq.getTriggername() + "计划任务");
	}

	public Scheduler getScheduler() {
		return scheduler;
	}

	public void setScheduler(Scheduler scheduler) {
		this.scheduler = scheduler;
	}

	public void setBeanFactory(BeanFactory factory) throws BeansException {
		this.beanFactory = factory;

	}

	public BeanFactory getBeanFactory() {
		return beanFactory;
	}
   
}
4.测试类代码 

package com.framework.timer;

import java.util.Date;

import org.quartz.SchedulerException;



public class ISCSynAllData{  
	
	public void run() throws SchedulerException{
    	 System.out.println("开始执行"+new Date());
  
     }
}
5.Spring.xml中的配置(标红的为核心配置) 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:context="http://www.springframework.org/schema/context" 
	xmlns:task="http://www.springframework.org/schema/task"
	xsi:schemaLocation="
	http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
	http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context-3.0.xsd
	http://www.springframework.org/schema/task   
	http://www.springframework.org/schema/task/spring-task-3.0.xsd
	">

	<!-- 引入属性文件 -->
	<context:property-placeholder location="classpath:config.properties" />

	<!-- 自动扫描dao和service包(自动注入) -->
	<context:component-scan base-package="com,cn" />
	
	<!-- 定时任务配置 实现方式1，利用spring自带的定时器
    <task:executor id="executor" pool-size="5" />   -->
    <!-- 声明一个具有10个线程的池，每一个对象将获取同样的运行机会
    <task:scheduler id="scheduler" pool-size="10" />   --> 
    <!--  定时器开关  开始
    <task:annotation-driven executor="executor" scheduler="scheduler" />-->
	<!--  定时器开关  结束-->
	<!--数据同步 -->
	<!--下面这种quartz定时器是为了实现人工对定时间的启用，停用，调用时间，和删除的操作  -->
<span style="color:#ff0000;"><!--实现方式二，利用 quartz实现定时器功能-->

<bean id="quartzManagerBean" class="com.framework.timer.QuartzManager">
		<property name="scheduler" ref="schedulerManager" />
	</bean>
	<bean id="quartzManagerJobDetail"
		class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
		<property name="targetObject" ref="quartzManagerBean" />
		<property name="targetMethod" value="reScheduleJob" />
		<property name="concurrent" value="false" />
	</bean>
	<!-- 主定时计划 -->
	<bean id="quartzManagerTrigger"
		class="org.springframework.scheduling.quartz.SimpleTriggerBean">
		<property name="jobDetail" ref="quartzManagerJobDetail" />
		<!-- 延时1分钟 执行任务 -->
		<property name="startDelay" value="300000" />
		<!-- 任务执行周期 5分钟 -->
		<property name="repeatInterval" value="60000" />
	</bean>
	<!-- 总管理类 如果将lazy-init='false'那么容器启动就会执行调度程序  -->
	<bean id="schedulerManager" lazy-init="false" autowire="no"
		class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
		<property name="triggers">
			<list>
				<ref bean="quartzManagerTrigger" />
			</list>
		</property>
	</bean>
</beans></span>
按照我以上配置流程把代码拷贝过去稍加修改即可实现！

demo代码下载地址：http://download.csdn.net/detail/wwkms/9152293

关于cronexpression时间表达式的说明，详见我的博客《Quartz CronTrigger最完整配置说明》

wesley_wwk
关注
  • 3
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
解决Spring中使用quartz发生NotSerializableException methodInvoker的问题
u012903926的专栏
05-12 7500
Spring2.5 + quartz1.6.5 发生如下异常   Caused by: org.quartz.JobPersistenceException: Couldn't store job: Unable to serialize JobDataMap for insertion into database because the value of property 'meth
基于数据库的动态定时任务
热门推荐
骑个小蜗牛的博客
01-25 2万+
文章目录1.实现原理2.源码解析数据库表实体类任务类调度配置类操作数据库Service定时任务初始化类刷新定时任务接口类3.注意事项 1.实现原理 @EnableScheduling开启任务调度； 自定义调度线程池； 数据库定义定时任务； 启动完成时，加载数据库定时任务并提交到线程池； 调用接口触发线程池中任务的更新（新增、删除、修改）； 2.源码解析 数据库表 CREATE TABLE `timed_task` ( `id` bigint(20) NOT NULL COMMENT '主键',
quartz1.8+spring2.3.9实现从数据库中读取定时任务
u011521890的专栏
03-19 1万+
环境配置quartz1.8和spring3.2.9。 quartz2.0以上和之下的版本差别有些不同。 我使用的是1.8版本的。数据库建表语句CREATE TABLE `report_tasks_manager` ( `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键id', `task_desc` varchar(255) DEFAULT
【quartz】定时任务时间在数据库中修改，无需启动服务
yuxiangdeming的博客
01-06 3328
一、修改定时任务时间方法 update qrtz_cron_triggers set CRON_EXPRESSION='0 */1 * * * ?' where TRIGGER_NAME='myTrigger1'; update qrtz_triggers set NEXT_FIRE_TIME=0,PREV_FIRE_TIME=0 where TRIGGER_NAME='myTrigger1'; 第一条sql语句是更改表qrtz_cron_triggers，原来数据库中该任务是每5分钟执行一次
【quartz】从数据库中读取配置实现动态定时任务
qq_37634156的博客
06-25 3894
实现方式 1、定时任务表实体 2、反射调用scheduleJob中定义的方法 3、创建正常状态下的job执行工厂 4、若一个方法一次执行不完下次轮转时则等待改方法执行完后才执行下一次操作 5、创建需要运行的定时任务类 6、SpringBean工厂工具类 7、其他用到的工具类 字符串工具类 日志工具类 数据分析常量类 接口返回参数类 其中ResultEnum类如下： 8、sql语句 注释的很
基于Spring的Quartz动态定时任务增删改查
01-31
基于Spring的Quartz动态定时任务增删改查，代码简洁。后端采用SpringMvc+Spring+Mybatis+Quartz，前端采用Bootstrap框架，数据库采用MySQL；完成定时任务动态任务初始化，增删改查
Spring mvc + Mybatis + quartz + swagger 定时任务管理[新增、编辑、删除、修改]
05-02
利用quartz动态操作定时任务，所有配置信息扔到数据库合理管理，同时把运行日志自动添加数据库表中。
java动态管理定时任务
07-31
spring+quartz整合，动态管理定时任务，可对正在进行的任务操作增删改查，可配合数据库进行操作
Spring boot整合Mybatis实现增删改查
最新发布
12-29
4.实现了sakila中的单表的增删改查和跨表查询，跨表查询包括了Mybatis的1-N和N-1双向映射； 5.添加定时任务：不再使用作业自动调度框架Quartz实现作业调度，使用spring框架自带的调度器进行作业调度，简化了配置。@...
Quartz实战：基于Quartz实现定时任务的动态调度，实现定时任务的增删改查
秃了也弱了
07-27 1074
Quartz使用文档，使用Quartz实现动态任务，Spring集成Quartz，Quartz集群部署，Quartz源码分析Quartz使用文档，使用Quartz实现动态任务，Spring集成Quartz，Quartz集群部署，Quartz源码分析 4、增删改查Controller 5、Quartz工具类 6、测试任务类 7、springboot启动初始化定时任务 8、自定义JobFactory，使Task注册为Bean 9、省略的内容 此处省略了SysJob实体类，以及Mapper等对数据库的
spring quartz动态实现对任务的增删改查
csdn_sunlighting的博客
05-27 1329
        最近在做项目的时候用到了定时任务，而且用到的地方比较多，如果用配置文件配置的话，感觉不太方便，调整任务的执行方式也十分麻烦，因此，我采用了动态添加的方式，将定时任务保存在数据库中，这样既可以方便定时任务的添加，有能够随时改变、关闭定时任务。      定时任务的主要实现逻辑是在初始化完spring之后初始化定时任务，添加、修改定时任务时，调用相应的方法去修改定时任务不多说，直接上核...
定时任务调度器（从数据库中获取定时任务）
miao_123abc的博客
07-26 1263
package cn.miaozw.scheduleTest.task; import java.time.LocalTime; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import j...
定时读取mysql_自定义定时任务(从数据库读定时任务)
weixin_26913055的博客
02-07 968
packagecom.ql.vessels.schemajob;importcom.fqgj.log.factory.LogFactory;importcom.fqgj.log.interfaces.Log;importcom.ql.vessels.common.util.DateUtils;importcom.ql.vessels.domain.services.MsgSendSchemaSer...
【SpringBoot教程】SpringBoot 创建定时任务（配合数据库动态执行）
sandy_3118的博客
12-10 909
序言：创建定时任务非常简单，主要有两种创建方式：一、基于注解(@Scheduled)二、基于接口（SchedulingConfigurer）. 前者相信大家都很熟悉，但是实际使用中我们往往想从数据库中读取指定时间来动态执行定时任务，这时候基于接口的定时任务就大派用场了。基于注解来创建定时任务非常简单，只需几行代码便可完成。@Scheduled 除了支持灵活的参数表达式cron之外，还支持简单的延时操作，例如 fixedDelay ，fixedRate 填写相应的毫秒数即可。
quart定时任务从数据库获取定时时间
哦哟的博客
05-13 2007
在ssm项目里面实现定时任务从数据库获取定时时间 1.创建定时时间表 2.创建定时任务类 package com.tencent.tusi.test.quartzTest; import com.tencent.tusi.business.entity.TSystemUsers; import com.tencent.tusi.business.service.TSystemUsersService; import org.springframework.beans.factory.annotation
在Spring Boot 中使用定时框架Quartz，触发时间在数据库表中获取
weixin_46013627的博客
04-20 2216
背景：在前端页面新建定时任务，将任务存入数据库，包含触发时间及触发模式 数据库表触发时间字段如下： 一、Quartz的介绍 Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，是完全由java开发的一个开源的任务日程管理系统，“任务进度管理器”就是一个在预先确定（被纳入日程）的时间到达时，负责执行（或者通知）其他软件组件的系统。 Quartz用一个小Java库发布文件（.jar文件），这个库文件包含了所有Quartz核心功能。这些...
Springboot设置定时任务，从数据库中获取cron表达式 DEMO
HM_1011000000的博客
08-17 2769
Springboot设置定时任务，自定义 cron表达式 DEMO。
spring + quartz 定时任务修改定时时间不重启服务
09-01
综上所述，使用Quartz的动态定时任务更新功能、数据库表保存定时任务配置参数或者Spring的动态Bean注册功能，都可以实现在不重启服务的情况下修改定时时间。根据实际项目需求和技术架构选择合适的方式即可。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值