Springboot自带定时任务实现动态配置Cron参数方式

springboot自带定时任务实现动态配置cron参数

同学们，我今天分享一下springboot动态配置cron参数。场景是这样子的：后台管理界面对定时任务进行管理，可动态修改执行时间，然后保存入库，每次任务执行前从库里查询时间，以达到动态修改cron参数的效果。好，咱们一起来看看是怎么回事。

springboot定时任务的四种实现方式(主要)

• timer：这是java自带的java.util.timer类，这个类允许你调度一个java.util.timertask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少。
• scheduledexecutorservice：也jdk自带的一个类；是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也就是说,任务是并发执行,互不影响。
• spring task：spring3.0以后自带的task，可以将它看成一个轻量级的quartz，而且使用起来比quartz简单许多。
• quartz：这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂。

1.1使用timer

这是让你按照固定的频率去执行一个任务，不能指定时间。

public class testtimer {
    public static void main(string[] args) {
        timertask timertask = new timertask() {
            @override
            public void run() {
                system.out.println("task  run:"+ new date());
            }
        };
        timer timer = new timer();
        //安排指定的任务在指定的时间开始进行重复的固定延迟执行。这里是每3秒执行一次
        timer.schedule(timertask,10,3000);
    }
}

1.2使用scheduledexecutorservice和timer类似

public class testscheduledexecutorservice {
    public static void main(string[] args) {
        scheduledexecutorservice service = executors.newsinglethreadscheduledexecutor();
        // 参数：1、任务体 2、首次执行的延时时间
        //      3、任务执行间隔 4、间隔时间单位
        service.scheduleatfixedrate(()->system.out.println("task scheduledexecutorservice "+new date()), 0, 3, timeunit.seconds);
    }
}

1.3使用spring task

我们主要讲解它的动态配置使用方法。

在刚开始使用的时候，我们更改一个任务的执行时间，一般是这样的：修改定时任务的执行周期，把服务停下来，改下任务的cron参数，再重启服务就搞搞定了。这种方式很简单，没有可说的，但是有没有一种可能，在不停服务的情况下，就可以动态的修改任务的cron参数呢？那是必须有！

刚刚提到的方法里，我们在主类上面加@enablescheduling注解，在任务方法前面加上@scheduled(cron =“0/5 * * * * *”)注解定义执行时间，但是动态配置的步骤就有点不一样：

1. 在定时任务类上增加@enabledscheduling注解，并实现schedulingconfigurer接口。

2. 设置一个静态的cron，用于存放任务执行周期参数。

3. 从数据库获取cron参数，用于模拟实际业务中外部原因修改了任务执行周期。

4. 设置任务触发器，触发任务执行。

import java.util.date;
import org.springframework.scheduling.trigger;
import org.springframework.scheduling.triggercontext;
import org.springframework.scheduling.annotation.enablescheduling;
import org.springframework.scheduling.annotation.schedulingconfigurer;
import org.springframework.scheduling.config.scheduledtaskregistrar;
import org.springframework.scheduling.support.crontrigger;
import org.springframework.stereotype.component;
import java.time.localdatetime;
@component 
@enablescheduling
public class taskcronchange implements  schedulingconfigurer{
    public static string cron; 
    @override
    public void configuretasks(scheduledtaskregistrar taskregistrar) {
        //项目部署时，会在这里执行一次，从数据库拿到cron表达式
        cron = timerquerymapper.getcrontime();
       runnable task = new runnable() {
           @override
           public void run() {
              //任务逻辑代码部分.
              system.out.println("i am going:" + localdatetime.now());
           }
       };
       trigger trigger = new trigger() {
           @override
           public date nextexecutiontime(triggercontext triggercontext) {
              //任务触发，可修改任务的执行周期.
              //每一次任务触发，都会执行这里的方法一次，重新获取下一次的执行时间        
              cron = timerquerymapper.getcrontime();
              crontrigger trigger = new crontrigger(cron);
              date nextexec = trigger.nextexecutiontime(triggercontext);
              return nextexec;
           }
       };
       taskregistrar.addtriggertask(task, trigger);
    }
}

因为是要任务执行一次的时候才会去修改时间的cron表达式，所以改了cron后，要在下下次任务执行时才会生效。

这里核心的主要是使用到了scheduledtaskregistrar这个类有一个方法addtriggertask（runnable,trigger） 两个参数，一个runnable,一个是trigger，在runnable中执行业务逻辑代码，在trigger修改定时任务的执行周期。

1.4整合quartz

在springboot版本是2.0.0以后的，则在spring-boot-starter中已经包含了quart的依赖，则可以直接使用spring-boot-starter-quartz依赖，如果是低于2.0.0版本的，需要额外添加quartz的依赖。

spring动态配置cron表达式，不需要停服

spring做定时任务调度时有常用的两种方式，分别是基于配置文件的quartz和基于注解的@scheduler。

quartz需要较多的配置文件，个人感觉比较麻烦，@scheduler注解只需要简单的配置即可，但是这两种发方法不能动态加载cron表达式，每次更改调度规则都需要重启服务。

本文介绍一种不需要重启服务的动态加载cron表达式的方法。

schedulingconfigurer接口实现动态加载cron表达式

代码示例如下：

@component
@enablescheduling
public class test implements schedulingconfigurer {
 
    @override
    public void configuretasks(scheduledtaskregistrar scheduledtaskregistrar) {
        //创建一个线程池调度器，默认是单线程执行
        scheduledexecutorservice executorservice = executors.newscheduledthreadpool(100);
        scheduledtaskregistrar.setscheduler(executorservice);
 
        //增加任务
        scheduledtaskregistrar.addtriggertask(new task("test1"),new trig("cronexpess1"));
        scheduledtaskregistrar.addtriggertask(new task("test2"),new trig("cronexpess2"));
        scheduledtaskregistrar.addtriggertask(new task("test3"),new trig("cronexpess2"));
    }
}
 
/**
 * 业务类
 */
class task implements runnable{
    string task;
    public task(string task){
        this.task = task;
    }
 
    //具体业务
    @override
    public void run() {
        system.out.println(task+":"+localdatetime.now()+","+thread.currentthread().getname());
    }
}
 
/**
 * 调度类
 */
class trig implements trigger{ 
    private string cronexpress;
    public trig(string cronexpress){
        this.cronexpress = cronexpress;
    }
 
    @override
    public date nextexecutiontime(triggercontext triggercontext) {
        string cron = null;
        try {
            //每次调度时加载cron表达式
            cron = new config().getcrons().get(cronexpress);
        } catch (ioexception e) {
            e.printstacktrace();
        }
        crontrigger crontrigger = new crontrigger(cron);
        return crontrigger.nextexecutiontime(triggercontext);
    }
}
 
/**
 * 加载cron表达式
 */
class config{
    private static map<string,string> cronmap;
    private static long premodifytime;
    private string cronfile = "config/application.properties";
 
    public map<string,string> getcrons() throws ioexception {
        file file = new file(cronfile);
        long nowmodifytime = file.lastmodified();
        if (cronmap != null && nowmodifytime == premodifytime){
            return cronmap;
        }else {
            cronmap = new hashmap<>();
            bufferedreader br = new bufferedreader(new filereader(file));
            string line = null;
            while ((line = br.readline()) != null){
                string[] s = line.split("=");
                cronmap.put(s[0].trim(),s[1].trim());
            }
            premodifytime = nowmodifytime;
            return cronmap;
        }
    }
}

配置文件：

cronexpess1 = 0/5 * * * * *
cronexpess2 = 0/10 * * * * *

运行结果（为了查看方便，只运行一个任务）：

以上为个人经验，希望能给大家一个参考，也希望大家多多支持。