Quartz学习笔记

最新推荐文章于 2023-08-29 13:54:07 发布
最新推荐文章于 2023-08-29 13:54:07 发布
阅读量196 收藏
点赞数
文章标签： Quartz基础 与spring/springmvc集成 Quartz集群
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43225978/article/details/86249731
版权

Quartz学习笔记

文章目录

⼀、概述

Quartz是⼀个开放源码的任务调度框架。Quartz功能强⼤，可以让你的程序在指定时间执⾏，也可以按照某⼀个频度执⾏，⽀持数据库、监听器、插件、集群等特性。
使⽤场景：定时消息推送、定时抢购、定时发送邮件、定时统计等。

官网：http://www.quartz-scheduler.org/

二、搭建简单的任务调度环境

1. 创建一个Maven项目，引入依赖jar

<dependency>
 	<groupId>org.quartz-scheduler</groupId>
 	<artifactId>quartz</artifactId>
 	<version>2.2.1</version>
	</dependency>
<dependency>
 	<groupId>org.quartz-scheduler</groupId>
	<artifactId>quartz-jobs</artifactId>
 	<version>2.2.1</version>
</dependency>

2. 创建任务类，定义任务内容

package com.demo.job;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import java.util.Date;

public class MyJob implements Job {
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //输出系统当前时间
        System.out.println(new Date());
    }
}

3. 构建调度任务功能类

package com.demo.test;

import com.demo.job.MyJob;
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.impl.StdSchedulerFactory;

import static org.quartz.CronScheduleBuilder.cronSchedule;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;

public class QuartzJobTest {
    public static void main(String[] args) {
        // 1. 获取调度器
        Scheduler scheduler = null;
        try {
            scheduler = StdSchedulerFactory.getDefaultScheduler();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        // 2. 包装任务内容
        JobDetail jobDetail = newJob(MyJob.class)
                .withIdentity("job1", "group1")
                .build();
        // 3. 定义触发器
        CronTrigger trigger = newTrigger()
                .withIdentity("trigger1", "group1")
                .startNow()
                .withSchedule(cronSchedule("* * * * * ? *"))
                .build();

        // 4. 组装任务
        try {
            scheduler.scheduleJob(jobDetail,trigger);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        // 5. 启动调度器，开始调度
        try {
            scheduler.start();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}

三、Quartz体系架构

Job

是⼀个接⼝，只定义⼀个⽅法execute(JobExecutionContext context)，在实现接⼝的execute
⽅法中编写所需要定时执⾏的Job(任务)， JobExecutionContext类提供了调度应⽤的⼀些信息。
Job运⾏时的信息保存在JobDataMap实例中。

JobDetail

JobDetail 定义的是任务数据，⽽真正的执⾏逻辑是在Job中。sheduler每次执⾏，都会根据
JobDetail创建⼀个新的Job实例

Trigger

是⼀个类，描述触发Job执⾏的时间触发规则。主要有SimpleTrigger和CronTrigger这两个⼦类。
当且仅当需调度⼀次或者以固定时间间隔周期执⾏调度，SimpleTrigger是最适合的选择；
⽽CronTrigger则可以通过Cron表达式定义出各种复杂时间规则的调度⽅案：如⼯作⽇周⼀到周
五的15：00~16：00执⾏调度等

Cron表达式的格式：秒 分 时 ⽇ ⽉ 周 年(可选)。

字段名允许的值允许的特殊字符
秒0-59, – * /
分0-59, – * /
时0-23, – * /
⽇1-31, – * ? / L W C
⽉1-12 or JAN-DEC, – * /
周1-7 or SUN-SAT, – * ? / L C # MON FRI
年（可选字段）empty, 1970-2099, – * /

允许的特殊字符:

  1. “?”字符：表示不确定的值
  2. “,”字符：指定数个值
  3. “-”字符：指定⼀个值的范围
  4. “/”字符：指定⼀个值的增加幅度。n/m表示从n开始，每次增加m
  5. “L”字符：⽤在⽇表示⼀个⽉中的最后⼀天，⽤在周表示该⽉最后⼀个星期X
  6. “W”字符：指定离给定⽇期最近的⼯作⽇(周⼀到周五)
  7. “#”字符：表示该⽉第⼏个周X。6#3表示该⽉第3个周五(从周日开始，6代表周五)

Cron表达式范例:

  1. 每隔5秒执⾏⼀次：*/5 * * * * ?
  2. 每隔1分钟执⾏⼀次：0 */1 * * * ?
  3. 每天23点执⾏⼀次：0 0 23 * * ?
  4. 每天凌晨1点执⾏⼀次：0 0 1 * * ?
  5. 每⽉1号凌晨1点执⾏⼀次：0 0 1 1 * ?
  6. 每⽉最后⼀天23点执⾏⼀次：0 0 23 L * ?
  7. 每周星期天凌晨1点实⾏⼀次：0 0 1 ? * L
  8. 在26分、29分、33分执⾏⼀次：0 26,29,33 * * * ?
  9. 每天的0点、13点、18点、21点都执⾏⼀次：0 0 0,13,18,21 * * ?

Scheduler

代表⼀个Quartz的独⽴运⾏容器，Trigger和JobDetail可以注册到Scheduler中， 两者在Scheduler中拥有各⾃的组及名称， 组及名称是Scheduler查找定位容器中某⼀对象的依据，Trigger的组及名称必须唯⼀， JobDetail的组和名称也必须唯⼀（但可以和Trigger的组和名称相同，因为它们是不同类型的）。Scheduler定义了多个接⼝⽅法， 允许外部通过组及名称访问和控制容器中Trigger和JobDetail。

JobBulider

⽤于定义/构建已经定义了Job实例的JobDetail实例

TriggerBuilder

⽤于定义/构建Trigger实例。

四、Quartz与Spring集成

1. 创建Spring项目，引入依赖jar

<!-- quartz依赖 -->
<dependency>
 	<groupId>org.quartz-scheduler</groupId>
 	<artifactId>quartz</artifactId>
 	<version>2.2.1</version>
</dependency>
<dependency>
 	<groupId>org.quartz-scheduler</groupId>
 	<artifactId>quartz-jobs</artifactId>
 	<version>2.2.1</version>
</dependency>
<!--spring依赖-->
<dependency>
 	<groupId>org.springframework</groupId>
 	<artifactId>spring-context-support</artifactId>
 	<version>3.2.8.RELEASE</version>
</dependency>
<dependency>
 	<groupId>org.springframework</groupId>
 	<artifactId>spring-tx</artifactId>
 	<version>3.2.8.RELEASE</version>
</dependency>

2. 创建任务类，定义任务内容

package com.demo.job;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import java.util.Date;

public class MyJob implements Job {
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //输出系统当前时间
        System.out.println(new Date());
    }
}

3. 创建并编写spring的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 创建JobDetail -->
    <bean id="jobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
        <!-- 指定任务类 -->
        <property name="jobClass" value="com.demo.job.MyJob"></property>
        <!-- 当Job在没有可以使⽤的trigger的情况下 不删除 -->
        <property name="durability" value="true"></property>
    </bean>

    <!-- 注意 spring quartz整合 ⼀个trigger只可以绑定⼀个JobDetail ⼀个jobDetail可以被多个Trigger所使⽤ -->
    <bean id="trigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <!-- 绑定JobDetail -->
        <property name="jobDetail" ref="jobDetail"></property>
        <property name="cronExpression" value="0-30 * * * * ?"></property>
    </bean>
    <bean id="trigger1" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <!--绑定JobDetail-->
        <property name="jobDetail" ref="jobDetail"></property>
        <property name="cronExpression" value="45-55 * * * * ?"></property>
    </bean>

    <!--注册trigger，进行任务调度 -->
    <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="trigger"></ref>
                <ref bean="trigger1"></ref>
            </list>
        </property>
    </bean>
</beans>

五、Quartz与Spring Boot集成

1. 创建Spring Boot项目，引入依赖jar

<!-- quartz依赖 -->
<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>

2. 创建任务类，定义任务内容

package com.demo.job;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import java.util.Date;

public class MyJob implements Job {
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //输出系统当前时间
        System.out.println(new Date());
    }
}

3. 创建controller

package com.demo.controller;

import com.demo.job.MyJob;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import static org.quartz.CronScheduleBuilder.cronSchedule;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;

@RestController
public class QuartzController {

    @Autowired
    private Scheduler scheduler;

    /**
     * 新增调度任务的方法
     * @return
     */
    @RequestMapping("/add")
    public String addJob(String jobName,String jobGroup,String triggerName,String triggerGroup,String cronExpression){
        try {
            //包装任务
            JobDetail jobDetail = newJob(MyJob.class).withIdentity(jobName,jobGroup).build();
            //创建触发器及触发规则
            Trigger trigger = newTrigger()
                    //指定触发规则 ，cronExpression为Cron表达式
                    .withSchedule(cronSchedule(cronExpression))
                    //指定触发器名称及所属组
                    .withIdentity(triggerName,triggerGroup)
                    //创建触发器
                    .build();
            //进行调度
            scheduler.scheduleJob(jobDetail,trigger);
            return "success";
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return "fail";
    }
    /**
     * 暂停调度任务
     */
    @RequestMapping("/pause")
    public String pause(String jobName,String jobGroup){
        try {
            scheduler.pauseJob(JobKey.jobKey(jobName,jobGroup));
            return "success";
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return "fail";
    }
    /**
     * 开始调度任务
     */
    @RequestMapping("/remuse")
    public String remuse(String jobName,String jobGroup){
        try {
            scheduler.resumeJob(JobKey.jobKey(jobName,jobGroup));
            return "success";
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return "fail";
    }
}

六、存储⽅式

1. RAMJobStore和JDBCJobStore存储方式对比

类型优点缺点
RAMJobStore（默认）不要外部数据库，配置容易，运⾏速度快因为调度程序信息是存储在被分配给JVM的内存⾥⾯，所以，当应⽤程序停⽌运⾏时，所有调度信息将被丢失。另外因为存储到JVM内存⾥⾯，所以可以存储多少个Job和Trigger将会受到限制
JDBCJobStore⽀持集群，因为所有的任务信息都会保存到数据库中，可以控制事物，还有就是如果应⽤服务器关闭或者重启，任务信息都不会丢失，并且可以恢复因服务器关闭或者重启⽽导致执⾏失败的任务运⾏速度的快慢取决与连接数据库的快慢

2. 设置 JDBCJobStore

在应⽤程序中设置使⽤ JDBCJobStore 需要两步：

1. ⾸先必须创建作业仓库使⽤的数据库表。

JDBCJobStore 与所有主流数据库都兼容，⽽且 Quartz 提供了⼀系列创建表的 SQL 脚本，能够简化设置过程。可以在 Quartz 发⾏包的 “docs/dbTables”⽬录中找到创建表的 SQL 脚本，使用对应的SQL脚本创建表：数据库表
>Quartz 发⾏包下载地址：链接：https://pan.baidu.com/s/1CZ1khHlRc9SyIul10uDNDQ 提取码：agjx

2. 创建quartz.properties配置文件，并定义⼀些属性
在 `quartz.properties`⽂件中指定 JDBCJobStore 属性

	org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
	org.quartz.threadPool.threadCount = 10
	org.quartz.threadPool.threadPriority = 5
	org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true
	# Using RAMJobStore
	## if using RAMJobStore, please be sure that you comment out the following
	## - org.quartz.jobStore.tablePrefix,
	## - org.quartz.jobStore.driverDelegateClass,
	## - org.quartz.jobStore.dataSource
	#org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore
	# Using JobStoreTX
	## Be sure to run the appropriate script(under docs/dbTables) first to create tables
	org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
	# Configuring JDBCJobStore with the Table Prefix
	org.quartz.jobStore.tablePrefix = QRTZ_
	# Using DriverDelegate
	org.quartz.jobStore.driverDelegateClass = 	org.quartz.impl.jdbcjobstore.StdJDBCDelegate
	# Using datasource
	org.quartz.jobStore.dataSource = qzDS
	# Define the datasource to use
	org.quartz.dataSource.qzDS.driver = com.mysql.jdbc.Driver
	org.quartz.dataSource.qzDS.URL = jdbc:mysql://localhost:3306/quartz
	org.quartz.dataSource.qzDS.user = root
	org.quartz.dataSource.qzDS.password = root
	org.quartz.dataSource.qzDS.maxConnections = 30
3. 定义spring的配置文件spring-quartz.xml

在进行任务调度时加入以下配置，指定jdbcJobStore的配置文件：
<property name="configLocation" value="classpath:quartz.properties"></property>
完整的spring配置文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 创建JobDetail -->
    <bean id="jobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
        <!-- 指定任务类 -->
        <property name="jobClass" value="com.demo.job.MyJob"></property>
        <!-- 当Job在没有可以使⽤的trigger的情况下 不删除 -->
        <property name="durability" value="true"></property>
    </bean>

    <!-- 注意 spring quartz整合 ⼀个trigger只可以绑定⼀个JobDetail ⼀个jobDetail可以被多个Trigger所使⽤ -->
    <bean id="trigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <!-- 绑定JobDetail -->
        <property name="jobDetail" ref="jobDetail"></property>
        <property name="cronExpression" value="0-30 * * * * ?"></property>
    </bean>
    <bean id="trigger1" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <!--绑定JobDetail-->
        <property name="jobDetail" ref="jobDetail"></property>
        <property name="cronExpression" value="45-55 * * * * ?"></property>
    </bean>

    <!--注册trigger ，进行任务调度 -->
    <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <!-- 指定jdbcJobStore使用的配置文件 -->
        <property name="configLocation" value="classpath:quartz.properties"></property>
        <property name="triggers">
            <list>
                <ref bean="trigger"></ref>
                <ref bean="trigger1"></ref>
            </list>
        </property>
    </bean>
</beans>
4. 运行测试

jdbcJobstore的存储方式
可以看到数据库中有任务存储进去。

六、集群⽀持

1. 原理

虽然单个Quartz实例能给予你很好的Job调度能⼒，但它不能满⾜典型的企业需求，如可伸缩性、⾼可靠性。假如你需要故障转移的能⼒并能运⾏⽇益增多的 Job，Quartz集群势必成为你应⽤的⼀部分了。使⽤ Quartz 的集群能⼒可以更好的⽀持你的业务需求，并且即使是其中⼀台机器在最糟的时间崩溃了也能确保所有的 Job 得到执⾏。
⼀个 Quartz 集群中的每个节点是⼀个独⽴的 Quartz 应⽤，它⼜管理着其他的节点。意思是你必须对每个节点分别启动或停⽌。不像许多应⽤服务器的集群，独⽴的 Quartz 节点并不与另⼀其他的节点通信或是管理节点通信。Quartz 应⽤是通过数据库表来感知到另⼀应⽤的。
图：表示了每个节点直接与数据库通信，若离开数据库将对其他节点⼀⽆所知
quartz集群节点之间的关系图

2. 搭建集群

1. 创建quartz-cluster.properties配置文件
#==============================================================
#Configure Main Scheduler Properties
#==============================================================
org.quartz.scheduler.instanceName = quartzScheduler
org.quartz.scheduler.instanceId = AUTO

#==============================================================
#Configure JobStore
#==============================================================
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.isClustered = true
org.quartz.jobStore.clusterCheckinInterval = 3000  
org.quartz.jobStore.dataSource = myDS

#==============================================================
#Configure DataSource
#==============================================================
org.quartz.dataSource.myDS.driver = com.mysql.jdbc.Driver
org.quartz.dataSource.myDS.URL = jdbc:mysql://localhost:3306/quartz?useUnicode=true&amp;characterEncoding=UTF-8
org.quartz.dataSource.myDS.user = root
org.quartz.dataSource.myDS.password = root
org.quartz.dataSource.myDS.maxConnections = 30

#==============================================================
#Configure ThreadPool
#==============================================================
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 5
org.quartz.threadPool.threadPriority = 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true
2. 创建spring-quartz.xml配置文件

在进行任务调度时加入以下配置，指定使用集群的配置文件：
<property name="configLocation" value="classpath:quartz-cluster.properties"></property>
完整的spring配置文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 创建JobDetail -->
    <bean id="jobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
        <!-- 指定任务类 -->
        <property name="jobClass" value="com.demo.job.MyJob"></property>
        <!-- 当Job在没有可以使⽤的trigger的情况下 不删除 -->
        <property name="durability" value="true"></property>
    </bean>

    <!-- 注意 spring quartz整合 ⼀个trigger只可以绑定⼀个JobDetail ⼀个jobDetail可以被多个Trigger所使⽤ -->
    <bean id="trigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <!-- 绑定JobDetail -->
        <property name="jobDetail" ref="jobDetail"></property>
        <property name="cronExpression" value="0-30 * * * * ?"></property>
    </bean>
    <bean id="trigger1" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <!--绑定JobDetail-->
        <property name="jobDetail" ref="jobDetail"></property>
        <property name="cronExpression" value="30-59 * * * * ?"></property>
    </bean>

    <!--注册trigger,进行任务管理-->
    <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <!-- 指定集群的配置文件 -->
        <property name="configLocation" value="classpath:quartz-cluster.properties"></property>
        <property name="triggers">
            <list>
                <ref bean="trigger"></ref>
                <ref bean="trigger1"></ref>
            </list>
        </property>
    </bean>
</beans>
3. 启动spring⼯⼚并测试
IT小浣熊
关注
专栏目录
作业调度框架 Quartz 学习笔记(一) -- HelloWorld !!!
无他， 但手熟尔
03-04 1万+
关于定时任务的操作方法,java语言本身具有 Timer 来解决,但Timer 作用起来不是特别的舒服,由于项目的需要,使用了Quartz 这个调度框架,现把学习过程记录下来,方便以后查阅. 本教程是按照Quartz 提供的 15个Example 一步一步深入学习,由于我也是一菜鸟,在学习本教程时,如发现有错误之处,请各位大人指点.小弟不胜感激! 附几个连接: Timer 的问题:http:
Quartz 学习笔记
qq_39183887的博客
10-21 501
Quartz quartz是什么 quartz能做什么 quartz的核心API 编写代码测试原生的quartz quartz的cron表达式 整合spring（spring mvc） - 单机版、集群版 整合springboot - 单机版、集群版 springboot整合spring task实现任务调度 1.Quartz是什么？ Quartz官方网站：http://www.quartz-scheduler.org Quartz是一个功能丰富的开源任务调度框架，几乎可以集成到任何java应用
quartz学习笔记
杨鹏飞的博客
02-02 251
1.定时任务quartz概况 quartz是一个任务调度框架，通过触发器设置作业的定时运行规则，来执行定时任务。相当于数据库中的 Job、Windows 的计划任务、Unix/Linux 下的 Cron，但 Quartz 可以把排程控制的更精细。把一系列任务自动安置到一个作业中，然后再为这个作业创建一个调度器，到时这个作业就会自动执行了。 2.定时任务quartz主要用到的设计模式
Quartz学习笔记（一）
不积跬步，无以至千里、
05-26 166
因为下个项目需要用到定时器，以前写定时器用的是 Timer类，都是一些比较简单的 Task ，这次的后台 Task 比较多，并且业务也相对复杂，所有再看需求 的同时，自己了看了下Quartz，先将学习笔记总结如下： 1、Quartz 简介 a、Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合也可以单...
Quartz 学习笔记（一）任务调度框架 | 核心组件 Job、Trigger 和 Scheduler | 入门案例 | 监听器
希望每天都能进步一点点
07-09 1274
Quartz 是开源且具有丰富特性的“任务调度库”，能够集成任何的Java应用，小到独立的应用，大到电子商业系统。Quartz既能创建简单，也能创建复杂的任务调度，以执行上十、上百，甚至上万的任务。任务 job 被定义为标准的Java组件，能够执行任何想要实现的功能。...
quartz学习笔记(1)---scheduler and Job
iZoro67
01-06 234
由java编写的开源作业调度框架,可单独使用,可与其他应用结合,Job和Trigger多对多的关系. Scheduler - 与调度器交互的主要API. Job - 一个被组件(你希望调度器执行的内容)实现的接口. JobDetail - 定义Job的实例化. Trigger - 一个组件，它定义执行给定作业的调度. JobBuilder - 用于定义/构建JobDetail...
Quartz学习笔记1：Quartz概述
weixin_30897233的博客
09-04 218
Quartz是开源任务调度框架中的翘楚，它提供了强大的 任务调度机制。Quartz允许开发人员灵活的定义触发器的调度时间表，并可对触发器和任务进行关联映射。此外，Quartz提供了调度运行环境的持久化机制，可以保存并恢复调度现场，即使系统因故障关闭，任务调度现场数据并不会丢失。此外，Quartz还提供了组件式的侦听器、各种插件、线程池等功能。 一、Quartz基础结...
Quartz学习笔记大全（不定期更新）
最新发布
力挽狂澜的POWER
08-29 286
通过调度器创建作业：Quartz 提供了调度器（Scheduler）来创建和管理作业。调度器管理：Quartz 提供了丰富的 API 和功能，用于管理调度器的状态、暂停和恢复作业、动态添加和移除作业等。Quartz 是一个开源的作业调度框架，用于在指定的时间触发和执行任务。执行作业：当触发器满足条件时，调度器会根据配置的作业信息执行相应的任务。总的来说，Quartz 的原理就是通过调度器、作业和触发器的配合，实现按照预定规则和时间执行任务的功能。调度器会根据触发器定义的规则，自动触发作业的执行。
Quartz学习笔记（一）快速入门
qq_38846242的博客
03-18 1571
Quartz学习笔记（一）快速入门什么是QuartzQuartz 核心概念Quartz的运行环境快速入门Quartz APIScheduler的生命期builder类 最近在工作中用到了Quartz，趁此机会学习了一下，顺便写些笔记记录一下。 参照Quartz官方文档 什么是Quartz Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目。 它完全由 J...
Quartz学习笔记（一）——入门
weixin_34199405的博客
06-27 160
2019独角兽企业重金招聘Python工程师标准>>> ...
Quartz2.x学习笔记（一）
Howard的博客
02-23 741
java有个Timer类可以实现定时任务，但相比开源框架Quartz，还是有所不足。 这里简单讲讲Quartz的使用。 我的测试环境是jdk8 Quartz版本是2.2.1. (参考博文：http://www.blogjava.net/baoyaer/articles/155645.html  对很多概念讲的比较清楚 只不过使用的是1.8版本的 我参考后做了quartz2.2.1版本的dem
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值