Quartz入门

最新推荐文章于 2024-09-17 15:51:24 发布
最新推荐文章于 2024-09-17 15:51:24 发布
阅读量285 收藏
点赞数
分类专栏： quartz
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tzyybhs/article/details/110824363
版权
Quartz是一个开源的Java任务调度框架，用于管理任务执行。本文介绍了Quartz的触发器类型，如SimpleTrigger和CronTrigger，以及Quartz的存储方式，包括RAMJobStore和JDBCJobStore。还详细讲解了Quartz的表结构、核心类之间的关系以及配置文件quartz.properties。通过一个简单的入门Demo展示了如何在RAM方式下使用Quartz，并解析了cronExpression的使用方式。
摘要由CSDN通过智能技术生成

Quartz入门

Quartz介绍

    任务调度框架“Quartz”是OpenSymphony开源组织在Job scheduling领域又一个开源项目，是完全由java开发的一个开源的任务日程管理系统，
“任务进度管理器”就是一个在预先确定（被纳入日程）的时间到达时，负责执行（或者通知）其他软件组件的系统。

    简单来说就是实现“计划(或定时)任务”的系统，例如：订单下单后未付款，15分钟后自动撤消订单，并自动解锁锁定的商品

Quartz的触发器

    触发器用来告诉调度程序作业什么时候触发。框架提供了5种触发器类型，但两个最常用的SimpleTrigger和CronTrigger。

五种类型的Trigger(定时器)
SimpleTrigger，CronTirgger，DateIntervalTrigger，
NthIncludedDayTrigger和Calendar类（ org.quartz.Calendar）。

场景：
SimpleTrigger：执行N次，重复N次
CronTirgger：几时几分几秒，哪天/哪月/哪年，执行

存储方式

    RAMJobStore(内存作业存储类型)和JDBCJobStore(数据库作业存储类型)，两种方式对比如下：

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

JDBCJobStor存储中表关系和说明

Quartz表关系
在这里插入图片描述

Quartz表说明
在这里插入图片描述

核心类和核心类之间关系

在这里插入图片描述

  1. QuartzSchedulerThread
    负责执行向QuartzScheduler注册的触发Trigger的工作的线程。

  2. ThreadPool
    Scheduler使用一个线程池作为任务运行的基础设施，任务通过共享线程池中的线程提供运行效率。

  3. QuartzSchedulerResources
    包含创建QuartzScheduler实例所需的所有资源（JobStore，ThreadPool等）。

  4. SchedulerFactory- XxxFactory
    提供用于获取调度程序实例的客户端可用句柄的机制。

  5. obStore
    通过类实现的接口，这些类要为org.quartz.core.QuartzScheduler的使用提供一个org.quartz.Job和org.quartz.Trigger存储机制。
    作业和触发器的存储应该以其名称和组的组合为唯一性。

  6. QuartzScheduler
    这是Quartz的核心，它是org.quartz.Scheduler接口的间接实现，包含调度org.quartz.Jobs，注册org.quartz.JobListener实例等的方法。

  7. Scheduler
    这是Quartz Scheduler的主要接口，代表一个独立运行容器。调度程序维护JobDetails和触发器的注册表。
    一旦注册，调度程序负责执行作业，当他们的相关联的触发器触发（当他们的预定时间到达时）。

  8. Trigger
    具有所有触发器通用属性的基本接口，描述了job执行的时间出发规则。 - 使用TriggerBuilder实例化实际触发器。

  9. JobDetail
    传递给定作业实例的详细信息属性。 JobDetails将使用JobBuilder创建/定义。

  10. Job：
    要由表示要执行的“作业”的类实现的接口。只有一个方法
    void execute(jobExecutionContext context)
    (jobExecutionContext 提供调度上下文各种信息，运行时数据保存在jobDataMap中)

    Job有个子接口StatefulJob ,代表有状态任务。
    有状态任务不可并发，前次任务没有执行完，后面任务处于阻塞等到

    注1：这里面最最重要的接口是Scheduler接口。它提供了简单的操作，例如：将任务纳入日程或者从日程中取消，开始/停止/暂停日程进度。
    翻译：Scheduler的中文是：“调度程序，日程安排程序”

配置文件quartz.properties

内容分如下几个部分
Quartz Schedular主配置、ThreadPool设置、JobStore配置、DataSources、JDBC-JobStore群集

JDBC插入表顺序

  1. Simple_trigger ：插入顺序
    qrtz_job_details —> qrtz_triggers —> qrtz_simple_triggers
    qrtz_fired_triggers

  2. Cron_Trigger：插入顺序
    qrtz_job_details —> qrtz_triggers —> qrtz_cron_triggers
    qrtz_fired_triggers

Quartz简单入门Demo(RAM方式)，版本quartz.2.2.1

  1. 导入依赖
<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>

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zking</groupId>
    <artifactId>q01</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>q01 Maven Webapp</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <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>

        <!-- **********************  日志配置  ********************** -->
        <!--记得修改mybatis.cfg.xml添加如下内容-->
        <!--<setting name="logImpl" value="SLF4J"/>-->
        <!-- log配置：Log4j2 + Slf4j -->
        <!-- slf4j核心包-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.13</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>1.7.13</version>
            <scope>runtime</scope>
        </dependency>

        <!--核心log4j2jar包-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.4.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.4.1</version>
        </dependency>
        <!--用于与slf4j保持桥接-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.4.1</version>
        </dependency>
        <!--web工程需要包含log4j-web，非web工程不需要-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-web</artifactId>
            <version>2.4.1</version>
            <scope>runtime</scope>
        </dependency>

        <!--需要使用log4j2的AsyncLogger需要包含disruptor-->
        <dependency>
            <groupId>com.lmax</groupId>
            <artifactId>disruptor</artifactId>
            <version>3.2.0</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>q01</finalName>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>
                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.0.0</version>
                </plugin>
                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.7.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.20.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.2.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>

<!-- status : 指定log4j本身的打印日志的级别.ALL< Trace < DEBUG < INFO < WARN < ERROR 
	< FATAL < OFF。 monitorInterval : 用于指定log4j自动重新配置的监测间隔时间，单位是s,最小是5s. -->
<Configuration status="WARN" monitorInterval="30">
	<Properties>
		<!-- 配置日志文件输出目录 ${sys:user.home} -->
		<Property name="LOG_HOME">/root/workspace/lucenedemo/logs</Property>
		<property name="ERROR_LOG_FILE_NAME">/root/workspace/lucenedemo/logs/error</property>
		<property name="WARN_LOG_FILE_NAME">/root/workspace/lucenedemo/logs/warn</property>
		<property name="PATTERN">%d{yyyy-MM-dd HH:mm:ss.SSS} [%t-%L] %-5level %logger{36} - %msg%n</property>
	</Properties>

	<Appenders>
		<!--这个输出控制台的配置 -->
		<Console name="Console" target="SYSTEM_OUT">
			<!-- 控制台只输出level及以上级别的信息(onMatch),其他的直接拒绝(onMismatch) -->
			<ThresholdFilter level="trace" onMatch="ACCEPT"
				onMismatch="DENY" />
			<!-- 输出日志的格式 -->
			<!-- %d{yyyy-MM-dd HH:mm:ss, SSS} : 日志生产时间 %p : 日志输出格式 %c : logger的名称 
				%m : 日志内容，即 logger.info("message") %n : 换行符 %C : Java类名 %L : 日志输出所在行数 %M 
				: 日志输出所在方法名 hostName : 本地机器名 hostAddress : 本地ip地址 -->
			<PatternLayout pattern="${PATTERN}" />
		</Console>

		<!--文件会打印出所有信息，这个log每次运行程序会自动清空，由append属性决定，这个也挺有用的，适合临时测试用 -->
		<!--append为TRUE表示消息增加到指定文件中，false表示消息覆盖指定的文件内容，默认值是true -->
		<File name="log" fileName="logs/test.log" append="false">
			<PatternLayout
				pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
		</File>
		<!-- 这个会打印出所有的info及以下级别的信息，每次大小超过size， 则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档 -->
		<RollingFile name="RollingFileInfo" fileName="${LOG_HOME}/info.log"
			filePattern="${LOG_HOME}/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log">
			<!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch） -->
			<ThresholdFilter level="info" onMatch="ACCEPT"
				onMismatch="DENY" />
			<PatternLayout
				pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
			<Policies>
				<!-- 基于时间的滚动策略，interval属性用来指定多久滚动一次，默认是1 hour。 modulate=true用来调整时间：比如现在是早上3am，interval是4，那么第一次滚动是在4am，接着是8am，12am...而不是7am. -->
				<!-- 关键点在于 filePattern后的日期格式，以及TimeBasedTriggeringPolicy的interval， 日期格式精确到哪一位，interval也精确到哪一个单位 -->
				<!-- log4j2的按天分日志文件 : info-%d{yyyy-MM-dd}-%i.log -->
				<TimeBasedTriggeringPolicy interval="1"
					modulate="true" />
				<!-- SizeBasedTriggeringPolicy:Policies子节点， 基于指定文件大小的滚动策略，size属性用来定义每个日志文件的大小. -->
				<!-- <SizeBasedTriggeringPolicy size="2 kB" /> -->
			</Policies>
		</RollingFile>

		<RollingFile name="RollingFileWarn" fileName="${WARN_LOG_FILE_NAME}/warn.log"
			filePattern="${WARN_LOG_FILE_NAME}/$${date:yyyy-MM}/warn-%d{yyyy-MM-dd}-%i.log">
			<ThresholdFilter level="warn" onMatch="ACCEPT"
				onMismatch="DENY" />
			<PatternLayout
				pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
			<Policies>
				<TimeBasedTriggeringPolicy />
				<SizeBasedTriggeringPolicy size="2 kB" />
			</Policies>
			<!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件，这里设置了20 -->
			<DefaultRolloverStrategy max="20" />
		</RollingFile>

		<RollingFile name="RollingFileError" fileName="${ERROR_LOG_FILE_NAME}/error.log"
			filePattern="${ERROR_LOG_FILE_NAME}/$${date:yyyy-MM}/error-%d{yyyy-MM-dd-HH-mm}-%i.log">
			<ThresholdFilter level="error" onMatch="ACCEPT"
				onMismatch="DENY" />
			<PatternLayout
				pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
			<Policies>
				<!-- log4j2的按分钟 分日志文件 : warn-%d{yyyy-MM-dd-HH-mm}-%i.log -->
				<TimeBasedTriggeringPolicy interval="1"
					modulate="true" />
				<!-- <SizeBasedTriggeringPolicy size="10 MB" /> -->
			</Policies>
		</RollingFile>

	</Appenders>

	<!--然后定义logger，只有定义了logger并引入的appender，appender才会生效 -->
	<Loggers>
		<!--过滤掉spring和mybatis的一些无用的DEBUG信息 -->
		<logger name="org.springframework" level="INFO"></logger>
		<logger name="org.mybatis" level="INFO"></logger>

		<!-- 第三方日志系统 -->
		<logger name="org.springframework" level="ERROR" />
		<logger name="org.hibernate" level="ERROR" />
		<logger name="org.apache.struts2" level="ERROR" />
		<logger name="com.opensymphony.xwork2" level="ERROR" />
		<logger name="org.jboss" level="ERROR" />


		<!-- 配置日志的根节点 -->
		<root level="all">
			<appender-ref ref="Console" />
			<appender-ref ref="RollingFileInfo" />
			<appender-ref ref="RollingFileWarn" />
			<appender-ref ref="RollingFileError" />
		</root>

	</Loggers>

</Configuration>
  1. 创建自定义RamJob
    必须实现org.quartz.Job接口
    RamJob
package p1;

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


public class RamJob implements Job {

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

        //得到当前作业的名称
        //String jobName = jobExecutionContext.getJobDetail().getJobDataMap().getString("name");
        Integer orderId = jobExecutionContext.getJobDetail().getJobDataMap().getInt("orderId");

        System.out.println("订单付款超时，编号为[" + orderId + "]的订单已取消");
    }
}
  1. 启动quartz
    Demo1.java
package p1;


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

import java.util.Date;

public class Demo1 {
    private static final Logger log = org.slf4j.LoggerFactory.getLogger(Demo1.class);

    public static void main(String[] args) throws Exception {
        //1.创建Scheduler的工厂
        SchedulerFactory sf = new StdSchedulerFactory();

        //2.从工厂中获取调度器实例
        Scheduler scheduler = sf.getScheduler();


        //3.创建JobDetail  XxxBuilder构建者模式
        JobDetail jb = JobBuilder.newJob(RamJob.class)
                .withDescription("this is a ram job") //job的描述
                .withIdentity("ramJob", "ramGroup") //job 的name和group生成任务ID
                .build();
        //向任务传递数据
        jb.getJobDataMap().put("orderId", 1001);

        //任务运行的时间，SimpleSchedle类型触发器有效
        long time = System.currentTimeMillis() + 5 * 1000L; //5秒后启动任务
        Date statTime = new Date(time);

        //4.创建Trigger
        //使用SimpleScheduleBuilder或者CronScheduleBuilder
        Trigger t = TriggerBuilder.newTrigger()
                .withDescription("")
                .withIdentity("ramTrigger", "ramTriggerGroup")
                .startAt(statTime)  //默认当前时间启动
                //.withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(3).withRepeatCount(3))//间隔3秒，重复3次
                .withSchedule(CronScheduleBuilder.cronSchedule("0/3 15 15 * * ?")) //两秒执行一次
                .build();

        //5.注册任务和定时器
        scheduler.scheduleJob(jb, t);

        //6.启动 调度器
        scheduler.start();
        log.info("启动时间 ： " + new Date());
    }
}

cronExpression表达式解释

这些星号由左到右按顺序代表 ： * * * * * * *
格式： [秒] [分] [小时] [日] [月] [周] [年]

常用示例

每天凌晨2点 0 0 2 * * ?和每天隔一小时 0 * */1 * * ?

例1：每隔5秒执行一次：*/5 * * * * ?

例2：每隔5分执行一次：0 */5 * * * ?cronExpression表达式解释
这些星号由左到右按顺序代表 ： * * * * * * *
格式： [秒] [分] [小时] [日] [月] [周] [年]

常用示例

每天凌晨2点 0 0 2 * * ?和每天隔一小时 0 * */1 * * ?

例1：每隔5秒执行一次：*/5 * * * * ?

例2：每隔5分执行一次：0 */5 * * * ?

涵ヂ
关注
专栏目录
Quartz的SimpleTrigger
实践求真知
11-17 1266
一 点睛 1 SimpleTrigger的作用 在一个指定的时间段内执行一次作业任务。 或是在指定的时间间隔内多次执行作业任务。 2 需要注意的点 重复次数可以为0，正整数或是SimpleTrigger.REPEAT_INDEFINITELY 常量值 重复执行间隔必须为0或长整数 一旦被指定了endTime参数，那么它就会覆盖重复次数参数的效果 二 实战——距离当前的时间4秒钟后执行...
Quartz(二)-SimpleTrigger
lss0555的博客
08-05 2516
介绍 如果你的job需要在指定的时间执行，或者要间断的不断地执行，SimpleTrigger就能满足这些需求。比如，让你的触发器在具体时间 触发，几秒执行一次，连续执行几次,这个时候可以使用SimpleTrigger。 SimpleTrigger中的几个参数：JobKey,start-time, end-time, repeat count, 以及repeat interval。 JobKe...
Quartz 完善版：Java任务调度框架即学即用指南
最新发布
weixin_35751412的博客
09-17 1042
本文还有配套的精品资源，点击获取 简介：Quartz是一个开源的Java任务调度框架，广泛应用于企业级Java应用中，其核心功能是高效管理和执行定时任务。本资源提供了优化的Quartz实例和详尽的文档，使用户能够迅速理解并应用Quartz的调度机制。简介中详细介绍了Quartz的关键组件：Job、Trigger、Scheduler、JobDetail、CalendarInt...
java Quartz
小十木的博客
08-06 294
Quartz 使用 在使用Quartz 前需要明白几个定义，第一就是，每个任务在都需要有调度器去调度该任务对应的触发器，然后才能按照时间表达式触发 ，执行业务代码； 一：jobDetail:具体的业务实现 二：触发器：触发业务的时间逻辑 三：调度器：负责调度触发器执行 ~~~代码示例 public class QuartzTest { public static void main(Str...
Java Quartz框架
sanmansan的博客
06-14 507
Java Quartz框架
java学习-quartz
cyy9487的博客
05-06 380
文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import.
quartz入门共3页.pdf.zip
10-30
通过阅读 "quartz入门共3页.pdf"，你将能够快速了解 Quartz 的基本概念和用法，为实际项目开发打下基础。文件可能涵盖了 Quartz 的安装、基本示例、API 使用方法等内容，帮助你快速上手并掌握这个强大的任务调度库。
Java 定时任务调度工具 ~ Quartz。
lyfGeek的博客
06-01 411
Java 定时任务调度工具 ~ Quartz。
java quartz 教程_Quartz 教程
weixin_35207054的博客
03-04 7847
一、关于 QuartzQuartz logoQuartz 是一个完全由 Java 编写的开源作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。Quartz 可以与 J2EE 与 J2SE 应用程序相结合也可以单独使用。Quartz 允许程序开发人员根据时间的间隔来调度作业。Quartz 实现了作业和触发器的多对多的关系，还能把多个作业与不同的触发器关联。二、Quartz ...
java 定时器 quartz_Java定时器和Quartz使用
weixin_35900668的博客
02-15 370
一、Java普通自定义定时器1 /**2 * 自定义一个定时器3 *@authorlw4 */5 public class MyTimer extendsThread{67 privateLong time ;89 publicMyTimer(Long time) {10 this.time =time;11 }1213 @Override14 publ...
Quartz:Quartz是一种可以集成在从小型的独立运行的应用程序到大型的商务系统的几乎所有的java应用程序的石英可以为执行十个，百个，甚至是成千上外的作业创建简单或复杂的调度。它们的任务是定义为一个标准的java组件，可以执行几乎任何你可以计划去做的工作
03-24
石英企业作业队调度框架 ###根据官方主要文档翻译而来，主要版本为2.2.x，查看###什么是Quartz企业作业团队调度框架？Quartz是一种可以集成在从小型的独立运行的应用程序到大型的商务系统的几乎所有的java应用程序的一种功能丰富，开放源代码的作业调度类库。Quartz可以为执行十个，百个，甚至是成千上外的作业创建简单或复杂的调度。他们的任务是定义为一个标准的java组件，可以执行几乎任何你可以计划去做的工作。Quartz调度包括很多企业级功能，如JTA事务支持和聚类。 Quartz是可以自由使用的，许可在Apache 2许可证。 如果你的应用程序需要在给定的连续执行某些任务，或者你的系统经常性的需要维护工作，那么Quartz可能是你的理想决解方案。 使用Quartz作业调度样例 驱动流程：在最初的位置调度一个在纠正的2小时后执行的作业作为一个新的订单，检查此订单的状态，如果
JAVA实例quartz
08-29
quartz的JAVA例子。这个是一个简单例子。刚接触的时候都是用这个例子来实现然后学习的
Java Quartz开发
10-29
Java Quartz开发的特性，及Java Quartz开发实例。
quartz有状态Job和无状态Job
11-16
有状态Job和无状态Job 描述>=20个字符,不支持HTML标签。 详细的资源描述有机会获得我们的推荐，更有利于他人下载，赚取更多积分。
Java的Quartz实现
cuma2369的博客
07-28 601
In this post, java development India based experts will explain the concept of Quartz. You will also learn the method of setting up the Quartz in this article. You can ask experts if anything bothers ...
Java调度框架Quartz 2.2.1
chszs的专栏
01-26 9235
Java调度框架Quartz 2.2.1Java调度框架Quartz 2.2.1版在前不久发布了，Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的日程序表。Jobs可以做成标准的Java组件或 EJBs。我根据官方的JavaDoc，制作了一份API文档，CHM格式，供大家参阅。下载地址见：http://download.csdn.net/detail/chszs/6
Java定时任务调度工具Quartz（一）——简单介绍
朝夕
03-02 352
引言 最近因为疫情闹得严重，业务部门需求少了很多，我这边相对比以前轻松一丢丢，终于可以把许多年前心头大患梳理一下搞一搞了。 我的心头大患是什么呢？就是这个系统的26个跑批，完全依赖JAR包，没有可视化操作页面，没有系统监控调度工具。就那么跑，裸跑。跑错了手工定位问题，手工协调数据，手工处理跑批。SHIT~ 什么是Quartz Quartz 是一个开源的作业调度框架，它完全由 Java 写成，并设计...
java 中的 quartz使用
口袋里的小龙的专栏
03-27 653
java 中的 quartz使用
Quartz入门教程：学习调度框架的关键步骤
资源摘要信息:"《Quartz入门》是一份专注于介绍Quartz调度器基本使用和概念的入门级文档。Quartz是一个功能强大的开源作业调度系统，它可以整合到几乎任何Java应用程序中，用于创建简单或复杂的定时任务。文档共分为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值