基于springboot定时任务的后台管理，使用数据库配置定时任务相关信息，修改，关闭定时任务不需重启项目

影耀子

已于 2023-11-07 13:32:44 修改

阅读量1.9k

点赞数 2

文章标签： java

于 2023-03-12 23:24:19 首次发布

本文链接：https://blog.csdn.net/yaoyipeng/article/details/129482305

版权

首先建立有张定时任务表，我的mysql是8.0.26版本，所以可以存储json字段


CREATE TABLE `config_scheduled` (
  `id` int NOT NULL AUTO_INCREMENT,
  `job_key` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '定时任务完整类名',
  `cron_expression` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT 'cron表达式',
  `task_explain` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '任务描述',
  `status` tinyint NOT NULL DEFAULT '-1' COMMENT '状态,1:正常启用;-1:停用',
  `create_date` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_date` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
  `json` json NOT NULL COMMENT '扩展字段',
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE KEY `scheduled_job_key_IDX` (`job_key`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=16 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci ROW_FORMAT=DYNAMIC COMMENT='管理定时任务表'

首先创建定时任务线程池



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

/**
 *
 * 创建定时任务线程池
 * @author 影耀子
 */
@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;
    }

}

然后项目启动时初始化定时任务



import com.lookvin.admin.config.service.ScheduledTaskService;
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;

/**
 * 项目启动时初始化定时任务
 * @author 影耀子
 */
@Slf4j
@Component
public class ScheduledTaskRunner implements ApplicationRunner {

    @Autowired
    private ScheduledTaskService scheduledTaskService;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        log.info("----初始化定时任务开始----");
        scheduledTaskService.initTask();
        log.info("----初始化定时任务完成----");
    }
}

然后我们新建一个定时任务的公共接口，所有定时任务中的类（也就是表中的job_key字段填写的类名）都必须实现此接口


/**
 * 定时任务公共接口
 * @author 影耀子
 */
public interface ScheduledOfTask extends Runnable{

    void execute();

    @Override
    default void run() {
        execute();
    }
}

创建完数据库，创建对应的ScheduledController，ScheduledService和ScheduledMapper和Scheduled实体类，相关代码我就不发了，控制层将定时任务相关信息修改后记得重启你修改过的定时任务，调用scheduledTaskService.restart(传入此定时任务的实体类信息);即可

ScheduledTaskService接口我就不发了，实现类的代码如下：



import com.lookvin.admin.config.service.IScheduledService;
import com.lookvin.admin.config.service.ScheduledTaskService;
import com.lookvin.admin.config.util.ScheduledOfTask;
import com.lookvin.common.exception.CommonException;
import com.lookvin.common.resPublicEntity.RCode;
import com.lookvin.common.util.spring.SpringContextUtil;
import com.lookvin.admin.config.entity.Scheduled;
import lombok.extern.slf4j.Slf4j;
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.util.Assert;

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

/**
 * @program: ihrm_parent
 * @description
 * @author: 影耀子（YingYew）
 * @create: 2022-05-28 23:37
 **/
@Slf4j
@Service
public class ScheduledTaskServiceImpl implements ScheduledTaskService {
    /**
     * 可重入锁
     */
    private ReentrantLock lock = new ReentrantLock();

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

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

    @Autowired
    private IScheduledService scheduledService;


    @Override
    public void initTask() {
        List<Scheduled> list = scheduledService.list();
        for (Scheduled sj : list) {
            if(sj.getStatus() == -1) {  //未启用
                continue;
            }
            doStartTask(sj);
        }
    }

    @Override
    public Boolean start(Scheduled scheduled) {
        String jobKey = scheduled.getJobKey();
        log.info("启动定时任务"+jobKey);
        //添加锁放一个线程启动，防止多人启动多次
        lock.lock();
        try {
            if(this.isStart(jobKey)){
                log.info("当前任务在启动状态中");
                return false;
            }
            //任务启动
            doStartTask(scheduled);
        } finally {
            lock.unlock();
            log.info("解锁完毕");
        }


        return true;
    }

    @Override
    public Boolean stop(String jobKey) {
        log.info("停止任务 "+jobKey);
        boolean flag = scheduledFutureMap.containsKey(jobKey);
        log.info("当前实例是否存在 "+flag);
        if(flag){
            ScheduledFuture scheduledFuture = scheduledFutureMap.get(jobKey);

            scheduledFuture.cancel(true);

            scheduledFutureMap.remove(jobKey);
        }
        return flag;
    }

    @Override
    public Boolean restart(Scheduled scheduled) {
        log.info("重启定时任务"+scheduled.getJobKey());
        //停止
        this.stop(scheduled.getJobKey());

        return this.start(scheduled);
    }

    @Override
    public void carryOut(Scheduled sj){
        log.info("执行此定时任务代码,不判断定时任务状态,不执行启动，重启等操作"+sj.getJobKey());
        Class<?> clazz;
        ScheduledOfTask task;
        try {
            clazz = Class.forName(sj.getJobKey());
            task = (ScheduledOfTask) SpringContextUtil.getBean(clazz);
            Assert.isAssignable(ScheduledOfTask.class, task.getClass(), "定时任务类必须实现ScheduledOfTask接口");
            task.run();
        } catch (Exception e) {
            throw new CommonException(RCode.SYS_CONFIG_ERROR,"定时任务scheduled_cron表数据" + sj.getJobKey() + "有误");
        }
    }

    /**
     * 任务是否已经启动
     */
    private Boolean isStart(String taskKey) {
        //校验是否已经启动
        if (scheduledFutureMap.containsKey(taskKey)) {
            return !scheduledFutureMap.get(taskKey).isCancelled();
        }
        return false;
    }
    /**
     * 执行启动任务
     */
    public void doStartTask(Scheduled sj){
        log.info(sj.getJobKey());
        if(sj.getStatus() != 1) {
            return;
        }
        Class<?> clazz;
        ScheduledOfTask task;
        try {
            clazz = Class.forName(sj.getJobKey());
            task = (ScheduledOfTask) SpringContextUtil.getBean(clazz);
            Assert.isAssignable(ScheduledOfTask.class, task.getClass(), "定时任务类必须实现ScheduledOfTask接口");
            ScheduledFuture scheduledFuture = threadPoolTaskScheduler.schedule
                    (task,(triggerContext -> new CronTrigger(sj.getCronExpression()).nextExecutionTime(triggerContext)));
            scheduledFutureMap.put(sj.getJobKey(),scheduledFuture);
           
        } catch (Exception e) {
            sj.setStatus(-1);   // 定时任务有误，停止它
            scheduledService.updateById(sj);
            // CommonException这个是我自定义的异常，抛出此异常是用于记录异常日志的
            throw new CommonException(RCode.SYS_CONFIG_ERROR,"定时任务scheduled_cron表数据" + sj.getJobKey() + "有误");
        }
    }
}



import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

/**
 * 获取bean工具类
 * @author 影耀子
 */
@Component
public class SpringContextUtil implements ApplicationContextAware {


    private static ApplicationContext applicationContext = null;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if(SpringContextUtil.applicationContext == null){
            SpringContextUtil.applicationContext  = applicationContext;
        }
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    public static Object getBean(String name){
        return getApplicationContext().getBean(name);
    }

    public static <T> T getBean(Class<T> clazz){
        return getApplicationContext().getBean(clazz);
    }

    public static <T> T getBean(String name,Class<T> clazz){
        return getApplicationContext().getBean(name, clazz);
    }
}

相关定时任务的代码已经都写完了，下面我们新建一个任务测试下吧，这条数据就是我添加的定时任务数据

然后创建此定时任务的实现类，注意创建的类名和包必须和数据库中的job_key字段记录的类名信息一样


package com.lookvin.admin.config.task;

import com.lookvin.admin.config.service.IScheduledService;
import com.lookvin.admin.config.util.ScheduledOfTask;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @program: ihrm_parent
 * @description  定时任务实现类
 * @author: 影耀子（YingYew）
 * @create: 2022-05-28 23:27
 **/
@Component
@Slf4j
public class Test implements ScheduledOfTask {

    @Autowired
    private IScheduledService scheduledService;

    @Override
    public void execute() {
//        log.info("执行任务1 "+ LocalDateTime.now());
        // 下面就可以开始写自己的定时任务的业务逻辑了
        // 可以通过String name = this.getClass().getName();获取到完整类名将数据库中的这条任务信息查询出来，比如需要用到的扩展字段等等    
    
    }
}

然后调用启动接口

这个接口的逻辑就是修改完定时任务状态后将此定时任务重启并且执行了一下定时任务的代码，最后结果运行成功，控制台已经打印出了相关信息了

影耀子

关注

2
点赞
踩
11

收藏

觉得还不错? 一键收藏
3
评论
基于springboot定时任务的后台管理，使用数据库配置定时任务相关信息，修改，关闭定时任务不需重启项目

创建完数据库，创建对应的ScheduledController，ScheduledService和ScheduledMapper和Scheduled实体类，相关代码我就不发了，控制层将定时任务相关信息修改后记得重启你修改过的定时任务，调用scheduledTaskService.restart(传入此定时任务的实体类信息);然后我们新建一个定时任务的公共接口，所有定时任务中的类（也就是表中的job_key字段填写的类名）都必须实现此接口。然后项目启动时初始化定时任务。首先创建定时任务线程池。
复制链接

扫一扫