ASP.NET Core 任务调度----Quartz.NET

任务调度：Hangfire、Quartz.NET、FluentScheduler、Coravel、Quartzmin 可自由选择和学习

Quartz.NET具有三个主要概念：

job：运行的后台任务

trigger：控制后台任务运行的触发器。

scheduler：协调job和trigger

一、引入Nuget包 Quartz 注入调度工厂

//注册服务
builder.Services.AddSingleton();

二、创建一个IOC服务类为了能够让我们访问到 注入容器中的其他注入信息，因为Quartz有一个默认的生成job的工厂类Quartz.Simpl.SimpleJobFactory

using Quartz;
using Quartz.Spi;

namespace QuzrtzJob.Factory
{
    public class IOCJobFactory : IJobFactory
    {
        private readonly IServiceProvider _serviceProvider;
        public IOCJobFactory(IServiceProvider serviceProvider)
        {
            _serviceProvider = serviceProvider;
        }
        public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler)
        {
            return _serviceProvider.GetService(bundle.JobDetail.JobType) as IJob;

        }

        public void ReturnJob(IJob job)
        {
            var disposable = job as IDisposable;
            disposable?.Dispose();

        }
    }
}

三、创建一个启动Quartz服务的服务类

using Quartz;
using Quartz.Spi;

namespace QuzrtzJob.Factory
{
    public class QuartzFactory
    {
    	//1、声明一个调度工厂
        private ISchedulerFactory _schedulerFactory;
        private IScheduler _scheduler=default;
        private IJobFactory _IOCjobFactory;
        public QuartzFactory(ISchedulerFactory schedulerFactory,IJobFactory jobFactory) {
            _schedulerFactory = schedulerFactory;            
            _IOCjobFactory = jobFactory;
        }
        public async Task Start()
        {            
            //2、通过调度工厂获得调度器
            _scheduler = await _schedulerFactory.GetScheduler();
            //这里是指定容器仓库
            _scheduler.JobFactory = _IOCjobFactory;
            //3、开启调度器
            await _scheduler.Start();
            //4、创建一个触发器
            var trigger = TriggerBuilder.Create()
                            .WithSimpleSchedule(x => x.WithIntervalInSeconds(2).RepeatForever())//每两秒执行一次
                            .Build();
            //5、创建任务
            var jobDetail = JobBuilder.Create()
                            .WithIdentity("job", "group")
                            .Build();
            //6、将触发器和任务器绑定到调度器中
            await _scheduler.ScheduleJob(jobDetail, trigger);
            return await Task.FromResult("将触发器和任务器绑定到调度器中完成");
        }
    }
}

四、创建自己的任务，继承自IJob

    public class Job_Blogs_Quartz : JobBase, IJob
    {
        private readonly IBlogArticleServices _blogArticleServices;

        public Job_Blogs_Quartz(IBlogArticleServices blogArticleServices, ITasksQzServices tasksQzServices, ITasksLogServices tasksLogServices)
            : base(tasksQzServices, tasksLogServices)
        {
            _blogArticleServices = blogArticleServices;
        }
        public async Task Execute(IJobExecutionContext context)
        {
            var executeLog = await ExecuteJob(context, async () => await Run(context));
        }
        public async Task Run(IJobExecutionContext context)
        {
            System.Console.WriteLine($"Job_Blogs_Quartz 执行 {DateTime.Now.ToShortTimeString()}");
            var list = await _blogArticleServices.Query();
            // 也可以通过数据库配置，获取传递过来的参数
            JobDataMap data = context.JobDetail.JobDataMap;
            //int jobId = data.GetInt("JobParam");
        }
    }

五、 Program.cs注入任务，也可以通过反射注入

builder.Services.AddSingleton();
builder.Services.AddSingleton();
builder.Services.AddSingleton();
或者自定义类反射注入
    //任务注入
    var baseType = typeof(IJob);
    var path = AppDomain.CurrentDomain.RelativeSearchPath ?? AppDomain.CurrentDomain.BaseDirectory;
    var referencedAssemblies = System.IO.Directory.GetFiles(path, "Quartz.Tasks.Core.dll").Select(Assembly.LoadFrom).ToArray();
    var types = referencedAssemblies
        .SelectMany(a => a.DefinedTypes)
        .Select(type => type.AsType())
        .Where(x => x != baseType && baseType.IsAssignableFrom(x)).ToArray();
    var implementTypes = types.Where(x => x.IsClass).ToArray();
    foreach (var implementType in implementTypes)
    {
        services.AddTransient(implementType);
    }

6、创建启动类

    //获取容器中的QuartzFactory
    var quartz = app.Services.GetRequiredService();
    app.Lifetime.ApplicationStarted.Register(async () =>
    {
       await quartz.Start();
    });

    app.Lifetime.ApplicationStopped.Register(() =>
    {
        //Quzrtz关闭方法
        //quartz.Stop();
    });

生成cron：http://cron.ciding.cc/

参考：https://blog.csdn.net/qq_44965678/article/details/122159501

          https://blog.csdn.net/xiaolu1014/article/details/103863979