Spring Boot 实现定时任务动态管理，太爽了！

最新推荐文章于 2023-06-30 17:38:58 发布
最新推荐文章于 2023-06-30 17:38:58 发布
阅读量300 收藏
点赞数
分类专栏： JAVA 文章标签： spring boot 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45635347/article/details/131460950
版权

一、功能说明

SpringBoot的定时任务的加强工具，实现对SpringBoot原生的定时任务进行动态管理,完全兼容原生@Scheduled注解,无需对原本的定时任务进行修改。

二、快速使用

具体的功能已经封装成SpringBoot-starter即插即用：

<dependency>
    <groupId>com.github.guoyixing</groupId>
    <artifactId>spring-boot-starter-super-scheduled</artifactId>
    <version>0.3.1</version>
</dependency>

使用方法和源码：

  • 码云：https://gitee.com/qiaodaimadewangcai/super-scheduled

  • github：https://github.com/guoyixing/super-scheduled

推荐一个开源免费的 Spring Boot 实战项目：

https://github.com/javastacks/spring-boot-best-practice

三、实现原理

1、动态管理实现

(1) 配置管理介绍

@Component("superScheduledConfig")
public class SuperScheduledConfig {
    /**
     * 执行定时任务的线程池
     */
    private ThreadPoolTaskScheduler taskScheduler;

    /**
     * 定时任务名称与定时任务回调钩子  的关联关系容器
     */
    private Map<String, ScheduledFuture> nameToScheduledFuture = new ConcurrentHashMap<>();

    /**
     * 定时任务名称与定时任务需要执行的逻辑  的关联关系容器
     */
    private Map<String, Runnable> nameToRunnable = new ConcurrentHashMap<>();

    /**
     * 定时任务名称与定时任务的源信息  的关联关系容器
     */
    private Map<String, ScheduledSource> nameToScheduledSource = new ConcurrentHashMap<>();
 /* 普通的get/sets省略 */
}

(2) 使用后处理器拦截SpringBoot原本的定时任务

  • 实现ApplicationContextAware接口拿到SpringBoot的上下文

  • 实现BeanPostProcessor接口，将这个类标记为后处理器，后处理器会在每个bean实例化之后执行

  • 使用@DependsOn注解强制依赖SuperScheduledConfig类，让SpringBoot实例化SuperScheduledPostProcessor类之前先实例化SuperScheduledConfig类

  • 主要实现逻辑在postProcessAfterInitialization()方法中

@DependsOn({"superScheduledConfig"})
@Component
@Order
public class SuperScheduledPostProcessor implements BeanPostProcessor, ApplicationContextAware {
    protected final Log logger = LogFactory.getLog(getClass());

    private ApplicationContext applicationContext;

    /**
     * 实例化bean之前的操作
     * @param bean bean实例
     * @param beanName bean的Name
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    /**
     * 实例化bean之后的操作
     * @param bean bean实例
     * @param beanName bean的Name
     */
    @Override
    public Object postProcessAfterInitialization(Object bean,
                                                 String beanName) throws BeansException {
        //1.获取配置管理器
        SuperScheduledConfig superScheduledConfig = applicationContext.getBean(SuperScheduledConfig.class);

        //2.获取当前实例化完成的bean的所有方法
        Method[] methods = bean.getClass().getDeclaredMethods();
        //循环处理对每个方法逐一处理
        if (methods.length > 0) {
            for (Method method : methods) {
             //3.尝试在该方法上获取@Scheduled注解（SpringBoot的定时任务注解）
                Scheduled annotation = method.getAnnotation(Scheduled.class);
                //如果无法获取到@Scheduled注解，就跳过这个方法
                if (annotation == null) {
                    continue;
                }
                //4.创建定时任务的源属性
                //创建定时任务的源属性（用来记录定时任务的配置，初始化的时候记录的是注解上原本的属性）
                ScheduledSource scheduledSource = new ScheduledSource(annotation, method, bean);
                //对注解上获取到源属性中的属性进行检测
                if (!scheduledSource.check()) {
                    throw new SuperScheduledException("在" + beanName + "Bean中" + method.getName() + "方法的注解参数错误");
                }
                //生成定时任务的名称（id），使用beanName+“.”+方法名
                String name = beanName + "." + method.getName();
                //将以key-value的形式，将源数据存入配置管理器中，key：定时任务的名称 value：源数据
                superScheduledConfig.addScheduledSource(name, scheduledSource);
                try {
                 //5.将原本SpringBoot的定时任务取消掉
                    clearOriginalScheduled(annotation);
                } catch (Exception e) {
                    throw new SuperScheduledException("在关闭原始方法" + beanName + method.getName() + "时出现错误");
                }
            }
        }
        //最后bean保持原有返回
        return bean;
    }

    /**
     * 修改注解原先的属性
     * @param annotation 注解实例对象
     * @throws Exception
     */
    private void clearOriginalScheduled(Scheduled annotation) throws Exception {
        changeAnnotationValue(annotation, "cron", Scheduled.CRON_DISABLED);
        changeAnnotationValue(annotation, "fixedDelay", -1L);
        changeAnnotationValue(annotation, "fixedDelayString", "");
        changeAnnotationValue(annotation, "fixedRate", -1L);
        changeAnnotationValue(annotation, "fixedRateString", "");
        changeAnnotationValue(annotation, "initialDelay", -1L);
        changeAnnotationValue(annotation, "initialDelayString", "");
    }

    /**
     * 获取SpringBoot的上下文
     * @param applicationContext SpringBoot的上下文
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

(3) 使用ApplicationRunner初始化自定义的定时任务运行器

  • 实现ApplicationContextAware接口拿到SpringBoot的上下文

  • 使用@DependsOn注解强制依赖threadPoolTaskScheduler类

  • 实现ApplicationRunner接口，在所有bean初始化结束之后，运行自定义逻辑

  • 主要实现逻辑在run()方法中

@DependsOn("threadPoolTaskScheduler") @Component public class SuperScheduledApplicationRunner implements ApplicationRunner, ApplicationContextAware {     protected final Log logger = LogFactory.getLog(getClass());     private DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");     private ApplicationContext applicationContext;  /**      * 定时任务配置管理器      */     @Autowired     private SuperScheduledConfig superScheduledConfig;     /**      * 定时任务执行线程      */     @Autowired     private ThreadPoolTaskScheduler threadPoolTaskScheduler;     @Override     public void run(ApplicationArguments args) {      //1.定时任务配置管理器中缓存  定时任务执行线程         superScheduledConfig.setTaskScheduler(threadPoolTaskScheduler);         //2.获取所有定时任务源数据         Map<String, ScheduledSource> nameToScheduledSource = superScheduledConfig.getNameToScheduledSource();         //逐一处理定时任务         for (String name : nameToScheduledSource.keySet()) {             //3.获取定时任务源数据             ScheduledSource scheduledSource = nameToScheduledSource.get(name);             //4.获取所有增强类             String[] baseStrengthenBeanNames = applicationContext.getBeanNamesForType(BaseStrengthen.class);             //5.创建执行控制器             SuperScheduledRunnable runnable = new SuperScheduledRunnable();             //配置执行控制器             runnable.setMethod(scheduledSource.getMethod());             runnable.setBean(scheduledSource.getBean());             //6.逐一处理增强类（增强器实现原理后面具体分析）             List<Point> points = new ArrayList<>(baseStrengthenBeanNames.length);             for (String baseStrengthenBeanName : baseStrengthenBeanNames) {              //7.将增强器代理成point                 Object baseStrengthenBean = applicationContext.getBean(baseStrengthenBeanName);                 //创建代理                 Point proxy = ProxyUtils.getInstance(Point.class, new RunnableBaseInterceptor(baseStrengthenBean, runnable));                 proxy.setSuperScheduledName(name);                 //8.所有的points连成起来                 points.add(proxy);             }    //将point形成调用链             runnable.setChain(new Chain(points));             //将执行逻辑封装并缓存到定时任务配置管理器中             superScheduledConfig.addRunnable(name, runnable::invoke);             try {              //8.启动定时任务                 ScheduledFuture<?> schedule = ScheduledFutureFactory.create(threadPoolTaskScheduler                         , scheduledSource, runnable::invoke);                 //将线程回调钩子存到任务配置管理器中                 superScheduledConfig.addScheduledFuture(name, schedule);                 logger.info(df.format(LocalDateTime.now()) + "任务" + name + "已经启动...");             } catch (Exception e) {                 throw new SuperScheduledException("任务" + name + "启动失败，错误信息：" + e.getLocalizedMessage());             }         }     }     @Override     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {         this.applicationContext = applicationContext;     } } 

(4) 进行动态管理

@Component public class SuperScheduledManager {     protected final Log logger = LogFactory.getLog(getClass());     private DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");     @Autowired     private SuperScheduledConfig superScheduledConfig;     /**      * 修改Scheduled的执行周期      *      * @param name scheduled的名称      * @param cron cron表达式      */     public void setScheduledCron(String name, String cron) {         //终止原先的任务         cancelScheduled(name);         //创建新的任务         ScheduledSource scheduledSource = superScheduledConfig.getScheduledSource(name);         scheduledSource.clear();         scheduledSource.setCron(cron);         addScheduled(name, scheduledSource);     }     /**      * 修改Scheduled的fixedDelay      *      * @param name       scheduled的名称      * @param fixedDelay 上一次执行完毕时间点之后多长时间再执行      */     public void setScheduledFixedDelay(String name, Long fixedDelay) {         //终止原先的任务         cancelScheduled(name);         //创建新的任务         ScheduledSource scheduledSource = superScheduledConfig.getScheduledSource(name);         scheduledSource.clear();         scheduledSource.setFixedDelay(fixedDelay);         addScheduled(name, scheduledSource);     }     /**      * 修改Scheduled的fixedRate      *      * @param name      scheduled的名称      * @param fixedRate 上一次开始执行之后多长时间再执行      */     public void setScheduledFixedRate(String name, Long fixedRate) {         //终止原先的任务         cancelScheduled(name);         //创建新的任务         ScheduledSource scheduledSource = superScheduledConfig.getScheduledSource(name);         scheduledSource.clear();         scheduledSource.setFixedRate(fixedRate);         addScheduled(name, scheduledSource);     }     /**      * 查询所有启动的Scheduled      */     public List<String> getRunScheduledName() {         Set<String> names = superScheduledConfig.getNameToScheduledFuture().keySet();         return new ArrayList<>(names);     }     /**      * 查询所有的Scheduled      */     public List<String> getAllSuperScheduledName() {         Set<String> names = superScheduledConfig.getNameToRunnable().keySet();         return new ArrayList<>(names);     }     /**      * 终止Scheduled      *      * @param name scheduled的名称      */     public void cancelScheduled(String name) {         ScheduledFuture scheduledFuture = superScheduledConfig.getScheduledFuture(name);         scheduledFuture.cancel(true);         superScheduledConfig.removeScheduledFuture(name);         logger.info(df.format(LocalDateTime.now()) + "任务" + name + "已经终止...");     }     /**      * 启动Scheduled      *      * @param name            scheduled的名称      * @param scheduledSource 定时任务的源信息      */     public void addScheduled(String name, ScheduledSource scheduledSource) {         if (getRunScheduledName().contains(name)) {             throw new SuperScheduledException("定时任务" + name + "已经被启动过了");         }         if (!scheduledSource.check()) {             throw new SuperScheduledException("定时任务" + name + "源数据内容错误");         }         scheduledSource.refreshType();         Runnable runnable = superScheduledConfig.getRunnable(name);         ThreadPoolTaskScheduler taskScheduler = superScheduledConfig.getTaskScheduler();         ScheduledFuture<?> schedule = ScheduledFutureFactory.create(taskScheduler, scheduledSource, runnable);         logger.info(df.format(LocalDateTime.now()) + "任务" + name + "已经启动...");         superScheduledConfig.addScheduledSource(name, scheduledSource);         superScheduledConfig.addScheduledFuture(name, schedule);     }     /**      * 以cron类型启动Scheduled      *      * @param name scheduled的名称      * @param cron cron表达式      */     public void addCronScheduled(String name, String cron) {         ScheduledSource scheduledSource = new ScheduledSource();         scheduledSource.setCron(cron);         addScheduled(name, scheduledSource);     }     /**      * 以fixedDelay类型启动Scheduled      *      * @param name         scheduled的名称      * @param fixedDelay   上一次执行完毕时间点之后多长时间再执行      * @param initialDelay 第一次执行的延迟时间      */     public void addFixedDelayScheduled(String name, Long fixedDelay, Long... initialDelay) {         ScheduledSource scheduledSource = new ScheduledSource();         scheduledSource.setFixedDelay(fixedDelay);         if (initialDelay != null && initialDelay.length == 1) {             scheduledSource.setInitialDelay(initialDelay[0]);         } else if (initialDelay != null && initialDelay.length > 1) {             throw new SuperScheduledException("第一次执行的延迟时间只能传入一个参数");         }         addScheduled(name, scheduledSource);     }     /**      * 以fixedRate类型启动Scheduled      *      * @param name         scheduled的名称      * @param fixedRate    上一次开始执行之后多长时间再执行      * @param initialDelay 第一次执行的延迟时间      */     public void addFixedRateScheduled(String name, Long fixedRate, Long... initialDelay) {         ScheduledSource scheduledSource = new ScheduledSource();         scheduledSource.setFixedRate(fixedRate);         if (initialDelay != null && initialDelay.length == 1) {             scheduledSource.setInitialDelay(initialDelay[0]);         } else if (initialDelay != null && initialDelay.length > 1) {             throw new SuperScheduledException("第一次执行的延迟时间只能传入一个参数");         }         addScheduled(name, scheduledSource);     }     /**      * 手动执行一次任务      *      * @param name scheduled的名称      */     public void runScheduled(String name) {         Runnable runnable = superScheduledConfig.getRunnable(name);         runnable.run();     } } 
2、增强接口实现

增强器实现的整体思路与SpringAop的思路一致，实现没有Aop复杂

(1) 增强接口

@Order(Ordered.HIGHEST_PRECEDENCE) public interface BaseStrengthen {     /**      * 前置强化方法      *      * @param bean   bean实例（或者是被代理的bean）      * @param method 执行的方法对象      * @param args   方法参数      */     void before(Object bean, Method method, Object[] args);     /**      * 后置强化方法      * 出现异常不会执行      * 如果未出现异常，在afterFinally方法之后执行      *      * @param bean   bean实例（或者是被代理的bean）      * @param method 执行的方法对象      * @param args   方法参数      */     void after(Object bean, Method method, Object[] args);     /**      * 异常强化方法      *      * @param bean   bean实例（或者是被代理的bean）      * @param method 执行的方法对象      * @param args   方法参数      */     void exception(Object bean, Method method, Object[] args);     /**      * Finally强化方法，出现异常也会执行      *      * @param bean   bean实例（或者是被代理的bean）      * @param method 执行的方法对象      * @param args   方法参数      */     void afterFinally(Object bean, Method method, Object[] args); } 

(2) 代理抽象类

public abstract class Point {     /**      * 定时任务名      */     private String superScheduledName;     /**      * 抽象的执行方法，使用代理实现      * @param runnable 定时任务执行器      */     public abstract Object invoke(SuperScheduledRunnable runnable);     /* 普通的get/sets省略 */ } 

(3) 调用链类

public class Chain {     private List<Point> list;     private int index = -1;     /**      * 索引自增1      */     public int incIndex() {         return ++index;     }     /**      * 索引还原      */     public void resetIndex() {         this.index = -1;     } } 

(4) cglib动态代理实现

使用cglib代理增强器，将增强器全部代理成调用链节点Point

public class RunnableBaseInterceptor implements MethodInterceptor {     /**      * 定时任务执行器      */     private SuperScheduledRunnable runnable;     /**      * 定时任务增强类      */     private BaseStrengthen strengthen;     @Override     public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {         Object result;         //如果执行的是invoke()方法         if ("invoke".equals(method.getName())) {          //前置强化方法             strengthen.before(obj, method, args);             try {              //调用执行器中的invoke()方法                 result = runnable.invoke();             } catch (Exception e) {              //异常强化方法                 strengthen.exception(obj, method, args);                 throw new SuperScheduledException(strengthen.getClass() + "中强化执行时发生错误", e);             } finally {              //Finally强化方法，出现异常也会执行                 strengthen.afterFinally(obj, method, args);             }             //后置强化方法             strengthen.after(obj, method, args);         } else {          //直接执行方法             result = methodProxy.invokeSuper(obj, args);         }         return result;     }     public RunnableBaseInterceptor(Object object, SuperScheduledRunnable runnable) {         this.runnable = runnable;         if (BaseStrengthen.class.isAssignableFrom(object.getClass())) {             this.strengthen = (BaseStrengthen) object;         } else {             throw new SuperScheduledException(object.getClass() + "对象不是BaseStrengthen类型");         }     }     public RunnableBaseInterceptor() {     } } 

(5) 定时任务执行器实现

public class SuperScheduledRunnable {     /**      * 原始的方法      */     private Method method;     /**      * 方法所在的bean      */     private Object bean;     /**      * 增强器的调用链      */     private Chain chain;     public Object invoke() {         Object result;         //索引自增1         if (chain.incIndex() == chain.getList().size()) {             //调用链中的增强方法已经全部执行结束             try {                 //调用链索引初始化                 chain.resetIndex();                 //增强器全部执行完毕，执行原本的方法                 result = method.invoke(bean);             } catch (IllegalAccessException | InvocationTargetException e) {                 throw new SuperScheduledException(e.getLocalizedMessage());             }         } else {             //获取被代理后的方法增强器             Point point = chain.getList().get(chain.getIndex());             //执行增强器代理             //增强器代理中，会回调方法执行器，形成调用链，逐一运行调用链中的增强器             result = point.invoke(this);         }         return result;     }     /* 普通的get/sets省略 */ } 

(6) 增强器代理逻辑

com.gyx.superscheduled.core.SuperScheduledApplicationRunner类中的代码片段

//创建执行控制器
SuperScheduledRunnable runnable = new SuperScheduledRunnable();
runnable.setMethod(scheduledSource.getMethod());
runnable.setBean(scheduledSource.getBean());
//用来存放 增强器的代理对象
List<Point> points = new ArrayList<>(baseStrengthenBeanNames.length);
//循环所有的增强器的beanName
for (String baseStrengthenBeanName : baseStrengthenBeanNames) {
 //获取增强器的bean对象
    Object baseStrengthenBean = applicationContext.getBean(baseStrengthenBeanName);
    //将增强器代理成Point节点
    Point proxy = ProxyUtils.getInstance(Point.class, new RunnableBaseInterceptor(baseStrengthenBean, runnable));
    proxy.setSuperScheduledName(name);
    //增强器的代理对象缓存到list中
    points.add(proxy);
}
//将增强器代理实例的集合生成调用链
//执行控制器中设置调用链
runnable.setChain(new Chain(points));

版权声明：本文为CSDN博主「敲代码的旺财」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/qq_34886352/article/details/106494637

远方并不远。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot Quartz定时任务的动态调度使用，实战详解
2401_84009549的博客
04-18 846
创建JobFactory.java （job实例工厂）：/**@Description : 创建job实例工厂,使用默认的也许会出现spring的@Autowired 无法注入问题**/@Component@Autowired@Override//Job实例注入到Job工厂创建QuartzConfig.java （一些属性配置项）：/**@Description : 调度工厂,线程池属性等等配置**/
springboot 动态定时任务
qq_44663816的博客
06-13 114
除了上面的借助cron表达式的方法，还有另一种触发器，区别于CronTrigger触发器，该触发器可随意设置循环间隔时间，不像cron表达式只能定义小于等于间隔59秒。
spring+quartz实现动态设置定时任务
10-28
spring+quartz实现动态设置定时任务，自己的例子+心得+sql语句
spring boot中实现动态定时任务
erxiaoouba的博客
08-04 387
在网上找的资料最后整理出来的, 不过找不到原文章地址了, 感谢原作者的奉献 这里总共创建以下几个类: DynamicCronJob: 动态定时任务, 包含了对定时任务的启动, 停止, 重启. 添加定时任务的功能没有加, 可以自行添加, 参考启动功能 ScheduledTaskConfig: 动态定时任务配置, 这是一个配置类, 配置ThreadPoolTaskScheduler线程池的, 还有就是初始化存放所有动态定时任务的map, 初始化map也就死创建一个map对象, 具体的初始化方法在下面的Sc.
SpringBoot实现动态定时任务
站在墙头上的博客
06-30 3873
springboot实现动态定时任务
SpringBoot 定时任务动态管理通用解决方案
Java笔记虾
12-23 495
点击关注公众号，利用碎片时间学习一、功能说明SpringBoot的定时任务的加强工具，实现对SpringBoot原生的定时任务进行动态管理,完全兼容原生@Scheduled注解,无需对原本...
Quartz+Spring Boot实现动态管理定时任务
08-26
最近做项目遇到动态管理定时任务的需求，刚拿到这个需求还真不知道从哪下手，经过一番思考，终于找出实现思路，接下来通过本文给大家介绍了Quartz+Spring Boot实现动态管理定时任务的相关知识,需要的朋友可以参考下
spring boot task实现动态创建定时任务的方法
08-26
主要介绍了spring boot task实现动态创建定时任务，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring Boot如何实现定时任务的动态增删启停详解
08-18
主要给大家介绍了关于Spring Boot如何实现定时任务的动态增删启停的相关资料，文中通过示例代码以及图文介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
Spring Boot中实现定时任务应用实践
08-27
定时任务一般是项目中都需要用到的，可以用于定时处理一些特殊的任务。下面这篇文章主要给大家介绍了关于Spring Boot中实现定时任务应用实践的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考下。
spring设置动态定时任务
11-28
spring设置动态定时任务，spring 定时器
dynamic-schedule:springboot 动态定时任务
05-14
写在前面：本文采取的环境 1.docker下的mysql (对于用户使用的数据库版本 请引用对应的数据库驱动版本)，2.springboot(该demo采用mysql数据库，druid连接池，mybatis持久层) 项目地址： 码云： github： 前端配套界面： 更新日志： 1.加入定时器 给定时间 得出下次执行时间点 参照 第一步 MySQL环境准备（可跳过） 1.在centos窗口中，拉取mysql镜像，并且创建该容器： docker pull mysql:5.7 docker run --name test-mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7 注：等容器启动成功后，读者可以尝试用Navicat连接 ：账号root， 密码123456. 2.数据库表准备，以及测试数据 本人创建了名为test
SpringBoot实现动态控制定时任务支持多参数功能
08-25
主要介绍了SpringBoot实现动态控制定时任务-支持多参数功能，本文通过实例代码给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
SpringBoot动态定时任务
客官不爱喝酒的博客
10-24 530
之前在SpringBoot项目中简单使用定时任务，不过由于要借助cron表达式且都提前定义好放在配置文件里，不能在项目运行中动态修改任务执行时间，实在不太灵活。现在我们就来实现可以动态修改cron表达式的定时任务。
SpringBoot 动态定时任务
qq_42291606的博客
11-22 200
既然是动态就必须牵扯到数据库 -- ---------------------------- -- Table structure for scheduled_task -- ---------------------------- DROP TABLE IF EXISTS `scheduled_task`; CREATE TABLE `scheduled_task` ( `id` int...
SPRING BOOT 动态定时任务
hudeyong926的专栏
06-14 1万+
动态定时任务
Springboot实现动态定时任务
北尘
09-09 3940
该动态定时任务主配置类是 ScheduledConfig，代码如下；最近有幸要开发个动态定时任务，这里简单再梳理一下。到这里核心类已经走完，剩下的就是获取数据相关类。紧接着是这个类，用于控制任务的执行与否；最后就是要测试的接口。
SpringBoot动态定时任务(完整版)
热门推荐
学习学习学习
10-14 2万+
完整版动态定时任务增删改启动暂停功能样样俱全，话不多说，直接看代码，你们直接CV就可以用！！！
spring boot 实现定时任务调度
最新发布
04-25
Spring Boot提供了一种简单而强大的方式来实现定时任务调度。下面是使用Spring Boot实现定时任务调度的步骤： 1. 添加依赖：在`pom.xml`文件中添加Spring Boot的定时任务依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-quartz</artifactId> </dependency> ``` 2. 创建定时任务类：创建一个继承自`QuartzJobBean`的定时任务类，并实现`executeInternal`方法，该方法中编写具体的定时任务逻辑。 ```java import org.quartz.JobExecutionContext; import org.quartz.JobExecutionException; import org.springframework.scheduling.quartz.QuartzJobBean; public class MyJob extends QuartzJobBean { @Override protected void executeInternal(JobExecutionContext context) throws JobExecutionException { // 定时任务逻辑 System.out.println("定时任务执行中..."); } } ``` 3. 配置定时任务：在`application.properties`或`application.yml`文件中配置定时任务的相关属性，例如触发时间、触发频率等。 ```yaml spring: quartz: job-store-type: memory properties: org: quartz: scheduler: instanceName: MyScheduler instanceId: AUTO job-details: my-job: cron: 0/5 * * * * ? job-class-name: com.example.MyJob ``` 4. 启动定时任务：在Spring Boot的启动类上添加`@EnableScheduling`注解，开启定时任务的自动配置。 ```java import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.scheduling.annotation.EnableScheduling; @SpringBootApplication @EnableScheduling public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } ``` 5. 运行定时任务：启动Spring Boot应用程序后，定时任务将按照配置的触发时间和频率执行。 以上就是使用Spring Boot实现定时任务调度的基本步骤。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值