首页 > 资讯 > 后端开发 > Python >SpringBoot Schedule调度任务的动态管理

678

分享到

SpringBoot Schedule调度任务的动态管理

SpringBoot Schedule SpringBoot Schedule动态管理任务 2023-02-25 11:02:01 678人浏览泡泡鱼

Python 官方文档：入门教程 => 点击学习

摘要

目录前言一、架构流程图二、代码实现流程1.引入库2.代码流程前言定时任务动态管理分为两种方式：方式一:WEB前台配置Trigger触发器(关联Cron)、ThreadPoolTa

前言

定时任务动态管理分为两种方式：

方式一:WEB前台配置Trigger触发器(关联Cron)、ThreadPoolTaskScheduler类创建Scheduler方式下进行Schedule调度任务的动态管理

方式二:基于已创建的Schedule调度任务的动态管理，即以组件类 @Scheduled注解声明Schedule调度，在启动程序前一次性初始化，如：

@Component
public class TestTask {
    private DateTimeFORMatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    @Scheduled(cron = "0/2 * * * * ?")
    public void robReceiveExpireTask() {
        System.out.println(df.format(LocalDateTime.now()) + "测试测试");
    }
}

解决方案参考 SpringBoot的定时任务动态管理

缺陷：目前无法在运行期间增加Schedule以及stop、Start、Reset等管理。

本文章主要编写方式一的实现方案，主要从架构流程图配合代码进行说明。

一、架构流程图

二、代码实现流程

架构为springBoot + Spring + mybatis-plus

1.引入库

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="Http://Maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>merak-hyper-automation-boot</artifactId>
        <groupId>com.merak.automation</groupId>
        <version>1.0.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>automation-quartz</artifactId>
    <packaging>jar</packaging>
    <repositories>
        <repository>
            <id>aliyun</id>
            <name>aliyun Repository</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>
    <dependencies>
        <!-- Spring框架基本的核心工具 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
        <!-- SpringWeb模块 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
        </dependency>
        <!-- Mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- druid数据连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        <dependency>
            <groupId>jakarta.validation</groupId>
            <artifactId>jakarta.validation-api</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastJSON</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
        </dependency>
        <!--引入quartz定时框架-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <!-- 打包跳过测试 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

resources目录下文件/application.yml:

spring:

profiles:

active: dev

resources目录下文件/application-dev.yml:

server:
port: 12105
servlet:
context-path: /automation-quartz

management:
endpoints:
web:
exposure:
include: '*'

# Spring配置
spring:
resources:
static-locations: classpath:/static/,classpath:/templates/
mvc:
throw-exception-if-no-handler-found: true
static-path-pattern: xml @EnableScheduling @EnableAsync @MapperScan(basePackages = {"com.merak.hyper.automation.persist.**.mapper"}) @SpringBootApplication(scanBasePackages = {"com.merak.hyper.automation.**"}, exclude = {SecurityAutoConfiguration.class}) public class MerakQuartzApplication { public static final Logger log = LoggerFactory.getLogger(MerakQuartzApplication.class); public static void main(String[] args) { SpringApplication.run(MerakQuartzApplication.class, args); } private int taskSchedulerCorePoolSize = 15; private int awaitTerminationSeconds = 60; private String threadNamePrefix = "taskExecutor-"; @Bean public ThreadPoolTaskScheduler threadPoolTaskScheduler() { ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler(); taskScheduler.setPoolSize(taskSchedulerCorePoolSize); taskScheduler.setThreadNamePrefix(threadNamePrefix); taskScheduler.setWaitForTasksToCompleteOnShutdown(false); taskScheduler.setAwaitTerminationSeconds(awaitTerminationSeconds); taskScheduler.initialize(); // isinitialized = true; log.info("初始化ThreadPoolTaskScheduler ThreadNamePrefix=" + threadNamePrefix + ",PoolSize=" + taskSchedulerCorePoolSize + ",awaitTerminationSeconds=" + awaitTerminationSeconds); return taskScheduler; } @Bean("asyncTaskExecutor") public Executor taskExecutor() { ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor(); taskExecutor.setCorePoolSize(5); taskExecutor.setMaxPoolSize(50); taskExecutor.setQueueCapacity(200); taskExecutor.seTKEepAliveSeconds(60); taskExecutor.setThreadNamePrefix("asyncTaskExecutor-"); taskExecutor.setWaitForTasksToCompleteOnShutdown(true); taskExecutor.setAwaitTerminationSeconds(60); //修改拒绝策略为使用当前线程执行 taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); //初始化线程池 taskExecutor.initialize(); return taskExecutor; } }

一、启动时项目启动时，加载任务关联的触发器，并全量执行流程。

initLineRunner类：

package com.merak.hyper.automation.Scheduling;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.merak.hyper.automation.persist.entity.AutoTriggerInfo;
import com.merak.hyper.automation.persist.entity.BusWorkflow;
import com.merak.hyper.automation.persist.service.IAutoTriggerInfoService;
import com.merak.hyper.automation.persist.service.IBusWorkflowService;
import com.merak.hyper.automation.util.CommonUtil;
import com.merak.hyper.automation.util.ScheduleUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

@Component
@Order(1)
public class initLineRunner implements CommandLineRunner {
    public static final Logger log = LoggerFactory.getLogger(initLineRunner.class);
    private DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    @Autowired
    private TaskService taskService;
    @Autowired
    private IAutoTriggerInfoService triggerInfoService;
    @Autowired
    private IBusWorkflowService workflowService;
    @Override
    public void run(String... args) {
        log.info("项目启动:加载数字员工关联的触发器信息并全量执行," + df.format(LocalDateTime.now()));
        QueryWrapper<BusWorkflow> wrapper = new QueryWrapper<>();
        wrapper.eq("wf_type", "3");//3:云托管
        wrapper.eq("wf_state", "1");
        List<BusWorkflow> busWorkflows = workflowService.list(wrapper);
        List<AutoTriggerInfo> triggerInfos =  triggerInfoService.list();
        if( 0 == busWorkflows.size() || 0 == triggerInfos.size() ){
            log.info("数字员工关联的触发器信息不正确，员工记录数:"+busWorkflows.size()+",触发器记录数:"+triggerInfos.size());
        }
        else{
            //数字员工关联的触发器信息
            Map<String,AutoTriggerInfo> loadWfidAndTriggerInfo = CommonUtil.loadWfidAndTriggerInfo(busWorkflows,triggerInfos);
            Iterator<Map.Entry<String, AutoTriggerInfo>> entries = loadWfidAndTriggerInfo.entrySet().iterator();
            while (entries.hasNext()) {
                Map.Entry<String, AutoTriggerInfo> entry = entries.next();
                String wfId = entry.getKey();
                BusWorkflow workflow = busWorkflows.stream().filter( t -> wfId.equals(t.getWfId()) ).findAny().orElse(null);
                if( null != workflow ){
                    ScheduleUtil.start(new ScheduleTask(wfId,String.valueOf(workflow.getWfCreateuserId()),taskService), entry.getValue());
                }
            }
            log.info("数字员工关联的触发器信息全量执行完成，数字员工定时个数:"+loadWfidAndTriggerInfo.size()+","+df.format(LocalDateTime.now()));
        }
    }
}
核心代码：
```java
  ScheduleUtil.start(new ScheduleTask(wfId,String.valueOf(workflow.getWfCreateuserId()),taskService), entry.getValue());

Scheduler管理工具类:启动、取消、修改等管理

package com.merak.hyper.automation.util;
import com.merak.hyper.automation.Scheduling.ScheduleTask;
import com.merak.hyper.automation.persist.entity.AutoTriggerInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.support.CronTrigger;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ScheduledFuture;

public class ScheduleUtil {
    public static final Logger log = LoggerFactory.getLogger(ScheduleUtil.class);
    private static ThreadPoolTaskScheduler threadPoolTaskScheduler = SprinGContextUtils.getBean(ThreadPoolTaskScheduler.class);
    //存储[数字员工wfI，dScheduledFuture]集合
    private static Map<String, ScheduledFuture<?>> scheduledFutureMap = new HashMap<>();
    
    public static boolean start(ScheduleTask scheduleTask, AutoTriggerInfo triggerInfo) {
        String wfId = scheduleTask.getId();
        log.info("启动数字员工"+wfId+"定时任务线程" + scheduleTask.getId());
        ScheduledFuture<?> scheduledFuture = threadPoolTaskScheduler.schedule(scheduleTask, new CronTrigger(triggerInfo.getLogicConfig()));
        scheduledFutureMap.put(wfId, scheduledFuture);
        return true;
    }
    
    public static boolean cancel(ScheduleTask scheduleTask) {
        log.info("关闭定时任务线程 taskId " + scheduleTask.getId());
        ScheduledFuture<?> scheduledFuture = scheduledFutureMap.get(scheduleTask.getId());
        if (scheduledFuture != null && !scheduledFuture.isCancelled()) {
            scheduledFuture.cancel(false);
        }
        scheduledFutureMap.remove(scheduleTask.getId());
        return true;
    }
    
    public static boolean reset(ScheduleTask scheduleTask, AutoTriggerInfo triggerInfo) {
        //先取消定时任务
        cancel(scheduleTask);
        //然后启动新的定时任务
        start(scheduleTask, triggerInfo);
        return true;
    }
}

ScheduleTask类：ScheduleTask任务类

package com.merak.hyper.automation.Scheduling;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ScheduleTask implements Runnable {
    private static final int TIMEOUT = 30000;
    private String id;
    private String userId;
    private TaskService service;
    public static final Logger log = LoggerFactory.getLogger(ScheduleTask.class);
    public String getId() {
        return id;
    }
    
    public ScheduleTask(String id, String userId, TaskService service) {
        this.id = id;
        this.userId = userId;
        this.service = service;
    }
    @Override
    public void run() {
        log.info("ScheduleTask-执行数字员工消息的发送,id:"+ this.id + ",用户id:"+userId);
        service.work(this.id,this.userId);
    }
}


public interface TaskService {
    
    void work(String keyWord,String userId);
}

@Service
public class TaskServiceImpl implements TaskService {
    public static final Logger log = LoggerFactory.getLogger(TaskServiceImpl.class);
    @Autowired
    private IAutoDeviceInfoService deviceInfoService;
    @Override
    public void work(String wfId,String userId) {
        try {
            log.info("定时任务：根据数字员工wfId"+ wfId +",用户id:"+userId+"，发送消息...");
            //sendRobotMsg(wfId,userId);
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

二、通过WEB配置的变更，动态管理定时任务

ScheduledController类:scheduled Web业务层：启动、取消、修改等管理schedule

调度任务信息变更（如1：Trigger Cron变更 2：任务停止 3：任务新增加等）

package com.merak.hyper.automation.controller;
import com.merak.hyper.automation.common.core.domain.ajaxResult;
import com.merak.hyper.automation.common.core.vo.ScheduledApiVo;
import com.merak.hyper.automation.persist.entity.AutoTriggerInfo;
import com.merak.hyper.automation.persist.service.IAutoTriggerInfoService;
import com.merak.hyper.automation.util.ScheduledHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/scheduled")
public class ScheduledController {
    public static final Logger log = LoggerFactory.getLogger(ScheduledController.class);
    @Autowired
    private IAutoTriggerInfoService triggerInfoService;
    @Autowired
    private ScheduledHelper scheduledHelper;
    @PostMapping("/add")
    public AjaxResult addScheduleds(@RequestBody ScheduledApiVo scheduledApiVo){
        AutoTriggerInfo autoTriggerInfo = triggerInfoService.getById(scheduledApiVo.getTriggerId());
        scheduledHelper.addScheduleds(scheduledApiVo,autoTriggerInfo);
        return AjaxResult.success();
    }
    @PostMapping("/reset")
    public AjaxResult resetScheduleds(@RequestBody ScheduledApiVo scheduledApiVo){
        AutoTriggerInfo autoTriggerInfo = triggerInfoService.getById(scheduledApiVo.getTriggerId());
        scheduledHelper.resetScheduleds(scheduledApiVo,autoTriggerInfo);
        return AjaxResult.success();
    }
    @PostMapping("/stop")
    public AjaxResult stopScheduleds(@RequestBody ScheduledApiVo scheduledApiVo){
        AutoTriggerInfo autoTriggerInfo = triggerInfoService.getById(scheduledApiVo.getTriggerId());
        scheduledHelper.stopScheduleds(scheduledApiVo);
        return AjaxResult.success();
    }
}
ScheduledHelper类：对外提供ScheduledHelper管理:创建、变更、停止
```java
package com.merak.hyper.automation.util;
import com.merak.hyper.automation.Scheduling.ScheduleTask;
import com.merak.hyper.automation.Scheduling.TaskService;
import com.merak.hyper.automation.common.core.vo.ScheduledApiVo;
import com.merak.hyper.automation.persist.entity.AutoTriggerInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Component
public class ScheduledHelper {
    public static final Logger log = LoggerFactory.getLogger(ScheduledHelper.class);
    
    @Async("asyncTaskExecutor")
    public void addScheduleds(ScheduledApiVo scheduledApiVo, AutoTriggerInfo triggerInfo) {
        //addSchedule任务
        log.warn("创建原数字员工["+scheduledApiVo.getWfId()+"],同步启动Schedule任务");
        TaskService taskService = SpringContextUtils.getBean(TaskService.class);
        ScheduleUtil.start(new ScheduleTask(scheduledApiVo.getWfId(), scheduledApiVo.getUserId(), taskService), triggerInfo);
    }
    @Async("asyncTaskExecutor")
    public void resetScheduleds(ScheduledApiVo scheduledApiVo,AutoTriggerInfo triggerInfo) {
        //cron值改变，变更Schedule任务
        log.warn("数字员工["+scheduledApiVo.getWfId()+"]关联的触发器信息cron值改变，变更Schedule任务");
        TaskService taskService = SpringContextUtils.getBean(TaskService.class);
        ScheduleUtil.reset(new ScheduleTask(scheduledApiVo.getWfId(), scheduledApiVo.getUserId(), taskService), triggerInfo);
    }
    @Async("asyncTaskExecutor")
    public void stopScheduleds(ScheduledApiVo scheduledApiVo) {
        //移除Wfid，停止原Schedule任务
        log.warn("原数字员工["+scheduledApiVo.getWfId()+"]无效，同步停止Schedule任务");
        TaskService taskService = SpringContextUtils.getBean(TaskService.class);
        ScheduleUtil.cancel(new ScheduleTask(scheduledApiVo.getWfId(), scheduledApiVo.getUserId(), taskService));
    }
}

SpringContextUtils类：

package com.merak.hyper.automation.util;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class SpringContextUtils implements ApplicationContextAware {
    private static ApplicationContext applicationContext;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext)
            throws BeansException {
        SpringContextUtils.applicationContext = applicationContext;
    }
    public static Object getBean(String name) {
        return applicationContext.getBean(name);
    }
    public static <T> T getBean(Class<T> requiredType) {
        return applicationContext.getBean(requiredType);
    }
    public static <T> T getBean(String name, Class<T> requiredType) {
        return applicationContext.getBean(name, requiredType);
    }
    public static boolean containsBean(String name) {
        return applicationContext.containsBean(name);
    }
    public static boolean isSingleton(String name) {
        return applicationContext.isSingleton(name);
    }
    public static Class<? extends Object> getType(String name) {
        return applicationContext.getType(name);
    }
}

ScheduledApiVo类：

import java.io.Serializable;

public class ScheduledApiVo implements Serializable {
    private String wfId;
    private String userId;
    private String triggerId;
    //set get 略
}

最终：Web端通过发送Http请求，调用ScheduledHelper管理类接口，实现Scheduled创建、变更、停止操作

  log.info("3:云托管更新启动数字员工操作");
  ScheduledApiVo scheduledApiVo = new ScheduledApiVo();
  scheduledApiVo.setWfId(wfId);
  scheduledApiVo.setUserId(String.valueOf(updateUserId));
  scheduledApiVo.setTriggerId(newTriggerInfo.getId());
  String webHookBody = jsON.toJSONString(scheduledApiVo);
  EmsApiUtil.SendQuartzMessage(url, "add", webHookBody);
 ******************** 分隔     ************************
  public static boolean SendQuartzMessage(String quartzUrl, String method, String webHookBody){
      boolean result = false;
      try{
          //org.apache.httpcomponents.httpclient sendPost，pom依赖如下dependency
          String resp = HttpClientUtil.sendPostByJson(quartzUrl+"/"+method, webHookBody,0);
          if( "error".equals(resp) || resp.contains("405 Not Allowed")){
              log.error("调用任务调度中心消息发送失败,地址:"+quartzUrl);
          }
          else {
              JSONObject jsonObject = JSON.parseObject(resp);
              if( "200".equals(String.valueOf(jsonObject.get("code"))) ){
                  result = true;
              }
              else{
                  log.error("调用任务调度中心失败,msg："+String.valueOf(jsonObject.get("msg")));
              }
          }
      }catch (Exception e){
          log.error("调用任务调度中心失败,msg："+e.getMessage());
      }
      return result;
  }

    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5.2</version>
    </dependency>

到此这篇关于SpringBoot Schedule调度任务的动态管理的文章就介绍到这了,更多相关SpringBoot Schedule内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: SpringBoot Schedule调度任务的动态管理

本文链接: https://www.lsjlt.com/news/197511.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

SpringBoot Schedule调度任务的动态管理

目录前言一、架构流程图二、代码实现流程1.引入库2.代码流程前言定时任务动态管理分为两种方式：方式一:Web前台配置Trigger触发器(关联Cron)、ThreadPoolTa...

99+

2023-02-25

SpringBoot Schedule SpringBoot Schedule动态管理任务
SpringBoot Schedule调度任务的动态管理方法是什么

这篇文章主要介绍了SpringBoot Schedule调度任务的动态管理方法是什么的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇SpringBoot Schedule调度任务的动态管理方法...

99+

2023-07-05
springboot怎么动态创建任务调度

在Spring Boot中动态创建任务调度可以使用Spring的TaskScheduler接口来实现。TaskScheduler接口...

99+

2023-10-20

springboot
SpringBoot 任务调度动态设置方式(不用重启服务)

目录SpringBoot 任务调度动态设置1.初始化入口(注解 @PostConstruct)2.任务调度类SpringBoot 调度任务1.首先需要用@EnableScheduli...

99+

2024-04-02
python周期任务调度工具Schedule使用详解

目录1.准备2.基本使用参数传递获取目前所有的作业取消所有作业标签功能设定作业截止时间3.高级使用装饰器安排作业并行执行日志记录异常处理如果你想周期性地执行某个 Python 脚本，...

99+

2024-04-02
spring schedule配置多任务动态cron(增删启停)

一、背景之前公司经常会遇到配置定时任务，简单的任务可以直接依赖spring。简单任务直接使用 @scheduled 注解配合@EnableScheduling。但是如何实现简单...

99+

2024-04-02
springboot任务调度怎么实现

要在Spring Boot中实现任务调度，可以使用Spring Task框架。下面是一些步骤来实现任务调度：1. 在pom.xml文...

99+

2023-10-11

springboot
掌握ASP Hangfire任务调度，轻松管理后台任务

ASP Hangfire、任务队列、后台任务、异步任务、定时任务、代码示例、.NET Core、.NET Framework。 ASP Hangfire简介 ASP Hangfire是一个开源的、轻量级的.NET任务队列，用于管理和执...

99+

2024-02-04

ASP Hangfire任务队列提供了便捷的后台任务管理功能帮助开发人员轻松处理异步任务提高应用程序的性能和可靠性。本文将深入解析ASP Hangfire任务队列的使用方法并提供代码示例帮助
SpringBoot 调度任务及常用任务表达式

首先需要用@EnableScheduling注解到*applicatin.java，用来检测是否有调度任务。@Scheduled 注解用于标注这个方法是一个定时任务的方法。Spring会自动扫描这个注解，启动调度任务。package com...

99+

2023-05-30

spring boot 调度
Springboot-admin整合Quartz实现动态管理定时任务的过程详解

目录boot-admin整合Quartz实现动态管理定时任务加入依赖前端整合vue页面后端整合配置类单独数据源配置调度器配置任务模板Job示例类管理功能boot-admin整合Qua...

99+

2023-05-18

Springboot-admin整合Quartz Springboot动态管理定时任务
Atlas是否支持自动化任务调度和工作流程管理

是的，Atlas支持自动化任务调度和工作流程管理。用户可以使用Atlas的Scheduled Tasks功能来创建和调度定期运行的任...

99+

2024-04-02
SpringBoot动态定时任务(完整版)

本文定时任务功能(增、删、改、启动、暂停) 话不多说，直接上代码，你们直接CV就可以用！！！执行定时任务的线程池配置类 import org.springframework.context.annotation.Bean;im...

99+

2023-08-30

spring boot java spring
SpringBoot+Quartz实现动态定时任务

本文实例为大家分享了springBoot+Quartz实现动态定时任务的具体代码，供大家参考，具体内容如下目前常用的几种任务调度 Timer，简单无门槛，一般也没人用。spring...

99+

2024-04-02
Spring动态管理定时任务之ThreadPoolTaskScheduler解读

目录Spring动态管理定时任务ThreadPoolTaskScheduler实现思路ThreadPoolTaskScheduler 定时任务实现总结Spring动态管理定时任务Th...

99+

2022-12-28

Spring动态管理定时任务 ThreadPoolTaskScheduler Spring定时任务
ASP Hangfire任务调度进阶指南：打造高效的任务管理系统

ASP Hangfire是一个基于.NET的开源任务调度框架，可帮助您创建可靠、可扩展的任务管理系统。Hangfire提供了多种功能，包括：定期任务：您可以设置任务在特定时间间隔（如每分钟、每小时或每天）运行。延迟任务：您可以设置...

99+

2024-02-04

ASP.NET Hangfire 任务调度任务管理
SpringBoot动态定时任务如何实现

这篇文章主要介绍了SpringBoot动态定时任务如何实现的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇SpringBoot动态定时任务如何实现文章都会有所收获，下面我们一起来看看吧。执行定时任务的...

99+

2023-07-05
SpringBoot如何设置动态定时任务

这篇文章主要介绍了SpringBoot如何设置动态定时任务的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇SpringBoot如何设置动态定时任务文章都会有所收获，下面我们一起来看看吧。之前写过文章记录怎么在Sp...

99+

2023-07-02
golang任务调度的原理是什么

Golang中的任务调度是通过使用goroutine和channel来实现的。Goroutine是一种轻量级的线程，由Go语言运行时...

99+

2024-02-29

golang
SpringBoot整合XxlJob分布式任务调度平台

目录1.XxlJob简介2.XxlJob快速入门2.1 下载源码仓库地址2.2 定时任务实现步骤3.SpringBoot整合XxlJob3.1 创建SpringBoot工程引入依赖3...

99+

2023-02-28

SpringBoot整合XxlJob SpringBoot分布式任务调度平台
SpringBoot动态Feign服务调用详解

目录1.Feign传统方式的不足2.动态Feign2.1.服务生产者2.2.动态Feign2.3.服务消费者3.总结1.Feign传统方式的不足 ①.在微服务架构中,当我们使用Fei...

99+

2022-12-21

SpringBoot动态Feign SpringBoot动态Feign服务调用