動態更改Spring定時任務Cron表達式的優雅方案

"Most of you are familiar with the virtues of a programmer. There are three, of course: laziness, impatience, and hubris." - Larry Wall “程式員的美德：懶惰，不耐煩 ...

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

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

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