天天看点

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

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

先在package包项目下,添加Quartz定时器组件:

十七、.net core(.NET 6)搭建基于Quartz组件的定时调度任务
新建类库项目Wsk.Core.QuartzNet,并且引用包类库项目。然后新建一个中间调度类,叫QuartzMiddleJob:
十七、.net core(.NET 6)搭建基于Quartz组件的定时调度任务
中间Job源码:
十七、.net core(.NET 6)搭建基于Quartz组件的定时调度任务
十七、.net core(.NET 6)搭建基于Quartz组件的定时调度任务

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

View Code

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

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

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

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

计划类和枚举源码:

十七、.net core(.NET 6)搭建基于Quartz组件的定时调度任务
十七、.net core(.NET 6)搭建基于Quartz组件的定时调度任务
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方法里面,就是该任务执行调度时候会进去执行的了:

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

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

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

NewJob源码:

public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler)
        {
            return _serviceProvider.GetRequiredService(bundle.JobDetail.JobType) as IJob;
        }      

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

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

对应源码:

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:

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

然后,在开始和结束方法内:

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

以上源码如下:

十七、.net core(.NET 6)搭建基于Quartz组件的定时调度任务
十七、.net core(.NET 6)搭建基于Quartz组件的定时调度任务
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();
        }
    }      

切回QuartzJobService,在 AddQuartzJobService 方法的最下方,添加上面启动服务的注册:

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

最后,在启动项目里面,添加对Wsk.CoreQuartz项目的引用,然后在WskService服务类下,添加对AddQuartzJobService服务的注册:

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

启动项目,看看效果:

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

由此可见,我们设置的每秒一次触发效果达成。为了检验是不是可以避免同一个调度任务产生并发,在调度任务方法里面,设置一个延时,看看效果:

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

运行结果:

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

说明在当前任务还没有完成的情况下,不会重复进入。如果要允许重复进,只需要把类上面的DisallowConcurrentExecution 标签注释掉就可以。

现在还原回去,然后在Cron表达式改写成定时10秒,看看效果:

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

以上就是本篇使用QuartzNet的全部内容,仅用于入门参考。对于其他定时用法、以及各种比较飘的使用,各位大佬可以自行变种。如果有什么建议或意见,也欢迎留言~~

欢迎加入QQ群:

群号:1079830632

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