Quartz 任务调度在 .Net Core 2.2 中的标准使用

Quartz.Net 是一款非常流行的任务调度组建,在很多系统中都必然要使用到,今天我就微软最新发布的.Net Core 2.2来介绍一下它的标准使用,也大致说下网上的那些不太正确的使用方式,当然那些也没错。

网上有三种方式来做 .Net core+Quartz 的任务调度,我来分析它,说说的弊端在哪里

第一种:用 Microsoft.AspNetCore.WebHost 来宿主Jobs服务
在.Net Core 2.1 还没有发布之前,使用 WebHost 宿主Jobs服务那也无可厚非,毕竟 .Net Core 控制台应用程序还没有官方的宿主方式,自打 .Net Core 2.1 开始,微软新增了 Microsoft.Extensions.Hosting ,其实看源码就是从 Microsoft.AspNetCore.WebHost 中分离出来,做了简化,把Web相关依赖去掉了。

第二种:把任务与触发器都写在了代码中,而没有使用配置文件
比如这样的封装:QuartzHelpers.StartAsync<HelloWorldJob>("0 0 3 * * ?", "myjob", "mytrigger", "mygroup");

第三种:自己实现配置关系的映射,类似如下实现,这个自己实现对大部分用户都是不必要的,因为配置文件就可以做到
public class QuartzOption
{
public QuartzOption(IConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}

var section = config.GetSection("quartz");
section.Bind(this);
}

public Scheduler Scheduler { get; set; }

public ThreadPool ThreadPool { get; set; }

public Plugin Plugin { get; set; }

public NameValueCollection ToProperties()
{
var properties = new NameValueCollection
{
["quartz.scheduler.instanceName"] = Scheduler?.InstanceName,
["quartz.threadPool.type"] = ThreadPool?.Type,
["quartz.threadPool.threadPriority"] = ThreadPool?.ThreadPriority,
["quartz.threadPool.threadCount"] = ThreadPool?.ThreadCount.ToString(),
["quartz.plugin.jobInitializer.type"] = Plugin?.JobInitializer?.Type,
["quartz.plugin.jobInitializer.fileNames"] = Plugin?.JobInitializer?.FileNames
};

return properties;
}
}

上面说了3个我认为不标准的姿势,现在我来说说标准的姿势,整个demo项目包含6个文件,包括2个配置文件在内
1. 先说说Job类
namespace QuartzNetCore
{
[DisallowConcurrentExecution]
public class HelloWorldJob : IJob
{
private readonly ILogger<HelloWorldJob> _logger;
public HelloWorldJob(ILogger<HelloWorldJob> logger)
{
_logger = logger;
}

public Task Execute(IJobExecutionContext context)
{
_logger.LogInformation("Hello world!");
return Task.CompletedTask;
}
}
}
我得说说DisallowConcurrentExecution属性,这个属性告诉这个HelloWorldJob,每次执行都是一个挨一个执行,前面那次没有执行完成,后面那次执行是不允许进去的,也就是禁止HelloWorldJob的并发执行,对其他Job的执行不受影响。

2. 聊聊宿主类
namespace QuartzNetCore
{
public class HostServer : IHostedService
{
private readonly ILogger _logger;
private readonly ISchedulerFactory _schedulerFactory;
private readonly IJobFactory _jobFactory;

public HostServer(ILogger<HostServer> logger, ISchedulerFactory schedulerFactory, IJobFactory jobFactory)
{
_logger = logger;
_schedulerFactory = schedulerFactory;
_jobFactory = jobFactory;
}

public IScheduler Scheduler { get; set; }

public async Task StartAsync(CancellationToken cancellationToken)
{
_logger.LogInformation("开始Quartz调度...");

Scheduler = await _schedulerFactory.GetScheduler(cancellationToken);
Scheduler.JobFactory = _jobFactory;
await Scheduler.Start(cancellationToken);
}

public async Task StopAsync(CancellationToken cancellationToken)
{
_logger.LogInformation("停止Quartz调度...");

await Scheduler.Shutdown(cancellationToken);
}
}
}
IHostedService接口来之Microsoft.Extensions.Hosting,是一个轻量级的宿主接口,它提供启动与停止方法,这个对于docker部署非常友好。同时在这个启动方法里面,可以看见重新赋值了JobFactory,这个是为了可以让Job类也支持依赖注入。上面的Job类public HelloWorldJob(ILogger<HelloWorldJob> logger)就是一个接口注入。

3. 看看任务工厂
namespace QuartzNetCore
{
public class JobFactory : IJobFactory
{
private readonly IServiceProvider _serviceProvider;
public JobFactory(IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
}

public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler)
{
return _serviceProvider.GetRequiredService(bundle.JobDetail.JobType) as IJob;
}

public void ReturnJob(IJob job) { }
}
}
这个类的作用就是实现Job的依赖注入,前面已经提到。

4. 任务与触发器配置
<schedule>
<job>
<name>HelloWorldJob</name>
<group>TestGroup</group>
<description>HelloWorldJob测试任务</description>
<job-type>QuartzNetCore.HelloWorldJob, QuartzNetCore</job-type>
<durable>true</durable>
<recover>false</recover>
</job>
<trigger>
<simple>
<name>TestTrigger</name>
<group>TestGroup</group>
<description>TestTrigger测试触发器</description>
<job-name>HelloWorldJob</job-name>
<job-group>TestGroup</job-group>
<repeat-count>-1</repeat-count>
<repeat-interval>1000</repeat-interval>
</simple>
</trigger>
</schedule>
</job-scheduling-data>
其中job-type得注意,这个必须是:类名,程序集名。repeat-count为-1即无限的次数重复执行,repeart-internval是执行间隔,1000即为1秒。

5. 配置插件配置,主要指定job的配置文件,插件的类与程序集,还有线程数等
quartz.scheduler.instanceName = QuartzTest

quartz.threadPool.type = Quartz.Simpl.SimpleThreadPool, Quartz
quartz.threadPool.threadCount = 10
quartz.threadPool.threadPriority = Normal

quartz.plugin.jobInitializer.type = Quartz.Plugin.Xml.XMLSchedulingDataProcessorPlugin, Quartz.Plugins
quartz.plugin.jobInitializer.fileNames = ~/quartz_jobs.xml
我的说说,这个文件是会被自动找到的,只要你将它放到跟目录,Quartz.Plugins插件会解读它,所以整个项目中你看不见哪个地方有引用它。

6. 启动类
class Program
{
static void Main(string[] args)
{
var host = new HostBuilder()
.ConfigureHostConfiguration(configHost =>
{
configHost.SetBasePath(Directory.GetCurrentDirectory());
//configHost.AddJsonFile("hostsettings.json", true, true);
//configHost.AddEnvironmentVariables("ASPNETCORE_");
//configHost.AddCommandLine(args);
})
.ConfigureAppConfiguration((hostContext, configApp) =>
{
configApp.AddJsonFile("appsettings.json", true);
configApp.AddJsonFile($"appsettings.{hostContext.HostingEnvironment.EnvironmentName}.json", true);
configApp.AddEnvironmentVariables();
})
.ConfigureServices((hostContext, services) =>
{
services.AddLogging();
services.AddOptions();
services.AddSingleton<IJobFactory, JobFactory>();
services.AddSingleton<ISchedulerFactory, StdSchedulerFactory>();
services.AddHostedService<HostServer>();
services.AddSingleton<HelloWorldJob>();
})
.ConfigureLogging((hostContext, configLogging) =>
{
configLogging.AddConsole();
})
.UseConsoleLifetime()
.Build();

host.Run();
}
}
设置跟目录,添加配置文件,重要的是添加宿主类HostServer,还有注册接口与实现,确保依赖注入能正常运行。

总结:这个方式使用Quartz.Net是最轻量级的,也是具有最小代码的,后面需要添加Job都是在配置文件中来实现,无需修改c#代码。

github源码:https://github.com/iissy/QuartzNetCore
Posted by 何敏 on 2019/06/07 09:27:44