如何在 ASP.NET 中使用 Quartz.NET

当咱们在web开发中，经常会遇到这么一个需求，在后台执行某一项具体的任务，具体的说就是这些任务必须在后台定时执行。

Quartz.NET 是一个开源的 JAVA 移植版，它有着悠久的历史而且提供了强大的 Cron 表达式，这篇咱们就来讨论如何在 ASP.NET Core 中使用 Quartz.NET 去执行一些后台任务。

安装 Quartz.NET

要想使用 Quartz.NET，你可使用 Visual Studio 2019 中的 NuGet package manager 可视化界面进行安装，或者经过 NuGet package manager console 命令行输入以下命令：

Install-Package Quartz

Quartz.NET 中的Job,triggers 和 Schedulers

Quartz.NET 里有三个很是重要的概念：任务，触发器 和 调度器，对应着 Job，Trigger 和 Schedulers，Job 表示一个你须要被执行的任务，任务中能够写上你的业务逻辑代码，Job 就是一个实现了 IJob 接口的子类，以下代码所示：

class Job : IJob
    {
        public Task Execute(IJobExecutionContext context)
        {
            throw new NotImplementedException();
        }
    }

Trigger 一般用于指定一个 job 是如何被调度的？ 什么意思呢？ 好比说：这个job是按天执行？ 仍是按小时执行？仍是按秒执行？值得注意的是由于支持了 Cron 表达式，还可以实现更加超级复杂的调度逻辑。

Scheduler 一般按照你预先设置的调度规则将 job 丢给它的任务队列，并按照 trigger 规则轮询而后执行任务。

建立 Scheduler

在 Quartz.NET 中能够建立多个 Scheduler，但为了演示目的我就建立一个 Scheduler 啦，下面的代码展现了如何去建立 Scheduler。

var scheduler = StdSchedulerFactory.GetDefaultScheduler().GetAwaiter().GetResult();

一旦使用上面的代码建立好了 Scheduler，接下来就能够将其做为服务注入到 Asp.net Core 的 IOC 容器中，实现代码以下：

public void ConfigureServices(IServiceCollection services)
        {
            var scheduler = StdSchedulerFactory.GetDefaultScheduler().GetAwaiter().GetResult();

            services.AddSingleton(scheduler);
            services.AddRazorPages();
        }

开启和中止 scheduler

为了方便实现 开启 和 中止 功能，我准备封装一个 hosting service 类，作法就是从 IHostingService 接口派生出一个 CustomQuartzHostedService 类，完整代码以下：

public class CustomQuartzHostedService : IHostedService
{
        private readonly IScheduler _scheduler;
        public CustomQuartzHostedService(IScheduler scheduler)
        {
            _scheduler = scheduler;
        }
        public async Task StartAsync(CancellationToken cancellationToken)
        {
            await _scheduler?.Start(cancellationToken);
        }
        public async Task StopAsync(CancellationToken cancellationToken)
        {
            await _scheduler?.Shutdown(cancellationToken);
        }
 }

有了这个自定义类，接下来把这个类也注入到 servcies collection 中，实现代码以下：

public void ConfigureServices(IServiceCollection services)
        {
            var scheduler = StdSchedulerFactory.GetDefaultScheduler().GetAwaiter().GetResult();

            services.AddSingleton(scheduler);
            services.AddHostedService<CustomQuartzHostedService>();
            services.AddRazorPages();
        }

建立 job

正如以前说到的，job 是一个实现了 IJob 接口 而且实现了 Execute() 的类，这个 Execute() 方法接收一个 IJobExecutionContext 参数。

下面的代码片断展现了这个 Job 类包含了一个异步方式的 Execute() 方法，这个方法中包含的代码就是你须要执行的业务逻辑。

[DisallowConcurrentExecution]
    public class NotificationJob : IJob
    {
        private readonly ILogger<NotificationJob> _logger;
        public NotificationJob(ILogger<NotificationJob> logger)
        {
            _logger = logger;
        }
        public Task Execute(IJobExecutionContext context)
        {
            _logger.LogInformation("Hello world!");
            return Task.CompletedTask;
        }
    }

建立 job 工厂

若是要定义一个 Job 工厂，则必需要实现 IJobFactory 接口中的 NewJob() 和 ReturnJob() 方法，下面的代码片断展现了如何去 建立 和 返回 job 的 factory 类。

public class CustomQuartzJobFactory : IJobFactory
    {
        private readonly IServiceProvider _serviceProvider;
        public CustomQuartzJobFactory(IServiceProvider serviceProvider)
        {
            _serviceProvider = serviceProvider;
        }
        public IJob NewJob(TriggerFiredBundle triggerFiredBundle,
        IScheduler scheduler)
        {
            var jobDetail = triggerFiredBundle.JobDetail;
            return (IJob)_serviceProvider.GetService(jobDetail.JobType);
        }
        public void ReturnJob(IJob job) { }
    }

值得注意的是，这里我并无实现 job 池，若是你想实现这个功能，你须要修改如下 NewJob() 方法 而且重写 ReturnJob() 方法。

建立 JobMetadata 存储你的 job 元数据

我准备定义一个 JobMetadata 类去存储和job 相关联的元数据，好比说：job的id，job的name 等等，下面的代码展现了如何定义这么一个类。

public class JobMetadata
    {
        public Guid JobId { get; set; }
        public Type JobType { get; }
        public string JobName { get; }
        public string CronExpression { get; }
        public JobMetadata(Guid Id, Type jobType, string jobName,
        string cronExpression)
        {
            JobId = Id;
            JobType = jobType;
            JobName = jobName;
            CronExpression = cronExpression;
        }
    }

使用 hosted service 封装 Scheduler 的start和stop

接下来，我须要丰富一下 CustomQuartzHostedService 类，完整的代码清单以下。

public class CustomQuartzHostedService : IHostedService
    {
        private readonly ISchedulerFactory schedulerFactory;
        private readonly IJobFactory jobFactory;
        private readonly JobMetadata jobMetadata;
        public CustomQuartzHostedService(ISchedulerFactory schedulerFactory,JobMetadata jobMetadata,IJobFactory jobFactory)
        {
            this.schedulerFactory = schedulerFactory;
            this.jobMetadata = jobMetadata;
            this.jobFactory = jobFactory;
        }
        public IScheduler Scheduler { get; set; }
        public async Task StartAsync(CancellationToken cancellationToken)
        {
            Scheduler = await schedulerFactory.GetScheduler();
            Scheduler.JobFactory = jobFactory;
            var job = CreateJob(jobMetadata);
            var trigger = CreateTrigger(jobMetadata);
            await Scheduler.ScheduleJob(job, trigger, cancellationToken);
            await Scheduler.Start(cancellationToken);
        }
        public async Task StopAsync(CancellationToken cancellationToken)
        {
            await Scheduler?.Shutdown(cancellationToken);
        }
        private ITrigger CreateTrigger(JobMetadata jobMetadata)
        {
            return TriggerBuilder.Create()
                                 .WithIdentity(jobMetadata.JobId.ToString())
                                 .WithCronSchedule(jobMetadata.CronExpression)
                                 .WithDescription($"{jobMetadata.JobName}")
                                 .Build();
        }
        private IJobDetail CreateJob(JobMetadata jobMetadata)
        {
            return JobBuilder
            .Create(jobMetadata.JobType)
            .WithIdentity(jobMetadata.JobId.ToString())
            .WithDescription($"{jobMetadata.JobName}")
            .Build();
        }
    }

接下来再看一下 Startup.ConfigureServices 方法下的完整代码。

public void ConfigureServices(IServiceCollection services)
{
    services.AddRazorPages();
    services.AddSingleton<IJobFactory, CustomQuartzJobFactory>();
    services.AddSingleton<ISchedulerFactory, StdSchedulerFactory>();
    services.AddSingleton<NotificationJob>();
    services.AddSingleton(new JobMetadata(Guid.NewGuid(), typeof(NotificationJob),"Notification Job", "0/10 * * * * ?"));
    services.AddHostedService<CustomQuartzHostedService>();
}

这就是全部要作的事情，接下来运行应用程序，你会观察到 NotificationJob 的 Execute() 方法会每 10s 执行一次。

如何你的应用程序中须要有任务调用的功能，如今开始能够不须要使用Timer了，采用强大的 Quartz.NET 便可，并且还有一个🐂👃的功能就是：你能够把 job 持久化到 SQL Server, PostgreSQL, SQLite 中，太强大了。

译文连接： https://www.infoworld.com/art...

更多高质量干货：参见个人 GitHub: dotnetfly