AspNet Core上实现web定时任务实例

//----------------选自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]);
}

// -------每小时将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.");
 }
 ......
 }

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)
 {
 }
 }
}

//-------------------------------截取自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);
}