如何優雅地重啓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來負責定時任務的註冊，類TaskScheduler負責對JDK類ScheduledExecutorService的包裝

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

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

實現SchedulingConfigurer接口的方式

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

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

    [@Override](https://my.oschina.net/u/1162528)
    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設計得多巧妙。