SpringBoot使用Quartz实现定时任务

Quartz是一个开源的任务调度框架。基于定时、定期的策略来执行任务是它的核心功能。
Quartz有3个核心要素： 调度器(Scheduler)、 任务(Job)、 触发器(Trigger)。只要定义了Job（任务），Trigger（触发器）和Scheduler（调度器），即可实现一个定时调度能力。其中 Scheduler是Quartz中的核心，Scheduler负责管理Quartz应用运行时环境， Scheduler不是靠自己完成所有的工作，是根据 Trigger的触发标准，调用 Job中的任务执行逻辑，来完成完整的定时任务调度。
注意：一个 Job可以对应多个 Trigger，但一个 Trigger只能对应一个 Job。

一、依赖

        <!-- druid连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.1</version>
        </dependency>
        <!-- quartz定时任务 -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>com.mchange</groupId>
                    <artifactId>c3p0</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

二、主启动类

主启动类上需要加上注解@EnableScheduling

@SpringBootApplication
@EnableScheduling
public class TimerTaskApplication {
    public static void main(String[] args) {
        SpringApplication.run(TimerTaskApplication.class);
    }
}

三、Quartz配置类

Job - 定时任务内容是什么。
Trigger - 在什么时间上执行job。
Scheduler - 维护定时任务环境，并让触发器生效。

定义一个 JobDetailFactoryBean ，用于生成JobDetail，将定时任务类注册进JobDetail。
定义一个CronTriggerFactoryBean，用于生成Trigger，将JobDetail注册进Trigger。
定义一个SchedulerFactoryBean，用于生成Trigger，将Trigger注册进Scheduler。

package com.lsh.config;



import com.lsh.quartz.SpringBootQuartzJob;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
/**
 * @author ：LiuShihao
 * @date ：Created in 2020/8/29 1:01 下午
 * @desc ：Quartz配置类
 */
@Configuration
public class QuartzConfiguration {

    /**
     * 创建Job对象。在Spring环境中，创建一个类型的对象的时候，很多情况下，都是通过FactoryBean来间接创建的。
     * 如果有多个Job对象，定义多次方法。
     * 将Job放入JobDetailFactoryBean
     * @return
     */
    @Bean
    public JobDetailFactoryBean initJobDetailFactoryBean(){
        JobDetailFactoryBean factoryBean = new JobDetailFactoryBean();
        // 提供job类型。
        factoryBean.setJobClass(SpringBootQuartzJob.class);
        return factoryBean;
    }

    /**
     * 管理Trigger对象
     * CronTrigger - 就是Trigger的一个实现类型。其中用于定义周期时间的是CronSchedulerBuilder
     * 实际上，CronTrigger是用于管理一个Cron表达式的类型。
     *
     * @param jobDetailFactoryBean - 上一个方法初始化的JobDetailFactoryBean
     * @return
     */
    @Bean(name="cronTriggerFactoryBean1")
    public CronTriggerFactoryBean initCronTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean ){
        CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean();
        factoryBean.setJobDetail(jobDetailFactoryBean.getObject());
        factoryBean.setCronExpression("0/10 * * * * ?");
        return factoryBean;
    }

    /**
     * 初始化Scheduler
     * @param cronTriggerFactoryBean - 上一个方法初始化的CronTriggerFactoryBean
     * @return
     */
    @Bean
    public SchedulerFactoryBean initSchedulerFactoryBean(CronTriggerFactoryBean cronTriggerFactoryBean){
        SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();
        // 注册触发器，一个Scheduler可以注册若干触发器。
        factoryBean.setTriggers(cronTriggerFactoryBean.getObject());
        return factoryBean;
    }

}

四、定时任务类

定时任务类需要实现Job接口，重写execute方法，在方法中执行我们定时任务的代码。

package com.lsh.quartz;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

/**
 * @author ：LiuShihao
 * @date ：Created in 2020/8/29 1:00 下午
 * @desc ：
 */
public class SpringBootQuartzJob1 implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
    //执行我们的业务代码
        System.out.println("QuartzJob定时任务执行:"+LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd HH:mm:ss")));
    }
}

4.1 启动测试

配置类中的cron表达式设置的是10秒执行一次。

五、执行多个定时任务

前面只是配置了一个定时任务，如果有多件定时任务配置类怎么写呢？
有几个事件就配置几个JobDetailFactoryBean和CronTriggerFactoryBean
而SchedulerFactoryBean只用配置一个即可，因为一个Scheduler可以注册若干触发器。
配置类如下：

package com.lsh.config;

import com.lsh.quartz.SpringBootQuartzJob;
import com.lsh.quartz.SpringBootQuartzJob1;
import org.quartz.CronTrigger;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
/**
 * @author ：LiuShihao
 * @date ：Created in 2020/8/29 1:01 下午
 * @desc ：Quartz配置类
 */
@Configuration
public class QuartzConfiguration {

    /**
     * 创建Job对象。在Spring环境中，创建一个类型的对象的时候，很多情况下，都是通过FactoryBean来间接创建的。
     * 如果有多个Job对象，定义多次方法。
     * 将Job放入JobDetailFactoryBean
     * @return
     */
    @Bean("JobDetailFactoryBean1")
    public JobDetailFactoryBean JobDetailFactoryBean1(){
        JobDetailFactoryBean factoryBean = new JobDetailFactoryBean();
        // 提供job类型。
        factoryBean.setJobClass(SpringBootQuartzJob1.class);
        return factoryBean;
    }
    @Bean("JobDetailFactoryBean2")
    public JobDetailFactoryBean JobDetailFactoryBean2(){
        JobDetailFactoryBean factoryBean = new JobDetailFactoryBean();
        // 提供job类型。
        factoryBean.setJobClass(SpringBootQuartzJob.class);
        return factoryBean;
    }

    /**
     * 管理Trigger对象
     * CronTrigger - 就是Trigger的一个实现类型。其中用于定义周期时间的是CronSchedulerBuilder
     * 实际上，CronTrigger是用于管理一个Cron表达式的类型。
     *
     * @param jobDetailFactoryBean - 上一个方法初始化的JobDetailFactoryBean
     * @return
     */
    @Bean(name="cronTriggerFactoryBean1")
    public CronTriggerFactoryBean initCronTriggerFactoryBean(@Qualifier("JobDetailFactoryBean1") JobDetailFactoryBean jobDetailFactoryBean ){
        CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean();
        factoryBean.setJobDetail(jobDetailFactoryBean.getObject());
        factoryBean.setCronExpression("0/10 * * * * ?");
        return factoryBean;
    }
    @Bean(name="cronTriggerFactoryBean2")
    public CronTriggerFactoryBean initCronTriggerFactoryBean2(@Qualifier("JobDetailFactoryBean2") JobDetailFactoryBean jobDetailFactoryBean ){
        CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean();
        factoryBean.setJobDetail(jobDetailFactoryBean.getObject());
        factoryBean.setCronExpression("0/15 * * * * ?");
        return factoryBean;
    }

    /**
     * 初始化Scheduler
     * @param cronTriggerFactoryBean - 上一个方法初始化的CronTriggerFactoryBean
     * @return
     */
    @Bean
    public SchedulerFactoryBean initSchedulerFactoryBean(CronTriggerFactoryBean[] cronTriggerFactoryBean){
        SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();

        CronTrigger[] triggers = new CronTrigger[cronTriggerFactoryBean.length];
        
        for(int i = 0; i < cronTriggerFactoryBean.length; i++){
            triggers[i] = cronTriggerFactoryBean[i].getObject();
        }
        // 注册触发器，一个Scheduler可以注册若干触发器。
        factoryBean.setTriggers(triggers);
        return factoryBean;
    }
}

另一个事件：

package com.lsh.quartz;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Period;

/**
 * @author ：LiuShihao
 * @date ：Created in 2020/8/29 1:00 下午
 * @desc ：
 * Duration   计算两个时间(time)之间的间隔
 * Period     计算两个日期(date)之间的间隔
 */
public class SpringBootQuartzJob2 implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        LocalDate start = LocalDate.of(2019, 07, 07);
        LocalDate now = LocalDate.now();
        Period between = Period.between(start, now);
        LocalDateTime startTime = LocalDateTime.of(2019, 07, 07, 0, 0, 0);
        LocalDateTime now1 = LocalDateTime.now();
        Duration between2 = Duration.between(startTime, now1);
        System.out.println("QuartzJob定时任务执行: 距离2019年7月7日已经："+between.getYears()+"年"+between.getMonths()+"个月"+between.getDays()+"天"+"———————— 一共"+between2.toDays()+"天" );
    }
}

5.1 启动测试

事件1cron表达式设置的是10秒执行一次，
事件2设置的是15秒执行一次。