SpringBoot定时任务动态管理

最新推荐文章于 2024-04-26 21:45:17 发布
最新推荐文章于 2024-04-26 21:45:17 发布
阅读量1k 收藏 7
点赞数
分类专栏： spring boot 文章标签： spring boot 定时任务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aw277866304/article/details/120650889
版权

1.作用

        无需对系统进行启停操作即可对定时任务进行增删改、启停和重启，对比于只使用了@Scheduled标签的定时任务更灵活多变。不推荐任务集群时使用，会重复执行。

2.前期准备

2.1 创建定时任务表

create table `cj_scheduled_task` (
  `id` varchar(50) primary key comment '主键id',
  `task_class` varchar(100) not null comment '定时任务完整类名',
  `cron_expression` varchar(20) not null comment 'cron表达式',
  `task_explain` varchar(200) default null comment '任务描述',
  `status` tinyint(1) not null comment '状态：1.启用；2.停用',
  `create_by` varchar(50) comment '创建人',
  `create_time` datetime comment '创建时间',
  `update_by` varchar(50) comment '修改人',
  `update_time` datetime comment '修改时间'
)
ENGINE = InnoDB
DEFAULT CHARSET = utf8mb4
COMMENT = '定时任务';

说明：

（1）表名自定义，一般开头为业务系统名

（2）task_class：为定时任务全路径，具体到类名

2.2 定时任务实体类

package com.trasen.modules.chunjun.desreport.entity.scheduled;

import java.io.Serializable;
import java.util.Date;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

/**
 * 定时任务配置
 * 
 * @author xxx
 * @date: 2021-11-29 10:49:35
 * @Copyright: Copyright (c) 2006 - 2021
 * @Company: xxx公司
 * @Version: V1.0
 */
@TableName("cj_scheduled_task")
@Data
public class ScheduledTask implements Serializable {
    private static final long serialVersionUID = 1L;

    /** 主键id */
    @TableId(type = IdType.ASSIGN_UUID)
    @ApiModelProperty(value = "主键id")
    private String id;

    /** 定时任务完整类名 */
    @TableField("task_class")
    @ApiModelProperty(value = "定时任务完整类名")
    private String taskClass;

    /** cron表达式 */
    @TableField("cron_expression")
    @ApiModelProperty(value = "cron表达式")
    private String cronExpression;

    /** 任务描述 */
    @TableField("task_explain")
    @ApiModelProperty(value = "任务描述")
    private String taskExplain;

    /** 状态：1.启用；2.停用 */
    @TableField("status")
    @ApiModelProperty(value = "状态：1.启用；2.停用")
    private int status;

    /** 创建人. */
    @TableField("create_by")
    @ApiModelProperty(value = "创建人")
    private String createBy;

    /** 创建时间. */
    @TableField("create_time")
    @ApiModelProperty(value = "创建时间")
    private Date createTime;

    /** 修改人. */
    @TableField("update_by")
    @ApiModelProperty(value = "修改人")
    private String updateBy;

    /** 修改时间. */
    @TableField("update_time")
    @ApiModelProperty(value = "修改时间")
    private Date updateTime;
}

3.实现代码

3.1 线程池配置类：ScheduledConfig

package com.trasen.modules.chunjun.config.scheduled;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;

import lombok.extern.slf4j.Slf4j;

/**
 * 定时任务线程池配置类
 * 
 * @author xxx
 * @date: 2021-12-01 15:46:06
 * @Copyright: Copyright (c) 2006 - 2021
 * @Company: xxx公司
 * @Version: V1.0
 */
@Configuration
@Slf4j
public class ScheduledConfig {

    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
        log.info("创建定时任务调度线程池 start");
        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
        // 线程池大小
        threadPoolTaskScheduler.setPoolSize(20);
        // 线程名前缀
        threadPoolTaskScheduler.setThreadNamePrefix("taskExecutor-");
        // 停止系统时等待任务完成
        threadPoolTaskScheduler.setWaitForTasksToCompleteOnShutdown(true);
        // 等待停止时间：秒
        threadPoolTaskScheduler.setAwaitTerminationSeconds(60);
        log.info("创建定时任务调度线程池 end");
        return threadPoolTaskScheduler;
    }
}

3.2 定时任务服务接口类

package com.trasen.modules.chunjun.desreport.service;

import java.util.List;

import com.trasen.modules.chunjun.common.vo.Result;
import com.trasen.modules.chunjun.desreport.entity.scheduled.ScheduledTask;
import com.trasen.modules.chunjun.desreport.model.ScheduledTaskVO;

/**
 * 定时任务服务接口
 * 
 * @author xxx
 * @date: 2021-11-29 14:15:31
 * @Copyright: Copyright (c) 2006 - 2021
 * @Company: xxx公司
 * @Version: V1.0
 */
public interface IScheduledTaskService {

    /**
     * 查询所有：生成定时任务所需
     * 
     * @author: xxx
     * @date: 2021-11-30 10:45:49
     * @return
     */
    List<ScheduledTask> listAll();

    /**
     * 根据完整类名分页模糊查询
     * 
     * @author: xxx
     * @date: 2021-11-30 10:45:19
     * @param taskClass 完整类名
     * @return
     */
    Result<?> pageList(String taskClass);

    /**
     * 根据id查询
     * 
     * @author: xxx
     * @date: 2021-11-30 10:56:53
     * @param id
     * @return
     */
    ScheduledTask getById(String id);

    /**
     * 根据完整类名查询
     * 
     * @author: xxx
     * @date: 2021-11-30 10:56:53
     * @param taskClass 完整类名
     * @return
     */
    ScheduledTask findByTaskClass(String taskClass);

    /**
     * 执行
     * 
     * @author: xxx
     * @date: 2021-11-30 14:15:11
     * @param id 任务id
     */
    Result<?> start(String id);

    /**
     * 停止
     * 
     * @author: xxx
     * @date: 2021-12-01 16:09:47
     * @param id
     * @return
     */
    Result<?> stop(String id);

    /**
     * 重启
     * 
     * @author: xxx
     * @date: 2021-11-30 14:15:11
     * @param id 任务id
     */
    Result<?> restart(String id);

    /**
     * 更新
     * 
     * @author: xxx
     * @date: 2021-11-30 14:25:59
     * @param id
     * @return
     */
    Result<?> update(ScheduledTaskVO st);

    /**
     * 新增
     * 
     * @author: xxx
     * @date: 2021-12-01 14:44:32
     * @param st
     * @return
     */
    Result<?> insert(ScheduledTaskVO st);

    /**
     * 初始化定时任务
     * 
     * @author: xxx
     * @date: 2021-12-01 15:51:43
     */
    void initTask();
}

3.3 定时任务服务实现类

package com.trasen.modules.chunjun.desreport.service.impl;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.trasen.modules.chunjun.common.base.query.CriteriaQuery;
import com.trasen.modules.chunjun.common.base.service.BaseServiceImpl;
import com.trasen.modules.chunjun.common.util.LoginUserUtil;
import com.trasen.modules.chunjun.common.vo.Result;
import com.trasen.modules.chunjun.desreport.entity.scheduled.ScheduledTask;
import com.trasen.modules.chunjun.desreport.entity.scheduled.ScheduledTaskReport;
import com.trasen.modules.chunjun.desreport.mapper.ScheduledTaskMapper;
import com.trasen.modules.chunjun.desreport.model.ScheduledTaskVO;
import com.trasen.modules.chunjun.desreport.service.IScheduledTaskReportService;
import com.trasen.modules.chunjun.desreport.service.IScheduledTaskService;
import com.trasen.modules.chunjun.desreport.task.ScheduledOfTask;

import cn.hutool.extra.spring.SpringUtil;
import lombok.extern.slf4j.Slf4j;

/**
 * 定时任务服务实现
 * 
 * @author xxx
 * @date: 2021-11-29 14:58:08
 * @Copyright: Copyright (c) 2006 - 2021
 * @Company: xxx公司
 * @Version: V1.0
 */
@Slf4j
@Service
public class ScheduledTaskServiceImpl extends BaseServiceImpl<ScheduledTaskMapper, ScheduledTask>
    implements IScheduledTaskService {

    /** 可重入锁 */
    private ReentrantLock lock = new ReentrantLock();

    /** 定时任务线程池 */
    @Autowired
    private ThreadPoolTaskScheduler threadPoolTaskScheduler;
    @Autowired
    private IScheduledTaskReportService strService;

    /** 启动状态的定时任务集合 */
    public Map<String, ScheduledFuture> scheduledFutureMap = new ConcurrentHashMap<String, ScheduledFuture>();

    @Override
    public List<ScheduledTask> listAll() {
        return this.list();
    }

    @Override
    public Result<?> pageList(String taskClass) {
        CriteriaQuery<ScheduledTask> cq = new CriteriaQuery<ScheduledTask>(this.request);
        cq.like(null != taskClass && !taskClass.isEmpty(), ScheduledTask::getTaskClass, taskClass);
        return this.pageList(cq);
    }

    @Override
    public ScheduledTask getById(String id) {
        return super.getById(id);
    }

    @Override
    public ScheduledTask findByTaskClass(String taskClass) {
        LambdaQueryWrapper<ScheduledTask> queryWrapper = new LambdaQueryWrapper<ScheduledTask>();
        queryWrapper.eq(ScheduledTask::getTaskClass, taskClass);
        return super.getOne(queryWrapper);
    }

    @Override
    public Result<?> start(String id) {
        // 根据id查询任务
        ScheduledTask task = super.getById(id);
        // 判断任务是否启用
        if (1 != task.getStatus()) {
            return Result.error("定时任务未启用，无法执行！");
        }
        String taskClass = task.getTaskClass();
        log.info("启动定时任务：" + taskClass);
        // 添加锁放一个线程启动，防止多人启动多次
        lock.lock();
        log.info("加锁完成");
        try {
            if (this.isStart(id)) {
                String msg = "当前任务在启动状态中";
                log.info(msg);
                return Result.error(msg);
            }
            // 任务启动
            this.doStartTask(task);
        } finally {
            lock.unlock();
            log.info("解锁完毕");
        }
        return Result.OK();
    }

    @Override
    public Result<?> stop(String id) {
        // 根据id查询任务
        log.info("停止任务： " + id);
        boolean flag = scheduledFutureMap.containsKey(id);
        log.info("当前实例是否存在 " + flag);
        if (flag) {
            ScheduledFuture scheduledFuture = scheduledFutureMap.get(id);
            scheduledFuture.cancel(true);
            scheduledFutureMap.remove(id);
        } else {
            String msg = "当前任务不存在！";
            log.info(msg + id);
            Result.error(msg);
        }
        return Result.OK();
    }

    @Override
    public Result<?> restart(String id) {
        log.info("重启定时任务：" + id);
        // 停止
        this.stop(id);
        // 启动
        return this.start(id);
    }

    @Override
    public Result<?> update(ScheduledTaskVO st) {
        // 赋值更新人、更新时间
        st.setUpdateBy(LoginUserUtil.getCurrentUserId());
        st.setUpdateTime(new Date());
        if (!super.updateById(st)) {
            String msg = "新增失败！";
            log.error(msg);
            return Result.error(msg);
        }
        // 批量保存关联数据
        JSONObject params = new JSONObject();
        List<ScheduledTaskReport> strList = st.getStrList();
        if (null != strList && !strList.isEmpty()) {
            // 赋值任务id
            for (ScheduledTaskReport str : strList) {
                str.setTaskId(st.getId());
            }
        }
        params.put("strList", strList);
        params.put("ids", st.getIds());
        if (!strService.saveBatch(params).isSuccess()) {
            String msg = "批量保存失败！";
            log.error(msg);
            return Result.error(msg);
        }
        return Result.OK();
    }

    @Override
    @Transactional
    public Result<?> insert(ScheduledTaskVO st) {
        // 赋值创建人、创建时间
        st.setCreateBy(LoginUserUtil.getCurrentUserId());
        st.setCreateTime(new Date());
        // 新增定时任务
        if (!super.save(st)) {
            String msg = "新增失败！";
            log.error(msg);
            return Result.error(msg);
        }
        // 新增关联数据
        JSONObject params = new JSONObject();
        List<ScheduledTaskReport> strList = st.getStrList();
        if (null != strList && !strList.isEmpty()) {
            // 赋值任务id
            for (ScheduledTaskReport str : strList) {
                str.setTaskId(st.getId());
            }
            params.put("strList", strList);
            if (!strService.saveBatch(params).isSuccess()) {
                String msg = "批量新增失败！";
                log.error(msg);
                return Result.error(msg);
            }
        }
        return Result.OK();
    }

    @Override
    public void initTask() {
        List<ScheduledTask> stList = super.list();
        if (null != stList && !stList.isEmpty()) {
            // 循环所有定时任务
            for (ScheduledTask st : stList) {
                // 判断是否启用
                if (1 != st.getStatus()) {
                    continue;
                }
                // 执行任务
                doStartTask(st);
            }
        }
    }

    /**
     * 执行启动任务
     * 
     * @author: xxx
     * @date: 2021-12-01 16:16:31
     * @param scheduledTask 定时任务
     */
    private void doStartTask(ScheduledTask scheduledTask) {
        String taskClass = scheduledTask.getTaskClass();
        log.info(taskClass);
        if (1 != scheduledTask.getStatus()) {
            return;
        }
        Class clazz;
        ScheduledOfTask task;
        try {
            clazz = Class.forName(scheduledTask.getTaskClass());
            task = (ScheduledOfTask)SpringUtil.getBean(clazz);
        } catch (ClassNotFoundException e) {
            throw new IllegalArgumentException("【" + taskClass + "】类未找到！", e);
        }
        Assert.isAssignable(ScheduledOfTask.class, task.getClass(), "定时任务类必须实现ScheduledOfTask接口");
        ScheduledFuture scheduledFuture = threadPoolTaskScheduler.schedule(task,
            (triggerContext -> new CronTrigger(scheduledTask.getCronExpression()).nextExecutionTime(triggerContext)));
        scheduledFutureMap.put(scheduledTask.getId(), scheduledFuture);
    }

    /**
     * 检查任务是否已经启动
     * 
     * @author: xxx
     * @date: 2021-12-01 16:00:17
     * @param id 定时任务id
     * @return
     */
    private Boolean isStart(String id) {
        // 校验是否已经启动
        if (scheduledFutureMap.containsKey(id)) {
            if (!scheduledFutureMap.get(id).isCancelled()) {
                return true;
            }
        }
        return false;
    }
}

说明

BaseServiceImpl：为本业务系统服务实现基础类，请根据自身框架修改

3.4 定时任务控制器

用于页面操作，维护定时任务

package com.trasen.modules.chunjun.desreport.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.trasen.modules.chunjun.common.annotation.LoginRequired;
import com.trasen.modules.chunjun.common.vo.Result;
import com.trasen.modules.chunjun.desreport.model.ScheduledTaskVO;
import com.trasen.modules.chunjun.desreport.service.IScheduledTaskService;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

/**
 * 定时任务控制器
 * 
 * @author xxx
 * @date: 2021-11-30 13:50:20
 * @Copyright: Copyright (c) 2006 - 2021
 * @Company: xxx公司
 * @Version: V1.0
 */
@RestController
@RequestMapping("/chunjunreport/scheduled/task")
@Api(tags = "定时任务控制器")
public class ScheduledTaskController {

    @Autowired
    private IScheduledTaskService scheduledTaskService;

    @GetMapping({"/pageList"})
    @LoginRequired
    @ApiOperation(value = "【定时任务】分页查询", notes = "【定时任务】分页查询")
    public Result<?> pageList(@RequestParam(name = "taskClass", required = false) String taskClass) {
        return scheduledTaskService.pageList(taskClass);
    }

    @PostMapping({"/start"})
    @LoginRequired
    @ApiOperation(value = "【定时任务】运行", notes = "【定时任务】运行")
    public Result<?> start(@RequestParam(name = "id", required = true) String id) {
        return scheduledTaskService.start(id);
    }

    @PostMapping({"/stop"})
    @LoginRequired
    @ApiOperation(value = "【定时任务】停止", notes = "【定时任务】停止")
    public Result<?> stop(@RequestParam(name = "id", required = true) String id) {
        return scheduledTaskService.stop(id);
    }

    @PostMapping({"/restart"})
    @LoginRequired
    @ApiOperation(value = "【定时任务】重启", notes = "【定时任务】重启")
    public Result<?> restart(@RequestParam(name = "id", required = true) String id) {
        return scheduledTaskService.restart(id);
    }

    @PostMapping({"/update"})
    @LoginRequired
    @ApiOperation(value = "【定时任务】更新", notes = "【定时任务】更新")
    public Result<?> update(@RequestBody ScheduledTaskVO scheduledTask) {
        return scheduledTaskService.update(scheduledTask);
    }

    @PostMapping({"/insert"})
    @LoginRequired
    @ApiOperation(value = "【定时任务】新增", notes = "【定时任务】新增")
    public Result<?> insert(@RequestBody ScheduledTaskVO scheduledTask) {
        return scheduledTaskService.insert(scheduledTask);
    }
}

3.5 自定义定时任务接口

必须集成【Runnable】

package com.trasen.modules.chunjun.desreport.task;

import com.trasen.modules.chunjun.desreport.entity.scheduled.ScheduledTask;
import com.trasen.modules.chunjun.desreport.service.IScheduledTaskService;

import cn.hutool.extra.spring.SpringUtil;

/**
 * @author xxx
 * @date: 2021-11-30 17:06:13
 * @Copyright: Copyright (c) 2006 - 2021
 * @Company: xxx公司
 * @Version: V1.0
 */
public interface ScheduledOfTask extends Runnable {
    /**
     * 定时任务方法
     * 
     * @author: xxx
     * @date: 2021-12-01 11:47:00
     * @param id 任务id
     */
    void execute(String id);

    /**
     * 实现控制定时任务启用或禁用的功能
     */
    @Override
    default void run() {
        IScheduledTaskService stService = SpringUtil.getBean(IScheduledTaskService.class);
        ScheduledTask st = stService.findByTaskClass(this.getClass().getName());
        if (1 != st.getStatus()) {
            // 任务是禁用状态
            return;
        }
        execute(st.getId());
    }
}

3.6 自定义定时任务接口实现

package com.trasen.modules.chunjun.desreport.task;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSONObject;
import com.trasen.modules.chunjun.desreport.service.IReportExportExcel;

import lombok.extern.slf4j.Slf4j;

/**
 * 生成excel任务
 * 
 * @author xxx
 * @date: 2021-11-29 17:04:35
 * @Copyright: Copyright (c) 2006 - 2021
 * @Company: xxx公司
 * @Version: V1.0
 */
@Component
@Slf4j
public class GenerateExcelTask implements ScheduledOfTask {

    @Autowired
    private IReportExportExcel reportExportExcel;
    private int i;

    @Override
    public void execute(String id) {
        // jsonObject.put("excelConfigId", "1414416708285894656");
        // jsonObject.put("queryParam", JSONObject.parseObject("{\"id\":\"1414416708285894656\",\"pageNo\":1}"));
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("taskId", id);
        jsonObject.put("pageNo", 1);
        jsonObject.put("pageSize", 10000);
        reportExportExcel.generateExcelUploadMinIO(jsonObject);
        log.info("thread id:{},DynamicPrintTask execute times:{}", Thread.currentThread().getId(), ++i);
    }
}

实现类说明：

（1）方法名可自定义，一般根据需要实现的功能定义

（2）必须实现自定义定时任务接口：ScheduledOfTask

（3）execute方法中id为定时任务id，如果定时任务需要关联业务数据时使用

（4）IReportExportExcel为业务服务接口类

3.7 项目启动时初始化定时任务

用于初始化以保存于数据库的定时任务，避免手动执行

package com.trasen.modules.chunjun.desreport.task;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

import com.trasen.modules.chunjun.desreport.service.IScheduledTaskService;

import lombok.extern.slf4j.Slf4j;

/**
 * 项目启动时初始化定时任务
 * 
 * @author xxx
 * @date: 2021-12-01 16:22:15
 * @Copyright: Copyright (c) 2006 - 2021
 * @Company: xxx公司
 * @Version: V1.0
 */
@Slf4j
@Component
public class ScheduledTaskRunner implements ApplicationRunner {

    @Autowired
    private IScheduledTaskService scheduledTaskService;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        log.info("----初始化定时任务开始----");
        scheduledTaskService.initTask();
        log.info("----初始化定时任务完成----");
    }
}
CS_草祭先生
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
7.springboot配置定时任务
qq_44959735的博客
07-07 361
在java项目中使用定时任务常用的实现方式有 Timer定时器，Hu tool工具包，Quartz等 ，Quartz是一个完全由　Java 编写的开源作业调度框架，可以用它来实现定时任务。每天的0点、13点、18点、21点都执行一次：0 0 0,13,18,21 * *?每月1号凌晨1点执行一次：0 0 1 1 *?每隔1分钟执行一次：0 */1 * * *?每隔1小时执行一次：0 0 */1 * *?每隔5秒执行一次：*/5 * * * *?每天凌晨1点执行一次：0 0 1 * *?
微服务系列文章 之SpringBoot之定时任务详解
Coder_Boy_的博客
07-15 2337
显然，使用@Scheduled 注解很方便，但缺点是当我们调整了执行周期的时候，需要重启应用才能生效，这多少有些不方便。数据库准备好数据之后，我们编写定时任务，注意这里添加的是TriggerTask，目的是循环读取我们在数据库设置好的执行周期，以及执行相关定时任务的内容。并且，由于开启了多线程，第一个任务的执行时间也不受其本身执行时间的限制，所以需要注意可能会出现重复操作导致数据异常。基于注解@Scheduled默认为单线程，开启多个任务时，任务的执行时机会受上一个任务执行时间的影响。
SpringBoot中的任务管理(异步任务、定时任务、邮件任务)
最新发布
TTruYi的博客
04-26 1118
开发web应用时，多数应用都具备任务调度功能，提高用户体验。名词解释：任务调度：任务调度指的是计算机系统中的一种机制，用于安排和执行特定任务或作业的时间和顺序。这些任务可以是一次性的，也可以是重复性的，如定期执行的任务。
Spring Boot和XXL-Job：高效定时任务管理
todoitbo的博客
10-25 9万+
xxl-job
SpringBoot设置动态定时任务
嘿！晚安 的博客
10-12 880
SpringBoot设置动态定时任务
Springboot +Flowable，服务任务ServiceTask执行的三种方式（一）
weixin_40991408的博客
05-08 1157
Springboot +Flowable，服务任务ServiceTask执行的三种方式（一）
springboot定时任务的动态开启关闭
03-07
Spring Boot提供了Spring Scheduler抽象来实现这样的需求，使得开发者能够方便地管理和控制定时任务。本篇文章将深入探讨如何在Spring Boot中实现定时任务的动态开启和关闭。 首先，我们需要引入Spring Boot的`...
springboot动态配置定时任务(schedule)
06-13
总结来说，Spring Boot通过`@Scheduled`注解提供了强大的定时任务功能，结合`@ConfigurationProperties`和`@RefreshScope`，我们可以轻松实现定时任务的动态配置，使得任务管理更加灵活。这不仅简化了开发流程，也...
SpringBoot实现动态定时任务
04-21
总结来说，Spring Boot提供了强大的定时任务支持，通过`@Scheduled`注解可以方便地定义静态任务，而结合`ThreadPoolTaskScheduler`和自定义服务，我们可以实现动态管理定时任务，包括暂停、恢复、添加和删除等功能。...
SpringBoot定时任务实现Oracle和mysql数据同步
12-21
Spring Boot作为Java领域的一个热门微服务框架，提供了强大的定时任务功能，能够帮助我们实现不同数据库间的数据同步，比如Oracle到MySQL。本篇文章将详细讲解如何利用Spring Boot的定时任务特性，结合Java的相关...
SpringBoot基于数据库的定时任务统一管理的实现
08-25
知识点1：SpringBoot定时任务管理 SpringBoot提供了对定时任务的支持，可以使用@Scheduled注解来标注需要执行的方法，并通过@EnableScheduling注解来启用计划任务。同时，SpringBoot也提供了对 Quartz scheduler的...
Spring定时任务管理
10-21
Spring定时任务的几种实现，欢迎交流！
【SpringBoot基础】Schedule 计划任务 注解实现
Shane_FZ_C的博客
04-08 540
【SpringBoot基础】Schedule 计划任务 注解实现内容概要文件结构环境jar包计划任务服务设置 ScheduleTaskService计划任务配置类TaskScheduleConfig测试类 Main输出结果 内容概要 学习计划任务注解实现，写个Demo方便以后使用 文件结构 环境jar包 jdk： jdk1.8.0_121（32位） pom： <depen...
【SpringBoot】25、SpringBoot中使用Quartz管理定时任务
热门推荐
Asurplus
07-21 21万+
定时任务在系统中用到的地方很多，例如每晚凌晨的数据备份，每小时获取第三方平台的 Token 信息等等，之前我们都是在项目中规定这个定时任务什么时候启动，到时间了便会自己启动，那么我们想要停止这个定时任务的时候，就需要去改动代码，还得启停服务器，这是非常不友好的事情 直至遇见 Quartz，利用图形界面可视化管理定时任务，使得我们对定时任务的管理更加方便，快捷 一、Quartz 简介 Quartz是一个开源的作业调度框架，它完全由Java写成，并设计用于J2SE和J2EE应用中。它提供了巨大的灵 活性而不牺牲
SpringBoot中使用@scheduled定时执行任务需要注意的坑
业精于勤，荒于嬉；行成于思，毁于随
11-27 5万+
要注意什么坑 不绕弯子了，直接说这个坑是啥： SpringBoot使用@scheduled定时执行任务的时候是在一个单线程中，如果有多个任务，其中一个任务执行时间过长，则有可能会导致其他后续任务被阻塞直到该任务执行完成。也就是会造成一些任务无法定时执行的错觉 可以通过如下代码进行测试： @Scheduled(cron = "0/1 * * * * ? ") public void ...
Spring Boot 中使用 Spring Task 实现定时任务
m0_37695902的博客
12-27 614
1. 前言 在日常项目开发中我们经常要使用定时任务。比如在凌晨进行统计结算，开启策划活动等等。今天我们就来看看如何在 Spring Boot 中使用 Spring 内置的定时任务。 2. 开启定时任务 Spring Boot 默认在无任何第三方依赖的情况下使用 spring-context 模块下提供的定时任务工具 Spring Task。我们只需要使用 @EnableSchedu...
定时任务解决方案2,Spring提供的ThreadPoolTaskScheduler
Allchin
06-08 1万+
 主要是使用org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler它是由spring提供的定时任务类 ,特点是可以使用cron表达式,当然,结合ioc和annotation,还是非常好用的.   package cn.test.schedule.spring;import org.springf
springboot 定时任务 定时更新数据库
07-27
- *2* *3* [基于springboot定时任务的后台管理，使用数据库配置定时任务相关信息，修改，关闭定时任务不需重启项目](https://blog.csdn.net/yaoyipeng/article/details/129482305)[target="_blank" data-report-...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值