基于springBoot动态配置定时任务

最新推荐文章于 2024-07-02 10:45:00 发布
最新推荐文章于 2024-07-02 10:45:00 发布
阅读量1.4k 收藏 1
点赞数 1
分类专栏： springboot动态配置定时任务 文章标签： spring boot java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/upordown6263/article/details/122705568
版权

引用地址：https://blog.csdn.net/qq_14861089/article/details/108831101
功能实现：
1.实体类：

package com.mengan.utilsProject.task;

import lombok.Data;

@Data
public class Scheduled {


    private int id;

    private String taskKey;

    private String name;

    private String cron;

    private int status;

    private String createTime;

    private String updateTime;
}

2.Mapper接口类：

package com.mengan.utilsProject.task;

import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper
//@Repository
public interface ScheduledMapper {

    List<Scheduled> selectList(Scheduled scheduled);
}

3.Mapper接口对应的xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mengan.utilsProject.task.ScheduledMapper">

    <select id="selectList" resultType="com.mengan.utilsProject.task.Scheduled">
        select * from scheduled where status = 1
        <if test="taskKey != null and taskKey != ''">
            AND task_key = #{taskKey}
        </if>
    </select>

</mapper>

4.状态枚举类

package com.mengan.utilsProject.task;


public enum ScheduledStatus {

    ENABLE(0, "禁用"),
    DISABLE(1, "启用");

    private int code;
    private String name;

    ScheduledStatus(int code, String name){
        this.code = code;
        this.name = name;
    }

    public static ScheduledStatus getByCode(int code){
        for (ScheduledStatus st : values()) {
            if(code == st.getCode())
                return st;
        }
        return null;
    }

    public int getCode() {
        return code;
    }

    public String getName() {
        return name;
    }

}

5.配置类

package com.mengan.utilsProject.task;


import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;

@Slf4j
@Configuration
public class ScheduledTaskConfig {

    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
        log.info("创建定时任务调度线程池 start");
        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
        threadPoolTaskScheduler.setPoolSize(20);
        threadPoolTaskScheduler.setThreadNamePrefix("taskExecutor-");
        //用来设置线程池关闭的时候等待所有任务都完成再继续销毁其他的Bean，这样这些异步任务的销毁就会先于Redis线程池的销毁。
        threadPoolTaskScheduler.setWaitForTasksToCompleteOnShutdown(true);
        //该方法用来设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住。
        threadPoolTaskScheduler.setAwaitTerminationSeconds(60);
        log.info("创建定时任务调度线程池 end");
        return threadPoolTaskScheduler;
    }

}

6.自定义定时任务接口

package com.mengan.utilsProject.task;


/**
 * @ClassName ScheduledTaskJob
 * @Description 创建调度任务公共父接口
 * @Author 
 * @Date
 * @Version
 */
public interface ScheduledTaskJob extends Runnable{
}

7.自定义定时任务实现类1

package com.mengan.utilsProject.task;


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

/**
 * @ClassName ScheduledTaskJob01
 * @Description 测试类01
 * @Author
 * @Date 2022/01/26
 * @Version 1.0
 */
@Slf4j
@Service
public class ScheduledTaskJob01 implements ScheduledTaskJob {

    @Override
    public void run() {
        // TODO 要处理的业务逻辑
        log.info("ScheduledTask => 01  run  当前线程名称 {} ", Thread.currentThread().getName());
    }
}

8.自定义定时任务实现类2

package com.mengan.utilsProject.task;


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

/**
 * @ClassName ScheduledTaskJob02
 * @Description 测试类02
 * @Author
 * @Date 2022/01/26
 * @Version 1.0
 */
@Slf4j
@Service
public class ScheduledTaskJob02 implements ScheduledTaskJob {

    @Override
    public void run() {
        // TODO 要处理的业务逻辑
        log.info("ScheduledTask => 02  run  当前线程名称 {} ", Thread.currentThread().getName());
    }
}

9.自定义定时任务实现类3

package com.mengan.utilsProject.task;


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

/**
 * @ClassName ScheduledTaskJob03
 * @Description 测试类03
 * @Author
 * @Date 2022/01/26
 * @Version 1.0
 */
@Slf4j
@Service
public class ScheduledTaskJob03 implements ScheduledTaskJob {

    @Override
    public void run() {
        // TODO 要处理的业务逻辑
        log.info("ScheduledTask => 03  run  当前线程名称 {} ", Thread.currentThread().getName());
    }
}

10.ScheduledTaskRunner类：

package com.mengan.utilsProject.task;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class ScheduledTaskRunner implements ApplicationRunner {

    @Autowired
    private ScheduledTaskService scheduledTaskService;

    /**
     * 程序启动完毕后,需要自启的任务
     */
    @Override
    public void run(ApplicationArguments applicationArguments){
        log.info(" >>>>>> 项目启动完毕, 开启 => 需要自启的任务 开始!");
        scheduledTaskService.initAllTask();
        log.info(" >>>>>> 项目启动完毕, 开启 => 需要自启的任务 结束！");
    }

}

11.ScheduledTaskService接口

package com.mengan.utilsProject.task;



/**
 * @ClassName ScheduledTaskService
 * @Description 定时任务接口
 * @Author
 * @Date
 * @Version 1.0
 */
public interface ScheduledTaskService {

    /**
     * 根据任务key 启动任务
     */
    Boolean start(String taskKey, Scheduled scheduled);

    /**
     * 根据任务key 停止任务
     */
    Boolean stop(String taskKey);

    /**
     * 根据任务key 重启任务
     */
    Boolean restart(String taskKey, Scheduled scheduled);

    /**
     * 初始化  ==> 启动所有正常状态的任务
     */
    void initAllTask();
}

12.定时任务实现类

package com.mengan.utilsProject.task;


import cn.hutool.extra.spring.SpringUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.TriggerContext;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @ClassName ScheduledTaskServiceImpl
 * @Description 定时任务实现
 * @Author
 * @Date
 * @Version 1.0
 */
@Slf4j
@Service
public class ScheduledTaskServiceImpl implements ScheduledTaskService {

    @Value("${task.enabled}")
    private Boolean taskEnable;

    /**
     * 可重入锁
     */
    private ReentrantLock lock = new ReentrantLock();
    /**
     * 定时任务线程池
     */
    @Autowired
    private ThreadPoolTaskScheduler threadPoolTaskScheduler;

    /**
     * 存放已经启动的任务map
     */
    private Map<String, ScheduledFuture> scheduledFutureMap = new ConcurrentHashMap<>();

    @Autowired
    private ScheduledMapper scheduledMapper;

    /**
     * 描述: 根据任务key 启动任务
     *
     * @param taskKey
     * @param scheduled
     * @return java.lang.Boolean
     * @author lv617
     * @date 2020/9/24 11:16
     */
    @Override
    public Boolean start(String taskKey, Scheduled scheduled) {
        log.info(">>>>>> 启动任务 {} 开始 >>>>>>", taskKey);
        //添加锁放一个线程启动，防止多人启动多次
        lock.lock();
        log.info(">>>>>> 添加任务启动锁完毕");
        try {
            //校验是否已经启动
            if (this.isStart(taskKey)) {
                log.info(">>>>>> 当前任务已经启动，无需重复启动！");
                return false;
            }
            //查询配置
            if(scheduled == null)
                scheduled = this.getByTaskKey(taskKey);
            if(scheduled == null)
                return false;
            //启动任务
            this.doStartTask(scheduled);
        } finally {
            // 释放锁
            lock.unlock();
            log.info(">>>>>> 释放任务启动锁完毕");
        }
        log.info(">>>>>> 启动任务 {} 结束 >>>>>>", taskKey);
        return true;
    }

    /**
     * 描述: 查询定时任务配置参数
     *
     * @param taskKey
     * @return com.yihaocard.main.module.scheduled.model.Scheduled
     * @author lv617
     * @date 2020/9/24 11:14
     */
    private Scheduled getByTaskKey(String taskKey) {
        Scheduled scheduledExample = new Scheduled();
        scheduledExample.setStatus(1);
        scheduledExample.setTaskKey(taskKey);
        List<Scheduled> scheduleds = scheduledMapper.selectList(scheduledExample);
        if(scheduleds == null || scheduleds.size() < 1)
            return null;
        return scheduleds.get(0);
    }

    /**
     * 描述: 根据 key 停止任务
     *
     * @param taskKey
     * @return java.lang.Boolean
     * @author lv617
     * @date 2020/9/24 11:17
     */
    @Override
    public Boolean stop(String taskKey) {
        log.info(">>>>>> 进入停止任务 {}  >>>>>>", taskKey);
        //当前任务实例是否存在
        boolean taskStartFlag = scheduledFutureMap.containsKey(taskKey);
        log.info(">>>>>> 当前任务实例是否存在 {}", taskStartFlag);
        if (taskStartFlag) {
            //获取任务实例
            ScheduledFuture scheduledFuture = scheduledFutureMap.get(taskKey);
            //关闭实例
            boolean cancel = scheduledFuture.cancel(true);
            log.info("cancel:{}", cancel);
            //删除关闭的任务实例
            scheduledFutureMap.remove(taskKey);
        }
        log.info(">>>>>> 结束停止任务 {}  >>>>>>", taskKey);
        return taskStartFlag;
    }

    /**
     * 描述: 根据任务key 重启任务
     *
     * @param taskKey
     * @param scheduled
     * @return java.lang.Boolean
     * @author lv617
     * @date 2020/9/24 11:18
     */
    @Override
    public Boolean restart(String taskKey, Scheduled scheduled) {
        log.info(">>>>>> 进入重启任务 {}  >>>>>>", taskKey);
        //先停止
        this.stop(taskKey);
        //查询配置
        if(scheduled == null)
            scheduled = this.getByTaskKey(taskKey);
        if(scheduled == null)
            return false;
        //再启动
        return this.start(taskKey,scheduled);
    }

    /**
     * 初始化  ==> 启动所有正常状态的任务
     */
    @Override
    public void initAllTask() {
        if(!taskEnable){
            log.info("配置文件禁用了定时任务----");
            return;
        }
        Scheduled scheduledExample = new Scheduled();
        scheduledExample.setStatus(1);
        List<Scheduled> scheduleds = scheduledMapper.selectList(scheduledExample);
        log.info("初始化  ==> 启动所有正常状态的任务开始 ！size={}", scheduleds == null ? 0 : scheduleds.size());
        if (scheduleds == null || scheduleds.size() < 1) {
            return;
        }
        for (Scheduled scheduled : scheduleds) {
            //任务 key
            String taskKey = scheduled.getTaskKey();
            //校验是否已经启动
            if (this.isStart(taskKey)) {
                // 重启任务
                this.restart(taskKey,scheduled);
            } else {
                // 启动任务
                this.doStartTask(scheduled);
            }
        }
        log.info("初始化  ==> 启动所有正常状态的任务结束 ！");
    }

    /**
     * 执行启动任务
     */
    private void doStartTask(Scheduled scheduled) {
        if (scheduled == null)
            return;
        //任务key
        String taskKey = scheduled.getTaskKey();
        //定时表达式
        String taskCron = scheduled.getCron();
        //获取需要定时调度的接口
        ScheduledTaskJob scheduledTaskJob = (ScheduledTaskJob) SpringUtil.getBean(taskKey);
        log.info(">>>>>> 任务 [ {} ] ,cron={}", scheduled.getName(), taskCron);
        ScheduledFuture scheduledFuture = threadPoolTaskScheduler.schedule(scheduledTaskJob, (TriggerContext triggerContext) -> new CronTrigger(taskCron).nextExecutionTime(triggerContext));
        //将启动的任务放入 map
        scheduledFutureMap.put(taskKey, scheduledFuture);
    }

    /**
     * 任务是否已经启动
     */
    private Boolean isStart(String taskKey) {
        //校验是否已经启动
        if (scheduledFutureMap.containsKey(taskKey)) {
            if (!scheduledFutureMap.get(taskKey).isCancelled()) {
                return true;
            }
        }
        return false;
    }

}

13.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mengan.utilsProject.task.ScheduledMapper">

    <select id="selectList" resultType="com.mengan.utilsProject.task.Scheduled">
        select * from scheduled where status = 1
        <if test="taskKey != null and taskKey != ''">
            AND task_key = #{taskKey}
        </if>
    </select>

</mapper>

14.application.yml文件

server:
  port: 38080

task:
  enabled: 1

spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
    driver-class-name: com.mysql.jdbc.Driver

mybatis:
  mapper-locations: classpath:mapping/*Mapper.xml
  type-aliases-package: com.mengan.utilsProject.task
  configuration:
    map-underscore-to-camel-case: true
#showSql
logging:
  level:
    com:
      example:
        mapper : debug

15.数据库表：

CREATE TABLE `scheduled` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `task_key` varchar(127) NOT NULL COMMENT '任务key值（使用bean名称）',
  `name` varchar(127) DEFAULT NULL COMMENT '任务名称',
  `cron` varchar(63) NOT NULL COMMENT '任务表达式',
  `status` int(2) DEFAULT '0' COMMENT '状态(0.禁用; 1.启用)',
  `create_time` timestamp NULL DEFAULT NULL COMMENT '创建时间',
  `update_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uniqu_task_key` (`task_key`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='定时任务配置表';

在这里插入图片描述
16.执行结果：
在这里插入图片描述

刀下阳光
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot动态配置定时任务(schedule)
06-13
springboot动态配置定时任务(schedule),可不重启项目实现开关重启任务,改变任务定时规则
Springboot2-Quartz 后台可动态配置的定时任务
02-28
SpringBoot2 与 Quartz 整合的Demo。 后台可添加、修改、移除 定时任务。 也可查看当前任务的状态 灵活的定时任务
Springboot项目配置定时任务
Soup's Blog
09-09 1626
1.定时任务实现的几种方式有： Timer：这是java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少。 ScheduledExecutorService：也jdk自带的一个类；是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也...
springboot集成动态任务调度，springboot集成动态quartz调度
wangyue123com的专栏
03-25 862
springboot集成动态任务调度，springboot集成动态quartz调度
Spring Boot 创建定时任务
最新发布
八戒的博客
07-02 2416
通过本文的介绍和示例代码，我们了解了如何在Spring Boot中创建和管理定时任务。Spring Boot的@Scheduled注解和TaskScheduler接口为定时任务提供了强大的支持，使得开发者能够轻松实现各种定时任务的需求。无论是简单的固定间隔任务，还是复杂的Cron表达式任务，Spring Boot都能提供简洁优雅的解决方案。在实际应用中，我们可能需要更复杂的定时任务管理功能，例如动态修改任务的执行时间、任务状态监控等。定时任务是指在预定的时间间隔或特定的时间点自动执行的任务。
SPRING BOOT 动态定时任务
热门推荐
hudeyong926的专栏
06-14 1万+
动态定时任务
SpringBoot使用Quartz实现定时任务动态配置
qq_42666609的博客
09-28 1386
SpringBoot使用quartz实现定时任务动态配置，实现在后台增删改查数据库中配置的定时任务，
Spring Boot 实现定时任务动态管理
程序员子龙
03-25 2055
本文主要介绍了SpringBoot架构下动态定时任务的使用，定时任务表达式配置在数据库中，通过反射执行到目标方法。Quartz定时任务默认都是并发执行的，不会等待上一次任务执行完毕，只要间隔时间到就会执行, 如果定时任执行太长，会长时间占用资源，导致其它任务堵塞。一般设置都是禁止并发执行//禁止并发执行@Override/*** 线程本地变量*/@Overridetry {if (sysJob!= null)log.error("任务执行异常 - ：", e);/**
(三)SpringBoot Spring Boot配置定时任务
Fay.Q
06-19 366
  SpringBoot配置定时任务可以直接使用自带的Scheduled， 这相当于一个轻量级的Quartz，它可以让我们直接使用注解来完成定时任务的配置。 @Configuration @EnableScheduling public class SchedulingConfig { private final Logger logger = LoggerFactory.ge...
springboot定时任务配置
weixin_43266529的博客
04-21 167
springboot定时任务配置 配置地址
(转)Springboot定时任务
weixin_33709609的博客
09-21 56
在我们的项目开发过程中，经常需要定时任务来帮助我们来做一些内容，springboot默认已经帮我们实行了，只需要添加相应的注解就可以实现 1、pom包配置 pom包里面只需要引入springboot starter包即可 &lt;dependencies&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;...
SpringBoot中并发定时任务的实现、动态定时任务的实现（看这一篇就够了）推荐
08-26
同时，为了实现动态定时任务，即在运行时修改任务的执行时间或频率，可以通过监听配置中心的变化，动态更新`@Scheduled`的cron表达式，或者使用Quartz等更灵活的调度库，它们通常提供API或接口来实现任务的动态管理...
springboot定时任务的动态开启关闭
03-07
1. **配置定时任务** 在Spring Boot应用的配置文件（`application.properties`或`application.yml`）中，我们可以设置全局的定时任务配置。例如，我们可以设置一个固定的延迟时间让定时任务开始执行： ```...
基于Springboot执行多个定时任务并动态获取定时任务信息
08-26
基于Springboot执行多个定时任务并动态获取定时任务信息 基于Springboot框架，实现多个定时任务的执行，并且可以动态获取定时任务的信息。这种实现方式可以满足一些业务需要，例如需要使用多个不同的定时任务，并且...
maven工程-基于springboot定时任务
07-21
在配置类上添加`@Configuration`和`@EnableScheduling`注解，表示这是一个配置定时任务的类，并开启定时任务的扫描： ```java import org.springframework.context.annotation.Configuration; import org.spring...
springboot之配置动态定时任务
weixin_41543212的博客
06-06 364
导入依赖： <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> </dependency> 基于接口配置： 初始化bean实例是当cron配置存在时启动定时任务； 修改配置cron，先停止在重
Spring Boot配置定时任务
07-23 193
在项目开发过程中，经常需要定时任务来做一些内容，比如定时进行数据统计（阅读量统计），数据更新（生成每天的歌单推荐）等。 Spring Boot默认已经实现了，我们只需要添加相应的注解就可以完成定时任务的配置。下面分两步来配置一个定时任务： 创建定时任务 启动类添加注解 创建定时任务 这里需要用到Cron表达式，如果对Cron表达式不是很熟悉 这是我自定义的一个定时任务：每10s中执行一次打印任务。 @Component public class TimerTask { private
spring boot中使用定时任务配置
DN金猿的博客
09-24 943
首先得创建一个spring boot项目吧，使用idea创建spring boot项目 使用步骤如下 【千万注意：一定要在启动类添加注解，否则定时任务无效】 1.在启动类 添加 开启定时任务 注解@EnableScheduling 2.创建定时任务类，使用注解@Component 标注定时任务类，作用是注入为Bean 　　　　　　　　　使用注解@Scheduled 标注在定时任务方法上， 作用是标注这个方法是执行定时任务的业务逻辑 关于@Scheduled的使用方法，参见后面备注1 @.
SpringBoot 实现定时任务
永远年轻
03-28 583
定时任务就是企业级开发中最为常见的功能之一，比如定时发送短信，邮件，定时统计各种数量 1. @Scheduled 注解 此注解是由 Spring 提供的定时任务注解，使用方便，配置简单，可以解决工作中大部分要使用到定时任务的场景，使用方式如下： 在启动类上添加 @EnableScheduling 注解开启定时任务，代码如下： @SpringBootApplication @EnableScheduling // 启动类添加此注解就表示开启了定时任务功能 public class SoftApplicatio
springboot 动态配置定时任务开关
04-30
总的来说，在SpringBoot中，实现定时任务的动态配置开关有多种方式，可以根据具体的业务需求选择合适的方式来实现。无论是使用注解还是框架，都可以轻松地实现任务的开启和关闭，提高系统的稳定性和可靠性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值