Quartz.net开源作业调度框架使用详解

最新推荐文章于 2024-07-31 08:00:00 发布
最新推荐文章于 2024-07-31 08:00:00 发布
阅读量48 收藏
点赞数
原文链接：http://www.cnblogs.com/knowledgesea/p/4930469.html
版权

前言

quartz.net作业调度框架是伟大组织OpenSymphony开发的quartz scheduler项目的.net延伸移植版本。支持 cron-like表达式,集群，数据库。功能性能强大更不用说。

下载项目文档官网：http://www.quartz-scheduler.net/

项目中需引用：Common.Logging.dll , Common.Logging.Core.dll , Quartz.dll 

下面给大家分解下我最近做的关于计划调度的一个小项目，来辅助理解quartz.net的功能和常用方法。

 

quartz.net的简单用法 -入门

如果你是quartz.net的使用新手，控制台入门这里，建议跟着做下，那么10分钟搞懂quartz.net也是 so easy 的事.

1.创建一个每隔3秒钟执行一次的计划调度

public class RunMain
    {
        static void Main(string[] args)
        {
            Console.WriteLine(DateTime.Now.ToString("r"));
            //1.首先创建一个作业调度池
            ISchedulerFactory schedf = new StdSchedulerFactory();
            IScheduler sched = schedf.GetScheduler();
            //2.创建出来一个具体的作业
            IJobDetail job = JobBuilder.Create<JobDemo>().Build();           
            //3.创建并配置一个触发器
            ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create().WithSimpleSchedule(x=>x.WithIntervalInSeconds(3).WithRepeatCount(int.MaxValue)).Build();
            //4.加入作业调度池中
            sched.ScheduleJob(job, trigger);
            //5.开始运行
            sched.Start();
            Console.ReadKey();
        }
    }
    public class JobDemo : IJob
    {
        /// <summary>
        /// 这里是作业调度每次定时执行方法
        /// </summary>
        /// <param name="context"></param>
        public void Execute(IJobExecutionContext context)
        {
            Console.WriteLine(DateTime.Now.ToString("r"));
        }
    }

Note:1、记下作业调度创建的顺序。2、上述代码执行结果是，每三秒执行一次JobDemo中的Execute，如果程序不停止，无休无止执行到天荒地老，呵呵，扯下蛋啊。

2.改进（丰富调度计划）：上一个作业，我想让他每三秒执行一次，一共执行100次，开始执行时间设定在当前时间，结束时间我设定在2小时后，不过100次执行完没2小时候都不再执行。

    public class RunMain
    {
        static void Main(string[] args)
        {
            Console.WriteLine(DateTime.Now.ToString("r"));
            //首先创建一个作业调度池
            ISchedulerFactory schedf = new StdSchedulerFactory();
            IScheduler sched = schedf.GetScheduler();
            //创建出来一个具体的作业
            IJobDetail job = JobBuilder.Create<JobDemo>().Build();
            //NextGivenSecondDate：如果第一个参数为null则表名当前时间往后推迟2秒的时间点。
            DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(DateTime.Now.AddSeconds(1), 2);
            DateTimeOffset endTime = DateBuilder.NextGivenSecondDate(DateTime.Now.AddHours(2), 3);
            //创建并配置一个触发器
            ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create().StartAt(startTime).EndAt(endTime)                
                                        .WithSimpleSchedule(x=>x.WithIntervalInSeconds(3).WithRepeatCount(100))
                                        .Build();
            //加入作业调度池中
            sched.ScheduleJob(job, trigger);
            //开始运行
            sched.Start();
            Console.ReadKey();
        }
    }
    public class JobDemo : IJob
    {
        /// <summary>
        /// 这里是作业调度每次定时执行方法
        /// </summary>
        /// <param name="context"></param>
        public void Execute(IJobExecutionContext context)
        {
            Console.WriteLine(DateTime.Now.ToString("r"));
        }
    }
View Code

3.继续改进（cron-like使用）：前两个作业调度都太简单，如果我想在每小时的第10，20，25，26，33，54分钟，每分钟的第1，10，14秒执行一次。那么上面显然是不能满足的。这是我就把cron-like表达式引入进来，以实现各种时间纬度的调用。

 public class RunMain
    {
        static void Main(string[] args)
        {
            Console.WriteLine(DateTime.Now.ToString("r"));
            //首先创建一个作业调度池
            ISchedulerFactory schedf = new StdSchedulerFactory();
            IScheduler sched = schedf.GetScheduler();
            //创建出来一个具体的作业
            IJobDetail job = JobBuilder.Create<JobDemo>().Build();
            //NextGivenSecondDate：如果第一个参数为null则表名当前时间往后推迟2秒的时间点。
            DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(DateTime.Now.AddSeconds(1), 2);
            DateTimeOffset endTime = DateBuilder.NextGivenSecondDate(DateTime.Now.AddYears(2), 3);
            //创建并配置一个触发器
            ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create().StartAt(startTime).EndAt(endTime)
                                        .WithCronSchedule("1,10,14 10,20,25,26,33,54 * * * ? ")
                                        .Build();
            //加入作业调度池中
            sched.ScheduleJob(job, trigger);
            //开始运行
            sched.Start();
            //挂起2天
            Thread.Sleep(TimeSpan.FromDays(2));
            //2天后关闭作业调度，将不在执行
            sched.Shutdown();
            Console.ReadKey();
        }
    }
    public class JobDemo : IJob
    {
        /// <summary>
        /// 这里是作业调度每次定时执行方法
        /// </summary>
        /// <param name="context"></param>
        public void Execute(IJobExecutionContext context)
        {
            Console.WriteLine(DateTime.Now.ToString("r"));
        }
    }

基于Quartz.net的作业调度项目详解

最终效果如开篇的第一个图所示。

下面主要说说，作业调度的中怎么定位到具体的作业调度，并给作业调度分组，命名，添加，启动，停止。

首先展示下表结构，项目中我叫作业调度为任务调度。

1、新增作业调度。

 /// <summary>
        /// 任务计划
        /// </summary>
        public static IScheduler scheduler = null;
        public static IScheduler GetScheduler()
        {
            if (scheduler != null)
            {
                return scheduler;
            }
            else
            {
                ISchedulerFactory schedf = new StdSchedulerFactory();
                IScheduler sched = schedf.GetScheduler();
                return sched;
            }
        }
 /// <summary>
        /// 添加任务计划
        /// </summary>
        /// <returns></returns>
        public bool AddScheduleJob(WJ_ScheduleEntity m)
        {
            try
            {
                if (m != null)
                {
                    if (m.StarRunTime == null)
                    {
                        m.StarRunTime = DateTime.Now;
                    }
                    DateTimeOffset starRunTime = DateBuilder.NextGivenSecondDate(m.StarRunTime, 1);
                    if (m.EndRunTime == null)
                    {
                        m.EndRunTime = DateTime.MaxValue.AddDays(-1);
                    }
                    DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(m.EndRunTime, 1);
                    scheduler = GetScheduler();
                    IJobDetail job = JobBuilder.Create<HttpJob>()
                      .WithIdentity(m.JobName, m.JobGroup)
                      .Build();
                    ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create()
                                                 .StartAt(starRunTime)
                                                 .EndAt(endRunTime)
                                                 .WithIdentity(m.JobName, m.JobGroup)
                                                 .WithCronSchedule(m.CronStr)
                                                 .Build();
                    scheduler.ScheduleJob(job, trigger);
                    scheduler.Start();
                    StopScheduleJob(m.JobGroup, m.JobName);
                    return true;
                }
                return false;
            }
            catch (Exception ex)
            {
                //DoApplication.WriteLogFile(ex.Message + "\r\n" + ex.StackTrace);
                return false;
            }
        }

Note:1.这里作业调度执行的函数如下。2.上面的WithIdentity(m.JobName, m.JobGroup) ，是给作业调度加入组，和名称，方便我们针对哪一个作业计划，进行启动停止等操作。

 

 public class HttpJob : IJob
    {
        public void Execute(IJobExecutionContext context)
        {
            ThreadPool.QueueUserWorkItem(delegate(Object o)
            {
                try
                {
                    //DoApplication.WriteLogFile(context.JobDetail.Key.Group + "---" + context.JobDetail.Key.Name + "---" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + "---" + context.NextFireTimeUtc.Value.DateTime.AddHours(8).ToString("yyyy-MM-dd HH:mm:ss"));
                    var sm = new WJ_ScheduleManage().GetScheduleModel(new WJ_ScheduleEntity() { JobGroup = context.JobDetail.Key.Group, JobName = context.JobDetail.Key.Name });
                    new WJ_ScheduleManage().UpdateScheduleRunStatus(new WJ_ScheduleEntity() { JobGroup = context.JobDetail.Key.Group, JobName = context.JobDetail.Key.Name,RunStatus=(int)ADJ.Job.Entity.EnumType.JobRunStatus.执行中 });
                    ESBRequest req = new ESBRequest(sm.ServiceCode, sm.ApiCode);
                    DataResult result = req.Request();
                    new WJ_ScheduleManage().UpdateScheduleRunStatus(new WJ_ScheduleEntity() { JobGroup = context.JobDetail.Key.Group, JobName = context.JobDetail.Key.Name, RunStatus = (int)ADJ.Job.Entity.EnumType.JobRunStatus.待运行 });
                    if (result.Code == 1)
                    {
                        #region 加入执行明细
                        WJ_ScheduleDetailsEntity dm = new WJ_ScheduleDetailsEntity();
                        dm.ActionDescribe = "执行完成:" + result.Message ;
                        dm.ActionStep = (int)ADJ.Job.Entity.EnumType.JobStep.执行完成;
                        dm.CreateTime = DateTime.Now;
                        dm.JobGroup = context.JobDetail.Key.Group;
                        dm.JobName = context.JobDetail.Key.Name;
                        dm.IsSuccess = 1;
                        new WJ_ScheduleManage().AddScheduleDetails(dm);
                        #endregion
                    }
                    else
                    {
                        #region 加入执行明细
                        WJ_ScheduleDetailsEntity dm = new WJ_ScheduleDetailsEntity();
                        dm.ActionDescribe = "执行任务计划中，执行计划过程出错."+result.Message;
                        dm.ActionStep = (int)ADJ.Job.Entity.EnumType.JobStep.执行任务计划中;
                        dm.CreateTime = DateTime.Now;
                        dm.JobGroup = context.JobDetail.Key.Group;
                        dm.JobName = context.JobDetail.Key.Name;
                        dm.IsSuccess = 0;
                        new WJ_ScheduleManage().AddScheduleDetails(dm);
                        #endregion
                    }
                    new WJ_ScheduleManage().UpdateScheduleNextTime(new WJ_ScheduleEntity() { JobGroup = context.JobDetail.Key.Group, JobName = context.JobDetail.Key.Name, NextTime = context.NextFireTimeUtc.Value.DateTime.AddHours(8) });
                }
                catch (Exception ex)
                {
                    #region 加入执行明细
                    WJ_ScheduleDetailsEntity dm = new WJ_ScheduleDetailsEntity();
                    dm.ActionDescribe = "执行任务计划中，执行计划过程出错：" + ex.Message + "/r/n" + ex.StackTrace;
                    dm.ActionStep = (int)ADJ.Job.Entity.EnumType.JobStep.执行任务计划中;
                    dm.CreateTime = DateTime.Now;
                    dm.JobGroup = context.JobDetail.Key.Group;
                    dm.JobName = context.JobDetail.Key.Name;
                    dm.IsSuccess = 0;
                    new WJ_ScheduleManage().AddScheduleDetails(dm);
                    #endregion
                    DoApplication.WriteLogFile(ex.Message + "\r\n" + ex.StackTrace);
                }
            });
        }
    }
View Code

note：这里执行的Execute方法参数IJobExecutionContext 中，会自动把作业调度的详细信息带过来，作业名称，作业组名，作业下次执行时间，作业执行时间等等，这里的内容也是至关重要的，比如根据作业组，作业名称我们可以从数据库找到相应的作业调度详细，更新操作数据库。

2、针对某个作业计划进行停止，启动。

 /// <summary>
        /// 暂停指定任务计划
        /// </summary>
        /// <returns></returns>
        public JsonResult StopScheduleJob(string jobGroup, string jobName)
        {
            try
            {
                scheduler = GetScheduler();                
                scheduler.PauseJob(new JobKey(jobName, jobGroup));
                new WJ_ScheduleManage().UpdateScheduleStatus(new WJ_ScheduleEntity() { JobName = jobName, JobGroup = jobGroup, Status = (int)ADJ.Job.Entity.EnumType.JobStatus.已停止 });               
                return Json(new StatusView() { Status = 0, Msg = "停止任务计划成功！" }, JsonRequestBehavior.AllowGet);
            }
            catch (Exception ex)
            {               
                DoApplication.WriteLogFile(ex.Message + "/r/n" + ex.StackTrace);
                return Json(new StatusView() { Status = -1, Msg = "停止任务将计划失败！" }, JsonRequestBehavior.AllowGet);
            }
        }
        /// <summary>
        /// 开启指定的任务计划
        /// </summary>
        /// <returns></returns>
        public JsonResult RunScheduleJob(string jobGroup, string jobName)
        {
            try
            {
                var sm = new WJ_ScheduleManage().GetScheduleModel(new WJ_ScheduleEntity() { JobName = jobName, JobGroup = jobGroup });
                AddScheduleJob(sm);
                sm.Status = (int)ADJ.Job.Entity.EnumType.JobStatus.已启用;
                new WJ_ScheduleManage().UpdateScheduleStatus(sm);
                scheduler = GetScheduler();
                scheduler.ResumeJob(new JobKey(jobName, jobGroup));
                return Json(new StatusView() { Status = 0, Msg = "启动成功！" }, JsonRequestBehavior.AllowGet);
            }
            catch (Exception ex)
            {
              
                DoApplication.WriteLogFile(ex.Message + "/r/n" + ex.StackTrace);
                return Json(new StatusView() { Status = -1, Msg = "启动失败！" }, JsonRequestBehavior.AllowGet);
            }
        }

最后注意：

1、这个项目完全使用啦cron-like表达式实现触发器配置，如果你对cron不了解，那么我上篇中有针对cron做介绍讲解，如果你对cron了解而没有一个合适的生成工具，那么入左上方2个群，找我。

2、这个项目部署在IIS中，那么就要设置应用程序池的回收机制为，永不回收，配置下，如果不会配置，入左上方2个群，找我。

 

转载于:https://www.cnblogs.com/knowledgesea/p/4930469.html

.Net Core中使用Quartz.Net实践记录
10-18
Quartz.NET是一套很好的任务调度框架。下面这篇文章主要给大家介绍了关于.Net Core中使用Quartz.Net的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考借鉴，下面随着小编来一起学习学习吧
Quartz.Net任务调度基本用法
hanyamei的专栏
03-22 943
Quartz包括调度器Scheduler，任务IJobDetail，触发器ITrigger。 一、任务配置 <?xml version="1.0" encoding="utf-8" ?> <Jobs> <!--节点属性说明 IsEnabled（0：未启用，1：启用） CronExpression：任务触发器时间配置表达式 --> <BoxCo...
Quartz.Net详解
李宥的博客
08-28 8750
Gitee：https://gitee.com/bluecusliyou Github：https://github.com/bluecusliyou业务中总是会有需要定时执行的任务，我们可以用timer实现最简单的定时需求，也可以借助Quartz.NET框架实现复杂定时任务的功能。 System.Timers.Timer 类具有“内置”定时器功能，为什么有人会使用 Quartz 而不是这些标准功能？主要有几个原因：Quartz.NET 是一个功能齐全的开源作业调度系统，可用于从最小的应用程序到大型企业系统
.NET Core的Quartz实战之自定义配置实现
qq_53644827的博客
08-09 1501
.NET Core，Quartz，c#，定时任务
详解.NET Core使用Quartz执行调度任务进阶
10-17
Quartz.Net是一个功能丰富的开源任务调度框架，适用于多种.NET环境，包括.NET Core。本文将深入探讨如何在.NET Core 2.2及以上版本中利用Quartz进行高级任务调度。 一、Quartz.Net简介 Quartz.Net提供了强大的定时...
详解免费开源的DotNet任务调度组件Quartz.NET（.NET组件介绍之五）
01-20
Quartz.NET是一个强大的任务调度框架，专为.NET环境设计，旨在替代系统内建的定时器功能，解决诸如持久化、灵活计划和线程管理等问题。Quartz.NET允许开发者定义作业（Jobs）和触发器（Triggers），以实现复杂的定时...
Quartz.NET 配置文件详解1
08-08
Quartz.NET 是一个开源的作业调度框架，用于在 .NET 应用程序中实现任务的自动化执行。它允许开发者定义任务（Job）和触发器（Trigger），并根据预设的时间表自动执行这些任务。本文将深入解析 Quartz.NET 的配置...
官方Quartz.NET 2.3.1 源码+15个示例
03-30
Quartz.NET是一个开源的作业调度框架，用于在.NET环境中创建和执行计划任务。它提供了高度可配置和可扩展性，使开发者能够灵活地定义和管理各种定时任务。2.3.1版本是官方在2015年1月15日发布的，这个压缩包包含了该...
.Net Core中Quartz的使用方法
最新发布
学习和分享
07-31 758
作业（Job）是Quartz执行的基本单位。你需要创建一个类，继承自IJob接口，并实现Execute方法。
记一次quertz框架出现的某个定时任务不执行BUG
scmhw的专栏
03-05 746
1.删除qrtz表中跟这个job有关的信息(如果不熟悉表操作，慎重选择此方案)，重新创建定时任务即可。2.查看这几个表中，异常记录跟正常记录的差异，修改为正常定时任务即可。2.在可视化界面删除并重新创建定时任务。1.在可视化界面启动停止定时任务。尝试了如下方案：均无法解决问题。
如何在 ASP.NET Core 中使用 Quartz.NET
_BigMao的博客
11-21 1022
当我们在web开发中，常常会遇到这么一个需求，在后台执行某一项具体的任务，具体的说就是这些任务必须在后台定时执行。Quartz.NET 是一个开源的 JAVA 移植版，它有着悠久的历史并且提供了强大的 Cron 表达式，这篇我们就来讨论如何在 ASP.NET Core 中使用 Quartz.NET 去执行一些后台任务。
.NET开源作业调度框架Quartz
forever2698的专栏
07-12 2146
Quartz是一个强大、开源、轻量的作业调度框架，你能够用它来为执行一个简单或复杂的作业调度任务。
.Net Core中使用Quartz.Net 简单示例
weixin_43965881的博客
03-23 2698
Quartz.Net 在.netcore 中的示例 一. Quartz.Net 介绍 Quartz.NET是一个强大、开源、轻量的作业调度框架，是一个用C＃编写的纯.NET库，是一个非常流行的开源Java作业调度框架。是 OpenSymphony 的 Quartz API 的.NET移植，非常适合在平时的工作中，定时轮询数据库同步，定时邮件通知，定时处理数据等 通俗说它的功能是：比如说我想每天晚上...
在ASP.NET Core中使用Quartz.NET实现定时任务
xujiyy的博客
03-31 539
【代码】在ASP.NET Core中使用Quartz.NET实现定时任务。
【.Net Core】注入Quartz定时任务
gx_up
09-12 9498
一、经常在项目会用到定时任务同步数据或更新缓存等操作，在很久以前我们可能经常会用一个多线程或timer来做定时任务，这样能实现比较简单轻量级的任务；对于任务多且都调用频率不一样的任务，我们都会用到Quartz.Net这个组件； Quartz.NET是一个强大、开源、轻量的作业调度框架，你能够用它来为执行一个作业而创建简单的或复杂的作业调度。它有很多特征，如：数据库支持，集群，插...
.Net Core Quartz
beijing_xiaohui的博客
05-30 399
Quartz主要有三部分组成任务(Job)、触发器(Trigger)和调度器(Schedule)。完成以上操作设置好定时任务执行时间后运行项目，在日志里查看输出记录。
ASP.NET Core基础之定时任务(二)-Quartz.NET入门
物联网大联盟
12-21 2186
对于QuartZ.NET任务调度框架做一个入门级的介绍
.net core（.NET 6）搭建基于Quartz组件的定时调度任务
vsmybits的博客
03-17 2822
.net core（.NET 6）搭建基于Quartz组件的定时调度任务
Quartz.NET开源作业调度框架系列(三):IJobExecutionContext 参数传递-转
05-25
Quartz.NET是一个开源的作业调度框架，它可以帮助我们实现定时任务和作业调度。在Quartz.NET中，我们可以通过实现IJob接口来定义一个作业，并且可以通过JobDataMap来传递参数。这篇文章将介绍如何在Quartz.NET中使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值