在.NET6中使用配置Quartz.NET定时任务并使用IHostedService实现项目启动自动加载任务

　　1 简介

　　Quartz.Net是一个强大、开源、轻量的作业调度框架,在平时的项目开发当中也会时不时的需要运用到定时调度方面的功能，如果每天需要跑任务的话，你肯定不会写个while循环，里面进行任务作业吧，这样是很耗线程的，很耗资源的。所以就有目前的定时任务框架。

　　2 项目级配置思路

　　3 下载包并在program注入

　　// 1在api层下载包

　　//2注入配置

　　//3 net6中只有program类，直接在里面Build前面添加以下代码

　　builder.Services.AddQuartz(q =>

　　{

　　// base quartz scheduler, job and trigger configuration

　　});

　　// ASP.NET Core hosting

　　builder.Services.AddQuartzServer(options =>

　　{

　　// when shutting down we want jobs to complete gracefully

　　options.WaitForJobsToComplete = true;

　　});

　　4 任务的帮助类

　　第一步增加Corn表达式的帮助类，用于验证Corn输入是否合格

　　using Quartz.Impl.Triggers;

　　namespace common

　　{

　　public static class QuartzUtil

　　{

　　///

　　/// 验证 Cron 表达式是否有效

　　///

　　public static bool IsValidExpression(this string cronExpression)

　　{

　　try

　　{

　　var trigger = new CronTriggerImpl();

　　trigger.CronExpressionString = cronExpression;

　　var date = trigger.ComputeFirstFireTimeUtc(null);

　　return date != null;

　　}

　　catch //(Exception e)

　　{

　　return false;

　　}

　　第二步任务调度服务公共类，主要负责任务的运行和暂停(复制代码，有一些引用的错误，先不要管)

　　using Quartz;

　　using Quartz.Impl.Matchers;

　　namespace Common

　　{

　　///

　　/// 任务调度服务

　　///

　　public class QuartzJobService : ITransientSelfDependency

　　{

　　private readonly ISchedulerFactory _schedulerFactory;

　　private readonly ResultfulApiJobFactory _resultfulApiJobFactory;

　　public QuartzJobService(ISchedulerFactory schedulerFactory, ResultfulApiJobFactory resultfulApiJobFactory)

　　{

　　_schedulerFactory = schedulerFactory;

　　_resultfulApiJobFactory = resultfulApiJobFactory;

　　}

　　///

　　/// 开始运行一个调度器

　　///

　　public async Task RunAsync(Z_SyncModules tasks)

　　{

　　//1、通过调度工厂获得调度器

　　var scheduler = await _schedulerFactory.GetScheduler();

　　var taskName = $"{tasks.Id}>{tasks.ModuleName}";

　　//2、创建一个触发器

　　var trigger = TriggerBuilder.Create()

　　.WithIdentity(taskName, taskName)

　　.StartNow()

　　.WithDescription(tasks.Description)

　　// .WithSimpleSchedule(x => x.WithIntervalInSeconds((int)tasks.Frequency).RepeatForever())

　　触发表达式 0 0 0 1 1 ?

　　.WithCronSchedule(tasks.SyncTime)

　　.Build();

　　//3、创建任务

　　var jobDetail = JobBuilder.Create()

　　.WithIdentity(taskName, taskName)

　　.UsingJobData("TasksId", tasks.Id.ToString())

　　.Build();

　　//4、写入 Job 实例工厂解决 Job 中取 ioc 对象

　　scheduler.JobFactory = _resultfulApiJobFactory;

　　//5、将触发器和任务器绑定到调度器中

　　await scheduler.ScheduleJob(jobDetail, trigger);

　　//6、开启调度器

　　await scheduler.Start();

　　Console.WriteLine("运行成功：" + taskName);

　　return await Task.FromResult(true);

　　}

　　///

　　/// 关闭调度器

　　///

　　public async Task CloseAsync(Z_SyncModules tasks)

　　{

　　IScheduler scheduler = await _schedulerFactory.GetScheduler();

　　var taskName = $"{tasks.Id}>{tasks.ModuleName}";

　　var jobKeys = (await scheduler

　　.GetJobKeys(GroupMatcher.GroupEquals(taskName)))

　　.ToList().FirstOrDefault();

　　if (jobKeys == null )

　　{

　　MessageBox.Show($"未找到任务:{taskName}");

　　}

　　var triggers = await scheduler.GetTriggersOfJob(jobKeys);

　　ITrigger trigger = triggers?.Where(x => x.JobKey.Name == taskName).FirstOrDefault();

　　if (trigger == null)

　　{

　　MessageBox.Show($"未找到触发器:{taskName}");

　　}

　　await scheduler.PauseTrigger(trigger.Key);

　　await scheduler.UnscheduleJob(trigger.Key);// 移除触发器

　　await scheduler.DeleteJob(trigger.JobKey);

　　Console.WriteLine("关闭成功："+ taskName);

　　return await Task.FromResult(true);

　　}

　　第三步运行的方法，也就是任务运行的时候，需要指定一个类，继承 IJob,也就是我们都使用这个类去执行方法

　　using Quartz;

　　using System.Diagnostics;

　　namespace HZY.Quartz.Service.Jobs

　　{

　　///

　　/// Resultful 风格 Api Job

　　///

　　[DisallowConcurrentExecution]

　　public class ResultfulApiJob : IJob

　　{

　　private readonly ApiRequestService _apiRequestService;

　　private readonly IServiceProvider _provider;

　　private readonly ILogger _logger;

　　public ResultfulApiJob(ApiRequestService apiRequestService, ILogger logger, IServiceProvider provider)

　　{

　　_apiRequestService = apiRequestService;

　　_logger = logger;

　　_provider = provider;

　　}

　　public async Task Execute(IJobExecutionContext context)

　　{

　　try

　　{

　　Stopwatch _stopwatch = new Stopwatch();

　　_stopwatch.Restart();

　　var tasksId = context.MergedJobDataMap.GetString("TasksId")?.ToString();

　　if (string.IsNullOrWhiteSpace(tasksId))

　　{

　　_logger.LogError("tasksId 空!");

　　return;

　　}

　　Z_SyncModules tasks = null;

　　using (var scope = _provider.CreateScope())

　　{

　　// 解析你的作用域服务

　　var service = scope.ServiceProvider.GetService>();

　　tasks = await service.SelectNoTracking.FirstOrDefaultAsync(w=>w.Id==Guid.Parse(tasksId));

　　}

　　if (tasks == null)

　　{

　　_logger.LogError("tasks 空!");

　　return;

　　}

　　var time = DateTime.Now;

　　var taskId = tasks?.Id ?? Guid.Empty;

　　var text = $"{tasks.ModuleName}|组={tasks.ModuleName}|{time:yyyy-MM-dd}|StartTime={time: HH:mm:ss:fff}|";

　　var result = await _apiRequestService.RequestAsync("Post", tasks.ApiUrl);

　　if (!result.IsSuccess)

　　{

　　_logger.LogError($"Web Api RequestAsync(); 请求失败! WebApi 返回结果:{result.Message}");

　　}

　　_stopwatch.Stop();

　　var endTime = $"{DateTime.Now:HH:mm:ss:fff}";

　　//运行结束记录

　　text += $"EndTime={endTime}|{_stopwatch.ElapsedMilliseconds} 毫秒|结果={result.Message}";

　　}

　　catch (Exception ex)

　　{

　　var message = $@"Message={ex.Message}

　　StackTrace={ex.StackTrace}

　　Source={ex.Source}

　　_logger.LogError(ex, message, null);

　　}

　　第四步注入IJob实例，方便注入

　　using Quartz;

　　using Quartz.Spi;

　　namespace HZY.Services.Admin.QuartzJobTask

　　{

　　///

　　/// IJob 对象无法构造注入需要此类实现返回注入后得 Job 实例

　　///

　　public class ResultfulApiJobFactory : IJobFactory

　　{

　　private readonly IServiceProvider _serviceProvider;

　　public ResultfulApiJobFactory(IServiceProvider serviceProvider)

　　{

　　_serviceProvider = serviceProvider;

　　}

　　public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler)

　　{

　　//Job类型

　　Type jobType = bundle.JobDetail.JobType;

　　return _serviceProvider.GetService(jobType) as IJob;

　　}

　　public void ReturnJob(IJob job)

　　{

　　var disposable = job as IDisposable;

　　disposable?.Dispose();

　　}

　　第五步就是webapi的请求，也就是那些post,get请求

　　我这里直接用的开源框架 Flurl.Http

　　namespace Common

　　{

　　///

　　/// WebApi 请求服务

　　///

　　public class ApiRequestService : ITransientSelfDependency

　　{

　　private readonly ILogger _logger;

　　public ApiRequestService(ILogger logger)

　　{

　　_logger = logger;

　　}

　　///

　　/// 请求数据

　　///

　　public async Task<(bool IsSuccess, string Message)> RequestAsync(string requsetMode, string apiUrl, string headerKeyValue = null)

　　{

　　try

　　{

　　var headerKey = "HZY.Quartz.Job.Request";

　　var headerValue = "Success";

　　if (!string.IsNullOrWhiteSpace(headerKeyValue) && headerKeyValue.Contains("="))

　　{

　　headerKey = headerKeyValue.Split('=')[0];

　　headerValue = headerKeyValue.Split('=')[1];

　　}

　　IFlurlRequest flurlRequest = apiUrl.WithHeader(headerKey, headerValue);

　　if (flurlRequest == null)

　　{

　　return (false, "flurlRequest 空指针！");

　　}

　　IFlurlResponse flurResponse = default;

　　if (requsetMode == "Post")

　　{

　　flurResponse = await flurlRequest.PostAsync();

　　}

　　if (requsetMode == "Get")

　　{

　　flurResponse = await flurlRequest.GetAsync();

　　}

　　if (flurResponse == null)

　　{

　　return (false, "flurResponse 空指针！");

　　}

　　var result = await flurResponse.GetStringAsync();

　　if (string.IsNullOrWhiteSpace(result))

　　{

　　return (false, "result 空指针！");

　　}

　　return (true, result);

　　}

　　catch (Exception ex)

　　{

　　_logger.LogError(ex, $"接口请求异常【ApiRequestService 》RequestAsync】：{ex.Message}");

　　return (false, ex.Message);

　　}

　　5 ioc容器注入

　　services.AddTransient();

　　//Job 实例化工厂

　　services.AddSingleton();

　　//Reultful 风格 api 请求任务

　　services.AddTransient();

　　6 实现项目启动就从数据库里面运行加载任务

　　写一个 Worker 继承 IHostedService

　　里面的逻辑就写，读数据库，循环加载任务，加载任务的方法就在上面的RUNAsync()

　　using System.Threading;

　　using System.Threading.Tasks;

　　namespace HZY.Quartz

　　{

　　public class Worker : IHostedService

　　{

　　private readonly ILogger _logger;

　　private readonly IServiceProvider _provider;

　　private readonly QuartzJobService _quartzJob;

　　public Worker(ILogger logger, QuartzJobService quartzJob, IServiceProvider provider)

　　{

　　_logger = logger;

　　this._quartzJob = quartzJob;

　　_provider = provider;

　　}

　　public async Task StartAsync(CancellationToken cancellationToken)

　　{

　　_logger.LogInformation($"程序服务开始 : {DateTime.Now}");

　　List servicelist = new();

　　using (var scope = _provider.CreateScope())

　　{

　　// 解析你的作用域服务

　　var service = scope.ServiceProvider.GetService();

　　if (service != null)

　　{

　　servicelist = await service.Where(xx).ToListAsync();

　　}

　　_logger.LogInformation($"程序服务查询定时任务列表成功 : {DateTime.Now}");

　　foreach (var item in servicelist)

　　{

　　//自动恢复任务机制a

　　try

　　{

　　var result = await _quartzJob.RunAsync(item);

　　if (result)

　　{

　　_logger.LogInformation($"自动开启任务成功 [{DateTime.Now}] ");

　　}

　　catch (Exception ex)

　　{

　　_logger.LogError(ex, $"自动开启任务错误 [{DateTime.Now}] : {ex.Message}");

　　}

　　await StopAsync(cancellationToken); //在项目查询运行的时候运行一次

　　}

　　public Task StopAsync(CancellationToken cancellationToken)

　　{

　　return Task.CompletedTask;

　　}

　　7 总结

　　以上就是我之前在项目中使用定时任务的一些逻辑和代码，

　　当然了我还参照了目前的开源项目 https://gitee.com/hzy6/hzy-quartz 一些设计思想和代码

　　，基本上在项目中可以随便使用。具体的一些执行逻辑就可以自己去写

　　8 Corn

　　Cron表达式生成器1：https://fontawesome.com

　　Cron表达式生成器2：https://cron.qqe2.com/

　　0 0/60 * * * ? 每60分钟执行一次

　　0 55 7 * * ? 每天7:55执行一次

　　0 0 1 ? * L 每周一凌晨1点执行

　　0 0 18 18 * ? 每月18号18点执行一次

　　到此这篇关于在.NET6中使用配置Quartz.NET定时任务并使用IHostedService实现项目启动自动加载任务的文章就介绍到这了,更多相关.NET6 Quartz.NET定时任务内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

　　您可能感兴趣的文章:

您可能感兴趣的文章:

在.NET6中使用配置Quartz.NET定时任务并使用IHostedService实现项目启动自动加载任务

相关文章

大家感兴趣的内容

最近更新的内容