怎么使用.NET6+Quartz實現定時任務

這篇文章主要介紹“怎么使用.NET6+Quartz實現定時任務”，在日常操作中，相信很多人在怎么使用.NET6+Quartz實現定時任務問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”怎么使用.NET6+Quartz實現定時任務”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

什么是定時任務

定時任務，也叫任務調度，是指在一定的載體上，根據具體的觸發規則，執行某些操作。所以定時任務需要滿足三個條件：載體（Scheduler），觸發規則（Trigger），具體業務操作（Job）。如下所示：

什么是Quartz

Quartz 是一個開源的作業調度框架，它完全由 Java 寫成，并設計用于 J2SE 和 J2EE 應用中。它提供了巨大的靈 活性而不犧牲簡單性。你能夠用它來為執行一個作業而創建簡單的或復雜的調度。它有很多特征，如：數據庫支持，集群，插件，EJB 作業預構 建，JavaMail 及其它，支持 cron-like 表達式等等。雖然Quartz最初是為Java編寫的，但是目前已經有.Net版本的Quartz，所以在.Net中應用Quartz已經不再是奢望，而是輕而易舉的事情了。

涉及知識點

在Quartz框架中，主要接口和API如下所示：

其中IScheduler，ITrigger , IJob 三者之間的關系，如下所示：

Quartz安裝

為了方便，本示例創建一個基于.Net6.0的控制臺應用程序，在VS2022中，通過Nuget包管理器進行安裝，如下所示：

創建一個簡單的定時器任務

要開發一個簡單，完整且能運行的定時器任務，步驟如下所示：

1. 創建工作單元Job

創建任務需要實現IJob接口，如下所示：

using Quartz;
using System.Diagnostics;

namespace DemoQuartz.QuartzA.Job
{
    /// <summary>
    /// 測試任務，實現IJob接口
    /// </summary>
    public class TestJob : IJob
    {
        public TestJob()
        {
            Console.WriteLine("執行構造函數");//表示每一次計劃執行，都是一次新的實例
        }

        public Task Execute(IJobExecutionContext context)
        {
            return Task.Run(() =>
             {
                 Console.WriteLine($"******************************");
                 Console.WriteLine($"測試信息{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}");
                 Console.WriteLine($"******************************");
                 Console.WriteLine();
             });
        }
    }
}

2. 創建時間軸Scheduler

時間軸也是任務執行的載體，可以通過StdSchedulerFactory進行獲取，如下所示：

//創建計劃單元（時間軸，載體）
 StdSchedulerFactory schedulerFactory = new StdSchedulerFactory();
 var scheduler = await schedulerFactory.GetScheduler();
 await scheduler.Start();

3. 創建觸發規則Trigger

觸發規則就是那些時間點執行任務，可通過TriggerBuilder進行構建，如下所示：

//Trigger時間觸發機制
var trigger = TriggerBuilder.Create()
    .WithIdentity("TestTrigger","TestGroup")
    //.StartNow() //立即執行
    .WithSimpleSchedule(w=>w.WithIntervalInSeconds(5).WithRepeatCount(5))//.RepeatForever()//無限循環
    //.WithCronSchedule("5/10 * * * * ?") //通過Cron表達式定制時間觸發規則, 示例表示從5開始，每隔10秒一次
    .Build();

4. 創建任務描述

任務描述定義了具體的任務名稱，分組等內容。可通過JobBuilder進行構建，如下所示：

//Job詳細描述
 var jobDetail = JobBuilder.Create<TestJob>()
     .WithDescription("這是一個測試Job")
     .WithIdentity("TestJob", "TestGroup")
     .Build();

5. 建立三者聯系

通過載體，將規則和工作單元串聯起來，如下所示：

 //把時間和任務通過載體關聯起來
 await scheduler.ScheduleJob(jobDetail, trigger);

6. 簡單示例測試

通過運行程序，示例結果如下所示：

傳遞參數

在Quartz框架下，如果需要給執行的Job傳遞參數，可以通過兩種方式：

jobDetail.JobDataMap，工作描述時通過JobDataMap傳遞參數。

trigger.JobDataMap, 時間觸發時通過JobDataMap傳遞參數。

在Job工作單元中，可以通過Context中對應的JobDataMap獲取參數。

傳遞參數，如下所示：

//傳遞參數
jobDetail.JobDataMap.Add("name", "Alan");
jobDetail.JobDataMap.Add("age", 20);
jobDetail.JobDataMap.Add("sex", true);


//trigger同樣可以傳遞參數
trigger.JobDataMap.Add("like1", "meimei");
trigger.JobDataMap.Add("like2", "football");
trigger.JobDataMap.Add("like3", "sing");

獲取參數，如下所示：

//獲取參數
var name = context.JobDetail.JobDataMap.GetString("name");
var age = context.JobDetail.JobDataMap.GetInt("age");
var sex = context.JobDetail.JobDataMap.GetBoolean("sex") ? "男" : "女";

var like1 = context.Trigger.JobDataMap.GetString("like1");
var like2 = context.Trigger.JobDataMap.GetString("like2");
var like3 = context.Trigger.JobDataMap.GetString("like3");

//context.MergedJobDataMap.GetString("aa");//注意如果使用MergedJobDataMap，JobDetail和Trigger中用到相同的Key，則后面設置的會覆蓋前面設置的。

注意：如果使用MergedJobDataMap，JobDetail和Trigger中用到相同的Key，則后面設置的會覆蓋前面設置的。

任務特性

假如我們的定時任務，執行一次需要耗時比較久，而且后一次執行需要等待前一次完成，并且需要前一次執行的結果作為參考，那么就需要設置任務的任性。因為默認情況下，工作單元在每一次運行都是一個新的實例，相互之間獨立運行，互不干擾。所以如果需要存在一定的關聯，就要設置任務的特性，主要有兩個，如下所示：

• [PersistJobDataAfterExecution]//在執行完成后，保留JobDataMap數據

• [DisallowConcurrentExecution]//不允許并發執行，即必須等待上次完成后才能執行下一次

 以上兩個特性，只需要標記在任務對應的類上即可。標記上后，只需要往對應的JobDataMap中添加值即可。

監聽器

在Quartz框架下，有三種監聽器，分別是：時間軸監聽器ISchedulerListener，觸發規則監聽器ITriggerListener，任務監聽器IJobListener。要實現對應監聽器，實現對應接口即可。實現監聽器步驟：

1. 創建監聽器

根據不同的需要，可以創建不同的監聽器，如下所示：

時間軸監聽器SchedulerListener

public class TestSchedulerListener : ISchedulerListener
{
    public Task JobAdded(IJobDetail jobDetail, CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test Job is added.");
        });
    }

    public Task JobDeleted(JobKey jobKey, CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test Job is deleted.");
        });
    }

    public Task JobInterrupted(JobKey jobKey, CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test Job is Interrupted.");
        });
    }

    public Task JobPaused(JobKey jobKey, CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test Job is paused.");
        });
    }

    public Task JobResumed(JobKey jobKey, CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test Job is resumed.");
        });
    }

    public Task JobScheduled(ITrigger trigger, CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test Job is scheduled.");
        });
    }

    public Task JobsPaused(string jobGroup, CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test Jobs is paused.");
        });
    }

    public Task JobsResumed(string jobGroup, CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test Jobs is resumed.");
        });
    }

    public Task JobUnscheduled(TriggerKey triggerKey, CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test Jobs is un schedulered.");
        });
    }

    public Task SchedulerError(string msg, SchedulerException cause, CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test scheduler is error.");
        });
    }

    public Task SchedulerInStandbyMode(CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test scheduler is standby mode.");
        });
    }

    public Task SchedulerShutdown(CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test scheduler is shut down.");
        });
    }

    public Task SchedulerShuttingdown(CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test scheduler is shutting down.");
        });
    }

    public Task SchedulerStarted(CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test scheduleer is started.");
        });
    }

    public Task SchedulerStarting(CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test scheduler is starting.");
        });
    }

    public Task SchedulingDataCleared(CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test scheduling is cleared.");
        });
    }

    public Task TriggerFinalized(ITrigger trigger, CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test trigger is finalized.");
        });
    }

    public Task TriggerPaused(TriggerKey triggerKey, CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test trigger is paused.");
        });
    }

    public Task TriggerResumed(TriggerKey triggerKey, CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test trigger is resumed.");
        });
    }

    public Task TriggersPaused(string? triggerGroup, CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test triggers is paused.");
        });
    }

    public Task TriggersResumed(string? triggerGroup, CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test triggers is resumed.");
        });
    }
}

觸發規則監聽器TriggerListener

/// <summary>
/// 觸發器監聽
/// </summary>
public class TestTriggerListener : ITriggerListener
{
    public string Name => "TestTriggerListener";

    public Task TriggerComplete(ITrigger trigger, IJobExecutionContext context, SchedulerInstruction triggerInstructionCode, CancellationToken cancellationToken = default)
    {
        //任務完成
        return Task.Run(() => {
            Console.WriteLine("Test trigger is complete.");

        });
    }

    public Task TriggerFired(ITrigger trigger, IJobExecutionContext context, CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test trigger is fired.");

        });
    }

    public Task TriggerMisfired(ITrigger trigger, CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test trigger is misfired.");

        });
    }

    public Task<bool> VetoJobExecution(ITrigger trigger, IJobExecutionContext context, CancellationToken cancellationToken = default)
    {
        return Task.Run(() => {
            Console.WriteLine("Test trigger is veto.");
            return false;//是否終止
        });
    }
}

JobListener任務監聽器

/// <summary>
/// TestJob監聽器
/// </summary>
public class TestJobListener : IJobListener
{
    public string Name => "TestJobListener";

    public Task JobExecutionVetoed(IJobExecutionContext context, CancellationToken cancellationToken = default)
    {
        //任務被終止時
        return Task.Run(() => {
            Console.WriteLine("Test Job is vetoed.");
        });
    }

    public Task JobToBeExecuted(IJobExecutionContext context, CancellationToken cancellationToken = default)
    {
        //任務被執行時
        return Task.Run(() => {
            Console.WriteLine("Test Job is to be executed.");
        });
    }

    public Task JobWasExecuted(IJobExecutionContext context, JobExecutionException? jobException, CancellationToken cancellationToken = default)
    {
        //任務已經執行
        return Task.Run(() => {
            Console.WriteLine("Test Job was executed.");
        });
    }
}

2. 添加監聽

在時間軸上的監聽管理器中進行添加，如下所示：

//增加監聽
 scheduler.ListenerManager.AddJobListener(new TestJobListener());
 scheduler.ListenerManager.AddTriggerListener(new TestTriggerListener());
 scheduler.ListenerManager.AddSchedulerListener(new TestSchedulerListener());

日志管理

在Quartz框架中，創建之前會進行日志創建檢測，所以如果需要獲取框架中的日志信息，可以進行創建實現ILogProvider，如下所示：

public class TestLogProvider : ILogProvider
{
    public Logger GetLogger(string name)
    {
        return (level, func, exception, parameters) =>
        {
            if (level >= Quartz.Logging.LogLevel.Info && func != null)
            {
                Console.WriteLine("[" + DateTime.Now.ToLongTimeString() + "] [" + level + "] " + func(), parameters);
            }
            return true;
        };
    }

    public IDisposable OpenMappedContext(string key, object value, bool destructure = false)
    {
        throw new NotImplementedException();
    }

    public IDisposable OpenNestedContext(string message)
    {
        throw new NotImplementedException();
    }
}

然后在當前的Scheduler中，添加日志即可，如下所示：

 //日志
 LogProvider.SetCurrentLogProvider(new TestLogProvider());

完整示例

在添加了監聽器，日志，參數傳遞，任務特性后，完整的目錄結構，如下所示：

示例截圖

到此，關于“怎么使用.NET6+Quartz實現定時任務”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！