Spring Boot整合Quartz使用的详解

本文由简悦 SimpRead 转码，原文地址 blog.csdn.net

🎉🎉欢迎来到我的 CSDN 主页！🎉🎉
🏅我是尘缘，一个在 CSDN 分享笔记的博主。📚📚
👉点击这里，就可以查看我的主页啦！👇👇
尘缘的个人主页
🎁如果感觉还不错的话请给我点赞吧！🎁🎁
💖期待你的加入，一起学习，一起进步！💖💖

Spring Boot 整合 Quartz 使用的详解
1 引言
2 准备工作
- 2.1 创建基于 Spring Boot 的 Maven 工程
- 2.2 添加依赖
3 创建定时任务
5 添加定时任务管理功能
- 5.1 创建定时任务管理类
- 5.2 设置定时任务的触发时间和频率
6 整合 Quartz 和 Spring 容器
- 6.1 配置 SchedulerFactoryBean
- 6.2 启用定时任务
7 编写定时任务逻辑
- 7.1 在具体的定时任务方法中编写逻辑
- 7.2 使用 @Scheduled 注解定义触发条件和执行频率
8 运行应用程序
- 8.1 启动 Spring Boot 应用程序
- 8.2 观察定时任务的执行情况

Spring Boot 整合 Quartz 使用的详解

1 引言

Spring Boot 整合 Quartz 主要是为了在 Spring Boot 应用中方便地使用 Quartz 定时任务框架。Quartz 是一个开源的 Java 定时任务调度框架，可以方便地创建、管理和执行定时任务。而 Spring Boot 则是一个基于 Spring 框架的快速开发工具，可以简化 Spring 应用的开发和部署过程。

2 准备工作

2.1 创建基于 Spring Boot 的 Maven 工程

在完成了 Spring Boot 与 Quartz 的集成之后，接下来是创建基于 Spring Boot 的 Maven 工程。以下是详细的步骤：

安装 Maven：确保您的计算机上已经安装了 Maven，这是构建和管理 Spring Boot 项目的关键工具。
创建 Spring Boot 项目：您可以使用 IDEA 开发工具来创建一个新的 Spring Boot 项目。在 IDEA 中选择 “File” > “New” > “Project”，然后选择 “Spring Initializr”（脚手架）来快速创建项目。您需要选择项目的 JDK 版本，并填写项目的基本信息，如 GroupId、ArtifactId 等。
配置 Maven：在项目中配置 Maven，这包括设置 pom.xml 文件，添加必要的依赖项，以及配置项目的构建路径和插件。
编译和运行项目：使用 Maven 命令来编译和运行 Spring Boot 项目。您可以在 IDEA 的终端中使用 Maven 命令，或者直接在命令行中操作。例如，使用mvn clean install来构建项目，然后使用mvn spring-boot:run来启动项目。

如果是 Spring Boot 初学者，可以参考一些开发笔记和教程，这些资料通常会详细解释如何使用 Maven 来创建和管理 Spring Boot 项目，包括多模块项目的搭建过程。

2.2 添加依赖

在 Spring Boot 中整合 Quartz，首先需要做的是在项目的 pom.xml 文件中添加必要的依赖。以下是具体步骤：

添加 Spring Boot Starter Quartz 依赖：这个依赖会简化 Quartz 与 Spring Boot 的集成过程。在<dependencies>标签内添加以下代码：
```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
```
添加 Quartz 核心依赖：虽然 Spring Boot Starter 已经包含了 Quartz，但有时你可能需要指定 Quartz 的版本，特别是当你需要使用特定版本的特性时。在<dependencies>标签内添加以下代码：
```
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.2</version> 
</dependency>
```
添加数据库相关依赖（可选）：如果你打算使用持久化存储任务信息，还需要添加数据库相关的依赖，例如 MySQL 的驱动依赖，并在application.yml或application.properties中配置数据源。
```
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.26</version> 
</dependency>
```
创建 Job 类：实现org.quartz.Job接口来定义你的任务类。
配置调度器：在 Spring Boot 的配置类中，你可以使用@Configuration和@EnableScheduling注解来配置 Quartz 的调度器。
定义调度任务：使用@Scheduled注解来定义定时任务的执行时间和周期。
启动测试：在主启动类中启动 Spring Boot 应用，并观察 Quartz 任务是否按预期执行。

通过以上步骤，你可以在 Spring Boot 项目中成功整合 Quartz，并创建、管理和执行定时任务。

3 创建定时任务

3.1 创建 Job 类

在 Quartz 中，Job 是执行定时任务的具体逻辑。你需要创建一个类来实现org.quartz.Job接口，并重写execute方法来定义具体的任务逻辑。

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

public class MyJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 在这里编写你的任务逻辑
        System.out.println("定时任务执行了！");
    }
}

创建了一个名为MyJob的类，实现了Job接口，并重写了execute方法。在execute方法中，你可以编写你的任务逻辑，这里只是简单地打印了一条消息。

3.2 定义 Job 的执行逻辑

在 Quartz 中，Job 的执行逻辑是通过实现org.quartz.Job接口的execute方法来定义的。execute方法接收一个JobExecutionContext参数，该参数包含了执行上下文信息，如 JobDetail、Trigger 等。

可以在execute方法中编写你的任务逻辑，例如调用其他服务或执行数据库操作。

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

public class MyJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 在这里编写你的任务逻辑
        System.out.println("定时任务执行了！");
        // 调用其他服务或执行数据库操作
        // ...
    }
}

在execute方法中打印了一条消息，并可以在该方法中调用其他服务或执行数据库操作。

3.3 创建 Quartz 配置类

在 Quartz 中，配置类是用于定义任务调度器的配置信息。你可以创建一个配置类来设置任务的触发器、JobDetail 等。

要创建 Quartz 配置类，你需要使用org.quartz.impl.StdSchedulerFactory类的getDefaultScheduler方法获取默认的任务调度器，并使用org.quartz.Scheduler接口的方法进行配置。

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

public class QuartzConfig {
    public static void main(String[] args) throws SchedulerException {
        // 创建Scheduler对象
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        // 创建JobDetail对象
        JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
                .withIdentity("myJob", "myGroup") // 设置任务名称和组名
                .build();

        // 创建Trigger对象
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger", "myGroup") // 设置触发器名称和组名
                .startNow() // 立即启动触发器
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(10) // 设置触发间隔为10秒
                        .repeatForever()) // 无限循环执行
                .build();

        // 将JobDetail和Trigger添加到调度器中
        scheduler.scheduleJob(jobDetail, trigger);

        // 启动调度器
        scheduler.start();
    }
}

首先通过StdSchedulerFactory.getDefaultScheduler方法获取了默认的任务调度器。然后，创建了一个 JobDetail 对象和一个 Trigger 对象，分别设置了任务的名称、组名、触发器的间隔等信息。接下来，将 JobDetail 和 Trigger 添加到调度器中，并启动调度器。

3.4 配置 JobDetail

要配置 JobDetail，你需要创建一个org.quartz.JobDetail对象，并设置相应的属性。

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;

// 创建JobDetail对象
JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
        .withIdentity("myJob", "myGroup") // 设置任务名称和组名
        .build();

// 获取JobKey
JobKey jobKey = jobDetail.getKey();

使用JobBuilder来创建一个新的 JobDetail 对象，并指定了任务的类为MyJob。然后，通过withIdentity方法设置了任务的名称为 "myJob"，组名为 "myGroup"。最后，通过build方法构建了 JobDetail 对象，并通过getKey方法获取了 JobKey。

3.5 配置 Trigger

要配置 Trigger，你需要创建一个org.quartz.Trigger对象，并设置相应的属性。

import org.quartz.TriggerBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerKey;

// 创建Trigger对象
Trigger trigger = TriggerBuilder.newTrigger()
        .withIdentity("myTrigger", "myGroup") // 设置触发器名称和组名
        .startNow() // 立即启动触发器
        .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                .withIntervalInSeconds(10) // 设置触发间隔为10秒
                .repeatForever()) // 无限循环执行
        .build();

// 获取TriggerKey
TriggerKey triggerKey = trigger.getKey();

使用TriggerBuilder来创建一个新的 Trigger 对象，并指定了触发器的名称为 "myTrigger"，组名为 "myGroup"。然后，通过startNow方法设置了触发器立即启动，并使用withSchedule方法设置了触发器的调度策略。这里使用了SimpleScheduleBuilder来创建一个简单调度策略，设置了触发间隔为 10 秒，并设置为无限循环执行。最后，通过build方法构建了 Trigger 对象，并通过getKey方法获取了 TriggerKey。

3.6 配置 Scheduler

要配置 Scheduler，你需要使用org.quartz.impl.StdSchedulerFactory类的getDefaultScheduler方法获取默认的任务调度器，并使用org.quartz.Scheduler接口的方法进行配置。

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

public class QuartzConfig {
    public static void main(String[] args) throws SchedulerException {
        // 创建Scheduler对象
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        // 创建JobDetail对象
        JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
                .withIdentity("myJob", "myGroup") // 设置任务名称和组名
                .build();

        // 创建Trigger对象
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger", "myGroup") // 设置触发器名称和组名
                .startNow() // 立即启动触发器
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(10) // 设置触发间隔为10秒
                        .repeatForever()) // 无限循环执行
                .build();

        // 将JobDetail和Trigger添加到调度器中
        scheduler.scheduleJob(jobDetail, trigger);

        // 启动调度器
        scheduler.start();
    }
}

5 添加定时任务管理功能

5.1 创建定时任务管理类

首先，需要创建一个定时任务管理类，用于存储和管理定时任务。这个类可以包含以下属性和方法：

tasks：一个字典，用于存储所有的定时任务，键为任务 ID，值为任务对象。
add_task(task)：添加一个新的定时任务。
remove_task(task_id)：根据任务 ID 移除一个定时任务。
get_task(task_id)：根据任务 ID 获取一个定时任务。
run_tasks()：运行所有定时任务。

class TaskManager:
    def __init__(self):
        self.tasks = {}

    def add_task(self, task):
        self.tasks[task.id] = task

    def remove_task(self, task_id):
        if task_id in self.tasks:
            del self.tasks[task_id]

    def get_task(self, task_id):
        return self.tasks.get(task_id)

    def run_tasks(self):
        for task in self.tasks.values():
            task.run()

5.2 设置定时任务的触发时间和频率

接下来，需要在定时任务类中添加触发时间和频率的属性，并在初始化时进行设置。同时，需要修改run_tasks()方法，使其根据任务的触发时间和频率来决定是否运行任务。

以下是一个简单的实现：

import time

class Task:
    def __init__(self, id, trigger_time, frequency):
        self.id = id
        self.trigger_time = trigger_time
        self.frequency = frequency

    def run(self):
        print(f"Running task {self.id}")

class TaskManager:
    def __init__(self):
        self.tasks = {}

    def add_task(self, task):
        self.tasks[task.id] = task

    def remove_task(self, task_id):
        if task_id in self.tasks:
            del self.tasks[task_id]

    def get_task(self, task_id):
        return self.tasks.get(task_id)

    def run_tasks(self):
        current_time = time.time()
        for task in self.tasks.values():
            if current_time >= task.trigger_time and (current_time - task.trigger_time) % task.frequency == 0:
                task.run()

这样，就实现了一个简单的定时任务管理系统，可以根据任务的触发时间和频率来运行任务。

6 整合 Quartz 和 Spring 容器

6.1 配置 SchedulerFactoryBean

要在 Spring 容器中整合 Quartz，需要配置一个SchedulerFactoryBean。这个 bean 负责创建和管理 Quartz 的调度器。可以在 Spring 的配置文件中添加以下配置：

<bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    <property  />
    <property  />
    <property  />
    <property  />
</bean>

这里设置了以下几个属性：

dataSource：数据源，用于存储 Quartz 的持久化数据。
transactionManager：事务管理器，用于管理 Quartz 的事务。
configLocation：Quartz 的配置文件位置。
applicationContextSchedulerContextKey：将 Spring 的应用上下文注入到 Quartz 的调度器上下文中，以便在任务中使用 Spring 的功能。

6.2 启用定时任务

要启用定时任务，需要在 Spring 的配置文件中添加以下配置：

<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    <property >
        <list>
            <ref bean="myTrigger" />
        </list>
    </property>
</bean>

<bean id="myTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
    <property  />
    <property 0/5 * * * * ?" />
</bean>

<bean id="myJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    <property  />
    <property  />
</bean>

<bean id="myTask" class="com.example.MyTask" />

这里定义了一个触发器myTrigger，它的 cron 表达式为0/5 * * * * ?，表示每 5 秒执行一次。触发器关联的任务详情myJobDetail调用了com.example.MyTask类的run方法。最后，将触发器添加到调度器的配置中。

7 编写定时任务逻辑

7.1 在具体的定时任务方法中编写逻辑

首先，需要在定时任务类中定义一个方法，用于执行定时任务的逻辑。例如，可以创建一个名为MyTask的类，并在其中定义一个名为run的方法：

public class MyTask {
    public void run() {
        // 在这里编写定时任务的逻辑
        System.out.println("定时任务执行了");
    }
}

7.2 使用 @Scheduled 注解定义触发条件和执行频率

接下来，需要在 Spring 容器中配置定时任务。可以在 Spring 的配置文件中添加以下配置：

<bean id="myTask" class="com.example.MyTask" />

<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    <property >
        <list>
            <ref bean="myTrigger" />
        </list>
    </property>
</bean>

<bean id="myTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
    <property  />
    <property 0/5 * * * * ?" />
</bean>

<bean id="myJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    <property  />
    <property  />
</bean>

这里使用了MethodInvokingJobDetailFactoryBean来关联定时任务类MyTask的run方法。同时，使用了CronTriggerFactoryBean来定义触发器，并设置了 cron 表达式为0/5 * * * * ?，表示每 5 秒执行一次。最后，将触发器添加到调度器的配置中。

8 运行应用程序

8.1 启动 Spring Boot 应用程序

要启动 Spring Boot 应用程序，可以在命令行中执行以下命令：

mvn spring-boot:run

这将启动应用程序，并在控制台输出日志信息。

8.2 观察定时任务的执行情况

在应用程序启动后，可以观察到定时任务的执行情况。例如，可以在MyTask类的run方法中添加一些日志输出，以观察定时任务的执行情况：

public class MyTask {
    public void run() {
        // 在这里编写定时任务的逻辑
        System.out.println("定时任务执行了");
    }
}

当运行应用程序时，应该能够在控制台看到类似以下的输出：

定时任务执行了
定时任务执行了
定时任务执行了
...

这表明定时任务正在按照设置的触发条件和执行频率正常运行。

到这里我的分享就结束了，欢迎到评论区探讨交流！！
💖如果觉得有用的话还请点个赞吧 💖