通过实例详细讲解Quartz.NET的一些高级功能的应用，你用到了多少

玉水

 
Quartz.NET 是一个强大的开源作业调度库，提供了许多高级功能。以下是 Quartz.NET 的常用高级功能：

• Cron 表达式触发器： 使用 Cron 表达式定义灵活的调度规则，实现复杂的时间调度策略。
  
• 作业依赖性： 允许定义作业之间的依赖关系，确保它们按照特定的顺序执行。
  
• 作业执行中的数据传递： 在调度作业时，可以传递参数和数据，使得作业能够根据需要获取执行时的上下文信息。
  
• 全局作业监听器： 添加全局监听器，监听作业的执行生命周期事件，例如作业执行前、执行后等。
  
• 全局触发器监听器： 添加全局监听器，监听触发器的生命周期事件，例如触发器触发、触发器完成等。
  
• 自定义日历： 可以实现自定义的日历逻辑，例如排除特定日期或时间段，以满足业务需求。
  
• 集群模式： 允许将 Quartz.NET 实例配置为集群，实现分布式作业调度，确保高可用性和负载均衡。
  
• 持久性作业： Quartz.NET 提供了作业的持久性支持，可以将作业和触发器存储在数据库中，保证作业不会丢失。
  
• 作业状态记录： Quartz.NET 能够记录作业的执行状态，包括成功、失败、被否决等，方便监控和故障排查。
  
• 并行执行： 允许多个作业同时执行，提高系统的并发性能。
  

这些功能使得 Quartz.NET 成为一个灵活且功能丰富的作业调度框架，适用于各种复杂的调度需求。
以下是 Quartz.NET 的高级功能示例，包含中文注释：
1.Cron 表达式触发器

1. using Quartz;
2. using Quartz.Impl;
3. using System;
5. class Program
6. {
7.     static void Main(string[] args)
8.     {
9.         try
10.         {
11.             // 创建调度器工厂
12.             ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
14.             // 获取调度器实例
15.             IScheduler scheduler = schedulerFactory.GetScheduler().Result;
17.             // 创建作业
18.             IJobDetail job = JobBuilder.Create<NetworkStatusCheckJob>()
19.                 .WithIdentity("networkStatusCheckJob", "group1")
20.                 .Build();
22.             // 创建触发器，使用 Cron 表达式，每天10:30触发一次
23.             ITrigger trigger = TriggerBuilder.Create()
24.                 .WithIdentity("networkStatusCheckTrigger", "group1")
25.                 .StartNow()
26.                 .WithCronSchedule("0 30 10 ? * *")
27.                 .Build();
29.             // 将作业和触发器添加到调度器
30.             scheduler.ScheduleJob(job, trigger).Wait();
32.             // 启动调度器
33.             scheduler.Start().Wait();
35.             Console.WriteLine("Quartz.NET 已启动，按任意键退出...");
36.             Console.ReadKey();
38.             // 关闭调度器
39.             scheduler.Shutdown().Wait();
40.         }
41.         catch (SchedulerException se)
42.         {
43.             Console.WriteLine(se);
44.         }
45.     }
46. }

复制代码

2.作业间的依赖性

1. using Quartz;
2. using Quartz.Impl;
3. using System;
5. class Program
6. {
7.     static void Main(string[] args)
8.     {
9.         try
10.         {
11.             // 创建调度器工厂
12.             ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
14.             // 获取调度器实例
15.             IScheduler scheduler = schedulerFactory.GetScheduler().Result;
17.             // 创建作业1
18.             IJobDetail job1 = JobBuilder.Create<Job1>()
19.                 .WithIdentity("job1", "group1")
20.                 .Build();
22.             // 创建作业2
23.             IJobDetail job2 = JobBuilder.Create<Job2>()
24.                 .WithIdentity("job2", "group1")
25.                 .Build();
27.             // 创建触发器1
28.             ITrigger trigger1 = TriggerBuilder.Create()
29.                 .WithIdentity("trigger1", "group1")
30.                 .StartNow()
31.                 .Build();
33.             // 创建触发器2，设置在触发器1后执行
34.             ITrigger trigger2 = TriggerBuilder.Create()
35.                 .WithIdentity("trigger2", "group1")
36.                 .StartNow()
37.                 .Build();
39.             // 将作业和触发器添加到调度器
40.             scheduler.ScheduleJob(job1, trigger1).Wait();
41.             scheduler.ScheduleJob(job2, trigger2.ForJob(job1).Build()).Wait();
43.             // 启动调度器
44.             scheduler.Start().Wait();
46.             Console.WriteLine("Quartz.NET 已启动，按任意键退出...");
47.             Console.ReadKey();
49.             // 关闭调度器
50.             scheduler.Shutdown().Wait();
51.         }
52.         catch (SchedulerException se)
53.         {
54.             Console.WriteLine(se);
55.         }
56.     }
57. }
59. public class Job1 : IJob
60. {
61.     public void Execute(IJobExecutionContext context)
62.     {
63.         Console.WriteLine("Job1 执行");
64.     }
65. }
67. public class Job2 : IJob
68. {
69.     public void Execute(IJobExecutionContext context)
70.     {
71.         Console.WriteLine("Job2 执行");
72.     }
73. }

复制代码

3.作业执行中的数据传递

1. using Quartz;
2. using Quartz.Impl;
3. using System;
5. class Program
6. {
7.     static void Main(string[] args)
8.     {
9.         try
10.         {
11.             // 创建调度器工厂
12.             ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
14.             // 获取调度器实例
15.             IScheduler scheduler = schedulerFactory.GetScheduler().Result;
17.             // 创建带数据的作业
18.             IJobDetail job = JobBuilder.Create<DataPassingJob>()
19.                 .WithIdentity("dataPassingJob", "group1")
20.                 .UsingJobData("key1", "value1")
21.                 .UsingJobData("key2", 123)
22.                 .Build();
24.             // 创建触发器
25.             ITrigger trigger = TriggerBuilder.Create()
26.                 .WithIdentity("dataPassingTrigger", "group1")
27.                 .StartNow()
28.                 .WithSimpleSchedule(x => x
29.                     .WithIntervalInSeconds(20)
30.                     .RepeatForever())
31.                 .Build();
33.             // 将作业和触发器添加到调度器
34.             scheduler.ScheduleJob(job, trigger).Wait();
36.             // 启动调度器
37.             scheduler.Start().Wait();
39.             Console.WriteLine("Quartz.NET 已启动，按任意键退出...");
40.             Console.ReadKey();
42.             // 关闭调度器
43.             scheduler.Shutdown().Wait();
44.         }
45.         catch (SchedulerException se)
46.         {
47.             Console.WriteLine(se);
48.         }
49.     }
50. }
52. public class DataPassingJob : IJob
53. {
54.     public void Execute(IJobExecutionContext context)
55.     {
56.         // 从作业执行上下文中获取传递的数据
57.         JobDataMap dataMap = context.JobDetail.JobDataMap;
58.         string value1 = dataMap.GetString("key1");
59.         int value2 = dataMap.GetInt("key2");
61.         Console.WriteLine($"作业执行中的数据：key1={value1}, key2={value2}");
62.     }
63. }

复制代码

4.全局作业监听器

1. using Quartz;
2. using Quartz.Impl;
3. using System;
5. public class GlobalJobListener : IJobListener
6. {
7.     public string Name => "GlobalJobListener";
9.     public Task JobExecutionVetoed(IJobExecutionContext context, CancellationToken cancellationToken = default)
10.     {
11.         Console.WriteLine($"作业被否决：{context.JobDetail.Key}");
12.         return Task.CompletedTask;
13.     }
15.     public Task JobToBeExecuted(IJobExecutionContext context, CancellationToken cancellationToken = default)
16.     {
17.         Console.WriteLine($"准备执行作业：{context.JobDetail.Key}");
18.         return Task.CompletedTask;
19.     }
21.     public Task JobWasExecuted(IJobExecutionContext context, JobExecutionException jobException, CancellationToken cancellationToken = default)
22.     {
23.         Console.WriteLine($"作业执行完成：{context.JobDetail.Key}");
24.         return Task.CompletedTask;
25.     }
26. }
28. class Program
29. {
30.     static void Main(string[] args)
31.     {
32.         try
33.         {
34.             // 创建调度器工厂
35.             ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
37.             // 获取调度器实例
38.             IScheduler scheduler = schedulerFactory.GetScheduler().Result;
40.             // 添加全局作业监听器
41.             scheduler.ListenerManager.AddJobListener(new GlobalJobListener());
43.             // 创建作业
44.             IJobDetail job = JobBuilder.Create<SimpleJob>()
45.                 .WithIdentity("simpleJob", "group1")
46.                 .Build();
48.             // 创建触发器
49.             ITrigger trigger = TriggerBuilder.Create()
50.                 .WithIdentity("simpleTrigger", "group1")
51.                 .StartNow()
54.                 .WithSimpleSchedule(x => x
55.                     .WithIntervalInSeconds(20)
56.                     .RepeatForever())
57.                 .Build();
59.             // 将作业和触发器添加到调度器
60.             scheduler.ScheduleJob(job, trigger).Wait();
62.             // 启动调度器
63.             scheduler.Start().Wait();
65.             Console.WriteLine("Quartz.NET 已启动，按任意键退出...");
66.             Console.ReadKey();
68.             // 关闭调度器
69.             scheduler.Shutdown().Wait();
70.         }
71.         catch (SchedulerException se)
72.         {
73.             Console.WriteLine(se);
74.         }
75.     }
76. }
78. public class SimpleJob : IJob
79. {
80.     public void Execute(IJobExecutionContext context)
81.     {
82.         Console.WriteLine("简单作业执行中...");
83.     }
84. }

复制代码

5.全局触发器监听器

1. using Quartz;
2. using Quartz.Impl;
3. using System;
5. public class GlobalTriggerListener : ITriggerListener
6. {
7.     public string Name => "GlobalTriggerListener";
9.     public Task TriggerComplete(ITrigger trigger, IJobExecutionContext context, Trigger.CompletedExecutionInstruction triggerInstructionCode, CancellationToken cancellationToken = default)
10.     {
11.         Console.WriteLine($"触发器完成：{trigger.Key}");
12.         return Task.CompletedTask;
13.     }
15.     public Task TriggerFired(ITrigger trigger, IJobExecutionContext context, CancellationToken cancellationToken = default)
16.     {
17.         Console.WriteLine($"触发器触发：{trigger.Key}");
18.         return Task.CompletedTask;
19.     }
21.     public Task TriggerMisfired(ITrigger trigger, CancellationToken cancellationToken = default)
22.     {
23.         Console.WriteLine($"触发器错过触发：{trigger.Key}");
24.         return Task.CompletedTask;
25.     }
27.     public Task<bool> VetoJobExecution(ITrigger trigger, IJobExecutionContext context, CancellationToken cancellationToken = default)
28.     {
29.         Console.WriteLine($"否决作业执行：{trigger.Key}");
30.         return Task.FromResult(false);
31.     }
32. }
34. class Program
35. {
36.     static void Main(string[] args)
37.     {
38.         try
39.         {
40.             // 创建调度器工厂
41.             ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
43.             // 获取调度器实例
44.             IScheduler scheduler = schedulerFactory.GetScheduler().Result;
46.             // 添加全局触发器监听器
47.             scheduler.ListenerManager.AddTriggerListener(new GlobalTriggerListener());
49.             // 创建作业
50.             IJobDetail job = JobBuilder.Create<SimpleJob>()
51.                 .WithIdentity("simpleJob", "group1")
52.                 .Build();
54.             // 创建触发器
55.             ITrigger trigger = TriggerBuilder.Create()
56.                 .WithIdentity("simpleTrigger", "group1")
57.                 .StartNow()
58.                 .WithSimpleSchedule(x => x
59.                     .WithIntervalInSeconds(20)
60.                     .RepeatForever())
61.                 .Build();
63.             // 将作业和触发器添加到调度器
64.             scheduler.ScheduleJob(job, trigger).Wait();
66.             // 启动调度器
67.             scheduler.Start().Wait();
69.             Console.WriteLine("Quartz.NET 已启动，按任意键退出...");
70.             Console.ReadKey();
72.             // 关闭调度器
73.             scheduler.Shutdown().Wait();
74.         }
75.         catch (SchedulerException se)
76.         {
77.             Console.WriteLine(se);
78.         }
79.     }
80. }
82. public class SimpleJob : IJob
83. {
84.     public void Execute(IJobExecutionContext context)
85.     {
86.         Console.WriteLine("简单作业执行中...");
87.     }
88. }

复制代码

6.自定义日历

1. using Quartz;
2. using Quartz.Impl;
3. using System;
5. public class CustomCalendar : BaseCalendar
6. {
7.     // 实现自定义的日历逻辑，这里简单演示一个排除周末的例子
8.     public override bool IsTimeIncluded(DateTimeOffset timeStampUtc)
9.     {
10.         return timeStampUtc.DayOfWeek != DayOfWeek.Saturday && timeStampUtc.DayOfWeek != DayOfWeek.Sunday;
11.     }
13.     public override DateTimeOffset GetNextIncludedTimeUtc(DateTimeOffset timeStampUtc)
14.     {
15.         // 确保下一个时间是在排除条件内的
16.         DateTimeOffset nextTime = timeStampUtc.AddSeconds(1);
17.         while (!IsTimeIncluded(nextTime))
18.         {
19.             nextTime = nextTime.AddSeconds(1);
20.         }
21.         return nextTime;
22.     }
23. }
25. class Program
26. {
27.     static void Main(string[] args)
28.     {
29.         try
30.         {
31.             // 创建调度器工厂
32.             ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
34.             // 获取调度器实例
35.             IScheduler scheduler = schedulerFactory.GetScheduler().Result;
37.             // 使用自定义日历
38.             scheduler.AddCalendar("customCalendar", new CustomCalendar(), true, true);
40.             // 创建作业
41.             IJobDetail job = JobBuilder.Create<SimpleJob>()
42.                 .WithIdentity("simpleJob", "group1")
43.                 .Build();
45.             // 创建触发器，关联自定义日历
46.             ITrigger trigger = TriggerBuilder.Create()
47.                 .WithIdentity("simpleTrigger", "group1")
48.                 .StartNow()
49.                 .WithSimpleSchedule(x => x
50.                     .WithIntervalInSeconds(20)
51.                     .RepeatForever())
52.                 .ModifiedByCalendar("customCalendar")
53.                 .Build();
55.             // 将作业和触发器添加到调度器
56.             scheduler.ScheduleJob(job, trigger).Wait();
58.             // 启动调度器
59.             scheduler.Start().Wait();
61.             Console.WriteLine("Quartz.NET 已启动，按任意键退出...");
62.             Console.ReadKey();
64.             // 关闭调度器
65.             scheduler.Shutdown().Wait();
66.         }
67.         catch (SchedulerException se)
68.         {
69.             Console.WriteLine(se);
70.         }
71.     }
72. }
74. public class SimpleJob : IJob
75. {
76.     public void Execute(IJobExecutionContext context)
77.     {
78.         Console.WriteLine("简单作业执行中...");
79.     }
80. }

复制代码

7.集群模式

1. using Quartz;
2. using Quartz.Impl;
3. using System;
5. class Program
6. {
7.     static void Main(string[] args)
8.     {
9.         try
10.         {
11.             // 创建调度器工厂
12.             ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
14.             // 获取调度器实例，设置为集群模式
15.             IScheduler scheduler = schedulerFactory.GetScheduler(new NameValueCollection { { "quartz.jobStore.type", "Quartz.Simpl.RAMJobStore, Quartz" } }).Result;
17.             // 创建作业
18.             IJobDetail job = JobBuilder.Create<SimpleJob>()
19.                 .WithIdentity("simpleJob", "group1")
20.                 .Build();
22.             // 创建触发器
23.             ITrigger trigger = TriggerBuilder.Create()
24.                 .WithIdentity("simpleTrigger", "group1")
25.                 .StartNow()
26.                 .WithSimpleSchedule(x => x
27.                     .WithIntervalInSeconds(20)
28.                     .RepeatForever())
29.                 .Build();
31.             // 将作业和触发器添加到调度器
32.             scheduler.ScheduleJob(job, trigger).Wait();
34.             // 启动调度器
35.             scheduler.Start().Wait();
37.             Console.WriteLine("Quartz.NET 已启动，按任意键退出...");
38.             Console.ReadKey();
40.             // 关闭调度器
41.             scheduler.Shutdown().Wait();
42.         }
43.         catch (SchedulerException se)
44.         {
45.             Console.WriteLine(se);
46.         }
47.     }
48. }
50. public class SimpleJob : IJob
51. {
52.     public void Execute(IJobExecutionContext context)
53.     {
54.         Console.WriteLine("简单作业执行中...");
55.     }
56. }

复制代码

8.持久性作业

1. using Quartz;
2. using Quartz.Impl;
3. using System;
5. class Program
6. {
7.     static void Main(string[] args)
8.     {
9.         try
10.         {
11.             // 创建调度器工厂
12.             ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
14.             // 获取调度器实例，设置为使用 AdoJobStore 持久性存储
15.             IScheduler scheduler = schedulerFactory.GetScheduler(new NameValueCollection
16.             {
17.                 { "quartz.jobStore.type", "Quartz.Impl.AdoJobStore.JobStoreTX, Quartz" },
18.                 { "quartz.jobStore.driverDelegateType", "Quartz.Impl.AdoJobStore.StdAdoDelegate, Quartz" },
19.                 { "quartz.jobStore.dataSource", "myDS" },
20.                 { "quartz.dataSource.myDS.connectionString", "YourConnectionString" },
21.                 { "quartz.jobStore.tablePrefix", "QRTZ_" },
22.                 { "quartz.jobStore.useProperties", "true" },
23.                 { "quartz.jobStore.misfireThreshold", "60000" }
24.             }).Result;
26.             // 创建作业
27.             IJobDetail job = JobBuilder.Create<SimpleJob>()
28.                 .WithIdentity("simpleJob", "group1")
29.                 .StoreDurably() // 设置为持久性作业
30.                 .Build();
32.             // 创建触发器
33.             ITrigger trigger = TriggerBuilder.Create()
34.                 .WithIdentity("simpleTrigger", "group1")
35.                 .StartNow()
36.                 .WithSimpleSchedule(x => x
37.                     .WithIntervalInSeconds(20)
38.                     .RepeatForever())
39.                 .Build();
41.             // 将作业和触发器添加到调度器
42.             scheduler.AddJob(job, true).Wait();
43.             scheduler.ScheduleJob(trigger).Wait();
45.             // 启动调度器
46.             scheduler.Start().Wait();
48.             Console.WriteLine("Quartz.NET 已启动，按任意键退出...");
49.             Console.ReadKey();
51.             // 关闭调度器
52.             scheduler.Shutdown().Wait();
53.         }
54.         catch (SchedulerException se)
55.         {
56.             Console.WriteLine(se);
57.         }
58.     }
59. }
61. public class SimpleJob : IJob
62. {
63.     public void Execute(IJobExecutionContext context)
64.     {
65.         Console.WriteLine("简单作业执行中...");
66.     }
67. }

复制代码

9.作业状态记录

1. using Quartz;
2. using Quartz.Impl;
3. using System;
5. class Program
6. {
7.     static void Main(string[] args)
8.     {
9.         try
10.         {
11.             // 创建调度器工厂
12.             ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
14.             // 获取调度器实例
15.             IScheduler scheduler = schedulerFactory.GetScheduler().Result;
17.             // 创建作业
18.             IJobDetail job = JobBuilder.Create<StatusRecordingJob>()
19.                 .WithIdentity("statusRecordingJob", "group1")
20.                 .Build();
22.             // 创建触发器
23.             ITrigger trigger = TriggerBuilder.Create()
24.                 .WithIdentity("statusRecordingTrigger", "group1")
25.                 .StartNow()
26.                 .WithSimpleSchedule(x => x
27.                     .WithIntervalInSeconds(20)
28.                     .RepeatForever())
29.                 .Build();
31.             // 将作业和触发器添加到调度器
32.             scheduler.ScheduleJob(job, trigger).Wait();
34.             // 启动调度器
35.             scheduler.Start().Wait();
37.             Console.WriteLine("Quartz.NET 已启动，按任意键退出...");
38.             Console.ReadKey();
40.             // 关闭调度器
41.             scheduler.Shutdown().Wait();
42.         }
43.         catch (SchedulerException se)
44.         {
45.             Console.WriteLine(se);
46.         }
47.     }
48. }
50. public class StatusRecordingJob : IJob
51. {
52.     public void Execute(IJobExecutionContext context)
53.     {
54.         // 记录作业状态
55.         Console.WriteLine($"作业执行中... 执行状态：{context.Result}");
56.     }
57. }

复制代码

10.并行执行

1. using Quartz;
2. using Quartz.Impl;
3. using System;
4. using System.Threading.Tasks;
6. class Program
7. {
8.     static async Task Main(string[] args)
9.     {
10.         try
13.         {
14.             // 创建调度器工厂
15.             ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
17.             // 获取调度器实例
18.             IScheduler scheduler = await schedulerFactory.GetScheduler();
20.             // 创建作业1
21.             IJobDetail job1 = JobBuilder.Create<ParallelJob>()
22.                 .WithIdentity("parallelJob1", "group1")
23.                 .Build();
25.             // 创建作业2
26.             IJobDetail job2 = JobBuilder.Create<ParallelJob>()
27.                 .WithIdentity("parallelJob2", "group1")
28.                 .Build();
30.             // 创建触发器1
31.             ITrigger trigger1 = TriggerBuilder.Create()
32.                 .WithIdentity("trigger1", "group1")
33.                 .StartNow()
34.                 .Build();
36.             // 创建触发器2
37.             ITrigger trigger2 = TriggerBuilder.Create()
38.                 .WithIdentity("trigger2", "group1")
39.                 .StartNow()
40.                 .Build();
42.             // 将作业和触发器添加到调度器
43.             await scheduler.ScheduleJob(job1, trigger1);
44.             await scheduler.ScheduleJob(job2, trigger2);
46.             // 启动调度器
47.             await scheduler.Start();
49.             Console.WriteLine("Quartz.NET 已启动，按任意键退出...");
50.             Console.ReadKey();
52.             // 关闭调度器
53.             await scheduler.Shutdown();
54.         }
55.         catch (SchedulerException se)
56.         {
57.             Console.WriteLine(se);
58.         }
59.     }
60. }
62. public class ParallelJob : IJob
63. {
64.     public async Task Execute(IJobExecutionContext context)
65.     {
66.         // 模拟作业执行时间
67.         await Task.Delay(TimeSpan.FromSeconds(10));
69.         Console.WriteLine($"并行作业执行中... 执行时间：{DateTime.Now}");
70.     }
71. }

复制代码

这些示例涵盖了 Quartz.NET 的一些高级功能，包括 Cron 表达式触发器、作业间的依赖性、作业执行中的数据传递、全局作业监听器、全局触发器监听器、自定义日历、集群模式、持久性作业、作业状态记录和并行执行。希望对你理解 Quartz.NET 的高级功能有所帮助。
 

来源:https://www.cnblogs.com/hanbing81868164/archive/2023/12/20/17915291.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！