spring定时任务，动态修改定时时间

在Spring中用到定时任务，一般会在方法上使用@Schedule（cron=“0/5 * * * * ?”）。像这样是代表每五秒执行一次定时任务。
但是有时候需求会需要定时时间可以人为控制，可动态修改。这样子上面的注解方法就不能用了。有一种方法是可以通过实现SchedulingConfigurer接口，重写configureTasks方法去动态修改定时时间，如下：

@Conponent
@Lazy(false)
@EnableScheduling
public class MySchedulerConfig implements SchedulingConfigurer{
    
    public static String cron = "0/5 * * * * ?";
    
    public void setCron(final String cron){
        this.cron = cron;
    }
    
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.addTriggerTask(new Runnable() {
            
            @Override
            public void run() {
                // 业务逻辑 
            }
        }, new Trigger(){  
            @Override  
            public Date nextExecutionTime(TriggerContext triggerContext) {  
                //任务触发，可修改任务的执行周期   
                CronTrigger trigger = new CronTrigger(cron);  
                Date nextExec = trigger.nextExecutionTime(triggerContext);  
                return nextExec;    
            }  
        });  
    }
    
}

这样就可以通过setCron方法改变定时的时间，不过缺陷在于不会即时生效。
第二种方法是使用spring的ThreadPoolTaskScheduler定时线程池。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.Trigger;
import org.springframework.scheduling.TriggerContext;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledFuture;

@Component
public class DynamicTaskConfig {


    @Autowired
    private ThreadPoolTaskScheduler threadPoolTaskScheduler;
    //用于存放对应的定时任务
    private Map<String, ScheduledFuture<?>> taskFutures = new ConcurrentHashMap<String, ScheduledFuture<?>>();

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

    /**
     * 开始定时任务
     * @param taskId
     * @param task
     * @param cron
     */
    public void startCron(String taskId, Runnable task, String cron) {
        //先把之前的定时任务取消
        stopCron(taskId);
        //提交任务
        ScheduledFuture<?> scheduledFuture = threadPoolTaskScheduler.schedule(task, new Trigger() {
            @Override
            public Date nextExecutionTime(TriggerContext triggerContext) {
               //设置定时时间
                CronTrigger trigger = new CronTrigger(cron);
                Date nextExecDate = trigger.nextExecutionTime(triggerContext);
                return nextExecDate;
            }
        });
        //保存任务，用于后面可以取消任务
        taskFutures.put(taskId, scheduledFuture);
    }

    /**
     * 取消定时任务
     * @param taskId
     */
    public void stopCron(String taskId) {
        ScheduledFuture<?> future = taskFutures.get(taskId);
        if (future != null) {
            future.cancel(true);
        }
    }


}

import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Date;

@Component
public class DynamicTask implements InitializingBean {
    @Autowired
    private DynamicTaskConfig dynamicTaskConfig;

    String cron = "";

    /**
     * 程序初始化默认启动定时任务
     * @throws Exception
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        testTask();
    }

    public void testTask() {
        String taskName = "testTask";
        cron = "0 30 22 * * ? ";
        //判断数据库中是否已经保存了定时时间的配置，有就从数据库中取出赋值给cron,没有就将默认cron的值存入数据库 
        
        //开始定时任务    
        dynamicTaskConfig.startCron(taskName, new Runnable() {
            @Override
            public void run() {
               //业务逻辑
            }
        }, cron);
    }
}