SpringBoot 整合定时任务

SpringBoot 的几种定时任务

• Timer：这是java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少。
• ScheduledExecutorService：也jdk自带的一个类；是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也就是说,任务是并发执行,互不影响。
• Spring Task：Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多。
• Quartz：这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂。

SpringBoot 快速实现定时任务

为什么说快速实现定时任务，Spring 3.0 以后自带定时任务task，相当于轻量级的Quartz，省去了Quartz复杂的配置步骤，上手简单，提高我们的开发速度
第一步：创建项目，在启动类中加入注解：@EnableScheduling 表示开启定时任务
第二步：创建定时任务类和方法，在需要执行定时任务的方法上使用注解：@Scheduled，在给Scheduled配置一些属性，一个简单的定时任务就实现了

1、Scheduled 注解常用属性

---

- cron ：支持cron表达式启动定时任务 - fixedDelay：上一次任务执行结束后等待多少毫秒后，开始下一个任务 - fixedRate：上一个任务开始执行等待多少毫秒后执行下一个任务，如果上一个任务执行的时间大于等待时间，那么上一个任务执行完成后立即执行下一个任务

注意：fixedRate 的任务某次执行时间再长也不会造成两次任务实例同时执行，除非用了 @Async 注解。 fixedDelay 总是前一次任务完成后，延时固定长度然后执行一次任务

下面我们来看一段代码帮助大家使用：

@Component
@Slf4j
public class MyShedule {

    /**
     * cron表达式触发定时任务
     */
    @Async
    @Scheduled(cron = "0/5 * * * * *")
    public void test1(){
        log.info("===========> cron方式执行定时任务 {}",new Date());
    }

    /**
     * 上次任务执行结束后间隔时间执行，单位毫秒
     */
    @Async
    @Scheduled(fixedDelay = 2000)
    public void test2() throws InterruptedException {
        TimeUnit.SECONDS.sleep(5);
        log.info("===========> fixedDelay方式执行定时任务 {}",new Date());
    }

    /**
     * 上次任务开始执行后间隔时间执行，单位毫秒
     */
    @Async
    @Scheduled(fixedRate = 200)
    public void test3() throws InterruptedException {
        TimeUnit.SECONDS.sleep(2);
        log.info("===========> fixedRate方式执行定时任务 {}",new Date());
    }
}

2、多线程执行

---

官网学习地址：https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-task-execution-scheduling

在传统的Spring项目中，我们可以在xml配置文件添加task的配置，而在SpringBoot项目中一般使用config配置类的方式添加配置，所以新建一个AsyncConfig类

@Configuration
@EnableAsync
public class AsyncConfig {
     /*
    此处成员变量应该使用@Value从配置中读取
     */
    private int corePoolSize = 10;
    private int maxPoolSize = 200;
    private int queueCapacity = 10;
    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.initialize();
        return executor;
    }
}

@Configuration：表明该类是一个配置类
@EnableAsync：开启异步事件的支持

然后在定时任务的类或者方法上添加@Async 。最后重启项目，每一个任务都是在不同的线程中

SpringBoot 整合 Quartz

官网学习地址：https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-quartz

Quartz是现在比较流行的定时任务了，配置比较复杂上手有一定难度。但是再难也得上是不是，下面就开始在SpringBoot中使用Quartz做定时任务

第一步：引入jar包（简单）

如果SpringBoot版本是2.0.0以后的，则在spring-boot-starter中已经包含了quart的依赖，则可以直接使用spring-boot-starter-quartz依赖

<!--QuartZ-->
<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-quartz</artifactId>
  </dependency>

第二步：创建定时任务类（简单）

@Slf4j
public class QuartzJob1 implements Job {

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.info("=====job1===开始执行 {}",System.currentTimeMillis());
		//======================业务逻辑==========================
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //=======================================================
        log.info("=====job1===结束执行 {}",System.currentTimeMillis());
    }
}

上面两步都比较简单，无法就是引入jar包，创建类实现Quartz中的Job接口，重写execute方法，execute方法里面就是我们的业务逻辑，这里我用一个sleep延时来代替

第三步：创建job和Trigger

@Configuration
public class MyQuartzScheduler {
    // 任务调度
    @Autowired
    private Scheduler scheduler;

    /**
     * 开始执行所有任务
     *
     * @throws SchedulerException
     */
    public void startJob() throws SchedulerException {
        startJob1(scheduler);
        startJob2(scheduler);
        scheduler.start();
    }

    /**
     * 注入Job1任务
     * @param scheduler
     * @throws SchedulerException
     */
    private void startJob1(Scheduler scheduler) throws SchedulerException {
        // 通过JobBuilder构建JobDetail实例，JobDetail规定只能是实现Job接口的实例
        // JobDetail 是具体Job实例
        JobDetail jobDetail = JobBuilder.newJob(QuartzJob1.class).withIdentity("job1", "group1").build();
        // 基于表达式构建触发器
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/5 * * * * ?");
        // CronTrigger表达式触发器 继承于Trigger
        // TriggerBuilder 用于构建触发器实例
        CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("job1", "group1")
                .withSchedule(cronScheduleBuilder).build();
        scheduler.scheduleJob(jobDetail, cronTrigger);
    }

    /**
     * 注入Job2任务
     * @param scheduler
     * @throws SchedulerException
     */
    private void startJob2(Scheduler scheduler) throws SchedulerException {
        JobDetail jobDetail = JobBuilder.newJob(QuartzJob2.class).withIdentity("job2", "group2").build();
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0 0/5 * * * ?");
        CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("job2", "group2")
                .withSchedule(cronScheduleBuilder).build();
        scheduler.scheduleJob(jobDetail, cronTrigger);
    }
}

在Quartz中有两个重要的概念必须掌握：job 和 trigger
job：使用 JobBuilder 创建
trigger：使用 TriggerBuilder创建

第四部：配置监听器

还需要配置监听器，让定时任务随着spring项目的启动

@Configuration
public class ApplicationStartQuartzJobListener implements ApplicationListener<ContextRefreshedEvent> {

    @Autowired
    private MyQuartzScheduler myQuartzScheduler;

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        try {
            //启动定时任务
            myQuartzScheduler.startJob();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    @Bean
    public Scheduler scheduler() throws SchedulerException {
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        return schedulerFactory.getScheduler();
    }
}

github项目地址：https://github.com/dongtiandexue/springboot-schedule