SpringBoot 动态配置定时任务

最新推荐文章于 2024-08-17 11:09:52 发布
最新推荐文章于 2024-08-17 11:09:52 发布
阅读量114 收藏
点赞数
文章标签： spring boot java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PointerIsSoul/article/details/133644806
版权
  1. pom.xml依赖
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
</dependency>

  1. 主启动类上加上 @EnableScheduling

  2. 表结构

-- 定时器相关配置表
CREATE TABLE if not exists QRTZ_JOB_DETAILS(
    SCHED_NAME VARCHAR(120) NOT NULL,
    JOB_NAME VARCHAR(190) NOT NULL,
    JOB_GROUP VARCHAR(190) NOT NULL,
    DESCRIPTION VARCHAR(250) NULL,
    JOB_CLASS_NAME VARCHAR(250) NOT NULL,
    IS_DURABLE VARCHAR(1) NOT NULL,
    IS_NONCONCURRENT VARCHAR(1) NOT NULL,
    IS_UPDATE_DATA VARCHAR(1) NOT NULL,
    REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
    JOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP))
    ENGINE=InnoDB;

CREATE TABLE if not exists QRTZ_TRIGGERS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(190) NOT NULL,
    TRIGGER_GROUP VARCHAR(190) NOT NULL,
    JOB_NAME VARCHAR(190) NOT NULL,
    JOB_GROUP VARCHAR(190) NOT NULL,
    DESCRIPTION VARCHAR(250) NULL,
    NEXT_FIRE_TIME BIGINT(13) NULL,
    PREV_FIRE_TIME BIGINT(13) NULL,
    PRIORITY INTEGER NULL,
    TRIGGER_STATE VARCHAR(16) NOT NULL,
    TRIGGER_TYPE VARCHAR(8) NOT NULL,
    START_TIME BIGINT(13) NOT NULL,
    END_TIME BIGINT(13) NULL,
    CALENDAR_NAME VARCHAR(190) NULL,
    MISFIRE_INSTR SMALLINT(2) NULL,
    JOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
    REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP))
    ENGINE=InnoDB;

CREATE TABLE if not exists QRTZ_SIMPLE_TRIGGERS (
  	SCHED_NAME VARCHAR(120) NOT NULL,
  	TRIGGER_NAME VARCHAR(190) NOT NULL,
  	TRIGGER_GROUP VARCHAR(190) NOT NULL,
  	REPEAT_COUNT BIGINT(7) NOT NULL,
  	REPEAT_INTERVAL BIGINT(12) NOT NULL,
  	TIMES_TRIGGERED BIGINT(10) NOT NULL,
  	PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
  	FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
  	REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
    ENGINE=InnoDB;

CREATE TABLE if not exists QRTZ_CRON_TRIGGERS (
   SCHED_NAME VARCHAR(120) NOT NULL,
   TRIGGER_NAME VARCHAR(190) NOT NULL,
   TRIGGER_GROUP VARCHAR(190) NOT NULL,
   CRON_EXPRESSION VARCHAR(120) NOT NULL,
   TIME_ZONE_ID VARCHAR(80),
   PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
   FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
   REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
   ENGINE=InnoDB;

CREATE TABLE if not exists QRTZ_SIMPROP_TRIGGERS
(
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(190) NOT NULL,
    TRIGGER_GROUP VARCHAR(190) NOT NULL,
    STR_PROP_1 VARCHAR(512) NULL,
    STR_PROP_2 VARCHAR(512) NULL,
    STR_PROP_3 VARCHAR(512) NULL,
    INT_PROP_1 INT NULL,
    INT_PROP_2 INT NULL,
    LONG_PROP_1 BIGINT NULL,
    LONG_PROP_2 BIGINT NULL,
    DEC_PROP_1 NUMERIC(13,4) NULL,
    DEC_PROP_2 NUMERIC(13,4) NULL,
    BOOL_PROP_1 VARCHAR(1) NULL,
    BOOL_PROP_2 VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
    ENGINE=InnoDB;

CREATE TABLE if not exists QRTZ_BLOB_TRIGGERS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(190) NOT NULL,
    TRIGGER_GROUP VARCHAR(190) NOT NULL,
    BLOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
    ENGINE=InnoDB;

CREATE TABLE if not exists QRTZ_CALENDARS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    CALENDAR_NAME VARCHAR(190) NOT NULL,
    CALENDAR BLOB NOT NULL,
    PRIMARY KEY (SCHED_NAME,CALENDAR_NAME))
    ENGINE=InnoDB;

CREATE TABLE if not exists QRTZ_PAUSED_TRIGGER_GRPS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_GROUP VARCHAR(190) NOT NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP))
    ENGINE=InnoDB;

CREATE TABLE if not exists QRTZ_FIRED_TRIGGERS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    ENTRY_ID VARCHAR(95) NOT NULL,
    TRIGGER_NAME VARCHAR(190) NOT NULL,
    TRIGGER_GROUP VARCHAR(190) NOT NULL,
    INSTANCE_NAME VARCHAR(190) NOT NULL,
    FIRED_TIME BIGINT(13) NOT NULL,
    SCHED_TIME BIGINT(13) NOT NULL,
    PRIORITY INTEGER NOT NULL,
    STATE VARCHAR(16) NOT NULL,
    JOB_NAME VARCHAR(190) NULL,
    JOB_GROUP VARCHAR(190) NULL,
    IS_NONCONCURRENT VARCHAR(1) NULL,
    REQUESTS_RECOVERY VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,ENTRY_ID))
    ENGINE=InnoDB;

CREATE TABLE if not exists QRTZ_SCHEDULER_STATE (
    SCHED_NAME VARCHAR(120) NOT NULL,
    INSTANCE_NAME VARCHAR(190) NOT NULL,
    LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
    CHECKIN_INTERVAL BIGINT(13) NOT NULL,
    PRIMARY KEY (SCHED_NAME,INSTANCE_NAME))
    ENGINE=InnoDB;

CREATE TABLE if not exists QRTZ_LOCKS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    LOCK_NAME VARCHAR(40) NOT NULL,
    PRIMARY KEY (SCHED_NAME,LOCK_NAME))
    ENGINE=InnoDB;
  1. 定时任务配置类
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import javax.sql.DataSource;
import java.util.Properties;

/**
 * 定时任务配置
 */
@Configuration
public class ScheduleConfig {

	@Bean
	public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource) {
		SchedulerFactoryBean factory = new SchedulerFactoryBean();
		factory.setDataSource(dataSource);

		//quartz参数
		Properties prop = new Properties();
		prop.put("org.quartz.scheduler.instanceName", "SchedulerName");
		prop.put("org.quartz.scheduler.instanceId", "AUTO");
		//线程池配置
		prop.put("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");
		prop.put("org.quartz.threadPool.threadCount", "20");
		prop.put("org.quartz.threadPool.threadPriority", "5");
		//JobStore配置
		//定时任务抛出 org.quartz.SchedulerConfigException: DataSource name not set. 异常.
		//prop.put("org.quartz.jobStore.class", "org.quartz.impl.jdbcjobstore.JobStoreTX");
		prop.put("org.quartz.jobStore.class", "org.springframework.scheduling.quartz.LocalDataSourceJobStore");
		//集群配置
		prop.put("org.quartz.jobStore.isClustered", "true");
		prop.put("org.quartz.jobStore.clusterCheckinInterval", "15000");
		prop.put("org.quartz.jobStore.maxMisfiresToHandleAtATime", "1");

		prop.put("org.quartz.jobStore.misfireThreshold", "12000");
		prop.put("org.quartz.jobStore.tablePrefix", "QRTZ_");
		prop.put("org.quartz.jobStore.selectWithLockSQL", "SELECT * FROM {0}LOCKS UPDLOCK WHERE LOCK_NAME = ?");

		//PostgreSQL数据库，需要打开此注释
		//prop.put("org.quartz.jobStore.driverDelegateClass", "org.quartz.impl.jdbcjobstore.PostgreSQLDelegate");

		factory.setQuartzProperties(prop);

		factory.setSchedulerName("SchedulerName");
		//延时启动
		factory.setStartupDelay(30);
		factory.setApplicationContextSchedulerContextKey("applicationContextKey");
		//可选，QuartzScheduler 启动时更新己存在的Job，这样就不用每次修改targetObject后删除qrtz_job_details表对应记录了
		factory.setOverwriteExistingJobs(true);
		//设置自动启动，默认为true
		factory.setAutoStartup(true);

		return factory;
	}
}
  1. 定时任务工具类
import org.quartz.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ScheduleJobUtils {

	private static final Logger logger = LoggerFactory.getLogger(ScheduleJobUtils.class);

	public static void deleteScheduleJob(Scheduler scheduler, String NAME, String JOB_NAME, String JOB_GROUP) {
		try {
			TriggerKey triggerKey = TriggerKey.triggerKey(JOB_NAME,	JOB_GROUP);
			if( scheduler.checkExists(triggerKey) ){
				//如果存在测删除
				scheduler.pauseTrigger(triggerKey);
            	scheduler.unscheduleJob(triggerKey);
			}

			JobKey jobKey = new JobKey(JOB_NAME, JOB_GROUP);
			if(scheduler.checkExists(jobKey)){
				scheduler.pauseJob(jobKey);		//停止任务
				scheduler.deleteJob(jobKey);	//删除任务
			}
			logger.info("删除【"+NAME+"】定时任务成功！");
		}catch (Exception e) {
			logger.error("删除【"+NAME+"】定时任务失败！", e);
		}
	}

	/**
	 * 方法名：addOrUpdateScheduleJob
	 *
	 * @param NAME        任务中文名称
	 * @param JOB_NAME    任务名
	 * @param JOB_GROUP   任务组
	 * @param jobClass    任务执行类
	 */
	public static void addOrUpdateScheduleJob(Scheduler scheduler, String NAME, String JOB_NAME, String JOB_GROUP, String CronExpression, Class <? extends Job> jobClass){
		try{
			deleteScheduleJob(scheduler, NAME, JOB_NAME, JOB_GROUP);
			//CronExpression-表达式调度构建器
			/**
			Cron表达式范例：
				每隔5秒执行一次：0/5 * * * * ?
				每隔1分钟执行一次：0 0/1 * * * ?
				每天23点执行一次：0 0 23 * * ?
				每天凌晨1点执行一次：0 0 1 * * ?
				每月1号凌晨1点执行一次：0 0 1 1 * ?
				每月最后一天23点执行一次：0 0 23 L * ?
				每周星期天凌晨1点实行一次：0 0 1 ? * L
				在26分、29分、33分执行一次：0 26,29,33 * * * ?
				每天的0点、13点、18点、21点都执行一次：0 0 0,13,18,21 * * ?
			*/
			CronExpression cronExpressionObj = new CronExpression(CronExpression);
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpressionObj).withMisfireHandlingInstructionDoNothing();

			//创建新触发条件
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			String datestr = sdf.format(new Date()) + " 00:00:00";
			Date startDate = stringToDateTime(datestr);
			//Date startDate = new Date(System.currentTimeMillis()+5*1000);

			CronTrigger newcorntrigger = TriggerBuilder.newTrigger()
					.withIdentity(JOB_NAME, JOB_GROUP)
					.startAt(startDate)
					.withSchedule(scheduleBuilder)
					.build();

			//创建任务对象
			JobKey jobKey = new JobKey(JOB_NAME, JOB_GROUP);
			SimpleDateFormat sdfall = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			JobDetail executeJob= JobBuilder.newJob(jobClass)
									.withIdentity(jobKey)
									.withDescription(sdfall.format(new Date()))
									.storeDurably(true)//没有trigger关联时自动删除
									.requestRecovery()//失败后重做
									//.usingJobData("createtaskdaynum", createtaskdaynum)
									.build();

			//按新的trigger重新设置job执行
			scheduler.scheduleJob(executeJob, newcorntrigger);

			logger.info("启动或更新【"+NAME+"】定时任务成功！");
		}catch(Exception e){
			logger.error("启动或更新【"+NAME+"】定时任务失败！", e);
		}
	}

	/**
	 * 手动执行任务
	 * @param scheduler
	 * @param JOB_NAME
	 * @param JOB_GROUP
	 */
	public static void triggerScheduleJob(Scheduler scheduler, String JOB_NAME, String JOB_GROUP){
		try{
			JobKey jobKey = new JobKey(JOB_NAME, JOB_GROUP);
			scheduler.triggerJob(jobKey);
		}catch(Exception e){
			logger.error("手动执行【"+JOB_NAME+"】定时任务失败！", e);
		}
	}

	/**
	 * 方法名称：isMatch
	 * @param crontabExpress	 表达式（如：* * 7 * * ? *）
	 * @param date
	 * @return
	 * @throws java.text.ParseException
	 * 作用说明：此函数的作用是判断给定的时间 是否 满足 crontab 表达式【忽略毫秒】
	 */
	private static boolean isMatch(String crontabExpress, Date date) {
		try {
			if(crontabExpress==null){
				return false;
			}
			if(crontabExpress.equals("")){
				return false;
			}
			CronExpression crontabExpression = new CronExpression(crontabExpress);
			return crontabExpression.isSatisfiedBy(date);
		} catch (Exception e) {
			logger.error("错误的cron表达式"+crontabExpress, e);
			return false;
		}
	}


	/**
	 * 字符转换日期时间对象
	 */
	private static Timestamp stringToDateTime(String time) {
		try{
			SimpleDateFormat formatter = null;
			if ((time.indexOf("/") > -1) && (time.indexOf(" ") > -1)) {
				formatter = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
			} else if ((time.indexOf("-") > -1) && (time.indexOf(" ") > -1)) {
				formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			}else if ((time.indexOf(".") > -1) && (time.indexOf(" ") > -1)) {
				formatter = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
			} else if ((time.indexOf("/") > -1) && (time.indexOf(" ") == -1)) {
				formatter = new SimpleDateFormat("yyyy/MM/dd");
			} else if ((time.indexOf("-") > -1) && (time.indexOf(" ") == -1)) {
				formatter = new SimpleDateFormat("yyyy-MM-dd");
			}else if ((time.indexOf(".") > -1) && (time.indexOf(" ") == -1)) {
				formatter = new SimpleDateFormat("yyyy.MM.dd");
			}else{
				formatter = new SimpleDateFormat("yyyyMMddHHmmss");
			}
			Date ctime = formatter.parse(time);
			Timestamp reval =  new Timestamp(ctime.getTime());
			return reval;
		}catch(Exception e){
			return null;
		}
	}

}
  1. 日期工具类
import java.sql.Timestamp;

/**
 * 日期处理
 */
public class DateUtils {	

	/**
	 * timestamp 转 cron表达式
	 * @param timestamp
	 * @return
	 */
	public static String convertToCronExpression(Timestamp timestamp) {
		// 从Timestamp中提取小时、分钟和秒
		int hour = timestamp.toLocalDateTime().getHour();
		int minute = timestamp.toLocalDateTime().getMinute();
		int second = timestamp.toLocalDateTime().getSecond();

		// 构建每日的cron表达式
		String cronExpression = second + " " + minute + " " + hour + " * * ?";

		return cronExpression;
	}
}
  1. TestScheduled 类，新增定时任务
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.quartz.Scheduler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.sql.Timestamp;

@Data
@Slf4j
@Component
public class TestScheduled {

	@Autowired
	private ITestService testService;

	@Resource
	private Scheduler scheduler;

	@PostConstruct
	public void init() {
		try{
			log.info("系统启动中, 注册定时任务");

			// 查数据库获取有效的 数据
			List<TestObj> list = new ArrayList<>();
			for (TestObj obj : list){
				// timestamp 转 cron表达式
				Timestamp cron = obj.getTime();
				String cronExpression = DateUtils.convertToCronExpression(cron);
				
				// 新增定时任务。obj.getId()参数必须唯一。
				ScheduleJobUtils.addOrUpdateScheduleJob(scheduler, "定时执行业务", "test-"+obj.getId(),"system", cronExpression, DetentionJob.class);
			}
		}catch (Exception e){
			log.error("系统启动中, 注册定时任务异常", e);
		}
	}



}
  1. Job 任务类, 定时任务到了触发时间执行具体业务逻辑
import org.quartz.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springblade.core.tool.utils.BeanUtil;
import org.springblade.core.tool.utils.SpringUtil;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.sql.Timestamp;
import java.util.Date;
import java.util.List;

public class TestJob implements Job {

	protected Logger logger = LoggerFactory.getLogger(getClass());

	private ITestService testService;

	public TestJob(){
		testService = SpringUtil.getBean(ITestService.class);	
	}

	/**
	 * 该方法到了触发时间自动触发
	 */
	@Override
	public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
		try{
			// 查数据库获取有效的 数据
			List<TestEntity> list = new ArrayList<>();
			// 处理数据
			for (TestEntity obj : list){
				
				// 获取业务时间
				Timestamp cron = obj.getTime();
				// timestamp 转 cron表达式
				String cronExpression = ScheduleJobUtils.convertToCronExpression(cron);
				// jobExecutionContext.getFireTime() 为触发时间
				boolean match = isMatch(cronExpression, jobExecutionContext.getFireTime());
				// 满足业务条件
				if (match){
					// 执行业务操作
				}
					

			}
		}catch (Exception e){
			logger.error("错误: " , e);
		}

	}
	
}
doshy_
关注
SpringBoot设置动态定时任务
m0_67390969的博客
08-02 322
先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。之前写过文章记录怎么在SpringBoot项目中简单使用定时任务，不过由于要借助cron表达式且都提前定义好放在配置文件里，不能在项目运行中动态修改任务执行时间，实在不太灵活。除了上面的借助cron表达式的方法，还有另一种触发器，区别于CronTrigger触发器，该触发器可随意设置循环间隔时间，不像cron表达式只能定义小于等于间隔59秒。可以看到任务变成了15秒执行一次。...
Springboot2-Quartz 后台可动态配置的定时任务
02-28
SpringBoot2 与 Quartz 整合的Demo。 后台可添加、修改、移除 定时任务。 也可查看当前任务的状态 灵活的定时任务
springboot动态配置定时任务(schedule)
06-13
springboot动态配置定时任务(schedule),可不重启项目实现开关重启任务,改变任务定时规则
springboot+Quartz通过数据库控制定时任务执行与时间
最新发布
xc9711的博客
08-17 861
springboot使用Quartz用简单的方式建表用数据库数据控制定时任务是否执行，以及变更定时任务执行时间
SpringBoot的定时任务动态管理
怪只怪满眼尽是人间烟火
01-30 688
地址：GitHub - guoyixing/super-scheduled: SpringBoot的定时调用的加强工具，实现定时任务动态管理，后续加入可视化管理、调度日志、集群任务统一管理
Spring / SpringBoot集成Quartz实现动态管理定时任务
qq_44322555的博客
08-05 7834
前言： 最近在做Java开发对接微信公众平台之类的工作，在开发过程中遇到一个需求是定时任务这块的，但是普通的定时任务还远远不能满足；最后要实现的效果是每个任务都是不同的定时时间来执行而且是在前台页面上来控制这些任务的创建，取消，开启，暂停；就好比是向数据库添加一条记录（任务）那么在添加成功后这个任务就是进入定时执行状态了，每次执行的时间是由添加任务时前台页面选择的时间； 要实现的效果如下： 该项目的整体框架和环境选用的时SpringBoot，所以当时在网上看了大部分的boot整合Quartz的文章发现都
Spring Boot动态设置定时任务
cn_220107的博客
04-04 5018
Spring Boot动态设置定时任务
Spring Boot 实现定时任务动态管理
程序员子龙
03-25 2257
本文主要介绍了SpringBoot架构下动态定时任务的使用，定时任务表达式配置在数据库中，通过反射执行到目标方法。Quartz定时任务默认都是并发执行的，不会等待上一次任务执行完毕，只要间隔时间到就会执行, 如果定时任执行太长，会长时间占用资源，导致其它任务堵塞。一般设置都是禁止并发执行//禁止并发执行@Override/*** 线程本地变量*/@Overridetry {if (sysJob!= null)log.error("任务执行异常 - ：", e);/**
SpringBoot中并发定时任务的实现、动态定时任务的实现（看这一篇就够了）推荐
08-26
同时，为了实现动态定时任务，即在运行时修改任务的执行时间或频率，可以通过监听配置中心的变化，动态更新`@Scheduled`的cron表达式，或者使用Quartz等更灵活的调度库，它们通常提供API或接口来实现任务的动态管理...
springboot 动态配置定时任务
09-23
总结起来，使用Spring Boot实现动态配置定时任务的步骤包括：启用定时任务和异步执行的功能、创建实现`Runnable`接口的定时任务类、注入`TaskScheduler`接口并调用`schedule()`方法、实例化`CronTrigger`并传入时间...
springboot动态配置定时任务
06-28
如果您想要动态配置定时任务，可以使用Spring的@Scheduled注释和Cron表达式来实现。Cron表达式是一种用于指定定时任务执行时间的语法。您可以使用Cron表达式来指定任务的执行时间，例如每天的早上6点执行任务。在...
Quartz+Spring Boot实现动态管理定时任务
08-26
最近做项目遇到动态管理定时任务的需求，刚拿到这个需求还真不知道从哪下手，经过一番思考，终于找出实现思路，接下来通过本文给大家介绍了Quartz+Spring Boot实现动态管理定时任务的相关知识,需要的朋友可以参考下
SpringBoot 定时任务动态管理通用解决方案
2401_83384536的博客
06-07 768
SpringBoot的定时任务的加强工具，实现对SpringBoot原生的定时任务进行动态管理,完全兼容原生@Scheduled注解,无需对原本的定时任务进行修改
基于SpringBoot实现轻量级的动态定时任务调度
糖拌西红柿
07-07 1083
定时任务，动态定时任务实现，SpringBoot实现定时任务
springboot 动态添加定时任务（配合数据库增删查改定时任务）
fanghuainihao的博客
07-11 7937
Quartz作业存储方式 Quartz提供两种基本作业存储类型。第一种类型叫做RAMJobStore，第二种类型叫做JDBC作业存储。 RAMJobStore和JDBC作业存储比较 RAMJobStore和JDBC作业存储比较 类型 优点 缺点 RAMJobStore 不要外部数据库，配置容易，运行速度快 因为调度程序信息是存储在被分配给JVM的内存里面，所以，...
基于Spring Boot 实现定时任务
justdo.fun博客
03-27 238
基于Spring Boot 实现定时任务 添加maven依赖 &lt;properties&gt; &lt;java.version&gt;1.8&lt;/java.version&gt; &lt;/properties&gt; &lt;dependencies&gt; &lt;dependency&gt; &lt;groupId&gt;org.s
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值