如何优雅地重启Spring Scheduler

时间 2020-01-02

原文原文链接

定时任务是一个比较常见的功能，在某些状况下，须要从新启动或者是重设Scheduler Job，可是官方的API上都没有提供相似restart的方法，那该如何完成此需求呢？html

Spring Quartz

Spring Quartz是一整套完整的Cron Job架构，能够完成复杂的任务调度需求，支持任务持久化，事务化，甚至分布式。若是是基于Spring Quartz作的Scheduler，那么重启比较简单，Task的管理类Scheduler提供了很是多的方法，如scheduleJob，unscheduleJob，rescheduleJob，deleteJob，addJob等，经过这些方法的组合就以达到重启的目的，参考此回答。java

Spring Scheduler

Spring Scheduler相对于Spring Quartz来讲更简单，不须要额外引入Quartz的包，可以实现简单的任务调度功能。它内部基于JDK的定时任务线程池ScheduledExecutorService实现，由类ScheduledTaskRegistrar来负责定时任务的注册，类TaskScheduler负责对JDK类ScheduledExecutorService的包装 spring

Spring建立Schedle有两种比较常见的方式：架构

标注**@Scheduled**注解

实现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方法，便可中止任务。ide

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

而后再经过ScheduledTaskRegistrar从新设置任务便可。post

标注@Scheduled注解的方式

用注解的方式配置定时任务，这种方法很方便，使用也比较普遍，只需在任务入口方法上添加一个注解，如this

@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，而后自动完成任务的配置。.net

在这种方案里面要实现重启，有一个大困难：没法拿到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设计得多巧妙。