使用spring-task定时任务动态配置修改执行时间

spring-task定时任务动态配置修改执行时间

因项目需要，几个定时任务需要人为动态设置执行时间，于是乎吧，就查阅相关资料，是可以动态设置的，废话不多说，直接上代码，一目了然。

package com.seckill.quartz;
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.text.simpledateformat;
import java.util.date;
 
/**
 * created by loup on 2017/11/11.
 */
@component
@enablescheduling
public class dynamicscheduledtask implements schedulingconfigurer {
    //时间表达式  每2秒执行一次
    private string cron = "0/2 * * * * ?";
    private simpledateformat sdf = new simpledateformat("yyyy-mm-dd hh:mm:ss");
 
    @override
    public void configuretasks(scheduledtaskregistrar scheduledtaskregistrar) {
        scheduledtaskregistrar.addtriggertask(new runnable() {
            @override
            public void run() {
                //任务逻辑
                system.out.println("---------------start-------------------");
                system.out.println("动态修改定时任务参数，时间表达式cron为：" + cron);
                system.out.println("当前时间为：" + sdf.format(new date()));
                system.out.println("----------------end--------------------");
            }
        }, new trigger() {
            @override
            public date nextexecutiontime(triggercontext triggercontext) {
                crontrigger crontrigger = new crontrigger(cron);
                date nextexecdate = crontrigger.nextexecutiontime(triggercontext);
                return nextexecdate;
            }
        });
    }
 
    public void setcron(string cron) {
        this.cron = cron;
    }
}

这个是定时任务调度执行器，采用的是注解的方式。首先要动态配置，要设置为@enablescheduling，这是确保能够动态，然后实现schedulingconfigurer，重写configuretasks方法，接下来就是这个的相关spring配置文件，要引入下面这个task，不然识别不了啊，配置文件就是这么简单

http://www.springframework.org/schema/task

<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
       xmlns:task="http://www.springframework.org/schema/task"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemalocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/task
        http://www.springframework.org/schema/task/spring-task.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
 
    <context:component-scan base-package="com.seckill.quartz"/> 
    <task:annotation-driven /> 
</beans>

接下来就是写测试类，测试可不可行啊

package com.seckill.quartz;
import org.junit.test;
import org.junit.runner.runwith;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.test.context.contextconfiguration;
import org.springframework.test.context.junit4.springjunit4classrunner;
import java.io.ioexception;
 
/**
 * created by loup on 2017/11/11.
 */
@runwith(springjunit4classrunner.class)
@contextconfiguration({"classpath*:/conf/spring-quartz.xml"})
public class quartztest {
 
    @autowired
    private dynamicscheduledtask dynamicscheduledtask;
 
    @test
    public void test1(){
        try {
            thread.sleep(10000);
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
        dynamicscheduledtask.setcron("0/10 * * * * ?");
        try {
            system.in.read();
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }
}

运行测试类，查看结果，达到效果，亲测可用

spring schedule 动态配置执行时间

之前saas平台实现动态修改定时任务的时间，都是通过xx-job这样的框架来实现，这样我们可以单独一个服务来管理我们整个saas平台的定时任务，但是最近给银行做的一个小项目，需要本地化部署，所以我不想弄很多的服务，并且他们并没有要求修改以后即时生效，所以我直接采用了 spring schedule结合mysql动态配置执行时间。

之前我们用的schedule通过注解的方式，只能用静态的corn表达式，如果想实现动态的需要实现schedulingconfigurer，并且通过注解@enablescheduling。如下：

package com.zqf.marketing.task;  
import com.zqf.db.marketingrobot.sys.model.robotsysswitch;
import com.zqf.marketing.sys.service.switchservice;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.context.annotation.lazy;
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.service; 
import java.util.date;
 
/**
 * @author zhenghao
 * @description
 * @date 2019/1/22 21:50
 */
 
@lazy(false)
@service
@enablescheduling
public class testtaskservice implements schedulingconfigurer { 
    private static logger log = loggerfactory.getlogger(testtaskservice.class);
    @autowired
    private switchservice switchservice;  
    private string springdynamiccrontask() {
        string cron = "0/5 * * * * ?";
        //从数据库获得配置的corn表达式
        robotsysswitch switchbyid = switchservice.getswitchbyid(5l);
        cron = switchbyid.getswitchflag();
        log.info(cron);
        return cron;
    } 
 
    @override
    public void configuretasks(scheduledtaskregistrar scheduledtaskregistrar) {
        scheduledtaskregistrar.addtriggertask(new runnable() {
            @override
            public void run() {
                // 任务逻辑
                log.info("task_task_tak");
            }
        }, new trigger() {
            @override
            public date nextexecutiontime(triggercontext triggercontext) {
                string s = springdynamiccrontask();
                // 任务触发，可修改任务的执行周期
                crontrigger trigger = new crontrigger(s);
                date nextexec = trigger.nextexecutiontime(triggercontext);
                return nextexec;
            }
        });  
    }
}

这样我们就可以动态的修改task的执行时间，生效时间为，上一个任务的执行周期，也可以满足我们现在需求，这样就可以实习项目更加的灵活！

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