【Springboot】Quartz定时任务框架

最新推荐文章于 2024-08-16 15:19:30 发布
最新推荐文章于 2024-08-16 15:19:30 发布
阅读量337 收藏 1
点赞数 1
分类专栏： spring boot 学习 文章标签： spring maven java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZJX_103/article/details/124316242
版权

一、实现流程：

  1. 导入依赖：

    <!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz -->
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.2</version>
</dependency>

  2. 定时任务-实现Job接口

    public class MyJob implements Job{
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException{
        //todo 定时任务代码逻辑
    }
}

  3. 定时器工具

    public class QuartzJobUtil{
    private static SchedulerFactory schedulerFactory = new StdSchedulerFactory();
    
    public static void add(String jobName, String jobGroupName, int time, Class <? extends Job> className){
        //创建任务
        JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
        //创建触发器 每 time 秒钟执行一次
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(jobName, jobGroupName)
               	.withSchedule(SimpleScheduleBuilder
                                  .simpleSchedule()
                                  .withIntervalInSeconds(time)
                                  .repeatForever())
                .build();
        try {
            //获取实例化的 Scheduler。
            Scheduler scheduler = schedulerFactory.getScheduler();
            //将任务及其触发器放入调度器
            scheduler.scheduleJob(jobDetail, trigger);
            //调度器开始调度任务
            if (!scheduler.isShutdown()) {
                scheduler.start();
                //todo 启动任务
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
    
    public void deleteJob(String jobName, String jobGroupName){
            try {
                TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroupName);
                Scheduler scheduler = schedulerFactory.getScheduler();
                scheduler.pauseTrigger(triggerKey);// 停止触发器
                scheduler.unscheduleJob(triggerKey);// 移除触发器
                scheduler.deleteJob(JobKey.jobKey(jobName, jobGroupName));
                //todo 删除任务
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
}

  4. 使用定时器工具添加定时任务。

二、需要注意：

  1. 由于简易，没有持久化操作，重启系统后定时任务丢失。

  2. 每个定时任务启动后会立即执行一次，需要注意。

    延时启动方法：

    //QuartzJobUtil.class
 Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(jobName, jobGroupName)
     //date为Date类型参数,指到该时间后执行第一次定时任务。
     			.startAt(date)
     			.withSchedule(SimpleScheduleBuilder
                                  .simpleSchedule()
                                  .withIntervalInSeconds(time)
                                  .withRepeatCount(0))
                .build();
//SimpleScheduleBuilder相关API用法
//无限制次数重复定时
SimpleScheduleBuilder.repeatForever()
//限制次数重复定时,countNum为定时次数
SimpleScheduleBuilder..withRepeatCount(countNum)
//每过time时间执行一次定时任务
SimpleScheduleBuilder.withIntervalInSeconds(time)

  3. 实际上Quartz有默认的配置文件，你可以使用quartz.properties文件去设置Quartz的参数。默认的配置文件可能并不适用于大量的定时任务，因此需要根据项目需求调整quartz的参数。

  4. 工具型的写法虽然简单，但是无法使用Spring注入的变量，即使用@Autowired修饰的变量，因为是static修饰，所以需要将Spring注入的变量提前加载好。所以该写法适用于监控任务简单的场景。

    建议：使用@Component修饰工具类，不使用static修饰变量与方法，统一使用Spring注入的方式调用工具类。

三、更进一步

  1. 定时任务持久化

    • 添加持久化池依赖：

      <dependency>
    <groupId>com.mchange</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.5.2</version>
</dependency>

    • 编写配置文件quartz.properties。Quartz通过配置文件结合StdSchedulerFactory实现载入配置，StdSchedulerFactory默认加载工作目录下的quartz.properties文件，读取失败时会尝试加载org/quartz包下的quartz.properties文件。

      #quartz.properties
# 实例化ThreadPool时，使用的线程类为SimpleThreadPool
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
# threadCount和threadPriority将以setter的形式注入ThreadPool实例
# 并发个数
org.quartz.threadPool.threadCount = 5
# 优先级
org.quartz.threadPool.threadPriority = 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true
org.quartz.jobStore.misfireThreshold = 5000
#持久化使用的类
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
#数据库中表的前缀
org.quartz.jobStore.tablePrefix = QRTZ_
#数据源命名
org.quartz.jobStore.dataSource = qzDS
#qzDS 数据源
org.quartz.dataSource.qzDS.driver = com.mysql.jdbc.Driver
org.quartz.dataSource.qzDS.URL = jdbc:mysql://localhost:3306/quartz?useUnicode=true&characterEncoding=UTF-8
org.quartz.dataSource.qzDS.user = root
org.quartz.dataSource.qzDS.password = root
org.quartz.dataSource.qzDS.maxConnections = 10

    • 自定义配置加载，创建QuartzConfig.java

      //QuartzConfig.java
import org.quartz.Scheduler;
import org.quartz.ee.servlet.QuartzInitializerListener;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import java.io.IOException;
import java.util.Properties;

/**
 * Qartz配置, 搭配quartz.properties文件自定义配置, 该处目的使定时任务持久化
 */
@Configuration
public class QuartzConfig {

    /**
     * 读取quartz.properties 文件
     * 将值初始化
     * @return
     */
    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }

    /**
     * 将配置文件的数据加载到SchedulerFactoryBean中
     * @return
     * @throws IOException
     */
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        schedulerFactoryBean.setQuartzProperties(quartzProperties());
        return schedulerFactoryBean;
    }

    /**
     * 初始化监听器
     * @return
     */
    @Bean
    public QuartzInitializerListener executorListener(){
        return new QuartzInitializerListener();
    }

    /**
     * 获得Scheduler 对象
     * @return
     * @throws IOException
     */
    @Bean
    public Scheduler scheduler() throws IOException {
        return schedulerFactoryBean().getScheduler();
    }
}

    • 数据库创建默认表，从官网或者org/quartz/impl/jdbcjobstore包下找到对应数据库的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(200) NOT NULL,
    JOB_GROUP VARCHAR(200) 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)
);

CREATE TABLE QRTZ_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    JOB_NAME  VARCHAR(200) NOT NULL,
    JOB_GROUP VARCHAR(200) 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(200) 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)
);

CREATE TABLE QRTZ_SIMPLE_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) 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)
);

CREATE TABLE QRTZ_CRON_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    CRON_EXPRESSION VARCHAR(200) 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)
);

CREATE TABLE QRTZ_SIMPROP_TRIGGERS
  (          
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) 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)
);

CREATE TABLE QRTZ_BLOB_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    BLOB_DATA BLOB 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)
);

CREATE TABLE QRTZ_CALENDARS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    CALENDAR_NAME  VARCHAR(200) NOT NULL,
    CALENDAR BLOB NOT NULL,
    PRIMARY KEY (SCHED_NAME,CALENDAR_NAME)
);

CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_GROUP  VARCHAR(200) NOT NULL, 
    PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_FIRED_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    ENTRY_ID VARCHAR(95) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    INSTANCE_NAME VARCHAR(200) 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(200) NULL,
    JOB_GROUP VARCHAR(200) NULL,
    IS_NONCONCURRENT VARCHAR(1) NULL,
    REQUESTS_RECOVERY VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,ENTRY_ID)
);

CREATE TABLE QRTZ_SCHEDULER_STATE
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    INSTANCE_NAME VARCHAR(200) NOT NULL,
    LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
    CHECKIN_INTERVAL BIGINT(13) NOT NULL,
    PRIMARY KEY (SCHED_NAME,INSTANCE_NAME)
);

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

  2. 解决直接实现Job接口导致@Autowired修饰的变量为空，并报空指针异常的情况。

    原因：Quartz的Job时由自己管理的，因此如果想要在Job中调用Spring管理的Bean，必须让Job也加入Spring容器当中。

    • 自定义JobFactory，使用Spring容器管理Quartz的Bean

      //参考https://www.cnblogs.com/huahua035/p/7839834.html
//MyJobFactory.class
import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.stereotype.Component;

/**
 * Description: 自定义JobFactory,使用Spring容器管理的Quartz的Bean(Job)
 * <p/>
 * AdaptableJobFactory是Spring提供的SchedulerFactoryBean的默认实例化工厂，将由直接实例化Job，没有被Spring管理
 */
@Component
public class MyJobFactory extends AdaptableJobFactory {

    /**
     * AutowireCapableBeanFactory接口是BeanFactory的子类
     * 可以连接和填充那些生命周期不被Spring管理的已存在的bean实例
     * 具体请参考：http://blog.csdn.net/iycynna_123/article/details/52993542
     */
    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;

    /**
     * 创建Job实例
     *
     * @param bundle
     * @return
     * @throws Exception
     */
    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        // 实例化对象
        Object jobInstance = super.createJobInstance(bundle);
        // 进行注入（Spring管理该Bean）,这是Spring进行注入的API，可以查看Spring官方API文档
        capableBeanFactory.autowireBean(jobInstance);
        //返回对象
        return jobInstance;
    }
}

    • 在QuartzConfig.java配置文件中配置SchedulerFactoryBean

      //QuartzConfig.java
@Autowired
private MyJobFactory myJobFactory;

@Bean //将一个方法产生为Bean并交给Spring容器管理(@Bean只能用在方法上)
public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource) throws IOException {
    //Spring提供SchedulerFactoryBean为Scheduler提供配置信息,并被Spring容器管理其生命周期
    SchedulerFactoryBean factory = new SchedulerFactoryBean();
    //启动时更新己存在的Job，这样就不用每次修改targetObject后删除qrtz_job_details表对应记录了
    factory.setOverwriteExistingJobs(true);
    // 延时启动(秒)
    factory.setStartupDelay(20);
    //设置quartz的配置文件
    factory.setQuartzProperties(quartzProperties());
    //设置自定义Job Factory，用于Spring管理Job bean----此处重点.
    factory.setJobFactory(myJobFactory);
    return factory;
}

    • 编写Job任务

      //MyJob.java
@Component
public class MyJob extends QuartzJobBean {

    //使用Spring容器中的变量
    @Autowired
    private XxxService xxxService;


    /**
     * 执行Job
     *
     * @param jobExecutionContext
     * @throws JobExecutionException
     */
    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
       //todo Job任务逻辑
    }

其他知识：

  1. 以Job，Trigger，Scheduler为主要组成部分

  2. Trigger：

    • SimpleTrigger：在特定的时间点，或每隔T个时间单位调度一次

    • CronTrigger：基于日历的调度十分有用，比如每个月，每个星期等调度方式

      * * * * * * *cron表达式，从左至右代表秒，分，时，日，月，周，年，一般情况下忽略年维度，因此6个参数

  3. 如何在Job中增加属性？

    • 因为每当scheduler执行Job时，会创建一个Job实例，调用execute()方法后会回收引用，因此无法在Job类中直接定义数据属性。
    • 使用JobDataMap，原理跟多线程中使用ThreadLocal类似。
    • 在执行Job时，从JobDataMap中取得数据。
    • 假如采取了持久化的方式，那么需要注意存储的数据对象的序列化方式。

  4. JobFactory：

    JobFactory

    当trigger触发时，通过Scheduler上配置的JobFactory实例化与之关联的jobs。默认的JobFactory只是在jobs类上调用newInstance（）。您可能需要创建自己的JobFactory实现，以完成诸如让应用程序的IoC或DI容器生成/初始化jobs实例之类的操作。

    请参阅org.quartz.spi.JobFactory接口以及相关的Scheduler.setJobFactory（fact） 方法。

  5. 参考:
    Quartz文档：w3c
    第一部分内容参考：文章一

天降之夕
关注
专栏目录
从0到1搭建SpringBoot整合Quartz定时任务框架（保姆级教学+Gitee源码）
黄团团的个人博客
06-28 2526
Quartz是一个完全由Java编写的开源作业调度框架，在Java应用程序中进行作业调度提供了强大功能，以下是Quartz的四个核心概念。1、Job（接口）：它只有一个execute方法需要被重写，重写的内容就是咱们需要执行的具体内容。2、JobDetail（调度信息）：表示一个具体的可执行的调度程序，Job是这个可执行调度程序中所需要执行的具体内容，另外JobDetail还包含了这个任务的调度方案和策略。3、Trigger（触发器）：代表一个调度参数的配置，动态去执行咱们的定时任务。
【SpringBoot】82、SpringBoot集成Quartz实现动态管理定时任务
热门推荐
Asurplus
06-29 3万+
Quartz 是一个开源的作业调度框架，它完全由 Java 写成，并设计用于 J2SE 和 J2EE 应用中。它提供了巨大的灵 活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。它有很多特征，如：数据库支持，集群，插件，EJB 作业预构 建，JavaMail 及其它，支持 cron-like 表达式等等
Quartz定时任务框架
12-17
Quartz定时任务框架，本次小白使用它实现一个简单的定时任务。每隔3秒打印一次Hello。这个是例子的jar包，实现过程在博客首页可看到。
【Quartz】Quartz定时任务框架
qq_22193961的博客
04-14 5296
Quartz是一个框架，是SpringBoot御用的定时任务框架，有三大核心部分组成，分别是JobTriggerScheduler。Job：任务，可以理解成你要做什么事，具体要执行的业务逻辑，比如：发送短信、同步数据、发送邮件等。Trigger：触发器，可以理解成你什么时候去做，用来定义Job触发条件、触发时间、触发间隔、终止时间等。Scheduler：调度器，可以理解成你什么时候要去做什么事，它会启动Trigger去执行Job。/*** @author : 黎剑。
springboot集成quartz框架，实现定时任务
weixin_48868742的博客
07-28 260
springboot集成quartz框架，实现定时任务
# SpringBoot定时任务——Quartz定时任务框架
不积跬步，无以至千里；不积小流，无以成江海
06-20 736
SpringBoot定时任务——Quartz定时任务框架 Quartz的介绍及使用思路 概念 Quartz是JobScheduling领域开源项目，可以创建运行10个或者百个Jobs。 使用思路 Job：任务（做什么） Trigger：触发器（什么时候做） Scheduler：任务调度（什么时候要去做什么事） SpringBoot整合 加入依赖 pom.xml <!-- 添加Quartz的依赖 --> <dependency> <groupId&
Springboot 整合 Quartz（定时任务框架）
原名：@程序员大禹
01-31 4820
Quartz是 OpenSymphony 开源组织在 Job scheduling 领域又一个开源项目，完全由 Java 开发，可以用来执行定时任务，类似于 java.util.Timer。持久性作业 - 就是保持调度定时的状态;作业管理 - 对调度作业进行有效的管理;
Springboot整合Quartz任务框架
华小灼
05-07 455
                                                                                                                                                                                                                                                                
SpringBoot 整合 Quartz 定时任务框架
Q54665642ljf的博客
08-15 195
在选择技术栈之前，一定要先明确一件事情，你真的需要用它吗？还有其他方式可以使用吗？相比其他技术技术，优点在哪里呢？使用了之后的利与弊等等。写这个主要是因为一直想写一下定时任务这个主题，这个算是写那篇文前期的铺垫和基础吧~本文没有聊到Java其他的实现定时任务的方法啥的~，只是对使用 Quartz 做了一个小实践。...
Springboot Quartz定时任务的动态调度使用，实战详解
2303_77877769的博客
04-17 1107
针对最近很多人都在面试，我这边也整理了相当多的面试专题资料，也有其他大厂的面经。希望可以帮助到大家。下面的面试题答案都整理成文档笔记。也还整理了一些面试资料&最新2021收集的一些大厂的面试真题（都整理成文档，小部分截图）最新整理电子书《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！定时任务，模拟多定时任务调度处理不同业务：/****/
Quartz--定时任务框架
walker_0312的博客
08-04 245
Quartz-定时任务组件 1.介绍 Quartz是Job scheduling（作业调度）领域的一个开源项目，Quartz既可以单独使用也可以跟spring框架整合使用，在实际开发中一般会使用后者。使用Quartz可以开发一个或者多个定时任务，每个定时任务可以单独指定执行的时间，例如每隔1小时执行一次、每个月第一天上午10点执行一次、每个月最后一天下午5点执行一次等。 官网 http://www.quartz-scheduler.org/ maven坐标 <dependency>
定时任务框架
11-02
使用springboot搭建的一个定时任务框架,具有增,删,改,查,启动,暂停任务的功能,前端页面使用react+antd搭建,详细介绍: https://blog.csdn.net/qq_35488769/article/details/83628374
基于quartz定时任务框架.rar
08-02
本框架是我自己写的一个基于quartz定时任务框架，非常轻量级，自定义的定时任务，同时可以随时调用定时任务结果，感兴趣的可以看看
定时任务框架Quartz
m0_53151031的博客
02-11 8648
一、spring自带调度器 二、Quartz集成 三、Quartz内存版基本使用
Quartz - 定时任务框架
plovec123的博客
10-19 208
Quartz - 定时任务框架 一、简介 ​ 对于定时任务的调度，设置好出发时间的规则，以及相应的业务处理。 ​ ex：30分钟后 提交订单 二、简单使用 ​ 1.引入依赖 <!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz --> <dependency> <groupId>org.quartz-scheduler</gro
quartz定时任务框架
最新发布
qq_49949568的博客
08-16 821
简单介绍了quartz常见的操作，单机、集群环境的搭建等
springboot的定时任务框架
05-02
Spring Boot提供了多种定时任务框架，其中常用的有两种： 1. Spring自带的定时任务框架：通过使用@Scheduled注解来实现定时任务。需要在启动类上面添加@EnableScheduling注解开启定时任务功能。 2. Quartz框架：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值