关于Quartz .net 使用

最新推荐文章于 2024-05-06 18:27:18 发布
置顶 最新推荐文章于 2024-05-06 18:27:18 发布
阅读量980 收藏 1
点赞数 1
分类专栏： C#后台 文章标签： qarez
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013766439/article/details/80825448
版权

这两天做一个实时任务推送，本来想着说用线程或者定时器。后面发现Quartz .net这个强大的定时任务框架，然后记录下

Quartz .Net就是一个定时任务推送的开源框架

下载地址：Quartz .net下载地址：https：//www.quartz-scheduler.net/download.html

Quartz有两种存储机制，一是存缓存

1.配置文件   

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

<!-- This file contains job definitions in schema version 2.0 format -->

<job-scheduling-data xmlns="http://quartznet.sourceforge.net/JobSchedulingData" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.0">

  <processing-directives>
    <overwrite-existing-data>true</overwrite-existing-data>
  </processing-directives>

  <schedule>

    <job>
      <name>sampleJob</name>
      <group>sampleGroup</group>
      <description>Sample job for Quartz Server</description>
      <job-type>Quartz.Server.SampleJob, Quartz.Server</job-type>
      <durable>true</durable>
      <recover>false</recover>
      <job-data-map>
        <entry>
          <key>key1</key>
          <value>value1</value>
        </entry>
        <entry>
          <key>key2</key>
          <value>value2</value>
        </entry>
      </job-data-map>
    </job>

    <trigger>
      <simple>
        <name>sampleSimpleTrigger</name>
        <group>sampleSimpleGroup</group>
        <description>Simple trigger to simply fire sample job</description>
        <job-name>sampleJob</job-name>
        <job-group>sampleGroup</job-group>
        <misfire-instruction>SmartPolicy</misfire-instruction>
        <repeat-count>-1</repeat-count>
        <repeat-interval>10000</repeat-interval>
      </simple>
    </trigger>
    <trigger>
      <cron>
        <name>sampleCronTrigger</name>
        <group>sampleCronGroup</group>
        <description>Cron trigger to simply fire sample job</description>
        <job-name>sampleJob</job-name>
        <job-group>sampleGroup</job-group>
        <misfire-instruction>SmartPolicy</misfire-instruction>
        <cron-expression>0/10 * * * * ?</cron-expression>
      </cron>
    </trigger>
    <trigger>
      <calendar-interval>
        <name>sampleCalendarIntervalTrigger</name>
        <group>sampleCalendarIntervalGroup</group>
        <description>Calendar interval trigger to simply fire sample job</description>
        <job-name>sampleJob</job-name>
        <job-group>sampleGroup</job-group>
        <misfire-instruction>SmartPolicy</misfire-instruction>
        <repeat-interval>15</repeat-interval>
        <repeat-interval-unit>Second</repeat-interval-unit>
      </calendar-interval>
    </trigger>
  </schedule>
</job-scheduling-data>


2：定义Quartz任务管理工厂

using Quartz;
using Quartz.Impl;
using Quartz.Impl.Triggers;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace Berry.SignalRService.Schedu.Jobs
{
    /// <summary>
    /// Quartz任务管理类
    /// </summary>
    public static class QuartzUtil
    {
        private static ISchedulerFactory sf = null;
        private static IScheduler sched = null;

        static QuartzUtil()
        {
            sf = new StdSchedulerFactory();
            sched = sf.GetScheduler();
            sched.Start();
        }

        /// <summary>
        /// 添加Job 并且以定点的形式运行 不带参数的cron表达式新建job
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="JobName"></param>
        /// <param name="CronTime"></param>
        /// <returns></returns>
        public static DateTimeOffset AddJob<T>(string JobName, string CronTime) where T : IJob
        {
            return AddJob<T>(JobName, CronTime, null);
        }

        /// <summary>
        /// 添加Job 并且以定点的形式运行  参数为Cron表达式，可传参数。目前支持一个参数，可加
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="JobName">keyName</param>
        /// <param name="CronTime">Cron表达式</param>
        /// <param name="jobDataMap">传递的参数，目前用于ConnId</param>
        /// <returns></returns>
        public static DateTimeOffset AddJob<T>(string JobName, string CronTime, string connIds) where T : IJob
        {
            IJobDetail jobCheck = JobBuilder.Create<T>().WithIdentity(JobName, JobName + "_Group").UsingJobData("connIds", connIds).Build();
            ICronTrigger CronTrigger = new CronTriggerImpl(JobName + "_CronTrigger", JobName + "_TriggerGroup", CronTime);
            return sched.ScheduleJob(jobCheck, CronTrigger);
        }

      

        /// <summary>
        /// 添加Job 并且以周期的形式运行
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="JobName"></param>
        /// <param name="SimpleTime">毫秒数</param>
        /// <returns></returns>
        public static DateTimeOffset AddJob<T>(string JobName, int SimpleTime) where T : IJob
        {
            return AddJob<T>(JobName, DateTime.UtcNow.AddMilliseconds(1), TimeSpan.FromMilliseconds(SimpleTime));
        }

        /// <summary>
        /// 添加Job 并且以周期的形式运行
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="JobName"></param>
        /// <param name="SimpleTime">毫秒数</param>
        /// <returns></returns>
        public static DateTimeOffset AddJob<T>(string JobName, DateTimeOffset StartTime, int SimpleTime) where T : IJob
        {
            return AddJob<T>(JobName, StartTime, TimeSpan.FromMilliseconds(SimpleTime));
        }

        /// <summary>
        /// 添加Job 并且以周期的形式运行
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="JobName"></param>
        /// <param name="SimpleTime"></param>
        /// <returns></returns>
        public static DateTimeOffset AddJob<T>(string JobName, DateTimeOffset StartTime, TimeSpan SimpleTime) where T : IJob
        {
            return AddJob<T>(JobName, StartTime, SimpleTime, new Dictionary<string, object>());
        }

        /// <summary>
        /// 添加Job 并且以周期的形式运行
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="JobName"></param>
        /// <param name="StartTime"></param>
        /// <param name="SimpleTime">毫秒数</param>
        /// <param name="jobDataMap"></param>
        /// <returns></returns>
        public static DateTimeOffset AddJob<T>(string JobName, DateTimeOffset StartTime, int SimpleTime, string MapKey, object MapValue) where T : IJob
        {
            Dictionary<string, object> map = new Dictionary<string, object>();
            map.Add(MapKey, MapValue);
            return AddJob<T>(JobName, StartTime, TimeSpan.FromMilliseconds(SimpleTime), map);
        }

        /// <summary>
        /// 添加Job 并且以周期的形式运行
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="JobName">JobKey</param>
        /// <param name="StartTime">开始时间</param>
        /// <param name="SimpleTime">时间差</param>
        /// <param name="jobDataMap">传递的参数</param>
        /// <returns></returns>
        public static DateTimeOffset AddJob<T>(string JobName, DateTimeOffset StartTime, TimeSpan SimpleTime, Dictionary<string, object> map) where T : IJob
        {
            IJobDetail jobCheck = JobBuilder.Create<T>().WithIdentity(JobName, JobName + "_Group").Build();
            jobCheck.JobDataMap.PutAll(map);
            ISimpleTrigger triggerCheck = new SimpleTriggerImpl(JobName + "_SimpleTrigger", JobName + "_TriggerGroup",
                                        StartTime,
                                        null,
                                        SimpleTriggerImpl.RepeatIndefinitely,
                                        SimpleTime);
            return sched.ScheduleJob(jobCheck, triggerCheck);
        }

        /// <summary>
        /// 修改触发器时间,需要job名,以及修改结果
        /// CronTriggerImpl类型触发器
        /// </summary>
        public static void UpdateTime(string jobName, string CronTime)
        {
            TriggerKey TKey = new TriggerKey(jobName + "_CronTrigger", jobName + "_TriggerGroup");
            CronTriggerImpl cti = sched.GetTrigger(TKey) as CronTriggerImpl;
            cti.CronExpression = new CronExpression(CronTime);
            sched.RescheduleJob(TKey, cti);
        }

        /// <summary>
        /// 修改触发器时间,需要job名,以及修改结果
        /// SimpleTriggerImpl类型触发器
        /// </summary>
        /// <param name="jobName"></param>
        /// <param name="SimpleTime">分钟数</param>
        public static void UpdateTime(string jobName, int SimpleTime)
        {
            UpdateTime(jobName, TimeSpan.FromMinutes(SimpleTime));
        }

        /// <summary>
        /// 修改触发器时间,需要job名,以及修改结果
        /// SimpleTriggerImpl类型触发器
        /// </summary>
        public static void UpdateTime(string jobName, TimeSpan SimpleTime)
        {
            TriggerKey TKey = new TriggerKey(jobName + "_SimpleTrigger", jobName + "_TriggerGroup");
            SimpleTriggerImpl sti = sched.GetTrigger(TKey) as SimpleTriggerImpl;
            sti.RepeatInterval = SimpleTime;
            sched.RescheduleJob(TKey, sti);
        }

        /// <summary>
        /// 暂停所有Job
        /// </summary>
        public static void PauseAll()
        {
            sched.PauseAll();
        }

        /// <summary>
        /// 恢复所有Job
        /// </summary>
        public static void ResumeAll()
        {
            sched.ResumeAll();
        }

        /// <summary>
        /// 暂停某个任务
        /// </summary>
        /// <param name="JobName"></param>
        public static void PauseJob(string JobName)
        {
            JobKey jk = new JobKey(JobName);
            sched.PauseJob(jk);
        }
        
        /// <summary>
        /// 恢复指定的Job
        /// </summary>
        /// <param name="JobKey"></param>
        public static void ResumeJob(string JobName)
        {
            JobKey jk = new JobKey(JobName);
            sched.ResumeJob(jk);
        }
      
        /// <summary>
        /// 删除Job
        /// </summary>
        /// <param name="JobName"></param>
        public static void DeleteJob(string JobName)
        {
            JobKey jk = new JobKey(JobName);
            sched.DeleteJob(jk);
        }

        /// <summary>
        /// 卸载定时器
        /// </summary>
        /// <param name="waitForJobsToComplete">是否等待job执行完成</param>
        public static void Shutdown(bool waitForJobsToComplete)
        {
            sched.Shutdown(waitForJobsToComplete);
        }
    }
}


这个是我定义的Quartz的工厂类，写了几种方式的建立任务，一般来说都是用的cron表达式来建立的，因为呢这样比较方便，灵活。就是下面这个方式

  public static DateTimeOffset AddJob <T>（string JobName，string CronTime，string connIds）其中T：IJob
        {
            IJobDetail jobCheck = JobBuilder.Create<T>().WithIdentity(JobName, JobName + "_Group").UsingJobData("connIds", connIds).Build();
            ICronTrigger CronTrigger = new CronTriggerImpl(JobName + "_CronTrigger", JobName + "_TriggerGroup", CronTime);
            return sched.ScheduleJob(jobCheck, CronTrigger);
        }

IJobDetail是用于创建一个Job详情，包括Job名称，Job组，Job参数 “connIds”就是我传递的参数

ICronTrigger就是写入cron表达式的，关于cron表达式的格式参考下这个

https://blog.csdn.net/li295214001/article/details/52065634

然后工厂类就定义好了，其他的扩展方法还有很多，就没有一一说明了

3.定义Job

using Microsoft.AspNet.SignalR;
using Microsoft.AspNet.SignalR.Hubs;
using Quartz;
using System.Collections.Generic;

namespace Berry.SignalRService.Schedu.Jobs
{
    /// <summary>
    /// 赛事推送
    /// </summary>
    public class MatchJob : IJob
    {
        /// <summary>
        /// 系统缓存
        /// </summary>
        private readonly Cache.WebCache _cache = new Cache.WebCache();

        private IHubConnectionContext<dynamic> Clients { get; set; }

        private MatchJob(IHubConnectionContext<dynamic> clients)
        {
            Clients = clients;
        }

        /// <summary>
        /// 执行函数
        /// </summary>
        /// <param name="context"></param>
        public void Execute(IJobExecutionContext context)
        {
            try
            {
                JobKey jobkey = context.JobDetail.Key;
                //系统缓存的之前已经查出来的数据
                var cachedata = _cache.GetCache<string>(jobkey.ToString() + "__JobDataCache");
                //datamap里存的数据，现在是存的connid
                string connIds = context.JobDetail.JobDataMap.GetString("connIds");
                string[] connidList = connIds.Split(',');

                //TODO  从数据库查询数据最新加的数据然后添加到__JobDataCache缓存
                cachedata += "";




                //将查出来的数据写入到缓存，覆盖之前的缓存
                _cache.WriteCache(cachedata, jobkey.ToString() + "__JobDataCache");

                //向所有开启服务的客户端推送查询到的数据
                foreach (var connId in connidList)
                {
                    Clients.Client(connId).BroadcastJobOpened(cachedata);
                }
               
            }
            catch (System.Exception e)
            {
                throw new HubException("发送消息发生异常.", new {  message = e.Message });

            }

        }
    }


    /// <summary>
    /// 新闻推送
    /// </summary>
    public class NewsJob : IJob
    {
        /// <summary>
        /// 系统缓存
        /// </summary>
        private readonly Cache.WebCache _cache = new Cache.WebCache();

        private IHubConnectionContext<dynamic> Clients { get; set; }

        private NewsJob(IHubConnectionContext<dynamic> clients)
        {
            Clients = clients;
        }

        /// <summary>
        /// 执行函数
        /// </summary>
        /// <param name="context"></param>
        public void Execute(IJobExecutionContext context)
        {
            try
            {
                JobKey jobkey = context.JobDetail.Key;
                //系统缓存的之前已经查出来的数据
                var cachedata = _cache.GetCache<string>(jobkey.ToString() + "__JobDataCache");
                //datamap里存的数据，现在是存的connid
                string connIds = context.JobDetail.JobDataMap.GetString("connIds");
                string[] connidList = connIds.Split(',');

                //TODO  从数据库查询数据最新加的数据然后添加到__JobDataCache缓存
                cachedata += "";




                //将查出来的数据写入到缓存，覆盖之前的缓存
                _cache.WriteCache(cachedata, jobkey.ToString() + "__JobDataCache");

                //向所有开启服务的客户端推送查询到的数据
                foreach (var connId in connidList)
                {
                    Clients.Client(connId).BroadcastJobOpened(cachedata);
                }

            }
            catch (System.Exception e)
            {
                throw new HubException("发送消息发生异常.", new { message = e.Message });

            }

        }
    }

    /// <summary>
    /// 系统推送
    /// </summary>
    public class SysJob : IJob
    {
        /// <summary>
        /// 系统缓存
        /// </summary>
        private readonly Cache.WebCache _cache = new Cache.WebCache();

        private IHubConnectionContext<dynamic> Clients { get; set; }

        private SysJob(IHubConnectionContext<dynamic> clients)
        {
            Clients = clients;
        }

        /// <summary>
        /// 执行函数
        /// </summary>
        /// <param name="context"></param>
        public void Execute(IJobExecutionContext context)
        {
            try
            {
                JobKey jobkey = context.JobDetail.Key;
                //系统缓存的之前已经查出来的数据
                var cachedata = _cache.GetCache<string>(jobkey.ToString() + "__JobDataCache");
                //datamap里存的数据，现在是存的connid
                string connIds = context.JobDetail.JobDataMap.GetString("connIds");
                string [] connidList = connIds.Split（'，'）;

                // TODO从数据库查询数据最新加的数据然后添加到__JobDataCache缓存
                cachedata + =“”;



 //将查出来的数据写入到缓存，覆盖之前的缓存 _cache.WriteCache（cachedata，jobkey.ToString（）+“__ JobDataCache”）; 
 //向所有开启服务的客户端推送查询到的数据 foreach（connidList中的var connId） {  Clients.Client（CONNID）.BroadcastJobOpened（cachedata）;  } 
 }  catch（System.Exception e） {  抛出新的HubException（“发送消息发生异常。”，new {message = e.Message}）; 
 } 
 }  }  }

有几种类型的工作单独定义，执行函数可能不同。但是都要集成IJob类。

在执行函数里执行，可以获取到你传递的一个的JobDetail中的各个参数，用于你使用。


这样建立后就没有问题了，然后我用的实时推送是用的SignalR的直接推送给对应的用户的。做实时推送的话可以去看看，之后我也会更新一篇SignalR的用法~~

发现问题的欢迎大家指出来交流

花花花七
关注
专栏目录
Quartz在.Net网站中的使用方法
09-13
现在做一个B/S项目需要用到计划任务,本来想自定写一个的,写了几句,突然想看看网上有没有现成可以用的. 结果在苦寻之下找到了Quartz这个组件.看过之后感觉还不错.决定用它实现计划任务了. 再找找看有没有现成的任务.但找了大半天.大多数都是C/S结构中用的. 于是就把自已的写的Demo放到网上,供大家参考一下,如有不正确之 处,还请大家多多指教!
Quartz.net-定时任务 Demo
08-13
通过查看项目源代码，你可以学习到更多关于Quartz.NET实际应用的细节。 总之，Quartz.NET是一个功能强大的.NET定时任务框架，能够满足各种复杂的定时需求。通过学习和实践这个"Quartz.net-定时任务 Demo"，你将能够...
Quartz.net官方开发指南 第一课：使用Quartz.net
shanyou的专栏
08-16 881
使用scheduler之前应首先实例化它。使用SchedulerFactory可以完成scheduler的实例化。用户可直接地实例化这个工厂类并且直接使用工厂的实例（例如下面的例子）。 一旦一个scheduler被实例化，它就可以被启动(start),并且处于驻留模式，直到被关闭(shutdown)。注意，一旦scheduler被关闭（shutdown）,则它不能再重新启动，除非重新
Quartz.NET 入门
weixin_34220179的博客
07-09 751
概述 Quartz.NET是一个开源的作业调度框架，非常适合在平时的工作中，定时轮询数据库同步，定时邮件通知，定时处理数据等。 Quartz.NET允许开发人员根据时间间隔（或天）来调度作业。它实现了作业和触发器的多对多关系，还能把多个作业与不同的触发器关联。整合了 Quartz.NET的应用程序可以重用来自不同事件的作业，还可以为一个事件组合多个作业。 参考 官方学习文档：http://w...
Quartz.NET 的使用
weixin_30678821的博客
07-16 82
先貼使用代碼： 1 using Quartz; 2 using Quartz.Impl; 3 using Quartz.Logging; 4 using System; 5 using System.Collections.Specialized; 6 using System.Threading.Tasks; 7 8 names...
Quartz.NET的使用
u011298872的博客
02-15 1820
Quartz.NET是一款功能齐全的开源作业调度框架，小至的应用程序，大到企业系统都可以适用。Quartz是作者James House用JAVA语言编写的，而Quartz.NET是从Quartz移植过来的C#版本。** private void SendKCQ() { // 构造一个调度程序工厂 ISchedulerFactory schedFact = new StdSchedulerFactory(); //
.Net Core中使用Quartz.Net实践记录
10-18
Quartz.NET是一套很好的任务调度框架。下面这篇文章主要给大家介绍了关于.Net Core中使用Quartz.Net的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考借鉴，下面随着小编来一起学习学习吧
ASP.NET使用Quartz.NET实现定时任务调度
08-03
结合使用Quartz.NET和TopShelf，我们可以构建一个在Windows服务中运行的定时任务调度系统。 Quartz.NET的特性包括： 1. **灵活的调度**：Quartz.NET支持多种调度模式，如简单触发器、cron触发器，可以按照精确时间...
基于ASP.NET Core和Quartz.Net的后台批量定时任务处理系统设计源码
04-09
本项目是基于ASP.NET Core和Quartz.Net的后台批量定时任务处理系统设计源码，包含3706个文件，其中1476个SVG文件，1334个PNG文件，234个JavaScript文件，227个CSS文件，79个GIF文件，77个C#文件，37个LESS文件，36个...
Quartz.NET简单使用
三千幻想乡
08-29 3521
Quartz，中文是石英的意思，由此联想到石英钟，利用石英的某些特性制成的钟表。时间这种东西可以被高精度的计时器具切分为很小份。在每份时间中，我们都可以做一些事情，而怎么安排每份时间做什么事情，就是时间调度。因此正如上图里描述的那样，Quartz（.NET）是一个.NET开源的调度系统。它原本是流行的Java开源框架，移植到.NET就成Quartz.NET了。当然，这丝毫不影响它的强大。随便摘几句官网对它的描述，小到应用程序，大到企业系统都可以使用它。.........
Quartz.net
08-09
Quartz.NET是一个开源的作业调度框架，一个简单的使用vs2017开发的demo。
Quartz.NET
12-09
Quartz,自动线程,简单实例,适合新手启蒙!
Quartz.NET 2.6
09-30
Quartz.NET官方的实例代码，由官方与2017-07-30发布。
Quartz.NET-2.0
10-17
Quartz.NET框架的核心是调度器。调度器负责管理Quartz.NET应用运行时环境。Quartz不仅仅是线程和线程管理。为确保可伸缩性，Quartz.NET采用了基于多线程的架构。启动时，框架初始化一套worker线程，这套线程被调度器用来执行预定的作业。这就是Quartz.NET怎样能并发运行多个作业的原理。Quartz.NET依赖一套松耦合的线程池管理部件来管理线程环境。作业是一个执行任务的简单.NET类。只需实现Quartz.IJob接口，IJob接口包含唯一的一个方法Execute()，作业从这里开始执行。一旦实现了IJob接口和Execute ()方法，当Quartz.NET确定该是作业运行的时候，它将调用作业。Execute()方法内就是要做的事情。
Quartz3.0.1.0调用
01-29
Quartz3.0.1.0版本关于Job scheduling的简单调用，并集成log4net的使用
Quartz.Net使用教程
qq_35382207的博客
04-19 421
Quartz.Net使用教程 在项目的开发过程中，难免会遇见后需要后台处理的任务，例如定时发送邮件通知、后台处理耗时的数据处理等，这个时候你就需要Quartz.Net了。 Quartz.Net是纯净的，它是一个.Net程序集，是非常流行的Java作业调度系统Quartz的C#实现。 Quartz.Net一款功能齐全的任务调度系统，从小型应用到大型企业级系统都能适用。功能齐全体现在触发器的多样性上面，即支持简单的定时器，也支持Cron表达式；即能执行重复的作业任务，也支持指定例外的日历；任务也可以是多样性的.
.NET中使用Quartz
weixin_50478033的博客
09-21 1269
.NET中使用Quartz
Quartz.net使用入门(二)
极客神殿
09-07 2782
Windows服务+Quartz.netApp.config配置文件<?xml version="1.0"?> <configuration> <configSections> <sectionGroup name="JobList"> <section name="Job" type="Quartz入门Service.MyConfigHandler,Quartz入门Serv
【个人博客搭建】（18）使用Quartz.NET 定时备份数据库
最新发布
【PlateauSnow】的博客
05-06 443
Quartz.NET 定时备份数据库
使用Quartz.NET与Topshelf构建定时任务调度
"定时计划与调度任务的配置，包括使用Dapper的ORM，Nlog的日志系统，以及通过Quartz.NET和Topshelf实现的作业调度。项目还提供了在Visual Studio Installer Projects下创建桌面安装程序的功能。" 在IT领域，配置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值