Spring Scheduler重啓的正確打開方式

背景

定時任務是一個比較常見的功能，在某些情況下，需要重新啓動或者是重設Scheduler Job，但是官方的API上都沒有提供類似restart的方法，那該如何完成此需求呢？

Spring Quartz

Spring Quartz是一整套完整的Cron Job架構，可以完成複雜的任務調度需求，支持任務持久化，事務化，甚至分佈式。如果是基於Spring Quartz做的Scheduler，那麼重啓比較簡單，Task的管理類Scheduler提供了非常多的方法，如scheduleJob，unscheduleJob，rescheduleJob，deleteJob，addJob等，通過這些方法的組合就以達到重啓的目的，參考此回答。

Spring Scheduler

Spring Scheduler相對於Spring Quartz來說更簡單，不需要額外引入Quartz的包，能夠實現簡單的任務調度功能。它內部基於JDK的定時任務線程池ScheduledExecutorService實現，由類ScheduledTaskRegistrar來負責定時任務的註冊，該類定義了一些操作task的方法。類TaskScheduler負責對JDK類ScheduledExecutorService的包裝

Spring創建Schedle有兩種比較常見的方式：

1. 標註@Scheduled註解
2. 實現SchedulingConfigurer接口

實現SchedulingConfigurer接口的方式

SchedulingConfigurer接口只有一個方法，用來做定時任務的定製化。以下是一個簡單例子

@Configuration      
@EnableScheduling   //開啓定時任務
public class DynamicScheduleTask implements SchedulingConfigurer {

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        // 手動配置，添加任務
        taskRegistrar.addTriggerTask(...);
        taskRegistrar.scheduleCronTask(...);
    }
}

用這種方式，因爲可以拿到任務註冊類ScheduledTasksRegistrar，重啓任務也比較簡單。
ScheduledTasksRegistrar提供了getScheduledTasks方法，可以拿到所有註冊上來的任務信息，ScheduledTask包裝了Task的Future信息。只要遍歷這些task，逐個調用cancel方法，即可停止任務。

Set<ScheduledTask> tasks = taskRegistrar.getScheduledTasks();
for (ScheduledTask task : tasks) {
    task.cancel();
}

然後再通過ScheduledTaskRegistrar重新設置任務即可。

標註@Scheduled註解的方式

用註解的方式配置定時任務，這種方法很方便，使用也比較廣泛，只需在任務入口方法上添加一個註解，如

@Configuration
@EnableScheduling
public class ScheduleTask {
    // execute every 10 sec
    @Scheduled(cron = "0/10 * * * * ?")
    private void configureTasks() {
        System.out.println("task executing...");
    }
}

這種方式使用簡單，是因爲Spring屏蔽了很多實現細節。SchedulingConfiguration會創建一個ScheduledAnnotationBeanPostProcessor，在這個BeanPostProcessor裏面會新建一個ScheduledTasksRegistrar，然後自動完成任務的配置。

在這種方案裏面要實現重啓，有一個大困難：無法拿到ScheduledTasksRegistrar：

@Configuration
@Role(2)
public class SchedulingConfiguration {
    @Bean(name = {"org.springframework.context.annotation.internalScheduledAnnotationProcessor"})
    @Role(2)
    public ScheduledAnnotationBeanPostProcessor scheduledAnnotationProcessor() {
        // 創建基於Annotation配置的BeanPostProcessor
        return new ScheduledAnnotationBeanPostProcessor();
    }
}

public class ScheduledAnnotationBeanPostProcessor implements ScheduledTaskHolder, MergedBeanDefinitionPostProcessor, DestructionAwareBeanPostProcessor, Ordered, EmbeddedValueResolverAware, BeanNameAware, BeanFactoryAware, ApplicationContextAware, SmartInitializingSingleton, ApplicationListener<ContextRefreshedEvent>, DisposableBean {
    private final ScheduledTaskRegistrar registrar;
    // 默認的構造方法中，新建類了一個ScheduledTaskRegistrar
    // 然而並沒有將之註冊到Spring Context裏面，所以沒法拿到它
    public ScheduledAnnotationBeanPostProcessor() {
        this.registrar = new ScheduledTaskRegistrar();
    }
}

當然也可以先拿到ScheduledAnnotationBeanPostProcessor，然後通過反射獲取私有屬性registrar，之後做法同上一種方案，這種比較hacker的做法這裏不考慮。那在這種情況下該怎麼重啓呢？

看了一下ScheduledAnnotationBeanPostProcessor的源碼，這個類實現在工程啓動的時候調用ScheduledTasksRegistrar去註冊並啓動定時任務，在工程關閉的時候會關閉並銷燬定時任務：

// 該類初始化之後調用
// 這個Bean變量，一般是標記了@Scheduled的Task類
public Object postProcessAfterInitialization(Object bean, String beanName) {
    if (!(bean instanceof AopInfrastructureBean) && !(bean instanceof TaskScheduler) && !(bean instanceof ScheduledExecutorService)) {
        Class<?> targetClass = AopProxyUtils.ultimateTargetClass(bean);
        // 找到標註了@Scheduled的方法
        Map<Method, Set<Scheduled>> annotatedMethods = MethodIntrospector.selectMethods(targetClass, (method) -> {
            Set<Scheduled> scheduledMethods = AnnotatedElementUtils.getMergedRepeatableAnnotations(method, Scheduled.class, Schedules.class);
            return !scheduledMethods.isEmpty() ? scheduledMethods : null;
        });
        // 遍歷方法，配置定時任務
        annotatedMethods.forEach((method, scheduledMethods) -> {
            scheduledMethods.forEach((scheduled) -> {
                // 真正配置定時任務的地方
                this.processScheduled(scheduled, method, bean);
            });
        });

        return bean;
    } else {
        return bean;
    }
}

// 該類銷燬之前調用
public void postProcessBeforeDestruction(Object bean, String beanName) {
    Set tasks;
    // 將定時任務從Collection中移除
    synchronized(this.scheduledTasks) {
        tasks = (Set)this.scheduledTasks.remove(bean);
    }

    // cancel task
    if (tasks != null) {
        Iterator var4 = tasks.iterator();

        while(var4.hasNext()) {
            ScheduledTask task = (ScheduledTask)var4.next();
            task.cancel();
        }
    }
}

有沒有發現，如果要重啓task，其實只要調用一下這兩個方法就可以了！以下是實現的具體邏輯

public class SchedulerServiceImpl {

    // 得到BeanPostProcessor
    @Autowired
    private ScheduledAnnotationBeanPostProcessor postProcessor;

    public void restartAllTasks() {
        // 拿到所有的task(帶包裝)
        Set<ScheduledTask> tasks = postProcessor.getScheduledTasks();
        Set<Object> rawTasks = new HashSet<>(tasks.size());
        for (ScheduledTask task : tasks) {
            Task t = task.getTask();
            ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) t.getRunnable();
            Object taskObject = runnable.getTarget();
            // 將task所關聯的對象放到Set中(就是帶@Scheduled方法的類)
            rawTasks.add(taskObject);
        }

        // 調用postProcessBeforeDestruction()方法，將task移除並cancel
        for (Object obj : rawTasks) {
            postProcessor.postProcessBeforeDestruction(obj, "scheduledTasks");
        }

        // 調用postProcessAfterInitialization()方法重新schedule task
        for (Object obj : rawTasks) {
            postProcessor.postProcessAfterInitialization(obj, "scheduledTasks");
        }
    }
}

想不到，原以爲最複雜的情況，只需要調用Spring提供的方法就能完成目的。可見Spring設計得多巧妙。