spring boot中实现动态定时任务

最新推荐文章于 2024-08-12 03:12:09 发布

erxiaoouba

最新推荐文章于 2024-08-12 03:12:09 发布

阅读量449

点赞数

本文链接：https://blog.csdn.net/erxiaoouba/article/details/107787349

版权

spring boot 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

在网上找的资料最后整理出来的, 不过找不到原文章地址了, 感谢原作者的奉献

这里总共创建以下几个类:

DynamicCronJob: 动态定时任务, 包含了对定时任务的启动, 停止, 重启. 添加定时任务的功能没有加, 可以自行添加, 参考启动功能
ScheduledTaskConfig: 动态定时任务配置, 这是一个配置类, 配置ThreadPoolTaskScheduler线程池的, 还有就是初始化存放所有动态定时任务的map, 初始化map也就死创建一个map对象, 具体的初始化方法在下面的ScheduledTaskEnum枚举类中. 也可以在使用别的方式初始化, 这里有一个前提, 因为这个是配合数据库执行的, 每次重启项目都会将数据库中正常状态的定时任务取出来添加到执行map中并执行, 所以要在别的地方初始化需要在这之前执行
ScheduledTaskJob: 动态定时任务的实体类, 包含了对应数据库的字段以及要执行的runnable
ScheduledTaskEnum: 动态定时任务枚举, 每一个要执行的定时任务都在这里添加一个枚举类型, 有两个属性, 第一个是定时任务的任务编码, 第二个就是定时任务的runnable, 还包括初始化存放所有动态定时任务的map, 放在这里是因为不需要动态添加定时任务, 放在这里可以在初始化map的时候设定map的容量, 如果需要动态添加定时任务则直接在ScheduledTaskConfig中初始化
ScheduledTaskRunner: 项目启动完毕后需要自启的任务, 主要就是用来执行初始化启动所有有效动态定时任务, 从数据库中获取有效的任务信息, 跟ScheduledTaskConfig中初始化的内容不一样, 这里是初始化执行所有的有效定时任务, 配置类中是初始化存放所有动态定时任务的map的
InsuranceTask: 具体的执行任务类, 这个是自定义的, 按照自己的需求创建类名, 成员属性, 定时任务要执行的方法等, 需要实现runnable接口, 成员属性无法直接注入, 需要将成员属性写成静态属性, 再使用set方法注入

提示: 代码中的ResultVO是一个统一返回对象, 包含code属性, msg属性和data属性, ResultVOUtil是统一返回对象的工具类, success是成功, code为0, msg为成功, 参数为data, error为失败, 需要自定义code和msg, 第一个参数是code, 第二个参数时msg

接下来是代码(未优化过, 功能已实现, 可以正常使用O(∩_∩)O):

DynamicCronJob:

import com.xxx.ScheduledTaskJob;
import com.xxx.ScheduledTaskEnum;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.stereotype.Component;

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

/**
 * 动态定时任务
 */
@Slf4j
@Component
public class DynamicCronJob {

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

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

    // 所有定时任务存放Map
    @Autowired
    private Map<String, ScheduledTaskJob> scheduledTaskJobMap;

    // 存放已经启动的任务map
    private Map<String, ScheduledFuture<?>> scheduledFutureMap = new ConcurrentHashMap<>();

    /**
     * 根据任务编码 启动任务
     *
     * @param tasksCode 任务编码
     * @return
     */
    public ResultVO start(String tasksCode) {
        // 添加锁放一个线程启动，防止多人启动多次
        lock.lock();
        try {
            // 校验是否已经启动
            if (this.isStart(tasksCode)) {
                return ResultVOUtil.error(-1, "当前任务已经启动，无需重复启动!");
            }
            // 校验任务是否存在
            if (!scheduledTaskJobMap.containsKey(tasksCode)) {
                return ResultVOUtil.error(-1, "不存在这个任务, 请先添加!");
            }

            // 启动任务
            this.doStartTask(tasksCode);
        } finally {
            // 释放锁
            lock.unlock();
        }
        return ResultVOUtil.success();
    }

    /**
     * 根据任务编码 停止任务
     *
     * @param tasksCode 任务编码
     * @return
     */
    public ResultVO stop(String tasksCode) {
        // 当前任务实例是否存在
        boolean taskStartFlag = scheduledFutureMap.containsKey(tasksCode);
        if (taskStartFlag) {
            // 获取任务实例
            ScheduledFuture<?> scheduledFuture = scheduledFutureMap.get(tasksCode);
            // 关闭实例
            scheduledFuture.cancel(true);
            log.info("停止任务任务[{}]", tasksCode);
        }
        return ResultVOUtil.success(taskStartFlag);
    }

    /**
     * 根据任务编码 重启任务
     *
     * @param tasksCode 任务编码
     * @return
     */
    public ResultVO restart(String tasksCode) {
        log.info("正在重新启动任务[{}]", tasksCode);
        // 先停止
        this.stop(tasksCode);
        // 再启动
        return this.start(tasksCode);
    }

    /**
     * 初始化启动所有有效动态定时任务
     *
     * @param scheduledTaskJobs 有效动态定时任务
     */
    public void initAllTask(List<ScheduledTaskJob> scheduledTaskJobs) {
        log.info("启动所有有效动态定时任务");
        if (CollectionUtils.isEmpty(scheduledTaskJobs)) {
            return;
        }
        for (ScheduledTaskJob scheduledTaskJob : scheduledTaskJobs) {
            // 任务编码
            String taskCode = scheduledTaskJob.getTasksCode();
            // 设置任务
            scheduledTaskJob.setRunnable(ScheduledTaskEnum.findRunnableByTaskCode(taskCode));
            // 将任务添加到所有任务的map中
            scheduledTaskJobMap.put(taskCode, scheduledTaskJob);
            // 校验是否已经启动
            if (this.isStart(taskCode)) {
                continue;
            }
            // 启动任务
            this.doStartTask(taskCode);
        }
    }

    /********************************************* 私有方法 *****************************************/

    /**
     * 启动任务
     *
     * @param tasksCode 任务编码
     */
    private void doStartTask(String tasksCode) {
        ScheduledTaskJob scheduledTaskJob = scheduledTaskJobMap.get(tasksCode);
        ScheduledFuture<?> scheduledFuture = threadPoolTaskScheduler.schedule(scheduledTaskJob.getRunnable(),
                triggerContext -> new CronTrigger(scheduledTaskJob.getCronExpression()).nextExecutionTime(triggerContext)
        );
        log.info("任务[{}]启动完成, cron表达式为: [{}]", tasksCode, scheduledTaskJob.getCronExpression());
        // 将启动的任务放入map
        scheduledFutureMap.put(tasksCode, scheduledFuture);
    }

    /**
     * 任务是否已经启动
     *
     * @param tasksCode 任务编码
     * @return
     */
    private Boolean isStart(String tasksCode) {
        // 校验是否已经启动
        if (scheduledFutureMap.containsKey(tasksCode) && !scheduledFutureMap.get(tasksCode).isCancelled()) {
            return true;
        }
        return false;
    }
}

ScheduledTaskConfig:

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

import java.util.Map;

/**
 * 动态定时任务配置
 */
@Slf4j
@Configuration
public class ScheduledTaskConfig {

    /**
     * 定时任务线程池
     *
     * @return
     */
    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
        threadPoolTaskScheduler.setPoolSize(20);
        threadPoolTaskScheduler.setThreadNamePrefix("taskExecutor-");
        threadPoolTaskScheduler.setWaitForTasksToCompleteOnShutdown(true);
        threadPoolTaskScheduler.setAwaitTerminationSeconds(60);
        return threadPoolTaskScheduler;
    }

    /**
     * 初始化所有动态定时任务的map
     *
     * @return
     */
    @Bean
    public Map<String, ScheduledTaskJob> scheduledTaskJobMap() {
        return ScheduledTaskEnum.initScheduledTaskMap();
    }
}

ScheduledTaskJob:

import lombok.Data;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Transient;

/**
 * 动态定时任务
 */
@Data
@Entity
public class ScheduledTaskJob {

    public ScheduledTaskJob() {
    }

    public ScheduledTaskJob(Runnable runnable) {
        this.runnable = runnable;
    }

    /**
     * 主键
     */
    @Id
    private Integer id;

    /**
     * 任务编码
     */
    private String tasksCode;

    /**
     * 任务名称
     */
    private String tasksName;

    /**
     * 任务说明
     */
    private String tasksDesc;

    /**
     * cron表达式
     */
    private String cronExpression;

    /**
     * 是否可用: 0 - 否, 1 - 是
     */
    private Integer state;

    /**************************************** 非数据库字段 **************************************/

    @Transient
    private Runnable runnable;
}

ScheduledTaskEnum:

import com.xxx.InsuranceTask;
import com.xxx.ScheduledTaskJob;
import lombok.extern.slf4j.Slf4j;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Stream;

/**
 * 动态定时任务枚举
 * ! key 需要与数据库保持一致
 */
@Slf4j
public enum ScheduledTaskEnum {
    /**
     * 定时任务类型枚举
     */
    INSURANCE("insuranceTask", new InsuranceTask());

    /**
     * 定时任务编码
     */
    private String taskCode;
    /**
     * 定时任务
     */
    private Runnable runnable;

    ScheduledTaskEnum(String taskCode, Runnable runnable) {
        this.taskCode = taskCode;
        this.runnable = runnable;
    }

    public String getTaskCode() {
        return taskCode;
    }

    public void setTaskCode(String taskCode) {
        this.taskCode = taskCode;
    }

    public Runnable getRunnable() {
        return runnable;
    }

    public void setRunnable(Runnable runnable) {
        this.runnable = runnable;
    }

    /**
     * 根据任务编码获取任务
     *
     * @param taskCode 任务编码
     * @return
     */
    public static Runnable findRunnableByTaskCode(String taskCode) {
        return Stream.of(ScheduledTaskEnum.values()).filter(item -> item.getTaskCode().equals(taskCode)).findAny().map(ScheduledTaskEnum::getRunnable).orElse(null);
    }

    /**
     * 初始化所有动态定时任务的map, 放在这里是因为不需要动态添加定时任务, 放在这里可以在初始化map的时候设定map的容量
     *
     * @return
     */
    public static Map<String, ScheduledTaskJob> initScheduledTaskMap() {
        log.info("初始化所有动态定时任务的map");
        return new ConcurrentHashMap<>(ScheduledTaskEnum.values().length);
    }
}

ScheduledTaskRunner:

import com.xxx.DynamicCronJob;
import com.xxx.ScheduledTaskJob;
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.core.annotation.Order;
import org.springframework.stereotype.Component;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.util.List;

/**
 * 项目启动完毕后需要自启的任务, Order注解的执行优先级是按value值从小到大顺序
 */
@Slf4j
@Component
@Order(value = 1)
public class ScheduledTaskRunner implements ApplicationRunner {

    @Autowired
    private DynamicCronJob dynamicCronJob;
    @PersistenceContext
    private EntityManager entityManager;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        List<ScheduledTaskJob> resultList = entityManager.createNativeQuery("select stj.* from scheduled_task_job stj where stj.state = 1", ScheduledTaskJob.class).getResultList();
        entityManager.clear();
        entityManager.close();
        dynamicCronJob.initAllTask(resultList);
    }
}

InsuranceTask:

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 成员变量需要静态化成员变量然后使用set注入
 */
@Slf4j
@Component
public class InsuranceTask implements Runnable {

    private static XXX xxx;
    private static YYY yyy;

    @Override
    public void run() {
        	// 要执行的定时任务
        }
    }

    /************************ set方法, 实现Runnable接口因为安全问题无法直接在成员变量上注入 *************************/

    @Autowired
    public void setXXX(XXX xxx) {
        InsuranceTask.xxx = xxx;
    }

    @Value("${yyy.yy.y}")
    public void setYYY(String yyy) {
        InsuranceTask.yyy = yyy;
    }
}

下面是业务代码:

controller:

   /**
     * 根据任务编码获取cron表达式
     *
     * @param tasksCode 任务编码
     * @return
     */
    @GetMapping("/findCronExpressionByTaskCode")
    public ResultVO findCronExpressionByTaskCode(String tasksCode) {
        List<ScheduledTaskJob> resultList = entityManager.createNativeQuery("select stj.* from scheduled_task_job stj where stj.tasks_code = ?1 and stj.state = 1", ScheduledTaskJob.class).setParameter(1, tasksCode).getResultList();
        entityManager.clear();
        entityManager.close();
        if (resultList.isEmpty()) return ResultVOUtil.error(1, "未获取到有效数据!");
        else return ResultVOUtil.success(resultList.get(0).getCronExpression());
    }

    /**
     * 根据任务编码修改cron表达式
     *
     * @param tasksCode      任务编码
     * @param cronExpression cron表达式
     * @param userCode       用户编码
     * @return
     */
    @PostMapping("/updateCronExpressionByTaskCode")
    public ResultVO updateCronExpressionByTaskCode(String tasksCode, String cronExpression, String userCode) {
        return ResultVOUtil.success(securityMgmtService.updateCronExpressionByTaskCode(tasksCode, cronExpression, userCode));
    }

service: 重置定时任务我是放在service中的, 因为需要修改数据库. 然后在service中注入所有定时任务存放Map和动态定时任务类来获取定时任务信息, 修改定时任务的cron表达式和修改后重启定时任务

    // 所有定时任务存放Map
    @Autowired
    private Map<String, ScheduledTaskJob> scheduledTaskJobMap;
    // 动态定时任务类
    @Autowired
    private DynamicCronJob dynamicCronJob;
    
   /**
     * 根据任务编码修改cron表达式
     *
     * @param taskCode       任务编码
     * @param cronExpression cron表达式
     * @param userCode       用户编码
     * @return
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, timeout = 36000, rollbackFor = Exception.class)
    public Integer updateCronExpressionByTaskCode(String taskCode, String cronExpression, String userCode) {
        int update = entityManager.createNativeQuery("update scheduled_task_job set cron_expression = ?2 where tasks_code = ?1").setParameter(1, taskCode).setParameter(2, cronExpression).executeUpdate();
        entityManager.clear();
        entityManager.close();
        // 换成新的cron表达式再重新启动
        ScheduledTaskJob scheduledTaskJob = scheduledTaskJobMap.get(taskCode);
        // 旧的cron表达式
        String oldCronExpression = scheduledTaskJob.getCronExpression();
        // 重新设定cron表达式
        scheduledTaskJob.setCronExpression(cronExpression);
        dynamicCronJob.restart(taskCode);
        log.info("用户[{}]修改了[xxx]的定时任务, 原cron表达式为: [{}], 修改后cron表达式为: [{}]", userCode, oldCronExpression, cronExpression);
        return update;
    }