通過實例詳細講解Quartz.NET的一些高級功能的應用，你用到了多少

作者：架構師老盧 2024-03-14 08:31:29

以下示例涵蓋了 Quartz.NET 的一些高級功能，包括 Cron 表達式觸發器、作業間的依賴性、作業執行中的數據傳遞、全局作業監聽器、全局觸發器監聽器、自定義日歷、集群模式、持久性作業、作業狀態記錄和并行執行。希望對你理解 Quartz.NET 的高級功能有所幫助。

Quartz.NET 是一個強大的開源作業調度庫，提供了許多高級功能。以下是 Quartz.NET 的常用高級功能：

Cron 表達式觸發器： 使用 Cron 表達式定義靈活的調度規則，實現復雜的時間調度策略。
作業依賴性： 允許定義作業之間的依賴關系，確保它們按照特定的順序執行。
作業執行中的數據傳遞： 在調度作業時，可以傳遞參數和數據，使得作業能夠根據需要獲取執行時的上下文信息。
全局作業監聽器： 添加全局監聽器，監聽作業的執行生命周期事件，例如作業執行前、執行后等。
全局觸發器監聽器： 添加全局監聽器，監聽觸發器的生命周期事件，例如觸發器觸發、觸發器完成等。
自定義日歷： 可以實現自定義的日歷邏輯，例如排除特定日期或時間段，以滿足業務需求。
集群模式： 允許將 Quartz.NET 實例配置為集群，實現分布式作業調度，確保高可用性和負載均衡。
持久性作業： Quartz.NET 提供了作業的持久性支持，可以將作業和觸發器存儲在數據庫中，保證作業不會丟失。
作業狀態記錄： Quartz.NET 能夠記錄作業的執行狀態，包括成功、失敗、被否決等，方便監控和故障排查。
并行執行： 允許多個作業同時執行，提高系統的并發性能。

這些功能使得 Quartz.NET 成為一個靈活且功能豐富的作業調度框架，適用于各種復雜的調度需求。

以下是 Quartz.NET 的高級功能示例，包含中文注釋：

1.Cron 表達式觸發器

using Quartz;
using Quartz.Impl;
using System;

class Program
{
    static void Main(string[] args)
    {
        try
        {
            // 創建調度器工廠
            ISchedulerFactory schedulerFactory = new StdSchedulerFactory();

            // 獲取調度器實例
            IScheduler scheduler = schedulerFactory.GetScheduler().Result;

            // 創建作業
            IJobDetail job = JobBuilder.Create<NetworkStatusCheckJob>()
                .WithIdentity("networkStatusCheckJob", "group1")
                .Build();

            // 創建觸發器，使用 Cron 表達式，每天10:30觸發一次
            ITrigger trigger = TriggerBuilder.Create()
                .WithIdentity("networkStatusCheckTrigger", "group1")
                .StartNow()
                .WithCronSchedule("0 30 10 ? * *")
                .Build();

            // 將作業和觸發器添加到調度器
            scheduler.ScheduleJob(job, trigger).Wait();

            // 啟動調度器
            scheduler.Start().Wait();

            Console.WriteLine("Quartz.NET 已啟動，按任意鍵退出...");
            Console.ReadKey();

            // 關閉調度器
            scheduler.Shutdown().Wait();
        }
        catch (SchedulerException se)
        {
            Console.WriteLine(se);
        }
    }
}

2.作業間的依賴性

using Quartz;
using Quartz.Impl;
using System;

class Program
{
    static void Main(string[] args)
    {
        try
        {
            // 創建調度器工廠
            ISchedulerFactory schedulerFactory = new StdSchedulerFactory();

            // 獲取調度器實例
            IScheduler scheduler = schedulerFactory.GetScheduler().Result;

            // 創建作業1
            IJobDetail job1 = JobBuilder.Create<Job1>()
                .WithIdentity("job1", "group1")
                .Build();

            // 創建作業2
            IJobDetail job2 = JobBuilder.Create<Job2>()
                .WithIdentity("job2", "group1")
                .Build();

            // 創建觸發器1
            ITrigger trigger1 = TriggerBuilder.Create()
                .WithIdentity("trigger1", "group1")
                .StartNow()
                .Build();

            // 創建觸發器2，設置在觸發器1后執行
            ITrigger trigger2 = TriggerBuilder.Create()
                .WithIdentity("trigger2", "group1")
                .StartNow()
                .Build();

            // 將作業和觸發器添加到調度器
            scheduler.ScheduleJob(job1, trigger1).Wait();
            scheduler.ScheduleJob(job2, trigger2.ForJob(job1).Build()).Wait();

            // 啟動調度器
            scheduler.Start().Wait();

            Console.WriteLine("Quartz.NET 已啟動，按任意鍵退出...");
            Console.ReadKey();

            // 關閉調度器
            scheduler.Shutdown().Wait();
        }
        catch (SchedulerException se)
        {
            Console.WriteLine(se);
        }
    }
}

public class Job1 : IJob
{
    public void Execute(IJobExecutionContext context)
    {
        Console.WriteLine("Job1 執行");
    }
}

public class Job2 : IJob
{
    public void Execute(IJobExecutionContext context)
    {
        Console.WriteLine("Job2 執行");
    }
}

3.作業執行中的數據傳遞

using Quartz;
using Quartz.Impl;
using System;

class Program
{
    static void Main(string[] args)
    {
        try
        {
            // 創建調度器工廠
            ISchedulerFactory schedulerFactory = new StdSchedulerFactory();

            // 獲取調度器實例
            IScheduler scheduler = schedulerFactory.GetScheduler().Result;

            // 創建帶數據的作業
            IJobDetail job = JobBuilder.Create<DataPassingJob>()
                .WithIdentity("dataPassingJob", "group1")
                .UsingJobData("key1", "value1")
                .UsingJobData("key2", 123)
                .Build();

            // 創建觸發器
            ITrigger trigger = TriggerBuilder.Create()
                .WithIdentity("dataPassingTrigger", "group1")
                .StartNow()
                .WithSimpleSchedule(x => x
                    .WithIntervalInSeconds(20)
                    .RepeatForever())
                .Build();

            // 將作業和觸發器添加到調度器
            scheduler.ScheduleJob(job, trigger).Wait();

            // 啟動調度器
            scheduler.Start().Wait();

            Console.WriteLine("Quartz.NET 已啟動，按任意鍵退出...");
            Console.ReadKey();

            // 關閉調度器
            scheduler.Shutdown().Wait();
        }
        catch (SchedulerException se)
        {
            Console.WriteLine(se);
        }
    }
}

public class DataPassingJob : IJob
{
    public void Execute(IJobExecutionContext context)
    {
        // 從作業執行上下文中獲取傳遞的數據
        JobDataMap dataMap = context.JobDetail.JobDataMap;
        string value1 = dataMap.GetString("key1");
        int value2 = dataMap.GetInt("key2");

        Console.WriteLine($"作業執行中的數據：key1={value1}, key2={value2}");
    }
}

4.全局作業監聽器

using Quartz;
using Quartz.Impl;
using System;

public class GlobalJobListener : IJobListener
{
    public string Name => "GlobalJobListener";

    public Task JobExecutionVetoed(IJobExecutionContext context, CancellationToken cancellationToken = default)
    {
        Console.WriteLine($"作業被否決：{context.JobDetail.Key}");
        return Task.CompletedTask;
    }

    public Task JobToBeExecuted(IJobExecutionContext context, CancellationToken cancellationToken = default)
    {
        Console.WriteLine($"準備執行作業：{context.JobDetail.Key}");
        return Task.CompletedTask;
    }

    public Task JobWasExecuted(IJobExecutionContext context, JobExecutionException jobException, CancellationToken cancellationToken = default)
    {
        Console.WriteLine($"作業執行完成：{context.JobDetail.Key}");
        return Task.CompletedTask;
    }
}

class Program
{
    static void Main(string[] args)
    {
        try
        {
            // 創建調度器工廠
            ISchedulerFactory schedulerFactory = new StdSchedulerFactory();

            // 獲取調度器實例
            IScheduler scheduler = schedulerFactory.GetScheduler().Result;

            // 添加全局作業監聽器
            scheduler.ListenerManager.AddJobListener(new GlobalJobListener());

            // 創建作業
            IJobDetail job = JobBuilder.Create<SimpleJob>()
                .WithIdentity("simpleJob", "group1")
                .Build();

            // 創建觸發器
            ITrigger trigger = TriggerBuilder.Create()
                .WithIdentity("simpleTrigger", "group1")
                .StartNow()


                .WithSimpleSchedule(x => x
                    .WithIntervalInSeconds(20)
                    .RepeatForever())
                .Build();

            // 將作業和觸發器添加到調度器
            scheduler.ScheduleJob(job, trigger).Wait();

            // 啟動調度器
            scheduler.Start().Wait();

            Console.WriteLine("Quartz.NET 已啟動，按任意鍵退出...");
            Console.ReadKey();

            // 關閉調度器
            scheduler.Shutdown().Wait();
        }
        catch (SchedulerException se)
        {
            Console.WriteLine(se);
        }
    }
}

public class SimpleJob : IJob
{
    public void Execute(IJobExecutionContext context)
    {
        Console.WriteLine("簡單作業執行中...");
    }
}

5.全局觸發器監聽器

using Quartz;
using Quartz.Impl;
using System;

public class GlobalTriggerListener : ITriggerListener
{
    public string Name => "GlobalTriggerListener";

    public Task TriggerComplete(ITrigger trigger, IJobExecutionContext context, Trigger.CompletedExecutionInstruction triggerInstructionCode, CancellationToken cancellationToken = default)
    {
        Console.WriteLine($"觸發器完成：{trigger.Key}");
        return Task.CompletedTask;
    }

    public Task TriggerFired(ITrigger trigger, IJobExecutionContext context, CancellationToken cancellationToken = default)
    {
        Console.WriteLine($"觸發器觸發：{trigger.Key}");
        return Task.CompletedTask;
    }

    public Task TriggerMisfired(ITrigger trigger, CancellationToken cancellationToken = default)
    {
        Console.WriteLine($"觸發器錯過觸發：{trigger.Key}");
        return Task.CompletedTask;
    }

    public Task<bool> VetoJobExecution(ITrigger trigger, IJobExecutionContext context, CancellationToken cancellationToken = default)
    {
        Console.WriteLine($"否決作業執行：{trigger.Key}");
        return Task.FromResult(false);
    }
}

class Program
{
    static void Main(string[] args)
    {
        try
        {
            // 創建調度器工廠
            ISchedulerFactory schedulerFactory = new StdSchedulerFactory();

            // 獲取調度器實例
            IScheduler scheduler = schedulerFactory.GetScheduler().Result;

            // 添加全局觸發器監聽器
            scheduler.ListenerManager.AddTriggerListener(new GlobalTriggerListener());

            // 創建作業
            IJobDetail job = JobBuilder.Create<SimpleJob>()
                .WithIdentity("simpleJob", "group1")
                .Build();

            // 創建觸發器
            ITrigger trigger = TriggerBuilder.Create()
                .WithIdentity("simpleTrigger", "group1")
                .StartNow()
                .WithSimpleSchedule(x => x
                    .WithIntervalInSeconds(20)
                    .RepeatForever())
                .Build();

            // 將作業和觸發器添加到調度器
            scheduler.ScheduleJob(job, trigger).Wait();

            // 啟動調度器
            scheduler.Start().Wait();

            Console.WriteLine("Quartz.NET 已啟動，按任意鍵退出...");
            Console.ReadKey();

            // 關閉調度器
            scheduler.Shutdown().Wait();
        }
        catch (SchedulerException se)
        {
            Console.WriteLine(se);
        }
    }
}

public class SimpleJob : IJob
{
    public void Execute(IJobExecutionContext context)
    {
        Console.WriteLine("簡單作業執行中...");
    }
}

6.自定義日歷

using Quartz;
using Quartz.Impl;
using System;

public class CustomCalendar : BaseCalendar
{
    // 實現自定義的日歷邏輯，這里簡單演示一個排除周末的例子
    public override bool IsTimeIncluded(DateTimeOffset timeStampUtc)
    {
        return timeStampUtc.DayOfWeek != DayOfWeek.Saturday && timeStampUtc.DayOfWeek != DayOfWeek.Sunday;
    }

    public override DateTimeOffset GetNextIncludedTimeUtc(DateTimeOffset timeStampUtc)
    {
        // 確保下一個時間是在排除條件內的
        DateTimeOffset nextTime = timeStampUtc.AddSeconds(1);
        while (!IsTimeIncluded(nextTime))
        {
            nextTime = nextTime.AddSeconds(1);
        }
        return nextTime;
    }
}

class Program
{
    static void Main(string[] args)
    {
        try
        {
            // 創建調度器工廠
            ISchedulerFactory schedulerFactory = new StdSchedulerFactory();

            // 獲取調度器實例
            IScheduler scheduler = schedulerFactory.GetScheduler().Result;

            // 使用自定義日歷
            scheduler.AddCalendar("customCalendar", new CustomCalendar(), true, true);

            // 創建作業
            IJobDetail job = JobBuilder.Create<SimpleJob>()
                .WithIdentity("simpleJob", "group1")
                .Build();

            // 創建觸發器，關聯自定義日歷
            ITrigger trigger = TriggerBuilder.Create()
                .WithIdentity("simpleTrigger", "group1")
                .StartNow()
                .WithSimpleSchedule(x => x
                    .WithIntervalInSeconds(20)
                    .RepeatForever())
                .ModifiedByCalendar("customCalendar")
                .Build();

            // 將作業和觸發器添加到調度器
            scheduler.ScheduleJob(job, trigger).Wait();

            // 啟動調度器
            scheduler.Start().Wait();

            Console.WriteLine("Quartz.NET 已啟動，按任意鍵退出...");
            Console.ReadKey();

            // 關閉調度器
            scheduler.Shutdown().Wait();
        }
        catch (SchedulerException se)
        {
            Console.WriteLine(se);
        }
    }
}

public class SimpleJob : IJob
{
    public void Execute(IJobExecutionContext context)
    {
        Console.WriteLine("簡單作業執行中...");
    }
}

7.集群模式

using Quartz;
using Quartz.Impl;
using System;

class Program
{
    static void Main(string[] args)
    {
        try
        {
            // 創建調度器工廠
            ISchedulerFactory schedulerFactory = new StdSchedulerFactory();

            // 獲取調度器實例，設置為集群模式
            IScheduler scheduler = schedulerFactory.GetScheduler(new NameValueCollection { { "quartz.jobStore.type", "Quartz.Simpl.RAMJobStore, Quartz" } }).Result;

            // 創建作業
            IJobDetail job = JobBuilder.Create<SimpleJob>()
                .WithIdentity("simpleJob", "group1")
                .Build();

            // 創建觸發器
            ITrigger trigger = TriggerBuilder.Create()
                .WithIdentity("simpleTrigger", "group1")
                .StartNow()
                .WithSimpleSchedule(x => x
                    .WithIntervalInSeconds(20)
                    .RepeatForever())
                .Build();

            // 將作業和觸發器添加到調度器
            scheduler.ScheduleJob(job, trigger).Wait();

            // 啟動調度器
            scheduler.Start().Wait();

            Console.WriteLine("Quartz.NET 已啟動，按任意鍵退出...");
            Console.ReadKey();

            // 關閉調度器
            scheduler.Shutdown().Wait();
        }
        catch (SchedulerException se)
        {
            Console.WriteLine(se);
        }
    }
}

public class SimpleJob : IJob
{
    public void Execute(IJobExecutionContext context)
    {
        Console.WriteLine("簡單作業執行中...");
    }
}

8.持久性作業

using Quartz;
using Quartz.Impl;
using System;

class Program
{
    static void Main(string[] args)
    {
        try
        {
            // 創建調度器工廠
            ISchedulerFactory schedulerFactory = new StdSchedulerFactory();

            // 獲取調度器實例，設置為使用 AdoJobStore 持久性存儲
            IScheduler scheduler = schedulerFactory.GetScheduler(new NameValueCollection
            {
                { "quartz.jobStore.type", "Quartz.Impl.AdoJobStore.JobStoreTX, Quartz" },
                { "quartz.jobStore.driverDelegateType", "Quartz.Impl.AdoJobStore.StdAdoDelegate, Quartz" },
                { "quartz.jobStore.dataSource", "myDS" },
                { "quartz.dataSource.myDS.connectionString", "YourConnectionString" },
                { "quartz.jobStore.tablePrefix", "QRTZ_" },
                { "quartz.jobStore.useProperties", "true" },
                { "quartz.jobStore.misfireThreshold", "60000" }
            }).Result;

            // 創建作業
            IJobDetail job = JobBuilder.Create<SimpleJob>()
                .WithIdentity("simpleJob", "group1")
                .StoreDurably() // 設置為持久性作業
                .Build();

            // 創建觸發器
            ITrigger trigger = TriggerBuilder.Create()
                .WithIdentity("simpleTrigger", "group1")
                .StartNow()
                .WithSimpleSchedule(x => x
                    .WithIntervalInSeconds(20)
                    .RepeatForever())
                .Build();

            // 將作業和觸發器添加到調度器
            scheduler.AddJob(job, true).Wait();
            scheduler.ScheduleJob(trigger).Wait();

            // 啟動調度器
            scheduler.Start().Wait();

            Console.WriteLine("Quartz.NET 已啟動，按任意鍵退出...");
            Console.ReadKey();

            // 關閉調度器
            scheduler.Shutdown().Wait();
        }
        catch (SchedulerException se)
        {
            Console.WriteLine(se);
        }
    }
}

public class SimpleJob : IJob
{
    public void Execute(IJobExecutionContext context)
    {
        Console.WriteLine("簡單作業執行中...");
    }
}

9.作業狀態記錄

using Quartz;
using Quartz.Impl;
using System;

class Program
{
    static void Main(string[] args)
    {
        try
        {
            // 創建調度器工廠
            ISchedulerFactory schedulerFactory = new StdSchedulerFactory();

            // 獲取調度器實例
            IScheduler scheduler = schedulerFactory.GetScheduler().Result;

            // 創建作業
            IJobDetail job = JobBuilder.Create<StatusRecordingJob>()
                .WithIdentity("statusRecordingJob", "group1")
                .Build();

            // 創建觸發器
            ITrigger trigger = TriggerBuilder.Create()
                .WithIdentity("statusRecordingTrigger", "group1")
                .StartNow()
                .WithSimpleSchedule(x => x
                    .WithIntervalInSeconds(20)
                    .RepeatForever())
                .Build();

            // 將作業和觸發器添加到調度器
            scheduler.ScheduleJob(job, trigger).Wait();

            // 啟動調度器
            scheduler.Start().Wait();

            Console.WriteLine("Quartz.NET 已啟動，按任意鍵退出...");
            Console.ReadKey();

            // 關閉調度器
            scheduler.Shutdown().Wait();
        }
        catch (SchedulerException se)
        {
            Console.WriteLine(se);
        }
    }
}

public class StatusRecordingJob : IJob
{
    public void Execute(IJobExecutionContext context)
    {
        // 記錄作業狀態
        Console.WriteLine($"作業執行中... 執行狀態：{context.Result}");
    }
}

10.并行執行

using Quartz;
using Quartz.Impl;
using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        try


        {
            // 創建調度器工廠
            ISchedulerFactory schedulerFactory = new StdSchedulerFactory();

            // 獲取調度器實例
            IScheduler scheduler = await schedulerFactory.GetScheduler();

            // 創建作業1
            IJobDetail job1 = JobBuilder.Create<ParallelJob>()
                .WithIdentity("parallelJob1", "group1")
                .Build();

            // 創建作業2
            IJobDetail job2 = JobBuilder.Create<ParallelJob>()
                .WithIdentity("parallelJob2", "group1")
                .Build();

            // 創建觸發器1
            ITrigger trigger1 = TriggerBuilder.Create()
                .WithIdentity("trigger1", "group1")
                .StartNow()
                .Build();

            // 創建觸發器2
            ITrigger trigger2 = TriggerBuilder.Create()
                .WithIdentity("trigger2", "group1")
                .StartNow()
                .Build();

            // 將作業和觸發器添加到調度器
            await scheduler.ScheduleJob(job1, trigger1);
            await scheduler.ScheduleJob(job2, trigger2);

            // 啟動調度器
            await scheduler.Start();

            Console.WriteLine("Quartz.NET 已啟動，按任意鍵退出...");
            Console.ReadKey();

            // 關閉調度器
            await scheduler.Shutdown();
        }
        catch (SchedulerException se)
        {
            Console.WriteLine(se);
        }
    }
}

public class ParallelJob : IJob
{
    public async Task Execute(IJobExecutionContext context)
    {
        // 模擬作業執行時間
        await Task.Delay(TimeSpan.FromSeconds(10));

        Console.WriteLine($"并行作業執行中... 執行時間：{DateTime.Now}");
    }
}

這些示例涵蓋了 Quartz.NET 的一些高級功能，包括 Cron 表達式觸發器、作業間的依賴性、作業執行中的數據傳遞、全局作業監聽器、全局觸發器監聽器、自定義日歷、集群模式、持久性作業、作業狀態記錄和并行執行。希望對你理解 Quartz.NET 的高級功能有所幫助。

責任編輯：姜華來源：今日頭條

Quartz.NE 開源作業調度庫