SpringBoot实现固定、动态定时任务 | 三种实现方式

最新推荐文章于 2024-09-25 11:21:08 发布
最新推荐文章于 2024-09-25 11:21:08 发布
阅读量5.3k 收藏 41
点赞数 3
文章标签： spring boot java mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76607156/article/details/129796248
版权

前言：

阅读完本文：🐱‍👓

  1. 知晓 SpringBoot 用注解如何实现定时任务
  2. 明白 SpringBoot 如何实现一个动态定时任务 （与数据库相关联实现）
  3. 理解 SpringBoot 实现设置时间执行定时任务 （使用 ThreadPoolTaskScheduler 实现）

一、注解实现定时任务

用注解实现是真的简单，只要会 cron 表达式就行。🧙‍♂️

第一步： 主启动类上加上 @EnableScheduling 注解

@EnableScheduling
@SpringBootApplication
public class SpringBootScheduled {

    public static void main(String[] args) {
        SpringApplication.run(SpringBootScheduled.class);
    }
}
复制代码

第二步：写一个类，注入到Spring，关键就是 @Scheduled 注解。 （) 里就是 cron 表达式，用来说明这个方法的执行周期的。 🛌

/**
 * 定时任务 静态定时任务
 *
 * 第一位，表示秒，取值0-59
 * 第二位，表示分，取值0-59
 * 第三位，表示小时，取值0-23
 * 第四位，日期天/日，取值1-31
 * 第五位，日期月份，取值1-12
 * 第六位，星期，取值1-7，1表示星期天，2表示星期一
 * 第七位，年份，可以留空，取值1970-2099
 * @author crush
 * @since 1.0.0
 * @Date: 2021-07-27 21:13
 */
@Component
public class SchedulingTaskBasic {

    /**
     * 每五秒执行一次
     */
    @Scheduled(cron = "*/5 * * * * ?")
    private void printNowDate() {
        long nowDateTime = System.currentTimeMillis();
        System.out.println("固定定时任务执行:--->"+nowDateTime+"，此任务为每五秒执行一次");
    }
}
复制代码

执行效果：

源码在文末。🏍

二、动态定时任务

其实也非常的简单。

2.1、建数据表

第一步：建个数据库表。

CREATE TABLE `tb_cron`  (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '动态定时任务时间表',
  `cron_expression` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '定时任务表达式',
  `cron_describe` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '描述',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

INSERT INTO `tb_cron` VALUES (1, '0 0/1 * * * ?', '每分钟执行一次');
复制代码

2.2、导入依赖，基础编码

第二步：导入数据库相关依赖，做到能从数据库查询数据。大家都会。🤸‍♂️

第三步： 编码

实体类：

@Data
@TableName("tb_cron")
public class Cron {
    private Long id;
    private String cronExpression;
    private String cronDescribe;
}
复制代码

mapper层：

@Repository
public interface CronMapper extends BaseMapper<Cron> {
    @Select("select cron_expression from tb_cron where id=1")
    String getCron1();
}
复制代码

2.3、主要实现代码

第四步：写一个类 实现 SchedulingConfigurer🍻

实现 void configureTasks(ScheduledTaskRegistrar taskRegistrar); 方法，此方法的作用就是根据给定的 ScheduledTaskRegistrar 注册 TaskScheduler 和特定的Task实例

@Component
public class CompleteScheduleConfig implements SchedulingConfigurer {

    @Autowired
    @SuppressWarnings("all")
    CronMapper cronMapper;

    /**
     * 执行定时任务.
     */
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.addTriggerTask(
                //1.添加任务内容(Runnable)
                () -> System.out.println("执行动态定时任务1: " + LocalDateTime.now().toLocalTime()+",此任务执行周期由数据库中的cron表达式决定"),
                //2.设置执行周期(Trigger)
                triggerContext -> {
                    //2.1 从数据库获取执行周期
                    String cron = cronMapper.getCron1();
                    //2.2 合法性校验.
                    if (cron!=null) {
                        // Omitted Code ..
                    }
                    //2.3 返回执行周期(Date)
                    return new CronTrigger(cron).nextExecutionTime(triggerContext);
                }
        );
    }
}
复制代码

2.4、效果

注意：当你修改了任务执行周期后，生效时间为执行完最近一次任务后。这一点是需要注意的，用生活中的例子理解就是我们取消电话卡的套餐也要下个月生效，含义是一样的。

源码同样在文末。

三、实现设置时间定时任务

通常业务场景是我前言中说的那样，是一次性的定时任务。如：我设置了我写的这篇文章的发布时间为今天下午的两点，执行完就删除没有了。一次性的。

实现主要依靠于 TaskScheduler 的ScheduledFuture<?> schedule(Runnable task, Trigger trigger);方法来实现。其本质和动态定时任务的实现是一样的。

3.1、实现重点

代码中都含有注解，不多做阐述。

import cn.hutool.core.convert.ConverterRegistry;
import com.crush.scheduled.entity.Task;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ScheduledFuture;

/**
 * @author crush
 */
@Component
@Slf4j
public class DynamicTaskService {

    /**
     * 以下两个都是线程安全的集合类。
     */
    public Map<String, ScheduledFuture<?>> taskMap = new ConcurrentHashMap<>();
    public List<String> taskList = new CopyOnWriteArrayList<String>();


    private final ThreadPoolTaskScheduler syncScheduler;

    public DynamicTaskService(ThreadPoolTaskScheduler syncScheduler) {
        this.syncScheduler = syncScheduler;
    }

    /**
     * 查看已开启但还未执行的动态任务
     * @return
     */
    public List<String> getTaskList() {
        return taskList;
    }


    /**
     * 添加一个动态任务
     *
     * @param task
     * @return
     */
    public boolean add(Task task) {
        // 此处的逻辑是 ，如果当前已经有这个名字的任务存在，先删除之前的，再添加现在的。（即重复就覆盖）
        if (null != taskMap.get(task.getName())) {
            stop(task.getName());
        }

        // hutool 工具包下的一个转换类型工具类 好用的很
        ConverterRegistry converterRegistry = ConverterRegistry.getInstance();
        Date startTime = converterRegistry.convert(Date.class, task.getStart());

        // schedule :调度给定的Runnable ，在指定的执行时间调用它。
        //一旦调度程序关闭或返回的ScheduledFuture被取消，执行将结束。
        //参数：
        //任务 – 触发器触发时执行的 Runnable
        //startTime – 任务所需的执行时间（如果这是过去，则任务将立即执行，即尽快执行）
        ScheduledFuture<?> schedule = syncScheduler.schedule(getRunnable(task), startTime);
        taskMap.put(task.getName(), schedule);
        taskList.add(task.getName());
        return true;
    }


    /**
     * 运行任务
     *
     * @param task
     * @return
     */
    public Runnable getRunnable(Task task) {
        return () -> {
            log.info("---动态定时任务运行---");
            try {
                System.out.println("此时时间==>" + LocalDateTime.now());
                System.out.println("task中设定的时间==>" + task);
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.info("---end--------");
        };
    }

    /**
     * 停止任务
     *
     * @param name
     * @return
     */
    public boolean stop(String name) {
        if (null == taskMap.get(name)) {
            return false;
        }
        ScheduledFuture<?> scheduledFuture = taskMap.get(name);
        scheduledFuture.cancel(true);
        taskMap.remove(name);
        taskList.remove(name);
        return true;
    }
}
复制代码

3.2、异步线程池的配置

/**
 * 异步线程池ThreadPoolExecutor 配置类
 *
 * @Author: crush
 * @Date: 2021-07-23 14:14
 */
@Configuration
public class ThreadPoolTaskExecutorConfig {

    @Bean
    public ThreadPoolTaskScheduler syncScheduler() {
        ThreadPoolTaskScheduler syncScheduler = new ThreadPoolTaskScheduler();
        syncScheduler.setPoolSize(5);
        // 这里给线程设置名字，主要是为了在项目能够更快速的定位错误。
        syncScheduler.setThreadGroupName("syncTg");
        syncScheduler.setThreadNamePrefix("syncThread-");
        syncScheduler.initialize();
        return syncScheduler;
    }
}

复制代码

3.3、业务代码

这里需要注意一个点，我给项目中的 LocalDateTime 做了类型转换。这里没贴出来（主要是复制以前的代码遗留下来的，源码中都有）

大家简单使用，可以直接用注解 标注在 LocalDateTime 属性上即可。

package com.crush.scheduled.controller;
import com.crush.scheduled.entity.Task;
import com.crush.scheduled.service.DynamicTaskService;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @Author: crush
 * @Date: 2021-07-29 15:26
 * version 1.0
 */
@RestController
@RequestMapping("/dynamicTask")
public class DynamicTaskController {

    private final DynamicTaskService dynamicTask;

    public DynamicTaskController(DynamicTaskService dynamicTask) {
        this.dynamicTask = dynamicTask;
    }

    /**
     * 查看已开启但还未执行的动态任务
     * @return
     */
    @GetMapping
    public List<String> getStartingDynamicTask(){
        return dynamicTask.getTaskList();
    }


    /**
     * 开启一个动态任务
     * @param task
     * @return
     */
    @PostMapping("/dynamic")
    public String startDynamicTask(@RequestBody Task task){
        // 将这个添加到动态定时任务中去
        dynamicTask.add(task);
         return "动态任务:"+task.getName()+" 已开启";
    }


    /**
     *  根据名称 停止一个动态任务
     * @param name
     * @return
     */
    @DeleteMapping("/{name}")
    public String stopDynamicTask(@PathVariable("name") String name){
        // 将这个添加到动态定时任务中去
        if(!dynamicTask.stop(name)){
            return "停止失败,任务已在进行中.";
        }
        return "任务已停止";
    }

}
复制代码

简单封装的一个实体类：

/**
 * @Author: crush
 * @Date: 2021-07-29 15:35
 * version 1.0
 */
@Data
@Accessors(chain = true) // 方便链式编写 习惯所然 
public class Task {
    /**
     * 动态任务名曾
     */
    private String name;

    /**
     * 设定动态任务开始时间
     */
    private LocalDateTime start;
}
复制代码

3.4、效果

💫💨

开启一个动态任务：

查看开启还未执行的动态任务：

执行结果：

和我们代码中是一模一样的。

停止任务：

再去查看就是已经停止的拉

搬山道猿
关注
springboot建立动态定时任务
xiegongmiao的博客
08-18 672
建立定时任务 1.创建定时器抽象类 /** * 定时器抽象类 * * @author * */ public abstract class ScheduleTask implements Runnable { private String id; public void setId(String id) { this.id = id; } public Strin...
在SpringBoot项目中实现动态定时任务。
weixin_59459355的博客
08-19 761
除了这种借助cron表达式的方法，还有另一种触发器，区别于CronTrigger触发器，这个触发器可随意设置循环间隔时间，不像cron表达式只能定义小于等于间隔59秒。cron表达是方式配置。
spring boot动态定时任务
weixin_36963061的博客
08-12 535
Spring Boot 动态定时任务 在现代软件开发中，定时任务是实现定期执行某些操作（例如，数据备份、邮件发送等）的有效方式。Spring Boot 作为一种流行的微服务框架，提供了简洁的定时任务机制。然而，很多时候，我们需要根据业务需求动态地调整定时任务的执行频率。本文将介绍如何在 Spring Boot 中实现动态定...
Spring定时任务 - @Scheduled注解详解
最新发布
weixin_49114503的博客
09-25 2525
Spring定时任务 - @Scheduled注解详解
SpringBoot实现动态定时任务
站在墙头上的博客
06-30 4490
springboot实现动态定时任务
Spring动态添加定时任务
huan的学习记录
07-08 4460
一、背景 在工作中，有些时候我们有些定时任务的执行可能是需要动态修改的，比如： 生成报表，有些项目配置每天的8点生成，有些项目配置每天的10点生成，像这种动态的任务执行时间，在不考虑分布式执行的情况下，我们可以 使用 Spring Task来简单的实现。 二、需求和实现思路 1、能够动态的添加一个定时任务。 在Spring中存在一个类ThreadPoolTaskScheduler,它可以实现根据一个cron表达式来调度一个任务，并返回一个ScheduledFuture对象。 2、能够取消定时任务的执行。 通
springboot定时任务的动态开启关闭
03-07
本篇文章将深入探讨如何在Spring Boot中实现定时任务的动态开启和关闭。 首先，我们需要引入Spring Boot的`spring-boot-starter-quartz`或者`spring-boot-starter-task`依赖，这两个都是Spring框架提供的定时任务...
Springboot2-Quartz 后台可动态配置的定时任务
02-28
Quartz 后台可动态配置的定时任务”是基于SpringBoot 2.x版本与Quartz Scheduler整合的一个示例，它展示了如何在后台管理系统中动态地创建、更新和删除定时任务，以及监控这些任务的状态，为开发人员提供了一种灵活...
详解SpringBoot 创建定时任务（配合数据库动态执行）
08-29
在SpringBoot中创建定时任务，主要有两种方式：一种是通过注解(@Scheduled)创建静态定时任务，另一种是通过实现接口(SchedulingConfigurer)创建动态定时任务。 静态定时任务的创建非常简单，只需几行代码便可以完成...
springboot集成schedule实现定时任务
08-27
Spring Boot 集成 Schedule 实现定时任务 Spring Boot 是一个基于 Java 的开源框架，用于快速构建生产级别的应用程序。 Schedule 是 Spring 中的一个...开发者可以根据实际需求选择合适的实现方式，以满足项目的需要。
SpringBoot设置动态定时任务
嘿！晚安 的博客
10-12 927
SpringBoot设置动态定时任务
spring设置动态定时任务
jad's blog
12-28 125
spring设置动态定时任务 Quartz 在 Spring 中动态设置 cronExpression 什么是动态定时任务：是由客户制定生成的，服务端只知道该去执行什么任务，但任务的定时是不确定的（是由客户制定）。 这样总不能修改配置文件每定制个定时任务就增加一个trigger 吧，即便允许客户修改配置文件，但总需要重新启动web 服务啊，研究了下Quartz 在Spring...
SPRING BOOT 动态定时任务
热门推荐
hudeyong926的专栏
06-14 1万+
动态定时任务
springboot 动态定时任务
CzRger的博客
09-09 2316
通过重写SchedulingConfigurer方法实现对定时任务的操作，单次执行、停止、启动三个主要的基本功能，动态的从数据库中获取配置的定时任务cron信息，通过反射的方式灵活定位到具体的类与方法中
springboot schedule动态实现_基于Spring Boot实现定时任务的动态增删启停
weixin_29763641的博客
01-12 821
今天跟大家分享基于Spring Boot实现定时任务的动态增删启停的知识。1基于Spring Boot实现定时任务的动态增删启停在spring boot项目中，可以通过@EnableScheduling注解和@Scheduled注解实现定时任务，也可以通过SchedulingConfigurer接口来实现定时任务。但是这两种方式不能动态添加、删除、启动、停止任务。要实现动态增删启停定时...
使用SpringBoot实现可以动态调整的定时任务
u012559967的专栏
05-13 2122
定时任务需求我们经常需要用到。在实现定时任务的场景中，一类是需要考虑到多节点只能由一个节点来执行的场景，这种定时任务需要能够将执行的记录存入到第三方存储中(比如数据库或者redis)，实际的开发中是用一些定时任务的框架来完成(如quartz）；另一类场景是每一个节点都能够执行的场景，不存在线程抢占的冲突。本文介绍的是适用于第二类场景，我们可以不用引入复杂的第三方框架，只用SpringBoot自带的方式来实现可以随时修改的定时任务。
Spring boot 动态创建定时任务
L19910311的博客
08-18 3170
springboot创建动态定时任务，支持添加，修改，删除，立即执行等操作
SpringBoot动态与静态定时任务实现详解
"本文详细介绍了在Java的SpringBoot框架下如何创建定时任务，包括基于注解(@Scheduled)、基于接口(SchedulingConfigurer)以及基于注解设定多线程定时任务的实现方式，并提供了相应的代码示例。" 在Java SpringBoot...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值