SpringBoot 定时任务动态管理通用解决方案

转x33g5p2x  于2022-03-18 转载在 Spring  
字(14.9k)|赞(0)|评价(0)|浏览(629)

一、功能说明

  • 二、快速使用
  • 三、实现原理

一、功能说明

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

推荐下自己做的 Spring Boot 的实战项目：

https://github.com/YunaiV/ruoyi-vue-pro

二、快速使用

具体的功能已经封装成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 Cloud 的实战项目：

https://github.com/YunaiV/onemall

三、实现原理

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;
  7.  
  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);
  12.     
  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.     }
  37.     
  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));
  1. 来源：blog.csdn.net/qq_34886352/
  2.       article/details/106494637
  3. 版权申明：内容来源网络，版权归原创者所有。除非无法确认，我们都会标明作者及出处，如有侵权烦请告知，我们会立即删除并表示歉意。谢谢！

推荐3个原创springboot+Vue项目，有完整视频讲解与文档和源码：

【dailyhub】【实战】带你从0搭建一个Springboot+elasticsearch+canal的完整项目
  • 视频讲解：https://www.bilibili.com/video/BV1Jq4y1w7Bc/
  • 完整开发文档：https://www.zhuawaba.com/post/124
  • 线上演示：https://www.zhuawaba.com/dailyhub
【VueAdmin】手把手教你开发SpringBoot+Jwt+Vue的前后端分离后台管理系统
  • 视频讲解：https://www.bilibili.com/video/BV1af4y1s7Wh/
  • 完整开发文档前端：https://www.zhuawaba.com/post/18
  • 完整开发文档后端：https://www.zhuawaba.com/post/19
  • 线上演示：https://www.markerhub.com/vueadmin/
【VueBlog】基于SpringBoot+Vue开发的前后端分离博客项目完整教学
  • 视频讲解：https://www.bilibili.com/video/BV1PQ4y1P7hZ
  • 完整开发文档：https://www.zhuawaba.com/post/17

关注我，学Java

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/MarkerHub/article/details/123564677

内容来源于网络，如有侵权，请联系作者删除！

Javaspringaopquartz

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com