Quartz.net的最佳实践

Quartz.NET 官网

Quartz.net是什么

Quartz.NET 是一个功能齐全的开源作业调度系统，他的前身来源于java的Quartz.Quartz.net安装和使用

基于visual studio引用安装，其他IDE类似，或者下载DLL手动引用也是可以的；运行环境基于.net core，源.net程序类似 Quartz.net的架构和关键属性以及方法

三个主要的概念

• scheduler 作业调度，作业计划在给定触发器发生时运行，实际就是领导
  
• job 作业，实现简单 IJob 接口的任何 .NET 类，实际就是干活的员工
  
• trigger 侦听器，负责捕获调度事件以监视或控制作业，实际就是监工
  

可以这样理解：

监工发现员工偷懒了，报告给领导，领导知道后，给员工派了很多活，导致了员工天天996. 大概是这么个关系;同时呢，一个员工可以被多个监工监理，同理一个监工也可以监理多个员工，他们是多对多的关系；多个员工也可以共属于一个领导，当然也可以一个领导只有一个员工，他们直接也是多对多的关系 Quartz.net的一些关键属性

类型
ISchedulerFactory	SchedulerBuilder的工厂类
IScheduler	用于与调度程序交互的主要 API
SchedulerBuilder	用于定义/构建调度程序实例，需要 Quartz 3.1 或更高版本
IJobFactory	JobBuilder的工厂类
IJob	由您希望由调度程序执行的组件实现的接口
IJobDetail	用于定义作业的实例
JobBuilder	用于定义/构建 JobDetail 实例，这些实例定义作业的实例
TriggerBuilder	用于定义/构建触发器实例
ITrigger	定义执行给定作业的计划的一个组件，作业可以有多个关联的触发器
ListenerManager	侦听器事件，例如：执行job工作之前，之后触发等等，同时也可用于触发器侦听

 IServiceCollectionQuartzConfigurator 参数

Scheduler Name	调度作业的名称
Scheduler Id	SchedulerId
Max Batch Size	同时执行job的最大数量
InterruptJobsOnShutdown
InterruptJobsOnShutdownWithWait
BatchTriggerAcquisitionFireAheadTimeWindow

 在通用host或者webhost中的最佳实践

通用host或者webhost代码是一样的

执行流程

• 在通用主机服务中注入服务AddQuartz，AddQuartzHostedService
  
• 在AddQuartz中配置调度作业的基本属性（SchedulerId等等）和调度器以及作业（ScheduleJob，AddJob，AddTrigger）；可以在这个地方写入所有的调度作业，也可以写入一个initjob作业，在主机完全启动5秒后执行相应的业务（可规避掉某些依赖服务未启动的问题）
  
• 在initjob中，初始化其他定时任务。官网介绍job只能有一个无参的构造函数，但我亲测可以注入（笑脸）
  
• 关于job和reigger的具体参数，可查看官网
  

如下

以下代码和执行结果,其中执行顺序一目了然代码

1.    static void Main(string[] args)
2.         {
3.             Console.WriteLine("Hello, World!");
5.             LogProvider.SetCurrentLogProvider(new ConsoleLogProvider());
6.             //通用主机配置
7.             var build = Host.CreateDefaultBuilder(args)
8.                 .ConfigureServices((host, services) =>
9.                 {
10.                     Console.WriteLine("--------1");
11.                     
12.                     //调度作业的唯一id的唯一标识，用于集群搭建cluster
13.                     q.SchedulerId = "SchedulerId_01";
14.                     //配置Quartz服务
15.                     services.AddQuartz(q =>
16.                     {
17.                         Console.WriteLine("--------2");
18.                         //依赖注入，ISchedulerFactory，Ijob等等
19.                         q.UseMicrosoftDependencyInjectionJobFactory();
21.                         //方法一和方法二使用不同方法的写法，本质基本是一样的
22.                         //方法一
23.                         q.ScheduleJob<InitJob>(
24.                             trigger =>
25.                             {
26.                                 Console.WriteLine("--------33");
27.                                 //WithIdentity 绑定触发器或者job的唯一属性和组
28.                                 //TriggerKey，JobKey 都是代表唯一个属性和组
29.                                 trigger.WithIdentity(new TriggerKey("trigger1", "triggergroup1"))
30.                                        .WithSimpleSchedule(x => x.WithIntervalInSeconds(5))
31.                                        // .StartAt(DateBuilder.EvenSecondDate(DateTimeOffset.UtcNow.AddSeconds(5)))
32.                                        //  .WithDailyTimeIntervalSchedule(x => x.WithInterval(10, IntervalUnit.Second))
33.                                        .WithDescription("init 描述");
34.                             },
35.                             jobConfigure =>
36.                             {
37.                                 Console.WriteLine("--------44");
38.                                 jobConfigure.WithIdentity(new JobKey("Init1", "jobgroup1"));
39.                             }
40.                         );
42.                         //方法二
43.                         //q.AddJob<InitJob>(opts =>
44.                         //{
45.                         //    Console.WriteLine("--------3");
46.                         //    opts.WithIdentity(new JobKey("Init1", "jobgroup1"));
48.                         //});
50.                         //q.AddTrigger(opts =>
51.                         //{
52.                         //    Console.WriteLine("--------4");
53.                         //    //将job添加至触发器中
54.                         //    opts.ForJob(new JobKey("Init1", "jobgroup1"))
55.                         //    .WithIdentity("trigger1", "triggergroup1")
56.                         //    .WithSimpleSchedule(x =>
57.                         //    {
58.                         //        Console.WriteLine("--------6");
59.                         //        x.WithIntervalInSeconds(5);
60.                         //        //.RepeatForever();
61.                         //        //.WithRepeatCount(5);
62.                         //    });
64.                         //});
66.                     });
67.                     services.AddQuartzHostedService(options =>
68.                     {   
69.                         options.WaitForJobsToComplete = true;
70.                     });
72.                 }).Build();
74.             //var schedulerFactory =  build.Services.GetService<ISchedulerFactory>();
75.             //var scheduler = schedulerFactory.GetScheduler();
76.             build.Run();
77.             Console.WriteLine("--------7");
78.         }
79.     }
82.     public class SampleJob : IJob
83.     {
84.         public SampleJob(ISchedulerFactory schedulerFactory, IJobFactory jobFactory)
85.         {
86.             Console.WriteLine("--------8");
87.         }
88.         public async Task Execute(IJobExecutionContext context)
89.         {
90.             Console.WriteLine("--------9");
91.             context.JobDetail.JobDataMap.GetString("我是sample的job数据key");
92.             Console.WriteLine($"我是sample的job数据key: {context.JobDetail.JobDataMap.GetString("我是sample的job数据key")}");
93.             Console.WriteLine($"我是sample的Trigger数据key: {context.MergedJobDataMap.GetString("我是sample的Trigger数据key")}");
95.         }
96.     }
97.     public class InitJob : IJob
98.     {
99.         public ISchedulerFactory _schedulerFactory;
100.         public IJobFactory _jobFactory;
101.         public InitJob(ISchedulerFactory schedulerFactory, IJobFactory jobFactory)
102.         {
103.             Console.WriteLine("--------12");
104.             _schedulerFactory = schedulerFactory;
105.             _jobFactory = jobFactory;
106.         }
107.         public async Task Execute(IJobExecutionContext context)
108.         {
109.             Console.WriteLine("--------13");
110.             Console.WriteLine("InitJob Execute " + Random.Shared.Next(0, 100));
111.             
112.             //创建job
113.             IJobDetail job = JobBuilder.Create<SampleJob>()
114.                                 //写入参数
115.                                 .UsingJobData("我是sample的job数据key", "我是sample的job数据value")
116.                                 .WithIdentity("sample1", "jobgroup1").Build();
117.             //创建触发器
118.             ITrigger trigger = TriggerBuilder.Create()
119.                                    .UsingJobData("我是sample的Trigger数据key", "我是sample的Trigger数据value")
120.                                    .WithIdentity("trigger_sample1", "triggergroup1")
121.                                    .WithDescription("我是描述")
122.                                    //通过corn符号来创建触发器
123.                                    //.WithCronSchedule(taskOptions.CronExpression)
124.                                    .WithSimpleSchedule(x =>
125.                                        x.WithIntervalInSeconds(5) //5秒后执行
126.                                        .RepeatForever()  //重复
127.                                     )
128.                                    .Build();
129.             //通过工厂获取一个作业调度
130.             var scheduler = await _schedulerFactory.GetScheduler();
131.             //绑定一个job的事件侦听器，从执行顺序上看 new JobListen是一个单例类
132.             scheduler.ListenerManager.AddJobListener(new JobListen(), KeyMatcher<JobKey>.KeyEquals(new JobKey("sample1", "jobgroup1")));
133.             //将作业和从触发器绑定至作业调度上
134.             await scheduler.ScheduleJob(job, trigger);
135.             //启动作业调度
136.             await scheduler.Start();
138.             Console.WriteLine("--------14");
139.         }
140.     }
141.     //作业侦听器
142.     public class JobListen : JobListenerSupport
143.     {
144.         public JobListen()
145.         {
146.             Console.WriteLine("--------20");
147.         }
148.         public override string Name { get { return "JobListen20"; } }
149.         //调用job之前执行
150.         public override Task JobToBeExecuted(IJobExecutionContext context, CancellationToken cancellationToken)
151.         {
152.             Console.WriteLine("--------21");
153.             return base.JobToBeExecuted(context, cancellationToken);
154.         }
155.     }
156.     //日志组件
157.     public class ConsoleLogProvider : ILogProvider
158.     {
159.         public Logger GetLogger(string name)
160.         {
161.             return (level, func, exception, parameters) =>
162.             {
163.                 if (level >= LogLevel.Info && func != null)
164.                 {
165.                     Console.WriteLine("[" + DateTime.Now.ToLongTimeString() + "] [" + level + "] " + func(), parameters);
166.                 }
167.                 return true;
168.             };
169.         }
170.         public IDisposable OpenNestedContext(string message)
171.         {
172.             throw new NotImplementedException();
173.         }
174.         public IDisposable OpenMappedContext(string key, object value, bool destructure = false)
175.         {
176.             throw new NotImplementedException();
177.         }
178.     }

复制代码

执行结果

  
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！