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

目录

一、使用?@Scheduled?注解

二、使用?SchedulingConfigurer?接口

三、使用?TaskScheduler

四、使用?Quartz?实现定时任务

---

一、使用@Scheduled注解

@Scheduled是 Spring 提供的一个注解，用于标记需要定时执行的方法。常见的属性包括：

• cron：通过 Cron 表达式定义任务的执行时间。
• fixedRate：定义任务的固定执行频率，以毫秒为单位。
• fixedDelay：定义任务在前一次执行完毕后延迟多少毫秒再执行。

代码示例：

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class ScheduledTasks {

    @Scheduled(cron = "0 0 * * * ?") // 每小时整点执行一次
    public void reportCurrentTime() {
        System.out.println("现在时间：" + System.currentTimeMillis());
    }

    @Scheduled(fixedRate = 5000) // 每5秒执行一次
    public void fixedRateTask() {
        System.out.println("每5秒执行一次任务：" + System.currentTimeMillis());
    }

    @Scheduled(fixedDelay = 7000) // 前一次执行完毕后延迟7秒执行
    public void fixedDelayTask() {
        System.out.println("延迟7秒后执行任务：" + System.currentTimeMillis());
    }
}

@Scheduled适用于大多数简单的定时任务场景，如定时发送邮件或生成报告等。然而，它的灵活性较差，对于复杂的任务调度需求，或需要动态调整任务时间的场景，可能并不适用。

二、使用SchedulingConfigurer接口

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

简单使用代码：

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

详细增删该查操作：

• 动态注册bean

  public class ApplicationContextUtils implements ApplicationContextAware {

  private static ApplicationContext CONTEXT;
  /**
   * 设置spring上下文
   * @param ctx spring上下文
   * @throws BeansException
   * */
  @Override
  public void setApplicationContext(ApplicationContext ctx) throws BeansException {
      CONTEXT = ctx;
  }
  
  /**
   * 获取容器
   * @return
   */
  public static ApplicationContext getApplicationContext() {
      return CONTEXT;
  }
  
  /**
   * 获取容器对象
   * @param type
   * @param <T>
   * @return
   */
  public static <T> T getBean(Class<T> type) {
      return CONTEXT.getBean(type);
  }
  
  public static <T> T getBean(String name,Class<T> clazz){
      return CONTEXT.getBean(name, clazz);
  }
  
  public static Object getBean(String name){
      return CONTEXT.getBean(name);
  }
  
  /**
   * springboot动态注册bean
   * @param clazz
   * @param <T>
   * @return
   */
  public static <T> T register(Class<T> clazz) {
  	ConfigurableApplicationContext configurableApplicationContext = (ConfigurableApplicationContext) ApplicationContextUtils.getApplicationContext();
  	DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) configurableApplicationContext.getBeanFactory();
  	BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(clazz);
      if(defaultListableBeanFactory.getBeanNamesForType(clazz).length > 0) {
          return defaultListableBeanFactory.getBean(clazz);
      }
  	defaultListableBeanFactory.registerBeanDefinition(clazz.getName(), beanDefinitionBuilder.getRawBeanDefinition());
  	return (T) ApplicationContextUtils.getBean(clazz.getName());
  }
  

  }

• 任务实体

  public class Job {

  /**
   * 任务id, 用于标识，默认使用全限定类名
   */
  private String jobId;
  
  /**
   * 任务名称, 默认简单类名
   */
  private String jobName;
  
  /**
   * cron表达式, 修改后即可生效
   */
  private String cron;
  
  /**
   * 任务描述
   */
  private String description;
  
  /**
   * 是否启用, 默认启用, 修改后即可生效
   */
  private boolean enable = true;
  
  /**
   * 是否处于等待执行下个任务的状态
   */
  private boolean active;
  /**
   * 任务运行类
   */
  private Class<? extends Runnable> clazz;
  

  }

• 操作类

  public class JobHandler {

  private ScheduledTask scheduledTask;
  
  private TriggerTask triggerTask;
  
  private TriggerContext triggerContext;
  

  }

• 配置SchedulingConfigurer

  public class JobSchedulingConfigurer implements SchedulingConfigurer {

  private ScheduledTaskRegistrar registrar;
  
  /**
   * 线程池任务调度器
   */
  @Bean
  public TaskScheduler taskScheduler() {
      ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
      scheduler.setPoolSize(Runtime.getRuntime().availableProcessors() / 3 + 1);
      scheduler.setThreadNamePrefix("TaskScheduler-");
      scheduler.setRemoveOnCancelPolicy(true);  // 保证能立刻丢弃运行中的任务
  
      taskScheduler = scheduler; // 获取 句柄，方便后期获取 future
  
      return scheduler;
  }
  
  @Override
  public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
      scheduledTaskRegistrar.setTaskScheduler(taskScheduler());
      this.registrar = scheduledTaskRegistrar;
  }
  
  public ScheduledTaskRegistrar getRegistrar() {
      return registrar;
  }
  
  public void setRegistrar(ScheduledTaskRegistrar registrar) {
      this.registrar = registrar;
  }
  

  }

• 增删改查

  public class SchedulerManager {

  /**
   * 任务容器
   */
  private Map<Job, JobHandler> tasks = new ConcurrentHashMap<>();
  
  /**
   * 任务注册
   */
  @Autowired
  private JobSchedulingConfigurer register;
  
  /**
   * 新增任务, 自生效
   * @param job 任务实体
   * @return 返回新增的任务
   */
  public Job addJob(Job job) {
      Assert.notNull(job, "job can't be null");
      ScheduledTaskRegistrar registrar = register.getRegistrar();
      Runnable runnable = ApplicationContextUtils.register(job.getClazz());
      if(job.getJobId() == null || "".equals(job.getJobId())) {
          job.setJobId(job.getClazz().getName());
      }
      Assert.isNull(this.getJob(job.getJobId()), "任务[" + job.getJobId() + "]已存在");
      if(job.getJobName() == null || "".equals(job.getJobName())) {
          job.setJobName(ClassUtils.getShortName(job.getClazz()));
      }
      CronExpress cron = AnnotationUtils.findAnnotation(job.getClazz(), CronExpress.class);
      if(cron != null && !"".equals(cron.value())) {
          // 注解的属性，大于配置的属性，方便调试
          job.setCron(cron.value());
      }
      job.setEnable(true);
      job.setActive(true);
      JobHandler entity = new JobHandler();
      TriggerTask triggerTask = new TriggerTask(runnable, (TriggerContext triggerContext) -> {
          // 每次任务执行均会进入此方法
          CronTrigger trigger = new CronTrigger(job.getCron());
          entity.setTriggerContext(triggerContext);
          return job.isEnable() ? trigger.nextExecutionTime(triggerContext) : null;
      });
      ScheduledTask scheduledTask = registrar.scheduleTriggerTask(triggerTask);
      entity.setScheduledTask(scheduledTask);
      entity.setTriggerTask(triggerTask);
      tasks.put(job, entity);
      return job;
  }
  
  /**
   * 任务类(必须标注了@CronExpress注解，且实现了Runnable接口)
   * @param clazz 接口类
   * @return 任务对象
   */
  public Job addJob(Class<? extends Runnable> clazz