[精简版]springboot动态配置定时器

最新推荐文章于 2023-03-28 10:12:45 发布
最新推荐文章于 2023-03-28 10:12:45 发布
阅读量512 收藏 2
点赞数
分类专栏： springboot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YiQieFuCong/article/details/113711071
版权

SpringBoot Quartz 定时任务 动态配置 数据库存储
关键词由CSDN通过智能技术生成

代码地址：https://github.com/gwy572294624/schedule-demo

git clone https://github.com/gwy572294624/schedule-demo

springboot项目 ，执行sql后修改数据库连接地址即可运行部署测试。

动态配置定时器

实现逻辑（文章开始前需要了解）

文章开始前先思考实现动态定时器需要什么

  1. 既然是动态的那就需要有地方存储动态的定时器任务（执行周期，执行的类方法信息）那就使用到了数据库
  2. 定时器动态添加之后有些任务因为业务逻辑需要停用或者更改执行机制，动态定时器需要支持可以增，删，改，停用，启用
  3. 每次项目启动重新加载库中的定时器任务
  4. 在程序中触发定时器是需要重开线程去执行（线程池）
  5. 每次执行的逻辑与结果怎么查看（存储数据库，或者查看程序运行日志）

程序中实现就是

  1. 项目启动初始化加载动态定时器信息或者（给程序中加入定时任务）
  2. 到点触发通过线程执行业务逻辑

代码实现

项目结构

在这里插入图片描述

数据库表信息

#  定时任务表
CREATE TABLE `tb_schedule_job` (
  `job_id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '任务id',
  `bean_name` varchar(200) NOT NULL DEFAULT '' COMMENT 'spring bean名称',
  `method_name` varchar(100) NOT NULL DEFAULT '' COMMENT '方法名',
  `params` varchar(200) NOT NULL DEFAULT '' COMMENT '参数',
  `cron_expression` varchar(100) NOT NULL DEFAULT '' COMMENT 'cron表达式',
  `yn` enum('y','n') NOT NULL DEFAULT 'y',
  `remark` varchar(255) NOT NULL DEFAULT '' COMMENT '备注',
  `ctime` bigint(20) NOT NULL DEFAULT '0' COMMENT '创建时间',
  `utime` bigint(20) NOT NULL DEFAULT '0' COMMENT '修改时间',
  PRIMARY KEY (`job_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COMMENT='定时任务';

INSERT INTO `tb_schedule_job` VALUES (1, 'testDynamicTask', 'test', '这是一个参数', '1 * * * * ? ', 'y', '', 0, 0);
COMMIT;

# 定时任务执行日志表
CREATE TABLE `tb_schedule_job_log` (
  `log_id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '任务日志id',
  `job_id` bigint(20) NOT NULL DEFAULT '0' COMMENT '任务id',
  `bean_name` varchar(200) NOT NULL DEFAULT '' COMMENT 'spring bean名称',
  `method_name` varchar(100) NOT NULL DEFAULT '' COMMENT '方法名',
  `params` varchar(200) NOT NULL DEFAULT '' COMMENT '参数',
  `status` tinyint(4) NOT NULL DEFAULT '0' COMMENT '任务状态    0：成功    1：失败',
  `error` varchar(200) NOT NULL DEFAULT '' COMMENT '失败信息',
  `times` int(11) NOT NULL DEFAULT '0' COMMENT '耗时(单位：毫秒)',
  `ctime` bigint(20) NOT NULL DEFAULT '0' COMMENT '创建时间',
  `yn` enum('y','n') NOT NULL DEFAULT 'y',
  `utime` bigint(20) NOT NULL DEFAULT '0' COMMENT '修改时间',
  PRIMARY KEY (`log_id`),
  KEY `job_id` (`job_id`)
) ENGINE=InnoDB AUTO_INCREMENT=13 DEFAULT CHARSET=utf8 COMMENT='定时任务日志';

pom

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--定时器配置jar-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.68</version>
        </dependency>

主要工具类

该类为程序中定时器增删改查类（主类）

package com.schedule.util.quartz;


import com.schedule.dao.ScheduleJobDO;
import org.quartz.*;

/**
 * 定时任务工具类
 *      该类为程序中定时器增删改查类
 *
 */
public class ScheduleUtils {
    private final static String JOB_NAME = "TASK_";

    /**
     * 获取触发器key
     */
    public static TriggerKey getTriggerKey(Long jobId) {
        return TriggerKey.triggerKey(JOB_NAME + jobId);
    }

    /**
     * 获取jobKey
     */
    public static JobKey getJobKey(Long jobId) {
        return JobKey.jobKey(JOB_NAME + jobId);
    }

    /**
     * 获取表达式触发器
     */
    public static CronTrigger getCronTrigger(Scheduler scheduler, Long jobId) throws SchedulerException {
            return (CronTrigger) scheduler.getTrigger(getTriggerKey(jobId));
    }

    /**
     * 创建定时任务
     */
    public static void createScheduleJob(Scheduler scheduler, ScheduleJobDO scheduleJob) {
        try {

            //构建job信息
            JobDetail jobDetail = JobBuilder.newJob(ScheduleJobUtils.class).withIdentity(getJobKey(scheduleJob.getJobId())).build();

            //表达式调度构建器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression())
                    .withMisfireHandlingInstructionDoNothing();

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

            //放入参数，运行时的方法可以获取
            jobDetail.getJobDataMap().put("JOB_KEY", scheduleJob);
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

    }

    /**
     * 更新定时任务
     */
    public static void updateScheduleJob(Scheduler scheduler, ScheduleJobDO scheduleJob) {
        try {
            TriggerKey triggerKey = getTriggerKey(scheduleJob.getJobId());

            //表达式调度构建器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression())
            		.withMisfireHandlingInstructionDoNothing();

            CronTrigger trigger = getCronTrigger(scheduler, scheduleJob.getJobId());

            //按新的cronExpression表达式重新构建trigger
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

            //参数
            trigger.getJobDataMap().put("JOB_KEY", scheduleJob);

            scheduler.rescheduleJob(triggerKey, trigger);


        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 立即执行任务
     */
    public static void run(Scheduler scheduler, ScheduleJobDO scheduleJob) {
        try {
        	//参数
        	JobDataMap dataMap = new JobDataMap();
        	dataMap.put("JOB_KEY", scheduleJob);

            scheduler.triggerJob(getJobKey(scheduleJob.getJobId()), dataMap);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 暂停任务
     */
    public static void pauseJob(Scheduler scheduler, Long jobId) {
        try {
            scheduler.pauseJob(getJobKey(jobId));
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 恢复任务
     */
    public static void resumeJob(Scheduler scheduler, Long jobId) {
        try {
            scheduler.resumeJob(getJobKey(jobId));
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 删除定时任务
     */
    public static void deleteScheduleJob(Scheduler scheduler, Long jobId) {
        try {
            scheduler.deleteJob(getJobKey(jobId));
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}

每次触发定时器时开启的方法（动态定时器触发类）


package com.schedule.util.quartz;

import com.schedule.config.ThreadPoolCache;
import com.schedule.dao.ScheduleJobDO;
import com.schedule.dao.ScheduleJobLogDO;
import com.schedule.mapper.ScheduleJobLogMapper;
import lombok.extern.slf4j.Slf4j;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.stereotype.Component;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;


/**
 * 定时任务工具
 *  该类为执行方法，每次触发定时器时执行的方法
 *
 */
@Slf4j
@Component
public class ScheduleJobUtils extends QuartzJobBean {

	@Autowired
	private ScheduleJobLogMapper scheduleJobLogMapper;


    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        ScheduleJobDO scheduleJob = (ScheduleJobDO ) context.getMergedJobDataMap()
        		.get("JOB_KEY");

        //获取spring bean
//        ScheduleJobLogService scheduleJobLogService = (ScheduleJobLogService) SpringContextUtils.getBean("scheduleJobLogService");
		long startTime = System.currentTimeMillis();
        //数据库保存执行记录
        ScheduleJobLogDO jobLog = new ScheduleJobLogDO(scheduleJob,startTime);

        //任务开始时间

		Byte zero = 0;

		Byte one=1;
        try {
            //执行任务
        	log.info("任务准备执行，任务ID：" + scheduleJob.getJobId());
            ScheduleRunnable task = new ScheduleRunnable(scheduleJob.getBeanName(),
            		scheduleJob.getMethodName(), scheduleJob.getParams());
            Future<?> future = ThreadPoolCache.InitThreadPoolCache.executorService.submit(task);

			future.get();

			//任务执行总时长
			long times = System.currentTimeMillis() - startTime;
			jobLog.setTimes((int)times);
			//任务状态    0：成功    1：失败
			jobLog.setStatus(zero);

			log.info("任务执行完毕，任务ID：" + scheduleJob.getJobId() + "  总共耗时：" + times + "毫秒");
		} catch (Exception e) {
			log.error("任务执行失败，任务ID：" + scheduleJob.getJobId(), e);

			//任务执行总时长
			long times = System.currentTimeMillis() - startTime;
			jobLog.setTimes((int)times);

			//任务状态    0：成功    1：失败
			jobLog.setStatus(one);
			jobLog.setError(e.toString().substring( 0, 199));
		}finally {
			scheduleJobLogMapper.insert(jobLog);
		}
    }
}

该类为构建线程执行任务（构建动态线程执行任务）

package com.schedule.util.quartz;


import com.schedule.util.SpringContextUtil;
import org.springframework.util.ObjectUtils;
import org.springframework.util.ReflectionUtils;

import java.lang.reflect.Method;

/**
 * 执行定时任务实现
 * 		该类为构建动态线程执行任务。
 *
 */
public class ScheduleRunnable implements Runnable {
	private Object target;
	private Method method;
	private String params;

	public ScheduleRunnable(String beanName, String methodName, String params) throws NoSuchMethodException, SecurityException {
		this.target = SpringContextUtil.getBean(beanName);
		this.params = params;

		if(!ObjectUtils.isEmpty(params)){
			this.method = target.getClass().getDeclaredMethod(methodName, String.class);
		}else{
			this.method = target.getClass().getDeclaredMethod(methodName);
		}
	}

	@Override
	public void run() {
		try {
			ReflectionUtils.makeAccessible(method);
			if(!ObjectUtils.isEmpty(params)){
				method.invoke(target, params);
			}else{
				method.invoke(target);
			}
		}catch (Exception e) {
			e.printStackTrace();
		}
	}

}

项目启动加载数据库中的定时方法到程序中

package com.schedule.config;

import com.schedule.dao.ScheduleJobDO;
import com.schedule.service.ScheduleJobService;
import com.schedule.util.quartz.ScheduleUtils;
import org.quartz.Scheduler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;

import java.util.List;

/**
 * @Author
 * @Date 2021/2/5
 * @Version 1.0
 * @Remarks 项目启动将动态定时器加载到系统中
 */
@Component
public class DynamicTaskInit implements ApplicationRunner {

    @Autowired
    @Qualifier("scheduleJobServiceImpl")
    private ScheduleJobService scheduleJobService;
    @Autowired
    private Scheduler scheduler;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("加载动态定时器");
        List<ScheduleJobDO> scheduleJobDOList = scheduleJobService.getAll();
        if (!ObjectUtils.isEmpty(scheduleJobDOList)){
            for (ScheduleJobDO thisJob:scheduleJobDOList) {
                ScheduleUtils.createScheduleJob(scheduler, thisJob);
            }
        }

    }
}

动态定时器执行的类（动态定时器触发执行的类，类名与方法名参数信息都为动态）（定时器触发的模版类信息）（业务逻辑）

Bean名称默认为首字母小写的类名 如此类bean名称为（testDynamicTask）

package com.schedule.timer;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;


/**
 * @Author
 * @Date 2021/2/5 下午3:31
 * @Version 1.0
 * @Remarks 动态定时器执行的类
 */
@Slf4j
@Component
public class TestDynamicTask {


	//测试方法
    public void test(String params){
        log.info(params);
        System.out.println(System.currentTimeMillis());
    }


    //测试方法2
    public void test2(String params){
        log.info(params);
        System.out.println(System.currentTimeMillis());
    }

}

测试执行

controller

@RestController
@RequestMapping("/test")
public class TestController {
    @Autowired
    @Qualifier("scheduleJobServiceImpl")
    private ScheduleJobService scheduleJobService;

    @RequestMapping("/getall")
    public String getAll(String name){
        return JSON.toJSONString(scheduleJobService.getAll());
    }


    @RequestMapping("/add")
    public String addJob(String methodName,String params,String cronExpression){
        ScheduleJobDO scheduleJobDO=new ScheduleJobDO(methodName,params,cronExpression);
        return scheduleJobService.addJob(scheduleJobDO);
    }

    @RequestMapping("/update")
    public String updateJob(Long jobId,String methodName,String params,String cronExpression){
        ScheduleJobDO scheduleJobDO=new ScheduleJobDO(methodName,params,cronExpression);
        scheduleJobDO.setJobId(jobId);
        return scheduleJobService.updateJob(scheduleJobDO);
    }

    @RequestMapping("/delete")
    public String deleteJob(Long jobId){
        return scheduleJobService.deleteJob(jobId);
    }

}

service

@Service
public class ScheduleJobServiceImpl implements ScheduleJobService {

    @Autowired
    private ScheduleJobMapper scheduleJobMapper;
    @Autowired
    private Scheduler scheduler;
    @Override
    public List<ScheduleJobDO> getAll(){
        return scheduleJobMapper.select(new ScheduleJobDO());
    }

    @Override
    public String addJob(ScheduleJobDO scheduleJobDO) {
        scheduleJobMapper.insert(scheduleJobDO);
        ScheduleUtils.createScheduleJob(scheduler,scheduleJobDO);
        return "add执行成功 ！！";
    }

    @Override
    public String updateJob(ScheduleJobDO scheduleJobDO) {
        scheduleJobMapper.updateByPK(scheduleJobDO);
        ScheduleUtils.updateScheduleJob(scheduler,scheduleJobDO);
        return "update执行成功 ！！";
    }

    @Override
    public String deleteJob(Long jobId) {
        scheduleJobMapper.deleteByPK(jobId);
        ScheduleUtils.deleteScheduleJob(scheduler,jobId);
        return "delete执行成功 ！！";
    }
}

add发送参数

127.0.0.1:8080/test/add?methodName=test2&params=测试新增定时任务&cronExpression=0 0/2 * * * ? *

执行结果

在这里插入图片描述

update发送参数

127.0.0.1:8080/test/update?methodName=test2&params=测试修改定时任务，每秒执行&cronExpression=* * * * * ? * &jobId=2

执行结果

在这里插入图片描述

delete发送参数

127.0.0.1:8080/test/delete?jobId=2

执行结果

在这里插入图片描述
停用与启用对我这边业务没有交互，就不演示了，有需要的可以自己尝试，

扩展

执行线程建议使用cacheThreadPool，因为定时器触发频率很高会导致新创建的线程占用大量内存和cpu无法及时释放。
测试过程中查看控制台日志ScheduleJobUtils类重写的executeInternal方法，默认是10个线程，使用完后会复用（类似线程池）。重写方法中的submit方法执行为自己提供线程池，建议使用cacheThreadPool。
文章中使用的是cacheThreadPool可参考（com.schedule.config.ThreadPoolCache）。

感谢https://blog.csdn.net/belonghuang157405/article/details/85605203
以上 ，希望本文可以帮到你。

Gy-1-__
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二、quartz的主要方法
weixin_41604362的博客
08-07 578
   必须注入Scheduler    ------ @Autowired   private Scheduler scheduler           ScheduleJob实体对象：实现Job------具体的任务内容对象 1、添加任务： public void addJob(ScheduleJob job) {   try {             // 创建jobDetail实...
springboot定时器动态mysql_springboot动态配置定时器
weixin_42508792的博客
01-26 370
首先创建有关定时任务的数据表,我这边用的是mysql,下面是创建语句CREATE TABLE `schedule_job` (`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '任务id',`name` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL C...
Java 任务调度框架 Quartz
方糖世界
12-13 831
文章目录1、Quartz1.1 引入依赖1.2 入门案例1.3 Job 与 JobDetail1.4 JobExecutionContext1.5 JobDataMap1.6 Job 状态1.7 Trigger1.8 SimpleTripper 1、Quartz 1.1 引入依赖 <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifac
java若依框架定时任务
weixin_59499726的博客
03-28 2936
若依框架定时任务
定时任务Quartz框架
liaoqing1999的博客
10-09 583
定时任务Quartz框架定时任务Quartz框架前言参考链接Quartz主要部分简单例子Job与JobDetail介绍TriggersSimpleTriggerCronTrigger 定时任务Quartz框架 前言 最近工作上接触到了定时任务，开始了解Quartz框架 参考链接 W3Cschool文档：https://www.w3cschool.cn/quartz_doc/ Quartz官方地址：http://www.quartz-scheduler.org/documentation/ Quartz主要部
qrcodeutil类中的方法详解_quartz 2.3.1源码分析一：创建JobDetail（JobBuilder详解）
weixin_39675963的博客
12-13 187
上一篇文章我记录了自己封装的QuartzUtil工具类，同时写了一个quartz骨架项目，以便大家理解使用。可在公众号quartz专栏查看。正文开始quartz源码分析第一部分：记录创建定时任务相关的源码。由于不想篇幅太长，所以这一部分将依次分成三篇文章：(这是三篇中的第一篇)创建JobDetail(JobBuilder详解)创建CronTrigger(TriggerBuilder详解)...
Quartz定时任务简单实现
cnsd_liuliu的博客
07-26 1292
一、创建保存定时任务的table bean_class为完全限定名，bean_name为实例化对象 二、创建JobInit类进行初始化工作 package com.mall.task.init; import java.util.List; import javax.annotation.Resource; import org.apache.log4j.Logger; im
springboot定时器
FoolFox
10-23 658
在使用spring的时候遇到如下场景：由于业务需要，需要定时更新数据库，比如每隔两个小时更新一次某个字段的状态，无论是什么场景只要是需要定时去执行某种操作都可以使用spring的定时器任务来解决，以下将介绍springboot如何使用定时器任务：创建定时任务：@Component public class NoticeTask { private SimpleDateFormat simple
SpringBoot 动态定时器的使用方法
08-27
下面将详细介绍这两种动态定时器的使用方法。 1. **使用`@Scheduled`注解** `@Scheduled`注解是Spring框架提供的定时任务注解，可以直接在方法上使用。例如，下面的`ClockTiming`类中定义了一个每天0点执行的定时...
SpringBoot集成ElaticJob定时器的实现代码
08-27
在SpringBoot应用中集成ElasticJob定时器，可以有效地管理和调度分布式任务。ElasticJob是当当网开源的一个分布式任务调度框架，它分为Elastic-Job-Lite（轻量级）和Elastic-Job-Cloud（云版）两个版本，分别适用于...
spring定时器的动态设置
04-01
NULL 博文链接：https://beisicao.iteye.com/blog/1222365
SpringBoot实现定时器
06-14
Spring Boot提供了一种通过配置文件（如application.properties或application.yml）来动态配置定时任务的方式。例如： ```properties # application.properties spring.task.scheduling.pool.size=5 # 设置线程池...
SpringBoot定时器
05-28
这个"SpringBoot定时器"的主题主要涉及的是Spring Boot如何集成和使用Java的定时任务库，如Quartz或Spring自带的Task Scheduling。 首先，Spring Boot内置了对Spring的Task Scheduling的支持，它提供了一个简单易用...
关于给springboot添加定时器的两种方式
05-06
@SpringBootApplication @EnableScheduling public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } } ``` **步骤二：定义定时任务...
jobbuilder.newjob
wangyuhang0813的博客
05-30 2346
package demo01;    import org.quartz.JobBuilder;  import org.quartz.JobDetail;  import org.quartz.Scheduler;  import org.quartz.SchedulerException;  import org.quartz.SchedulerFactory;  import org.qua
SpringBoot系列：Spring Boot集成定时任务Quartz，java百度云短信发送
m0_64867220的博客
12-13 371
然后创建QuartzConfig，接着定义JobDetail，JobDetail由JobBuilder构建，同时关联了任务QuartzJob1。 @Configuration public class QuartzConfig { @Bean public JobDetail jobDetail1(){ return JobBuilder.newJob(QuartzJob1.class).storeDurably().build(); } } 最后我们需要定义定时调度Trigger，简单实现类SimpleS
SpringBoot整合Quartz定时任务框架
qq_34565436的博客
06-14 674
SpringBoot整合Quartz定时任务框架，动态修改cron表达式执行任务
springboot实现quartz定时任务
Rockandrollman的博客
11-25 295
2）usingJobData()方法动态传入Job任务中的参数，这里传入SampleJob任务类中的name参数。当然，也可以不设置参数，Quartz会自动生成一个独一无二的TriggerKey来区分不同的触发器。在上面的示例中，定义的SampleScheduler调度器类包含JobDetail和Trigger两个对象，分别用于控制任务启动时的参数传入和任务触发规则。4）withIntervalInSeconds()方法中的任务触发规则包含withIntervalInXXX等多种时间设置。
SpringBoot任务调度
技术分享博客
03-15 1322
spring boot 两种任务调度实现方式
springboot动态定时器配置文件如何编写
最新发布
04-04
以下是Spring Boot动态定时器配置文件的示例： 1. 创建一个配置文件，例如dynamic-tasks.properties。 2. 在文件中添加以下内容： ``` # 配置动态任务 tasks[0].name=Task1 tasks[0].cron=0 * * * * ? tasks[0].enabled=true tasks[1].name=Task2 tasks[1].cron=0 0 * * * ? tasks[1].enabled=false ``` 3. 创建一个DynamicTask类，用于读取和解析配置文件： ```java @Configuration @ConfigurationProperties(prefix = "tasks") public class DynamicTask { private List<Task> list = new ArrayList<>(); public List<Task> getList() { return list; } public void setList(List<Task> list) { this.list = list; } public static class Task { private String name; private String cron; private boolean enabled; // getters and setters } } ``` 4. 创建一个ScheduledTaskRegistrar类，用于注册定时器任务： ```java @Configuration @EnableScheduling public class ScheduledTaskRegistrar { @Autowired private DynamicTask dynamicTask; @Autowired private TaskScheduler taskScheduler; @PostConstruct public void init() { for (DynamicTask.Task task : dynamicTask.getList()) { if (task.isEnabled()) { taskScheduler.schedule(new Runnable() { @Override public void run() { // 定时器任务逻辑 } }, new CronTrigger(task.getCron())); } } } } ``` 5. 在启动类中添加@EnableConfigurationProperties注解，以启用配置文件属性： ```java @SpringBootApplication @EnableConfigurationProperties(DynamicTask.class) public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } ``` 6. 运行应用程序，动态定时器将从配置文件中加载任务并启动。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值