Quartz定时框架的简单入门

最新推荐文章于 2023-02-21 22:44:41 发布
最新推荐文章于 2023-02-21 22:44:41 发布
阅读量668 收藏 2
点赞数
分类专栏： 常用组件框架 文章标签： quartz 定时任务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hnh_blog/article/details/119180901
版权

Quartz的三个核心概念：调度器、任务、触发器，三者之间的关系是：

 

一个作业，比较重要的三个要素就是Schduler，jobDetail，Trigger；而Trigger 对于job而言就好比一个驱动器；没有触发器来定时驱动作业，作业就无法运行；对于Job而言， 一个job可以对应多个Trigger，但对于Trigger而言，一个Trigger只能对应一个job；所以一 个Trigger 只能被指派给一个 Job；如果你需要一个更复杂的触发计划，你可以创建多个 Trigger并指派它们给同一个 Job。

Scheduler的创建方式：

（1）StdSchedulerFactory:

Quartz默认的SchedulerFactory

  • 使用一组参数（java.util.Properties）来创建和初始化Quartz调度器
  • 配置参数一般存储在quartz.properties文件中
  • 调用getScheduler方法就能创建和初始化调度器对象
    SchedulerFactory schedulerFactory = new StdSchedulerFactory();
    Scheduler scheduler = schedulerFactory.getScheduler();

用法一：输出调度器开始的时间（重要：使得任务和触发器进行关联）：

Date scheduleJob(JobDetail jobDetail, Trigger trigger)

SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println("调度器开始的时间是："+dateFormat.format(scheduler.scheduleJob(job, trigger)));

用法二：启动任务调度：

void start();

scheduler.start();

用法三：任务调度挂起，即暂停操作

void standby()

// Scheduler执行2秒后自动挂起
Thread.sleep(2000L);
scheduler.standby();    
// Scheduler执行5秒后自动开启
Thread.sleep(5000L);
scheduler.start();

用法四：关闭任务调度

void shutdown()

shutdown(true)：表示等待所有正在执行的job执行完毕之后，再关闭Scheduler； shutdown(false)：表示直接关闭Scheduler

入门案例：

项目结构：

pom.xml

   <!-- quartz  -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.1</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>  <!--5.1.6-->
            <scope>runtime</scope>
        </dependency>
QuartzJob类（任务类）
package test.quartz;

import lombok.Data;
import org.quartz.Job;
import java.io.Serializable;


@Data
public class QuartzJob implements Serializable {
    //任务名
    private String taskName;
    //组名
    private String groupName;
    //corn表达式
    private String cornExpr;
    //具体任务实现类
    private Class<? extends Job> clazz;
    //配置类
    private Object obj;

}

QuartzJobImpl类（任务实现类）
package test.quartz;

import org.quartz.*;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 任务实现类
 */
public class QuartzJobImpl implements InterruptableJob {

    private JobKey jobKey;

    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        // 定义时间
        Date date = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateString = dateFormat.format(date);
        System.out.println("进入任务实现类，处理业务逻辑 ->"+dateString);

        jobKey = jobExecutionContext.getJobDetail().getKey();
        //获取任务类
        Object obj = jobExecutionContext.getJobDetail().getJobDataMap().get("obj");
        runTask(obj);
    }

    public void runTask(Object object) {
        //配置类名
        String className = object.getClass().getSimpleName();
        System.out.println("className=" + className);
        //根据配置类名做相应处理
        if ("DemoConfig".equals(className)) {
            System.out.println("good good study");
        } else {
            System.out.println("day day sleep");
        }

    }

    public void interrupt() throws UnableToInterruptJobException {

    }
}

QuarztJobConfig 类(任务配置类)：主要用于配置任务，是否启动任务等

package test.quartz;

import lombok.Data;

import java.io.Serializable;

/**
 * 任务配置类
 */

@Data
public class QuarztJobConfig implements Serializable {
    private String name;
    private Integer state;
}

QuartzManager类：任务调度管理
package test.quartz;

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

/**
 * 任务调度管理器
 */
public class QuartzManager {

    private Scheduler scheduler;

    public void addJob(QuartzJob job){
        System.out.println("enter addJob");
        // 任务名  组名
        JobKey jobKey = new JobKey(job.getTaskName(), job.getGroupName());
        // 任务执行类
        JobDetail jobDetail = JobBuilder.newJob(job.getClazz()).withIdentity(jobKey).build();
        //把配置信息 放入jobdatamap中
        jobDetail.getJobDataMap().put("obj",job.getObj());
        //触发器
        TriggerKey triggerKey = new TriggerKey(job.getTaskName(), job.getGroupName());

        Trigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerKey)
                .withSchedule(CronScheduleBuilder.cronSchedule(job.getCornExpr())
                        .withMisfireHandlingInstructionDoNothing())
                .build();

    /*    Trigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerKey)
                // 2秒执行一次
                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(2))
                // 立即执行
                .startNow()
                .build();*/

        StdSchedulerFactory factory = new StdSchedulerFactory();
        try {
            scheduler = factory.getScheduler();
            //将任务作业 和触发器注册到任务调度中
            scheduler.scheduleJob(jobDetail,trigger);
            //启动
            scheduler.start();

        } catch (SchedulerException e) {
            e.printStackTrace();
        }

    }

    /**
     * 修改定时任务的时间
     * @param job
     * @throws SchedulerException
     */
    public void modify(QuartzJob job) throws SchedulerException {
        TriggerKey triggerKey = new TriggerKey(job.getTaskName(), job.getGroupName());
        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        String oldExp = trigger.getCronExpression();
        String newExp= job.getCornExpr();

        if (!oldExp.equals(newExp)) {
            trigger = TriggerBuilder.newTrigger().withIdentity(triggerKey)
                    .withSchedule(CronScheduleBuilder.cronSchedule(newExp))
                    .startNow().build();

            scheduler.rescheduleJob(triggerKey,trigger);
        }

    }


}

QuartzTest 测试类：
package test.quartz;

import org.quartz.SchedulerException;

/**
 * 测试类
 */
public class QuartzTest {
    private static final String DATA_BACKUP = "data_backup";
    private static final String DATA_GROUP = "data_group";

    public static void main(String[] args) throws SchedulerException {

        QuarztJobConfig taskConfig = new QuarztJobConfig();
        taskConfig.setName("任务配置信息");
        taskConfig.setState(1); //任务配置状态
        QuartzJob taskJob = new QuartzJob();
        taskJob.setTaskName(DATA_BACKUP);
        taskJob.setGroupName(DATA_GROUP);
        taskJob.setCornExpr("0 0/1 11 * * ?");
        //具体任务实现类
        taskJob.setClazz(QuartzJobImpl.class);
        taskJob.setObj(taskConfig);
        //创建任务执行
        QuartzManager manager = new QuartzManager();
        manager.addJob(taskJob);

        //修改定时任务时间
        taskJob.setCornExpr("0 0/1 15 * * ?");
        manager.modify(taskJob);

    }

}

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(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)
);

Quartz的配置属性：quartz.properties

org.quartz.scheduler.instanceName = TestScheduler
org.quartz.threadPool.threadCount = 3
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.tablePrefix = QRTZ_
org.quartz.jobStore.dataSource = myDS

org.quartz.dataSource.myDS.driver = com.mysql.jdbc.Driver
org.quartz.dataSource.myDS.URL = jdbc:mysql://localhost:3306/hnh?characterEncoding=utf-8
org.quartz.dataSource.myDS.user = root
org.quartz.dataSource.myDS.password = xxxx
org.quartz.dataSource.myDS.maxConnections = 5
#连接数据库检测语句
org.quartz.dataSource.myDS.validationQuery = select 1 from dual

测试结果：

Mr_张三阿
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Quartz Scheduler详解
04-03
很不错的quarts scheduler的学习书籍，能帮助初学者快速的入门quarts scheduler框架和运用。
Quartz框架快速入门
10-31
Quartz框架快速入门Quartz框架快速入门
Quartz源码——scheduler.start()启动源码分析（二）
weixin_30814223的博客
04-26 355
scheduler.start()是Quartz的启动方式！下面进行分析，方便自己查看! 我都是分析的jobStore 方式为jdbc的SimpleTrigger！RAM的方式类似分析方式！ Quartz学习——QuartzSchedulerThread.run 源码分析：http://blog.csdn.net/u010648555/article/details/53525041 解释： ...
精进Quartz源码—scheduler.start()启动源码分析（二）
阿飞云漫步
12-08 1万+
scheduler.start()是Quartz的启动方式！下面进行分析，方便自己查看! 我都是分析的jobStore 方式为jdbc的SimpleTrigger！RAM的方式类似分析方式！
初识Quartz之Scheduler组件
carson0408的博客
04-09 2307
        之前在Trigger组件中的withSchedule(ScheduleBuilder scheduleBuilder)方法中，接触过ScheduleBuilder抽象类，通过将ScheduleBuilder对象传入用于调度参数的设置。本文主要讲述的是Scheduler组件，Scheduler组件主要用于将前文讲述的Job组件中的JobDetail对象和Trigger对象绑定在一起，...
Quartz-start启动流程
WandaZw的博客
04-12 1396
转载请注明出处：https://www.cnblogs.com/Dorae/p/9357180.html 本文出自：后端知识点梳理-定时任务Quartz篇章 Quartz 启动流程解析 若Quartz是配置在spring中，当服务器启动时，就会装载相关的bean。SchedulerFactoryBean实现了InitializingBean接口，因此在初始化Bean的时候会执行af...
Quartz源码节选（四）启动Scheduler
无意中流逝的博客
03-16 638
参考资料 Quartz文档译文 Quartz官方文档 Quartz源码解析 第一篇配合第二篇阅读，讲解一些基本概念。若已了解可跳过。 推荐阅读第三篇，因为本文是基于第三篇的笔记。 DEMO 一个DEMO，每3秒输出helloworld public class MyJob implements Job { @Override public void execute(JobExe...
Quartz框架快速入门.pdf
10-05
Quartz框架是一款强大的开源任务调度库，广泛应用于Java环境下的定时任务管理。要开始使用Quartz，首先需要在项目中引入必要的依赖。基础依赖是quartz-<version>.jar，这是Quartz的核心库。除此之外，根据你的需求，...
Quartz_框架快速入门
04-01
本文将引导您快速入门 Quartz 框架，了解其基本使用方法。 首先，要开始使用 Quartz，您需要从官方网站下载对应的 JAR 包，通常为 quartz-<version>.jar。除此之外，根据您的需求，Quartz 可能还需要一些第三方库，...
JAVA定时调度框架-Quartz使用入门到精通.doc
03-13
总的来说，Quartz 是一个功能强大、灵活且易于使用的 Java 定时调度框架，适用于各种需要定时任务的应用场景，如定时发送短信、定期备份数据、自动化统计等。对于 Java 开发者来说，掌握 Quartz 能极大地提高工作...
Python中定时任务框架APScheduler的快速入门指南
12-24
APScheduler是基于Quartz的一个python定时任务框架，实现了Quartz的所有功能，使用起来十分方便。提供了基于日期、固定时间间隔以及crontab类型的任务，并且可以持久化任务。 APScheduler提供了多种不同的调度器，...
quartz---的Scheduler
diyingshou8608的博客
05-10 120
　　　　　　　　　　　　　　　　　　　　　　quartz---的Scheduler 　　　　 　　从这副图中可以很直观的看出来quartz的关系： 　　　　调度：Scheduler任务调度器，是实际执行任务调度的控制器。在spring中通过SchedulerFactoryBean封装起来。 　　　　触发器：Trigger触发器，用于定义任务调度的时间规则，有Simple...
quartz定时任务（05）—— 运行流程源码解析
四维大脑的博客
10-21 753
可了解Quartz框架中的正式开始运行部分源码
任务调度框架Quartz（三）任务调度框架Quartz实例详解深入理解Scheduler,Job,Trigger,JobDetail
w_iceh的博客
07-24 294
首先给一个简明扼要的理解： Scheduler 调度程序-任务执行计划表，只有安排进执行计划的任务Job（通过scheduler.scheduleJob方法安排进执行计划），当它预先定义的执行时间到了的时候（任务触发trigger），该任务才会执行。 在上一节中我们的示例中，我们预先安排了一个定时任务：该任务只做一件事，就是打印任务执行时间以及汇报任务已经执行。我们的任务类实现了org.quar...
Scheduler
heishuiloveyou的博客
02-21 395
通过Properties设置工厂属性的缺点在用硬编码，假如需要修改例子中线程数量，将不得不修改代码，然后重新编译，所以不推荐使用。中存在监听器，相应的，这三者也分别有对应的监听器。监听器的作用便是用于当任务调度中你所关注事件发生时，能够及时获取这一事件的通知。实战中我们了解到三个核心模块分别是。调度器，配置参数一般存储在。getName()：用于获取改。，我们可以使用自定义参数（将要被执行时调用这个方法。是以模块的方式构建的，三、Quartz 监听器。被执行之后调用这个方法。
python 定时任务。任务调度
qq659851998的博客
04-29 2558
介绍官网文档：http://apscheduler.readthedoc...API：http://apscheduler.readthedoc...APScheduler是一个python的第三方库，用来提供python的后台程序。包含四个组件，分别是：triggers： 任务触发器组件，提供任务触发方式job stores： 任务商店组件，提供任务保存方式executors： 任务调度组件，提...
Quartz的任务的临时启动和暂停和恢复
热门推荐
05-24 1万+
转自：http://topmanopensource.iteye.com/blog/1125753         在项目中需要手动启停某些服务，那么需要有一个控制这些任务的类。由于任务是有Quartz控制的，我们只需要通过Quartz的相关的API实现相关的功能即可。        Java代码   package com.easyway.app.quar
Quartz基础篇（三）Scheduler模块
Hello Sky
08-25 1307
Scheduler模块1 .Scheduler作为quart核心控制器的。 核心概念：1.任务，触发器，调度器， 调度器把任务和触发器结合在一起了。2.Scheduler 使用的是工厂模式:俩种创建方式。 常用声明式的创建的方式: SchedulerFactory sfact=new StdSchedulerFactory(); Sched
quartz定时任务框架优缺点
最新发布
09-30
Quartz是一个用于执行定时任务的框架，它具有以下优点： - 灵活性：Quartz允许您定义复杂的触发条件，包括日期、时间间隔和Cron表达式，以满足各种定时需求。 - 可靠性：Quartz提供了持久性作业的支持，可以保持调度定时的状态。即使在应用程序重新启动后，也能保证任务的准确执行。 - 扩展性：Quartz提供了作业管理的功能，可以对调度作业进行有效的管理和监控。 - 高可用性：Quartz支持集群环境下的任务调度，通过使用数据库来存储和共享调度信息，确保多个节点之间的任务调度的一致性。 然而，Quartz也有一些缺点： - 学习曲线较陡峭：Quartz的概念和API相对复杂，需要一定的学习成本和时间来理解和掌握。 - 依赖性较强：Quartz需要依赖于Java环境和相关的第三方库，可能会增加项目的复杂性和依赖关系。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值