十七、.net core（.NET 6）搭建基于Quartz组件的定时调度任务

搭建基于Quartz组件的定时调度任务

先在package包项目下，添加Quartz定时器组件：

新建类库项目Wsk.Core.QuartzNet,并且引用包类库项目。然后新建一个中间调度类，叫QuartzMiddleJob:

中间Job源码：

 public class QuartzMiddleJob : IJob

    {

        private readonly IServiceProvider _serviceProvider;

        public QuartzMiddleJob(IServiceProvider serviceProvider)

        {

            _serviceProvider = serviceProvider;

        }

        public async Task Execute(IJobExecutionContext context)

        {

            using (var scope = _serviceProvider.CreateScope())

            {

                var jobType = context.JobDetail.JobType;

                var job = scope.ServiceProvider.GetRequiredService(jobType) as IJob;

                await job.Execute(context);

            }

        }

    }

新建一个Job工厂类，叫WeskyJobFactory，用来获取刚刚创建的中间调度类的服务：

新建一个通用执行计划类，叫WeskyJobSchedule，用于每次任务都通过该计划进行生成：

计划类和枚举源码：

 public class WeskyJobSchedule

    {

        public WeskyJobSchedule(Type jobType, string cronExpression)

        {

            this.JobType = jobType ?? throw new ArgumentNullException(nameof(jobType));

            CronExpression = cronExpression ?? throw new ArgumentNullException(nameof(cronExpression));

        }

        /// <summary>

        /// Job类型

        /// </summary>

        public Type JobType { get; private set; }

        /// <summary>

        /// Cron表达式

        /// </summary>

        public string CronExpression { get; private set; }

        /// <summary>

        /// Job状态

        /// </summary>

        public JobStatus JobStatu { get; set; } = JobStatus.Init;

    }

    /// <summary>

    /// 运行状态

    /// </summary>

    public enum JobStatus : byte

    {

        [Description("Initialization")]

        Init = 0,

        [Description("Running")]

        Running = 1,

        [Description("Scheduling")]

        Scheduling = 2,

        [Description("Stopped")]

        Stopped = 3,

    }

现在添加一个任务，新建任务类 MyJobs，并且继承自IJob，然后在Excute方法里面，就是该任务执行调度时候会进去执行的了：

似乎上面哪儿感觉不太对，咱们把原来的Job工厂里面到代码稍微调整下如下：

NewJob源码：

 public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler)

        {

            return _serviceProvider.GetRequiredService(bundle.JobDetail.JobType) as IJob;

        }

现在新增一个静态类QuartzJobService，用来当做调度任务的中间启动项，并且把有关的一些服务注册进来：

对应源码：

  public static class QuartzJobService

    {

        public static void AddQuartzJobService(this IServiceCollection services)

        {

            if (services == null)

            {

                throw new ArgumentNullException(nameof(services));

            }

            services.AddSingleton<IJobFactory, WeskyJobFactory>();

            services.AddSingleton<ISchedulerFactory, StdSchedulerFactory>();

            services.AddSingleton<QuartzMiddleJob>();

            services.AddSingleton<MyJobs>();

            services.AddSingleton(

                new WeskyJobSchedule(typeof(MyJobs), "0/1 * * * * ? ")

          );

            services.AddHostedService<WeskyJobHostService>();

        }

    }

最后，还少了个启动项，用来程序启动的时候，进行启动定时调度任务。新建类 WeskyJobHostService ，并且新建创建调度任务方法 CreateJob和触发器方法CreateTrigger：

然后，在开始和结束方法内：

以上源码如下：

  public class WeskyJobHostService: IHostedService

    {

        private readonly ISchedulerFactory _schedulerFactory;

        private readonly IJobFactory _jobFactory;

        private readonly IEnumerable<WeskyJobSchedule> _jobSchedules;

        public WeskyJobHostService(ISchedulerFactory schedulerFactory, IJobFactory jobFactory, IEnumerable<WeskyJobSchedule> jobSchedules)

        {

            _schedulerFactory = schedulerFactory ?? throw new ArgumentNullException(nameof(schedulerFactory));

            _jobFactory = jobFactory ?? throw new ArgumentNullException(nameof(jobFactory));

            _jobSchedules = jobSchedules ?? throw new ArgumentNullException(nameof(jobSchedules));

        }

        public IScheduler Scheduler { get; set; }

        public async Task StartAsync(CancellationToken cancellationToken)

        {

            Scheduler = await _schedulerFactory.GetScheduler(cancellationToken);

            Scheduler.JobFactory = _jobFactory;

            foreach (var jobSchedule in _jobSchedules)

            {

                var job = CreateJob(jobSchedule);

                var trigger = CreateTrigger(jobSchedule);

                await Scheduler.ScheduleJob(job, trigger, cancellationToken);

                jobSchedule.JobStatu = JobStatus.Scheduling;

            }

            await Scheduler.Start(cancellationToken);

            foreach (var jobSchedule in _jobSchedules)

            {

                jobSchedule.JobStatu = JobStatus.Running;

            }

        }

        public async Task StopAsync(CancellationToken cancellationToken)

        {

            await Scheduler?.Shutdown(cancellationToken);

            foreach (var jobSchedule in _jobSchedules)

            {

                jobSchedule.JobStatu = JobStatus.Stopped;

            }

        }

        private static IJobDetail CreateJob(WeskyJobSchedule schedule)

        {

            var jobType = schedule.JobType;

            return JobBuilder

                .Create(jobType)

                .WithIdentity(jobType.FullName)

                .WithDescription(jobType.Name)

                .Build();

        }

        private static ITrigger CreateTrigger(WeskyJobSchedule schedule)

        {

            return TriggerBuilder

                .Create()

                .WithIdentity($"{schedule.JobType.FullName}.trigger")

                .WithCronSchedule(schedule.CronExpression)

                .WithDescription(schedule.CronExpression)

                .Build();

        }

    }