spring 不停止服务 动态修改定时任务schedul

包含两种方式

@Configuration
public class ScheduledConfig {
    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
        threadPoolTaskScheduler.setPoolSize(3);
        threadPoolTaskScheduler.setRemoveOnCancelPolicy(true);
        return threadPoolTaskScheduler;
    }
}

public class ScheduledFutureHolder {
    private ScheduledFuture scheduledFuture;

    private Class runnableClass;

    private String corn;

    public ScheduledFuture getScheduledFuture() {
        return scheduledFuture;
    }

    public void setScheduledFuture(ScheduledFuture scheduledFuture) {
        this.scheduledFuture = scheduledFuture;
    }

    public Class getRunnableClass() {
        return runnableClass;
    }

    public void setRunnableClass(Class runnableClass) {
        this.runnableClass = runnableClass;
    }

    public String getCorn() {
        return corn;
    }

    public void setCorn(String corn) {
        this.corn = corn;
    }

    @Override
    public String toString() {
        return "ScheduledFutureHolder{" +
                "scheduledFuture=" + scheduledFuture +
                ", runnableClass=" + runnableClass +
                ", corn='" + corn + ''' +
                '}';
    }
}

public class DatabaseBackupTask implements Runnable {

    @Override
    public void run() {
        System.out.println(new Date()+"定时任务执行............");
    }
}

// 前端传入控制

@RestController
public class DoScheduledController {
    @Autowired
    private ThreadPoolTaskScheduler threadPoolTaskScheduler;

    //存储任务执行的包装类
    private HashMap scheduleMap = new HashMap<>();

    
   @GetMapping("/start")
    public void startTask(String className, String corn)  {
        try {
            //判断当前任务是否已经在计划列表，在的话不再重复加载
            if (scheduleMap.containsKey(className)) {
                System.out.println("当前任务已存在，不再重复加载。如需修改任务执行间隔，请调用restart接口");
                return;
            }
            //初始化一个任务（这里可以初始话多个）
            Runnable helloTask =(Runnable) Class.forName(className).newInstance();
            //将任务交给任务调度器执行
            ScheduledFuture schedule = threadPoolTaskScheduler.schedule(helloTask, new CronTrigger(corn));
            //将任务包装成ScheduledFutureHolder
            ScheduledFutureHolder scheduledFutureHolder = new ScheduledFutureHolder();
            scheduledFutureHolder.setScheduledFuture(schedule);
            scheduledFutureHolder.setRunnableClass(helloTask.getClass());
            scheduledFutureHolder.setCorn(corn);

            scheduleMap.put(scheduledFutureHolder.getRunnableClass().getName(),scheduledFutureHolder);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    @RequestMapping("/queryTask")
    public void queryTask(){
        scheduleMap.forEach((k,v)->{
            System.out.println(k+"  "+v);
        });
    }

    
    @RequestMapping("/stop/{className}")
    public void stopTask(@PathVariable  String className){
        if(scheduleMap.containsKey(className)){//如果包含这个任务
            ScheduledFuture scheduledFuture = scheduleMap.get(className).getScheduledFuture();
            if(scheduledFuture!=null){
                scheduledFuture.cancel(true);
            }
        }
    }


    
   @GetMapping("/restart")
    public void restartTask(String className, String corn) throws InstantiationException, IllegalAccessException {
        if(scheduleMap.containsKey(className)){//如果包含这个任务
            ScheduledFutureHolder scheduledFutureHolder = scheduleMap.get(className);
            ScheduledFuture scheduledFuture = scheduledFutureHolder.getScheduledFuture();
            if(scheduledFuture!=null){
                //先停掉任务
                scheduledFuture.cancel(true);
                //修改触发时间重新启动任务
                Runnable runnable = scheduledFutureHolder.getRunnableClass().newInstance();
                ScheduledFuture schedule = threadPoolTaskScheduler.schedule(runnable, new CronTrigger(corn));
                scheduledFutureHolder.setScheduledFuture(schedule);
                scheduledFutureHolder.setCorn(corn);
                scheduleMap.put(scheduledFutureHolder.getRunnableClass().getName(),scheduledFutureHolder);
            }
        }
    }
}

@Lazy(false)
@Component
@EnableScheduling
public class SpringDynamicCornTask implements SchedulingConfigurer {
    private static final Logger logger = LoggerFactory.getLogger(SpringDynamicCornTask.class);
    private static String cron = "* * * 31 2 ?";
    public SpringDynamicCornTask() {
    }

    public void setCron(String cron) {
        this.cron = cron;
    }

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.addTriggerTask(new Runnable() {

            @Override
            public void run() {
                // 任务逻辑
                logger.info("定时任务进行中...");
            }
        }, new Trigger() {

            @Override
            public Date nextExecutionTime(TriggerContext triggerContext) {
                // 任务触发，可修改任务的执行周期
                CronTrigger trigger = new CronTrigger(cron);
                Date nextExecutionTime = trigger.nextExecutionTime(triggerContext);
                return nextExecutionTime;
            }
        });
    }
}

// controller层


@GetMapping ("changeScheduled")
    public String changeScheduled(String cron){
        springDynamicCornTask.setCron(cron);
        return "suc";
    }