quartz 订阅
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个,百个,甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。Quartz的最新版本为Quartz 2.3.2。 展开全文
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个,百个,甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。Quartz的最新版本为Quartz 2.3.2。
信息
外文名
quartz
最新版本
Quartz 2.3.2
类    别
开源项目
中文名
扩特兹公式
解    释
由java编写的开源作业调度框架
quartz调度简单
Quartz是一个完全由java编写的开源作业调度框架。不要让作业调度这个术语吓着你。尽管Quartz框架整合了许多额外功能, 但就其简易形式看,你会发现它易用得简直让人受不了!简单地创建一个实现org.quartz.Job接口的java类。Job接口包含唯一的方法:public void execute(JobExecutionContext context)throws JobExecutionException;在你的Job接口实现类里面,添加一些逻辑到execute()方法。一旦你配置好Job实现类并设定好调度时间表,Quartz将密切注意剩余时间。当调度程序确定该是通知你的作业的时候,Quartz框架将调用你Job实现类(作业类)上的execute()方法并允许做它该做的事情。无需报告任何东西给调度器或调用任何特定的东西。仅仅执行任务和结束任务即可。如果配置你的作业在随后再次被调用,Quartz框架将在恰当的时间再次调用它。
收起全文
精华内容
参与话题
问答
  • Quartz

    千次阅读 2017-12-06 09:11:27
    这里以quartz-2.2.3为例 1.上官网下载quartz的完整版,quartz-2.2.3-distribution.tar,里面包含源代码,官方Demo,Java Doc,所需的Jar包,JDBCStore数据库等文件,下载完毕,将lib文件下的jar包复制到项目中 2....

    这里以quartz-2.2.3为例

    1.上官网下载quartz的完整版,quartz-2.2.3-distribution.tar,里面包含源代码,官方Demo,Java Doc,所需的Jar包,JDBCStore数据库等文件,下载完毕,将lib文件下的jar包复制到项目中

    2.quartz主要有三个概念

    (1)任务调度器Scheduler 

    SchedulerFactory sf = new StdSchedulerFactory();
    Scheduler sched = sf.getScheduler();

    Scheduler schedule = StdSchedulerFactory.getDefaultScheduler();

    (2)任务触发器Trigger

    Trigger tri = TriggerBuilder.newTrigger().build;

    (3)任务Job

    JobBuilder.newJob(MyJob.class).build();


    其他:

    Cron表达式:
    格式:秒 分 时 日 月  星期几 年(可选)
    1:?只能用在日或星期几的域上
    2:分隔符[",","-","/","*"];eg:在分钟域使用12/15(从12分开始每隔15分钟触发)
    3: 星期(1-7)
    4:日跟星期的域不能是互斥的,不能同时使用
    5:完整的例子:0 15,25,35 9-17 ? * 6 2017-2018 = 2017年和2018年的6月份每天9点到17点分钟刻度为15或25或35时触发




    调度器的设置和功能信息
    SchedulerMetaData sm = s.getMetaData();




    Job参数:
    往具体的Job里传递参数

    JobDataMap jobParam= jobdetail.getJobDataMap();
    jobParam.put("","");
    Job任务里获取:JobExecutionContext/ctx.getJobDetail().getJobDataMap().get()

    JobBuilder.usingJobData(),取时同上

    JobDataMap jobParam = JobExecutionContext/ctx.getMergedJobDataMap()


    监听器管理器:
    例:给指定key的任务增加监听器
    ListenerManager lm= schedule.getListenerManager();
    Matcher<JobKey> matcher = KeyMatcher.keyEquals(job.getKey());
    lm.addJobListener(new MyListener(),matcher);


    二:配置文件

    quartz有一个默认的配置文件,在quarz包里,如果需要更改配置文件信息,需要将该文件复制一份到src下

    如果需要用到数据库存储

    #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.useProperties: true


    #org.quartz.jobStore.dataSource: ds 

    #org.quartz.dataSource.ds.driver: com.mysql.jdbc.Driver 

    #org.quartz.dataSource.ds.URL: jdbc:mysql://127.0.0.1:3306/quartz?useUnicode=true&characterEncoding=UTF-8

    #org.quartz.dataSource.ds.user: emil 

    #org.quartz.dataSource.ds.password: 123456

    以上部分为开启JDBCStore,其实没啥用,就记录了一下还未跑完的任务,已经跑完的就不知所踪了,如果需要自己记录任务的详细情况,自己动手写吧。

    #配置一个全局的任务监听器,当然这个也是可以在代码中添加的

    org.quartz.jobListener.NAME.class = MyListener

    更多详细的配置可以参考官方网站:http://www.quartz-scheduler.org/documentation/quartz-2.2.x/configuration/


    入门demo:

    try {
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
            JobDetail jobdetail = JobBuilder.newJob(MyJob.class).withIdentity("任务名字").build();
            Trigger trigger = TriggerBuilder.newTrigger() 
                    .withIdentity("触发器名字")
                    .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(5).withRepeatCount(3))
                    .build();
            // and start it off
            scheduler.scheduleJob(jobdetail, trigger);
            scheduler.start();
        } catch (SchedulerException se) {
            se.printStackTrace();
        }


    Job:

    public class MyJob implements Job{
    
    	@Override
    	public void execute(JobExecutionContext context) throws JobExecutionException {
    		//通过上下文获取  
            JobKey jobKey = context.getJobDetail().getKey();  
            System.out.println("任务id>>>>>>>>>>>>>>>"+jobKey);
            for(int i=0;i<5;i++) {
            	    System.out.println("i am a superman");
            }
    	}
    }




    展开全文
  • Spring+Quartz实现定时任务的配置方法

    万次阅读 多人点赞 2019-07-31 19:16:18
    &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="... xmlns:context="...
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    	xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
    	xsi:schemaLocation="
    		http://www.springframework.org/schema/beans 
    		http://www.springframework.org/schema/beans/spring-beans.xsd
    		http://www.springframework.org/schema/context
    		http://www.springframework.org/schema/context/spring-context.xsd
    		http://www.springframework.org/schema/tx 
    		http://www.springframework.org/schema/tx/spring-tx.xsd
    		http://www.springframework.org/schema/aop 
    		http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--  Scheduler配置 -->
    	<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    		<property name="triggers">
    			<list>
    				<ref bean="teachingProcessTrigger" />
    			</list>
    		</property>
    		<property name="quartzProperties">
    			<props>
    				<prop key="org.quartz.threadPool.threadCount">3</prop>
    			</props>
    		</property>
    	</bean>
    <!--  Trigger配置 -->
    	<bean id="teachingProcessTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
    		<property name="jobDetail">
    			<ref bean="teachingProcess" />
    		</property>
    		<property name="cronExpression">
    			<!--  每天凌晨0点执行一次 -->
    			<value>0 0 0 * * ?</value>
    		</property>
    	</bean>
    <!--  JobDetail配置 -->
    	<bean id="teachingProcess"
    		class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    		<property name="targetObject">
        <!-- hrQuartzServiceImpl是一个业务类,在其他地方声明了bean,这里直接引用就可以 -->
    			<ref bean="hrQuartzServiceImpl" />
    		</property>
    		<property name="targetMethod">
        <!-- hrQuartzServiceImpl类里作为执行入口的方法名 -->
    			<value>doTeachingProcess</value>
    		</property>
    	</bean>
    </beans>
    

    任务有并行和串行之分,并行是指:一个定时任务,当执行时间到了的时候,立刻执行此任务,不管当前这个任务是否在执行中;串行是指:一个定时任务,当执行时间到了的时候,需要等待当前任务执行完毕,再去执行下一个任务。
    quartz框架中可以设置是否允许任务并行:
    如果是通过MethodInvokingJobDetailFactoryBean在运行中动态生成的Job,配置的xml文件有个concurrent属性,这个属性的功能是配置此job是否可以并行运行,如果为false则表示不可以并行运行,否则可以并行。如果一个job的业务处理发费的时间超过了job的启动的间隔时间(repeatInterval),这个属性非常有用。如果为false,那么,在这种情况下,当前job还在运行,那么下一个job只能延时运行。如果为true,那么job就会并行运行,配置示例如下:

    <bean id="jobCompareB2cAndLocal" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    	<property name="targetObject " ref="delegateJob " />
    	<property name="targetMethod " value="方法名" />
    	<property name="concurrent " value="false " />
    </bean >
    

    如果不配置,默认是true的,就是允许并行。

    展开全文
  • quartz

    2015-11-25 10:25:02
    quartz.properties中 org.quartz.jobStore.misfireThreshold = 60000表示quartz在暂停time(stop)后又重新启动time(start)其中 如果time(start)-time(stop)>60000(1分钟)则quartz会忽略掉暂停那段时间内的job,如果...

    quartz.properties中

    org.quartz.jobStore.misfireThreshold = 60000表示quartz在暂停time(stop)后又重新启动time(start)其中 如果time(start)-time(stop)>60000(1分钟)则quartz会忽略掉暂停那段时间内的job,如果time(start)-time(stop)<60000则quartz不会忽略掉暂停那段时间内的job,说白了就是当quartz暂停那端时间内没有做的job,会在启动后重新补上(即多个以前的多个job同时做了)


    org.quartz.threadPool.threadCount = 10线程数量,可以理解为工厂里面的workers(工人),工人是用来完成工厂里面的jobs的。


    org.quartz.jobStore.tablePrefix = QRTZ_ 表示quartz对应数据库表的表明的前缀

    展开全文
  • using Quartz; using Quartz.Impl; using System; using System.Collections.Concurrent; using System.Threading.Tasks; namespace Core.Util { /// <summary> /// 任务帮助类 /// </summary> ...
    using Quartz;
    using Quartz.Impl;
    using System;
    using System.Collections.Concurrent;
    using System.Threading.Tasks;
    
    namespace Core.Util
    {
        /// <summary>
        /// 任务帮助类
        /// </summary>
        public static class JobHelper
        {
            #region 私有成员
    
            private static IScheduler __scheduler;
            private static object _lock = new object();
            private static IScheduler _scheduler
            {
                get
                {
                    if (__scheduler == null)
                    {
                        lock (_lock)
                        {
                            if (__scheduler == null)
                            {
                                __scheduler = AsyncHelper.RunSync(() => StdSchedulerFactory.GetDefaultScheduler());
                                AsyncHelper.RunSync(() => __scheduler.Start());
                            }
                        }
                    }
    
                    return __scheduler;
                }
            }
            static ConcurrentDictionary<string, Action> _jobs { get; }
                = new ConcurrentDictionary<string, Action>();
    
            #endregion
    
            #region 外部接口
    
            /// <summary>
            /// 设置一个时间间隔的循环操作
            /// </summary>
            /// <param name="action">执行的操作</param>
            /// <param name="timeSpan">时间间隔</param>
            /// <returns>任务标识Id</returns>
            public static string SetIntervalJob(Action action, TimeSpan timeSpan)
            {
                string key = Guid.NewGuid().ToString();
                _jobs[key] = action;
                IJobDetail job = JobBuilder.Create<Job>()
                   .WithIdentity(key)
                   .Build();
                ITrigger trigger = TriggerBuilder.Create()
                    .WithIdentity(key)
                    .StartNow()
                    .WithSimpleSchedule(x => x.WithInterval(timeSpan).RepeatForever())
                    .Build();
                AsyncHelper.RunSync(() => _scheduler.ScheduleJob(job, trigger));
    
                return key;
            }
    
            /// <summary>
            /// 设置每天定时任务
            /// </summary>
            /// <param name="action">执行的任务</param>
            /// <param name="h">时</param>
            /// <param name="m">分</param>
            /// <param name="s">秒</param>
            /// <returns>任务标识Id</returns>
            public static string SetDailyJob(Action action, int h, int m, int s)
            {
                string key = Guid.NewGuid().ToString();
                _jobs[key] = action;
                IJobDetail job = JobBuilder.Create<Job>()
                   .WithIdentity(key)
                   .Build();
                ITrigger trigger = TriggerBuilder.Create()
                    .WithIdentity(key)
                    .StartNow()
                    .WithCronSchedule($"{s} {m} {h} * * ?")//每天定时
                    .Build();
                AsyncHelper.RunSync(() => _scheduler.ScheduleJob(job, trigger));
    
                return key;
            }
    
            /// <summary>
            /// 设置延时任务,仅执行一次
            /// </summary>
            /// <param name="action">执行的操作</param>
            /// <param name="delay">延时时间</param>
            /// <returns>任务标识Id</returns>
            public static string SetDelayJob(Action action, TimeSpan delay)
            {
                string key = Guid.NewGuid().ToString();
                action += () =>
                {
                    RemoveJob(key);
                };
                _jobs[key] = action;
    
                IJobDetail job = JobBuilder.Create<Job>()
                   .WithIdentity(key)
                   .Build();
                ITrigger trigger = TriggerBuilder.Create()
                    .WithIdentity(key)
                    .StartAt(DateTime.Now + delay)
                    .WithSimpleSchedule(x => x.WithRepeatCount(0).WithInterval(TimeSpan.FromSeconds(10)))
                    .Build();
                AsyncHelper.RunSync(() => _scheduler.ScheduleJob(job, trigger));
    
                return key;
            }
    
            /// <summary>
            /// 通过表达式创建任务
            /// 表达式规则参考:http://www.jsons.cn/quartzcron/
            /// </summary>
            /// <param name="action">执行的操作</param>
            /// <param name="cronExpression">表达式</param>
            /// <returns></returns>
            public static string SetCronJob(Action action, string cronExpression)
            {
                string key = Guid.NewGuid().ToString();
                _jobs[key] = action;
                IJobDetail job = JobBuilder.Create<Job>()
                   .WithIdentity(key)
                   .Build();
                ITrigger trigger = TriggerBuilder.Create()
                    .WithIdentity(key)
                    .StartNow()
                    .WithCronSchedule(cronExpression)
                    .Build();
                AsyncHelper.RunSync(() => _scheduler.ScheduleJob(job, trigger));
    
                return key;
            }
    
            /// <summary>
            /// 删除任务
            /// </summary>
            /// <param name="jobId">任务标识Id</param>
            public static void RemoveJob(string jobId)
            {
                AsyncHelper.RunSync(() => _scheduler.DeleteJob(new JobKey(jobId)));
                _jobs.TryRemove(jobId, out _);
            }
    
            #endregion
    
            #region 内部类
    
            private class Job : IJob
            {
                public async Task Execute(IJobExecutionContext context)
                {
                    await Task.Run(() =>
                    {
                        string jobName = context.JobDetail.Key.Name;
                        if (_jobs.ContainsKey(jobName))
                        {
                            _jobs[jobName]?.Invoke();
                        }
                    });
                }
            }
    
            #endregion
        }
    }
    
    展开全文
  • Spring中使用Quartz

    万次阅读 2018-09-17 15:25:00
    人工智能,零基础入门!... 一、概述 各种企业应用几乎都会碰到任务调度的需求,就拿论坛来说:每隔半个小时生成精华文章的RSS文件,每天凌晨统计论坛用户的积分排名,每隔30分钟执行锁定 用户解锁任务。...
  • Nuget引入程序包 QuartZ 三大核心对象 IScheduler:时间轴 单元 盒子 在这里进行任务配置 IJobDetail:描述具体做什么事情,定时任务执行的动作 ITrigger:时间策略,按照什么频率来执行 传参数:jobDetail....
  • 精进 QuartzQuartz大致介绍(一)

    万次阅读 多人点赞 2017-02-04 15:13:26
    Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,是完全由java开发的一个开源的任务日程管理系统,“任务进度管理器”就是一个在预先确定(被纳入日程)的时间到达时,负责执行(或者通知)其他...
  • Quartz 入门详解

    万次阅读 2017-05-23 14:39:18
    基本上任何公司都会用到调度这个功能, 比如我们公司需要定期执行调度生成报表, 或者比如博客什么的定时更新之类的,都可以靠Quartz来完成。正如官网所说,小到独立应用大到大型电子商务网站, Quartz都能胜任。...
  • 定时任务框架Quartz-(一)Quartz入门与Demo搭建

    万次阅读 多人点赞 2018-07-10 13:57:07
    一、什么是Quartz 什么是Quartz? Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,完全由Java开发,可以用来执行定时任务,类似于java.util.Timer。但是相较于Timer, Quartz增加了很多功能:...
  • SpringQuartz定时任务的cron表达式书写

    万次阅读 2018-09-17 15:09:28
    SpringQuartz定时任务的使用,要配置这个定时任务什么时候执行,周期是多少,周期内执行多少次,这个都是cron表达式来控制的,下面详解一下这个cron表达式。 一、先来举些例子 【1】0 0 10,14,16 * * ? 每天上午10...
  • 精进Quartz—Spring和Quartz集成详解(三)

    万次阅读 多人点赞 2017-02-06 11:49:46
    Spring是一个很优秀的框架,它无缝的集成了Quartz,简单方便的让企业级应用更好的使用Quartz进行任务的调度。下面就对Spring集成Quartz进行简单的介绍和示例讲解!和上一节 Quartz学习——2、简单入门示例Demo 的...
  • 精进QuartzQuartz简单入门Demo(二)

    万次阅读 多人点赞 2017-02-04 15:55:38
    要学习Quartz框架,首先大概了解了Quartz的基本知识后,在通过简单的例子入门,一步一个脚印的走下去。 下面介绍Quartz入门的示例,由于Quartz的存储方式分为RAM和JDBC,分别对这两种进行简单的说明。并附上代码! ...
  • SpringMVC+quartz 报错

    2017-09-09 08:55:38
    at org.quartz.core.QuartzScheduler.scheduleJob(QuartzScheduler.java:932) at org.quartz.impl.StdScheduler.scheduleJob(StdScheduler.java:258) at org.springframework.scheduling.quartz....
  • java quartz 初始化异常

    2016-04-19 10:31:40
    2016-04-19 02:11:11,421 (QuartzScheduler.java:2425)-An error occured instantiating job to be executed. job= 'maxbet_job_group.isn_job_group' org.quartz.SchedulerException: Problem instantiating class ...
  • 林炳文Evankaka原创作品。... 一、 Quartz存储与持久化  Quartz提供两种基本作业存储...在默认情况下Quartz将任务调度的运行信息保存在内存中,这种方法提供了最佳的性能,因为内存中数据访问最快。不足之处是缺乏...
  • Quartz 定时任务调度框架

    万次阅读 2020-10-06 19:40:36
    定时任务调度框架 Quartz 入门案例: 依赖: <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.2</version> ...
  • quartz持久化到数据库

    2016-01-13 08:40:53
    quartz在项目启动时,是不是会根据配置文件自动持久化到数据库,我的配置如下: <!-- 调度器 --> <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> ...

空空如也

1 2 3 4 5 ... 20
收藏数 37,306
精华内容 14,922
关键字:

quartz