Spring Boot整合Quartz使用的详解

尘缘_
2 阅读10分钟

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工程。以下是详细的步骤：

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

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

2.2 添加依赖

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

  1. 添加Spring Boot Starter Quartz依赖：这个依赖会简化Quartz与Spring Boot的集成过程。在<dependencies>标签内添加以下代码：

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

  2. 添加Quartz核心依赖：虽然Spring Boot Starter已经包含了Quartz，但有时你可能需要指定Quartz的版本，特别是当你需要使用特定版本的特性时。在<dependencies>标签内添加以下代码：

     <dependency>
     <groupId>org.quartz-scheduler</groupId>
     <artifactId>quartz</artifactId>
     <version>2.3.2</version> <!-- 请根据实际情况选择合适的版本 -->
 </dependency>

  3. 添加数据库相关依赖（可选）：如果你打算使用持久化存储任务信息，还需要添加数据库相关的依赖，例如MySQL的驱动依赖，并在application.yml或application.properties中配置数据源。

     <dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>8.0.26</version> <!-- 使用适合你项目的版本 -->
 </dependency>

  4. 创建Job类：实现org.quartz.Job接口来定义你的任务类。

  5. 配置调度器：在Spring Boot的配置类中，你可以使用@Configuration和@EnableScheduling注解来配置Quartz的调度器。

  6. 定义调度任务：使用@Scheduled注解来定义定时任务的执行时间和周期。

  7. 启动测试：在主启动类中启动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();
    }
}

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

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 name="dataSource" ref="dataSource" />
    <property name="transactionManager" ref="transactionManager" />
    <property name="configLocation" value="classpath:quartz.properties" />
    <property name="applicationContextSchedulerContextKey" value="applicationContext" />
</bean>

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

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

6.2 启用定时任务

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

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

<bean id="myTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
    <property name="jobDetail" ref="myJobDetail" />
    <property name="cronExpression" value="0/5 * * * * ?" />
</bean>

<bean id="myJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    <property name="targetObject" ref="myTask" />
    <property name="targetMethod" value="run" />
</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 name="triggers">
        <list>
            <ref bean="myTrigger" />
        </list>
    </property>
</bean>

<bean id="myTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
    <property name="jobDetail" ref="myJobDetail" />
    <property name="cronExpression" value="0/5 * * * * ?" />
</bean>

<bean id="myJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    <property name="targetObject" ref="myTask" />
    <property name="targetMethod" value="run" />
</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("定时任务执行了");
    }
}

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

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

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

avatar
文章
阅读
粉丝
相关推荐
@Value使用详解快速入门
87阅读
 · 
1点赞
并发容器之CopyOnWrite
299阅读
 · 
0点赞
Java_滑动窗口_找到字符串中所有字母异位词
195阅读
 · 
4点赞
关于ListUtils.partition、Lists.partition方法的实现原理——类似于懒加载思想
180阅读
 · 
1点赞
Spring Boot 入参校验及全局异常处理
88阅读
 · 
1点赞