springboot动态定时器开发

最新推荐文章于 2024-08-12 03:12:09 发布
最新推荐文章于 2024-08-12 03:12:09 发布
阅读量2.1k 收藏 2
点赞数 1
文章标签： spring boot spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40496191/article/details/124511731
版权

文章目录

一、背景

需要实现springboot定时调用项目类和第三方接口，并且可以通过页面进行动态配置。这里只展示后台部分，因为前台都是表单，不做展示，核心功能都在后台。代码中存在相关的冗余参数，主要是为相关业务的拓展保留参数。

二、后台功能代码展示

原理：创建map集合，将在spring容器实例化的定时器记录下来。每次新增定时器，一方面存数据库（没做，自行实现），另一方面存在集合中。删除同理。

1. 反射实现方法工具类

package serve.peam.schedule.reflect;

/**
 * spring容器的相关方法，如根据名称获取spring实例
 *
 * @author 天真热
 * @create 2022-04-28 9:55
 * @desc
 **/

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class SpringContextUtils implements ApplicationContextAware {
    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringContextUtils.applicationContext = applicationContext;
    }

    public static Object getBean(String name) {
        return applicationContext.getBean(name);
    }

    public static <T> T getBean(Class<T> requiredType) {
        return applicationContext.getBean(requiredType);
    }

    public static <T> T getBean(String name, Class<T> requiredType) {
        return applicationContext.getBean(name, requiredType);
    }

    public static boolean containsBean(String name) {
        return applicationContext.containsBean(name);
    }

    public static boolean isSingleton(String name) {
        return applicationContext.isSingleton(name);
    }

    public static Class<? extends Object> getType(String name) {
        return applicationContext.getType(name);
    }
}


package serve.peam.schedule.reflect;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.ReflectionUtils;

import java.lang.reflect.Method;
import java.util.Date;

/**
 * 线程类，主要是实现反射方法
 *
 * @author 天真热
 * @create 2022-04-28 9:52
 * @desc
 **/
public class ScheduleClassReflect implements Runnable {
    private static final Logger logger = LoggerFactory.getLogger(ScheduleClassReflect.class);
    /**
     * 实例化到spring容器的实例名，一般是类名首字母小写
     */
    private String beanName;
    /**
     * 方法名
     */
    private String methodName;
    /**
     * 定时规则
     */
    private Long taskId;
    /**
     * 参数，预留
     */
    private String params;


    public ScheduleClassReflect(String beanName, String methodName, Long taskId) {
        this(beanName, methodName, taskId, null);
    }

    public ScheduleClassReflect(String beanName, String methodName, Long taskId, String params) {
        this.beanName = beanName;
        this.methodName = methodName;
        this.taskId = taskId;
        this.params = params;
    }

    /**
     * 利用反射实现方法
     */
    @Override
    public void run() {
        logger.info("定时任务开始执行 - bean：{}，方法：{}，参数：{}", beanName, methodName, params);
        long startTime = System.currentTimeMillis();

        try {
            //从spring容器获取实例
            Object target = SpringContextUtils.getBean(beanName);
            Method method = null;
            //获取方法
            if (StringUtils.isNotEmpty(params)) {
                method = target.getClass().getDeclaredMethod(methodName, String.class);
            } else {
                method = target.getClass().getDeclaredMethod(methodName);
            }
            //反射实现方法
            ReflectionUtils.makeAccessible(method);
            if (StringUtils.isNotEmpty(params)) {
                method.invoke(target, params);
            } else {
                method.invoke(target);
            }


        } catch (Exception ex) {

            logger.error(String.format("定时任务执行异常 - bean：%s，方法：%s，参数：%s ", beanName, methodName, params), ex);
        }
        long times = System.currentTimeMillis() - startTime;
        logger.info("定时任务执行结束 - bean：{}，方法：{}，参数：{}，耗时：{} 毫秒", beanName, methodName, params, times);
    }

}

2. 远程调用接口工具类

package serve.peam.schedule.request;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Date;

/**
 * 线程类，主要是实现反射方法
 *
 * @author 天真热
 * @create 2022-04-28 9:52
 * @desc
 **/
public class ScheduleRequest implements Runnable {
    private static final Logger logger = LoggerFactory.getLogger(ScheduleRequest.class);
    /**
     * 接口
     */
    private String requestInterface;
    /**
     * 接口类型，POST/GET
     */
    String requestType;
    /**
     * 定时规则
     */
    private Long taskId;
    /**
     * 参数，预留
     */
    private String params;

    public ScheduleRequest(String requestInterface, String requestType, Long taskId) {
        this(requestInterface, requestType, taskId, null);
    }

    public ScheduleRequest(String requestInterface, String requestType, Long taskId, String params) {
        this.requestInterface = requestInterface;
        this.requestType = requestType;
        this.params = params;
        this.taskId = taskId;
    }

    /**
     * 利用反射实现方法
     */
    @Override
    public void run() {
        logger.info("定时任务开始执行 - 接口：{}，接口类型：{}，参数：{}", requestInterface, requestType, params);
        long startTime = System.currentTimeMillis();
        try {
            //远程调用接口逻辑
            ScheduleHttpRequest.request(requestInterface, requestType, requestType);

        } catch (Exception ex) {
            logger.error(String.format("定时任务执行异常 - 接口：%s，接口类型：%s，参数：%s ", requestInterface, requestType, params), ex);
        }
        long times = System.currentTimeMillis() - startTime;
        logger.info("定时任务执行结束 - 接口：{}，接口类型：{}，参数：{}，耗时：{} 毫秒", requestInterface, requestType, params, times);
    }

}


package serve.peam.schedule.request;

import java.io.*;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

/**
 * 请求接口
 *
 * @author 天真热
 * @create 2022-04-28 10:11
 * @desc
 */
public class ScheduleHttpRequest {

    /**
     * 请求接口
     *
     * @param httpUrl     地址
     * @param requestType 请求方式
     * @param param       参数
     * @return
     */
    public static Boolean request(String httpUrl, String requestType, String param) {
        boolean isSuccess = false;
        HttpURLConnection connection = null;
        InputStream is = null;
        OutputStream os = null;
        BufferedReader br = null;
        String result = null;
        try {
            URL url = new URL(httpUrl);
            // 通过远程url连接对象打开连接
            connection = (HttpURLConnection) url.openConnection();
            // 设置连接请求方式
            connection.setRequestMethod(requestType);
            // 设置连接主机服务器超时时间：15000毫秒
            connection.setConnectTimeout(15000);
            // 设置读取主机服务器返回数据超时时间：60000毫秒
            connection.setReadTimeout(60000);

            // 默认值为：false，当向远程服务器传送数据/写数据时，需要设置为true
            connection.setDoOutput(true);
            // 默认值为：true，当前向远程服务读取数据时，设置为true，该参数可有可无
            connection.setDoInput(true);

            connection.setRequestProperty("Content-Type", "application/x-www-formurlencoded");
            connection.setRequestProperty("Accept", "application/json;charset=UTF-8");
            // 通过连接对象获取一个输出流
            os = connection.getOutputStream();
            // 通过输出流对象将参数写出去/传输出去,它是通过字节数组写出的
            os.write(param.getBytes());
            // 通过连接对象获取一个输入流，向远程读取
            int code = connection.getResponseCode();
            if (connection.getResponseCode() == 200) {

                is = connection.getInputStream();
                // 对输入流对象进行包装:charset根据工作项目组的要求来设置
                br = new BufferedReader(new InputStreamReader(is, "UTF-8"));

                StringBuffer sbf = new StringBuffer();
                String temp = null;
                // 循环遍历一行一行读取数据
                while ((temp = br.readLine()) != null) {
                    sbf.append(temp);
                    sbf.append("\r\n");
                }
                result = sbf.toString();
            }
            isSuccess = true;
        } catch (MalformedURLException e) {
            isSuccess = false;
            e.printStackTrace();
        } catch (IOException e) {
            isSuccess = false;
            e.printStackTrace();
        } finally {
            // 关闭资源
            if (null != br) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != os) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != is) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            // 断开与远程地址url的连接
            connection.disconnect();
        }
        return isSuccess;
    }


}

3. 定时器线程池配置

package serve.peam.schedule;

import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;

/**
 * 开启线程池
 *
 * @author 天真热
 * @create 2022-04-28 10:11
 * @desc
 **/
public class SchedulingThreadPoolConfig {
    @Bean
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler(); // 定时任务执行线程池核心线程数
        taskScheduler.setPoolSize(10);
        taskScheduler.setRemoveOnCancelPolicy(true);
        taskScheduler.setThreadNamePrefix("TaskSchedulerThreadPool-");
        return taskScheduler;
    }
}

4. 定时器实体类

package serve.peam.schedule;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/**
 * 定时器管理对象 schedule_task
 *
 * @author 天真热
 * @create 2022-04-28 10:11
 * @desc
 */
@Data
public class ScheduleTask implements Serializable {
    private static final long serialVersionUID = 1L;

    private Long id;

    /**
     * 任务名称
     */
    private String taskName;

    /**
     * 任务状态
     */
    private String taskStatus;

    /**
     * 任务类型(接口调用/类调用)
     */
    private String taskType;

    /**
     * 定时器表达式
     */
    private String cronExpression;

    /**
     * 接口
     */
    private String cronInterface;

    /**
     * 接口类型，GET/POST
     */
    private String cronInterfaceType;

    /**
     * service类
     */
    private String cronServiceName;

    /**
     * service方法
     */
    private String cronServiceMethod;


}

5. 定时实际工作类

package serve.peam.schedule;

import java.util.concurrent.ScheduledFuture;

/**
 * 定时器实际工作类
 *
 * @author 天真热
 * @create 2022-04-28 9:43
 * @desc
 **/
public class ScheduledRealTask {
    volatile ScheduledFuture<?> future;

    /**
     * 取消定时任务
     */
    public void cancel() {
        ScheduledFuture<?> future = this.future;
        if (future != null) {
            future.cancel(true);
        }
    }
}

6. 定时器api类

package serve.peam.schedule;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.config.CronTask;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 定时器新增、删除Api
 *
 * @author 天真热
 * @create 2022-04-28 10:11
 * @desc
 */
@Component
public class ScheduleApi implements DisposableBean {
    //线程、定时器任务
    private Map<Long, Map<String, Object>> taskMaps = new ConcurrentHashMap<>(16);

    //定时器实现类
    @Autowired
    private TaskScheduler taskScheduler;

    public TaskScheduler getScheduler() {
        return this.taskScheduler;
    }

    /**
     * 添加并启动定时器
     *
     * @param task
     * @param cronExpression
     */
    public void addCronTask(Long taskId, Runnable task, String cronExpression) {
        //先移除
        if (this.taskMaps.containsKey(taskId)) {
            removeCronTask(taskId);
        }
        //创建定时器
        CronTask cronTask = new CronTask(task, cronExpression);
        //启动定时器
        ScheduledRealTask scheduledRealTask = new ScheduledRealTask();
        scheduledRealTask.future = this.taskScheduler.schedule(cronTask.getRunnable(), cronTask.getTrigger());

        //构造任务map
        Map<String, Object> map = new HashMap();
        map.put("runnable", task);
        map.put("scheduledRealTask", scheduledRealTask);
        //添加定时器
        this.taskMaps.put(taskId, map);
    }

    /**
     * 移除并关闭定时器
     *
     * @param taskId
     */
    public void removeCronTask(Long taskId) {
        //移除定时器
        Map<String, Object> map = this.taskMaps.remove(taskId);
        if (map != null) {
            ScheduledRealTask scheduledRealTask = (ScheduledRealTask) map.get("scheduledRealTask");

            //关闭定时器
            if (scheduledRealTask != null) {
                scheduledRealTask.cancel();
            }
        }

    }


    /**
     * 销毁并关闭所有定时器
     */
    @Override
    public void destroy() {
        for (Map<String, Object> map : this.taskMaps.values()) {
            ScheduledRealTask scheduledRealTask = (ScheduledRealTask) map.get("scheduledRealTask");
            if (scheduledRealTask != null) {
                scheduledRealTask.cancel();
            }

        }
        this.taskMaps.clear();
    }
}

7. 定时器容器初始化启动类

package serve.peam.schedule;

import org.apache.commons.collections.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import serve.peam.schedule.reflect.ScheduleClassReflect;
import serve.peam.schedule.request.ScheduleRequest;

import java.util.ArrayList;
import java.util.List;

/**
 * 项目启动加载定时器任务
 *
 * @author 天真热
 * @create 2022-04-28 9:39
 * @desc
 **/
@Component
public class ScheduleInit implements CommandLineRunner {
    private static final Logger logger = LoggerFactory.getLogger(ScheduleInit.class);
    @Autowired
    private ScheduleApi scheduleApi;

    @Override
    public void run(String... args) {
        // 初始加载数据库里状态为正常的定时任务,这里暂时取空，具体根据业务获取
        List<ScheduleTask> ScheduleTaskList = new ArrayList<>();
        //遍历
        for (ScheduleTask scheduleTask : ScheduleTaskList) {
            //启动状态的才注入spring
            if (scheduleTask.getTaskStatus().equals("开启")) {
                if (scheduleTask.getTaskType().equals("类调用")) {
                    //类调用
                    ScheduleClassReflect task = new ScheduleClassReflect(scheduleTask.getCronServiceName(), scheduleTask.getCronServiceMethod(), scheduleTask.getId());
                    scheduleApi.addCronTask(scheduleTask.getId(), task, scheduleTask.getCronExpression());
                } else if (scheduleTask.getTaskType().equals("接口调用")) {
                    //接口调用
                    ScheduleRequest task = new ScheduleRequest(scheduleTask.getCronInterface(), scheduleTask.getCronInterfaceType(), scheduleTask.getId());
                    scheduleApi.addCronTask(scheduleTask.getId(), task, scheduleTask.getCronExpression());
                }

            }
        }
        logger.info("定时任务已加载完毕...");
    }
}

8. 容器demo调用类

package serve.peam.schedule;

import org.springframework.beans.factory.annotation.Autowired;
import serve.peam.schedule.reflect.ScheduleClassReflect;
import serve.peam.schedule.request.ScheduleRequest;

/**
 * @author 天真热
 * @create 2022-04-30 12:43
 * @desc
 **/
public class Demo {
    @Autowired
    private ScheduleApi scheduleApi;

    public void demo() {
        //获取ScheduleTask
        ScheduleTask scheduleTask = new ScheduleTask();

        //新增类定时调用
        ScheduleClassReflect task = new ScheduleClassReflect(scheduleTask.getCronServiceName(), scheduleTask.getCronServiceMethod(), scheduleTask.getId());
        scheduleApi.addCronTask(scheduleTask.getId(), task, scheduleTask.getCronExpression());

        //新增接口定时调用
        ScheduleRequest task1 = new ScheduleRequest(scheduleTask.getCronInterface(), scheduleTask.getCronInterfaceType(), scheduleTask.getId());
        scheduleApi.addCronTask(scheduleTask.getId(), task1, scheduleTask.getCronExpression());

        //移除定时调用
        scheduleApi.removeCronTask(scheduleTask.getId());
    }
}

三、前台cron组件功能代码展示

前端功能基本是表单啥的，这里不做演示。值得一提的是vue有提供cron表达式插件：czr-vue-cron

  1. 下载：npm install czr-vue-cron
  2. vue组件
<template>
  <div id="app">
    <input v-model="cronData"/>
    <CzrVueCron :cron.sync="cronData" :recent="[5, 5]"/>
  </div>
</template>
<script>
import CzrVueCron from 'czr-vue-cron'

export default {
  components: {
    CzrVueCron
  },
  data() {
    return {
      cronData: ''
    }
  }
}
</script>

在这里插入图片描述

懒惰の天真热
关注
SpringBoot整合定时器：定时任务不再硬编码，动态定时刷起来
Park33的博客
08-05 696
定时器在开发中真的算是一种福利了。通过定时器我们省去了很多人力。我们通过定时器将一些繁琐定期的事情通过代码去完成。在Java开发中我们通过Timer类可以简单实现定时器功能。既然是springboot课程今天我们就来看看srpingboot整合定时器的事情-上面的代码已经上传至gitee 点我传送 https://gitee.com/zxhTom/crontab.git下面Java类是我们这次使用用到的类。...
终于不再硬编码，动态定时太舒服了：教你做一个SpringBoot整合定时器
wdjnb的博客
12-18 188
前言 传统定时器是硬编码。但是有的时候业务上需要不断地调整 问题描述 我们开发了一个定闹钟的功能。这个功能肯定是定时器开发。但是这就存在一个问题这个定时是动态的。那么我们如何实现呢？请接着看 简介 定时器在开发中真的算是一种福利了。通过定时器我们省去了很多人力。我们通过定时器将一些繁琐定期的事情通过代码去完成。在Java开发中我们通过Timer类可以简单实现定时器功能。既然是springboot课程今天我们就来看看srpingboot整合定时器的事情 传统定时器 这里使用的是之前课程一的配置。spr
SpringBoot 动态定时器的使用方法
08-27
主要介绍了SpringBoot 动态定时器的使用方法,非常不错，具有一定的参考借鉴借鉴价值，需要的朋友可以参考下
定时任务不在硬编码，动态定时刷起来
烟花散尽的专栏
05-31 384
前言 传统定时器是硬编码。但是有的时候业务上需要不断的调整 问题描述 我们开发了一个定闹钟的功能。这个功能肯定是定时器开发。但是这就存在一个问题这个定时是动态的。那么我们如何实现呢？请接着看 简介 定时器在开发中真的算是一种福利了。通过定时器我们省去了很多人力。我们通过定时器将一些繁琐定期的事情通过代码去完成。在Java开发中我们通过Timer类可以简单实现定时器功能。既然是springboot课程今天我们就来看看srpingboot整合定时器的事情 传统定时器 这里使用的是之前课程一的配置。
spring boot动态定时任务
最新发布
weixin_36963061的博客
08-12 227
Spring Boot 动态定时任务 在现代软件开发中，定时任务是实现定期执行某些操作（例如，数据备份、邮件发送等）的有效方式。Spring Boot 作为一种流行的微服务框架，提供了简洁的定时任务机制。然而，很多时候，我们需要根据业务需求动态地调整定时任务的执行频率。本文将介绍如何在 Spring Boot 中实现动态定...
Springboot2-Quartz 后台可动态配置的定时任务
02-28
SpringBoot2 与 Quartz 整合的Demo。 后台可添加、修改、移除 定时任务。 也可查看当前任务的状态 灵活的定时任务
[精简版]springboot动态配置定时器
YiQieFuCong的博客
02-06 529
代码地址：https://github.com/gwy572294624/schedule-demo git clone https://github.com/gwy572294624/schedule-demo springboot项目 ，执行sql后修改数据库连接地址即可运行部署测试。 动态配置定时器实现逻辑（文章开始前需要了解）程序中实现就是代码实现项目结构数据库表信息pom主要工具类该类为程序中定时器增删改查类（主类）每次触发定时器时开启的方法（动态定时器触发类）该类为开启线程执行方法类（开启线程
springboot动态配置定时任务(schedule)
06-13
springboot动态配置定时任务(schedule),可不重启项目实现开关重启任务,改变任务定时规则
SpringBoot实现定时器
06-14
首先，我们需要了解Spring Boot中的定时器是如何工作的。Spring Boot通过`@EnableScheduling`注解启用定时任务调度。这个注解会开启一个后台任务调度器，定期检查是否有待执行的任务。我们可以创建一个名为`...
SpringBoot定时器
05-28
这个"SpringBoot定时器"的主题主要涉及的是Spring Boot如何集成和使用Java的定时任务库，如Quartz或Spring自带的Task Scheduling。 首先，Spring Boot内置了对Spring的Task Scheduling的支持，它提供了一个简单易用...
利用Spring Boot轻松实现动态定时器开发！
SQY0809的博客
06-17 1770
前言 传统定时器是硬编码。但是有的时候业务上需要不断地调整 问题描述 我们开发了一个定闹钟的功能。这个功能肯定是定时器开发。但是这就存在一个问题这个定时是动态的。那么我们如何实现呢？Spring Boot核心学习笔记共享。 简介 定时器在开发中真的算是一种福利了。通过定时器我们省去了很多人力。我们通过定时器将一些繁琐定期的事情通过代码去完成。在Java开发中我们通过Timer类可以简单实现定时器功能。既然是springboot课程今天我们就来看看srpingboot整合定时器的事情 传统定时器
Spring Boot 实现定时任务动态管理
程序员子龙
03-25 2252
本文主要介绍了SpringBoot架构下动态定时任务的使用，定时任务表达式配置在数据库中，通过反射执行到目标方法。Quartz定时任务默认都是并发执行的，不会等待上一次任务执行完毕，只要间隔时间到就会执行, 如果定时任执行太长，会长时间占用资源，导致其它任务堵塞。一般设置都是禁止并发执行//禁止并发执行@Override/*** 线程本地变量*/@Overridetry {if (sysJob!= null)log.error("任务执行异常 - ：", e);/**
springboot 动态配置定时器
热门推荐
做对一件事很重要
01-02 3万+
写在前面：本文采取的环境 1.docker下的mysql（便于读者测试，本人将开放该mysql服务连接（jdbc: mysql://47.99.200.71:3306/test?allowMultiQueries=true&amp;useUnicode=true&amp;characterEncoding=utf8&amp;autoReconnect=true&amp;useSSL=true），便...
springboot动态定时任务
Happywzy~的博客
05-12 435
spring boot通过注解@EnableScheduling和@Scheduled实现的是静态定时任务，不能动态添加、停止、修改等. 本文通过ThreadPoolTaskScheduler实现定时任务动态增删改. 静态定时任务参考 创建ThreadPoolTaskScheduler @Bean public ThreadPoolTaskScheduler threadPoolTaskScheduler() { ThreadPoolTaskScheduler threadPoolTas.
SpringBoot动态定时任务(完整版)
学习学习学习
10-14 2万+
完整版动态定时任务增删改启动暂停功能样样俱全，话不多说，直接看代码，你们直接CV就可以用！！！
springboot 动态定时器
吴灵辉的博客
11-06 348
定时表达式 https://www.cnblogs.com/javabg/p/10912176.html springboot使用注解实现定时器 https://blog.csdn.net/u010096717/article/details/85160758 任务动态修改cron表达式改变执行周期 https://www.cnblogs.com/gtblogs/p/10224937.htm...
SpringBoot 动态添加定时任务
郊眠寺
06-14 293
最近的需求有一个自动发布的功能, 需要做到每次提交都要动态的添加一个定时任务[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UuVut2Fw-1655176961196)(https://juejin.cn/ “点击并拖拽以移动”)]​[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JwqhvCi0-1655176961196)(https://juejin.cn/ “点击并拖拽以移动”)]​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保
玩转SpringBoot动态定时任务（启动、暂停）
Tan_xiong的博客
04-02 1109
最近在做一个项目，需要用到动态定时任务，现在比较普遍的做法是集成第三方框架(例如Quartz、XXL-JOB)，但是基于项目本身的复杂度和使用场景，使用springBoot自身带有的定时任务框架来实现
SpringBoot动态添加数据源：寄存器位行为详解
本文档主要讨论了SpringBoot如何在运行时动态添加数据源的问题，并以CLRC663 NFC ISO44443芯片为例，介绍其寄存器位行为及其功能。...这对于开发涉及NFC技术的SpringBoot应用开发者来说，提供了宝贵的参考和指导。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值