springBoot集成Quartz实现分布式定时任务(持久化数据库表)

最新推荐文章于 2023-06-22 20:53:35 发布
最新推荐文章于 2023-06-22 20:53:35 发布
阅读量1.3k 收藏 3
点赞数 1
文章标签： java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49865353/article/details/121910315
版权

添加pom依赖

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

ConfirmStatusJob.Class任务类

@PersistJobDataAfterExecution
//此注解是不允许并发执行任务，单线程执行，可以不写，默认为多线程执行
@DisallowConcurrentExecution
@Component
public class ConfirmStatusJob extends QuartzJobBean {

    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        //在此区域编写任务
        System.out.println("Current Time is:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    }
}

SchedulerConfig.Class调度类

@Configuration
public class SchedulerConfig {

    @Autowired
    private DataSource dataSource;

    @Autowired
    private QuartzAdaptableJobFactory quartzAdaptableJobFactory;

    //调度器
    @Bean
    public Scheduler scheduler() throws IOException {
        return schedulerFactoryBean().getScheduler();
    }

    //创建调度器
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        //添加调度器名称
        factory.setSchedulerName("cluster_scheduler");
        //添加数据源
        factory.setDataSource(dataSource);
        //添加应用程序上下文调度程序
        factory.setApplicationContextSchedulerContextKey("application");
        //添加配置文件信息
        factory.setQuartzProperties(quartzProperties());
        //添加调度程序线程池
        factory.setTaskExecutor(schedulerThreadPool());
        //延时启动，这个很重要，必须要有足够长的时间让你的应用先启动完成后再让 Scheduler启动
        factory.setStartupDelay(60);
        //任务工厂，不加的话会在执行任务的时候发生注入失败导致执行任务失败
        factory.setJobFactory(quartzAdaptableJobFactory);
        return factory;
    }

    //获取配置文件信息
    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        //获取配置文件位置
        propertiesFactoryBean.setLocation(new ClassPathResource("/application.yml"));
        //获取 配置文件信息
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }

    //创建调度程序线程池
    @Bean
    public Executor schedulerThreadPool(){
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(Runtime.getRuntime().availableProcessors());
        executor.setMaxPoolSize(Runtime.getRuntime().availableProcessors());
        executor.setQueueCapacity(Runtime.getRuntime().availableProcessors());
        return executor;
    }

    //设置时区在触发类会用到，根据自己需要的时区设置
    @Bean
    public TimeZone timeZone(){
        TimeZone timeZone = TimeZone.getTimeZone("CTT");
        return timeZone;
    }
}

TriggerConfig.Class

import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;

import java.util.TimeZone;

@Component
public class TriggerConfig implements ApplicationListener<ContextRefreshedEvent> {

    @Autowired
    private Scheduler scheduler;

    @Autowired
    private TimeZone timeZone;

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey("update","update");
            Trigger trigger = scheduler.getTrigger(triggerKey);
            //判断任务是否添加，为null的话会将任务添加进去，如果已经添加将不会再次添加，修改触发事件需要在数据库清除此条数据
            //添加新任务时以此类推
            if (trigger == null){
                trigger = TriggerBuilder.newTrigger()
                        .withIdentity(triggerKey)
                        //设置执行时间可以参考cron表达式，timeZone设置时区，因为本地的时区和服务器的时区不一样，如果不设置的话在本地测试没问题，但是部署到服务器就不是在你设置的时间点执行了
                        .withSchedule(CronScheduleBuilder.cronSchedule("1 0 0 * * ?").inTimeZone(timeZone))
                        .build();
                JobDetail jobDetail = JobBuilder.newJob(ConfirmStatusJob.class)
                        .withIdentity("update","update")
                        .build();
                scheduler.scheduleJob(jobDetail,trigger);
                scheduler.start();
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}

QuartzAdaptableJobFactory.Class工厂类

如果任务不需要注入别的类可以省略，如果需要注入而且没有写此类在执行任务时将会报空指针，因为没有添加到springIOC容器中，所以会注入失败。

@Component
public class QuartzAdaptableJobFactory extends AdaptableJobFactory {

    //AutowireCapableBeanFactory 可以将一个对象添加到SpringIOC容器中，并且完成该对象注入
    @Autowired
    private AutowireCapableBeanFactory autowireCapableBeanFactory;

    /**
     * 该方法需要将实例化的任务对象手动的添加到springIOC容器中并且完成对象的注入
     */
    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        Object obj = super.createJobInstance(bundle);
        //将obj对象添加Spring IOC容器中，并完成注入
        this.autowireCapableBeanFactory.autowireBean(obj);
        return obj;
    }

}

quartz.yml

org:
  quartz:
    #与spring整合后，使用spring线程池
    threadPool:
      class: org.quartz.simpl.SimpleThreadPool
      #线程数
      threadCount: 5
      #线程优先级
      threadPriority: 5
    jobStore:
      #在被认为“失火”之前，调度程序将“容忍”一个Triggers将其下一个启动时间通过的毫秒数。默认值（如果您在配置中未输入此属性）为60000（60秒）。
      misfireThreshold: 60000
      #持久化配置
      class: org.quartz.impl.jdbcjobstore.JobStoreTX
      #为数据库制作了特定于数据库的代理
      driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
      #以指示JDBCJobStore将JobDataMaps中的所有值都作为字符串
      useProperties: <span class="code-keyword">false</span>
      #数据库名字
      dataSource: myDS
      #数据库表名前缀
      tablePrefix: QRTZ_
      #打开群集功能 ,Clustering目前与JDBC-Jobstore（JobStoreTX或JobStoreCMT）和TerracottaJobStore一起使用。功能包括负载平衡和 job故障转移（如果JobDetail的“请求恢复”标志设置为true）。
      isClustered: <span class="code-keyword">true</span>
      #设置此实例“检入”*与群集的其他实例的频率（以毫秒为单位）。影响检测失败实例的速度。
      clusterCheckinInterval: 20000
    # Configure Datasources （与spring整合后，使用spring数据源）
    dataSource:
      myDS:
        #JDBC驱动
        driver: com.mysql.cj.jdbc.Driver
        #数据库地址
        URL: jdbc:mysql://#localhost:3306/quartz
        #用户名
        user: root
        #密码
        password: 123456
        #最大连接数
        maxConnections: 5
        #校验数据库连接
        validationQuery: select 1
        #供应者
        provider: hikaricp

Quartz所需表 

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
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Quartz任务中调用Spring容器中bean及动态调度任务
John_Kong19的专栏
08-31 991
[size=medium]Quartz 是开源任务调度框架中的翘首，它提供了强大任务调度机制，同时保持了使用的简单性。Quartz 允许开发人员灵活地定义触发器的调度时间表，并可以对触发器和任务进行关联映射。此外，Quartz提供了调度运行环境的持久化机制，可以保存并恢复调度现场，即使系统因故障关闭，任务调度现场数据并不会丢失。此外，Quartz还提供了组件式的侦听器、各种插件、线程池等功能。 ...
Springboot Quartz定时任务的动态调度使用，实战详解
最新发布
2303_77877769的博客
04-17 1067
针对最近很多人都在面试，我这边也整理了相当多的面试专题资料，也有其他大厂的面经。希望可以帮助到大家。下面的面试题答案都整理成文档笔记。也还整理了一些面试资料&最新2021收集的一些大厂的面试真题（都整理成文档，小部分截图）最新整理电子书《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！定时任务，模拟多定时任务调度处理不同业务：/****/
springboot+quartz以持久化的方式实现定时任务
weixin_45032957的博客
07-27 989
@SpringBootApplication @EnableScheduling public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } // cron为每秒执行一次 @Scheduled(cron = "* * * * * ?") public void print(){ System.out.println("
spring-boot-quartz的任务管理
喝醉的咕咕鸟
11-20 330
1.Quartz:来触发和执行作业 2.表结构 （官方提供了11张表） 表结构说明 表位置: SpringbootQuartz配置： import java.io.IOException; import java.util.Properties; import org.quartz.Scheduler; import org.quartz.ee.servlet.QuartzIn...
前后端分离项目中 springboot整合quartz
qq_39930070的博客
10-23 5091
springboot+ant design pro of vue 前后端分离项目整合quartz，加三个小案例
分布式应用部署模式下的Quartz配置
luckyye的专栏
06-22 1888
分布式应用部署模式下的Quartz配置
SpringBoot集成Quartz分布式定时任务
11-01
要实现分布式，Quartz需要配置为使用可持久化的Job存储，如数据库，这样多台服务器上的Quartz实例可以共享任务信息。此外，还需要配置集群策略，如`org.quartz.impl.jdbcjobstore.ClusterManager`，确保任务不被多...
springboot整合quartz，实现数据库方式执行定时任务
11-19
总结，通过Spring Boot整合Quartz，我们可以利用数据库存储定时任务，实现任务的灵活管理和持久化。这使得在分布式环境中，多个实例可以共享同一个任务列表，避免重复执行。同时，通过数据库的方式，我们还能方便地...
crystal-demo：用于Spring Boot 2和Quartz Scheduler集成的演示项目
01-29
2. **任务持久化**：任务和触发器可以持久化到数据库，确保任务不会丢失。 3. **灵活的调度**：支持cron表达式和基于时间间隔的调度。 4. **丰富的API**：易于使用且功能强大。 **Spring Boot 2集成Quartz ...
它是基于Dubbo的分布式系统架构，快速简单的上手，有服务层、前端页面层、定时任务系统、日志系统等.zip
08-20
7. **定时任务系统** - 可能使用Quartz或Spring Task等库实现的后台定时任务，执行周期性工作。 8. **日志系统** - 使用Log4j、Logback或Spring Boot内置的日志框架记录应用日志。 整体而言，这个项目展示了如何...
SpringBoot集成常用开发中间件，分库分表，缓存，消息队列，定时器，权限管理等组件
02-21
SpringBoot结合Quartz或Spring Task可以实现定时任务的调度。通过@Scheduled注解，开发者可以方便地定义定时任务的执行周期和行为。 最后，"权限管理"涉及到用户认证（Authentication）和授权（Authorization）。...
Springboot整合Quartz定时任务框架（Spring解决方案）
Ricardo.M.Yu的博客
04-17 3633
spring提供的quartz解决发难
定时任务Quartz（二）-- 持久化定时任务
weixin_45272815的博客
05-25 917
在做持久化定时任务Quartz案例前，确保已经阅读过，之前文章，（简单、入门版本）。。本此实现基于之前版本进行更新，追加，实现与数据库交互，完成重启服务，定时任务不丢失。真正做到持久化定时任务至此，job 已经被我们成功持久化到数据库。我们来回顾下整体的一个流程。pom文件添加对应的依赖。mysql数据库对应表的初始化。配置对应的properties。将原来quartz控制的类的实例化交给spirng IOC控制。（对应的是核心QuartzConfiguration类和JobFactory类。
Springboot + Quartz分布式集群配置
weixin_43901067的博客
07-27 1333
前言 由于最近要解决一个问题，在nginx转发请求的集群部署的情况下，用户创建一个任务并运行在某台服务器上，当用户取消任务时，如何优雅的找到那台服务器并关闭该任务。 我想了一些办法，虽然也能够解决问题，比如广播，消息队列，redis缓存轮询等等，但都感觉不是很优雅。实现方法比较笨拙并且不容易管理，增加了代码的复杂度。 通过不停的在论坛上找方案，找到了Quartz，一个成熟优秀的分布式集群任务管理框架。 建表 set global innodb_large_prefix = ON; set global in
在Spring Boot 中使用定时框架Quartz，触发时间在数据库表中获取
weixin_46013627的博客
04-20 2276
背景：在前端页面新建定时任务，将任务存入数据库，包含触发时间及触发模式 数据库表触发时间字段如下： 一、Quartz的介绍 Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，是完全由java开发的一个开源的任务日程管理系统，“任务进度管理器”就是一个在预先确定（被纳入日程）的时间到达时，负责执行（或者通知）其他软件组件的系统。 Quartz用一个小Java库发布文件（.jar文件），这个库文件包含了所有Quartz核心功能。这些...
SpringBoot集成Quartz实现分布式动态任务调度
an-ping的博客
10-24 1431
通过Quartz实现动态的管理任务的执行，通过Quartz将任务持久化到数据库中，在集群环境中确保只有单节点执行，当某一节点出故障后，会切换到另一个节点执行。 1 运行环境准备： 去官网下载Quartz的压缩包 将docs/dbTables/tables_mysql.sql下的sql文件在Mysql数据库执行。这是Quartz框架负责实现任务调度的自带数据库。 2 导入Jar包和quartz...
springboot 自动生成quartz表
csdn学子
06-17 1159
spring-boot 中自动生成 quartz 所需的表_冬无雪的博客-CSDN博客_quartz自动建表数据库
[笔记]Springboot入门《三》springboot集成Quartz简单使用+数据库
二次元怪兽的博客
11-19 811
Spring Boot教程(二十一)：Spring Boot使用Quartz定时任务 文章目录环境一、简单使用二、配合数据库 环境 quartz 2.3 一、简单使用 二、配合数据库
SpringBoot整合Quartz实现定时任务
WGH100817的博客
05-13 276
简介 Quartz是一个很牛的任务调度框架，通过它我们可以实现诸如:定时活动、延时活动、订单状态延时检测、服务器状态定时检测等，时间调度任务功能。 下面我们介绍一下它在SpringBoot中的使用： 1.配置Quartz 2.静态任务调度 3.动态任务调度 4.任务调度监听器 快速集成 快速集成体验一下Quartz的功能吧。 1.首先...
SpringBoot搭配Quartz实现动态定时任务源码
06-06
好的，以下是 SpringBoot 搭配 Quartz 实现动态定时任务的源码： 1. 首先，我们需要引入 Quartz 和 SpringBoot 的依赖： ```xml <!-- Quartz相关依赖 --> <groupId>org.quartz-scheduler <artifactId>quartz ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值