.NET6+Quartz实现定时任务的示例详解

在实际工作中，经常会有一些需要定时操作的业务，如：定时发邮件，定时统计信息等内容，那么如何实现才能使得我们的项目整齐划一呢？本文通过一些简单的小例子，简述在.Net6+Quartz实现定时任务的一些基本操作，及相关知识介绍，仅供学习分享使用，如有不足之处，还请指正。

什么是定时任务

定时任务，也叫任务调度，是指在一定的载体上，根据具体的触发规则，执行某些操作。所以定时任务需要满足三个条件：载体（Scheduler），触发规则（Trigger），具体业务操作（Job）。如下所示：

什么是Quartz

Quartz 是一个开源的作业调度框架，它完全由 Java 写成，并设计用于 J2SE 和 J2EE 应用中。它提供了巨大的灵活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。它有很多特征，如：数据库支持，集群，插件，EJB 作业预构建，JavaMail 及其它，支持 cron-like 表达式等等。虽然Quartz最初是为Java编写的，但是目前已经有.Net版本的Quartz，所以在.Net中应用Quartz已经不再是奢望，而是轻而易举的事情了。

Github上开源网址为：https://github.com/quartznet

关于Quartz的快速入门和API文档，可以参考：https://www.quartz-scheduler.net/documentation/quartz-3.x/quick-start.html

涉及知识点

在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());