开发者

springboot使用TaskScheduler实现动态增删启停定时任务方式

目录
  • TaskScheduler
    • 概述
    • 接口的6种方法
      • 6、scheduleWithFixedDelay(Runnable task, Date startTime, long delay);
    • 接口5个实现类
    • spring boot使用TaskScheduler实现动态增删启停定时任务
      • SchedulingConfig:添加执行定时任务的线程池配置类
        • ScheduledTask:添加ScheduledFuture的包装类
          • SchedulingRunnable:添加Runnable接口实现类
            • CronTaskRegistrar:添加定时任务注册类,用来增加、删除定时任务
              • CronUtils:校验Cron表达式的有效性
                • ScheduleResult:添加定时任务实体类
                  • ScheduleJobStatus:任务状态枚举类型
                    • SpringContextUtils类:从spring容器里获取bean
                      • ScheduleJobService:增删启停service方法
                        • cronController:访问接口
                          • c1:测试bean
                            • init:项目启动后的定时任务
                            • 总结

                              TaskScheduler

                              概述

                              TaskScheduler是spring 3.0版本后,自带了一个定时任务工具,不用配置文件,可以动态改变执行状态。也可以使用cron表达式设置定时任务。

                              被执行的类要实现Runnable接口

                              TaskScheduler是一个接口,它定义了6个方法

                              springboot使用TaskScheduler实现动态增删启停定时任务方式

                              接口的6种方法

                              public interface TaskScheduler { 
                              
                              /** 
                              * 提交任务调度请求 
                              * @param task 待执行任务   
                              * @param trigger 使用Trigger指定任务调度规则 
                              * @return 
                              */
                              ScheduledFuture schedule(Runnable task, Trigger trigger);
                              
                              /** 
                              * 提交任务调度请求 
                              * 注意任务只执行一次,使用startTime指定其启动时间  
                              * @param task 待执行任务 
                              * @param startTime 任务启动时间 
                              * @return 
                              */
                              ScheduledFuture schedule(Runnable task, Date startTime);
                              
                              
                              /** 
                              * 使用fixedRate的方式提交任务调度请求 
                              * 任务首次启动时间由传入参数指定 
                              * @param task 待执行的任务  
                              * @param startTime 任务启动时间 
                              * @param period 两次任务启动时间之间的间隔时间,默认单位是毫秒 
                              * @return 
                              */
                              ScheduledFuture scheduleAtFixedRate(Runnable task, Date startTime, long period);
                              
                              /** 
                              * 使用fixedRate的方式提交任务调度请求 
                              * 任务首次启动时间未设置,任务池将会尽可能早的启动任务 
                              * @param task 待执行任务 
                              * @param period 两次任务启动时间之间的间隔时间,默认单位是毫秒 
                              * @return 
                              */
                              ScheduledFuture scheduleAtFixedRate(Runnable task, long period);
                              
                              /** 
                              * 使用fixedDelay的方式提交任务调度请求 
                              * 任务首次启动时间由传入参数指定 
                              * @param task 待执行任务 
                              * @param startTime 任务启动时间 
                              * @param delay 上一次任务结束时间与下一次任务开始时间的间隔时间,单位默认是毫秒 
                              * @return 
                              */
                              ScheduledFuture scheduleWithFixedDelay(Runnable task, Date startTime, long delay);
                              
                              /** 
                              * 使用fixedDelay的方式提交任务调度请求 
                              * 任务首次启动时间未设置,任务池将会尽可能早的启动任务 
                              * @param task 待执行任务 
                              * @param delay 上一次任务结束时间与下一次任务开始时间的间隔时间,单位默认是毫秒 
                              * @return 
                              */
                              ScheduledFuture scheduleWithFixedDelay(Runnable task, long delay);
                              }

                              0、ThreadPoolTaskScheduler

                              在 ThreadPoolTaskSchedulerConfig 中定义 ThreadPoolTaskScheduler bean

                              @Configuration
                              public class ThreadPoolTaskSchedulerConfig {
                              
                                  @Bean
                                  public ThreadPoolTaskScheduler threadPoolTaskScheduler(){
                                      ThreadPoolTaskScheduler threadPoolTaskScheduler
                                        = new ThreadPoolTaskScheduler();
                                      threadPoolTaskScheduler.setPoolSize(5);
                                      threadPoolTaskScheduler.setThreadNamePrefix(
                                        "ThreadPoolTaskScheduler");
                                      return threadPoolTaskScheduler;
                                  }
                              }

                              配置的 bean threadPoolTaskScheduler 可以根据配置的池大小 5 异步执行任务。

                              请注意,所有与 ThreadPoolTaskScheduler 相关的线程名称都将以ThreadPoolTaskScheduler 为前缀。

                              让我们实现一个简单的任务,然后我们可以安排:

                              class RunnableTask implements Runnable{
                                  private String message;
                                  
                                  public RunnableTask(String message){
                                      this.message = message;
                                  }
                                  
                                  @Override
                                  public void run() {
                                      System.out.println(new Date()+" Runnable Task with "+message
                                        +" on thread "+Thread.currentThread().getName());
                                  }
                              }

                              1、schedule(Runnable task, Trigger trigger)

                              指定一个触发器执行定时任务。可以使用CronTrigger来指定Cron表达式,执行定时任务

                              如下:使用CronTrigger 来根据 cron 表达式调度任务,可以使用提供的触发器按照某个指定的节奏或时间表运行任务,在这种情况下,RunnableTask 将在每分钟的第 10 秒执行。

                              taskScheduler.schedule(new RunnableTask("Cron Trigger"), cronTrigger);

                              2、schedule(Runnable task, Date startTime);

                              指定一个具体时间点执行定时任务,可以动态的指定时间,开启任务,只执行一次

                              如下:配置一个任务在 1000 毫秒的固定延迟后运行,RunnableTask 将始终在一次执行完成和下一次执行开始之间运行 1000 毫秒。

                              taskScheduler.schedule(
                                new Runnabletask("Specific time, 3 Seconds from now"),
                                new Date(System.currentTimeMillis + 3000)
                              );

                              3、scheduleAtFixedRate(Runnable task, long period);

                              立即执行,循环任务,指定一个执行周期(毫秒计时)

                              PS:不管上一个周期是否执行完,到时间下个周期就开始执行

                              如下:安排一个任务以固定的毫秒速率运行,下一个 RunnableTask 将始终在 2000 毫秒后运行,而不管上次执行的状态如何,它可能仍在运行。

                              taskScheduler.scheduleAtFixedRate(
                                new RunnableTask("Fixed Rate of 2 seconds") , 
                                2000);

                              4、scheduleAtFixedRate(Runnable task, Date startTime, long period);

                              指定时间开始执行,循环任务,指定一个间隔周期(毫秒计时)

                              PS:不管上一个周期是否执行完,到时间下个周期就开始执行

                              如下:使用CronTrigger 来根据 cron 表达式调度任务,可以使用提供的触发器按照某个指定的节奏或时间表运行任务,在这种情况下,RunnableTask 将在每分钟的第 10 秒执行。

                              taskScheduler.scheduleAtFixedRate(new RunnableTask(
                                "Fixed Rate of 2 seconds"), new Date(), 3000);

                              5、scheduleWithFixedDelay(Runnable task, long delay);

                              立即执行,循环任务,指定一个间隔周期(毫秒计时)

                              PS:上一个周期执行完,等待delay时间,下个周期开始执行

                              如下:配置一个任务在 1000 毫秒的固定延迟后运行,RunnableTask 将始终在一次执行完成和下一次执行开始之间运行 1000 毫秒。

                              taskScheduler.scheduleWithFixedDelay(
                                new RunnableTask("Fixed 1 second Delay"), 
                                1000);

                              6、scheduleWithFixedDelay(Runnable task, Date startTime, long delay);

                              指定时间开始执行,循环任务,指定一个间隔周期(毫秒计时)

                              PS:上一个周期执行完,等待delay时间,下个周期开始执行

                              如下:将任务配置为在给定开始时间的固定延迟后运行,RunnableTask 将在指定的执行时间被调用,其中包括 @PostConstruct 方法开始的时间,随后延迟 1000 毫秒。

                              taskScheduler.scheduleWithFixedDelay(
                                new RunnableTask("Current Date Fixed 1 second Delay"),
                                new Date(),
                                1000);

                              接口5个实现类

                              springboot使用TaskScheduler实现动态增删启停定时任务方式

                              1、ConcurrentTaskScheduler

                              以当前线程执行任务,如果任务简单,可以直接使用这个类来执行,快捷方便

                              • 单线程运行
                              public class LocTest implements Runnable {
                                private ConcurrentTaskScheduler concurrentTaskScheduler = new ConcurrentTaskScheduler();
                                private void start() {
                                  concurrentTaskScheduler.schedule(this, new Date());
                                }
                                public void run() {
                                  Thread thread = Thread.currentThread();
                                  System.out.println("current id:" + thread.getId());
                                  System.out.println("current name:" + thread.getName());
                                }
                                public static void main(String[] args) {
                                  new LocTest().start();
                                }
                              }

                              2、DefaultManagedTaskScheduler

                              以当前线程执行任务,是ConcurrentTaskScheduler的子类,添加了JNDI的支持。

                              和ConcurrentTaskScheduler一样的用法,需要使用JNDI可以单独设置

                              3、ThreadPoolTaskScheduler

                              TaskScheduler接口的默认实现类,多线程定时任务执行。可以设置执行线程池数(默认一个线程)

                              • 使用前必须得先调用initialize()【初始化方法】
                              • shutDown()方法,执行完后可以关闭线程

                              除实现了TaskScheduler接口中的方法外,它还包含了一些对ScheduledThreadPoolExecutor进行操作的接口,其常用方法如下:

                              • setPoolSize:设置线程池大小,最小为1,默认情况下也为1;
                              • setErrorHandler :设置异常处理器。
                              • getScheduledThreadPoolExecutor :获取ScheduledExecutor,默认ScheduledThreadPoolExecutor类型。
                              • getActiveCount :获取当前活动的线程数
                              • execute : 提交执行一次的任务
                              • submit\submitListenable :提交执行一次的任务,并且返回一个Future对象供判断任务状态使用
                              public class LocTest implements Runnable {
                              	private ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
                              	private void start() {
                              		taskScheduler.setPoolSize(10);
                              		//必须得先初始化,才能使用
                              		taskScheduler.initialize();
                              		taskScheduler.schedule(this, new Date());
                              	}
                              	public void run() {
                              		Thread ct = Thread.currentThread();
                              		System.out.println("current id:"+ct.getId());
                              		System.out.println("current name:"+ct.getName());
                              	}
                              	public static void main(String[] args) {
                              		new LocTest().start();
                              	}
                              }

                              4、TimerManagerTaskScheduler

                              用于包装CommonJ中的TimerManager接口。

                              在使用CommonJ进行调度时使用

                              spring boot使用TaskScheduler实现动态增删启停定时任务

                              SchedulingConfig:添加执行定时任务的线程池配置类

                              import org.springframework.context.annotation.Bean;
                              import org.springframework.context.annotation.Configuration;
                              import org.springframework.scheduling.TaskScheduler;
                              import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
                              
                              @Configuration
                              public class SchedulingConfig {
                              
                                  @Bean
                                  public TaskScheduler taskScheduler() {
                                      ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
                                      // 定时任务执行线程池核心线程数
                                      taskScheduler.setPoolSize(4);
                                      taskScheduler.setRemoveOnCancelPolicy(true);
                                      taskScheduler.setThreadNamePrefix("TaskSchedulerThreadPool-");
                                      return taskScheduler;
                                  }
                              }

                              ScheduledTask:添加ScheduledFuture的包装类

                              ScheduledFuture是ScheduledExecutorService定时任务线程池的执行结果。

                              import Java.util.concurrent.ScheduledFuture;
                              public final class ScheduledTask {
                                  volatile ScheduledFuture<?> future;
                              
                                  /**
                                   * 取消定时任务
                                   */
                                  public void cancel() {
                                      ScheduledFuture<?> future = this.future;
                                      if (future != null) {
                                          future.cancel(true);
                                      }
                                  }
                              }

                              SchedulingRunnable:添加Runnable接口实现类

                              添加Runnable接口实现类,被定时任务线程池调用,用来执行指定bean里面的方法

                              import org.apache.commons.lang.StringUtils;
                              import org.slf4j.Logger;
                              import org.slf4j.LoggerFactory;
                              import org.springframework.util.ReflectionUtils;
                              
                              import java.lang.reflect.Method;
                              import java.util.Objects;
                              
                              
                              public class SchedulingRunnable implements Runnable {
                              
                                  private static final Logger logger = LoggerFactory.getLogger(SchedulingRunnable.class);
                              
                                  private final String beanName;
                              
                                  private final String methodName;
                              
                                  private final String params;
                              
                                  public SchedulingRunnable(String beanName, String methodName) {
                                      this(beanName, methodName, null);
                                  }
                              
                                  public SchedulingRunnable(String beanName, String methodName, String params) {
                                      this.beanName = beanName;
                                      this.methodName = methodName;
                                      this.params = params;
                                  }
                              
                              
                              
                                  @Override
                                  public void run() {
                                      logger.info("定时任务开始执行 - bean:{},方法:{},参数:{}", beanName, methodName, params);
                                      long startTime = System.currentTimeMillis();
                              
                                      try {
                                          Object target = SpringContextUtils.getBean(beanName);
                              
                                          Method method = null;
                                          if (StringUtils.isNotEmpty(params)) {
                                              method = target.getClass().getDeclaredMethod(methodName, String.class);
                                          } else {
                                              method = target.getClass().getDeclaredMethod(methodName);
                                          }
                              
                                          ReflectionUtils.makeAccessible(method);
                                          if (StringUtils.isNotEmpty(params)) {
                                              method.invoke(target, params);
                                          } else {
                                              method.invoke(target);
                                          }
                                      } catch (Exception ex) {
                                          logger.error(String.format("定时任务执行异常 - bean:%s,方法:%s,参数:%s ", beanName, methodName, params), ex);
                                      }
                              
                                      long times = System.currentTimeMillis() - startTime;
                                      logger.info("定时任务执行结束 - bean:{},方法:{},参数:{},耗时:{} 毫秒", beanName, methodName, params, times);
                                  }
                              
                                  @Override
                                  public boolean equals(Object o) {
                                      if (this == o) return true;
                                      if (o == null || getClass() != o.getClass()) return false;
                                      SchedulingRunnable that = (SchedulingRunnable) o;
                                      if (params == null) {
                                          return beanName.equals(that.beanName) &&
                                                  methodName.equals(that.methodName) &&
                                                  that.params == null;
                                      }
                              
                                      return beanName.equals(that.beanName) &&
                                              methodName.equals(that.methodName) &&
                                              params.equals(that.params);
                                  }
                              
                                  @Override
                                  public int hashCode() {
                                      if (params == null) {
                                          return Objects.hash(beanName, methodName);
                                      }
                              
                                      return Objects.hash(beanName, methodName, params);
                                  }
                              }

                              CronTaskRegistrar:添加定时任务注册类,用来增加、删除定时任务

                              import com.example.testspringboot.cron.ScheduleResult;
                              import org.springframework.beans.factory.DisposableBean;
                              import org.springframework.beans.factory.annotation.Autowired;
                              import org.springframework.scheduling.TaskScheduler;
                              import org.springframework.scheduling.config.CronTask;
                              import org.springframework.stereotype.Component;
                              
                              jsimport java.util.*;
                              import java.util.concurrent.ConcurrentHashMap;
                              
                              /**
                               * 添加定时任务注册类,用来增加、删除定时任务。
                               */
                              @Component
                              public class CronTaskRegistrar implements DisposableBean {
                              
                                  private final Map<Runnable, ScheduledTask> scheduledTasks = new ConcurrentHashMap<>(16);
                                  private final Map<Integer, ScheduleResult> schedulerJob = new HashMap<>();
                                  @Autowired
                                  private TaskScheduler taskScheduler;
                              
                                  public TaskScheduler getScheduler() {
                                      return this.taskScheduler;
                                  }
                              
                                  public void addCronTask(ScheduleResult scheduleResult) {
                                      SchedulingRunnab编程客栈le task = new SchedulingRunnable(scheduleResult.getBeanName(), scheduleResult.getMethodName(), scheduleResult.getMethodParams());
                                      String cronExpression = scheduleResult.getCronExpression();
                              
                                      CronTask cronTask = new CronTask(task, cronExpression);
                                      // 如果当前包含这个任务,则移除
                                      if (this.scheduledTasks.containsKey(task)) {
                                          removeCronTask(scheduleResult.getBeanName(), scheduleResult.getMethodName(), scheduleResult.getMethodParams());
                                      }
                                      schedulerJob.put(scheduleResult.getJobId(), scheduleResult);
                                      this.scheduledTasks.put(task, scheduleCronTask(cronTask));
                                  }
                              
                                  public void removeCronTask(String beanName, String methodName, String methodParams) {
                                      SchedulingRunnable task = new SchedulingRunnable(beanName, methodName, methodParams);
                                      ScheduledTask scheduledTask = this.scheduledTasks.remove(task);
                                      if (scheduledTask != null) {
                                          scheduledTask.cancel();
                                      }
                                  }
                              
                                  public void removeCronTask(ScheduleResult scheduleResult) {
                                      schedulerJob.put(scheduleResult.getJobId(), scheduleResult);
                                      removeCronTask(scheduleResult.getBeanName(), scheduleResult.getMethodName(), scheduleResult.getMethodParams());
                                  }
                              
                                  public ScheduledTask scheduleCronTask(CronTask cronTask) {
                                      ScheduledTask scheduledTask = new ScheduledTask();
                                      scheduledTask.future = this.taskScheduler.schedule(cronTask.getRunnable(), cronTask.getTrigger());
                                      return scheduledTask;
                                  }
                              
                              
                                  public Map<Runnable, ScheduledTask> getScheduledTasks() {
                                      return scheduledTasks;
                                  }
                              
                                  public Map<Integer, ScheduleResult> getSchedulerJob() {
                                      return schedulerJob;
                                  }
                              
                                  @Override
                                  public void destroy() {
                                      for (ScheduledTask task : this.scheduledTasks.values()) {
                                          task.cancel();
                                      }
                              
                                      this.scheduledTasks.clear();
                                  }
                              
                                  public ScheduleResult getSchedulerByJobId(Integer jobId) {
                                      for (ScheduleResult job : findAllTask()) {
                                          if (jobId.equals(job.getJobId())) {
                                              return job;
                                          }
                                      }
                                      return null;
                                  }
                              
                                  public List<ScheduleResult> findAllTask() {
                                      List<ScheduleResult> ScheduleResults = new ArrayList<>();
                                      Set<Map.Entry<Integer, ScheduleResult>> entries = schedulerJob.entrySet();
                                      for (Map.Entry<Integer, ScheduleResult> en : entries) {
                                          ScheduleResults.add(en.getValue());
                                      }
                                      return ScheduleResults;
                                  }
                              
                              
                              }

                              CronUtils:校验Cron表达式的有效性

                              import org.springframework.scheduling.support.CronExpression;
                              
                              public class CronUtils {
                                  /**
                                   * 返回一个布尔值代表一个给定的Cron表达式的有效性
                                   *
                                   * @param cronExpression Cron表达式
                                   * @return boolean 表达式是否有效
                                   */
                                  public static boolean isValid(String cronExpression) {
                                      return CronExpression.isValidExpression(cronExpression);
                                  }
                              
                              
                              }

                              ScheduleResult:添加定时任务实体类

                              import lombok.Data;
                              
                              
                              @Data
                              public class ScheduleResult {
                                  /**
                                   * 任务ID
                                   */
                                  private Integer jobId;
                                  /**
                                   * bean名称
                                   */
                                  private String beanName;
                                  /**
                                   * 方法名称
                                   */
                                  private String methodName;
                                  /**
                                   * 方法参数: 执行service里面的哪一种方法
                                   */
                                  private String methodParams;
                                  /**
                                   * cron表达式
                                   */
                                  private String cronExpression;
                                  /**
                                   * 状态(1正常 0暂停)
                                   */
                                  private Integer jobStatus;
                                  /**
                                   * 备注
                                   */
                                  private String remark;
                                  /**
                                   * 创建时间
                                   */
                                  private String createTime;
                                  /**
                                   * 更新时间
                                   */
                                  private String updateTime;
                              
                              }

                              ScheduleJobStatus:任务状态枚举类型

                              public enum ScheduleJobStatus {
                                  /**
                                   * 暂停
                                   */
                                  PAUSE,
                              
                                  /**
                                   * 正常
                                   */
                                  NORMAL;
                              
                              }
                              

                              SpringContextUtils类:从spring容器里获取bean

                              import org.springframework.beans.BeansException;
                              import org.springframework.context.ApplicationContext;
                              import org.springframework.context.ApplicationContextAware;
                              import org.springframework.stereotype.Component;
                              
                              @Component
                              public class SpringContextUtils implements ApplicationContextAware {
                              
                                  private static ApplicationContext applicationContext = null;
                              
                                  @Override
                                  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
                                      if (SpringContextUtils.applicationContext == null) {
                                          SpringContextUtils.applicationContext = applicationContext;
                                      }
                                  }
                              
                                  public static ApplicationContext getApplicationContext() {
                                      return applicationContext;
                                  }
                              
                                  // 通过name获取 Bean.
                                  public static Object getBean(String name) {
                                      return getApplicationContext().getBean(name);
                              
                                  }
                              
                                  // 通过class获取Bean.
                                  public static <T> T getBean(Class<T> clazz) {
                                      return getApplicationContext().getBean(clazz);
                              
                                  }
                              
                                  // 通过name,以及Clazz返回指定的Bean
                                  public static <T> T getBean(String name, Class<T> clazz) {
                                      return getApplicationContext().getBean(name, clazz);
                                  }
                              
                                  public static boolean containsBean(String name) {
                                      return getApplicationContext().containsBean(name);
                                  }
                              
                                  public static boolean isSingleton(String name) {
                                      return getApplicationContext().isSingleton(name);
                                  }
                              
                                  public static Class<? extends Object> getType(String name) {
                                      return getApplicationContext().getType(name);
                                  }
                              }

                              ScheduleJobService:增删启停service方法

                              @Service
                              @Slf4j
                              public class ScheduleJobService {
                              
                              
                                  @Autowired
                                  private CronTaskRegistrar cronTaskRegistrar;
                              
                                  public void addScheduleJob(ScheduleResult scheduleResult) {
                                      long currentTimeMillis = System.currentTimeMillis();
                                      scheduleResult.setCreateTime(formatTimeYMD_HMS_SSS(currentTimeMillis));
                                      scheduleResult.setUpdateTime(formatTimeYMD_HMS_SSS(currentTimeMillis));
                                      scheduleResult.setJobId(findAllTask().size() + 1);
                                      if (scheduleResult.getJobStatus().equals(ScheduleJobStatus.NORMAL.ordinal())) {
                                          log.info("Stop or pause: is now on");
                                          cronTaskRegistrar.addCronTask(scheduleResult);
                                          return;
                                      }
                                      cronTaskRegistrar.getSchedulerJob().put(scheduleResult.getJobId(), scheduleResult);
                                  }
                              
                                  public void editScheduleJob(ScheduleResult currentSchedule) {
                                      //先移除
                                      cronTaskRegistrar.removeCronTask(currentSchedule.getBeanName(), currentSchedule.getMethodName(), currentSchedule.getMethodParams());
                                      ScheduleResult pastScheduleJob = cronTaskRegistrar.getSchedulerByJobId(currentSchedule.getJobId());
                                      if (pastScheduleJob == null) {
                                          System.out.println("没有这个任务");
                                          return;
                                      }
                                      //然后判断是否开启, 如果开启的话,现在立即执行
                                      startOrStopSchedulerJob(currentSchedule, true);
                                  }
                              
                                  public void deleteScheduleJob(ScheduleResult scheduleResult) {
                                      // 清除这个任务
                                      cronTaskRegistrar.removeCronTask(scheduleResult.getBeanName(), scheduleResult.getMethodName(), scheduleResult.getMethodParams());
                                      // 清除这个任务的数据
                                      cronTaskRegistrar.getSchedulerJob().remove(scheduleResult.getJobId());
                                  }
                              
                                  public void startOrStopScheduler(ScheduleResult scheduleResult) {
                                      cronTaskRegistrar.getSchedulerJob().get(scheduleResult.getJobId()).setJobStatus(scheduleResult.getJobStatus());
                                      startOrStopSchedulerJob(scheduleResult, false);
                                  }
                              
                                  private void startOrStopSchedulerJob(ScheduleResult scheduleResult, boolean update) {
                                      // 更新时间
                                      scheduleResult.setUpdateTime(formatTimeYMD_HMS_SSS(System.currentTimeMillis()));
                                      if (scheduleResult.getJobStatus().equals(ScheduleJobStatus.NORMAL.ordinal())) {
                                          System.out.println("停止或暂停:现在是开启");
                                          cronTaskRegistrar.addCronTask(scheduleResult);
                                          return;
                                      }
                                      System.out.println("停止或暂停:现在是暂停");
                                      if (update){
                                          cronTaskRegistrar.removeCronTask(scheduleResult);
                                          return;
                                      }
                                      cronTaskRegistrar.removeCronTask(scheduleResult.getBeanName(), scheduleResult.getMethodName(), scheduleResult.getMethodParams());
                                  }
                              
                                  public List<ScheduleResult> findAllTask() {
                                      return cronTaskRegistrar.findAllTask();
                                  }
                              
                              
                                  // 转换为年-月-日 时:分:秒
                                  private String formatTimeYMD_HMS_SSS(long time) {
                                      return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS").format(time);
                                  }
                              
                              }

                              cronController:访问接口

                              import com.example.testspringboot.cron.ScheduleResult;
                              import com.example.testspringboot.cron.ScheduleJobService;
                              import com.example.testspringboot.cron.utils.CronUtils;
                              import com.google.gson.Gson;
                              import org.springframework.beans.factory.annotation.Autowired;
                              import org.springframework.web.bind.annotation.*;
                              
                              import java.util.List;
                              
                              @RestController
                              public class cronController {
                                  @Autowired
                                  private ScheduleJobService scheduleJobService;
                                  /**
                                   * 测试上传的用例文件, 获取详细执行结果
                                   */
                                  @PostMapping("/add")
                                  void executeTestOneFile(@RequestBody ScheduleResult scheduleResult) {
                                      boolean valid = CronUtils.isValid(sche编程duleResult.getCronExpression());
                                      if (valid){
                                          System.out.println("校验成功, 添加任务");
                                          scheduleResult.setMethodParams(scheduleResult.getBranch()+scheduleResult.getCaseDir());
                                          scheduleJobService.addScheduleJob(scheduleResult)编程客栈;
                                      }else {
                                          System.out.println("校验失败");
                                      }
                                  }
                              
                                  @PostMapping("/stop")
                                  void end(@RequestBody ScheduleResult scheduleResult) {
                                      Gson gson = new Gson();
                              
                                    js  System.out.println("================");
                                      System.out.println(scheduleResult);
                                      System.out.println("=================");
                                      scheduleResult.setJobStatus(0);
                                      scheduleJobService.startOrStopScheduler(scheduleResult);
                                  }
                                  @PostMapping("/start")
                                  void start(@RequestBody ScheduleResult scheduleResult) {
                                      System.out.println("================");
                                      System.out.println(scheduleResult);
                                      System.out.println("=================");
                                      scheduleResult.setJobStatus(1);
                                      scheduleJobService.startOrStopScheduler(scheduleResult);
                                  }
                              
                                  @PostMapping("/edit")
                                  void edit(@RequestBody ScheduleResult scheduleResult) {
                                      System.out.println("=======edit=========");
                                      System.out.println(scheduleResult);
                                      System.out.println("=================");
                                      scheduleJobService.editScheduleJob(scheduleResult);
                                  }
                              
                                  @PostMapping("/delete")
                                  void delete(@RequestBody ScheduleResult scheduleResult) {
                                      System.out.println("=======delete=========");
                                      System.out.println(scheduleResult);
                                      System.out.println("=================");
                                      scheduleJobService.deleteScheduleJob(scheduleResult);
                                  }
                              
                                  @GetMapping("/tasks")
                                  List<ScheduleResult> get() throws Exception {
                                      List<ScheduleResult> allTask = scheduleJobService.findAllTask();
                                      System.out.println("现在的定时任务数量 = " + allTask.size());
                                      System.out.println("现在的定时任务 = " + allTask);
                                      return allTask;
                                  }
                              
                              
                              }
                              

                              c1:测试bean

                              import org.springframework.stereotype.Component;
                              
                              @Component
                              public class c1 {
                                  public void test1(String y){
                                      System.out.println("这个是test1的bean : " + y);
                                  }
                                  public void test2(){
                                      System.out.println("这个是test1的bean中test2方法");
                                  }
                              }
                              

                              init:项目启动后的定时任务

                              import com.example.testspringboot.cron.ScheduleJobService;
                              import com.example.testspringboot.cron.ScheduleResult;
                              import org.springframework.beans.factory.annotation.Autowired;
                              import org.springframework.boot.CommandLineRunner;
                              import org.springframework.stereotype.Component;
                              
                              @Component
                              public class init  implements CommandLineRunner {
                                  @Autowired
                                  private ScheduleJobService scheduleJobService;
                              
                                  @Override
                                  public void run(String... args) throws Exception {
                                      System.out.println("开始珍惜");
                                      ScheduleResult scheduleResult = new ScheduleResult();
                                      scheduleResult.setBeanName("c1");
                                      scheduleResult.setMethodName("test1");
                                      scheduleResult.setCronExpression("0/25 * * * * *");
                                      scheduleResult.setJobStatus(1);
                                      scheduleResult.setMethodParams("test1");
                                      scheduleJobService.addScheduleJob(scheduleResult);
                                      scheduleJobService.findAllTask();
                                  }
                              }
                              

                              后续的操作,基本上就是复制粘贴,运行

                              总结

                              以上为个人经验,希望能给大家一个参考,也希望大家多多支持编程客栈(www.devze.com)。

                              0

                              上一篇:

                              下一篇:

                              精彩评论

                              暂无评论...
                              验证码 换一张
                              取 消

                              最新开发

                              开发排行榜