【SpringBoot】9 定时任务（Quartz）

介绍

实现方式

java定时任务调度的实现方式：Timer，ScheduledExecutor，Spring Scheduler，JCron Tab，Quartz 等。

Quartz

Quartz是一个由Java开发的开源项目，它可以与J2EE、J2SE应用程序相结合也可以单独使用。

Quartz是一个定时调度框架，用来执行定时任务（某个时间出发执行某个动作）。

官网

https://www.quartz-scheduler.org/

核心概念

Scheduler：调度器，负责进行任务的调度与管理。Scheduler可以启动、停止、暂停、恢复任务的执行，还可以配置任务的触发条件和执行计划。

Trigger：触发器，负责定义任务的触发条件，即何时触发任务执行。一个Job可以关联一个或多个Trigger，根据时间表达式或特定的时间间隔来配置触发器。

TriggerBuilder：触发器构建器，用来创建触发器的实例。

Job：业务组件，需要被调度任务执行的具体事件。需要将Job注册到Scheduler中，调度器会调用Job接口的execute方法完成具体的业务实现。

JobDetail：任务详情，JobDetail是与Job相关联的详细信息，包括Job名称、所属的Job类、Job的身份标识等。

JobBuilder：任务构建器，用来创建JobDetail实例。

JobStore：任务存储，Quartz的持久化机制，负责将任务和调度相关的信息存储到数据库或其他存储介质中。即使应用程序重启或服务器关闭，已经配置的调度任务仍然可以保留。

Listener：监听器，Quartz提供了丰富的监听器接口，可以监控任务的状态变化、执行情况、异常事件。通过实现监听器接口，可以在任务执行前后、暂停、恢复、出错等情况下执行额外的逻辑。

ThreadPool：线程池，Scheduler使用线程池来并发执行任务，提高任务的处理效率。允许配置线程池的大小、类型、特性，以适应不同的负载情况。

三大核心组件

Scheduler（调度器）、Trigger（触发器）、Job（任务）

持久化方式

Quartz提供了两种持久化方式

1）RAMJobStore：在默认情况下，Quartz会将任务调度的运行信息保存在内存中，这种方法提供了最佳的性能。不足之处是缺乏数据的持久性，当程序停止或崩溃时，所有运行的信息都会丢失。

2）JobStoreTX：分布式方式一般采用此中方式，持久化到数据库中。所有的任务信息都会保存到数据库中，可以控制事务，如果应用程序或服务器关闭或重启时，已经保存到数据库中的任务信息不会丢失，并且可以恢复继续执行。

依赖

pom.xml

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

<!-- 读取yml配置文件 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

方式1（简单）

需求

实现固定的一个或几个Job的定时任务的效果。

效果图

代码实现

ScheduleConfig.java

package com.lm.system.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

/**
 * @author DUHAOLIN
 * @date 2024/8/12
 */
@Data
@Configuration
@ConfigurationProperties(prefix = "schedule")
public class ScheduleConfig {

    private String cron;

}

application.yml

schedule:
  cron:  0/5 * * * * ?  #5s执行一次

Task.java

package com.lm.system.job;

import lombok.extern.slf4j.Slf4j;

import java.util.Random;

/**
 * 具体的任务类
 * @author DUHAOLIN
 * @date 2024/8/12
 */
@Slf4j
public class Task {

    public void execute(int arg) {
        int i = new Random().nextInt(arg);
        log.info("执行具体任务,{}", i);
    }

}

TaskSchedule.java

package com.lm.system.job;

import com.lm.system.config.ScheduleConfig;
import lombok.extern.slf4j.Slf4j;
import org.quartz.JobDetail;
import org.quartz.Trigger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import javax.annotation.Resource;

/**
 * @author DUHAOLIN
 * @date 2024/8/12
 */
@Slf4j
@Configuration
public class TaskSchedule {

    @Resource
    private ScheduleConfig scheduleConfig;

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(Trigger taskTrigger) {
        log.info("注册调度器");
        SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();
        factoryBean.setTriggers(taskTrigger); //注册触发器
        return factoryBean;
    }

    @Bean
    public CronTriggerFactoryBean taskTrigger(JobDetail taskJob) {
        log.info("注册触发器");
        CronTriggerFactoryBean bean = new CronTriggerFactoryBean();
        bean.setJobDetail(taskJob);
        bean.setCronExpression(scheduleConfig.getCron());
        return bean;
    }

    @Bean
    public MethodInvokingJobDetailFactoryBean taskJob() {
        log.info("注册任务");
        MethodInvokingJobDetailFactoryBean bean = new MethodInvokingJobDetailFactoryBean();
        bean.setConcurrent(false); //同一Job不允许并发执行
        bean.setTargetObject(new Task()); //目标方法所在的实例对象
        bean.setTargetMethod("execute"); //需要执行的方法
        bean.setArguments(100); //需要执行的方法的入参
        return bean;
    }

}

项目目录结构图

方式2（按配置文件配置加载）