ASP.NET Core2.2+Quartz.Net 實現web定時任務

時間 2019-11-16

標籤 asp.net asp core2.2+quartz.net core quartz 實現 web 定時任務欄目 ASP 简体版

原文原文鏈接

做爲一枚後端程序狗，項目實踐常遇到定時任務的工做，最容易想到的的思路就是利用Windows計劃任務/wndows service程序/Crontab程序等主機方法在主機上部署定時任務程序/腳本。web

可是不少時候，若使用的是共享主機或者受控主機，這些主機不容許你私自安裝exe程序、Windows服務程序。redis

碼甲會想到在web程序中作定時任務，目前有兩個方向：sql

①.AspNetCore自帶的HostService，這是一個輕量級的後臺服務，須要搭配timer完成定時任務數據庫

②.老牌Quartz.Net組件，支持複雜靈活的Scheduling、支持ADO/RAM Job任務存儲、支持集羣、支持監聽、支持插件。後端

此處咱們的項目使用稍複雜的Quartz.net實現web定時任務。架構

項目背景

最近須要作一個計數程序：採用redis計數，設定每小時將當日累積數據持久化到關係型數據庫sqlite。app

添加Quartz.Net Nuget 依賴包：<PackageReference Include="Quartz" Version="3.0.6" />

①.定義定時任務內容： Jobasync

②.設置觸發條件： Triggeride

③.將Quartz.Net集成進AspNet Core函數

頭腦風暴

IScheduler類包裝了上述背景須要完成的第①②點工做，SimpleJobFactory定義了生成指定的Job任務的過程，這個行爲是利用反射機制調用無參構造函數構造出的Job實例。下面是源碼：

//----------------選自Quartz.Simpl.SimpleJobFactory類-------------
using System;
using Quartz.Logging;
using Quartz.Spi;
using Quartz.Util;
namespace Quartz.Simpl
{
    /// <summary> 
    /// The default JobFactory used by Quartz - simply calls 
    /// <see cref="ObjectUtils.InstantiateType{T}" /> on the job class.
    /// </summary>
    /// <seealso cref="IJobFactory" />
    /// <seealso cref="PropertySettingJobFactory" />
    /// <author>James House</author>
    /// <author>Marko Lahma (.NET)</author>
    public class SimpleJobFactory : IJobFactory
    {
        private static readonly ILog log = LogProvider.GetLogger(typeof (SimpleJobFactory));

        /// <summary>
        /// Called by the scheduler at the time of the trigger firing, in order to
        /// produce a <see cref="IJob" /> instance on which to call Execute.
        /// </summary>
        /// <remarks>
        /// It should be extremely rare for this method to throw an exception -
        /// basically only the case where there is no way at all to instantiate
        /// and prepare the Job for execution.  When the exception is thrown, the
        /// Scheduler will move all triggers associated with the Job into the
        /// <see cref="TriggerState.Error" /> state, which will require human
        /// intervention (e.g. an application restart after fixing whatever
        /// configuration problem led to the issue with instantiating the Job).
        /// </remarks>
        /// <param name="bundle">The TriggerFiredBundle from which the <see cref="IJobDetail" />
        ///   and other info relating to the trigger firing can be obtained.</param>
        /// <param name="scheduler"></param>
        /// <returns>the newly instantiated Job</returns>
        /// <throws>  SchedulerException if there is a problem instantiating the Job. </throws>
        public virtual IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler)
        {
            IJobDetail jobDetail = bundle.JobDetail;
            Type jobType = jobDetail.JobType;
            try
            {
                if (log.IsDebugEnabled())
                {
                    log.Debug($"Producing instance of Job '{jobDetail.Key}', class={jobType.FullName}");
                }

                return ObjectUtils.InstantiateType<IJob>(jobType);
            }
            catch (Exception e)
            {
                SchedulerException se = new SchedulerException($"Problem instantiating class '{jobDetail.JobType.FullName}'", e);
                throw se;
            }
        }

        /// <summary>
        /// Allows the job factory to destroy/cleanup the job if needed. 
        /// No-op when using SimpleJobFactory.
        /// </summary>
        public virtual void ReturnJob(IJob job)
        {
            var disposable = job as IDisposable;
            disposable?.Dispose();
        }
    }
}

//------------------節選自Quartz.Util.ObjectUtils類-------------------------
 public static T InstantiateType<T>(Type type)
{
     if (type == null)
     {
          throw new ArgumentNullException(nameof(type), "Cannot instantiate null");
     }
     ConstructorInfo ci = type.GetConstructor(Type.EmptyTypes);
     if (ci == null)
     {
          throw new ArgumentException("Cannot instantiate type which has no empty constructor", type.Name);
     }
     return (T) ci.Invoke(new object[0]);
}

不少時候，定義的Job任務依賴了其餘組件（Job實例化時多參），此時默認的SimpleJobFactory不能知足實例化要求，須要考慮將Job任務做爲依賴注入組件，加入依賴注入容器。

關鍵思路：

① IScheduler 開放了JobFactory 屬性，便於你控制Job任務的實例化方式；

JobFactories may be of use to those wishing to have their application produce IJob instances via some special mechanism, such as to give the opportunity for dependency injection

② AspNet Core的服務架構是以依賴注入爲基礎的，利用ASPNET Core已有的依賴注入容器IServiceProvider管理Job任務的建立過程。

編碼實踐

① 定義Job內容：

// -------每小時將redis數據持久化到sqlite， 每日凌晨跳針，持久化昨天全天數據---------------------
public class UsageCounterSyncJob : IJob
{
        private readonly EqidDbContext _context;
        private readonly IDatabase _redisDB1;
        private readonly ILogger _logger;
        public UsageCounterSyncJob(EqidDbContext context, RedisDatabase redisCache, ILoggerFactory loggerFactory)
        {
            _context = context;
            _redisDB1 = redisCache[1];
            _logger = loggerFactory.CreateLogger<UsageCounterSyncJob>();
        }
         public async Task Execute(IJobExecutionContext context)
        {
            // 觸發時間在凌晨，則同步昨天的計數
            var _day = DateTime.Now.ToString("yyyyMMdd");
            if (context.FireTimeUtc.LocalDateTime.Hour == 0)
                _day = DateTime.Now.AddDays(-1).ToString("yyyyMMdd");

            await SyncRedisCounter(_day);
            _logger.LogInformation("[UsageCounterSyncJob] Schedule job executed.");
        }
        ......
 }

②註冊Job和Trigger：

namespace EqidManager
{
    using IOCContainer = IServiceProvider;
    // Quartz.Net啓動後註冊job和trigger
    public class QuartzStartup
    {
        public IScheduler _scheduler { get; set; }

        private readonly ILogger _logger;
        private readonly IJobFactory iocJobfactory;
        public QuartzStartup(IOCContainer IocContainer, ILoggerFactory loggerFactory)
        {
            _logger = loggerFactory.CreateLogger<QuartzStartup>();
            iocJobfactory = new IOCJobFactory(IocContainer);
            var schedulerFactory = new StdSchedulerFactory();
            _scheduler = schedulerFactory.GetScheduler().Result;
            _scheduler.JobFactory = iocJobfactory;
        }

        public void Start()
        {
            _logger.LogInformation("Schedule job load as application start.");
            _scheduler.Start().Wait();

            var UsageCounterSyncJob = JobBuilder.Create<UsageCounterSyncJob>()
               .WithIdentity("UsageCounterSyncJob")
               .Build();

            var UsageCounterSyncJobTrigger = TriggerBuilder.Create()
                .WithIdentity("UsageCounterSyncCron")
                .StartNow()
                // 每隔一小時同步一次
                .WithCronSchedule("0 0 * * * ?")      // Seconds,Minutes,Hours，Day-of-Month，Month，Day-of-Week，Year（optional field）
                .Build();
            _scheduler.ScheduleJob(UsageCounterSyncJob, UsageCounterSyncJobTrigger).Wait();

            _scheduler.TriggerJob(new JobKey("UsageCounterSyncJob"));
        }

        public void Stop()
        {
            if (_scheduler == null)
            {
                return;
            }

            if (_scheduler.Shutdown(waitForJobsToComplete: true).Wait(30000))
                _scheduler = null;
            else
            {
            }
            _logger.LogCritical("Schedule job upload as application stopped");
        }
    }

    /// <summary>
    /// IOCJobFactory ：實如今Timer觸發的時候注入生成對應的Job組件
    /// </summary>
    public class IOCJobFactory : IJobFactory
    {
        protected readonly IOCContainer Container;

        public IOCJobFactory(IOCContainer container)
        {
            Container = container;
        }

        //Called by the scheduler at the time of the trigger firing, in order to produce
        //     a Quartz.IJob instance on which to call Execute.
        public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler)
        {
            return Container.GetService(bundle.JobDetail.JobType) as IJob;
        }

        // Allows the job factory to destroy/cleanup the job if needed.
        public void ReturnJob(IJob job)
        {
        }
    }
}

③結合AspNet Core 注入組件；綁定Quartz.Net

//-------------------------------截取自Startup文件------------------------
......
services.AddTransient<UsageCounterSyncJob>();      // 這裏使用瞬時依賴注入
services.AddSingleton<QuartzStartup>();
......

// 綁定Quartz.Net
public void Configure(IApplicationBuilder app, Microsoft.AspNetCore.Hosting.IApplicationLifetime lifetime, ILoggerFactory loggerFactory)
{
     var quartz = app.ApplicationServices.GetRequiredService<QuartzStartup>();
     lifetime.ApplicationStarted.Register(quartz.Start);
     lifetime.ApplicationStopped.Register(quartz.Stop);
}