SpringBoot整合Quartz定时任务（持久化到数据库）_spring boot集成quartz并将数据持久化到数据库

于 2024-05-16 01:00:49 发布
阅读量592 收藏 11
点赞数 3
分类专栏： 2024年程序员学习 文章标签： 物联网 嵌入式硬件 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_85012088/article/details/138930081
版权

收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。
img
img

如果你需要这些资料，可以戳这里获取

需要这些体系化资料的朋友，可以加我V获取：vip1024c （备注嵌入式）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人

都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

  1. RAMJobStore ：RAM也就是内存，默认情况下Quartz会将任务调度存在内存中，这种方式性能是最好的，因为内存的速度是最快的。不好的地方就是数据缺乏持久性，但程序崩溃或者重新发布的时候，所有运行信息都会丢失
  2. JDBC作业存储：存到数据库之后，可以做单点也可以做集群，当任务多了之后，可以统一进行管理。关闭或者重启服务器，运行的信息都不会丢失。缺点就是运行速度快慢取决于连接数据库的快慢。

所以决定采用 JDBC作业存储的方式。

为什么需要持久化？

  1. 以后可以做集群。
  2. 任务可以进行管理，随时停止、暂停、修改任务。

你应该了解的概念

因为之前接触过quartz这个任务调度框架，所以对quartz有一定的了解，quartz三要素：Scheduler、Trigger、JobDetai&Job。
突然想起来，之前写过介绍-。- 自己都忘了，贴上地址，需要的童鞋可以先去了解下：
https://blog.csdn.net/bicheng4769/article/details/81097305

SpringBoot集成Quartz

我们也可以自己去将quartz和springBoot整合在一起，其实说是springBoot还不如说是sping，因为我们没有用到spirngboot的相关的快捷方式。
如果童鞋们想快速集成Quartz，立刻看到效果的话，可以直接往下翻，直接看SpirngBoot自带的Quartz插件。但我建议大家还是从spring整合Quartz开始，懂的原理，方有收获。

Quartz初始化表

如果需要做持久化的话，数据肯定是要存在数据库的，那么到底存在哪些表呢？其实官网文档也跟我们讲过了，地址如下：
http://www.quartz-scheduler.org/documentation/quartz-2.2.x/tutorials/tutorial-lesson-09.html
其中有句话：

JDBCJobStore works with nearly any database, it has been used widely with Oracle, PostgreSQL, MySQL, MS SQLServer, HSQLDB, and DB2. To use JDBCJobStore, you must first create a set of database tables for Quartz to use. You can find table-creation SQL scripts in the “docs/dbTables” directory of the Quartz distribution.

荣老夫这个四级的水平给你们翻译下：
大概就是支持这么多的数据库类型。如果你要使用JDBCJoBStore的话，你先要创建一些表，这些表在 “doc/dbTables”里面。“doc/dbTables” 在哪儿呢？其实都在源码里面，直接到官网下下来就行了。

Spring整合Quartz

  1. pom文件加入相关jar
  2. 相关配置文件（不管是properties 还是yml。采用JDBC存储）
  3. 业务逻辑层中使用。

pom文件

如下所示：

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--quartz -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
            <!-- <version>2.3.0</version> -->
        </dependency>
        <!--定时任务需要依赖context模块-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>
        <!--&lt;!&ndash; druid数据库连接池 &ndash;&gt;-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
    </dependencies>

对应的properties 文件

#使用自己的配置文件
org.quartz.jobStore.useProperties:true

#默认或是自己改名字都行
org.quartz.scheduler.instanceName: DefaultQuartzScheduler
#如果使用集群，instanceId必须唯一，设置成AUTO
org.quartz.scheduler.instanceId = AUTO


org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount: 10
org.quartz.threadPool.threadPriority: 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true


#存储方式使用JobStoreTX，也就是数据库
org.quartz.jobStore.class:org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#是否使用集群（如果项目只部署到 一台服务器，就不用了）
org.quartz.jobStore.isClustered = false
org.quartz.jobStore.clusterCheckinInterval=20000
org.quartz.jobStore.tablePrefix = qrtz_
org.quartz.jobStore.dataSource = myDS

#配置数据源
#数据库中quartz表的表名前缀
org.quartz.dataSource.myDS.driver = com.mysql.jdbc.Driver
org.quartz.dataSource.myDS.URL = jdbc:mysql://localhost:3306/aipyun?serverTimezone=GMT&characterEncoding=utf-8
org.quartz.dataSource.myDS.user = root
org.quartz.dataSource.myDS.password = root123
org.quartz.dataSource.myDS.maxConnections = 5

核心QuartzConfiguration类：

ackage com.cj.config;

import org.quartz.Scheduler;
import org.quartz.spi.JobFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

/**
 * 描述 ： quartz 配置信息
 *
 * @author caojing
 * @create 2018-12-24-16:47
 */
@Configuration
public class QuartzConfiguration {
    @Autowired
    private JobFactory jobFactory;

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        schedulerFactoryBean.setJobFactory(jobFactory);
        // 用于quartz集群,QuartzScheduler 启动时更新己存在的Job
        schedulerFactoryBean.setOverwriteExistingJobs(true);
        //延长启动
        schedulerFactoryBean.setStartupDelay(1);
        //设置加载的配置文件
        schedulerFactoryBean.setConfigLocation(new ClassPathResource("/quartz.properties"));
        return schedulerFactoryBean;
    }

    @Bean
    public Scheduler scheduler() {
        return schedulerFactoryBean().getScheduler();
    }
}

这其中我们把2个类的初始化移到了IOC中，因为之前Quartz的实例化是自己去控制的，为什么要这么做后面会有讲到。
一个是SchedulerFactoryBean类，这个类其实就是之前xml配置中的SchedulerFactoryBean。附上之前xml配置如下（这里不需要配置，springboot建议我们少用xml配置）

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

这个类我相信只要用过xml配置的人一定很熟悉，这是Quartz入口。同时也是spring 和Scheduler 关系的桥梁。以便在Spring容器启动后，Scheduler自动开始工作，而在Spring容器关闭前，自动关闭Scheduler。

JobFactory类

package com.cj.config;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;
import org.springframework.stereotype.Component;

/**
 * 描述：
 *
 * @author caojing
 * @create 2018-12-26-14:03
 */
@Component
public  class JobFactory extends AdaptableJobFactory {

    @Autowired
    private AutowireCapableBeanFactory  capableBeanFactory;


    @Override
    protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
        // 调用父类的方法
        Object jobInstance = super.createJobInstance(bundle);
        // 进行注入
        capableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

这个类的作用就是讲Job的实例化交给IOC去进行。
其实问题在于：
Job对象的实例化过程是在Quartz中进行的，注入的实体类是在Spring容器当中的 所以在job中无法注入Srping容器的实体类。
解决方案：将Job Bean也纳入到Spring容器的管理之中，Spring容器自然能够为Job Bean自动装配好所需的依赖。
如何纳入：Job的创建都是通过JobFactory创建的。官网解释为证：
https://www.quartz-scheduler.org/api/2.2.1/org/quartz/spi/JobFactory.html

A JobFactory is responsible for producing instances of Job classes.

翻译：JobFactory负责生成Job类的实例。
JobFactory 有2个实现类：AdaptableJobFactory 和 SimpleJobFactory。

  1. 自定义的工厂类 JobFactory 继承 AdaptableJobFactory 。
  2. 通过调用父类 AdaptableJobFactory 的方法createJobInstance来实现对Job的实例化。
  3. 在Job实例化完以后，再调用自身方法为创建好的Job实例进行属性自动装配并将其纳入到Spring容器的管理之中。(通过AutowireCapableBeanFactory纳入)。截胡~~~~

UploadTask 类：

package com.cj.quartzdemo;
import com.cj.controller.IndexController;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import java.util.Date;

/**


**收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。**
![img](https://img-blog.csdnimg.cn/img_convert/79d82a8495e585bb43dc391ac800c6e2.png)
![img](https://img-blog.csdnimg.cn/img_convert/7e34fc1aedc64d7580edda11bff3d869.png)

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618679757)**

**需要这些体系化资料的朋友，可以加我V获取：vip1024c （备注嵌入式）**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人**

**都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

初衷也很简单，就是希望能够帮助到想自学提升的朋友。**
[外链图片转存中...(img-C8D00ety-1715792426685)]
[外链图片转存中...(img-OH56VyP8-1715792426685)]

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618679757)**

**需要这些体系化资料的朋友，可以加我V获取：vip1024c （备注嵌入式）**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人**

**都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
2401_85012088
关注
  • 3
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot整合Quartz
桐花思雨
11-02 4万+
目录`Quartz` 简介 Quartz 简介 Quartz 是一款功能强大的开源任务调度框架，几乎可以集成到任何 Java 应用程序中（小到单机应用，大到分布式应用）。Quartz 可用于创建简单或复杂的任务调度，用以执行数以万计的任务。任务被定义为标准化的 Java 组件，Java 编写的任务都可以被执行 Quartz 是一个任务日程管理系统，一个在预先确定（被纳入日程）的时间到达时，负责执行（或者通知）其他软件组件的系统 Quartz 用一个小 Java 库发布文件（.jar文件），这个库文件包含了所
springboot+quartz以持久化的方式实现定时任务的代码
08-18
Quartz可以将任务持久化到数据库中，以便于任务的存储和管理。我们可以使用Quartz提供的数据库表结构来创建数据库表。例如，使用MySQL数据库可以使用以下SQL语句创建表： ```sql CREATE TABLE QRTZ_JOB_DETAILS ( ...
springboot2.3集成quartz定时任务持久化数据库,支持集群
07-13
执行resources中的sql脚本,修改数据库连接参数,亲测完美运行-----------------------------------------------------
springboot整合quartz定时任务yml文件配置方式
03-23
spring-cloud-alibaba+dubbo+nacos+quartz以yml配置方式实现
SpringBoot-集成Quartz实现持久化定时接口调用任务
m0_71777195的博客
02-26 1320
Quartz 是功能强大的开源作业调度库，几乎可以集成到任何 Java 应用程序中，从最小的独立应用程序到最大的电子商务系统。Quartz 可用于创建简单或复杂的计划，以执行数以万计的工作；可以执行您编写的所有内容。
分布式定时任务框架Quartz总结和实践（2）—持久化到Mysql数据库
yangnk的技术记录
08-24 1771
Quartz提供两种基本作业存储类型，包括将任务数据保存在内存中的RAMJobStore模式和保存在数据库中的JDBC作业存储模式，上篇说明了RAMJobStore 模式，本篇说明JDBC作业存储。RAMJobStore ：RAM也就是内存，默认情况下Quartz会将任务调度存在内存中，这种方式性能是最好的，因为内存的速度是最快的。不好的地方就是数据缺乏持久性，但程序崩溃或者重新发布的时候，所有运行信息都会丢失JDBC作业存储：存到数据库之后，可以做单点也可以做集群，当任务多了之后，可以统一进行管理。
Spring Boot 集成 Quartz（任务调度框架）
欲变世界，先变其身
09-28 5418
Quartz 是完全由Java开发的作业调度框架，当定时任务愈加复杂时，使用Spring注解@Schedule已经不能满足业务需要。} }return JobBuilder . newJob(SampleJob . class) . withIdentity("job" , "group") . withDescription("任务描述：内存方式运行") . storeDurably() . build();} }
Springboot集成quartz
qq_44300280的博客
11-04 903
Springboot集成quartz
Spring Boot 集成Quartz
Pluted的博客
03-25 244
1) 引入 Quartz 依赖： 完整的pom文件如图所示： 2) 我们需要使用注解@Configuration 来定义一个配置类，代码如下： 3) 为了方便我们看清楚任务调度的次数，我们声明一个辅助类，如图 4) 接下创建一个任务调度的类，如图: 在任务类中使用了两个注解@EnableScheduling 和@Scheduled(Cron 表达式)。具体作用如下： ...
Springboot集成Quartz
segegefe的博客
08-30 1040
Quartz 是一个完全由 Java 编写的开源作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。该文章不过多介绍Quartz的概念，主要做一个封装的记录。
Quartz定时任务持久化数据表
09-21
Quartz定时任务持久化数据表 ，mysql数据库，方便动态配置定时任务，各字段都有注释，简单的crud即可使用
springboot整合mybatis+quartz实现任务持久化
最新发布
12-25
springboot整合mybatis+quartz实现任务持久化
SpringBoot整合Quartz定时任务持久化到数据库的开发。超详细，可用
languageStudent的博客
03-11 2832
开发环境准备 开发环境： jdk11 springboot 2.4.3 quartz 2.3.2 mysql 1. gradle导入依赖 implementation 'org.springframework.boot:spring-boot-starter-web' compile group: 'com.baomidou', name: 'mybatis-plus-boot-starter', version: '3.3.2' compile group: 'com.baomidou',
quartz 2.0持久化到mysql_springBoot使用quartz，单表持久化到数据库，
weixin_31727797的博客
02-03 148
Quartz定时任务持久化到数据库，单表1.表结构DAO层使用mybatis-generator自动生成2.pom.xml文件加入依赖org.quartz-schedulerquartz2.2.1org.quartz-schedulerquartz-jobs2.2.13.application.properties中配置quartz线程池的线程数量，避免造成不必要的开销spring.quartz....
SpringBoot整合Quartz，实现数据库方式执行定时任务
_江屿_
08-22 363
SpringBoot整合Quartz，实现数据库方式执行定时任务
《SpringBoot2.0 实战》系列-集成Quartz定时任务（持久化到数据库）
小葫芦的博客
07-08 9928
前言 之前写过一篇spring整合quartz的过程的文章，但是配置比较繁琐，而且持久化脚本需要手动生成到数据库，比较笨拙； 现在大多数项目都使用了springboot，所以本文主要讲springboot与quartz的完美整合，简化配置、持久化数据并自定义quartz数据源。 正文 一、增加依赖 我们使用的spring-boot-starter-quartz,所以不用显示指定版本号...
springboot2.x+quartz+mysql持久化集成
OceanSky的专栏
09-01 1438
1.pom文件中引入相关依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-quartz</artifactId> </dependency> <dependency> <groupI
使用Quartz2.3.2+spring boot实现数据库持久化存储多个定时任务
06-10
好的，我了解了你的问题。要使用Quartz2.3.2和Spring Boot实现数据库持久化存储多个定时任务，你可以按照以下步骤操作： 1. 在Spring Boot项目中添加Quartz2.3.2的依赖包： ```xml <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.2</version> </dependency> ``` 2. 创建一个继承了`org.quartz.impl.jdbcjobstore.PostgreSQLDelegate`的类，用于实现PostgreSQL数据库的存储。 ```java public class PostgreSQLDelegateCustom extends PostgreSQLDelegate { private String tablePrefix = ""; public PostgreSQLDelegateCustom() { super(); } @Override public void setInstanceName(String schedName) { super.setInstanceName(schedName); this.tablePrefix = schedName + "."; } @Override public String getSelectNextTriggerToAcquireSql(int maxCount) { return "SELECT * FROM " + tablePrefix + "QRTZ_TRIGGERS WHERE " + "TRIGGER_STATE = ? AND NEXT_FIRE_TIME <= ? " + "AND MISFIRE_INSTR IN (" + MisfireInstruction.IGNORE_MISFIRE_POLICY + "," + MisfireInstruction.SMART_POLICY + ") ORDER BY NEXT_FIRE_TIME ASC"; } @Override public String getSelectNextMisfiredTriggersInStateSql(Connection conn, String state, long ts) { return "SELECT * FROM " + tablePrefix + "QRTZ_TRIGGERS WHERE " + "TRIGGER_STATE = ? AND NEXT_FIRE_TIME <= ? " + "AND MISFIRE_INSTR NOT IN (" + MisfireInstruction.IGNORE_MISFIRE_POLICY + "," + MisfireInstruction.SMART_POLICY + ") ORDER BY NEXT_FIRE_TIME ASC"; } @Override public String getSelectPausedTriggerGroupsSql() { return "SELECT TRIGGER_GROUP FROM " + tablePrefix + "QRTZ_PAUSED_TRIGGER_GRPS"; } @Override public String getSelectPausedTriggerGroupsLikeSql() { return "SELECT TRIGGER_GROUP FROM " + tablePrefix + "QRTZ_PAUSED_TRIGGER_GRPS WHERE TRIGGER_GROUP LIKE ?"; } @Override public String getSelectFiredTriggersSql(int limit) { return "SELECT * FROM " + tablePrefix + "QRTZ_FIRED_TRIGGERS ORDER BY FIRE_TIME ASC LIMIT " + limit; } @Override public String getSelectFiredTriggerSql() { return "SELECT * FROM " + tablePrefix + "QRTZ_FIRED_TRIGGERS WHERE ENTRY_ID = ?"; } @Override public String getInsertPausedTriggerGroupSql() { return "INSERT INTO " + tablePrefix + "QRTZ_PAUSED_TRIGGER_GRPS (TRIGGER_GROUP) VALUES (?)"; } @Override public String getDeletePausedTriggerGroupSql() { return "DELETE FROM " + tablePrefix + "QRTZ_PAUSED_TRIGGER_GRPS WHERE TRIGGER_GROUP = ?"; } @Override public String getDeleteAllPausedTriggerGroupsSql() { return "DELETE FROM " + tablePrefix + "QRTZ_PAUSED_TRIGGER_GRPS"; } @Override public String getInsertFiredTriggerSql() { return "INSERT INTO " + tablePrefix + "QRTZ_FIRED_TRIGGERS (ENTRY_ID, " + "TRIGGER_NAME, TRIGGER_GROUP, " + "IS_VOLATILE, INSTANCE_NAME, " + "FIRED_TIME, SCHED_TIME, " + "PRIORITY, STATE, JOB_NAME, " + "JOB_GROUP, IS_STATEFUL, " + "REQUESTS_RECOVERY, " + "MISFIRE_INSTR) " + "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"; } @Override public String getUpdateFiredTriggerSql() { return "UPDATE " + tablePrefix + "QRTZ_FIRED_TRIGGERS SET " + "FIRED_TIME = ?, SCHED_TIME = ?, STATE = ? " + "WHERE ENTRY_ID = ?"; } @Override public String getDeleteFiredTriggerSql() { return "DELETE FROM " + tablePrefix + "QRTZ_FIRED_TRIGGERS WHERE ENTRY_ID = ?"; } @Override public String getDeleteFiredTriggersSql(String instanceId) { return "DELETE FROM " + tablePrefix + "QRTZ_FIRED_TRIGGERS WHERE INSTANCE_NAME = ?"; } @Override public String getSelectInstancesFiredTriggerCountSql() { return "SELECT COUNT(*) FROM " + tablePrefix + "QRTZ_FIRED_TRIGGERS WHERE INSTANCE_NAME = ?"; } } ``` 3. 在Spring Boot配置文件中配置Quartz的相关参数： ```yaml spring: quartz: job-store-type: jdbc properties: org: quartz: scheduler: instanceId: AUTO instanceName: my-scheduler jobStore: driverDelegateClass: com.example.PostgreSQLDelegateCustom useProperties: false isClustered: false dataSource: myDataSource tablePrefix: QRTZ_ threadPool: threadCount: 10 plugin: shutdownhook: class: org.quartz.plugins.management.ShutdownHookPlugin cleanShutdown: true jobHistory: class: org.quartz.plugins.history.LoggingJobHistoryPlugin jobHistoryLogLevel: INFO ``` 4. 创建一个继承了`org.quartz.Job`的类，用于定义任务的具体逻辑： ```java public class MyJob implements Job { @Override public void execute(JobExecutionContext context) throws JobExecutionException { // 任务逻辑代码 } } ``` 5. 在Spring Boot的任意一个类中添加以下代码，用于配置和启动Quartz Scheduler： ```java @Configuration public class QuartzConfig { @Bean public JobDetail myJobDetail() { return JobBuilder.newJob(MyJob.class) .withIdentity("myJob") .storeDurably() .build(); } @Bean public Trigger myTrigger() { return TriggerBuilder.newTrigger() .forJob(myJobDetail()) .withIdentity("myTrigger") .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ?")) .build(); } @Bean public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource) { SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean(); schedulerFactoryBean.setDataSource(dataSource); schedulerFactoryBean.setJobDetails(myJobDetail()); schedulerFactoryBean.setTriggers(myTrigger()); return schedulerFactoryBean; } } ``` 6. 最后，你需要在PostgreSQL数据库中创建Quartz所需的表结构。你可以使用Quartz提供的`tables_postgres.sql`文件进行创建。 至此，你已经成功实现了使用Quartz2.3.2和Spring Boot实现数据库持久化存储多个定时任务。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值