Spring中Cron表達式的優雅實現方案
在 SpringBoot 項目中，我們可以通過@EnableScheduling注解開啟調度任務支持，并通過@Scheduled注解快速地建立一系列定時任務。
@Scheduled支持下面三種配置執行時間的方式：
- cron(expression)：根據Cron表達式來執行。
- fixedDelay(period)：固定間隔時間執行，無論任務執行長短，兩次任務執行的間隔總是相同的。
- fixedRate(period)：固定頻率執行，從任務啟動之后，總是在固定的時刻執行，如果因為執行時間過長，造成錯過某個時刻的執行（晚點），則任務會被立刻執行。
最常用的應該是第一種方式，基于Cron表達式的執行模式，因其相對來說更加靈活。
可變與不可變
默認情況下，@Scheduled注解標記的定時任務方法在初始化之后，是不會再發生變化的。Spring 在初始化 bean 后，通過后處理器攔截所有帶有@Scheduled注解的方法，并解析相應的的注解參數，放入相應的定時任務列表等待后續統一執行處理。到定時任務真正啟動之前，我們都有機會更改任務的執行周期等參數。
換言之，我們既可以通過application.properties配置文件配合@Value注解的方式指定任務的Cron表達式，亦可以通過CronTrigger從數據庫或者其他任意存儲中間件中加載并注冊定時任務。這是 Spring 提供給我們的可變的部分。
但是我們往往要得更多。能否在定時任務已經在執行過的情況下，去動態更改Cron表達式，甚至禁用某個定時任務呢？很遺憾，默認情況下，這是做不到的，任務一旦被注冊和執行，用于注冊的參數便被固定下來，這是不可變的部分。
創造與毀滅
既然創造之后不可變，那就毀滅之后再重建吧。于是乎，我們的思路便是，在注冊期間保留任務的關鍵信息，并通過另一個定時任務檢查配置是否發生變化，如果有變化，就把“前任”干掉，取而代之。如果沒有變化，就保持原樣。
先對任務做個簡單的抽象，方便統一的識別和管理：
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中，但是為了方便擴展，這里還是將執行與觸發分離了。畢竟除了通過定時任務觸發刷新，還可以在界面上通過按鈕手動觸發刷新，或者通過消息機制回調刷新。這一部分就請大家根據實際業務情況來自由發揮了。
驗證
我們創建一個原型工程和三個簡單的定時任務來驗證下，第一個任務是執行周期固定的任務，假設它的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小結
我們在上文通過定時刷新和重建任務的方式來實現了動態更改Cron表達式的需求，能夠滿足大部分的項目場景，而且沒有引入quartzs等額外的中間件，可以說是十分的輕量和優雅了。
