8、quartz.net 支持多点部署的job服务

github地址

https://github.com/quartznet/quartznet

1、概念、作用

quartz是一个job工具，什么是job，可以理解成windows的计划任务。也可以理解成数据库的作业

为什么要用，因为需要用，为什么不用数据库作业去跑，请放过数据库吧

2、安装

因为我是集成在程序里的，所以直接nuget安装库就就可以了

Quartz

Quartz.Serialization.Json（这个必须要，不用问为啥）

3、思路

.net core 基本就是ioc的理念，所以接下来用依赖注入的思路来实现一个小功能，每10秒，输出当前时间到日志内，简约而不简单，因为基本上定时任务就是干这个的

4、开始

4.1 数据库脚本执行

quartz依赖数据库做持久化，支持很多种数据库，可以在下面的网址查看

https://github.com/quartznet/quartznet/tree/master/database/tables

弄下来直接执行就行了

mysql数据库安装配置前面说过了

https://www.cnblogs.com/ares-core/p/12956219.html

4.2 配置文件

我们在apollo里，增加一个namespace，然后加入到程序里

Apollo 安装配置请看

https://www.cnblogs.com/ares-core/p/12964701.html

https://www.cnblogs.com/ares-core/p/12975477.html

配置信息如下

{
	"Quartz": {
	　　"Enable": true,
	　　"JobStoreType": "Quartz.Impl.AdoJobStore.JobStoreTX, Quartz",
	　　"JobStoreTablePrefix": "QRTZ_",
	　　"DriverDelegateType": "Quartz.Impl.AdoJobStore.MySQLDelegate,Quartz",
	　　"JobStoreDataSource": "myDS",
	　　"DataSourceProvider": "MySql",
	　　"ConnectionString": "Server=192.168.137.220; Port=3306; Database=quartznet; Uid=root; Pwd=123456; persistsecurityinfo=True; CharSet=utf8; SslMode=none;",
	　　"Tasks": [{
           　　 "JobName": "GameApiTest",
            　　"JobGroup": "GameApi",
            　　"ScheduleTaskType": "GameApi.Web.ScheduleTask.ITest",
            　　"Type": 3,
            　　"Cron": "0/10 * * * * ?",
           　　 "Data": "",
            　　"Description": "测试"
          　　}]
	}
}

　先别管干什么的，一会儿写代码的时候会挨个说

4.3 创建启动服务

干啥用？就是程序启动的时候，根据上面的配置文件，创建任务，当然要判断一下，有没有这个任务，有的话就跳过添加，没有的话就添加

怎么实现？继承 IHostedService 接口即可，IHostedService是啥？去问msdn

首先我们创建一个job全局类，原因后面说

using System;
using Quartz;
namespace GameApi.Quartz4Net
{
    public static class JobApplicationContext
    {
        public static IScheduler Scheduler { get; set; }
    }
}

然后是两个entity类，用来反序列化Apollo里的参数

using System.Collections.Generic;

namespace GameApi.Quartz4Net
{
    public class ScheduleTaskParameter
    {
        public int Type { get; set; }
        public string ScheduleTaskType { get; set; }
        public int DelaySeconds { get; set; }
        public int RepeatCount { get; set; }
        public string Data { get; set; }
        public string Cron { get; set; } = string.Empty;
        public string JobName { get; set; } = string.Empty;
        public string JobGroup { get; set; } = string.Empty;
        public string Description { get; set; } = string.Empty;
        public string TriggerName { get; set; } = string.Empty;
        public string TriggerGroup { get; set; } = string.Empty;
    }

    public class QuartzOptions
    {
        public bool Enable { get; set; }
        public string JobStoreType { get; set; }
        public string JobStoreTablePrefix { get; set; }
        public string DriverDelegateType { get; set; }
        public string JobStoreDataSource { get; set; }
        public string DataSourceProvider { get; set; }
        public string ConnectionString { get; set; }
        public List<ScheduleTaskParameter> Tasks { get; set; }
    }
}

我们新建一个类 ScheduleTaskHostedService 继承IHostedService 接口，实现在程序启动的时候，去初始化任务

代码

using GameApi.Quartz4Net.Internals;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options;
using Quartz;
using Quartz.Impl;
using System;
using System.Collections.Specialized;
using System.Threading;
using System.Threading.Tasks;

namespace GameApi.Quartz4Net
{
    public class ScheduleTaskHostedService : IHostedService
    {
        // 获取注入的参数
        private readonly QuartzOptions _options;
        // 获取注入的serviceProvider
        private readonly IServiceProvider _serviceProvider;
        // 构造函数
        public ScheduleTaskHostedService(IOptions<QuartzOptions> options,IServiceProvider serviceProvider)
        {
            this._options = options.Value;
            this._serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
        }
        // 实现 IHostedService 接口， 在系统启动时会执行
        public async Task StartAsync(CancellationToken cancellationToken)
        {
            // 验证apollo内的enable参数是否开启
            if (!this._options.Enable) return;
            // 初始化一些属性，用来创建任务对象（单例模式）
            var properties = new NameValueCollection
            {
                // 去Apollo看配置 
                ["quartz.jobStore.type"] = this._options.JobStoreType,
                // 去Apollo看配置 
                ["quartz.jobStore.tablePrefix"] = this._options.JobStoreTablePrefix,
                // 去Apollo看配置 
                ["quartz.jobStore.driverDelegateType"] = this._options.DriverDelegateType,
                // 固定的myDS 
                ["quartz.jobStore.dataSource"] = this._options.JobStoreDataSource,
                // 数据库连接字符串
                ["quartz.dataSource.myDS.connectionString"] = this._options.ConnectionString,
                // 数据库类型
                ["quartz.dataSource.myDS.provider"] = this._options.DataSourceProvider,
                // 序列化方式 有json 和 binary 如果是json 的话，必须nuget引用Quartz.Serialization.Json
                ["quartz.serializer.type"] = "json",
                // 是否多点部署 
                ["quartz.jobStore.clustered"] = "true",
                ["quartz.scheduler.instanceId"] = "AUTO"
            };
            // 初始化一个schedule对象 因为是单例模式的，所以要用一个全局的静态类来存一下
            JobApplicationContext.Scheduler = await new StdSchedulerFactory(properties).GetScheduler();
            // 设置1s的延时启动 没啥特别的，就是记录一下它可以延时启动
            await JobApplicationContext.Scheduler.StartDelayed(TimeSpan.FromSeconds(1d), cancellationToken);

            // 通过生命周期获取 scheduleTaskProvider
            using (var scope = this._serviceProvider.CreateScope())
            {
                //var scheduleTaskProvider = scope.ServiceProvider.GetRequiredService<IScheduleTaskProvider>();

                // 循环获取apollo中的任务列表
                foreach (var parameter in this._options.Tasks)
                {
                    // 获取到任务的Key
                    var jobKey = JobKey.Create(parameter.JobName, parameter.JobGroup);
                    // 验证任务是否已经创建
                    var isExist = await JobApplicationContext.Scheduler.CheckExists(jobKey, cancellationToken);
                    if (isExist) continue;
                    // 没有创建的进行创建
                    var jobName = parameter.JobName;
                    var jobGroup = parameter.JobGroup;
                    // 创建任务明细
                    var jobBuilder = JobBuilder
                        // 这个InnerJob类 是最终执行业务代码的入口类，代码下面给出
                        .Create<InnerJob>()
                        .WithIdentity(jobName, jobGroup)
                        .UsingJobData("type", parameter.Type)
                        .UsingJobData("schedule_task_type", parameter.ScheduleTaskType)
                        .UsingJobData("data", parameter.Data)
                        .UsingJobData("delay_seconds", parameter.DelaySeconds)
                        .UsingJobData("cron", parameter.Cron)
                        .UsingJobData("repeatCount", parameter.RepeatCount)
                        .UsingJobData("repeat_count", parameter.RepeatCount);
                    jobBuilder.WithDescription(parameter.Description ?? string.Empty);
                    var jobDetail = jobBuilder.Build();

                    // 创建触发器
                    // cron 表达式 https://cron.qqe2.com/
                    var triggerBuilder = TriggerBuilder.Create().WithIdentity(jobName, jobGroup);
                    switch (parameter.Type)
                    {
                        case 3: // 基于 cron 表达式的周期性任务
                            if (string.IsNullOrWhiteSpace(parameter.Cron))
                            {
                                throw new ArgumentException("计划任务 cron 表达式不能为空");
                            }

                            triggerBuilder = triggerBuilder.WithCronSchedule(parameter.Cron, builder =>
                            {
                                builder.InTimeZone(TimeZoneInfo.Local);
                            });
                            break;
                        default:
                            throw new ArgumentException("未知任务类型 Type ");
                    }
                    var trigger = triggerBuilder.ForJob(jobDetail.Key).Build();

                    // 创建任务
                    await JobApplicationContext.Scheduler.ScheduleJob(jobDetail, trigger);
                     
                }
            }
        }

        public async Task StopAsync(CancellationToken cancellationToken)
        {
            if (!this._options.Enable) return;

            await JobApplicationContext.Scheduler.Shutdown(cancellationToken);
        }
    }
}

定义一个接口用来反射实现执行任务，凡是继承了这个接口的，并且接口名称与配置文件相匹配的，就执行

using System.Threading.Tasks;

namespace GameApi.Quartz4Net
{
    public interface IScheduleTask
    {
        // 执行计划任务。
        Task RunAsync(ScheduleTaskContext context);
    }
}

下面是InnerJob类，他继承了IJob，通俗的来说，就是触发器的实现，下面用反射的思路来实现

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Quartz;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace GameApi.Quartz4Net.Internals
{
    internal class InnerJob : IJob
    {
        public InnerJob()
        {

        }
        public async Task Execute(IJobExecutionContext context)
        {
            using (var childScope = JobApplicationContext.IoC.CreateScope())
            {
                var logger = childScope.ServiceProvider.GetRequiredService<ILoggerFactory>().CreateLogger<InnerJob>();
                var scheduleTaskType = context.JobDetail.JobDataMap.GetString("schedule_task_type");
                var data = context.JobDetail.JobDataMap.GetString("data");
                var delaySeconds = context.JobDetail.JobDataMap.GetInt("delay_seconds");

                foreach (var kv in context.JobDetail.JobDataMap)
                {
                    logger.LogInformation("计划任务参数：{0} = {1}", kv.Key, kv.Value);
                }

                var type = AssemblyHelper.GetType(scheduleTaskType);
                if (type == null)
                {
                    logger.LogWarning("未找到指定的任务类型: {0}", scheduleTaskType);
                    return;
                }
                var instances = childScope.ServiceProvider.GetServices(type);
                if (instances == null || !instances.Any()) return;

                foreach (var obj in instances)
                {
                    var instance = obj as IScheduleTask;
                    if (instance == null)
                    {
                        logger.LogWarning("任务 {0} 必须继承 {1} 接口", scheduleTaskType, nameof(IScheduleTask));
                        continue;
                    }
                    try
                    {
                        var scheduleTaskContext = new ScheduleTaskContext
                        {
                            Data = data,
                            TaskId = context.JobDetail.Key.Name,
                            TaskGroup = context.JobDetail.Key.Group
                        };
                        await instance.RunAsync(scheduleTaskContext);
                    }
                    catch (Exception e)
                    {
                        logger.LogError(e, "调用计划任务异常。");
                    }
                }
            }
        }
    }

    public static class AssemblyHelper
    {
        private static List<Assembly> _applicationAssemblies { get; } =
            AppDomain.CurrentDomain.GetAssemblies()
            .Where(asm => asm.FullName.StartsWith("GameApi.", StringComparison.OrdinalIgnoreCase)).ToList();

        /// <summary>
        /// 通过指定的类型名称获取一个类型 <see cref="Type"/> 。
        /// </summary>
        /// <param name="typeFullName"></param>
        /// <returns></returns>
        public static Type GetType(string typeFullName)
        {
            var items = typeFullName.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
            var builder = new StringBuilder(typeFullName.Length);
            var index = items.Length;
            Assembly assembly = null;
            while (index > 0)
            {
                builder.Clear();
                if (index < 0) return null;
                for (var i = 0; i < index; i++)
                {
                    builder.Append(items[i]).Append('.');
                }
                builder.Remove(builder.Length - 1, 1);
                --index;
                assembly = _applicationAssemblies.FirstOrDefault(_ => _.FullName.StartsWith(builder.ToString(), StringComparison.OrdinalIgnoreCase));
                if (assembly != null)
                {
                    break;
                }
            }
            var type = assembly.GetType(typeFullName, false, true);
            return type;
        }
    }
}

然后我们把　 ScheduleTaskHostedService 这个类，注入到容器内，为了可扩展性，这种东西我们一般都写一个扩展类来实现，我们在新建一个 ServiceCollectionExtensions 类

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace GameApi.Quartz4Net
{
    public static class ServiceCollectionExtensions
    {
        // 扩展类 添加 Quartz.NET 组件支持。
        public static IServiceCollection AddQuartz(this IServiceCollection services, IConfiguration configuration)
        {
            // 单例注入
            services.AddSingleton<IHostedService, ScheduleTaskHostedService>();
            // 配置
            services.Configure<QuartzOptions>(configuration.GetSection("Quartz"));
            return services;
        }
    }
}

然后在startup里，add一下

services.AddQuartz(this.Configuration);

至此，服务端的实现已经完毕，接下来就是怎么用了

我们回头来解读一下apollo的配置文件，只说重要的部分

DataSourceProvider 和 ConnectionString 是数据库相关的配置

Tasks 这个就是一个job集合，可以是多个，下面是task子节点的说明

JobName 名称，需要全局唯一，不可为空

JobGroup 分组，不能为空

ScheduleTaskType 任务类型，这个下面在定义客户端的时候会用到，因为是用反射执行代码，所以这个一定不可以错，错i的话任务创建成功了但是不会执行

Type 任务执行的方式目前只实现了基于Cron表达式的方式，其他的可以自己去查文档

Cron 周期表达式参考 https://cron.qqe2.com/

Data 自定义参数

Description 任务描述（可以用来看日志）

4.4 执行任务

上面已经把任务定义好了，那么怎么实现呢，在4..3结尾的地方说到了用反射的方式去执行任务，下面给出具体实现，其实就是实现上面定义的IScheduleTask接口

先定义一个接口，继承 IScheduleTask 接口（面向对象已经过时了，要面向接口）

using GameApi.Quartz4Net;

namespace GameApi.Web.ScheduleTask
{
    public interface ITest : IScheduleTask
    {
    }
}

注意，上面Apollo里面的ScheduleTaskType参数，是

GameApi.Web.ScheduleTask.ITest

这个接口的名字和namespace，要跟上面的配置文件对应上

然后实现这个test接口

using GameApi.Quartz4Net;
using Microsoft.Extensions.Logging;
using System;
using System.Threading.Tasks;

namespace GameApi.Web.ScheduleTask
{
    public class Test : ITest
    {
        private readonly ILogger<Test> _logger;
        public Test(ILogger<Test> logger)
        {
            this._logger = logger;
        }
        public Task RunAsync(ScheduleTaskContext context)
        {
            this._logger.LogInformation($"当前时间:{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");

            return Task.CompletedTask;
        }
    }
}

同样，注入到service里面

services.AddTransient<ITest, Test>();

F5 运行，结果如下

接下来多点部署，看会不会起冲突，其实就是试试

["quartz.jobStore.clustered"] = "true",

这个参数好不好使

起了8801，8802两个端口，结果如下

结果证明，多点部署后，只会打到一个节点上，不会有多点消费的情况