Spring Boot 实现定时任务动态管理，太爽了！

一、功能说明

SpringBoot的定时任务的加强工具，实现对SpringBoot原生的定时任务进行动态管理,完全兼容原生@Scheduled注解,无需对原本的定时任务进行修改
二、快速使用

具体的功能已经封装成SpringBoot-starter即插即用：

1. <dependency>
2.     <groupId>com.github.guoyixing</groupId>
3.     <artifactId>spring-boot-starter-super-scheduled</artifactId>
4.     <version>0.3.1</version>
5. </dependency>

复制代码

使用方法和源码：

• 码云：https://gitee.com/qiaodaimadewangcai/super-scheduled
  
• github：https://github.com/guoyixing/super-scheduled
  

推荐一个开源免费的 Spring Boot 实战项目：

https://github.com/javastacks/spring-boot-best-practice

三、实现原理

1、动态管理实现

(1) 配置管理介绍

1. @Component("superScheduledConfig")
2. public class SuperScheduledConfig {
3.     /**
4.      * 执行定时任务的线程池
5.      */
6.     private ThreadPoolTaskScheduler taskScheduler;
8.     /**
9.      * 定时任务名称与定时任务回调钩子  的关联关系容器
10.      */
11.     private Map<String, ScheduledFuture> nameToScheduledFuture = new ConcurrentHashMap<>();
13.     /**
14.      * 定时任务名称与定时任务需要执行的逻辑  的关联关系容器
15.      */
16.     private Map<String, Runnable> nameToRunnable = new ConcurrentHashMap<>();
18.     /**
19.      * 定时任务名称与定时任务的源信息  的关联关系容器
20.      */
21.     private Map<String, ScheduledSource> nameToScheduledSource = new ConcurrentHashMap<>();
22. /* 普通的get/sets省略 */
23. }

复制代码

(2) 使用后处理器拦截SpringBoot原本的定时任务

• 实现ApplicationContextAware接口拿到SpringBoot的上下文
  
• 实现BeanPostProcessor接口，将这个类标记为后处理器，后处理器会在每个bean实例化之后执行
  
• 使用@DependsOn注解强制依赖SuperScheduledConfig类，让SpringBoot实例化SuperScheduledPostProcessor类之前先实例化SuperScheduledConfig类
  
• 主要实现逻辑在postProcessAfterInitialization()方法中
  

1. @DependsOn({"superScheduledConfig"})
2. @Component
3. @Order
4. public class SuperScheduledPostProcessor implements BeanPostProcessor, ApplicationContextAware {
5.     protected final Log logger = LogFactory.getLog(getClass());
7.     private ApplicationContext applicationContext;
9.     /**
10.      * 实例化bean之前的操作
11.      * @param bean bean实例
12.      * @param beanName bean的Name
13.      */
14.     @Override
15.     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
16.         return bean;
17.     }
19.     /**
20.      * 实例化bean之后的操作
21.      * @param bean bean实例
22.      * @param beanName bean的Name
23.      */
24.     @Override
25.     public Object postProcessAfterInitialization(Object bean,
26.                                                  String beanName) throws BeansException {
27.         //1.获取配置管理器
28.         SuperScheduledConfig superScheduledConfig = applicationContext.getBean(SuperScheduledConfig.class);
30.         //2.获取当前实例化完成的bean的所有方法
31.         Method[] methods = bean.getClass().getDeclaredMethods();
32.         //循环处理对每个方法逐一处理
33.         if (methods.length > 0) {
34.             for (Method method : methods) {
35.              //3.尝试在该方法上获取@Scheduled注解（SpringBoot的定时任务注解）
36.                 Scheduled annotation = method.getAnnotation(Scheduled.class);
37.                 //如果无法获取到@Scheduled注解，就跳过这个方法
38.                 if (annotation == null) {
39.                     continue;
40.                 }
41.                 //4.创建定时任务的源属性
42.                 //创建定时任务的源属性（用来记录定时任务的配置，初始化的时候记录的是注解上原本的属性）
43.                 ScheduledSource scheduledSource = new ScheduledSource(annotation, method, bean);
44.                 //对注解上获取到源属性中的属性进行检测
45.                 if (!scheduledSource.check()) {
46.                     throw new SuperScheduledException("在" + beanName + "Bean中" + method.getName() + "方法的注解参数错误");
47.                 }
48.                 //生成定时任务的名称（id），使用beanName+“.”+方法名
49.                 String name = beanName + "." + method.getName();
50.                 //将以key-value的形式，将源数据存入配置管理器中，key：定时任务的名称 value：源数据
51.                 superScheduledConfig.addScheduledSource(name, scheduledSource);
52.                 try {
53.                  //5.将原本SpringBoot的定时任务取消掉
54.                     clearOriginalScheduled(annotation);
55.                 } catch (Exception e) {
56.                     throw new SuperScheduledException("在关闭原始方法" + beanName + method.getName() + "时出现错误");
57.                 }
58.             }
59.         }
60.         //最后bean保持原有返回
61.         return bean;
62.     }
64.     /**
65.      * 修改注解原先的属性
66.      * @param annotation 注解实例对象
67.      * @throws Exception
68.      */
69.     private void clearOriginalScheduled(Scheduled annotation) throws Exception {
70.         changeAnnotationValue(annotation, "cron", Scheduled.CRON_DISABLED);
71.         changeAnnotationValue(annotation, "fixedDelay", -1L);
72.         changeAnnotationValue(annotation, "fixedDelayString", "");
73.         changeAnnotationValue(annotation, "fixedRate", -1L);
74.         changeAnnotationValue(annotation, "fixedRateString", "");
75.         changeAnnotationValue(annotation, "initialDelay", -1L);
76.         changeAnnotationValue(annotation, "initialDelayString", "");
77.     }
79.     /**
80.      * 获取SpringBoot的上下文
81.      * @param applicationContext SpringBoot的上下文
82.      */
83.     @Override
84.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
85.         this.applicationContext = applicationContext;
86.     }
87. }

复制代码

(3) 使用ApplicationRunner初始化自定义的定时任务运行器

• 实现ApplicationContextAware接口拿到SpringBoot的上下文
  
• 使用@DependsOn注解强制依赖threadPoolTaskScheduler类
  
• 实现ApplicationRunner接口，在所有bean初始化结束之后，运行自定义逻辑
  
• 主要实现逻辑在run()方法中
  

1. @DependsOn("threadPoolTaskScheduler")
2. @Component
3. public class SuperScheduledApplicationRunner implements ApplicationRunner, ApplicationContextAware {
4.     protected final Log logger = LogFactory.getLog(getClass());
5.     private DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
6.     private ApplicationContext applicationContext;
8. /**
9.      * 定时任务配置管理器
10.      */
11.     @Autowired
12.     private SuperScheduledConfig superScheduledConfig;
13.     /**
14.      * 定时任务执行线程
15.      */
16.     @Autowired
17.     private ThreadPoolTaskScheduler threadPoolTaskScheduler;
19.     @Override
20.     public void run(ApplicationArguments args) {
21.      //1.定时任务配置管理器中缓存  定时任务执行线程
22.         superScheduledConfig.setTaskScheduler(threadPoolTaskScheduler);
23.         //2.获取所有定时任务源数据
24.         Map<String, ScheduledSource> nameToScheduledSource = superScheduledConfig.getNameToScheduledSource();
25.         //逐一处理定时任务
26.         for (String name : nameToScheduledSource.keySet()) {
27.             //3.获取定时任务源数据
28.             ScheduledSource scheduledSource = nameToScheduledSource.get(name);
29.             //4.获取所有增强类
30.             String[] baseStrengthenBeanNames = applicationContext.getBeanNamesForType(BaseStrengthen.class);
31.             //5.创建执行控制器
32.             SuperScheduledRunnable runnable = new SuperScheduledRunnable();
33.             //配置执行控制器
34.             runnable.setMethod(scheduledSource.getMethod());
35.             runnable.setBean(scheduledSource.getBean());
36.             //6.逐一处理增强类（增强器实现原理后面具体分析）
37.             List<Point> points = new ArrayList<>(baseStrengthenBeanNames.length);
38.             for (String baseStrengthenBeanName : baseStrengthenBeanNames) {
39.              //7.将增强器代理成point
40.                 Object baseStrengthenBean = applicationContext.getBean(baseStrengthenBeanName);
41.                 //创建代理
42.                 Point proxy = ProxyUtils.getInstance(Point.class, new RunnableBaseInterceptor(baseStrengthenBean, runnable));
43.                 proxy.setSuperScheduledName(name);
44.                 //8.所有的points连成起来
45.                 points.add(proxy);
46.             }
47.    //将point形成调用链
48.             runnable.setChain(new Chain(points));
49.             //将执行逻辑封装并缓存到定时任务配置管理器中
50.             superScheduledConfig.addRunnable(name, runnable::invoke);
51.             try {
52.              //8.启动定时任务
53.                 ScheduledFuture<?> schedule = ScheduledFutureFactory.create(threadPoolTaskScheduler
54.                         , scheduledSource, runnable::invoke);
55.                 //将线程回调钩子存到任务配置管理器中
56.                 superScheduledConfig.addScheduledFuture(name, schedule);
57.                 logger.info(df.format(LocalDateTime.now()) + "任务" + name + "已经启动...");
59.             } catch (Exception e) {
60.                 throw new SuperScheduledException("任务" + name + "启动失败，错误信息：" + e.getLocalizedMessage());
61.             }
62.         }
63.     }
65.     @Override
66.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
67.         this.applicationContext = applicationContext;
68.     }
69. }

复制代码

(4) 进行动态管理

1. @Component
2. public class SuperScheduledManager {
3.     protected final Log logger = LogFactory.getLog(getClass());
4.     private DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
6.     @Autowired
7.     private SuperScheduledConfig superScheduledConfig;
9.     /**
10.      * 修改Scheduled的执行周期
11.      *
12.      * @param name scheduled的名称
13.      * @param cron cron表达式
14.      */
15.     public void setScheduledCron(String name, String cron) {
16.         //终止原先的任务
17.         cancelScheduled(name);
18.         //创建新的任务
19.         ScheduledSource scheduledSource = superScheduledConfig.getScheduledSource(name);
20.         scheduledSource.clear();
21.         scheduledSource.setCron(cron);
22.         addScheduled(name, scheduledSource);
23.     }
25.     /**
26.      * 修改Scheduled的fixedDelay
27.      *
28.      * @param name       scheduled的名称
29.      * @param fixedDelay 上一次执行完毕时间点之后多长时间再执行
30.      */
31.     public void setScheduledFixedDelay(String name, Long fixedDelay) {
32.         //终止原先的任务
33.         cancelScheduled(name);
34.         //创建新的任务
35.         ScheduledSource scheduledSource = superScheduledConfig.getScheduledSource(name);
36.         scheduledSource.clear();
37.         scheduledSource.setFixedDelay(fixedDelay);
38.         addScheduled(name, scheduledSource);
39.     }
41.     /**
42.      * 修改Scheduled的fixedRate
43.      *
44.      * @param name      scheduled的名称
45.      * @param fixedRate 上一次开始执行之后多长时间再执行
46.      */
47.     public void setScheduledFixedRate(String name, Long fixedRate) {
48.         //终止原先的任务
49.         cancelScheduled(name);
50.         //创建新的任务
51.         ScheduledSource scheduledSource = superScheduledConfig.getScheduledSource(name);
52.         scheduledSource.clear();
53.         scheduledSource.setFixedRate(fixedRate);
54.         addScheduled(name, scheduledSource);
55.     }
57.     /**
58.      * 查询所有启动的Scheduled
59.      */
60.     public List<String> getRunScheduledName() {
61.         Set<String> names = superScheduledConfig.getNameToScheduledFuture().keySet();
62.         return new ArrayList<>(names);
63.     }
65.     /**
66.      * 查询所有的Scheduled
67.      */
68.     public List<String> getAllSuperScheduledName() {
69.         Set<String> names = superScheduledConfig.getNameToRunnable().keySet();
70.         return new ArrayList<>(names);
71.     }
73.     /**
74.      * 终止Scheduled
75.      *
76.      * @param name scheduled的名称
77.      */
78.     public void cancelScheduled(String name) {
79.         ScheduledFuture scheduledFuture = superScheduledConfig.getScheduledFuture(name);
80.         scheduledFuture.cancel(true);
81.         superScheduledConfig.removeScheduledFuture(name);
82.         logger.info(df.format(LocalDateTime.now()) + "任务" + name + "已经终止...");
83.     }
85.     /**
86.      * 启动Scheduled
87.      *
88.      * @param name            scheduled的名称
89.      * @param scheduledSource 定时任务的源信息
90.      */
91.     public void addScheduled(String name, ScheduledSource scheduledSource) {
92.         if (getRunScheduledName().contains(name)) {
93.             throw new SuperScheduledException("定时任务" + name + "已经被启动过了");
94.         }
95.         if (!scheduledSource.check()) {
96.             throw new SuperScheduledException("定时任务" + name + "源数据内容错误");
97.         }
99.         scheduledSource.refreshType();
101.         Runnable runnable = superScheduledConfig.getRunnable(name);
102.         ThreadPoolTaskScheduler taskScheduler = superScheduledConfig.getTaskScheduler();
104.         ScheduledFuture<?> schedule = ScheduledFutureFactory.create(taskScheduler, scheduledSource, runnable);
105.         logger.info(df.format(LocalDateTime.now()) + "任务" + name + "已经启动...");
107.         superScheduledConfig.addScheduledSource(name, scheduledSource);
108.         superScheduledConfig.addScheduledFuture(name, schedule);
109.     }
111.     /**
112.      * 以cron类型启动Scheduled
113.      *
114.      * @param name scheduled的名称
115.      * @param cron cron表达式
116.      */
117.     public void addCronScheduled(String name, String cron) {
118.         ScheduledSource scheduledSource = new ScheduledSource();
119.         scheduledSource.setCron(cron);
121.         addScheduled(name, scheduledSource);
122.     }
124.     /**
125.      * 以fixedDelay类型启动Scheduled
126.      *
127.      * @param name         scheduled的名称
128.      * @param fixedDelay   上一次执行完毕时间点之后多长时间再执行
129.      * @param initialDelay 第一次执行的延迟时间
130.      */
131.     public void addFixedDelayScheduled(String name, Long fixedDelay, Long... initialDelay) {
132.         ScheduledSource scheduledSource = new ScheduledSource();
133.         scheduledSource.setFixedDelay(fixedDelay);
134.         if (initialDelay != null && initialDelay.length == 1) {
135.             scheduledSource.setInitialDelay(initialDelay[0]);
136.         } else if (initialDelay != null && initialDelay.length > 1) {
137.             throw new SuperScheduledException("第一次执行的延迟时间只能传入一个参数");
138.         }
140.         addScheduled(name, scheduledSource);
141.     }
143.     /**
144.      * 以fixedRate类型启动Scheduled
145.      *
146.      * @param name         scheduled的名称
147.      * @param fixedRate    上一次开始执行之后多长时间再执行
148.      * @param initialDelay 第一次执行的延迟时间
149.      */
150.     public void addFixedRateScheduled(String name, Long fixedRate, Long... initialDelay) {
151.         ScheduledSource scheduledSource = new ScheduledSource();
152.         scheduledSource.setFixedRate(fixedRate);
153.         if (initialDelay != null && initialDelay.length == 1) {
154.             scheduledSource.setInitialDelay(initialDelay[0]);
155.         } else if (initialDelay != null && initialDelay.length > 1) {
156.             throw new SuperScheduledException("第一次执行的延迟时间只能传入一个参数");
157.         }
159.         addScheduled(name, scheduledSource);
160.     }
162.     /**
163.      * 手动执行一次任务
164.      *
165.      * @param name scheduled的名称
166.      */
167.     public void runScheduled(String name) {
168.         Runnable runnable = superScheduledConfig.getRunnable(name);
169.         runnable.run();
170.     }
171. }

复制代码

2、增强接口实现

增强器实现的整体思路与SpringAop的思路一致，实现没有Aop复杂
(1) 增强接口

1. @Order(Ordered.HIGHEST_PRECEDENCE)
2. public interface BaseStrengthen {
3.     /**
4.      * 前置强化方法
5.      *
6.      * @param bean   bean实例（或者是被代理的bean）
7.      * @param method 执行的方法对象
8.      * @param args   方法参数
9.      */
10.     void before(Object bean, Method method, Object[] args);
12.     /**
13.      * 后置强化方法
14.      * 出现异常不会执行
15.      * 如果未出现异常，在afterFinally方法之后执行
16.      *
17.      * @param bean   bean实例（或者是被代理的bean）
18.      * @param method 执行的方法对象
19.      * @param args   方法参数
20.      */
21.     void after(Object bean, Method method, Object[] args);
23.     /**
24.      * 异常强化方法
25.      *
26.      * @param bean   bean实例（或者是被代理的bean）
27.      * @param method 执行的方法对象
28.      * @param args   方法参数
29.      */
30.     void exception(Object bean, Method method, Object[] args);
32.     /**
33.      * Finally强化方法，出现异常也会执行
34.      *
35.      * @param bean   bean实例（或者是被代理的bean）
36.      * @param method 执行的方法对象
37.      * @param args   方法参数
38.      */
39.     void afterFinally(Object bean, Method method, Object[] args);
40. }

复制代码

(2) 代理抽象类

1. public abstract class Point {
2.     /**
3.      * 定时任务名
4.      */
5.     private String superScheduledName;
7.     /**
8.      * 抽象的执行方法，使用代理实现
9.      * @param runnable 定时任务执行器
10.      */
11.     public abstract Object invoke(SuperScheduledRunnable runnable);
13.     /* 普通的get/sets省略 */
14. }

复制代码

(3) 调用链类

1. public class Chain {
2.     private List<Point> list;
3.     private int index = -1;
4.     /**
5.      * 索引自增1
6.      */
7.     public int incIndex() {
8.         return ++index;
9.     }
11.     /**
12.      * 索引还原
13.      */
14.     public void resetIndex() {
15.         this.index = -1;
16.     }
17. }

复制代码

(4) cglib动态代理实现
使用cglib代理增强器，将增强器全部代理成调用链节点Point

1. public class RunnableBaseInterceptor implements MethodInterceptor {
2.     /**
3.      * 定时任务执行器
4.      */
5.     private SuperScheduledRunnable runnable;
6.     /**
7.      * 定时任务增强类
8.      */
9.     private BaseStrengthen strengthen;
11.     @Override
12.     public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
13.         Object result;
14.         //如果执行的是invoke()方法
15.         if ("invoke".equals(method.getName())) {
16.          //前置强化方法
17.             strengthen.before(obj, method, args);
18.             try {
19.              //调用执行器中的invoke()方法
20.                 result = runnable.invoke();
21.             } catch (Exception e) {
22.              //异常强化方法
23.                 strengthen.exception(obj, method, args);
24.                 throw new SuperScheduledException(strengthen.getClass() + "中强化执行时发生错误", e);
25.             } finally {
26.              //Finally强化方法，出现异常也会执行
27.                 strengthen.afterFinally(obj, method, args);
28.             }
29.             //后置强化方法
30.             strengthen.after(obj, method, args);
32.         } else {
33.          //直接执行方法
34.             result = methodProxy.invokeSuper(obj, args);
35.         }
36.         return result;
37.     }
39.     public RunnableBaseInterceptor(Object object, SuperScheduledRunnable runnable) {
40.         this.runnable = runnable;
41.         if (BaseStrengthen.class.isAssignableFrom(object.getClass())) {
42.             this.strengthen = (BaseStrengthen) object;
43.         } else {
44.             throw new SuperScheduledException(object.getClass() + "对象不是BaseStrengthen类型");
45.         }
46.     }
48.     public RunnableBaseInterceptor() {
50.     }
51. }

复制代码

(5) 定时任务执行器实现

1. public class SuperScheduledRunnable {
2.     /**
3.      * 原始的方法
4.      */
5.     private Method method;
6.     /**
7.      * 方法所在的bean
8.      */
9.     private Object bean;
10.     /**
11.      * 增强器的调用链
12.      */
13.     private Chain chain;
15.     public Object invoke() {
16.         Object result;
17.         //索引自增1
18.         if (chain.incIndex() == chain.getList().size()) {
19.             //调用链中的增强方法已经全部执行结束
20.             try {
21.                 //调用链索引初始化
22.                 chain.resetIndex();
23.                 //增强器全部执行完毕，执行原本的方法
24.                 result = method.invoke(bean);
25.             } catch (IllegalAccessException | InvocationTargetException e) {
26.                 throw new SuperScheduledException(e.getLocalizedMessage());
27.             }
28.         } else {
29.             //获取被代理后的方法增强器
30.             Point point = chain.getList().get(chain.getIndex());
31.             //执行增强器代理
32.             //增强器代理中，会回调方法执行器，形成调用链，逐一运行调用链中的增强器
33.             result = point.invoke(this);
34.         }
35.         return result;
36.     }
38.     /* 普通的get/sets省略 */
39. }

复制代码

(6) 增强器代理逻辑
com.gyx.superscheduled.core.SuperScheduledApplicationRunner类中的代码片段

1. //创建执行控制器
2. SuperScheduledRunnable runnable = new SuperScheduledRunnable();
3. runnable.setMethod(scheduledSource.getMethod());
4. runnable.setBean(scheduledSource.getBean());
5. //用来存放 增强器的代理对象
6. List<Point> points = new ArrayList<>(baseStrengthenBeanNames.length);
7. //循环所有的增强器的beanName
8. for (String baseStrengthenBeanName : baseStrengthenBeanNames) {
9. //获取增强器的bean对象
10.     Object baseStrengthenBean = applicationContext.getBean(baseStrengthenBeanName);
11.     //将增强器代理成Point节点
12.     Point proxy = ProxyUtils.getInstance(Point.class, new RunnableBaseInterceptor(baseStrengthenBean, runnable));
13.     proxy.setSuperScheduledName(name);
14.     //增强器的代理对象缓存到list中
15.     points.add(proxy);
16. }
17. //将增强器代理实例的集合生成调用链
18. //执行控制器中设置调用链
19. runnable.setChain(new Chain(points));

复制代码

版权声明：本文为CSDN博主「敲代码的旺财」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_34886352/article/details/106494637
近期热文推荐：
1.1,000+ 道 Java面试题及答案整理(2022最新版)
2.劲爆！Java 协程要来了。。。
3.Spring Boot 2.x 教程，太全了！
4.别再写满屏的爆爆爆炸类了，试试装饰器模式，这才是优雅的方式！！
5.《Java开发手册（嵩山版）》最新发布，速速下载！
觉得不错，别忘了随手点赞+转发哦！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！