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

影耀子

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

阅读量2.2k

点赞数 2

文章标签： java

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

本文链接：https://blog.youkuaiyun.com/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();获取到完整类名将数据库中的这条任务信息查询出来，比如需要用到的扩展字段等等    
    
    }
}

然后调用启动接口