SpringBoot3整合Quartz实现定时任务的示例_Java

1. 什么是 quartz scheduler？

quartz 是 java 平台下的一个强大、灵活的调度库，它支持复杂的任务调度，包括：

简单的任务：按固定频率或延迟执行任务。
基于 cron 表达式的任务：支持类似于 linux cron 的表达式，用于定义复杂的定时任务。
持久化任务：支持将任务数据持久化存储，以便在应用程序重启后可以恢复任务状态。

2. spring boot 3 集成 quartz scheduler 的优势

无缝集成：通过 spring boot 3 的自动配置特性，无需编写复杂的配置即可使用 quartz。
灵活管理：支持任务的动态添加、暂停、恢复和删除。
扩展性：可以轻松扩展任务调度系统，便于业务逻辑的复杂应用。

3. spring boot 3 集成 quartz 的步骤

3.1 创建 spring boot 项目

可以使用 spring initializr 创建项目，选择以下依赖：

spring web
quartz scheduler

3.2 添加 quartz 依赖

如果使用的是手动创建的项目，可以在 pom.xml 中添加 quartz 的依赖：

        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-quartz</artifactid>
        </dependency>
        <dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-web</artifactid>
        </dependency>

3.3 配置 quartz 属性

在 application.yml 或 application.properties 文件中配置 quartz 的基本属性，例如任务存储和调度方式。

以下是 application.yml 配置示例：

spring:
  application:
    name: spring-boot3-19-quartz
  quartz:
    job-store-type: memory  # 储类型为内存存储
    properties:
      org:
        quartz:
          threadpool:
            threadcount: 5  # 配置线程池线程数为 5
          jobstore:
            misfirethreshold: 60000  # 设置作业存储的错过触发阈值为 60000 毫秒（1分钟）

这里使用了内存存储方式（job-store-type: memory），也可以根据需要配置数据库存储任务信息。

3.4 创建一个 quartz 任务类

创建一个简单的 quartz 任务类，需要实现 job 接口，并重写 execute 方法：

import org.quartz.job;
import org.quartz.jobexecutioncontext;
import org.quartz.jobexecutionexception;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.stereotype.component;

@component
public class samplejob implements job {

    private static final logger logger = loggerfactory.getlogger(samplejob.class);

    @override
    public void execute(jobexecutioncontext context) throws jobexecutionexception {
        logger.info("executing sample job at: " + context.getfiretime());
    }
}

3.5 配置任务调度器

在 spring boot 3 中，可以通过 @configuration 创建 quartz 的调度器，并配置定时任务的触发器（trigger）和任务详情（jobdetail）。

import org.quartz.jobbuilder;
import org.quartz.jobdetail;
import org.quartz.simpleschedulebuilder;
import org.quartz.trigger;
import org.quartz.triggerbuilder;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;

@configuration
public class quartzconfig {

    @bean
    public jobdetail samplejobdetail() {
        return jobbuilder.newjob(samplejob.class)
                .withidentity("samplejob")
                .storedurably()
                .build();
    }

    @bean
    public trigger samplejobtrigger() {
        simpleschedulebuilder schedulebuilder = simpleschedulebuilder.simpleschedule()
                .withintervalinseconds(10)  // 每 10 秒执行一次
                .repeatforever();

        return triggerbuilder.newtrigger()
                .forjob(samplejobdetail())
                .withidentity("samplejobtrigger")
                .withschedule(schedulebuilder)
                .build();
    }
}

samplejobdetail 方法定义了任务的基本信息，包括任务类和名称。
samplejobtrigger 方法定义了触发器的调度策略，这里设置为每 10 秒执行一次。

3.6 使用 cron 表达式配置任务

除了简单的时间间隔，还可以通过 cron 表达式实现更灵活的调度。以下示例展示如何使用 cron 表达式配置任务触发器。

import org.quartz.cronschedulebuilder;
import org.quartz.trigger;
import org.quartz.triggerbuilder;

@bean
public trigger cronjobtrigger() {
    return triggerbuilder.newtrigger()
            .forjob(samplejobdetail())
            .withidentity("cronjobtrigger")
            .withschedule(cronschedulebuilder.cronschedule("0 0/1 * 1/1 * ? *"))  // 每分钟执行一次
            .build();
}

在这个例子中，cron 表达式 "0 0/1 * 1/1 * ? *" 表示每分钟执行一次任务。

4. 运行应用并查看日志

配置完成后，启动 spring boot 应用。quartz scheduler 会按照配置执行 samplejob 任务。您可以在控制台中看到日志输出，类似如下：

2024-11-13t21:07:39.910+08:00  info 11984 --- [spring-boot3-18-quartz] [eduler_worker-4] c.coderjia.boot318quartz.job.samplejob   : executing sample job at: wed nov 13 21:07:39 cst 2024

每 10 秒执行一次效果：

每分钟执行一次效果：

5. 动态管理 quartz 任务

可以在代码中动态地添加、暂停、恢复和删除任务。例如，以下是动态添加任务的示例：

package com.coderjia.boot318quartz;

import org.quartz.jobdetail;
import org.quartz.jobkey;
import org.quartz.scheduler;
import org.quartz.schedulerexception;
import org.quartz.trigger;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.service;

/**
 * @author coderjia
 * @create 2024/11/13 下午 09:25
 * @description
 **/
@service
public class quartzservice {

    private final scheduler scheduler;

    @autowired
    public quartzservice(scheduler scheduler) {
        this.scheduler = scheduler;
    }

    public void schedulejob(jobdetail jobdetail, trigger trigger) {
        try {
            scheduler.schedulejob(jobdetail, trigger);
        } catch (exception e) {
            e.printstacktrace();
        }
    }

    public void pausejob(string jobname, string jobgroup) {
        try {
            jobkey jobkey = new jobkey(jobname, jobgroup);
            scheduler.pausejob(jobkey);
            system.out.println("job paused: " + jobkey);
        } catch (schedulerexception e) {
            e.printstacktrace();
        }
    }

    public void resumejob(string jobname, string jobgroup) {
        try {
            jobkey jobkey = new jobkey(jobname, jobgroup);
            scheduler.resumejob(jobkey);
            system.out.println("job resumed: " + jobkey);
        } catch (schedulerexception e) {
            e.printstacktrace();
        }
    }

    public void deletejob(string jobname, string jobgroup) {
        try {
            jobkey jobkey = new jobkey(jobname, jobgroup);
            boolean deleted = scheduler.deletejob(jobkey);
            if (deleted) {
                system.out.println("job deleted: " + jobkey);
            } else {
                system.out.println("job not found: " + jobkey);
            }
        } catch (schedulerexception e) {
            e.printstacktrace();
        }
    }
}

调用 schedulejob 方法可以动态地添加新的任务。类似地，使用 scheduler.pausejob() 和 scheduler.deletejob() 可以暂停或删除任务。