栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

SpringBoot定时任务的动态配置处理(动态获取数据库配置的定时任务)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

SpringBoot定时任务的动态配置处理(动态获取数据库配置的定时任务)

SpringBoot定时任务的动态配置处理(动态获取数据库配置的定时任务)
  • 1. 前言
  • 2. SpringBoot的动态定时任务
    • 2.1 准备工作——数据库表和数据
    • 2.2 Java代码实现
      • 2.2.1 实体
      • 2.2.2 查询数据库
      • 2.2.3 动态定时任务实现代码1
        • 2.2.3.1 代码
        • 2.2.3.2 效果
      • 2.2.4 动态定时任务实现代码2
  • 3. 对于配置多个定时任务的优化
    • 3.1 优化代码1
      • 代码
      • 效果
    • 3.2 优化代码2——线程池
    • 3.2 优化代码3——自定义线程池
      • 3.2.1 自定义线程池(ThreadPoolTaskScheduler)
      • 3.2.2 使用自定义的线程池
      • 3.2.3 效果
  • 4. 代码

1. 前言
  • 如果不需要动态处理定时任务的,可以看下面几篇文章
    • 关于SpringBoot中定时任务@EnableScheduling的开关设置(针对指定的定时任务可控制)

      Java多线程之定时任务 以及 SpringBoot多线程实现定时任务.

      SpringBoot 自定义线程池以及多线程间的异步调用(@Async、@EnableAsync).

2. SpringBoot的动态定时任务 2.1 准备工作——数据库表和数据
  • 关于 corn 表达式的了解:
    cron表达式的详细介绍(各域说明以及举例说明).
  • 数据如图:
  • 建表语句:
    SET NAMES utf8mb4;
    SET FOREIGN_KEY_CHECKS = 0;
    
    -- ----------------------------
    -- Table structure for my_task_corn
    -- ----------------------------
    DROp TABLE IF EXISTS `my_task_corn`;
    CREATE TABLE `my_task_corn`  (
      `corn_id` int(10) NOT NULL AUTO_INCREMENT COMMENT '主键id',
      `corn` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT 'corn表达式',
      `execute_cycle` varchar(4) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '定时任务执行的配置的周期(01:每天一次 02:每周一次 03:每月一次)',
      `corn_desc` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '解释说明',
      `off_state` varchar(10) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '关闭状态',
      PRIMARY KEY (`corn_id`) USING BTREE
    ) ENGINE = InnoDB AUTO_INCREMENT = 7 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '定时任务配置表' ROW_FORMAT = Dynamic;
    
    -- ----------------------------
    -- Records of my_task_corn
    -- ----------------------------
    INSERT INTO `my_task_corn` VALUES (1, '0/5 * * * * ?', '00', '每5秒执行一次', 'on');
    INSERT INTO `my_task_corn` VALUES (2, '0 0 0 * * ? ', '01', '每天一次,每天晚上凌晨24点执行(0 0 0 * * ? *)', 'on');
    INSERT INTO `my_task_corn` VALUES (3, '0 0 0 ? * 5', '02', '每周一次,每周五凌晨24点执行', 'off');
    INSERT INTO `my_task_corn` VALUES (4, '0 0 0 1 * ?', '03', '每月1号执行凌晨24点执行', 'off');
    INSERT INTO `my_task_corn` VALUES (6, '0 0 0 1 7 ?', '04', '每年一次,每年的7月1日执行凌晨24点执行', 'on');
    
    SET FOREIGN_KEY_CHECKS = 1;
    
2.2 Java代码实现
  • 这里用的是JPA,想了解关于JPA的推荐下面文章:
    springboot整合jpa项目入门级别demo.
2.2.1 实体
  • JPA工具自动生成的,没改,看着不舒服自己改,如下:
    package com.liu.susu.pojo;
    
    import javax.persistence.*;
    import java.util.Objects;
    
    
    @Entity
    @Table(name = "my_task_corn", schema = "liu", catalog = "")
    public class MyTaskCornEntity {
    
        private int cornId;
        private String corn;
        private String executeCycle;
        private String cornDesc;
        private String offState;
    
        @Id
        @Column(name = "corn_id", nullable = false)
        public int getCornId() {
            return cornId;
        }
    
        public void setCornId(int cornId) {
            this.cornId = cornId;
        }
    
        @Basic
        @Column(name = "corn", nullable = true, length = 32)
        public String getCorn() {
            return corn;
        }
    
        public void setCorn(String corn) {
            this.corn = corn;
        }
    
        @Basic
        @Column(name = "execute_cycle", nullable = true, length = 4)
        public String getExecuteCycle() {
            return executeCycle;
        }
    
        public void setExecuteCycle(String executeCycle) {
            this.executeCycle = executeCycle;
        }
    
        @Basic
        @Column(name = "corn_desc", nullable = true, length = 100)
        public String getCornDesc() {
            return cornDesc;
        }
    
        public void setCornDesc(String cornDesc) {
            this.cornDesc = cornDesc;
        }
    
        @Basic
        @Column(name = "off_state", nullable = true, length = 10)
        public String getOffState() {
            return offState;
        }
    
        public void setOffState(String offState) {
            this.offState = offState;
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            MyTaskCornEntity that = (MyTaskCornEntity) o;
            return cornId == that.cornId && Objects.equals(corn, that.corn) && Objects.equals(executeCycle, that.executeCycle) && Objects.equals(cornDesc, that.cornDesc) && Objects.equals(offState, that.offState);
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(cornId, corn, executeCycle, cornDesc, offState);
        }
    }
    
    
2.2.2 查询数据库
  • 如下:
    package com.liu.susu.thread.task.scheduled.dynamic;
    
    import com.liu.susu.pojo.Dog;
    import org.springframework.stereotype.Service;
    
    import javax.persistence.EntityManager;
    import javax.persistence.PersistenceContext;
    import javax.persistence.Query;
    
    
    @Service
    public class CornUtils {
    
        @PersistenceContext
        private EntityManager entityManager;
    
        public String getCorn(String executeCycle){
            String sql = "select t.corn from my_task_corn t where t.execute_cycle=?1";
            Query query = entityManager.createNativeQuery(sql);
            query.setParameter(1,executeCycle);
            return (String) query.getSingleResult();
        }
    
    }
    
    
2.2.3 动态定时任务实现代码1 2.2.3.1 代码
  • 如下:

    package com.liu.susu.thread.task.scheduled.dynamic;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.scheduling.annotation.Async;
    import org.springframework.scheduling.annotation.SchedulingConfigurer;
    import org.springframework.scheduling.config.ScheduledTaskRegistrar;
    import org.springframework.scheduling.support.CronTrigger;
    import org.springframework.stereotype.Component;
    
    import java.time.LocalDateTime;
    
    
    @Component
    @Slf4j
    public class DynamicScheduledTest implements SchedulingConfigurer {
    
        @Autowired
        private CornUtils cornUtils;
    
        @Override
        public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
    
            scheduledTaskRegistrar.addTriggerTask(
                    //1.添加任务内容(Runnable)
                    () -> log.info("这里动态执行定时任务--->"+Thread.currentThread().getName()),
    
                    //2.设置执行周期(Trigger)
                    triggerContext -> {
                        //2.1 从数据库获取 corn 表达式(执行周期)
                        String cron = cornUtils.getCorn("00");
                        log.info("cron表达式--->: " + cron);
    
                        //2.3 返回执行周期(Date)
                        return new CronTrigger(cron).nextExecutionTime(triggerContext);
                    }
            );
        }
    
    }
    
    
2.2.3.2 效果
  • 如图:
2.2.4 动态定时任务实现代码2
  • 与上面是一样的,就是拆分一下
    package com.liu.susu.thread.task.scheduled.dynamic;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.scheduling.Trigger;
    import org.springframework.scheduling.TriggerContext;
    import org.springframework.scheduling.annotation.SchedulingConfigurer;
    import org.springframework.scheduling.config.ScheduledTaskRegistrar;
    import org.springframework.scheduling.support.CronTrigger;
    import org.springframework.stereotype.Component;
    
    import java.time.LocalDateTime;
    import java.util.Date;
    
    
    @Component
    @Slf4j
    public class DynamicScheduledTest2 implements SchedulingConfigurer {
    
        @Autowired
        private CornUtils cornUtils;
    
    
        @Override
        public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
            scheduledTaskRegistrar.addTriggerTask(myTask(),trigger());
        }
    
        
        private Runnable myTask() {
            return new Runnable() {
                @Override
                public void run() {
                    //业务逻辑部分
                    log.info("这里动态执行定时任务--->"+Thread.currentThread().getName());
                }
            };
        }
    
        
        private Trigger trigger() {
            return new Trigger() {
                @Override
                public Date nextExecutionTime(TriggerContext triggerContext) {
                    //每一次任务触发,都会执行这里的方法一次,重新获取下一次的执行时间。所以它是下下次才生效的,即不是实时生效
                    //1.从数据库获取 corn 表达式(执行周期)
                    String cron = cornUtils.getCorn("00");
                    log.info("cron表达式--->: " + cron);
    
                    //2 返回执行周期(Date)
                    CronTrigger cronTrigger = new CronTrigger(cron);
                    Date date = cronTrigger.nextExecutionTime(triggerContext);
                    return date;
                }
            };
        }
    
    }
    
    
3. 对于配置多个定时任务的优化
  • 对于配置多任务的情况,在上面代码的基础上可以进行优化
3.1 优化代码1 代码
  • 如下:

    package com.liu.susu.thread.task.scheduled.dynamic;
    
    import com.liu.susu.pojo.MyTaskCornEntity;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.scheduling.Trigger;
    import org.springframework.scheduling.TriggerContext;
    import org.springframework.scheduling.annotation.SchedulingConfigurer;
    import org.springframework.scheduling.config.ScheduledTaskRegistrar;
    import org.springframework.scheduling.support.CronTrigger;
    import org.springframework.stereotype.Component;
    import org.springframework.util.ReflectionUtils;
    
    import java.lang.reflect.Method;
    import java.util.Date;
    import java.util.List;
    
    
    @Component
    @Slf4j
    public class DynamicScheduledTest3 implements SchedulingConfigurer {
    
        @Autowired
        private CornUtils cornUtils;
    
        @Override
        public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
            //1.获取需要执行的所有的任务
            List cronList = cornUtils.getAllCornsList();
    
            //2.根据配置情况执行对应的任务
            for (MyTaskCornEntity cornEntity : cronList){
                scheduledTaskRegistrar.addTriggerTask(myTask(cornEntity),myTrigger(cornEntity));
            }
        }
    
        
        private Runnable myTask(MyTaskCornEntity cornEntity) {
            return new Runnable() {
                @Override
                public void run() {
                    //业务逻辑部分
                    if ("00".equals(cornEntity.getExecuteCycle())){
                        log.info("这里动态执行的定时任务是--->"+cornEntity.getCorn()+"-->"+Thread.currentThread().getName());
                    }else if ("05".equals(cornEntity.getExecuteCycle())){
                        log.info("这里动态执行的定时任务是--->"+cornEntity.getCorn()+"-->"+Thread.currentThread().getName());
                    }
                }
            };
        }
    
        
        private Trigger myTrigger(MyTaskCornEntity cornEntity){
            return new Trigger() {
                @Override
                public Date nextExecutionTime(TriggerContext triggerContext) {
                    CronTrigger trigger = new CronTrigger(cornEntity.getCorn());
                    return trigger.nextExecutionTime(triggerContext);
                }
            };
        }
    
    }
    
    
效果
  • 如图:
3.2 优化代码2——线程池
  • 上面 3.1 优化后的代码,我们可以看到虽然是读取了多个任务,但是是一个线程在跑这些任务,实际开发一般用线程池,所以我们接下来的优化是在3.1的基础上使用线程池。
  • 在 3.1 代码的基础上只加一行代码,如图:
  • 效果如图:
3.2 优化代码3——自定义线程池 3.2.1 自定义线程池(ThreadPoolTaskScheduler)
  • 如下:
    package com.liu.susu.thread.task.scheduled.dynamic;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.scheduling.TaskScheduler;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
    
    import java.util.concurrent.Executor;
    import java.util.concurrent.ThreadPoolExecutor;
    
    
    @Configuration
    public class DynamicScheduledPoolConfig {
        private static int poolSize = 5;//核心线程
        private static int awaitTermination = 60;//挂壁时间
        private static String threadNamePrefix = "task-job-";
        private static volatile ThreadPoolTaskScheduler taskScheduler;
        @Bean
        public static Executor getMySchedulerPool(){
            if(taskScheduler == null){
                synchronized (ThreadPoolTaskScheduler.class){
                    if(taskScheduler == null){
                        taskScheduler = new ThreadPoolTaskScheduler();
                        taskScheduler.setThreadNamePrefix(threadNamePrefix);
                        taskScheduler.setPoolSize(poolSize);
    //                    taskScheduler.setThreadFactory(Executors.defaultThreadFactory());
                        taskScheduler.setAwaitTerminationSeconds(awaitTermination);//演示挂壁的时间为60s
                        
                        taskScheduler.setWaitForTasksToCompleteOnShutdown(true);
                        taskScheduler.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());//线程池对拒绝任务(无线程可用的)的处理策略
                        taskScheduler.initialize();//初始化
                    }
                }
            }
            return taskScheduler;
        }
    
    }
    
    
3.2.2 使用自定义的线程池
  • 如图,代码只改一处,所以直接上图
    • 放上完整代码也行
    package com.liu.susu.thread.task.scheduled.dynamic;
    
    import com.liu.susu.pojo.MyTaskCornEntity;
    import com.liu.susu.thread.task.async.async2.config.LiuTaskExecutorConfig2;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Bean;
    import org.springframework.core.task.TaskExecutor;
    import org.springframework.scheduling.TaskScheduler;
    import org.springframework.scheduling.Trigger;
    import org.springframework.scheduling.TriggerContext;
    import org.springframework.scheduling.annotation.SchedulingConfigurer;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
    import org.springframework.scheduling.config.ScheduledTaskRegistrar;
    import org.springframework.scheduling.support.CronTrigger;
    import org.springframework.stereotype.Component;
    
    import java.util.Date;
    import java.util.List;
    import java.util.concurrent.Executors;
    import java.util.concurrent.ThreadPoolExecutor;
    
    
    @Component
    @Slf4j
    public class DynamicScheduledTest4 implements SchedulingConfigurer {
    
        @Autowired
        private CornUtils cornUtils;
        
        @Override
        public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
            //0-1: 配置线程池
    //        scheduledTaskRegistrar.setScheduler(Executors.newScheduledThreadPool(10));
    
            //0-2: 用自定义的线程池
            scheduledTaskRegistrar.setScheduler(DynamicScheduledPoolConfig.getMySchedulerPool());
    
            //1.获取需要执行的所有的任务
            List cronList = cornUtils.getAllCornsList();
    
            //2.根据配置情况执行对应的任务
            for (MyTaskCornEntity cornEntity : cronList){
                scheduledTaskRegistrar.addTriggerTask(myTask(cornEntity),myTrigger(cornEntity));
            }
        }
    
        
        private Runnable myTask(MyTaskCornEntity cornEntity) {
            return new Runnable() {
                @Override
                public void run() {
                    //业务逻辑部分
    //                log.info("这里动态执行的定时任务是--->"+cornEntity.getCorn()+"-->"+Thread.currentThread().getName());
    
                    if ("00".equals(cornEntity.getExecuteCycle())){
                        log.info("任务1:这里动态执行的定时任务是--->"+cornEntity.getCorn()+"-->"+Thread.currentThread().getName());
    
                    }else if ("05".equals(cornEntity.getExecuteCycle())){
                        log.info("任务2:这里动态执行的定时任务是--->"+cornEntity.getCorn()+"-->"+Thread.currentThread().getName());
                    }
    
                }
            };
        }
    
        
        private Trigger myTrigger(MyTaskCornEntity cornEntity){
            return new Trigger() {
                @Override
                public Date nextExecutionTime(TriggerContext triggerContext) {
                    CronTrigger trigger = new CronTrigger(cornEntity.getCorn());
                    return trigger.nextExecutionTime(triggerContext);
                }
            };
        }
    
    }
    
    
    
3.2.3 效果
  • 如图:
4. 代码
  • 如果下载整个项目代码,这个文章下有代码路径,下载最新版本即可,自己可以找找看
    Java多线程之定时任务 以及 SpringBoot多线程实现定时任务.
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/986292.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号