SpringBoot3.x引入Quartz，持久化到MySQL数据库

最新推荐文章于 2025-08-17 21:38:20 发布
原创 最新推荐文章于 2025-08-17 21:38:20 发布 · 268 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据库 #mysql #定时任务 #Quartz

示例版本

  • SpringBoot3.2.11
  • JDK17
  • MySQL5.7.38

Cron

在线Cron表达式生成器：https://www.pppet.net

持久化SQL语句

DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
DROP TABLE IF EXISTS QRTZ_LOCKS;
DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
DROP TABLE IF EXISTS QRTZ_CALENDARS;

CREATE TABLE QRTZ_JOB_DETAILS(
  SCHED_NAME VARCHAR(120) NOT NULL,
  JOB_NAME VARCHAR(190) NOT NULL,
  JOB_GROUP VARCHAR(190) NOT NULL,
  DESCRIPTION VARCHAR(250) NULL,
  JOB_CLASS_NAME VARCHAR(250) NOT NULL,
  IS_DURABLE VARCHAR(1) NOT NULL,
  IS_NONCONCURRENT VARCHAR(1) NOT NULL,
  IS_UPDATE_DATA VARCHAR(1) NOT NULL,
  REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
  JOB_DATA BLOB NULL,
  PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_TRIGGERS (
  SCHED_NAME VARCHAR(120) NOT NULL,
  TRIGGER_NAME VARCHAR(190) NOT NULL,
  TRIGGER_GROUP VARCHAR(190) NOT NULL,
  JOB_NAME VARCHAR(190) NOT NULL,
  JOB_GROUP VARCHAR(190) NOT NULL,
  DESCRIPTION VARCHAR(250) NULL,
  NEXT_FIRE_TIME BIGINT(13) NULL,
  PREV_FIRE_TIME BIGINT(13) NULL,
  PRIORITY INTEGER NULL,
  TRIGGER_STATE VARCHAR(16) NOT NULL,
  TRIGGER_TYPE VARCHAR(8) NOT NULL,
  START_TIME BIGINT(13) NOT NULL,
  END_TIME BIGINT(13) NULL,
  CALENDAR_NAME VARCHAR(190) NULL,
  MISFIRE_INSTR SMALLINT(2) NULL,
  JOB_DATA BLOB NULL,
  PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
  FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
  REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_SIMPLE_TRIGGERS (
  SCHED_NAME VARCHAR(120) NOT NULL,
  TRIGGER_NAME VARCHAR(190) NOT NULL,
  TRIGGER_GROUP VARCHAR(190) NOT NULL,
  REPEAT_COUNT BIGINT(7) NOT NULL,
  REPEAT_INTERVAL BIGINT(12) NOT NULL,
  TIMES_TRIGGERED BIGINT(10) NOT NULL,
  PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
  FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
  REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_CRON_TRIGGERS (
  SCHED_NAME VARCHAR(120) NOT NULL,
  TRIGGER_NAME VARCHAR(190) NOT NULL,
  TRIGGER_GROUP VARCHAR(190) NOT NULL,
  CRON_EXPRESSION VARCHAR(120) NOT NULL,
  TIME_ZONE_ID VARCHAR(80),
  PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
  FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
  REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_SIMPROP_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(190) NOT NULL,
    TRIGGER_GROUP VARCHAR(190) NOT NULL,
    STR_PROP_1 VARCHAR(512) NULL,
    STR_PROP_2 VARCHAR(512) NULL,
    STR_PROP_3 VARCHAR(512) NULL,
    INT_PROP_1 INT NULL,
    INT_PROP_2 INT NULL,
    LONG_PROP_1 BIGINT NULL,
    LONG_PROP_2 BIGINT NULL,
    DEC_PROP_1 NUMERIC(13,4) NULL,
    DEC_PROP_2 NUMERIC(13,4) NULL,
    BOOL_PROP_1 VARCHAR(1) NULL,
    BOOL_PROP_2 VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_BLOB_TRIGGERS (
  SCHED_NAME VARCHAR(120) NOT NULL,
  TRIGGER_NAME VARCHAR(190) NOT NULL,
  TRIGGER_GROUP VARCHAR(190) NOT NULL,
  BLOB_DATA BLOB NULL,
  PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
  INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),
  FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
  REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_CALENDARS (
  SCHED_NAME VARCHAR(120) NOT NULL,
  CALENDAR_NAME VARCHAR(190) NOT NULL,
  CALENDAR BLOB NOT NULL,
  PRIMARY KEY (SCHED_NAME,CALENDAR_NAME))
ENGINE=InnoDB;

CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS (
  SCHED_NAME VARCHAR(120) NOT NULL,
  TRIGGER_GROUP VARCHAR(190) NOT NULL,
  PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_FIRED_TRIGGERS (
  SCHED_NAME VARCHAR(120) NOT NULL,
  ENTRY_ID VARCHAR(95) NOT NULL,
  TRIGGER_NAME VARCHAR(190) NOT NULL,
  TRIGGER_GROUP VARCHAR(190) NOT NULL,
  INSTANCE_NAME VARCHAR(190) NOT NULL,
  FIRED_TIME BIGINT(13) NOT NULL,
  SCHED_TIME BIGINT(13) NOT NULL,
  PRIORITY INTEGER NOT NULL,
  STATE VARCHAR(16) NOT NULL,
  JOB_NAME VARCHAR(190) NULL,
  JOB_GROUP VARCHAR(190) NULL,
  IS_NONCONCURRENT VARCHAR(1) NULL,
  REQUESTS_RECOVERY VARCHAR(1) NULL,
  PRIMARY KEY (SCHED_NAME,ENTRY_ID))
ENGINE=InnoDB;

CREATE TABLE QRTZ_SCHEDULER_STATE (
  SCHED_NAME VARCHAR(120) NOT NULL,
  INSTANCE_NAME VARCHAR(190) NOT NULL,
  LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
  CHECKIN_INTERVAL BIGINT(13) NOT NULL,
  PRIMARY KEY (SCHED_NAME,INSTANCE_NAME))
ENGINE=InnoDB;

CREATE TABLE QRTZ_LOCKS (
  SCHED_NAME VARCHAR(120) NOT NULL,
  LOCK_NAME VARCHAR(40) NOT NULL,
  PRIMARY KEY (SCHED_NAME,LOCK_NAME))
ENGINE=InnoDB;

CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY ON QRTZ_JOB_DETAILS(SCHED_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_J_GRP ON QRTZ_JOB_DETAILS(SCHED_NAME,JOB_GROUP);

CREATE INDEX IDX_QRTZ_T_J ON QRTZ_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_JG ON QRTZ_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_C ON QRTZ_TRIGGERS(SCHED_NAME,CALENDAR_NAME);
CREATE INDEX IDX_QRTZ_T_G ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_T_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_G_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME ON QRTZ_TRIGGERS(SCHED_NAME,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);

CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME);
CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_FT_J_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_JG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_T_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_FT_TG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);

commit;

项目改造

  1. 添加依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
  1. 配置yml文件
# 定时任务配置
quartz:
  # 任务存储类型
  job-store-type: jdbc
  # 关闭时等待任务完成
  wait-for-jobs-to-complete-on-shutdown: false
  # 是否覆盖已有的任务
  overwrite-existing-jobs: true
  # 是否自动启动计划程序
  auto-startup: true
  # 延迟启动
  startup-delay: 0s
  jdbc:
    # 数据库架构初始化模式（never：从不进行初始化；always：每次都清空数据库进行初始化；embedded：只初始化内存数据库（默认值））
    # 注意：第一次启动后，需要将always改为never，否则后续每次启动都会重新初始化quartz数据库
    initialize-schema: never
    # 用于初始化数据库架构的SQL文件的路径
    # schema: classpath:sql/tables_mysql_innodb.sql
  # 相关属性配置
  properties:
    org:
      quartz:
        scheduler:
          # 调度器实例名称
          instanceName: QuartzScheduler
          # 分布式节点ID自动生成
          instanceId: AUTO
          # 禁用调度器实例的恢复机制
          makeSchedulerThreadDaemon: true
        jobStore:
          class: org.springframework.scheduling.quartz.LocalDataSourceJobStore
          driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
          # 表前缀
          tablePrefix: QRTZ_
          # 是否开启集群
          isClustered: true
          # 数据源别名（自定义）
          dataSource: quartz
          # 分布式节点有效性检查时间间隔（毫秒）
          clusterCheckinInterval: 10000
          useProperties: false

        # 线程池配置
        threadPool:
          class: org.quartz.simpl.SimpleThreadPool
          threadCount: 10
          threadPriority: 5
          threadsInheritContextClassLoaderOfInitializingThread: true
  1. 参数解释
    • 在Spring Boot中集成Quartz并使用数据库持久化时，spring.quartz.jdbc.initialize-schema 是一个重要配置项，它控制Quartz数据库表的初始化行为
      1. always：每次应用启动时都会尝试创建Quartz所需的数据库表（如果表不存在）。
      2. never：永远不会自动初始化表结构。可以执行Quartz发行包的docs/dbTables里的SQL文件来创建。
      3. embedded：仅当使用嵌入式数据库（如H2、HSQLDB、Derby）时才会初始化表结构。
    • spring.quartz.properties.org.quartz.threadPool.threadCount 是配置Quartz调度器线程池大小的关键参数，它决定了Quartz可以同时执行多少个作业。
      1. 如果使用JDBC JobStore，确保数据库连接池大小 ≥ Quartz线程数
      2. 不要设置过大，过大的线程数会导致：
        • 内存消耗增加
        • 线程上下文切换开销增大
        • 可能拖慢整个系统
      3. 典型配置范围：
        • 开发环境：5-10
        • 中小型生产环境：10-25
        • 大型高并发环境：25-50（不建议超过50）
  2. 创建测试执行方法

import lombok.extern.slf4j.Slf4j;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobExecutionContext;

import java.util.Date;

/**
 * @Author WangHan
 * @Date 2025/7/31
 * @Description 继承 QuartzJobBean (更方便地使用 Spring 的依赖注入)
 */

@DisallowConcurrentExecution
@Slf4j
public class HelloJob implements Job {

    @Override
    public void execute(JobExecutionContext jobExecutionContext) {
        // 检查是否是恢复执行（应用重启后的执行）
        if (jobExecutionContext.isRecovering()) {
            log.info("Skipping HelloJob execution on recovery at: " + new Date());
            return; // 跳过恢复执行，不执行业务逻辑
        }

        log.info("execute HelloJob...." + new Date());
        // 你的实际业务逻辑放在这里
    }
}
  1. 创建service

import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * @Author WangHan
 * @Date 2025/7/31
 * @Description 定时任务服务
 */
@Service
public class QuartzJobService {

    @Autowired
    private Scheduler scheduler;

    /**
     * 新增定时任务
     *
     * @param jobName
     * @param jobGroup
     * @param triggerName
     * @param triggerGroup
     * @param jobClass
     * @param cron
     */
    public void addJob(String jobName, String jobGroup, String triggerName, String triggerGroup, String jobClass, String cron) throws Exception {
        Class<? extends Job> jobClazz = (Class<? extends Job>) Class.forName("com.platform.base.job." + jobClass);
        JobDetail jobDetail = JobBuilder.newJob(jobClazz)
                .withIdentity(jobName, jobGroup)
                .storeDurably()
                .build();

        CronTrigger cronTrigger = TriggerBuilder.newTrigger()
                .withIdentity(triggerName, triggerGroup)
                .startNow()
                .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                .build();

        scheduler.scheduleJob(jobDetail, cronTrigger);
        if (!scheduler.isShutdown()) {
            scheduler.start();
        }
    }

    /**
     * 重启定时任务
     *
     * @param triggerName
     * @param triggerGroup
     * @param cron
     */
    public void rescheduleJob(String triggerName, String triggerGroup, String cron) throws Exception {
        TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroup);
        CronTrigger cronTrigger = TriggerBuilder.newTrigger()
                .withIdentity(triggerKey)
                .startNow()
                .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                .build();
        scheduler.rescheduleJob(triggerKey, cronTrigger);
    }

    /**
     * 暂停定时任务
     *
     * @param jobName
     * @param jobGroup
     */
    public void pauseJob(String jobName, String jobGroup) throws Exception {
        scheduler.pauseJob(JobKey.jobKey(jobName, jobGroup));
    }

    /**
     * 恢复定时任务
     *
     * @param jobName
     * @param jobGroup
     */
    public void resumeJob(String jobName, String jobGroup) throws Exception {
        scheduler.resumeJob(JobKey.jobKey(jobName, jobGroup));
    }

    /**
     * 删除定时任务
     * @param jobName
     * @param jobGroup
     * @param triggerName
     * @param triggerGroup
     * @throws Exception
     */
    public void deleteJob(String jobName, String jobGroup, String triggerName, String triggerGroup) throws Exception {
        scheduler.pauseTrigger(TriggerKey.triggerKey(triggerName, triggerGroup));
        scheduler.unscheduleJob(TriggerKey.triggerKey(triggerName, triggerGroup));
        scheduler.deleteJob(JobKey.jobKey(jobName, jobGroup));
    }

    /**
     * 查询所有定时任务
     *
     * @return
     */
    public List<String> listJobs() throws Exception {
        Set<JobKey> jobKeys = scheduler.getJobKeys(GroupMatcher.anyGroup());
        return jobKeys.stream().map(JobKey::getName).collect(Collectors.toList());
    }

    /**
     * 立即执行指定的任务（不干扰原有的定时任务）
     *
     * @param jobName 任务名称
     * @param jobGroup 任务组
     */
    public void triggerJobOnce(String jobName, String jobGroup) throws Exception {
        JobKey jobKey = new JobKey(jobName, jobGroup);

        // 检查任务是否存在
        if (!scheduler.checkExists(jobKey)) {
            throw new IllegalArgumentException("任务不存在: " + jobName + "." + jobGroup);
        }

        // 立即触发执行指定的任务
        scheduler.triggerJob(jobKey);
    }
}
  1. 测试controller

import com.platform.base.service.quartz.QuartzJobService;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author WangHan
 * @Date 2025/7/31
 * @Description 定时任务
 */
@Tag(name = "定时任务管理接口", description = "定时任务管理接口")
@EnableTransactionManagement
@RestController
@RequestMapping("/v1/base/pc/quartz")
public class QuartzController {

    @Autowired
    private QuartzJobService quartzJobService;

    /**
     * 新增定时任务
     *
     * @param jobName      任务名称，示例：helloJob
     * @param jobGroup     任务组，示例：helloJobGroup
     * @param triggerName  触发器名称，示例：helloTrigger
     * @param triggerGroup 触发器组，示例：helloTriggerGroup
     * @param jobClass     调度任务，示例：HelloJob
     * @param cron         cron表达式，示例：0 0/1 * * * ?
     * @return String
     */
    @GetMapping(path = "/add")
    public String addJob(String jobName, String jobGroup, String triggerName, String triggerGroup, String jobClass, String cron) {
        try {
            quartzJobService.addJob(jobName, jobGroup, triggerName, triggerGroup, jobClass, cron);
            return "ok";
        } catch (Exception e) {
            e.printStackTrace();
            return "fail";
        }
    }

    /**
     * 暂停任务
     *
     * @param jobName  任务名称
     * @param jobGroup 任务组
     * @return String
     */
    @GetMapping(path = "/pause")
    public String pauseJob(String jobName, String jobGroup) {
        try {
            quartzJobService.pauseJob(jobName, jobGroup);
            return "ok";
        } catch (Exception e) {
            e.printStackTrace();
            return "fail";
        }
    }

    /**
     * 恢复任务
     *
     * @param jobName  任务名称
     * @param jobGroup 任务组
     * @return String
     */
    @GetMapping(path = "/resume")
    public String resumeJob(String jobName, String jobGroup) {
        try {
            quartzJobService.resumeJob(jobName, jobGroup);
            return "ok";
        } catch (Exception e) {
            e.printStackTrace();
            return "fail";
        }
    }

    /**
     * 重启任务
     *
     * @param triggerName  触发器名称，示例：helloTrigger
     * @param triggerGroup 触发器组，示例：helloTriggerGroup
     * @param cron     cron表达式
     * @return String
     */
    @GetMapping(path = "/reSchedule")
    public String rescheduleJob(String triggerName, String triggerGroup, String cron) {
        try {
            quartzJobService.rescheduleJob(triggerName, triggerGroup, cron);
            return "ok";
        } catch (Exception e) {
            e.printStackTrace();
            return "fail";
        }
    }

    /**
     * 删除任务
     *
     * @param jobName      任务名称，示例：helloJob
     * @param jobGroup     任务组，示例：helloJobGroup
     * @param triggerName  触发器名称，示例：helloTrigger
     * @param triggerGroup 触发器组，示例：helloTriggerGroup
     * @return String
     */
    @GetMapping(path = "/delete")
    public String deleteJob(String jobName, String jobGroup, String triggerName, String triggerGroup) {
        try {
            quartzJobService.deleteJob(jobName, jobGroup, triggerName, triggerGroup);
            return "ok";
        } catch (Exception e) {
            e.printStackTrace();
            return "fail";
        }
    }

    /**
     * 查询所有定时任务
     *
     * @return List<String>
     */
    @GetMapping(path = "/list")
    public List<String> listJobs() {
        try {
            return quartzJobService.listJobs();
        } catch (Exception e) {
            e.printStackTrace();
            return new ArrayList<String>();
        }
    }

    @GetMapping(path = "/runOnce")
    public String runOnce(String jobName, String jobGroup) {
        try {
            // 临时手动触发执行一次（不影响原有的定时任务）
            quartzJobService.triggerJobOnce(jobName, jobGroup);
            return "ok";
        } catch (Exception e) {
            e.printStackTrace();
            return "fail";
        }
    }
}
  1. 接口调用

    • 查询列表
      在这里插入图片描述

    • 添加定时任务
      在这里插入图片描述

    • 删除定时任务
      在这里插入图片描述

    • 执行一次定时任务
      在这里插入图片描述

springboot2.2.13.RELEASE整合quartz任务调度框架,并持久化到MySQL数据库
qq_43068123的博客
07-23 293
springboot2.x 整合quartz并持久化到MySQL
quartz mysql 初始化_SpringBoot整合Quartz定时任务（持久化到数据库）
weixin_33241808的博客
01-19 1289
背景最近在做项目，项目中有个需求：需要使用定时任务，这个定时任务需要即时生效。查看Quartz官网之后发现：Quartz提供两种基本作业存储类型：RAMJobStore ：RAM也就是内存，默认情况下Quartz会将任务调度存在内存中，这种方式性能是最好的，因为内存的速度是最快的。不好的地方就是数据缺乏持久性，但程序崩溃或者重新发布的时候，所有运行信息都会丢失JDBC作业存储：存到数据库之后，可以...
springboot2.x+quartz+mysql持久化集成
OceanSky的专栏
09-01 1695
1.pom文件中引入相关依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-quartz</artifactId> </dependency> <dependency> <groupI
SpringBoot2.x集成Quartz实现定时任务管理（持久化到数据库）
C3Stones
09-25 1015
1. Quartz简介   Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目。   Quartz是一个完全由Java编写的开源作业调度框架，为在Java应用程序中进行作业调度提供了简单却强大的机制。   Quartz可以与J2EE与J2SE应用程序相结合也可以单独使用。   Quartz允许程序开发人员根据时间的间隔来调度作业。   Quar...
【半原创】springboot 1.X 集成Quartz.
woodyMe的博客
04-17 1360
springboot 1.X 集成Quartz.〇， 个人理解，欢迎指正一，本文主要解决的问题查找了一些资料相关资料，发现要么写得太肤浅，要么没有解决一些实际问题。故在别人的基础上抄了一抄，梳理了一下有了此文。背景跳过，这里主要介绍使用sring集成Quartz 的代码,使用spring+Quartz的JDBC持久化任务特性：主要解决的问题：A.任务涉及到的数据库事务问题 （Quartz的Job任...
springboot2.x+quartz实现定时调度任务
weixin_45546418的博客
04-15 717
一、Quartz介绍 1.简介 起初是OpenSymphony组织提供的一个功能丰富的开源作业调度框架 官网：http://www.quartz-scheduler.org/ 纯java编写，用法简单而功能强大 2.特点 1.、强大的作业调度功能 作为spring默认的调度框架，极易与spring无缝整合，实现灵活可配置的调度功能，quartz提供了调 度运行环境持久化机制，可以保存并恢复调度现场...
SpringBoot整合Quartz，做到数据库持久化
qq_45597674的博客
10-31 870
pom文件引入 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/mav
springboot2.x+quartz 实现分布式任务调度
菜猿子的博客
07-16 3615
正好最近做了这个功能,在网上看了好多人写的博客,很多都是重复的,也有一些内容太冗余,所以自己整理了一下,更简便易懂的,适用于初学者,当然我也是! 不多说 上代码! 1.首先创建数据库表, 这里只说mysql, 其他数据库可以去网上搜搜, # # In your Quartz properties file, you'll need to set # org.quartz.jobStore...
第三十九章：基于SpringBoot1.5.x & Quartz完成定时任务分布式单节点持久化
恒宇少年De成长之路
04-22 5418
定时任务在企业项目比较常用到，几乎所有的项目都会牵扯该功能模块，定时任务一般会处理指定时间点执行某一些业务逻辑、间隔时间执行某一些业务逻辑等。我们在之前有讲过SpringBoot是已经集成了定时任务的，详见：第二十六章：SpringBoot使用@Scheduled创建定时任务，那么我们本章将会采用外置的quartz定时任务框架来完成定时任务的分布式单节点持久化，我们为什么要持久化定时任务呢？ 在...
springboot2.3集成quartz定时任务持久化数据库,支持集群
07-13
在本文中，我们将深入探讨如何在Spring Boot 2.3版本中集成Quartz定时任务，并实现其持久化到数据库，以便支持集群环境。这个过程的关键在于配置Quartz Scheduler，设置数据库连接，以及确保任务在多节点环境中能够...
springboot整合mybatis+quartz实现任务持久化
12-25
在本项目"springboot整合mybatis+quartz实现任务持久化"中，我们将讨论如何将这三个技术有效地集成，以实现高效、可靠的定时任务管理。 首先，Spring Boot的整合通常涉及添加依赖。在`pom.xml`或`build.gradle`文件...
SpringBoot集成Quartz数据库持久化
weixin_45180769的博客
12-03 553
Spring整合Quartz a、quartz调度框架是有内置表的 进入quartz的官网http://www.quartz-scheduler.org/，点击Downloads， 下载后在目录\docs\dbTables下有常用数据库创建quartz表的脚本，例如：“tables_mysql.sql” table_mysql.sql table_mysql_innodb.sql 上述两者所有的数...
MoonBit Perals Vol.05: 函数式里的依赖注入：Reader Monad
m0_74743788的博客
08-13 1502
普通的函数就像一个流水线，你丢进去一袋面粉，然后直接跑到生产线末端，等着方便面出来。但这条流水线需要自动处理中间的所有复杂情况：没放面粉/“没有下单，期待发货”（null）面团含水量不够把压面机干卡了（抛出异常）配料机需要读取今天的生产配方，比如是红烧牛肉味还是香菇炖鸡味（读取外部配置）流水线末端的打包机需要记录今天打包了多少包（更新计数器）Monad 就是专门管理这条复杂流水线的“总控制系统”。它把你的数据和处理流程的上下文一起打包，确保整个流程能顺畅、安全地进行下去。
如何在 Linux 上安装 SQL Server 2022 和 Azure Data Studio
csdn_aspnet的专栏，请点击博客主页右上角三个点中的私信联系
08-15 1058
本文介绍了如何在Linux系统（以Ubuntu 20.04为例）上安装SQL Server 2022及Azure Data Studio。SQL Server自2017版开始支持Linux平台，通过平台抽象层实现跨平台兼容性。文章详细说明了安装步骤：导入GPG密钥、注册存储库、安装软件包并配置管理员密码。同时介绍了SQL Server在Linux上的不同版本（企业版、标准版等）和主要功能差异。安装完成后，用户可通过Azure Data Studio等工具进行连接管理，文中提供了连接参数设置指南。整个过程简便
MySQL 常用命令速查表
DeppBing的博客，全栈修炼记｜记录一个开发者的进化轨迹
08-15 555
本文总结了MySQL常用SQL命令，涵盖数据库操作、表操作、数据操作、数据查询、权限控制、事务控制等核心功能。主要内容包括：数据库的创建/删除/修改（CREATE/DROP/ALTER DATABASE）；表结构的创建/修改/删除（CREATE/ALTER/DROP TABLE）；数据增删改查（INSERT/DELETE/UPDATE/SELECT）；索引管理（CREATE/DROP INDEX）；用户权限控制（GRANT/REVOKE）；事务管理（START/COMMIT/ROLLBACK）等。每个命令都
cat本地部署
Chaser______的博客
08-15 605
CAT监控系统部署指南 环境准备：JDK1.8、Tomcat、MySQL 获取CAT包：通过Git克隆源码或下载官网war包 部署步骤： 创建/data目录结构并设置权限 配置client.xml、datasources.xml和server.xml 导入SQL文件创建数据库 将cat.war部署到Tomcat的webapps目录 启动服务：启动Tomcat后访问http://ip:8080/cat 注意事项：将配置文件中的127.0.0.1替换为实际IP地址 （98字）
SQL进阶-学习路线梳理（一）
xfzldxfz的博客
08-13 936
本文档是MySQL 8.0+的SQL学习指南，内容涵盖从基础到进阶的完整知识体系。主要包含SQL基础概念、数据类型与约束、CRUD操作、函数、表连接、分组聚合、子查询、窗口函数等核心语法，以及索引优化、事务锁机制、存储过程、触发器、视图等高级特性。特别介绍了MySQL 8.0的新功能如CTE、JSON数据处理等，并提供了数据库设计、性能优化、安全管理、备份恢复等实战经验。文档强调生产环境验证的重要性，建议根据实际业务场景调整SQL语句，并定期关注MySQL官方更新。
Text2SQL实战
leiya_163的博客
08-13 352
主要部署到企业中，私有搭建。QWen 3，提供各种尺寸的模型8B、32B、mini MOE等。
蓝凌EKP产品：JSP 性能优化和 JSTL/EL要点检查列表
最新发布
wwwhongxia的专栏
08-17 601
使用或获取 Spring BeanFilter 本身由 Tomcat 管理，但业务逻辑由 Spring 管理支持 Redis 缓存、限流、统计等功能JSP 内置对象作用域优化临时页面变量使用page作用域避免使用 request/session/application 存储短期临时数据提升性能，降低内存压力。
springboot 整合quartz和quartz-jobs数据库持久化
01-17
### 整合Spring Boot与Quartz实现数据库持久化的作业调度 #### 配置依赖项 为了使Spring Boot应用程序能够支持Quartz并利用`quartz-jobs`库来完成数据库中的作业存储，需先调整项目的构建文件。对于Maven项目，在`pom.xml`中加入如下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-quartz</artifactId> </dependency> <!-- Quartz Jobs --> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz-jobs</artifactId> <version>${quartz.version}</version> </dependency> ``` 上述配置引入了必要的组件用于启动和管理定时任务以及通过JDBC连接到关系型数据库保存job详情[^1]。 #### 数据源设置 接着定义数据源属性以便于Quartz可以访问外部数据库执行持久操作。编辑`application.properties`或`application.yml`: ```yaml spring.datasource.url=jdbc:mysql://localhost:3306/quartz_db?useSSL=false&serverTimezone=UTC spring.datasource.username=root spring.datasource.password=password spring.jpa.hibernate.ddl-auto=update ``` 这里指定了MySQL作为后台存储介质；当然也可以选择其他类型的RDBMS只要相应修改URL即可满足需求[^4]。 #### 初始化表结构 为了让Quartz能在指定的数据源上创建所需的表格，应该下载官方提供的SQL脚本并将之应用于目标schema内。通常这些DDL语句位于Quartz发行版下的`docs/dbTables`目录下找到适合版本的建表语句应用至实际环境中[^2]。 #### 自定义Job类 编写具体的业务逻辑单元即所谓的Jobs, 它们代表待被执行的任务体。下面给出一个简单的例子展示怎样继承自`Job`接口从而形成可被调度器识别的对象形式： ```java import org.quartz.Job; import org.quartz.JobExecutionContext; public class SampleJob implements Job { @Override public void execute(JobExecutionContext context){ System.out.println("Executing sample job at " + new Date()); } } ``` 此段代码实现了基本的日志记录功能每当触发条件达成时就会打印当前时间戳信息给控制台输出流[^3]。 #### 调度策略设定 最后一步就是安排何时何地运行已注册好的jobs了。这可以通过编程方式动态添加trigger实例或者静态声明的方式预先确定好计划参数。以下是采用Java Config风格的例子说明如何做到这一点： ```java @Configuration @EnableScheduling public class SchedulerConfig { @Autowired private ApplicationContext applicationContext; @Bean public JobDetailFactoryBean jobDetail(){ JobDetailFactoryBean factory = new JobDetailFactoryBean(); factory.setJobClass(SampleJob.class); factory.setDescription("Invoke SampleJob"); return factory; } @Bean public CronTriggerFactoryBean cronTrigger() throws ParseException{ CronTriggerFactoryBean trigger = new CronTriggerFactoryBean(); trigger.setCronExpression("*/5 * * * * ?"); //每五秒一次 trigger.setJobDetail(jobDetail().getObject()); return trigger; } } ``` 这段配置片段设置了每隔五分钟就激活一次之前提到过的SampleJob示例程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值