動態更改Spring定時任務Cron運算式的優雅方案-有解無憂

"Most of you are familiar with the virtues of a programmer. There are three, of course: laziness, impatience, and hubris." - Larry Wall

“程式員的美德：懶惰，不耐煩以及老子天下第一，” —— 拉里·沃爾

0x00 大綱

0x00 大綱
0x01 前言
0x02 可變與不可變
0x03 創造與毀滅
0x04 驗證
0x05 小結

0x01 前言

在 SpringBoot 專案中，我們可以通過@EnableScheduling注解開啟調度任務支持，并通過@Scheduled注解快速地建立一系列定時任務，

@Scheduled支持下面三種配置執行時間的方式：

cron(expression)：根據Cron運算式來執行，
fixedDelay(period)：固定間隔時間執行，無論任務執行長短，兩次任務執行的間隔總是相同的，
fixedRate(period)：固定頻率執行，從任務啟動之后，總是在固定的時刻執行，如果因為執行時間過長，造成錯過某個時刻的執行（晚點），則任務會被立刻執行，

最常用的應該是第一種方式，基于Cron運算式的執行模式，因其相對來說更加靈活，

0x02 可變與不可變

默認情況下，@Scheduled注解標記的定時任務方法在初始化之后，是不會再發生變化的，Spring 在初始化 bean 后，通過后處理器攔截所有帶有@Scheduled注解的方法，并決議相應的的注解引數，放入相應的定時任務串列等待后續統一執行處理，到定時任務真正啟動之前，我們都有機會更改任務的執行周期等引數，換言之，我們既可以通過application.properties組態檔配合@Value注解的方式指定任務的Cron運算式，亦可以通過CronTrigger從資料庫或者其他任意存盤中間件中加載并注冊定時任務，這是 Spring 提供給我們的可變的部分，

但是我們往往要得更多，能否在定時任務已經在執行過的情況下，去動態更改Cron運算式，甚至禁用某個定時任務呢？很遺憾，默認情況下，這是做不到的，任務一旦被注冊和執行，用于注冊的引數便被固定下來，這是不可變的部分，

0x03 創造與毀滅

既然創造之后不可變，那就毀滅之后再重建吧，于是乎，我們的思路便是，在注冊期間保留任務的關鍵資訊，并通過另一個定時任務檢查配置是否發生變化，如果有變化，就把“前任”干掉，取而代之，如果沒有變化，就保持原樣，

先對任務做個簡單的抽象，方便統一的識別和管理：

public interface IPollableService {
    /**
     * 執行方法
     */
    void poll();

    /**
     * 獲取周期運算式
     *
     * @return CronExpression
     */
    default String getCronExpression() {
        return null;
    }

    /**
     * 獲取任務名稱
     *
     * @return 任務名稱
     */
    default String getTaskName() {
        return this.getClass().getSimpleName();
    }
}

最重要的便是getCronExpression()方法，每個定時服務實作可以自己控制自己的運算式，變與不變，自己說了算，至于從何處獲取，怎么獲取，請諸君自行發揮了，接下來，就是實作任務的動態注冊：

@Configuration
@EnableAsync
@EnableScheduling
public class SchedulingConfiguration implements SchedulingConfigurer, ApplicationContextAware {
    private static final Logger log = LoggerFactory.getLogger(SchedulingConfiguration.class);
    private static ApplicationContext appCtx;
    private final ConcurrentMap<String, ScheduledTask> scheduledTaskHolder = new ConcurrentHashMap<>(16);
    private final ConcurrentMap<String, String> cronExpressionHolder = new ConcurrentHashMap<>(16);
    private ScheduledTaskRegistrar taskRegistrar;

    public static synchronized void setAppCtx(ApplicationContext appCtx) {
        SchedulingConfiguration.appCtx = appCtx;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        setAppCtx(applicationContext);
    }

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        this.taskRegistrar = taskRegistrar;
    }

    /**
     * 重繪定時任務運算式
     */
    public void refresh() {
        Map<String, IPollableService> beanMap = appCtx.getBeansOfType(IPollableService.class);
        if (beanMap.isEmpty() || taskRegistrar == null) {
            return;
        }
        beanMap.forEach((beanName, task) -> {
            String expression = task.getCronExpression();
            String taskName = task.getTaskName();
            if (null == expression) {
                log.warn("定時任務[{}]的任務運算式未配置或配置錯誤，請檢查配置", taskName);
                return;
            }
            // 如果策略執行時間發生了變化，則取消當前策略的任務，并重新注冊任務
            boolean unmodified = scheduledTaskHolder.containsKey(beanName) && cronExpressionHolder.get(beanName).equals(expression);
            if (unmodified) {
                log.info("定時任務[{}]的任務運算式未發生變化，無需重繪", taskName);
                return;
            }
            Optional.ofNullable(scheduledTaskHolder.remove(beanName)).ifPresent(existTask -> {
                existTask.cancel();
                cronExpressionHolder.remove(beanName);
            });
            if (ScheduledTaskRegistrar.CRON_DISABLED.equals(expression)) {
                log.warn("定時任務[{}]的任務運算式配置為禁用，將被不會被調度執行", taskName);
                return;
            }
            CronTask cronTask = new CronTask(task::poll, expression);
            ScheduledTask scheduledTask = taskRegistrar.scheduleCronTask(cronTask);
            if (scheduledTask != null) {
                log.info("定時任務[{}]已加載，當前任務運算式為[{}]", taskName, expression);
                scheduledTaskHolder.put(beanName, scheduledTask);
                cronExpressionHolder.put(beanName, expression);
            }
        });
    }
}

重點是保存ScheduledTask物件的參考，它是控制任務啟停的關鍵，而運算式“-”則作為一個特殊的標記，用于禁用某個定時任務，當然，禁用后的任務通過重新賦予新的 Cron 運算式，是可以“復活”的，完成了上面這些，我們還需要一個定時任務來動態監控和重繪定時任務配置：

@Component
public class CronTaskLoader implements ApplicationRunner {
    private static final Logger log = LoggerFactory.getLogger(CronTaskLoader.class);
    private final SchedulingConfiguration schedulingConfiguration;
    private final AtomicBoolean appStarted = new AtomicBoolean(false);
    private final AtomicBoolean initializing = new AtomicBoolean(false);

    public CronTaskLoader(SchedulingConfiguration schedulingConfiguration) {
        this.schedulingConfiguration = schedulingConfiguration;
    }

    /**
     * 定時任務配置重繪
     */
    @Scheduled(fixedDelay = 5000)
    public void cronTaskConfigRefresh() {
        if (appStarted.get() && initializing.compareAndSet(false, true)) {
            log.info("定時調度任務動態加載開始>>>>>>");
            try {
                schedulingConfiguration.refresh();
            } finally {
                initializing.set(false);
            }
            log.info("定時調度任務動態加載結束<<<<<<");
        }
    }

    @Override
    public void run(ApplicationArguments args) {
        if (appStarted.compareAndSet(false, true)) {
            cronTaskConfigRefresh();
        }
    }
}

當然，也可以把這部分代碼直接整合到SchedulingConfiguration中，但是為了方便擴展，這里還是將執行與觸發分離了，畢竟除了通過定時任務觸發重繪，還可以在界面上通過按鈕手動觸發重繪，或者通過訊息機制回呼重繪，這一部分就請大家根據實際業務情況來自由發揮了，

0x04 驗證

我們創建一個原型工程和三個簡單的定時任務來驗證下，第一個任務是執行周期固定的任務，假設它的Cron運算式永遠不會發生變化，像這樣：

@Service
public class CronTaskBar implements IPollableService {
    @Override
    public void poll() {
        System.out.println("Say Bar");
    }

    @Override
    public String getCronExpression() {
        return "0/1 * * * * ?";
    }
}

第二個任務是一個經常更換執行周期的任務，我們用一個亂數發生器來模擬它的善變：

@Service
public class CronTaskFoo implements IPollableService {
    private static final Random random = new SecureRandom();

    @Override
    public void poll() {
        System.out.println("Say Foo");
    }

    @Override
    public String getCronExpression() {
        return "0/" + (random.nextInt(9) + 1) + " * * * * ?";
    }
}

第三個任務就厲害了，它仿佛就像一個電燈的開關，在啟用和禁用中反復橫跳：

@Service
public class CronTaskUnavailable implements IPollableService {
    private String cronExpression = "-";
    private static final Map<String, String> map = new HashMap<>();

    static {
        map.put("-", "0/1 * * * * ?");
        map.put("0/1 * * * * ?", "-");
    }

    @Override
    public void poll() {
        System.out.println("Say Unavailable");
    }

    @Override
    public String getCronExpression() {
        return (cronExpression = map.get(cronExpression));
    }
}

如果上面的步驟都做對了，日志里應該能看到類似這樣的輸出：

定時調度任務動態加載開始>>>>>>
定時任務[CronTaskBar]的任務運算式未發生變化，無需重繪
定時任務[CronTaskFoo]已加載，當前任務運算式為[0/6 * * * * ?]
定時任務[CronTaskUnavailable]的任務運算式配置為禁用，將被不會被調度執行
定時調度任務動態加載結束<<<<<<
Say Bar
Say Bar
Say Foo
Say Bar
Say Bar
Say Bar
定時調度任務動態加載開始>>>>>>
定時任務[CronTaskBar]的任務運算式未發生變化，無需重繪
定時任務[CronTaskFoo]已加載，當前任務運算式為[0/3 * * * * ?]
定時任務[CronTaskUnavailable]已加載，當前任務運算式為[0/1 * * * * ?]
定時調度任務動態加載結束<<<<<<
Say Unavailable
Say Bar
Say Unavailable
Say Bar
Say Foo
Say Unavailable
Say Bar
Say Unavailable
Say Bar
Say Unavailable
Say Bar

0x05 小結

我們在上文通過定時重繪和重建任務的方式來實作了動態更改Cron運算式的需求，能夠滿足大部分的專案場景，而且沒有引入quartzs等額外的中間件，可以說是十分的輕量和優雅了，當然，如果各位看官有更好的方法，還請不吝賜教，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/540440.html

標籤：Java

上一篇：openssl jni nginx證書私鑰有效性校驗

下一篇：day07-功能實作06