0
0

SpringBoot创建动态定时任务的几种方式

一、使用 @Scheduled 注解

  1.     @Scheduled 是 Spring 提供的一个注解，用于标记需要定时执行的方法。常见的属性包括：
  • cron ：通过 Cron 表达式定义任务的执行时间。
  • fixedRate ：定义任务的固定执行频率，以毫秒为单位。
  • fixedDelay ：定义任务在前一次执行完毕后延迟多少毫秒再执行。

代码示例：

  1. import org.springframework.scheduling.annotation.Scheduled;
  2. import org.springframework.stereotype.Component;
  4. @Component
  5. public class ScheduledTasks {
  7.     @Scheduled(cron = "0 0 * * * ?") // 每小时整点执行一次
  8.     public void reportCurrentTime() {
  9.         System.out.println("现在时间：" + System.currentTimeMillis());
  10.     }
  12.     @Scheduled(fixedRate = 5000) // 每5秒执行一次
  13.     public void fixedRateTask() {
  14.         System.out.println("每5秒执行一次任务：" + System.currentTimeMillis());
  15.     }
  17.     @Scheduled(fixedDelay = 7000) // 前一次执行完毕后延迟7秒执行
  18.     public void fixedDelayTask() {
  19.         System.out.println("延迟7秒后执行任务：" + System.currentTimeMillis());
  20.     }
  21. }
  1.     @Scheduled 适用于大多数简单的定时任务场景，如定时发送邮件或生成报告等。然而，它的灵活性较差，对于复杂的任务调度需求，或需要动态调整任务时间的场景，可能并不适用。

二、使用 SchedulingConfigurer 接口

  1.     SchedulingConfigurer 接口允许我们通过编程方式配置任务调度器（TaskScheduler）。通过实现这个接口，我们可以灵活地设置任务的调度规则，甚至动态地添加或移除任务。

简单使用代码：

  1. public class TaskConfig implements SchedulingConfigurer {
  2.     
  3.     @Override
  4.     public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
  5.         scheduledTaskRegistrar.addTriggerTask(
  6.                 //1.添加任务内容(Runnable)
  7.                 () -> System.out.println("执行定时任务2: " + LocalDateTime.now().toLocalTime()),
  8.                 //2.设置执行周期(Trigger)
  9.                 triggerContext -> {
  10.                     //2.1 从数据库获取执行周期
  11.                     String cron = zhyMapper.getCron();
  12.                     //2.2 合法性校验.
  13.                     if (StringUtils.isEmpty(cron)) {
  14.                         // Omitted Code ..
  15.                     }
  16.                     //2.3 返回执行周期(Date)
  17.                     return new CronTrigger(cron).nextExecutionTime(triggerContext);
  18.                 }
  19.         );
  20.  
  21.     }
  22. }

详细增删该查操作：

  • 动态注册bean
  1. public class ApplicationContextUtils implements ApplicationContextAware {
  3.     private static ApplicationContext CONTEXT;
  4.     /**
  5.      * 设置spring上下文
  6.      * @param ctx spring上下文
  7.      * @throws BeansException
  8.      * */
  9.     @Override
  10.     public void setApplicationContext(ApplicationContext ctx) throws BeansException {
  11.         CONTEXT = ctx;
  12.     }
  14.     /**
  15.      * 获取容器
  16.      * @return
  17.      */
  18.     public static ApplicationContext getApplicationContext() {
  19.         return CONTEXT;
  20.     }
  22.     /**
  23.      * 获取容器对象
  24.      * @param type
  25.      * @param <T>
  26.      * @return
  27.      */
  28.     public static <T> T getBean(Class<T> type) {
  29.         return CONTEXT.getBean(type);
  30.     }
  32.     public static <T> T getBean(String name,Class<T> clazz){
  33.         return CONTEXT.getBean(name, clazz);
  34.     }
  36.     public static Object getBean(String name){
  37.         return CONTEXT.getBean(name);
  38.     }
  40.     /**
  41.      * springboot动态注册bean
  42.      * @param clazz
  43.      * @param <T>
  44.      * @return
  45.      */
  46.     public static <T> T register(Class<T> clazz) {
  47.         ConfigurableApplicationContext configurableApplicationContext = (ConfigurableApplicationContext) ApplicationContextUtils.getApplicationContext();
  48.         DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) configurableApplicationContext.getBeanFactory();
  49.         BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(clazz);
  50.         if(defaultListableBeanFactory.getBeanNamesForType(clazz).length > 0) {
  51.             return defaultListableBeanFactory.getBean(clazz);
  52.         }
  53.         defaultListableBeanFactory.registerBeanDefinition(clazz.getName(), beanDefinitionBuilder.getRawBeanDefinition());
  54.         return (T) ApplicationContextUtils.getBean(clazz.getName());
  55.     }
  56. }
  • 任务实体
  1. public class Job {
  3.     /**
  4.      * 任务id, 用于标识，默认使用全限定类名
  5.      */
  6.     private String jobId;
  8.     /**
  9.      * 任务名称, 默认简单类名
  10.      */
  11.     private String jobName;
  13.     /**
  14.      * cron表达式, 修改后即可生效
  15.      */
  16.     private String cron;
  18.     /**
  19.      * 任务描述
  20.      */
  21.     private String description;
  23.     /**
  24.      * 是否启用, 默认启用, 修改后即可生效
  25.      */
  26.     private boolean enable = true;
  28.     /**
  29.      * 是否处于等待执行下个任务的状态
  30.      */
  31.     private boolean active;
  32.     /**
  33.      * 任务运行类
  34.      */
  35.     private Class<? extends Runnable> clazz;
  36. }
  • 操作类
  1. public class JobHandler {
  3.     private ScheduledTask scheduledTask;
  5.     private TriggerTask triggerTask;
  7.     private TriggerContext triggerContext;
  8. }
  • 配置SchedulingConfigurer
  1. public class JobSchedulingConfigurer implements SchedulingConfigurer {
  3.     private ScheduledTaskRegistrar registrar;
  5.     /**
  6.      * 线程池任务调度器
  7.      */
  8.     @Bean
  9.     public TaskScheduler taskScheduler() {
  10.         ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
  11.         scheduler.setPoolSize(Runtime.getRuntime().availableProcessors() / 3 + 1);
  12.         scheduler.setThreadNamePrefix("TaskScheduler-");
  13.         scheduler.setRemoveOnCancelPolicy(true);  // 保证能立刻丢弃运行中的任务
  15.         taskScheduler = scheduler; // 获取 句柄，方便后期获取 future
  17.         return scheduler;
  18.     }
  20.     @Override
  21.     public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
  22.         scheduledTaskRegistrar.setTaskScheduler(taskScheduler());
  23.         this.registrar = scheduledTaskRegistrar;
  24.     }
  26.     public ScheduledTaskRegistrar getRegistrar() {
  27.         return registrar;
  28.     }
  30.     public void setRegistrar(ScheduledTaskRegistrar registrar) {
  31.         this.registrar = registrar;
  32.     }
  33. }
  • 增删改查
  1. public class SchedulerManager {
  3.     /**
  4.      * 任务容器
  5.      */
  6.     private Map<Job, JobHandler> tasks = new ConcurrentHashMap<>();
  8.     /**
  9.      * 任务注册
  10.      */
  11.     @Autowired
  12.     private JobSchedulingConfigurer register;
  14.     /**
  15.      * 新增任务, 自生效
  16.      * @param job 任务实体
  17.      * @return 返回新增的任务
  18.      */
  19.     public Job addJob(Job job) {
  20.         Assert.notNull(job, "job can't be null");
  21.         ScheduledTaskRegistrar registrar = register.getRegistrar();
  22.         Runnable runnable = ApplicationContextUtils.register(job.getClazz());
  23.         if(job.getJobId() == null || "".equals(job.getJobId())) {
  24.             job.setJobId(job.getClazz().getName());
  25.         }
  26.         Assert.isNull(this.getJob(job.getJobId()), "任务[" + job.getJobId() + "]已存在");
  27.         if(job.getJobName() == null || "".equals(job.getJobName())) {
  28.             job.setJobName(ClassUtils.getShortName(job.getClazz()));
  29.         }
  30.         CronExpress cron = AnnotationUtils.findAnnotation(job.getClazz(), CronExpress.class);
  31.         if(cron != null && !"".equals(cron.value())) {
  32.             // 注解的属性，大于配置的属性，方便调试
  33.             job.setCron(cron.value());
  34.         }
  35.         job.setEnable(true);
  36.         job.setActive(true);
  37.         JobHandler entity = new JobHandler();
  38.         TriggerTask triggerTask = new TriggerTask(runnable, (TriggerContext triggerContext) -> {
  39.             // 每次任务执行均会进入此方法
  40.             CronTrigger trigger = new CronTrigger(job.getCron());
  41.             entity.setTriggerContext(triggerContext);
  42.             return job.isEnable() ? trigger.nextExecutionTime(triggerContext) : null;
  43.         });
  44.         ScheduledTask scheduledTask = registrar.scheduleTriggerTask(triggerTask);
  45.         entity.setScheduledTask(scheduledTask);
  46.         entity.setTriggerTask(triggerTask);
  47.         tasks.put(job, entity);
  48.         return job;
  49.     }
  51.     /**
  52.      * 任务类(必须标注了@CronExpress注解，且实现了Runnable接口)
  53.      * @param clazz 接口类
  54.      * @return 任务对象
  55.      */
  56.     public Job addJob(Class<? extends Runnable> clazz) {
  57.         Job job = new Job();
  58.         job.setClazz(clazz);
  59.         return this.addJob(job);
  60.     }
  62.     /**
  63.      * 获取任务操作对象
  64.      * @param jobId 任务id
  65.      * @return 任务操作对象
  66.      */
  67.     public JobHandler getJobHandler(String jobId) {
  68.         return tasks.get(new Job(jobId));
  69.     }
  71.     /**
  72.      * 根据任务id获取任务
  73.      * @param jobId 任务id
  74.      * @return 任务实体
  75.      */
  76.     public Job getJob(String jobId) {
  77.         Assert.hasText(jobId, "jobId can't be null");
  78.         Set<Job> jobs = tasks.keySet();
  79.         if(jobs.size() == 0) {
  80.             return null;
  81.         }
  82.         Iterator<Job> iterator = jobs.iterator();
  83.         while (iterator.hasNext()) {
  84.             Job next = iterator.next();
  85.             if(jobId.equals(next.getJobId())) {
  86.                 return next;
  87.             }
  88.         }
  89.         return null;
  90.     }
  92.     /**
  93.      * 关闭任务(若任务正在执行，待任务执行完)
  94.      * @param jobId 任务id
  95.      * @return 是否关闭成功
  96.      */
  97.     public boolean shutDown(String jobId) {
  98.         try {
  99.             JobHandler handler = this.getJobHandler(jobId);
  100.             Assert.notNull(handler, "任务[" + jobId + "]不存在");
  101.             handler.getScheduledTask().cancel();
  102.             Job job = getJob(jobId);
  103.             job.setActive(false);
  104.             return true;
  105.         } catch (Exception e) {
  106.             return false;
  107.         }
  108.     }
  110.     /**
  111.      * 启动已经注册的任务
  112.      * @param jobId 任务id
  113.      * @return 是否成功启动
  114.      */
  115.     public boolean startUp(String jobId) {
  116.         try {
  117.             JobHandler handler = this.getJobHandler(jobId);
  118.             Assert.notNull(handler, "任务[" + jobId + "]不存在");
  119.             register.getRegistrar().scheduleTriggerTask(handler.getTriggerTask());
  120.             Job job = getJob(jobId);
  121.             job.setActive(true);
  122.             return true;
  123.         } catch (Exception e) {
  124.             return false;
  125.         }
  126.     }
  128.     /**
  129.      * 获取所有的任务实体
  130.      * @return
  131.      */
  132.     public List<Job> getJobs() {
  133.         return new ArrayList<>(tasks.keySet());
  134.     }
  136.     /**
  137.      * 删除任务，先关闭再删除
  138.      * @param jobId
  139.      * @return
  140.      */
  141.     public boolean deleteJob(String jobId) {
  142.         try {
  143.             Job job = this.getJob(jobId);
  144.             Assert.notNull(job, "任务[" + jobId + "]不存在");
  145.             shutDown(jobId);
  146.             tasks.remove(job);
  147.             return true;
  148.         } catch (Exception e) {
  149.             return false;
  150.         }
  151.     }
  152. }
  • 任务运行类
  1. @CronExpress("0/1 * * * * *")
  2. public class HelloJob implements Runnable {
  4.     @Override
  5.     public void run() {
  6.         System.out.println("hello msg" + Thread.currentThread().getId());
  7.     }
  8. }
  • 测试
  1. ConfigurableApplicationContext ctx = SpringApplication.run(UnifiedTaskScheduleStarterApplication.class, args);
  2. SchedulerManager schedulerManager = ctx.getBean(SchedulerManager.class);
  3. Job job = schedulerManager.addJob(com.github.softwarevax.web.HelloJob.class);
  4. schedulerManager.shutDown(job.getJobId());

三、使用 TaskScheduler

  1.     TaskScheduler 是Spring提供的用于调度任务的核心接口。通过 TaskScheduler，你可以灵活地安排任务的执行时间，并且可以在运行时动态地创建、取消任务。

代码示例简单使用：

  1. import org.springframework.context.annotation.Bean;
  2. import org.springframework.context.annotation.Configuration;
  3. import org.springframework.scheduling.TaskScheduler;
  4. import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
  6. @Configuration
  7. public class TaskSchedulerConfig {
  9.     @Bean
  10.     public TaskScheduler taskScheduler() {
  11.         ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
  12.         scheduler.setPoolSize(5);
  13.         scheduler.setThreadNamePrefix("MyScheduler-");
  14.         return scheduler;
  15.     }
  16. }

在使用 TaskScheduler 时，可以通过 schedule 方法动态安排任务：

  1. import org.springframework.beans.factory.annotation.Autowired;
  2. import org.springframework.scheduling.TaskScheduler;
  3. import org.springframework.stereotype.Component;
  5. import java.util.Date;
  7. @Component
  8. public class DynamicTask {
  10.     @Autowired
  11.     private TaskScheduler taskScheduler;
  13.     public void scheduleTask() {
  14.         taskScheduler.schedule(() -> System.out.println("动态任务执行：" + System.currentTimeMillis()), new Date(System.currentTimeMillis() + 5000));
  15.     }
  16. }

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

  • SchedulingConfig：添加执行定时任务的线程池配置类
  1. import org.springframework.context.annotation.Bean;
  2. import org.springframework.context.annotation.Configuration;
  3. import org.springframework.scheduling.TaskScheduler;
  4. import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
  6. @Configuration
  7. public class SchedulingConfig {
  9.     @Bean
  10.     public TaskScheduler taskScheduler() {
  11.         ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
  12.         // 定时任务执行线程池核心线程数
  13.         taskScheduler.setPoolSize(4);
  14.         taskScheduler.setRemoveOnCancelPolicy(true);
  15.         taskScheduler.setThreadNamePrefix("TaskSchedulerThreadPool-");
  16.         return taskScheduler;
  17.     }
  18. }
  • ScheduledTask：添加ScheduledFuture的包装类

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

  1. import java.util.concurrent.ScheduledFuture;
  3. public final class ScheduledTask {
  5.     volatile ScheduledFuture<?> future;
  7.     /**
  8.      * 取消定时任务
  9.      */
  10.     public void cancel() {
  11.         ScheduledFuture<?> future = this.future;
  12.         if (future != null) {
  13.             future.cancel(true);
  14.         }
  15.     }
  16. }
  • SchedulingRunnable：添加Runnable接口实现类

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

  1. import org.apache.commons.lang.StringUtils;
  2. import org.slf4j.Logger;
  3. import org.slf4j.LoggerFactory;
  4. import org.springframework.util.ReflectionUtils;
  6. import java.lang.reflect.Method;
  7. import java.util.Objects;
  9. public class SchedulingRunnable implements Runnable {
  11.     private static final Logger logger = LoggerFactory.getLogger(SchedulingRunnable.class);
  13.     private final String beanName;
  15.     private final String methodName;
  17.     private final String params;
  19.     public SchedulingRunnable(String beanName, String methodName) {
  20.         this(beanName, methodName, null);
  21.     }
  23.     public SchedulingRunnable(String beanName, String methodName, String params) {
  24.         this.beanName = beanName;
  25.         this.methodName = methodName;
  26.         this.params = params;
  27.     }
  29.     @Override
  30.     public void run() {
  31.         logger.info("定时任务开始执行 - bean：{}，方法：{}，参数：{}", beanName, methodName, params);
  32.         long startTime = System.currentTimeMillis();
  34.         try {
  35.             Object target = SpringContextUtils.getBean(beanName);
  37.             Method method = null;
  38.             if (StringUtils.isNotEmpty(params)) {
  39.                 method = target.getClass().getDeclaredMethod(methodName, String.class);
  40.             } else {
  41.                 method = target.getClass().getDeclaredMethod(methodName);
  42.             }
  44.             ReflectionUtils.makeAccessible(method);
  45.             if (StringUtils.isNotEmpty(params)) {
  46.                 method.invoke(target, params);
  47.             } else {
  48.                 method.invoke(target);
  49.             }
  50.         } catch (Exception ex) {
  51.             logger.error(String.format("定时任务执行异常 - bean：%s，方法：%s，参数：%s ", beanName, methodName, params), ex);
  52.         }
  54.         long times = System.currentTimeMillis() - startTime;
  55.         logger.info("定时任务执行结束 - bean：{}，方法：{}，参数：{}，耗时：{} 毫秒", beanName, methodName, params, times);
  56.     }
  58.     @Override
  59.     public boolean equals(Object o) {
  60.         if (this == o) return true;
  61.         if (o == null || getClass() != o.getClass()) return false;
  62.         SchedulingRunnable that = (SchedulingRunnable) o;
  63.         if (params == null) {
  64.             return beanName.equals(that.beanName) &&
  65.                     methodName.equals(that.methodName) &&
  66.                     that.params == null;
  67.         }
  69.         return beanName.equals(that.beanName) &&
  70.                 methodName.equals(that.methodName) &&
  71.                 params.equals(that.params);
  72.     }
  74.     @Override
  75.     public int hashCode() {
  76.         if (params == null) {
  77.             return Objects.hash(beanName, methodName);
  78.         }
  80.         return Objects.hash(beanName, methodName, params);
  81.     }
  82. }
  • CronTaskRegistrar：添加定时任务注册类，用来增加、删除定时任务
  1. import com.example.testspringboot.cron.ScheduleResult;
  2. import org.springframework.beans.factory.DisposableBean;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.scheduling.TaskScheduler;
  5. import org.springframework.scheduling.config.CronTask;
  6. import org.springframework.stereotype.Component;
  8. import java.util.*;
  9. import java.util.concurrent.ConcurrentHashMap;
  11. /**
  12.  * 添加定时任务注册类，用来增加、删除定时任务。
  13.  */
  14. @Component
  15. public class CronTaskRegistrar implements DisposableBean {
  17.     private final Map<Runnable, ScheduledTask> scheduledTasks = new ConcurrentHashMap<>(16);
  18.     private final Map<Integer, ScheduleResult> schedulerJob = new HashMap<>();
  20.     @Autowired
  21.     private TaskScheduler taskScheduler;
  23.     public TaskScheduler getScheduler() {
  24.         return this.taskScheduler;
  25.     }
  27.     public void addCronTask(ScheduleResult scheduleResult) {
  28.         SchedulingRunnable task = new SchedulingRunnable(scheduleResult.getBeanName(), scheduleResult.getMethodName(), scheduleResult.getMethodParams());
  29.         String cronExpression = scheduleResult.getCronExpression();
  31.         CronTask cronTask = new CronTask(task, cronExpression);
  32.         // 如果当前包含这个任务，则移除
  33.         if (this.scheduledTasks.containsKey(task)) {
  34.             removeCronTask(scheduleResult.getBeanName(), scheduleResult.getMethodName(), scheduleResult.getMethodParams());
  35.         }
  36.         schedulerJob.put(scheduleResult.getJobId(), scheduleResult);
  37.         this.scheduledTasks.put(task, scheduleCronTask(cronTask));
  38.     }
  40.     public void removeCronTask(String beanName, String methodName, String methodParams) {
  41.         SchedulingRunnable task = new SchedulingRunnable(beanName, methodName, methodParams);
  42.         ScheduledTask scheduledTask = this.scheduledTasks.remove(task);
  43.         if (scheduledTask != null) {
  44.             scheduledTask.cancel();
  45.         }
  46.     }
  48.     public void removeCronTask(ScheduleResult scheduleResult) {
  49.         schedulerJob.put(scheduleResult.getJobId(), scheduleResult);
  50.         removeCronTask(scheduleResult.getBeanName(), scheduleResult.getMethodName(), scheduleResult.getMethodParams());
  51.     }
  53.     public ScheduledTask scheduleCronTask(CronTask cronTask) {
  54.         ScheduledTask scheduledTask = new ScheduledTask();
  55.         scheduledTask.future = this.taskScheduler.schedule(cronTask.getRunnable(), cronTask.getTrigger());
  56.         return scheduledTask;
  57.     }
  59.     public Map<Runnable, ScheduledTask> getScheduledTasks() {
  60.         return scheduledTasks;
  61.     }
  63.     public Map<Integer, ScheduleResult> getSchedulerJob() {
  64.         return schedulerJob;
  65.     }
  67.     @Override
  68.     public void destroy() {
  69.         for (ScheduledTask task : this.scheduledTasks.values()) {
  70.             task.cancel();
  71.         }
  73.         this.scheduledTasks.clear();
  74.     }
  76.     public ScheduleResult getSchedulerByJobId(Integer jobId) {
  77.         for (ScheduleResult job : findAllTask()) {
  78.             if (jobId.equals(job.getJobId())) {
  79.                 return job;
  80.             }
  81.         }
  82.         return null;
  83.     }
  85.     public List<ScheduleResult> findAllTask() {
  86.         List<ScheduleResult> ScheduleResults = new ArrayList<>();
  87.         Set<Map.Entry<Integer, ScheduleResult>> entries = schedulerJob.entrySet();
  88.         for (Map.Entry<Integer, ScheduleResult> en : entries) {
  89.             ScheduleResults.add(en.getValue());
  90.         }
  91.         return ScheduleResults;
  92.     }
  93. }
  • CronUtils：校验Cron表达式的有效性
  1. import org.springframework.scheduling.support.CronExpression;
  3. public class CronUtils {
  5.     /**
  6.      * 返回一个布尔值代表一个给定的Cron表达式的有效性
  7.      *
  8.      * @param cronExpression Cron表达式
  9.      * @return boolean 表达式是否有效
  10.      */
  11.     public static boolean isValid(String cronExpression) {
  12.         return CronExpression.isValidExpression(cronExpression);
  13.     }
  15. }
  • ScheduleResult：添加定时任务实体类
  1. import lombok.Data;
  3. @Data
  4. public class ScheduleResult {
  6.     /**
  7.      * 任务ID
  8.      */
  9.     private Integer jobId;
  11.     /**
  12.      * bean名称
  13.      */
  14.     private String beanName;
  16.     /**
  17.      * 方法名称
  18.      */
  19.     private String methodName;
  21.     /**
  22.      * 方法参数: 执行service里面的哪一种方法
  23.      */
  24.     private String methodParams;
  26.     /**
  27.      * cron表达式
  28.      */
  29.     private String cronExpression;
  31.     /**
  32.      * 状态（1正常 0暂停）
  33.      */
  34.     private Integer jobStatus;
  36.     /**
  37.      * 备注
  38.      */
  39.     private String remark;
  41.     /**
  42.      * 创建时间
  43.      */
  44.     private String createTime;
  46.     /**
  47.      * 更新时间
  48.      */
  49.     private String updateTime;
  51. }
  • ScheduleJobStatus：任务状态枚举类型
  1. public enum ScheduleJobStatus {
  3.     /**
  4.      * 暂停
  5.      */
  6.     PAUSE,
  8.     /**
  9.      * 正常
  10.      */
  11.     NORMAL;
  13. }
  • SpringContextUtils类：从spring容器里获取bean
  1. import org.springframework.beans.BeansException;
  2. import org.springframework.context.ApplicationContext;
  3. import org.springframework.context.ApplicationContextAware;
  4. import org.springframework.stereotype.Component;
  6. @Component
  7. public class SpringContextUtils implements ApplicationContextAware {
  9.     private static ApplicationContext applicationContext = null;
  11.     @Override
  12.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  13.         if (SpringContextUtils.applicationContext == null) {
  14.             SpringContextUtils.applicationContext = applicationContext;
  15.         }
  16.     }
  18.     public static ApplicationContext getApplicationContext() {
  19.         return applicationContext;
  20.     }
  22.     // 通过name获取 Bean.
  23.     public static Object getBean(String name) {
  24.         return getApplicationContext().getBean(name);
  25.     }
  27.     // 通过class获取Bean.
  28.     public static <T> T getBean(Class<T> clazz) {
  29.         return getApplicationContext().getBean(clazz);
  30.     }
  32.     // 通过name,以及Clazz返回指定的Bean
  33.     public static <T> T getBean(String name, Class<T> clazz) {
  34.         return getApplicationContext().getBean(name, clazz);
  36.     }
  38.     public static boolean containsBean(String name) {
  39.         return getApplicationContext().containsBean(name);
  40.     }
  42.     public static boolean isSingleton(String name) {
  43.         return getApplicationContext().isSingleton(name);
  44.     }
  46.     public static Class<? extends Object> getType(String name) {
  47.         return getApplicationContext().getType(name);
  48.     }
  49. }
  • ScheduleJobService：增删启停service方法
  1. @Service
  2. @Slf4j
  3. public class ScheduleJobService {
  5.     @Autowired
  6.     private CronTaskRegistrar cronTaskRegistrar;
  8.     public void addScheduleJob(ScheduleResult scheduleResult) {
  9.         long currentTimeMillis = System.currentTimeMillis();
  10.         scheduleResult.setCreateTime(formatTimeYMD_HMS_SSS(currentTimeMillis));
  11.         scheduleResult.setUpdateTime(formatTimeYMD_HMS_SSS(currentTimeMillis));
  12.         scheduleResult.setJobId(findAllTask().size() + 1);
  13.         if (scheduleResult.getJobStatus().equals(ScheduleJobStatus.NORMAL.ordinal())) {
  14.             log.info("Stop or pause: is now on");
  15.             cronTaskRegistrar.addCronTask(scheduleResult);
  16.             return;
  17.         }
  18.         cronTaskRegistrar.getSchedulerJob().put(scheduleResult.getJobId(), scheduleResult);
  19.     }
  21.     public void editScheduleJob(ScheduleResult currentSchedule) {
  22.         //先移除
  23.         cronTaskRegistrar.removeCronTask(currentSchedule.getBeanName(), currentSchedule.getMethodName(), currentSchedule.getMethodParams());
  24.         ScheduleResult pastScheduleJob = cronTaskRegistrar.getSchedulerByJobId(currentSchedule.getJobId());
  25.         if (pastScheduleJob == null) {
  26.             System.out.println("没有这个任务");
  27.             return;
  28.         }
  29.         //然后判断是否开启, 如果开启的话，现在立即执行
  30.         startOrStopSchedulerJob(currentSchedule, true);
  31.     }
  33.     public void deleteScheduleJob(ScheduleResult scheduleResult) {
  34.         // 清除这个任务
  35.         cronTaskRegistrar.removeCronTask(scheduleResult.getBeanName(), scheduleResult.getMethodName(), scheduleResult.getMethodParams());
  36.         // 清除这个任务的数据
  37.         cronTaskRegistrar.getSchedulerJob().remove(scheduleResult.getJobId());
  38.     }
  40.     public void startOrStopScheduler(ScheduleResult scheduleResult) {
  41.         cronTaskRegistrar.getSchedulerJob().get(scheduleResult.getJobId()).setJobStatus(scheduleResult.getJobStatus());
  42.         startOrStopSchedulerJob(scheduleResult, false);
  43.     }
  45.     private void startOrStopSchedulerJob(ScheduleResult scheduleResult, boolean update) {
  46.         // 更新时间
  47.         scheduleResult.setUpdateTime(formatTimeYMD_HMS_SSS(System.currentTimeMillis()));
  48.         if (scheduleResult.getJobStatus().equals(ScheduleJobStatus.NORMAL.ordinal())) {
  49.             System.out.println("停止或暂停：现在是开启");
  50.             cronTaskRegistrar.addCronTask(scheduleResult);
  51.             return;
  52.         }
  53.         System.out.println("停止或暂停：现在是暂停");
  54.         if (update){
  55.             cronTaskRegistrar.removeCronTask(scheduleResult);
  56.             return;
  57.         }
  58.         cronTaskRegistrar.removeCronTask(scheduleResult.getBeanName(), scheduleResult.getMethodName(), scheduleResult.getMethodParams());
  59.     }
  61.     public List<ScheduleResult> findAllTask() {
  62.         return cronTaskRegistrar.findAllTask();
  63.     }
  65.     // 转换为年-月-日 时:分:秒
  66.     private String formatTimeYMD_HMS_SSS(long time) {
  67.         return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS").format(time);
  68.     }
  69. }
  • cronController：访问接口
  1. import com.example.testspringboot.cron.ScheduleResult;
  2. import com.example.testspringboot.cron.ScheduleJobService;
  3. import com.example.testspringboot.cron.utils.CronUtils;
  4. import com.google.gson.Gson;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.web.bind.annotation.*;
  8. import java.util.List;
  10. @RestController
  11. public class cronController {
  13.     @Autowired
  14.     private ScheduleJobService scheduleJobService;
  16.     /**
  17.      * 测试上传的用例文件, 获取详细执行结果
  18.      */
  19.     @PostMapping("/add")
  20.     void executeTestOneFile(@RequestBody ScheduleResult scheduleResult) {
  21.         boolean valid = CronUtils.isValid(scheduleResult.getCronExpression());
  22.         if (valid){
  23.             System.out.println("校验成功， 添加任务");
  24.             scheduleResult.setMethodParams(scheduleResult.getBranch()+scheduleResult.getCaseDir());
  25.             scheduleJobService.addScheduleJob(scheduleResult);
  26.         }else {
  27.             System.out.println("校验失败");
  28.         }
  29.     }
  31.     @PostMapping("/stop")
  32.     void end(@RequestBody ScheduleResult scheduleResult) {
  33.         Gson gson = new Gson();
  34.         System.out.println("================");
  35.         System.out.println(scheduleResult);
  36.         System.out.println("=================");
  37.         scheduleResult.setJobStatus(0);
  38.         scheduleJobService.startOrStopScheduler(scheduleResult);
  39.     }
  41.     @PostMapping("/start")
  42.     void start(@RequestBody ScheduleResult scheduleResult) {
  43.         System.out.println("================");
  44.         System.out.println(scheduleResult);
  45.         System.out.println("=================");
  46.         scheduleResult.setJobStatus(1);
  47.         scheduleJobService.startOrStopScheduler(scheduleResult);
  48.     }
  50.     @PostMapping("/edit")
  51.     void edit(@RequestBody ScheduleResult scheduleResult) {
  52.         System.out.println("=======edit=========");
  53.         System.out.println(scheduleResult);
  54.         System.out.println("=================");
  55.         scheduleJobService.editScheduleJob(scheduleResult);
  56.     }
  58.     @PostMapping("/delete")
  59.     void delete(@RequestBody ScheduleResult scheduleResult) {
  60.         System.out.println("=======delete=========");
  61.         System.out.println(scheduleResult);
  62.         System.out.println("=================");
  63.         scheduleJobService.deleteScheduleJob(scheduleResult);
  64.     }
  66.     @GetMapping("/tasks")
  67.     List<ScheduleResult> get() throws Exception {
  68.         List<ScheduleResult> allTask = scheduleJobService.findAllTask();
  69.         System.out.println("现在的定时任务数量 = " + allTask.size());
  70.         System.out.println("现在的定时任务 = " + allTask);
  71.         return allTask;
  72.     }
  73. }
  • 测试bean
  1. import org.springframework.stereotype.Component;
  3. @Component
  4. public class c1 {
  5.     public void test1(String y){
  6.         System.out.println("这个是test1的bean : " + y);
  7.     }
  9.     public void test2(){
  10.         System.out.println("这个是test1的bean中test2方法");
  11.     }
  12. }
  • 项目启动后的定时任务
  1. import com.example.testspringboot.cron.ScheduleJobService;
  2. import com.example.testspringboot.cron.ScheduleResult;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.boot.CommandLineRunner;
  5. import org.springframework.stereotype.Component;
  7. @Component
  8. public class init  implements CommandLineRunner {
  10.     @Autowired
  11.     private ScheduleJobService scheduleJobService;
  13.     @Override
  14.     public void run(String... args) throws Exception {
  15.         System.out.println("开始珍惜");
  16.         ScheduleResult scheduleResult = new ScheduleResult();
  17.         scheduleResult.setBeanName("c1");
  18.         scheduleResult.setMethodName("test1");
  19.         scheduleResult.setCronExpression("0/25 * * * * *");
  20.         scheduleResult.setJobStatus(1);
  21.         scheduleResult.setMethodParams("test1");
  22.         scheduleJobService.addScheduleJob(scheduleResult);
  23.         scheduleJobService.findAllTask();
  24.     }
  25. }

四、使用 Quartz 实现定时任务

  1.     Quartz 是一个功能强大的开源任务调度框架，支持复杂的任务调度需求，如任务的持久化、分布式任务管理、基于数据库的调度等。Spring Boot 提供了对 Quartz 的良好集成，使得在应用中使用 Quartz 变得更加简单。

简单使用：

  1. import org.quartz.*;
  2. import org.springframework.context.annotation.Bean;
  3. import org.springframework.context.annotation.Configuration;
  4. import org.springframework.scheduling.quartz.JobDetailFactoryBean;
  5. import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;
  7. @Configuration
  8. public class QuartzConfig {
  10.     @Bean
  11.     public JobDetailFactoryBean jobDetail() {
  12.         JobDetailFactoryBean factoryBean = new JobDetailFactoryBean();
  13.         factoryBean.setJobClass(SampleJob.class);
  14.         factoryBean.setDescription("Sample Quartz Job");
  15.         factoryBean.setDurability(true);
  16.         return factoryBean;
  17.     }
  19.     @Bean
  20.     public SimpleTriggerFactoryBean trigger(JobDetail jobDetail) {
  21.         SimpleTriggerFactoryBean factoryBean = new SimpleTriggerFactoryBean();
  22.         factoryBean.setJobDetail(jobDetail);
  23.         factoryBean.setRepeatInterval(5000); // 每5秒执行一次
  24.         factoryBean.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY);
  25.         return factoryBean;
  26.     }
  28.     public static class SampleJob implements Job {
  29.         @Override
  30.         public void execute(JobExecutionContext context) {
  31.             System.out.println("Quartz任务执行：" + System.currentTimeMillis());
  32.         }
  33.     }
  34. }

springboot整合

  • 数据库设计

    1.   将任务计划放入数据库中保存。在启动任务是，从数据库中查找任务计划信息，并动态配置进去即可。
  1. DROP TABLE IF EXISTS `cc_task_info`;
  3. CREATE TABLE `cc_task_info` (
  4.   `TID` int(11) NOT NULL AUTO_INCREMENT,
  5.   `TASK_ANME` varchar(50) NOT NULL,
  6.   `TASK_CODE` varchar(50) NOT NULL,
  7.   `JOB_CLASS` varchar(200) NOT NULL,
  8.   `JOB_GROUP` varchar(50) NOT NULL,
  9.   `CRON` varchar(50) NOT NULL,
  10.   `DEL_STATUS` varchar(2) DEFAULT '1' NULL,
  11.   `CRT_TIME` datetime DEFAULT NULL,
  12.   PRIMARY KEY (`TID`)
  13. ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='定时任务管理表';
  15. DROP TABLE IF EXISTS `cc_task_record`;
  17. CREATE TABLE `cc_task_record` (
  18.   `RID` int(11) NOT NULL AUTO_INCREMENT,
  19.   `TASK_CODE` varchar(50) NOT NULL,
  20.   `RUN_TIME` datetime NOT NULL,
  21.   `RUN_CODE` char(1) NOT NULL,
  22.   `RUN_MSG` varchar(100) NULL,
  23.   PRIMARY KEY (`RID`)
  24. ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='定时任务运行记录表';
  26. DROP TABLE IF EXISTS `cc_task_status`;
  28. CREATE TABLE `cc_task_status` (
  29.   `TASK_CODE` varchar(50) NOT NULL,
  30.   `TASK_STATUS` varchar(10) NOT NULL,
  31.   `LST_SUCC_TIME` datetime NOT NULL,
  32.   `LST_TIME` datetime NOT NULL,
  33.   PRIMARY KEY (`TASK_CODE`)
  34. ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='定时任务运行状态表';

  • 定时任务管理

    1.   通过Scheduler的方法来实现。Scheduler提供了一系列方法来管理定时任务的执行状态。

主要包括：

  • scheduleJob()：添加定时任务
  • rescheduleJob()：修改定时任务
  • pauseJob()：暂停定时任务执行
  • resumeJob()：恢复定时任务执行
  • deleteJob()：删除定时任务执行

针对上述方法，只需要传入对应参数即可。建了一个QuartzService来管理定时任务，供业务层调用。

详细代码如下：

  1. /**
  2.  * 定时任务管理服务
  3.  */
  4. @Service
  5. public class QuartzService {
  7.     public static String SCHEDULER_OPR_START = "start";
  8.     public static String SCHEDULER_OPR_PAUSE = "pause";
  9.     public static String SCHEDULER_OPR_RESUME = "resume";
  10.     public static String SCHEDULER_OPR_REMOVE = "remove";
  12.     @Autowired
  13.     private Scheduler scheduler;
  15.     /**
  16.      * 启动任务
  17.      */
  18.     public void startJob(String taskCode, String taskAnme, String cron, String jobGroup,
  19.                          String className) throws Exception{
  20.         Class<Job> jobClass = null;
  21.         try {
  22.             jobClass = (Class<Job>) Class.forName(className);//获取任务执行类
  23.         } catch (ClassNotFoundException e) {
  24.             throw new Exception("任务类不存在");
  25.         }
  26.         //创建job，指定job名称和分组
  27.         JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(taskCode, jobGroup).build();
  28.         //创建表达式工作计划
  29.         CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
  30.         //创建触发器
  31.         CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(taskCode, jobGroup)
  32.                 .withSchedule(cronScheduleBuilder).build();
  33.         scheduler.scheduleJob(jobDetail, cronTrigger);
  34.     }
  36.     /**
  37.      * 修改定时任务执行时间
  38.      * @param taskCode
  39.      * @param jobGroup
  40.      * @param cron 新的时间
  41.      * @throws Exception
  42.      */
  43.     public void modifyJob(String taskCode, String jobGroup, String cron) throws Exception{
  44.         TriggerKey triggerKey = new TriggerKey(taskCode, jobGroup);
  45.         CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
  46.         String oldCron = trigger.getCronExpression();
  47.         if(!oldCron.equals(cron)){
  48.             CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(taskCode, jobGroup)
  49.                     .withSchedule(CronScheduleBuilder.cronSchedule(cron)).build();
  50.             Date date = scheduler.rescheduleJob(triggerKey, cronTrigger);
  51.             if(date == null){
  52.                 throw new Exception("修改定时任务执行时间报错");
  53.             }
  54.         }
  55.     }
  57.     /**
  58.      * 暂停某个定时任务（任务恢复后，暂停时间段内未执行的任务会继续执行，如暂停时间段内有2次，则会执行2次）
  59.      * @param taskCode
  60.      * @param jobGroup
  61.      * @throws Exception
  62.      */
  63.     public void pauseJob(String taskCode, String jobGroup) throws Exception{
  64.         JobKey jobKey = new JobKey(taskCode, jobGroup);
  65.         JobDetail jobDetail = scheduler.getJobDetail(jobKey);
  66.         if(jobDetail == null){
  67.             return;
  68.         }
  69.         scheduler.pauseJob(jobKey);
  70.     }
  72.     /**
  73.      * 恢复某个定时任务
  74.      * @param taskCode
  75.      * @param jobGroup
  76.      * @throws Exception
  77.      */
  78.     public void resumeJob(String taskCode, String jobGroup) throws Exception{
  79.         JobKey jobKey = new JobKey(taskCode, jobGroup);
  80.         JobDetail jobDetail = scheduler.getJobDetail(jobKey);
  81.         if(jobDetail == null){
  82.             return;
  83.         }
  84.         scheduler.resumeJob(jobKey);
  85.     }
  87.     /**
  88.      * 删除某个定时任务
  89.      * @param taskCode
  90.      * @param jobGroup
  91.      * @throws Exception
  92.      */
  93.     public void deleteJob(String taskCode, String jobGroup) throws Exception{
  94.         JobKey jobKey = new JobKey(taskCode, jobGroup);
  95.         JobDetail jobDetail = scheduler.getJobDetail(jobKey);
  96.         if(jobDetail == null){
  97.             return;
  98.         }
  99.         scheduler.deleteJob(jobKey);
  100.     }
  101. }

  • 编写任务类JOB

    1.   任务类JOB就是定时任务具体要处理的系统业务逻辑，需要实现Job接口。

在任务启动时，通过jobClass传入JobDetail。

  1. public class DemoJob implements Job {
  3.     @Override
  4.     public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
  5.         String taskCode = jobExecutionContext.getJobDetail().getKey().getName();
  6.         System.out.println("执行定时任务：" + taskCode);
  7.     }
  8. }
  • 配置Scheduler

在Configuration中配置Scheduler实例，并启动。

  1. @Configuration
  2. public class QuartzConfig {
  4.     @Bean
  5.     public Scheduler scheduler(){
  6.         Scheduler scheduler = null;
  7.         SchedulerFactory factory = new StdSchedulerFactory();
  8.         try {
  9.             scheduler = factory.getScheduler();
  10.         } catch (SchedulerException e) {
  11.             e.printStackTrace();
  12.         }
  13.         if(scheduler != null){
  14.             try {
  15.                 //启动定时任务
  16.                 scheduler.start();
  17.             } catch (SchedulerException e) {
  18.                 e.printStackTrace();
  19.             }
  20.         }
  21.         return scheduler;
  22.     }
  23. }

  • 编写API接口

    1.   通过Controller提供API接口，这里的TaskService调用了QartzService的对应接口，并做了一个写数据库读写操作，主要记录定时任务状态、执行记录信息的等。
  1. @RestController
  2. @RequestMapping("/api/task")
  3. public class TaskController {
  5.     @Autowired
  6.     private TaskService service;
  8.     @RequestMapping("/start")
  9.     public Object start(int id){
  10.         try {
  11.             service.startJob(id);
  12.             return RtnData.ok();
  13.         } catch (Exception e) {
  14.             return RtnData.fail(e.getMessage());
  15.         }
  16.     }
  18.     @RequestMapping("/pause")
  19.     public Object pause(int id){
  20.         try {
  21.             service.pauseJob(id);
  22.             return RtnData.ok();
  23.         } catch (Exception e) {
  24.             return RtnData.fail(e.getMessage());
  25.         }
  26.     }
  28.     @RequestMapping("/resume")
  29.     public Object resume(int id){
  30.         try {
  31.             service.resumeJob(id);
  32.             return RtnData.ok();
  33.         } catch (Exception e) {
  34.             return RtnData.fail(e.getMessage());
  35.         }
  36.     }
  38.     @RequestMapping("/remove")
  39.     public Object remove(int id){
  40.         try {
  41.             service.deleteJob(id);
  42.             return RtnData.ok();
  43.         } catch (Exception e) {
  44.             return RtnData.fail(e.getMessage());
  45.         }
  46.     }
  47. }
标签： spring boot oracle 数据库
本文转载自: https://blog.csdn.net/hk000001/article/details/143038049
版权归原作者 蓝眸少年CY 所有， 如有侵权，请联系我们删除。
登录后发布评论

“SpringBoot创建动态定时任务的几种方式”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航
没有找到文章内容分段。。。