Quartz + SpringBoot 实现定时任务（多任务，多执行时间）代码模板（转）

一，什么是Quartz

quartz 是一款开源且丰富特性的Java 任务调度库，用于实现任务调度和定时任务。它支持各种任务类型和灵活的配置选项，具备作业持久化、集群和分布式调度、错误处理和重试机制等功能。Quartz被广泛应用于各种应用程序中，提供可靠和灵活的任务调度解决方案。

二，核心概念

任务 Job

我们想要调度的任务都必须实现 org.quartz.job 接口，然后实现接口中定义的 execute( ) 方法即可。

但是我们这里使用配置类的方法，可不实现 job接口 直接，在里面定义自己的方法，去实现任务逻辑

触发器 Trigger

​ Trigger 作为执行任务的调度器,它规定安排了关联的任务会在什么时候执行，并且表明了再次执行的时机。我们如果想要凌晨1点执行备份数据的任务，那么 Trigger 就会设置凌晨1点执行该任务。

​ 其中 Trigger 的实现又分为 SimpleTrigger ， CronTrigger ，CalendarIntervalTrigger， DailyTimeIntervalTrigger， MutableTrigger ，OperableTrigger 几种

​ 一般情况下我们使用是的是 CronTrigger ，因为这个可以编写 cron 表达式，对时间的定制化更高，编写更方便。对 Trigger 的各种实现和更详细的内容本文就不过多介绍，有兴趣的小伙伴可以自行百度。

这里提供一个cron表达式在线生成网址：Cron - 在线Cron表达式生成器

调度器 Scheduler

Scheduler 为任务的调度器，它会将任务 Job 及触发器 Trigger 整合起来，负责基于 Trigger 设定的时间来执行 Job

三者的关系图为：

三，代码实现

两个任务分别不同时间去执行：

QuartzFirst ：每天晚上22.30 执行

QuartzSecond：每天晚上 23.00 执行

想马上看到效果可自己修改cron 表达式，或者把下面提供 cron 注释打开

添加依赖

在 pom.xml 中添加 Quartz 依赖，

<!--定时任务 核心包-->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.2</version>
        </dependency>
        <!--工具-->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
            <version>2.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.7</version>
            <scope>compile</scope>
        </dependency>

创建配置类（核心）

@Configuration
public class QuartzConfig {

    /**
     * 配置定时任务1的任务实例
     * @param  job 任务 QuartzFirst 这个是自己定义job,这里是 类名
     */
    @Bean(name = "firstJobDetail")
    public MethodInvokingJobDetailFactoryBean firstJobDetail(QuartzFirst job) {
        MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
        // 是否并发执行
        jobDetail.setConcurrent(false);
        // 为需要执行的实体类对应的对象
        jobDetail.setTargetObject(job);
        // 需要执行的方法
        jobDetail.setTargetMethod("JobTest");
        return jobDetail;
    }

    /**
     *   配置触发器1
     * @param firstJobDetail 第一个触发器
     * @return
     */
    @Bean(name = "firstTrigger")
    public CronTriggerFactoryBean firstTrigger(JobDetail firstJobDetail) {
        CronTriggerFactoryBean trigger = new CronTriggerFactoryBean();
        trigger.setJobDetail(firstJobDetail);
        // 设置任务启动延迟
        trigger.setStartDelay(0);
        // 设置定时任务启动时间
        trigger.setStartTime(new Date());
        // 每晚 22.30 执行
        trigger.setCronExpression("0 30 22 ? * *");

        // 每3秒 执行一次
        //trigger.setCronExpression("0/3 * * * * ?");    
            
       // 每5秒执行一次
        //trigger.setRepeatInterval(5000);
        return trigger;
    }


    /**
     * 配置定时任务2的任务实例
     * @param  job 任务  QuartzSecond 这个是自己定义job，这里是 类名
     */
    @Bean(name = "secondJobDetail")
    public MethodInvokingJobDetailFactoryBean secondJobDetail(QuartzSecond job) {
        MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
        // 是否并发执行
        jobDetail.setConcurrent(true);
        // 为需要执行的实体类对应的对象
        jobDetail.setTargetObject(job);
        // 需要执行的方法
        jobDetail.setTargetMethod("JobTest");
        return jobDetail;
    }

    /**
     * 配置触发器2
     * @param secondJobDetail 第二个触发器
     * @return
     */
    @Bean(name = "secondTrigger")
    public CronTriggerFactoryBean secondTrigger(JobDetail secondJobDetail) {
        CronTriggerFactoryBean trigger = new CronTriggerFactoryBean();
        trigger.setJobDetail(secondJobDetail);
        // 设置定时任务启动时间
        trigger.setStartTime(new Date());
        // cron表达式(每天晚上23点执行)
         trigger.setCronExpression("0 0 23 ? * *");
        
        // 每 5 秒 执行一次
        //trigger.setCronExpression("0/5 * * * * ?"); 
        
        return trigger;
    }


    /**
     *  定义 任务，传入 triggers
     * @param triggers 触发器
     * @return
     */
    @Bean
    public SchedulerFactoryBean scheduler1(Trigger... triggers){
        SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();
        // 设置 triggers
        factoryBean.setTriggers( triggers );
        // 用于quartz集群,QuartzScheduler 启动时更新己存在的Job
        factoryBean.setOverwriteExistingJobs(true);
        // 延时启动，应用启动3秒后
        factoryBean.setStartupDelay(3);
        return factoryBean;
    }


}

上面 QuartzFirst 和 QuartzSecond 类是自己定义的job类，把 类名 作为参数传递，然后中 job 类中就可以实现自己的业务逻辑。

编写 Job 类

QuartzFirst

@Configuration
public class QuartzFirst {

    public Logger log = LoggerFactory.getLogger(QuartzFirst.class);

    @Resource
    AttendanceRecordBiz attendanceRecordBiz;
    
    public void JobTest(){
        
        //  DateUtil 这个是hutool 的工具类
        log.info(" 执行开始时间为：" + DateUtil.date());
        
        
        /**
        * 在这里就可以实现自己的逻辑，比如执行某个方法，和 DB 交互等，都可以在上面进行注入，和写普通的是实现方法一样就行
        *
        **/
        log.info("点个赞哦 ~~~")   

       

        log.info(" 执行结束时间为：" + DateUtil.date());
     
    }

}

QuartzSecond

@Configuration
public class QuartzSecond {

    public Logger log = LoggerFactory.getLogger(QuartzSecond.class);

    @Resource
    SalaryDataBiz salaryDataBiz;
    
    public void JobTest(){

     //  DateUtil 这个是hutool 的工具类
        log.info(" 执行开始时间为：" + DateUtil.date());
        
        
        /**
        * 在这里就可以实现自己的逻辑，比如执行某个方法，和 DB 交互等，都可以在上面进行注入，和写普通的是实现方法一样就行
        *
        **/
        log.info("点个赞哦 ~~~")   

       

        log.info(" 执行结束时间为：" + DateUtil.date());
    }
}

到这里就实现定时任务了，在项目启动的时候后 3 秒就会去开启定时任务了。