定时处理组件---Quartz.net

1.认识任务调度

     所谓任务调度，就是以将业务区块任务化（即抽象成每个独立的任务，执行每一个任务便完成某种业务的需求）。好比，咱们有一个订单系统，如今有这样的一个需求，就是须要在某一时间点去扫描数据库，删掉垃圾订单。又好比，咱们想要在某一时刻去批量给用户推送信息，等等等等。如何去解决那？？咱们首先想到的是利用定时器或者是开线程独立扫描。这能够说是解决方案，可是若是是本身去实现，不免考虑的不周全。因而，Quartz.net应运而生。

2.Quartz.net了解

     Quartz.NET是java的Quartz移植过来的开源的做业调度框架的.net版本，是很是适合在平时的工做中，定时轮询数据库同步，定时邮件通知，定时处理数据等。 Quartz.NET容许开发人员根据时间间隔（或天）来调度做业。它实现了做业和触发器的多对多关系，还能把多个做业与不一样的触发器关联。整合了 Quartz.NET的应用程序能够重用来自不一样事件的做业，还能够为一个事件组合多个做业。其实使用起来很简单，只要了解其中的几个概念点，就能够轻松的使用。

    (1).Scheduler:调度器，用来将任务和触发器绑定关联起来的中枢系统。

  （2).Trigger:触发器，定义任务的执行条件。

  （3).JobDetail:任务构建模型，用来装载实现定义好的任务的。

3.Quartz.net使用

     使用nuget包管理器安装quartz.net，而后引用using Quartz、using Quartz.Impl.。其使用流程即是（继承IJob,重写Excute方法-->构建Scheduler-->构建JobDetail-->构建Trigger-->利用Scheduler绑定Trigger与JobDetail-->开启调度）接下来，咱们来熟悉一下核心的模型及api。

     IJob:任务基础接口，我没定义的每个任务，都须要继承该接口，并重写Excute方法，并在其中书写本身的业务逻辑。

     IScheduler：调度器；

     StdSchedulerFactory:调度器构建/获取工厂,咱们能够经过经过Scheduler = StdSchedulerFactory.GetDefaultScheduler();获取一个默认的调度器，经过Scheduler.Start()开启调度，而后经过 Scheduler.ScheduleJob("任务模型",“触发器模型”)来关联触发器与任务。

     ITrigger:触发器;

     TriggerBuilder:触发器构造器,经过ITrigger trigger =TriggerBuilder.Create().WithIdentity("触发器名称,"“触发器分组名称”).WithCronSchedule("cron表达式，触发的条件").Build();构建一个触发器

     IJobDetail:任务模型。

     JobDetailBuilder:任务构造模型，经过  IJobDetail jobDetail = JobBuilder.Create("自定义的任务对象类型").SetJobData("要传给任务的执行所需的参数对象").WithIdentity("任务名称", "任务分组名").Build();

4.Quartz.net的简单封装

    这里，我对基础api简单的封装啦一下，方便使用(JobConfig-->任务参数配置模型,QuartzUtil-->核心帮助文件）。

    

/// <summary>
/// 任务配置对象
/// </summary>
public class JobConfig
    {
        public JobConfig()
        {
            JobDataMap = new JobDataMap();
        }
        
        public string JobName { get; set; }//任务名称
        public string JobGroup { get; set; }//任务分组名
        public string TriggerName { get; set; }//触发器名
        public string TriggerGroup { get; set; }//触发器分组名
        public string CronExpression { get; set; }//cron表达式
        public Type JobType { get; set; }//任务类型
        public JobDataMap JobDataMap { get; set; } //任务参数map
        
    }

　　

public class QuartzUtil
    {
        private static IScheduler Scheduler { get; set; }
        static QuartzeUtil()
        {
            Scheduler = StdSchedulerFactory.GetDefaultScheduler();
            Scheduler.Start();
        }
        /// <summary>
        /// 添加任务
        /// </summary>
        /// <param name="jobConfig"></param>
        /// <returns></returns>
        public static bool AddJob(JobConfig jobConfig)
        {
            try
            {
                ITrigger trigger = TriggerBuilder.Create()
                              .WithIdentity(jobConfig.TriggerName, jobConfig.TriggerGroup)
                              .WithCronSchedule(jobConfig.CronExpression).Build();
                IJobDetail jobDetail = JobBuilder.Create(jobConfig.JobType).SetJobData(jobConfig.JobDataMap).WithIdentity(jobConfig.JobName, jobConfig.JobGroup).Build();
                Scheduler.ScheduleJob(jobDetail, trigger);
                return true;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return false;
            }


        }
        /// <summary>
        /// 构建cons表达式
        /// </summary>
        /// <param name="dateTime"></param>
        /// <returns></returns>
        public static string BuildConsExpression(DateTime dateTime)
        {
            return string.Format("{0} {1} {2} {3} {4} ? {5}", dateTime.Second, dateTime.Minute, dateTime.Hour, dateTime.Day, dateTime.Month, dateTime.Year);
        }
        /// <summary>
        /// 移除任务
        /// </summary>
        /// <param name="jobConfig"></param>
        /// <returns></returns>
        public static bool RemoveJob(JobConfig jobConfig)
        {

            try
            {
                TriggerKey triggerKey = new TriggerKey(jobConfig.TriggerName, jobConfig.TriggerGroup);
                Scheduler.PauseTrigger(triggerKey);
                Scheduler.ResumeTrigger(triggerKey);
                Scheduler.DeleteJob(JobKey.Create(jobConfig.JobName, jobConfig.JobGroup));
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }


        }
        /// <summary>
        /// 构建触发器
        /// </summary>
        /// <param name="triggerName"></param>
        /// <param name="groupName"></param>
        /// <param name="cronExpression"></param>
        /// <returns></returns>
        public static ITrigger BuildTrigger(string triggerName, string groupName, string cronExpression)
        {
            ITrigger trigger = TriggerBuilder.Create()
                                .WithIdentity(triggerName, groupName)
                                .WithCronSchedule(cronExpression).Build();
            return trigger;
        }
        /// <summary>
        /// 构建任务
        /// </summary>
        /// <param name="jobName"></param>
        /// <param name="groupName"></param>
        /// <param name="jobType"></param>
        /// <returns></returns>
        public static IJobDetail BuildJob(string jobName, string groupName, Type jobType)
        {
            IJobDetail jobDetail = JobBuilder.Create(jobType).WithIdentity(jobName, groupName).Build();
            return jobDetail;
        }
        /// <summary>
        /// 绑定任务与触发器
        /// </summary>
        /// <param name="jobDetail"></param>
        /// <param name="trigger"></param>
        public static void BindJobAndTrigger(IJobDetail jobDetail, ITrigger trigger)
        {

            Scheduler.ScheduleJob(jobDetail, trigger);
        }
    }