springboot （scheduled）定时器 可通过数据库控制定时任务的增删查改和启动关闭

已于 2024-03-30 18:54:19 修改
阅读量2.2k 收藏 11
点赞数
分类专栏： springboot 文章标签： java mysql
于 2020-11-25 11:41:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36992948/article/details/110121730
版权

springboot +@scheduled定时器 可通过数据库控制定时任务的增删查改和启动关闭


前端定时器表达式可参考： layui 定时器表达式 插件 代码.

一、定时器控制表

CREATE TABLE `scheduled` (
  `ID` bigint(20) NOT NULL AUTO_INCREMENT,
  `CODE` varchar(50) DEFAULT NULL COMMENT '定时器编号',
  `CORN` varchar(50) DEFAULT NULL COMMENT '定时器表达式',
  `CORNDESC` varchar(200) DEFAULT NULL COMMENT '定时器表达式内容',
  `CORNNAME` varchar(100) DEFAULT NULL COMMENT '定时器名称',
  `CORNLINK` varchar(200) DEFAULT NULL COMMENT '定时接口 链接 eg:http://project/test?id=123456',
  `METHOD` varchar(10) DEFAULT NULL COMMENT '请求方式GET/POST',
  `STATUS` varchar(2) DEFAULT NULL COMMENT '状态1=启动  2=停止',
  `STARTTIME` datetime DEFAULT NULL COMMENT '最后一次启动时间',
  `ENDTIME` datetime DEFAULT NULL COMMENT '最后一次停止时间',
  `REMARK` varchar(200) DEFAULT NULL COMMENT '备注说明',
  PRIMARY KEY (`ID`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=25 DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='定时器控制表';

二、功能实现代码

1.定时调度配置类+启动项目时自动启动数据库中开启状态的调度

/**
 * 描述:
 * 定时调度配置类
 * @author 闲走天涯
 * @create 2020/9/3 11:15
 */
@Slf4j
@Component
public class ScheduledConfig implements ApplicationRunner {
    @Autowired
    ScheduledDao scheduledDao;

    @Autowired
    RestTemplate restTemplate;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        try {
            List<ScheDuledVo> vos = scheduledDao.findStartingScheduled();
            for (ScheDuledVo vo : vos) {
                MultiValueMap<String,Object> multiValueMap = new LinkedMultiValueMap<>();
                multiValueMap.add("code",vo.getCode());
                Map result = restTemplate.postForObject("http://ALI-ASSIST-SERVICE/scheduled/startCron",multiValueMap,Map.class);
                log.info("【启动 定时调度】接口={},结果={}", vo.getCornLink(), result);
            }
        }catch (Exception e){
            log.error("【启动 定时调度】失败",e);
        }
    }
}

2.开启、关闭调度

/**
 * 描述:
 * java 定时调度 控制 执行代码端
 *
 * @author 闲走天涯
 * @create 2020/9/2 11:23
 */
@Slf4j
@RestController
@RequestMapping("/scheduled")
public class ScheduledController {

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private ScheduledDao scheduledDao;

    @Autowired
    private ThreadPoolTaskScheduler threadPoolTaskScheduler;

    Map<String, ScheduledFuture> map = new HashMap<>();

    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
        return new ThreadPoolTaskScheduler();
    }

    /**
     * 启动定时器
     *
     * @param code 定时器编号
     * @return
     */
    @RequestMapping("/startCron")
    public Map startCron(String code) {
        Map result = new HashMap();
        result.put("code", "1");
        try {
            log.info("【定时调度】启动 参数-》 code={}", code);
            if (!VerifyData.strIsNotNull(code)) {
                result.put("code", "1");
                result.put("msg", "参数错误");
                return result;
            }
            ScheDuledVo vo = scheduledDao.selectScheDuleByCode(code);
            log.info("【定时调度】启动 参数-》 vo={}", vo.toString());
            if (!VerifyData.strIsNotNull(vo.getCorn()) || !VerifyData.strIsNotNull(vo.getCode()) || !VerifyData.strIsNotNull(vo.getCornName()) || !VerifyData.strIsNotNull(vo.getCornLink()) || !VerifyData.strIsNotNull(vo.getMethod())) {
                result.put("code", "1");
                result.put("msg", "参数错误");
                return result;
            }
          
            ScheduledFuture future = threadPoolTaskScheduler.schedule(new taskRunnable(vo), new CronTrigger(vo.getCorn()));
            map.put(vo.getCode(), future);
            log.info("【定时调度】启动 定时器编号={},名称={}", vo.getCode(), vo.getCornName());
            if (!"1".equals(vo.getStatus())) {
                int i = scheduledDao.updateScheduledStatus(code, "1");
            }
        } catch (Exception e) {
            log.error("【定时调度】启动 失败", e);
            result.put("code", "1");
            result.put("msg", "系统错误");
            return result;
        }
        result.put("code", "3");
        result.put("msg", "启动成功");
        return result;
    }

    /**
     * 停止定时器
     *
     * @param code
     * @return
     */
    @RequestMapping("/stopCron")
    public Map stopCron(String code) {
        Map result = new HashMap();
        result.put("code", "1");
        try {
            log.info("【定时调度】停止 参数-》 code={}", code);
            if (!VerifyData.strIsNotNull(code)) {
                result.put("code", "1");
                result.put("msg", "参数错误");
                return result;
            }
            ScheDuledVo vo = scheduledDao.selectScheDuleByCode(code);
            log.info("【定时调度】停止 参数-》 vo={}", vo.toString());
            if (!VerifyData.strIsNotNull(vo.getCorn()) || !VerifyData.strIsNotNull(vo.getCode()) || !VerifyData.strIsNotNull(vo.getCornName()) || !VerifyData.strIsNotNull(vo.getCornLink()) || !VerifyData.strIsNotNull(vo.getMethod())) {
                result.put("code", "1");
                result.put("msg", "参数错误");
                return result;
            }
            ScheduledFuture future = map.get(vo.getCode());
            if (future != null) {
                future.cancel(true);
                log.info("【定时调度】停止 定时器编号={},名称={}", vo.getCode(), vo.getCornName());
                map.remove(vo.getCode());
                if (!"2".equals(vo.getStatus())) {
                    int i = scheduledDao.updateScheduledStatus(code, "2");
                }
            } else {
                result.put("code", "2");
                result.put("msg", "查无定时器编号,错误");
                return result;
            }
        } catch (Exception e) {
            log.error("【定时调度】停止 失败", e);
            result.put("code", "1");
            result.put("msg", "系统错误");
            return result;
        }
        result.put("code", "3");
        result.put("msg", "停止成功");
        return result;
    }

    /**
     * 定时器执行方法
     *
     * @param vo
     */
    private void dotask(ScheDuledVo vo) {
        log.info("【定时任务】" + vo.getCode() + ":" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        try {
            JSONObject result = new JSONObject();
            if ("get".equals(vo.getMethod().toLowerCase())) {
                result = restTemplate.getForObject(vo.getCornLink(), JSONObject.class);
            } else if ("post".equals(vo.getMethod().toLowerCase())) {
                if (vo.getCornLink().indexOf("?") != -1) {
                    String link = vo.getCornLink().substring(0, vo.getCornLink().indexOf("?"));
                    MultiValueMap<String, Object> multiValueMap = new LinkedMultiValueMap<>();
                    String params = vo.getCornLink().substring(vo.getCornLink().indexOf("?") + 1, vo.getCornLink().length());
                    if (params.indexOf("&") != -1) {
                        String[] paramArr = params.split("&");
                        for (String param : paramArr) {
                            multiValueMap.add(param.split("=")[0], param.split("=")[1]);
                        }
                    } else {
                        multiValueMap.add(params.split("=")[0], params.split("=")[1]);
                    }
                    result = restTemplate.postForObject(link, multiValueMap, JSONObject.class);
                } else {
                    result = restTemplate.postForObject(vo.getCornLink(), null, JSONObject.class);
                }
            }
            //log.info("【定时任务】"+vo.getCode()+":result="+JSONObject.toJSONString(result));
        } catch (Exception e) {
            log.error("【定时任务】接口(" + vo.getCornLink() + ") 访问失败" + e.getMessage());
        }
    }

	//多线程
    class taskRunnable implements Runnable {

        private ScheDuledVo vo;

        public taskRunnable(ScheDuledVo vo) {
            this.vo = vo;
        }

        @Override
        public void run() {
            //编写你自己的业务逻辑
            dotask(vo);
        }
    }
}

三、vo类

@Data
public class ScheDuledVo {
    private Long id;
    private String corn;//定时器表达式
    private String cornDesc;//定时器表达式内容
    private String cornName;//定时器名称
    private String status;//定时器状态 1=开启  2=关闭
    private Date startTime;//上一次开始时间
    private Date endTime;//上一次结束时间
    private String remark;//备注说明
    private String cornLink;//定时器访问接口链接 eg:http://ali-assist/deal/test?id=123456
    private String method;//定时器访问接口方式 GET POST
    private String code;//定时器编号

    private String startTimeStr;//上一次开始时间
    private String endTimeStr;//上一次结束时间
}
闲走天涯
关注
  • 0
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
从数据库获取值设置@Scheduled cron的值(springboot)
qq_34792830的博客
04-27 5069
我正在使用，Spring Boot并且在调度cron task数据库中存在的使用值时遇到问题。 目前，我正在从属性文件中读取值，如下所示： @Scheduled(cron= "${time.export.cron}") public void performJob() throws Exception { // do something } 这很好用，但是我不想从属性文件中获取值，而是想从数据库表中获取它们。有可能吗？ Vignesh： 您可以在SpringBootApplic..
【quartz】从数据库中读取配置实现动态定时任务
qq_37634156的博客
06-25 4155
实现方式 1、定时任务表实体 2、反射调用scheduleJob中定义的方法 3、创建正常状态下的job执行工厂 4、若一个方法一次执行不完下次轮转时则等待改方法执行完后才执行下一次操作 5、创建需要运行的定时任务类 6、SpringBean工厂工具类 7、其他用到的工具类 字符串工具类 日志工具类 数据分析常量类 接口返回参数类 其中ResultEnum类如下： 8、sql语句 注释的很
利用Spring中的SchedulingConfigurer实现数据库配置化定时任务
最新发布
qq_43877180的博客
04-23 908
直接使用@Scheduled的方式来实现定时任务有是有效，但是每增加一个定时任务，或者要修改定时任务的规则，比如修改cron表达式为固定频率或者固定次数，每次修改都要重启一下服务，为我们的开发带来了许多不方便的地方。但是这样简单粗暴的方式可以实现定时任务的功能，但是在我们之后的开发过程中会频繁的使用到定时任务，如果拓展定时任务实现方式的灵活性与拓展性就成了问题。UrTaskConfig这一类用来获取定时任务的一些配置，定时任务的规则，定时任务的状态，以及定时任务的类型（cron表达式、固定频率、固定间隔）
springboot集成quartz完成定时任务+数据库存储
qq_45384482的博客
12-07 1620
文章目录前言Spring整合Quartz读取数据库启动定时任务 前言 注意：本篇博客采取的是spring自带的定时器与quartz调度框架一并使用，不涉及到页面。 项目层次： Spring整合Quartz quartz调度框架是有内置表的，进入quartz的官网http://www.quartz-scheduler.org/，点击Downloads，下载后在目录\docs\dbTables下有常用数据库创建quartz表的脚本，找到tables_mysql.sql导入到数据库。 这些表是操作quartz
SpringBoot基于数据库的定时任务实现
u011134780的博客
12-28 7414
在我们平时开发的项目中，定时任务基本属于必不可少的功能，那大家都是怎么做的呢？但我知道的大多都是静态定时任务实现。 基于注解来创建定时任务非常简单，只需几行代码便可完成。实现如下： @Configuration @EnableScheduling public class SimpleScheduleTask { //10秒钟执行一次 @Scheduled(cron = "...
SpringBoot中的定时任务，基于数据库动态执行
老丁学抓娃的博客
10-22 2981
普通无数据库版： 一、加入@EnableScheduling，开启定时任务(此注解也可以加在启动类上)。 @EnableScheduling @Component public class OneDemo { 二、在需要执行定时任务的方法上加上 @Scheduled注解并设置定时规则 @Scheduled(fixedRate = 100*2) //每两百毫秒秒执行一次，或使用cron 设置执行规则 public void handleDelay(){ System.
spring-boot定时任务@Scheduled怎么实现动态获取
ItGsn_NoBug的博客
07-13 783
在每天定时的需要去扫描数据库的info表,需要根据当前时间来判断当前活动的状态,需要用到@Scheduled定时任务,但是考虑到后期有可能会更改cron表达式,所以这边就做成了动态获取的状态。cron在动态获取的时候,不会实时去加载你新的cron表达式,而是在下一次执行之前的任务,才会记录到最新的cron表达式,所以在这一块,需要注意一点。@EnableScheduling-->开启定时任务。@Configuration-->加载配置信息。3. @Scheduled使用的注意步骤。
springboot实现定时任务定时查找数据库
浩浩的博客
08-03 819
定时任务
Spring Boot如何实现定时任务的动态增删启停详解
08-18
Spring Boot 实现定时任务的动态增删启停详解 在 Spring Boot 项目中，实现定时任务的动态增删启停是非常重要的。传统的方法是使用 Quartz 框架，但是这种方法需要依赖其它框架，可能会导致项目的臃肿和复杂。因此...
SpringBoot中使用@Scheduled注解创建定时任务的实现
08-19
SpringBoot中使用@Scheduled注解创建定时任务的实现可以使用Timer、Quartz和@Scheduled注解三种方式来实现定时任务，每种方式都有其优缺。此外，使用@Scheduled注解实现定时任务的方式可以轻松地实现复杂的定时任务...
SpringBoot基于数据库实现定时任务过程解析
08-25
SpringBoot基于数据库实现定时任务过程解析 在 SpringBoot 应用程序中，实现定时任务是非常常见的需求。传统的实现方法是使用 @Scheduled 注解来创建定时任务，但是这种方法有很大的缺点和局限，就是当我们调整了...
Java多线程之定时任务 以及 SpringBoot多线程实现定时任务——异步任务
03-12
1. SpringBoot 自定义线程池以及多线程间的异步调用（@Async、@EnableAsync） 2.Java多线程之定时任务 以及 SpringBoot多线程实现定时任务 3.@EnableScheduling 与 @Scheduled
springboot定时任务的动态开启关闭
03-07
为了通过外部请求动态控制定时任务，我们可以创建RESTful API，调用`TaskService`的`startTask`和`stopTask`方法： ```java @RestController public class TaskController { private final TaskService ...
SpringBoot中使用Schedule
tobearc的专栏
05-05 6841
一、基本方法 有了SpringBoot貌似一切都变了非常简单，定时任务也不用整合quartz了，直接schedule就欧了。具体咋用？非常简单。 1、引入POM依赖 Spring的Schedule包含在spring-boot-starter模块中，无需引入其他依赖。 2、开启注解支持 在启动类增加注解：@EnableScheduling 3、轻松上手使用 A、Cron表达式 ...
SpringBoot Scheduled实现定时任务和配合数据库动态执行任务
zhangshengqiang168的博客
04-24 1239
1.依赖只需要parent 和web <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.14.RELEASE&lt...
SpringBoot集成Quartz数据库配置定时任务
人生就像一场戏
09-28 3550
Spring Boot 整合 Quartz 实现定时任务集群 文章参考 https://blog.csdn.net/l18848956739/article/details/86597709 https://blog.csdn.net/xibei19921101/article/details/105012749 https://blog.csdn.net/WLPJLP/article/details/103908448 https://blog.csdn.net/sqlgao22/arti.
基于springboot定时任务的后台管理，使用数据库配置定时任务相关信息，修改，关闭定时任务不需重启项目
yaoyipeng的博客
03-12 1954
创建完数据库，创建对应的ScheduledController，ScheduledService和ScheduledMapper和Scheduled实体类，相关代码我就不发了，控制层将定时任务相关信息修改后记得重启你修改过的定时任务，调用scheduledTaskService.restart(传入此定时任务的实体类信息);然后我们新建一个定时任务的公共接口，所有定时任务中的类（也就是表中的job_key字段填写的类名）都必须实现此接口。然后项目启动时初始化定时任务。首先创建定时任务线程池。
Java之SpringBoot 创建定时任务（配合数据库动态执行）
热门推荐
命中的缘分的博客
09-03 2万+
SpringBoot 创建定时任务（配合数据库动态执行） 序言：创建定时任务非常简单，主要有两种创建方式：一、基于注解(@Scheduled) 二、基于接口（SchedulingConfigurer）. 前者相信大家都很熟悉，但是实际使用中我们往往想从数据库中读取指定时间来动态执行定时任务，这时候基于接口的定时任务就大派用场了。 一、静态定时任务（基于注解） 基于注解来创建定时任务非常简单...
springboot scheduled定时器
03-16
Spring Boot中的Scheduled定时器是一种基于注解的定时任务调度框架，它可以帮助我们在指定的时间间隔或固定的时间点执行任务。使用Scheduled注解可以将一个方法标记为定时任务，然后通过配置cron表达式或时间间隔来指定任务的执行时间。这个定时器非常方便，可以用于定时发送邮件、定时清理缓存、定时备份数据库等各种场景。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值