Quartz任务调度说明 CronTrigger + Spring

合集下载

quartz任务调度原理

quartz任务调度原理

Quartz任务调度原理解析1. 什么是Quartz任务调度Quartz是一个开源的、功能强大的作业调度库,可以用于创建基于时间表的作业调度。

它允许开发人员能够编写灵活和可靠的作业,并将其安排在特定的时间或间隔内执行。

Quartz提供了丰富的API和灵活的配置选项,使得任务调度变得简单易用。

2. Quartz任务调度原理Quartz任务调度的基本原理可以分为以下几个方面:2.1 Job和Trigger在Quartz中,Job代表一个要执行的具体任务,而Trigger则定义了这个任务何时被执行。

Trigger可以基于时间表达式(cron表达式)来定义执行时间,也可以根据一些特定的规则来触发执行。

2.2 调度器(Scheduler)Scheduler是Quartz任务调度器的核心组件,负责管理所有Job和Trigger,并根据配置进行作业调度。

Scheduler可以创建、暂停、恢复和删除Job以及相关联的Trigger。

它还负责记录所有Job的状态信息,并在需要时触发相关事件。

2.3 JobDetailJobDetail是定义一个特定Job实例的详细信息,包括Job类名、Job名称、所属组等属性。

每个JobDetail都关联一个唯一标识符(JobKey),用于在Scheduler中唯一标识该Job。

2.4 TriggerTrigger是定义一个作业何时执行的组件。

它可以基于时间表达式来定义执行时间,也可以根据一些特定的规则来触发执行。

每个Trigger都关联一个唯一标识符(TriggerKey),用于在Scheduler中唯一标识该Trigger。

2.5 JobExecutionContextJobExecutionContext是Job在执行时的上下文信息,包括当前执行时间、上次执行时间、下次执行时间等。

Job可以通过获取JobExecutionContext中的信息来进行任务处理。

2.6 JobFactoryJobFactory负责创建Job实例,当Scheduler需要调度一个Job时,会通过JobFactory创建一个新的实例,并将其交给Scheduler管理。

quartz的cron表达式

quartz的cron表达式

quartz的cron表达式Quartz的Cron表达式简介1. 什么是Cron表达式Cron表达式是一种用于定时任务调度的标准格式。

在Quartz框架中,Cron表达式被广泛使用,用于设置任务的执行时间。

2. Cron表达式的语法Cron表达式由6个或7个字段组成,每个字段代表时间的一个维度。

这6个或7个字段分别是:•秒(0~59)•分钟(0~59)•小时(0~23)•日(1~31)•月(1~12)•周几(0~7,0和7都代表周日)可以使用通配符或范围来表示时间的不确定性。

例如,“*“代表所有可能的值,”?“在日和周几字段中代表不指定值,”-“用来表示范围,” / “用来表示递增间隔。

例如,要设置每天早上9点执行任务,Cron表达式可以是0 0 9 ? * *。

3. 常用的Cron表达式示例以下是一些常见的Cron表达式示例:•0 0/5 * * * ?表示每隔5分钟执行一次任务。

•0 0 12 * * ?表示每天中午12点执行任务。

•0 0 8 ? * MON-FRI表示周一到周五每天早上8点执行任务。

•0 0 8 ? * 6L表示每个月的最后一个周五早上8点执行任务。

4. Cron表达式的高级用法Cron表达式还支持一些高级功能,例如使用”#“指定月份中的第几个周几,使用”L”指定月份中的最后一天,使用”W”指定平日最近的工作日等等。

以下是一些高级用法的示例:•0 0 12 ? JAN,FEB,DEC *表示一月、二月和十二月每天中午12点执行任务。

•0 0/30 9-17 * * MON-FRI#2表示周一到周五上午9点到下午5点之间,每隔30分钟执行一次任务,并且每个月的第二个周一符合条件。

5. 总结Cron表达式是Quartz框架中用于指定任务执行时间的标准格式。

它非常灵活,并且支持多种时间维度的设置。

掌握Cron表达式的语法和常用示例,可以帮助我们轻松实现定时任务的调度。

6. Cron表达式的注意事项在使用Cron表达式时,需要注意以下几点:•时间表达式字段之间使用空格分隔。

调度Quartz时间格式配置

调度Quartz时间格式配置

调度Quartz时间格式配置1、 CronTrigger时间格式配置说明CronTrigger配置格式:格式: [秒] [分] [⼩时] [⽇] [⽉] [周] [年]通配符说明:* :表⽰所有值. 例如:在分的字段上设置 "*",表⽰每⼀分钟都会触发。

:表⽰不指定值。

使⽤的场景为不需要关⼼当前设置这个字段的值。

例如:要在每⽉的10号触发⼀个操作,但不关⼼是周⼏,所以需要周位置的那个字段设置为"?" 具体设置为 0 0 0 10 * ?- :表⽰区间。

例如在⼩时上设置 "10-12",表⽰ 10,11,12点都会触发。

, :表⽰指定多个值,例如在周字段上设置 "MON,WED,FRI" 表⽰周⼀,周三和周五触发/ :⽤于递增触发。

如在秒上⾯设置"5/15" 表⽰从5秒开始,每增15秒触发(5,20,35,50)。

在⽉字段上设置'1/3'所⽰每⽉1号开始,每隔三天触发⼀次。

L :表⽰最后的意思。

在⽇字段设置上,表⽰当⽉的最后⼀天(依据当前⽉份,如果是⼆⽉还会依据是否是润年[leap]), 在周字段上表⽰星期六,相当于"7"或"SAT"。

如果在"L"前加上数字,则表⽰该数据的最后⼀个。

例如在周字段上设置"6L"这样的格式,则表⽰“本⽉最后⼀个星期五"W :表⽰离指定⽇期的最近那个⼯作⽇(周⼀⾄周五). 例如在⽇字段上设置"15W",表⽰离每⽉15号最近的那个⼯作⽇触发。

如果15号正好是周六,则找最近的周五(14号)触发, 如果15号是周未,则找最近的下周⼀(16号)触发.如果15号正好在⼯作⽇(周⼀⾄周五),则就在该天触发。

如果指定格式为 "1W",它则表⽰每⽉1号往后最近的⼯作⽇触发。

Quartz——CronTrigger触发器

Quartz——CronTrigger触发器

转载请出自出处:一.概述CronTrigger 能够提供比 SimpleTrigger 更有具体实际意义的调度方案,调度规则基于 Cron 表达式,CronTrigger 支持日历相关的重复时间间隔(比如每月第一个周一执行),而不是简单的周期时间间隔。

二.Cron表达式介绍1)Cron表达式规则表Quartz使用类似于Linux下的Cron表达式定义时间规则,Cron表达式由6或7个由空格分隔的时间字段组成,各个字段的含义如下表所示:字段位置位置含义允许值允许的特殊字符1 秒0-59 , - * /2 分钟0-59 , - * /3 小时0-23 , - * /4 日期1-31 , - * ? / L W C5 月份1-12 , - * /6 星期1-7 , - * ? / L C #7 年(可选) 空值;1970-2099 , - * /2)Cron表达式中的特殊字符Cron表达式的各个字段除允许设置数值外,还可使用一些特殊的字符,提供列表、范围、通配符等功能,具体规则如下所示:星号(*):可用在所有字段中,表示对应时间域的每一个时刻,例如,*在分钟字段时,表示“每分钟”;问号(?):该字符只在日期和星期字段中使用,它通常指定为“无意义的值”,相当于点位符;减号(-):表达一个范围,如在小时字段中使用“10-12”,则表示从10到12点,即10,11,12;逗号(,):表达一个列表值,如在星期字段中使用“MON,WED,FRI”,则表示星期一,星期三和星期五;斜杠(/):x/y表达一个等步长序列,x为起始值,y为增量步长值。

如在分钟字段中使用0/15,则表示为0,15,30和45秒,而5/15在分钟字段中表示5,20,35,50,你也可以使用*/y,它等同于0/y;L:该字符只在日期和星期字段中使用,代表“Last”的意思,但它在两个字段中意思不同。

L在日期字段中,表示这个月份的最后一天,如一月的31号,非闰年二月的28号;如果L用在星期中,则表示星期六,等同于7。

quartz用法

quartz用法

Quartz用法一、什么是Quartz?Quartz是一个功能强大且广泛应用于Java中的开源任务调度框架。

它允许开发人员通过简单而灵活的方式在应用程序中调度和执行任务。

无论是简单的定时任务还是复杂的作业调度,Quartz都可以满足需求。

二、Quartz的基本概念在深入探讨Quartz的用法之前,我们首先需要了解一些基本概念。

1. 作业(Job)作业是Quartz中最基本的调度单元。

它表示一项任务或一个操作,可以被Quartz 调度和执行。

2. 触发器(Trigger)触发器是Quartz中用于指定作业何时执行的组件。

可以根据时间表达式(如每小时、每天等)来触发作业的执行,也可以根据特定的日期和时间来触发。

3. 调度器(Scheduler)调度器是Quartz的核心组件,它负责在指定的时间触发作业的执行。

调度器可以同时管理多个作业和触发器,并根据设定的调度策略来决定执行顺序。

三、Quartz的用法接下来,我们将深入探讨Quartz的用法,包括作业和触发器的创建、调度器的配置和管理。

1. 创建作业要创建一个作业,我们需要定义一个类,实现Quartz的Job接口,并重写其中的execute()方法。

在execute()方法中,我们可以编写具体的任务逻辑。

例如:public class MyJob implements Job {public void execute(JobExecutionContext context) throws JobExecutionExcept ion {// 编写具体的任务逻辑}}2. 创建触发器Quartz提供了多种触发器类型,可以根据需求灵活选择。

其中最常用的是SimpleTrigger和CronTrigger。

•SimpleTrigger:简单触发器会在指定的时间间隔内循环执行作业。

可以设置作业的开始时间、结束时间和重复次数。

•CronTrigger:基于Cron表达式触发器允许我们非常灵活地指定作业的执行时间。

Spring集成Quartz定时任务框架介绍和Cron表达式详解

Spring集成Quartz定时任务框架介绍和Cron表达式详解

在JavaEE系统中,我们会经常用到定时任务,比如每天凌晨生成前天报表,每一小时生成汇总数据等等。

我们可以使用java.util.Timer结合java.util.TimerTask来完成这项工作,但时调度控制非常不方便,并且我们需要大量的代码。

使用Quartz框架无疑是非常好的选择,并且与Spring可以非常方便的集成,下面介绍它们集成方法和Cron表达式的详细介绍。

一、增加所依赖的JAR包1、增加Spring的Maven依赖<dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>3.0.5.RELEASE</version></dependency>2、增加Quartz的Maven依赖<dependency><groupId>org.quartz-scheduler</groupId><artifactId>quartz</artifactId><version>1.8.4</version></dependency>二、增加定时业务逻辑类publicclass ExpireJobTask {/** Logger */privatestaticfinal Logger logger =LoggerFactory.getLogger(ExpireJobTask.class);/*** 业务逻辑处理*/publicvoid doBiz() {// 执行业务逻辑// ........}}ExpireJobTask业务逻辑类与一般普通的类没有任务区别,它定义的doBiz方法即为调度业务方法。

Quartz(计划任务)2.x 使用简介

Quartz(计划任务)2.x 使用简介

Quartz 计划任务使用简介Quartz是个开源项目,可以用于JAVAEE,SE项目中,提供强大的计划任务机制。

版本历史:1.0至1.5,Quartz属于OpenSymphony开源组织。

1.7至目前版本2.x 更换组织名为,其官方网站是: 本文以2.2.1版本为例,演示基本使用方法。

方式一:在Java项目中单独使用(main方法调用).方式二:在Java web + spring环境整合使用.开发环境:JDK1.6, maven3.x, spring3.2.2, quartz2.2.1对于初学者,需要先明白quartz项目的概念。

为了将计划任务高度抽象,quartz将所有计划任务都提取出2个部分:作业(即定义需要程序做什么),触发器(即定义什么时候做)。

将这两部分解耦和之后,可以提高两部分的复用性。

比如:一个作业,可以在多个触发器下运作;同时,一个触发器,也可以用于多个作业。

准备工作步骤如下:1.从下载Quartz zip文件。

2.解压缩并把quartz-x.x.x.jar 放在项目文件夹内,或者把文件放在项目的类路径中。

3.把core 和/或optional 文件夹中的jar 文件放在项目的文件夹或项目的类路径中。

代码演示:方式一:在Java项目中单独使用(main方法调用).步骤1:先建立一个作业(Job)自己写一个类,实现org.quartz.Job接口,并实现execute()方法,使得当前类可被执行。

代码截图:步骤2:写一个单元测试类,代码如下:以上代码演示了:作业+调度器=计划任务其中调度器部分,使用了quartz实现的Cron调度器,关于Cron表达式的使用,请参考wiki:/wiki/Cron本文演示的cron表达式效果是:每隔3秒钟运行一次。

方式二:在Java web + spring环境整合使用.Spring框架同样提供了对Quartz整合的支持,需要将文件添加到项目构建路径。

C#调用Quartz定时任务。使用Cron表达式的方法

C#调用Quartz定时任务。使用Cron表达式的方法

C#调⽤Quartz定时任务。

使⽤Cron表达式的⽅法最近在做⼀个定时任务,要求是每⼀分钟触发⼀次。

由于之前是采⽤的FluentScheduler写的,现在改成了Cron表达式。

中间出现了⼀些问题,所以现在写下来,和⼤家分享⼀下。

先说⼀下准备⼯作,你需要这么三个dll:将他们添加到指定的位置就可以了。

定时任务,我们要做的就是在⼀开始运⾏项⽬的时候让他启动,所以在Global.asax⾥⾯的这个⽅法⾥⾯增加圈出的这个⽅法,指向你另⼀个类中的⽅法。

我是指向了这么⼀个类PlanRegistry,这⾥⾯的这个Start⽅法:public static void Start(){string QuestionCron = ConfigurationManager.AppSettings["quarterCon"] == null ? "0 0/1 * * * ? *" : ConfigurationManager.AppSettings["quarterCon"];////新建⼀个调度器⼯⼯⼚ISchedulerFactory factory = new StdSchedulerFactory();////使⽤⼯⼚⽣成⼀个调度器IScheduler scheduler = factory.GetScheduler();//启动调度器scheduler.Start();IJobDetail job = JobBuilder.Create<CreateCheckTaskJob>().Build();// 新建⼀个触发器ITrigger trigger = TriggerBuilder.Create().StartNow().WithCronSchedule(QuestionCron).Build();//将任务与触发器关联起来放到调度器中scheduler.ScheduleJob(job, trigger);}这个地⽅有⼀个点需要注意,那就是这个quarterCon,我们需要从我们的Web.Config配置⽂件中读取。

java中spring与Quartz 整合定时任务

java中spring与Quartz 整合定时任务

现在想要获得在特定时间或者指定时间执行相应功能有两种做法在applicationContext.xml中写入如下Bean<bean id="repeatingTrigger"class="org.springframework.scheduling.timer.ScheduledTimerTask"> <!--启动一秒后执行 --><property name="delay"><value>1000</value></property><!--每隔一小时执行一次 --><property name="period"><value>3600000</value></property><!--注入要监控的javaBean --><property name="timerTask"><ref bean="task" /></property><!--类型是否为fixedRate型,默认为fixedDelay--><property name="fixedRate"><value>true</value></property></bean><bean id="scheduler"class="org.springframework.scheduling.timer.TimerFactoryBean"> <property name="scheduledTimerTasks"><list><ref bean="repeatingTrigger" /></list></property></bean><bean id="task" class="com.css.wam.portlet.SampleTask"><property name="workService"><ref bean="workService" /></property><property name="work"><ref bean="work" /></property></bean>然后写SampleTask类,如下:package com.css.wam.portlet;import java.util.ArrayList;import java.util.Calendar;import java.util.Iterator;import java.util.List;import java.util.TimerTask;import javax.servlet.ServletContext; 字串2import org.apache.jetspeed.security.SecurityException; 字串9 import com.css.wam.service.WorkService; 字串1@SuppressWarnings("unused")class SampleTask extends TimerTask{ 字串2private static final int C_SCHEDULE_HOUR = 23;//设置指定时间private WorkService workService;private List users;private List teams;private WorkPortlet work;public void setWorkService(WorkService workService) {this.workService = workService;} 字串7public void setWork(WorkPortlet work) {this.work = work;} 字串4public SampleTask(){}@SuppressWarnings("unchecked")public void run() {Calendar cal = Calendar.getInstance();try {users = work.getUsers();teams = new ArrayList();for(Iterator it = users.iterator(); it.hasNext();){String teamname = work.getGroupsByUser((String)it.next()); teams.add(teamname);}//查看当前时间与指定是否一致,一致则执行任务if (C_SCHEDULE_HOUR == cal.get(Calendar.HOUR_OF_DAY) ) 字串6workService.autoWorkOff(users, teams); 字串8} catch (SecurityException e) {e.printStackTrace();}}}使用Quartz定时<bean id="methodInvokingJobDetail"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"><property name="targetObject"><ref bean="changeService"/></property><property name="targetMethod"><value>changeAll</value></property></bean><bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail"><ref bean="methodInvokingJobDetail"/></property><property name="cronExpression"><!--<value>0 0 6,12,20 * * ?</value>--><value>0 0 23 * * ?</value></property></bean><bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"><property name="triggers"><list><ref local="cronTrigger"/></list></property></bean>简单定时<bean id="methodInvokingJobDetail"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"><property name="targetObject"><ref bean="sgService"/></property><property name="targetMethod"><value>updateNowSgList</value></property></bean><bean id="simpleTrigger"class="org.springframework.scheduling.quartz.SimpleTriggerBean"><property name="jobDetail"><ref bean="methodInvokingJobDetail"/></property><property name="startDelay"><value>10000</value> <!-- 10 s--></property><property name="repeatInterval"><value>1296000000</value> <!-- 1296000000 6 hours--></property></bean><bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"><property name="triggers"><list><ref local="simpleTrigger"/></list></property></bean>一个cron表达式有至少6个(也可能7个)有空格分隔的时间元素。

quartz qrtz_triggers字段详解

quartz qrtz_triggers字段详解

Quartz 是一个开源的作业调度框架,广泛应用于各种 Java 应用程序中。

在 Quartz 中,触发器(triggers)是一项关键的功能,用于定义作业(job)的执行时间和频率。

在使用 Quartz 进行作业调度时,掌握 triggers 的相关字段是非常重要的。

本文将对 Quartz 中 triggers 的字段进行详细解析,帮助读者更好地理解和使用 Quartz 框架。

一、触发器类型Quartz 中有多种类型的触发器,常用的包括 SimpleTrigger、CronTrigger 和 CalendarIntervalTrigger。

不同类型的触发器在定义作业的执行时间和频率时具有不同的灵活性和精度。

在使用 triggers字段时,需要根据具体的需求选择适合的触发器类型。

二、字段解析1. triggerName 和 triggerGroup在 Quartz 中,每个触发器都有一个名称和所属的组。

triggerName和 triggerGroup 两个字段用于唯一标识一个触发器。

在定义触发器时,需要确保 triggerName 和 triggerGroup 的组合是唯一的,以便能准确地找到和管理触发器。

2. jobName 和 jobGroup触发器与作业是相互关联的,jobName 和 jobGroup 两个字段用于指定触发器关联的作业。

当触发器被触发时,对应的作业将被执行。

同样地,jobName 和 jobGroup 的组合也需要是唯一的。

3. startTime 和 endTimestartTime 字段指定触发器的开始时间,endTime 字段指定触发器的结束时间。

在 startTime 之前,触发器不会被触发;在 endTime 之后,触发器将不再被触发。

通过配置 startTime 和 endTime,可以灵活地控制触发器的生效时间。

4. prioritypriority 字段用于指定触发器的优先级。

quartz调度触发器类型_概述说明以及概述

quartz调度触发器类型_概述说明以及概述

quartz调度触发器类型概述说明以及概述1. 引言1.1 概述在软件开发过程中,定时任务的调度和执行是一项非常重要的功能。

在Java语言中,Quartz调度框架是一个强大而灵活的工具,被广泛应用于各种复杂的任务调度场景。

本文将详细介绍Quartz调度框架的触发器类型。

触发器是Quartz调度框架中用于定义任务触发规则和频率的组件。

不同类型的触发器具有不同的特点和功能,并且适用于不同的业务场景。

1.2 文章结构本文主要分为以下几个部分来讨论Quartz调度触发器类型:- 引言:对本文内容进行概述说明。

- Quartz调度触发器类型概述说明:介绍Quartz调度框架及其触发器的作用和重要性。

- Quartz的简单触发器(SimpleTrigger):详细介绍SimpleTrigger触发器的特点、功能、使用场景以及注意事项。

- Quartz的Cron触发器(CronTrigger):深入探讨CronTrigger触发器,包括其特点、功能、Cron表达式解析与使用技巧以及应用案例和实践经验总结。

- Quartz的日历触发器(CalendarTrigger):分析日历触发器的日历规则和配置方式,以及与业务场景的关系分析、最佳实践和注意事项。

1.3 目的本文的目的是帮助读者全面了解Quartz调度框架中不同类型触发器的特点和功能,并且指导读者在实际项目中选择合适的触发器应用于任务调度场景。

通过深入理解每种触发器类型的使用方法和注意事项,读者将能够更好地设计和开发可靠、高效的定时任务系统。

2. Quartz调度触发器类型概述说明2.1 简介Quartz是一个功能强大的开源定时任务调度框架,其中最重要的概念之一就是触发器(Trigger)。

触发器用于定义任务何时被执行,以及如何被执行。

Quartz 提供了多种类型的触发器,包括简单触发器(SimpleTrigger)、Cron触发器(CronTrigger)和日历触发器(CalendarTrigger),每种触发器都具有不同的特点和应用场景。

crontrigger 触发器工作原理

crontrigger 触发器工作原理

crontrigger 触发器工作原理
CronTrigger 是 Quartz 调度器中的一种触发器,它的工作原理
如下:
1. 首先,需要通过 Cron 表达式来配置 CronTrigger 的触发规则。

Cron 表达式是一种时间表达式,可以指定触发时间的细节,
例如:秒、分钟、小时、日期等。

2. Quartz 调度器会根据Cron 表达式计算出下一次触发的时间,并将其存储在内存中。

3. 当调度器启动后,它会根据内存中存储的下一次触发时间,等待到达触发时间时,就会执行与该触发器关联的任务。

4. 执行完任务后,Quartz 调度器会再次根据 Cron 表达式计算
出下一次触发的时间,并更新内存中的触发时间。

5. 调度器会持续重复以上过程,周期性地触发任务。

每次触发任务时,都会重新计算下一次触发的时间,保证任务能够按照预定的时间间隔被触发。

总结起来,CronTrigger 的工作原理是通过 Cron 表达式计算下
一次触发时间,并周期性地触发与该触发器关联的任务。

quartz批处理调度逻辑

quartz批处理调度逻辑

Quartz 是一款强大的开源作业调度框架,可以用于执行周期性的任务,支持多种调度策略。

以下是Quartz 批处理调度逻辑的概述:1. 任务定义:首先,需要定义要执行的任务。

这可以通过实现`org.quartz.Job`接口或使用Quartz 提供的示例类来实现。

任务执行的代码被封装在一个类中,该类实现`execute`方法。

2. 任务触发:Quartz 支持多种触发方式,包括基于时间、基于表达式、基于其他任务等。

触发器(Trigger)定义了任务何时执行,可以设置任务的执行频率、执行间隔、执行时间等。

3. 任务调度器:任务调度器(Scheduler)负责安排和执行任务。

它根据触发器设置的规则,在指定时间执行任务。

Quartz 提供了多种调度器实现,如`StdScheduler`、`ThreadPoolScheduler`等。

4. 任务存储:任务存储(JobStore)用于存储任务信息和调度状态。

默认情况下,Quartz 使用`RAMJobStore`,将任务信息存储在内存中。

此外,Quartz 还支持将任务信息存储在数据库或其他持久化存储中。

5. 任务监听器:任务监听器(JobListener)可以在任务执行前后接收通知。

通过实现`org.quartz.Listener`接口或使用Quartz 提供的示例类,可以自定义任务监听器。

6. 配置和启动:在完成任务定义、触发器设置、调度器创建等操作后,需要对Quartz 进行配置并启动。

Quartz 的配置文件(如`quartz.properties`)中包含了各种参数,如数据源、作业存储位置等。

启动Quartz 时,可以通过命令行、Java 代码或Web 控制台等方式进行。

7. 监控和维护:Quartz 提供了监控和维护功能,可以实时查看任务的执行状态、调度器的状态等信息。

此外,Quartz 还支持动态修改任务和触发器的配置,方便根据实际需求进行调整。

Quartz调度框架详解、运用场景、与集群部署实践

Quartz调度框架详解、运用场景、与集群部署实践

Quartz调度框架详解、运⽤场景、与集群部署实践以下将分别从Quartz架构简介、集群部署实践、Quartz监控、集群原理分析详解Quartz任务调度框架。

QuartzQuartz是Java领域最著名的开源任务调度⼯具,是⼀个任务调度框架,通过触发器设置作业的定时运⾏规则,来执⾏定时任务。

其中quartz集群通过故障切换和负载平衡的功能,能给调度器带来⾼可⽤性和伸缩性。

Quartz提供了极为⼴泛的特性如持久化任务,集群和分布式任务等。

其特点如下:完全由Java写成,⽅便集成(Spring)伸缩性负载均衡⾼可⽤性典型的使⽤场景,主要⽤来执⾏定时任务,例如:定时发送信息定时⽣成报表⾃动更新静态数据⾃动结账等等QuartzQuartz框架主要核⼼组件包括:1.Scheduler任务调度是最核⼼的概念,需要把JobDetail和Trigger注册到scheduler中,才可以执⾏。

⼯⼚模式,组装各个组件<JOB,Trigger> sched.scheduleJob(job, trigger);2.Job任务其实Job是接⼝,其中只有⼀个execute⽅法,我们只需要 implements 此接⼝,重写 execute(*) ⽅法。

3.Trigger触发器执⾏任务的规则;⽐如每天,每⼩时等。

⼀般情况使⽤SimpleTrigger,和CronTrigger,这些触发器实现了Trigger接⼝。

或者 ScheduleBuilder ⼦类 SimpleScheduleBuilder和CronScheduleBuilder。

对于简单的时间来说,⽐如每天执⾏⼏次,使⽤SimpleTrigger。

对于复杂的时间表达式来说,⽐如每个⽉15⽇上午⼏点⼏分,使⽤CronTrigger以及CromExpression 类。

4.JobDetail任务细节任务细节,Quartz执⾏Job时,需要新建个Job实例,但是不能直接操作Job类,所以通过JobDetail来获取Job的名称、描述信息。

Spring4定时器cronTrigger和simpleTrigger实现方法

Spring4定时器cronTrigger和simpleTrigger实现方法

Spring4定时器cronTrigger和simpleTrigger实现⽅法spring4定时器 cronTrigger和simpleTrigger实现⽅法Quartz 是个开源的作业调度框架,为在应⽤程序中进⾏作业调度提供了简单却强⼤的机制。

Quartz 允许开发⼈员根据时间间隔(或天)来调度作业。

它实现了作业和触发器的多对多关系,还能把多个作业与不同的触发器关联。

整合了 Quartz 的应⽤程序可以重⽤来⾃不同事件的作业,还可以为⼀个事件组合多个作业。

SimpleTrigger 当需要在规定的时间执⾏⼀次或在规定的时间段以⼀定的时间间隔重复触发执⾏Job时,SimpleTrigger就可以满⾜要求;SimpleTrigger的属性有:开始时间、结束时间、重复次数和重复的时间间隔,重复次数属性的值可以为0、正整数、或常量 SimpleTrigger.REPEAT_INDEFINITELY,重复的时间间隔属性值必须为0或长整型的正整数,以毫秒作为时间单位,当重复的时间间隔为0时,意味着与Trigger同时触发执⾏(或⼏乎与Scheduler开始时同时触发执⾏)。

如果有指定结束时间属性值,则结束时间属性优先于重复次数属性,这样的好处在于:当我们需要创建⼀个每间隔10秒钟触发⼀次直到指定的结束时间的 Trigger,⽽⽆需去计算从开始到结束的所重复的次数,我们只需简单的指定结束时间和使⽤REPEAT_INDEFINITELY作为重复次数的属性值即可(我们也可以指定⼀个⽐在指定结束时间到达时实际执⾏次数⼤的重复次数)。

CronTrigger ⽀持⽐ SimpleTrigger 更具体的调度,⽽且也不是很复杂。

基于 cron 表达式,CronTrigger ⽀持类似⽇历的重复间隔,⽽不是单⼀的时间间隔。

Cron 表达式包括以下 7 个字段:格式: [秒] [分] [⼩时] [⽇] [⽉] [周] [年]序号说明是否必填允许填写的值允许的通配符1 秒是 0-59 , - * /2 分是 0-59 , - * /3 ⼩时是 0-23 , - * /4 ⽇是 1-31 , - * ? / L W5 ⽉是 1-12 or JAN-DEC , - * /6 周是 1-7 or SUN-SAT , - * ? / L #7 年否 empty 或 1970-2099 , - * /Quartz官⽅⽹站对SimpleTrigger和CronTrigger的简单对⽐:SimpleTrigger is handy if you need 'one-shot' execution (just single execution of a job at a given moment in time), or if you need to fire a job at a given time, and have it repeat N times, with a delay of T between executions.当你需要的是⼀次性的调度(仅是安排单独的任务在指定的时间及时执⾏),或者你需要在指定的时间激活某个任务并执⾏N次,设置每次任务执⾏的间隔时间T。

一文揭秘定时任务调度框架quartz

一文揭秘定时任务调度框架quartz

⼀⽂揭秘定时任务调度框架quartz之前写过quartz或者引⽤过quartz的⼀些⽂章,有很多⼈给我发消息问quartz的相关问题,趁着年底⽐较清闲,把quartz的问题整理了⼀下,顺带翻了翻源码,做了⼀些总结,希望能帮助到⼀些⼈或者减少⼈们探索的时间。

注意,使⽤版本为quartz2.2.3 spring boot2.1.31.quartz的核⼼组件1.1 Job组件1.1.1JobJob负责任务执⾏的逻辑,所有逻辑在execute()⽅法中,执⾏所需要的数据存放在JobExecutionContext 中Job实例:@PersistJobDataAfterExecution@DisallowConcurrentExecutionpublic class ColorJob implements Job {private static Logger _log = LoggerFactory.getLogger(ColorJob.class);// parameter names specific to this jobpublic static final String FAVORITE_COLOR = "favorite color";public static final String EXECUTION_COUNT = "count";// Since Quartz will re-instantiate a class every time it// gets executed, members non-static member variables can// not be used to maintain state!private int _counter = 1;/*** <p>* Empty constructor for job initialization* </p>* <p>* Quartz requires a public empty constructor so that the* scheduler can instantiate the class whenever it needs.* </p>*/public ColorJob() {}/*** <p>* Called by the <code>{@link org.quartz.Scheduler}</code> when a* <code>{@link org.quartz.Trigger}</code> fires that is associated with* the <code>Job</code>.* </p>** @throws JobExecutionException* if there is an exception while executing the job.*/public void execute(JobExecutionContext context)throws JobExecutionException {// This job simply prints out its job name and the// date and time that it is runningJobKey jobKey = context.getJobDetail().getKey();// Grab and print passed parametersJobDataMap data = context.getJobDetail().getJobDataMap();String favoriteColor = data.getString(FAVORITE_COLOR);int count = data.getInt(EXECUTION_COUNT);_("ColorJob: " + jobKey + " executing at " + new Date() + "\n" +" favorite color is " + favoriteColor + "\n" +" execution count (from job map) is " + count + "\n" +" execution count (from job member variable) is " + _counter);// increment the count and store it back into the// job map so that job state can be properly maintainedcount++;data.put(EXECUTION_COUNT, count);// Increment the local member variable// This serves no real purpose since job state can not// be maintained via member variables!_counter++;}}1.1.2 JobDetail存储Job的信息主要负责1.指定执⾏的Job类,唯⼀标识(job名称和组别名称)2.存储JobDataMap信息// job1 will only run 5 times (at start time, plus 4 repeats), every 10 secondsJobDetail job1 = newJob(ColorJob.class).withIdentity("job1", "group1").build();// pass initialization parameters into the jobjob1.getJobDataMap().put(ColorJob.FAVORITE_COLOR, "Green");job1.getJobDataMap().put(ColorJob.EXECUTION_COUNT, 1);数据库存储如下:1.1.3 Quartz JobBuilder提供了⼀个链式api创建JobDetail@Beanpublic JobDetail jobDetail() {return JobBuilder.newJob().ofType(SampleJob.class).storeDurably().withIdentity("Qrtz_Job_Detail").withDescription("Invoke Sample Job service...").build();}1.1.4 Spring JobDetailFactoryBeanspring提供的⼀个创建JobDetail的⽅式⼯⼚bean@Beanpublic JobDetailFactoryBean jobDetail() {JobDetailFactoryBean jobDetailFactory = new JobDetailFactoryBean(); jobDetailFactory.setJobClass(SampleJob.class);jobDetailFactory.setDescription("Invoke Sample Job service...");jobDetailFactory.setDurability(true);return jobDetailFactory;}1.2 Trigger组件trigger的状态不同trigger的状态// STATESString STATE_WAITING = "WAITING";String STATE_ACQUIRED = "ACQUIRED";String STATE_EXECUTING = "EXECUTING";String STATE_COMPLETE = "COMPLETE";String STATE_BLOCKED = "BLOCKED";String STATE_ERROR = "ERROR";String STATE_PAUSED = "PAUSED";String STATE_PAUSED_BLOCKED = "PAUSED_BLOCKED";String STATE_DELETED = "DELETED";状态的表结构trigger的类型// TRIGGER TYPES/** Simple Trigger type. */String TTYPE_SIMPLE = "SIMPLE";/** Cron Trigger type. */String TTYPE_CRON = "CRON";/** Calendar Interval Trigger type. */String TTYPE_CAL_INT = "CAL_INT";/** Daily Time Interval Trigger type. */String TTYPE_DAILY_TIME_INT = "DAILY_I";/** A general blob Trigger type. */String TTYPE_BLOB = "BLOB";对应表结构SimpleTrigger trigger1 = newTrigger().withIdentity("trigger1", "group1").startAt(startTime).withSchedule(simpleSchedule().withIntervalInSeconds(10).withRepeatCount(4)).build();Trigger存储在mysql中1.2.2 Quartz TriggerBuilder提供了⼀个链式创建Trigger的api@Beanpublic Trigger trigger(JobDetail job) {return TriggerBuilder.newTrigger().forJob(job).withIdentity("Qrtz_Trigger").withDescription("Sample trigger").withSchedule(simpleSchedule().repeatForever().withIntervalInHours(1)).build();}1.2.3 Spring SimpleTriggerFactoryBeanspring提供的⼀个创建SimpleTrigger的⼯⼚类@Beanpublic SimpleTriggerFactoryBean trigger(JobDetail job) {SimpleTriggerFactoryBean trigger = new SimpleTriggerFactoryBean();trigger.setJobDetail(job);trigger.setRepeatInterval(3600000);trigger.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY);return trigger;}1.3 调度组件1.3.1 quartz提供的⼯⼚类@Beanpublic Scheduler scheduler(Trigger trigger, JobDetail job) {StdSchedulerFactory factory = new StdSchedulerFactory();factory.initialize(new ClassPathResource("quartz.properties").getInputStream());Scheduler scheduler = factory.getScheduler();scheduler.setJobFactory(springBeanJobFactory());scheduler.scheduleJob(job, trigger);scheduler.start();return scheduler;}1.3.2 spring提供的⼯⼚bean@Beanpublic SchedulerFactoryBean scheduler(Trigger trigger, JobDetail job) {SchedulerFactoryBean schedulerFactory = new SchedulerFactoryBean();schedulerFactory.setConfigLocation(new ClassPathResource("quartz.properties"));schedulerFactory.setJobFactory(springBeanJobFactory());schedulerFactory.setJobDetails(job);schedulerFactory.setTriggers(trigger);return schedulerFactory;}2.⼯作原理2.1 核⼼类QuartzSchedulerScheduler实现类StdScheduler封装了核⼼⼯作类QuartzScheduler/*** <p>* Construct a <code>StdScheduler</code> instance to proxy the given* <code>QuartzScheduler</code> instance, and with the given <code>SchedulingContext</code>.* </p>*/public StdScheduler(QuartzScheduler sched) {this.sched = sched;}2.2 JobDetail的存取public void addJob(JobDetail jobDetail, boolean replace, boolean storeNonDurableWhileAwaitingScheduling) throws SchedulerException { validateState();if (!storeNonDurableWhileAwaitingScheduling && !jobDetail.isDurable()) {throw new SchedulerException("Jobs added with no trigger must be durable.");}resources.getJobStore().storeJob(jobDetail, replace);notifySchedulerThread(0L);notifySchedulerListenersJobAdded(jobDetail);}2.2.1 存储JobDetail信息(以mysql Jdbc⽅式为例)/*** <p>* Insert or update a job.* </p>*/protected void storeJob(Connection conn,JobDetail newJob, boolean replaceExisting)throws JobPersistenceException {boolean existingJob = jobExists(conn, newJob.getKey());try {if (existingJob) {if (!replaceExisting) {throw new ObjectAlreadyExistsException(newJob);}getDelegate().updateJobDetail(conn, newJob);} else {getDelegate().insertJobDetail(conn, newJob);}} catch (IOException e) {throw new JobPersistenceException("Couldn't store job: "+ e.getMessage(), e);} catch (SQLException e) {throw new JobPersistenceException("Couldn't store job: "+ e.getMessage(), e);}}调⽤StdJDBCDelegate实现/*** <p>* Insert the job detail record.* </p>** @param conn* the DB Connection* @param job* the job to insert* @return number of rows inserted* @throws IOException* if there were problems serializing the JobDataMap*/public int insertJobDetail(Connection conn, JobDetail job)throws IOException, SQLException {ByteArrayOutputStream baos = serializeJobData(job.getJobDataMap());PreparedStatement ps = null;int insertResult = 0;try {ps = conn.prepareStatement(rtp(INSERT_JOB_DETAIL));ps.setString(1, job.getKey().getName());ps.setString(2, job.getKey().getGroup());ps.setString(3, job.getDescription());ps.setString(4, job.getJobClass().getName());setBoolean(ps, 5, job.isDurable());setBoolean(ps, 6, job.isConcurrentExectionDisallowed());setBoolean(ps, 7, job.isPersistJobDataAfterExecution());setBoolean(ps, 8, job.requestsRecovery());setBytes(ps, 9, baos);insertResult = ps.executeUpdate();} finally {closeStatement(ps);}return insertResult;}注意:JobDataMap序列化后以Blob形式存储到数据库中StdJDBCConstants中执⾏sql如下:String INSERT_JOB_DETAIL = "INSERT INTO "+ TABLE_PREFIX_SUBST + TABLE_JOB_DETAILS + " ("+ COL_SCHEDULER_NAME + ", " + COL_JOB_NAME+ ", " + COL_JOB_GROUP + ", " + COL_DESCRIPTION + ", "+ COL_JOB_CLASS + ", " + COL_IS_DURABLE + ", "+ COL_IS_NONCONCURRENT + ", " + COL_IS_UPDATE_DATA + ", "+ COL_REQUESTS_RECOVERY + ", "+ COL_JOB_DATAMAP + ") " + " VALUES(" + SCHED_NAME_SUBST + ", ?, ?, ?, ?, ?, ?, ?, ?, ?)";2.2.2 查询JobDetail强调⼀下,因JobDetail中的JobDataMap是以Blob形式存放到数据库中的(也可以通过useProperties属性修改成string存储,默认是false,Blob形式存储),所以查询时需要特殊处理:StdJDBCDelegate.java/*** <p>* Select the JobDetail object for a given job name / group name.* </p>** @param conn* the DB Connection* @return the populated JobDetail object* @throws ClassNotFoundException* if a class found during deserialization cannot be found or if* the job class could not be found* @throws IOException* if deserialization causes an error*/public JobDetail selectJobDetail(Connection conn, JobKey jobKey,ClassLoadHelper loadHelper)throws ClassNotFoundException, IOException, SQLException {PreparedStatement ps = null;ResultSet rs = null;try {ps = conn.prepareStatement(rtp(SELECT_JOB_DETAIL));ps.setString(1, jobKey.getName());ps.setString(2, jobKey.getGroup());rs = ps.executeQuery();JobDetailImpl job = null;if (rs.next()) {job = new JobDetailImpl();job.setName(rs.getString(COL_JOB_NAME));job.setGroup(rs.getString(COL_JOB_GROUP));job.setDescription(rs.getString(COL_DESCRIPTION));job.setJobClass( loadHelper.loadClass(rs.getString(COL_JOB_CLASS), Job.class));job.setDurability(getBoolean(rs, COL_IS_DURABLE));job.setRequestsRecovery(getBoolean(rs, COL_REQUESTS_RECOVERY));Map<?, ?> map = null;if (canUseProperties()) {map = (Map<?, ?>) getObjectFromBlob(rs, COL_JOB_DATAMAP);}if (null != map) {job.setJobDataMap(new JobDataMap(map));}}return job;} finally {closeResultSet(rs);closeStatement(ps);}}2.3 查询trigger/*** <p>* Retrieve the given <code>{@link org.quartz.Trigger}</code>.* </p>** @return The desired <code>Trigger</code>, or null if there is no* match.*/public OperableTrigger retrieveTrigger(final TriggerKey triggerKey) throws JobPersistenceException {return (OperableTrigger)executeWithoutLock( // no locks necessary for read...new TransactionCallback() {public Object execute(Connection conn) throws JobPersistenceException {return retrieveTrigger(conn, triggerKey);}});}protected OperableTrigger retrieveTrigger(Connection conn, TriggerKey key)throws JobPersistenceException {try {return getDelegate().selectTrigger(conn, key);} catch (Exception e) {throw new JobPersistenceException("Couldn't retrieve trigger: "+ e.getMessage(), e);}}StdJDBCDelegate.java/*** <p>* Select a trigger.* </p>** @param conn* the DB Connection* @return the <code>{@link org.quartz.Trigger}</code> object* @throws JobPersistenceException*/public OperableTrigger selectTrigger(Connection conn, TriggerKey triggerKey) throws SQLException, ClassNotFoundException, IOException, JobPersistenceException {PreparedStatement ps = null;ResultSet rs = null;try {OperableTrigger trigger = null;ps = conn.prepareStatement(rtp(SELECT_TRIGGER));ps.setString(1, triggerKey.getName());ps.setString(2, triggerKey.getGroup());rs = ps.executeQuery();if (rs.next()) {String jobName = rs.getString(COL_JOB_NAME);String jobGroup = rs.getString(COL_JOB_GROUP);String description = rs.getString(COL_DESCRIPTION);long nextFireTime = rs.getLong(COL_NEXT_FIRE_TIME);long prevFireTime = rs.getLong(COL_PREV_FIRE_TIME);String triggerType = rs.getString(COL_TRIGGER_TYPE);long startTime = rs.getLong(COL_START_TIME);long endTime = rs.getLong(COL_END_TIME);String calendarName = rs.getString(COL_CALENDAR_NAME);int misFireInstr = rs.getInt(COL_MISFIRE_INSTRUCTION);int priority = rs.getInt(COL_PRIORITY);Map<?, ?> map = null;if (canUseProperties()) {map = getMapFromProperties(rs);} else {map = (Map<?, ?>) getObjectFromBlob(rs, COL_JOB_DATAMAP);}Date nft = null;if (nextFireTime > 0) {nft = new Date(nextFireTime);}Date pft = null;if (prevFireTime > 0) {pft = new Date(prevFireTime);}Date startTimeD = new Date(startTime);Date endTimeD = null;if (endTime > 0) {endTimeD = new Date(endTime);}if (triggerType.equals(TTYPE_BLOB)) {rs.close(); rs = null;ps.close(); ps = null;ps = conn.prepareStatement(rtp(SELECT_BLOB_TRIGGER));ps.setString(1, triggerKey.getName());ps.setString(2, triggerKey.getGroup());rs = ps.executeQuery();if (rs.next()) {trigger = (OperableTrigger) getObjectFromBlob(rs, COL_BLOB);}}else {TriggerPersistenceDelegate tDel = findTriggerPersistenceDelegate(triggerType);throw new JobPersistenceException("No TriggerPersistenceDelegate for trigger discriminator type: " + triggerType);TriggerPropertyBundle triggerProps = null;try {triggerProps = tDel.loadExtendedTriggerProperties(conn, triggerKey);} catch (IllegalStateException isex) {if (isTriggerStillPresent(ps)) {throw isex;} else {// QTZ-386 Trigger has been deletedreturn null;}}TriggerBuilder<?> tb = newTrigger().withDescription(description).withPriority(priority).startAt(startTimeD).endAt(endTimeD).withIdentity(triggerKey).modifiedByCalendar(calendarName).withSchedule(triggerProps.getScheduleBuilder()).forJob(jobKey(jobName, jobGroup));if (null != map) {ingJobData(new JobDataMap(map));}trigger = (OperableTrigger) tb.build();trigger.setMisfireInstruction(misFireInstr);trigger.setNextFireTime(nft);trigger.setPreviousFireTime(pft);setTriggerStateProperties(trigger, triggerProps);}}return trigger;} finally {closeResultSet(rs);closeStatement(ps);}}执⾏的sql:String SELECT_TRIGGER = "SELECT * FROM "+ TABLE_PREFIX_SUBST + TABLE_TRIGGERS + " WHERE "+ COL_SCHEDULER_NAME + " = " + SCHED_NAME_SUBST+ " AND " + COL_TRIGGER_NAME + " = ? AND " + COL_TRIGGER_GROUP + " = ?";和JobDetail⼀样,也存在Blob的问题,不再赘述。

C#中Quartz的简单易懂定时任务实现

C#中Quartz的简单易懂定时任务实现

C#中Quartz的简单易懂定时任务实现作为⼀个优秀的开源调度框架,Quartz 具有以下特点:1. 强⼤的调度功能,例如⽀持丰富多样的调度⽅法,可以满⾜各种常规及特殊需求;2. 灵活的应⽤⽅式,例如⽀持任务和调度的多种组合⽅式,⽀持调度数据的多种存储⽅式;3. 分布式和集群能⼒,Terracotta 收购后在原来功能基础上作了进⼀步提升。

另外,作为 Spring 默认的调度框架,Quartz 很容易与 Spring 集成实现灵活可配置的调度功能。

quartz调度核⼼元素:1. Scheduler:任务调度器,是实际执⾏任务调度的控制器。

在spring中通过SchedulerFactoryBean封装起来。

2. Trigger:触发器,⽤于定义任务调度的时间规则,有SimpleTrigger,CronTrigger,DateIntervalTrigger和NthIncludedDayTrigger,其中CronTrigger⽤的⽐较多,本⽂主要介绍这种⽅式。

CronTrigger在spring中封装在CronTriggerFactoryBean中。

3. Calendar:它是⼀些⽇历特定时间点的集合。

⼀个trigger可以包含多个Calendar,以便排除或包含某些时间点。

4. JobDetail:⽤来描述Job实现类及其它相关的静态信息,如Job名字、关联监听器等信息。

在spring中有JobDetailFactoryBean和MethodInvokingJobDetailFactoryBean两种实现,如果任务调度只需要执⾏某个类的某个⽅法,就可以通过MethodInvokingJobDetailFactoryBean来调⽤。

5. Job:是⼀个接⼝,只有⼀个⽅法void execute(JobExecutionContext context),开发者实现该接⼝定义运⾏任务,JobExecutionContext类提供了调度上下⽂的各种信息。

quartz 触发器原理

quartz 触发器原理

Quartz触发器的工作原理可以分为两个主要部分:调度任务和任务执行。

1. 调度任务:Quartz任务调度器将任务(Job)和触发器(Trigger)绑定在一起。

触发器定义了任务调度的时间规则。

Quartz框架有两类常见的触发器,包括SimpleTrigger、CronTrigger、DateIntervalTrigger 和NthIncludedDayTrigger。

这些触发器都有一个重要的属性,称为“错过触发”(misfire)。

如果调度器关闭,或者Quartz线程池中没有可用的线程来执行任务,此时持久性的触发器就会错过其触发时间。

不同类型的触发器,其misfire机制默认都使用“智能策略”(smart policy),即根据触发器的类型和配置动态调整行为。

2. 任务执行:Quartz工作线程(scheduler)通过常规调度线程轮询所有的触发器。

当某个触发器到达下次触发的时间时(通过wait和notifyAll实现),调度线程会从任务执行线程池获取一个空闲线程,执行与该触发器关联的任务。

总的来说,Quartz框架通过将任务和触发器绑定在一起,实现任务的定时或周期性执行,同时使用了智能策略来处理触发器的错过触发问题,使得任务的执行更为灵活和可配置。

Quartz定时任务的使用和配置,全注解和xml

Quartz定时任务的使用和配置,全注解和xml

Quartz定时任务的使⽤和配置,全注解和xml
简介
Quartz是Job scheduling(作业调度)领域的⼀个开源项⽬,Quartz既可以单独使⽤也可以跟spring框架整合使⽤,在实际开发中⼀般会使⽤后者。

使⽤Quartz可以开发⼀个或者多个定时任务,每个定时任务可以单独指定执⾏的时间,例如每隔1⼩时执⾏⼀次、每个⽉第⼀天上午10点执⾏⼀次、每个⽉最后⼀天下午5点执⾏⼀次等。

maven坐标:
</dependency
xml配置
创建⼀个⼯作类
}
主要配置的内容有
配置⾃定义Job、任务描述、触发器、调度⼯⼚等
⾃动扫包
注册任务对象
注册JobDetail
触发器
调度⼯⼚
</bean
全注解(1)对应xml配置写⼀⼀注⼊就ok ⼯作类
}
@Configuration
}
按照xml顺序配置下来测试没问题。

全注解配置(2),推荐⽤法,⾮常简洁⾸先有⼀个配置类
}
@EnableScheduling
使⽤定时任务
}。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

触发器中两个重要的触发器1,SimpleTrigger :可以精确到毫秒,如果需要让任务只在某个时刻执行一次,或者,在某个时刻开始,然后按照某个时间间隔重复执行例如:public SimpleTrigger(String name, //名称String group, //组名Date startTime, //开始时间Date endTime, //结束时间(控制权高于重复次数属性)为null时直到永远int repeatCount, //重复次数(可能是0)long repeatInterval) //重复间隔(以毫秒为单位)2,CronTrigger :像日历那样按日程来触发任务。

可以指定诸如“每个周五中午”,或者“每个工作日的9:30”或者“从每个周一、周三、周五的上午9:00到上午10:00之间每隔五分钟”这样日程安排来触发。

也可以像SimpleTrigger一样,CronTrigger也有一个startTime以指定日程从什么时候开始,也有一个(可选的)endTime以指定何时日程不再继续.Cron表达式被用来配置CronTrigger实例.Cron表达式是一个由7个子表达式组成的字符串。

每个子表达式都描述了一个单独的日程细节。

这些子表达式用空格分隔,分别表示:秒分钟小时月中的天天周中的天年秒---例如:3/5从第3秒开始每隔5秒触发一次通配符('*')可以被用来表示域中“每个”可能的值'?'字符可以用在day-of-month及day-of-week域中,它用来表示“没有指定值”。

'L'字符可以在day-of-month及day-of-week中使用,L是last的缩写。

如时在day-of-month 中L表示的月的最后一天。

在day-of-week中,表示"当月的最后的周XXX",例如:"6L" 或者"FRIL"都表示本月的最后一个周五。

'#'表示表示月中的第几个周几。

例如:day-of-week 域中的"6#3" 或者"FRI#3"表示“月中第三个周五”。

注意:对于单独触发器来说,有些日程需求可能过于复杂而不能用表达式表述,例如:9:00到10:00之间每隔5分钟触发一次,下午1:00到10点每隔20分钟触发一次。

这个解决方案就是创建两个触发器,两个触发器都运行相同的任务。

CronTrigger 例1 –一个简单的每隔5分钟触发一次的表达式"0 0/5 * * * ?"CronTrigger 例2 –在每分钟的10秒后每隔5分钟触发一次的表达式(例如. 10:00:10 am, 10:05:10等.)。

"10 0/5 * * * ?"CronTrigger 例3 –在每个周三和周五的10:30,11:30,12:30触发的表达式。

"0 30 10-13 ? * WED,FRI"CronTrigger 例4 –在每个月的5号,20号的8点和10点之间每隔半个小时触发一次且不包括10点,只是8:30,9:00和9:30的表达式。

"0 0/30 8-9 5,20 * ?"注意,对于单独触发器来说,有些日程需求可能过于复杂而不能用表达式表述,例如:9:00到10:00之间每隔5分钟触发一次,下午1:00到10点每隔20分钟触发一次。

这个解决方案就是创建两个触发器,两个触发器都运行相同的任务。

CronTrigger +Spring比如每天晚上11点30分30秒对系统数据进行备份。

1,要写一个job类package .fbi.ln.quartz;public class SayFBI {@AutowiredFeedBackRuleService feedBackRuleService;//可以注入service 层public void validCalculateFee() throws Exception {//调用service层的方法对系统数据进行备份}}2,注入job类<bean id="sayFBI" class=".fbi.ln.quartz.SayFBI"></bean>3,注入任务类及方法。

<bean id="jobtask4" class="org.springframework.scheduling.quartz.MethodInvokingJobDet ailFactoryBean"><property name="targetObject"><ref bean="sayFBI"/><!--job的实体类--></property><property name="targetMethod"><value>validCalculateFee</value><!--job中的方法--></property></bean>4,在spring中配置时间触发器<bean id="doTime4" class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail"><!--设置触发时执行的任务--><ref bean="jobtask4"/></property><property name="cronExpression"><value>30 30 11 * * ?</value><!--每天晚上11点30分30秒--></property></bean><bean id="startQuertz" lazy-init="false" autowire="no" class="org.springframework.scheduling.quartz.SchedulerFactoryBean ">5,注入要启动的触发器到总管理类<bean id="startQuertz" lazy-init="false" autowire="no" class="org.springframework.scheduling.quartz.SchedulerFactoryBean "><property name="triggers"><list><ref bean="doTime4"/><ref bean="doTime5"/><ref bean="doTime6"/></list></property></bean>6,实例化总管理类,启动监听final Scheduler s = (Scheduler) SpringContextHelper.getContext().getBean("startQuertz");s.start();//通过这个方法就可以启动监听了以上配置的文明:1,先写一个job类sayFBI,sayFBI里面有方法validCalculateFee。

2,注入任务类及方法。

3,注入触发器,并将任务类和时间设置进行注入。

4,最后注入总管理类,当总管理类实例化时执行start()方法启动触发器SimpleTrigger +Spring1,<!-- 定义调用对象和调用对象的方法 --><bean id="job"class="org.springframework.scheduling.quartz.JobDetailBean"><property name="jobClass"><value> com.learnworld.quartz.MessageJob </value></property><property name="jobDataAsMap"><map><entry key="message"><value>This is a message from Spring Quartz configuration!</value></entry></map></property></bean>2, <!-- 定义触发时间 --><bean id="trigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean"> <property name="startDelay"><value>1000</value></property><property name="repeatInterval"><value>3000</value></property><property name="jobDetail"><ref local="job" /></property></bean>3,<!-- 总管理类如果将lazy-init='false'那么容器启动就会执行调度程序 --> <bean id="schdulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean "><property name="triggers"><list><ref local="trigger" /></list></property></bean></beans>1,为什么触发器没有被触发?最常见的原因就是没有调用Scheduler.start(),这个方法告知scheduler开始触发触发器。

相关文档
最新文档