基于Spring實現(xiàn)零重啟自由編排任務的定時管理器

更新時間：2023年07月25日 14:03:46 作者：我是小趴菜

我們發(fā)現(xiàn)，我們使用Spring自帶的定時任務如果要有修改，那么就要修改代碼，然后重啟項目，所以本文就帶大家實現(xiàn)一個零重啟自由編排任務的定時管理器吧

實現(xiàn)

創(chuàng)建一個普通的SpringBoot項目，首先我們需要一個配置類，來配置定時任務的線程池

package com.coco.schedule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
@Configuration
public class ScheduleConfig {
    @Bean
    public ThreadPoolTaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
        //定制化我們的線程池
        taskScheduler.setPoolSize(1);        
        taskScheduler.setThreadNamePrefix("myTask-");
        return taskScheduler;
    }
}

創(chuàng)建一個接口，以供其它服務調(diào)用

/**
 * 定時任務的任務接口，需要實現(xiàn)Runnable接口
 */
public interface ScheduleTask extends Runnable {
    /**
     * 獲取定時任務的名稱
     */
    String getTaskName();
}

接下來就是定時任務的編排核心處理類

package com.coco.schedule;
import cn.hutool.core.util.StrUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledFuture;
/**
 * 定時任務管理器
 */
@Component
public class ScheduleManager {
    private static final Logger LOGGER = LoggerFactory.getLogger(ScheduleManager.class);
    @Resource
    private ThreadPoolTaskScheduler taskScheduler;
    /**
     * 內(nèi)部正在執(zhí)行的定時任務緩存
     */
    private Map<String,ScheduleTaskHolder> cache = new ConcurrentHashMap<>();
    /**
     * 啟動一個定時任務
     * scheduleTask：定時任務實現(xiàn)類
     * cron：cron表達式
     */
    public String startTask(ScheduleTask scheduleTask,String cron) {
        ScheduledFuture<?> scheduledFuture = taskScheduler.schedule(scheduleTask, new CronTrigger(cron));
        //使用UUID生成定時任務的唯一key
        String key = UUID.randomUUID().toString();
        //將定時任務與定時任務結果封裝成ScheduleTaskHolder對象，
        //這個對象下文有源碼，也是我們自定義的
        ScheduleTaskHolder scheduleTaskHolder = new ScheduleTaskHolder(scheduleTask,scheduledFuture);
        //將正在執(zhí)行的定時任務緩存起來
        cache.put(key,scheduleTaskHolder);
        LOGGER.info("定時任務啟動成功，key = {}",key);
        return key;
    }
    /**
     * 停止一個定時任務
     * @param key：緩存里面的定時任務的key
     */
    public void stopTask(String key) {
        //基本判斷
        if(StrUtil.isBlank(key) || !cache.containsKey(key)) {
            return;
        }
        //從緩存中拿到這個定時任務
        ScheduleTaskHolder scheduleTaskHolder = cache.get(key);
        if(scheduleTaskHolder == null) {
            return;
        }
        ScheduledFuture scheduledFuture = scheduleTaskHolder.getScheduledFuture();
        //停止這個定時任務
        boolean isCancel = scheduledFuture.cancel(true);
        if(isCancel) {
            //停止成功，就從緩存中移除這個定時任務
            cache.remove(key);
            LOGGER.info("定時任務停止成功,key = {}",key);
        }else {
            LOGGER.error("定時任務停止失敗,key = {}",key);
        }
    }
    /**
     * 停止一個定時任務
     * @param key：緩存里面的定時任務的key
     * @param cron：新的cron表達式
     */
    public String changeTask(String key,String cron) {
        //基本判空處理
        if(StrUtil.isBlank(key) || StrUtil.isBlank(cron)) {
            throw new RuntimeException("key and cron mast not null");
        }
        ScheduleTaskHolder scheduleTaskHolder = cache.get(key);
        if(scheduleTaskHolder == null) {
            throw new RuntimeException("ScheduleTaskHolder not exist,key = {}" + key);
        }
        //先停止這個定時任務
        stopTask(key);
        //然后重啟開啟一個定時任務
        return startTask(scheduleTaskHolder.getScheduleTask(),cron);
    }
}

定時任務與定時任務結果的緩存封裝類

package com.coco.schedule;
import cn.hutool.core.util.StrUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledFuture;
/**
 * 定時任務管理器
 */
@Component
public class ScheduleManager {
    private static final Logger LOGGER = LoggerFactory.getLogger(ScheduleManager.class);
    @Resource
    private ThreadPoolTaskScheduler taskScheduler;
    /**
     * 內(nèi)部正在執(zhí)行的定時任務緩存
     */
    private Map<String,ScheduleTaskHolder> cache = new ConcurrentHashMap<>();
    /**
     * 啟動一個定時任務
     * scheduleTask：定時任務實現(xiàn)類
     * cron：cron表達式
     */
    public String startTask(ScheduleTask scheduleTask,String cron) {
        ScheduledFuture<?> scheduledFuture = taskScheduler.schedule(scheduleTask, new CronTrigger(cron));
        //使用UUID生成定時任務的唯一key
        String key = UUID.randomUUID().toString();
        //將定時任務與定時任務結果封裝成ScheduleTaskHolder對象，
        //這個對象下文有源碼，也是我們自定義的
        ScheduleTaskHolder scheduleTaskHolder = new ScheduleTaskHolder(scheduleTask,scheduledFuture);
        //將正在執(zhí)行的定時任務緩存起來
        cache.put(key,scheduleTaskHolder);
        LOGGER.info("定時任務啟動成功，key = {}",key);
        return key;
    }
    /**
     * 停止一個定時任務
     * @param key：緩存里面的定時任務的key
     */
    public void stopTask(String key) {
        //基本判斷
        if(StrUtil.isBlank(key) || !cache.containsKey(key)) {
            return;
        }
        //從緩存中拿到這個定時任務
        ScheduleTaskHolder scheduleTaskHolder = cache.get(key);
        if(scheduleTaskHolder == null) {
            return;
        }
        ScheduledFuture scheduledFuture = scheduleTaskHolder.getScheduledFuture();
        //停止這個定時任務
        boolean isCancel = scheduledFuture.cancel(true);
        if(isCancel) {
            //停止成功，就從緩存中移除這個定時任務
            cache.remove(key);
            LOGGER.info("定時任務停止成功,key = {}",key);
        }else {
            LOGGER.error("定時任務停止失敗,key = {}",key);
        }
    }
    /**
     * 停止一個定時任務
     * @param key：緩存里面的定時任務的key
     * @param cron：新的cron表達式
     */
    public String changeTask(String key,String cron) {
        //基本判空處理
        if(StrUtil.isBlank(key) || StrUtil.isBlank(cron)) {
            throw new RuntimeException("key and cron mast not null");
        }
        ScheduleTaskHolder scheduleTaskHolder = cache.get(key);
        if(scheduleTaskHolder == null) {
            throw new RuntimeException("ScheduleTaskHolder not exist,key = {}" + key);
        }
        //先停止這個定時任務
        stopTask(key);
        //然后重啟開啟一個定時任務
        return startTask(scheduleTaskHolder.getScheduleTask(),cron);
    }
}

測試

寫好的程序怎么能不測試，首先我們需要創(chuàng)建一個自己的定時任務執(zhí)行的業(yè)務處理類，我這里創(chuàng)建了個MyTask.class

package com.coco.schedule;
import org.springframework.stereotype.Component;
//需要實現(xiàn)ScheduleTask接口
@Component
public class MyTask implements ScheduleTask {
    @Override
    public String getTaskName() {
        return "MyTask";
    }
    @Override
    public void run() {
        //在這里就是我們定時任務的業(yè)務邏輯
        System.out.println("這是自定義的定時起任務");
    }
}

為了簡單，我直接在啟動類中編寫接口了,大家別跟我一樣這么懶哈

package com.coco;
import com.coco.schedule.MyTask;
import com.coco.schedule.ScheduleManager;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
@RestController
@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class,args);
    }
    @Resource
    private ScheduleManager scheduleManager;
    @Resource
    private MyTask myTask;
    //啟動我們的定時任務
    @GetMapping("/startTask")
    public String startTask() {
        String key = scheduleManager.startTask(myTask, "0/10 * * * * ? ");
        return key;
    }
    //修改我們的定時任務
    @GetMapping("/changeTask")
    public String changeTask(@RequestParam("key") String key) {
        String keyValue = scheduleManager.changeTask(key, "0/20 * * * * ? ");
        return keyValue;
    }
    //停止我們的定時任務
    @GetMapping("/stopTask")
    public String stopTask(@RequestParam("key") String key) {
        scheduleManager.stopTask(key);
        return "ok";
    }
}

可以先啟動，然后修改，最后停止