基于.Net Core 5.0 Worker Service 的 Quart 服务

前言

看过我之前博客的人应该都知道，我负责了相当久的部门数据同步相关的工作。其中的艰辛不赘述了。

随着需求的越来越复杂，最近windows的计划任务已经越发的不能满足我了，而且计划任务毕竟太弱智，总是会失败之类，强制结束之类的。

最近增加了一些复杂的参数，每天的任务对同步程序调用需要多次调用不同参数，我也终于打算不再忍受弱智的计划任务。最初测试了一下基于 IIS 的 Quart ，发现还是存在会被回收无法定时的情况，

在此之前我并未做过 Quart 相关的开发。我查了查相关资料，可以更改 IIS 设置修改定时回收的模式，可以通过访问站点来唤醒等，觉得不是很合适。而且综合业务的考虑，实在是没必要在内网客户机搭一个 Web 站点。

这样一来，干脆搞一个 WindowsService 得了，而且定时的场景还是比较常见的，写一份肯定不亏，以后还是用的上。而且也没尝试过基于 Core 写 WindowsService，正好借此机会学习一下。

Worker Service

使用 VS2019 ，安装了 .NET CORE 3.0 以上的 SDK ，安装SDK的时候最好也安装运行时，免得最后忘记。

项目模板自带的代码如下：

using System;

using System.Collections.Generic;

using System.Linq;

using System.Runtime.InteropServices;

using System.Threading.Tasks;

using Microsoft.Extensions.DependencyInjection;

using Microsoft.Extensions.Hosting;

namespace WorkerServiceTest

{

    public class Program

    {

        public static void Main(string[] args)

        {

            CreateHostBuilder(args).Build().Run();

        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>

      Host.CreateDefaultBuilder(args)

      .ConfigureServices((hostContext, services) =>

      {

          services.AddHostedService<Worker>();

      });

        }

    }

}

Program.cs中，依旧是创建一个 IHost 并启动。为了方便进行依赖注入，可以创建一个 IServiceCollection 的扩展方法来进行相关服务的注册。

而 Worker 类已经提供了一个默认例子，其中有一个 ExecuteAsync 方法，可以直接执行后台任务。这个时候，直接F5就可以正常运行了实现了一个显示当前时间的程序。

Work 类继承 BackgroundService，并重写其 ExecuteAsync 方法。显而易见，ExecuteAsync 方法就是执行后台任务的入口。

Quartz.Net

Quartz.Net 是一个功能齐全的开源作业调度系统，可以在最小规模的应用程序到大型企业系统使用。

Quartz.Net有三个主要概念:

job 这是你想要运行的后台任务。
trigger trigger 控制 job 何时运行，通常按某种调度规则触发。
scheduler 它负责协调 job 和 trigger，根据 trigger 的要求执行 job。

ASP.NET Core 很好地支持通过 hosted services（托管服务）运行“后台任务”。当你的 ASP.NET Core 应用程序启动，托管服务也启动，并在应用程序的生命周期中在后台运行。

现在有了一个官方包 Quartz.Extensions.Hosting 实现使用 Quartz.Net 运行后台任务，所以把 Quartz.Net 添加到 ASP.NET Core 或 Worker Service 要简单得多。

Quartz.Net 3.2.0 通过 Quartz.Extensions.Hosting 引入了对该模式的直接支持。

Quartz.Extensions.Hosting 即可以用在ASP.NET Core应用程序，也可以用在基于“通用主机”的Worker Service。

虽然可以创建一个“定时”后台服务(例如，每10分钟运行一个任务)，但Quartz.NET提供了一个更加健壮的解决方案。

通过使用Cron trigger，你可以确保任务只在一天的特定时间(例如凌晨2:30)运行，或者只在特定的日子运行，或者这些时间的任意组合运行。

Quartz.Net还允许你以集群的方式运行应用程序的多个实例，以便在任何时候只有一个实例可以运行给定的任务。

Quartz.Net托管服务负责Quartz的调度。它将在应用程序的后台运行，检查正在执行的触发器，并在必要时运行相关的作业。

你需要配置调度程序，但不需要担心启动或停止它，IHostedService 会为你管理。

引用 Quartz.Net

你可以通过使用 dotnet add package Quartz.Extensions.Hosting 命令安装 Quartz.Net 包。

如果你查看项目的.csproj，它应该是这样的:

<Project Sdk="Microsoft.NET.Sdk.Worker">

  <PropertyGroup>

    <TargetFramework>net5.0</TargetFramework>

    <UserSecretsId>dotnet-QuartzWorkerService-9D4BFFBE-BE06-4490-AE8B-8AF1466778FD</UserSecretsId>

  </PropertyGroup>

  <ItemGroup>

    <PackageReference Include="Microsoft.Extensions.Hosting" Version="5.0.0" />

		<PackageReference Include="Quartz.Extensions.Hosting" Version="3.3.2" />

  </ItemGroup>

</Project>

添加 Quartz.Net 托管服务

注册Quartz.Net需要做两件事：

注册Quartz.Net需要的DI容器服务。
注册托管服务。

在 ASP.NET Core 中，通常会在 Startup.ConfigureServices() 方法中完成这两项操作。

但 Worker Services 不使用 Startup 类，所以我们在 Program.cs 中的 IHostBuilder 的 ConfigureServices 方法中注册它们:

    public class Program

    {

        public static void Main(string[] args)

        {

            //...

        }

        public static IHostBuilder CreateHostBuilder(string[] args)

        {

            IHostBuilder hostBuilder = Host.CreateDefaultBuilder(args);

            hostBuilder.ConfigureServices((hostContext, services) =>

            {

                services.AddQuartz(q =>

                {

                    q.UseMicrosoftDependencyInjectionScopedJobFactory();

                    //q.InitJobAndTriggerFromJobsettings(hostContext.Configuration);

                });

                services.AddQuartzHostedService(q => q.WaitForJobsToComplete = true);

                //services.AddHostedService<Worker>();

            });

            //Windows

            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))

            { hostBuilder.UseWindowsService(); }

            //Linux

            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))

            { hostBuilder.UseSystemd(); }

            return hostBuilder;

        }

    }

}

UseMicrosoftDependencyInjectionScopedJobFactory 告诉 Quartz.NET 注册一个 IJobFactory，该 IJobFactory 通过从DI容器中创建 job。

方法中的 Scoped 部分意味着你的作业可以使用 scoped 服务，而不仅仅是 single 或 transient 服务。

WaitForJobsToComplete 用来设置确保当请求关闭时，Quartz.NET在退出之前优雅地等待作业结束。

如果你现在运行应用程序，将看到Quartz服务启动，并将大量日志转储到控制台，因为篇幅原因，此处不再贴出。

另外可能有读者注意到了其中的 hostBuilder.UseWindowsService();/hostBuilder.UseSystemd();

这是关于跨平台的一段设置，稍后会有简单讲解。

此时，你已经让 Quartz 作为托管服务在你的应用程序中运行，但是没有任何job让它运行。在下一节中，我们将创建并注册一个简单的job。

创建 Job

因为我的场景是定时运行一个EXE，最常见的通用定时任务场景应该是调用一个接口。

这里举例一个打印日志的Job，我的相关源代码会在结尾处放出。

using Quartz;

using Serilog;

using System;

using System.Threading.Tasks;

namespace AX.QuartzServer.Core.Jobs

{

    [DisallowConcurrentExecution]

    public class TestJob : AXQuartzJob

    {

        public string Name { get { return "测试Job"; } }

        public string Note { get { return "会打印日志"; } }

        public Task Execute(IJobExecutionContext context)

        {

            Log.Logger.Information($"{Newtonsoft.Json.JsonConvert.SerializeObject(context.JobDetail.JobDataMap)}");

            Log.Logger.Information($"Hello world! {DateTime.Now.ToLongTimeString()}");

            return Task.CompletedTask;

        }

    }

}

这里我使用了全局的 Serilog 来记录日志。所以和一般的日志不太一样。

我还用 [DisallowConcurrentExecution] 属性装饰了 job 。此属性防止Quartz.NET试图同时运行相同的作业。

它将定时的在日志或控制台中打印 Hello world! 和当前时间。

现在我们已经有了作业，我们需要将它与 trigger 一起注册到 DI 容器中。

启动时自动配置Job

Quartz.NET 为运行 job 提供了一些简单的 schedule，但最常见的方法之一是使用 Quartz.NET Cron 表达式，这里不再赘述。

因为我的场景是Windows服务，暂不考虑一些高级的，可以实时停止，注册Job，运行Job之类的封装。

所以决定是在启动时直接通过读取配置文件注册 Job。

下面是注册的关键代码：

    public static class AXQuartzConfigExtensions

    {

        public static void InitJobAndTriggerFromJobsettings(this IServiceCollectionQuartzConfigurator quartz, IConfiguration configuration)

        {

            var allJobs = configuration.GetSection("Jobs").Get<List<BaseJobConfig>>();

            Log.Logger.Information($"开始注册 Job");

            Log.Logger.Information($"共获取到 {allJobs.Count} 个 Job");

            foreach (var item in allJobs)

            {

                Log.Logger.Information($"{JsonConvert.SerializeObject(item)}");

                var jobName = $"{item.JobType}_{item.Name}";

                var jobKey = new JobKey(jobName);

                Log.Logger.Information($"{nameof(jobKey)}_{jobKey}");

                var jobData = new JobDataMap();

                jobData.PutAll(ToIDictionary(item));

                if (item.JobType.ToLower().Contains("testjob"))

                { quartz.AddJob<Jobs.TestJob>(opts => { opts.WithIdentity(jobKey); opts.SetJobData(jobData); }); }

                if (item.JobType.ToLower().Contains("windowscmdjob"))

                { quartz.AddJob<Jobs.WindowsCMDJob>(opts => { opts.WithIdentity(jobKey); opts.SetJobData(jobData); }); }

                quartz.AddTrigger(opts => opts

                    .ForJob(jobKey)

                    .WithIdentity($"{jobName}_Trigger")

                    .WithCronSchedule(item.Cron));

            }

            Log.Logger.Information($"结束注册 Job");

        }

        //...

    }

从配置文件中读取了配置之后，为每个 job 创建唯一的 JobKey 。这用于将job与其trggier连接在一起。

用 AddJob 注册我们的 TestJob。它将 TestJob 添加到了 DI 容器中，这样就可以创建它。它还在内部向 Quartz 注册了job。

然后用 AddTrigger 添加触发器，

使用 JobKey 将 trigger 与一个 job 关联起来，并为 trigger 提供唯一的名称(在本例中不是必需的，但如果你在集群模式下运行quartz，这很重要)。

最后，为trigger 设置了 Cron 表达式， Cron 表达式来自配置文件，测试时我用的是每五秒一次。

其中有一些快速实现时未优化的弱智代码之类的，各位读者不用在意。

配置文件配置节：

{

  "Logging": {

      //...

    }

  },

  //任务配置 DEMO

  "JobDemo": {

    "Name": "唯一任务名称",

    "JobType": "任务类型 windowscmdjob/testjob",

    "Cron": "运行时间表达式"

  },

  "Jobs": [

    {

      "Name": "LogHelloWorldTest",

      "JobType": "testjob",

      "Cron": "0 0 */1 * * ?" //这是每小时一次

      //"Cron": "0/5 * * * * ?" 这是每五秒一次

    }

  ]

}

如果你现在运行你的应用程序，你会看到和以前一样的启动消息，然后每5秒你会看到HelloWorldJob写入控制台:

这就是搭建一个定时服务的全部关键内容了。

跨平台

在 Host.CreateDefaultBuilder(args) 增加相关环境的调用。

可以使用判断平台的一个函数： IsOSPlatform ，可以判断是否在Windows平台运行，并进行分别调用。

虽然程序可以正常执行，但是还不能正常部署为服务，需要依据平台添加对应的nuget包：

windows服务，需要添加：

Install-Package Microsoft.Extensions.Hosting.WindowsServices

Linux服务，需要添加：

Install-Package Microsoft.Extensions.Hosting.Systemd

.UseWindowsService();

.UseSystemd();

Windows下部署

管理员下运行cmd/powershell，执行

sc.exe create WorkerServiceTest binPath=【你编译后的exe路径，不需要带双引号】

提示 CreateService 成功 即安装成功了，可以输入下面的命令运行服务。

sc.exe start WorkerServiceTest

sc.exe负责管理服务，具体配置启动方式和删除，可以查看命令的帮助。另外，友情提醒，如果是在powershell中，不要省略这个.exe，sc有别的用处...

开源代码

https://github.com/aaxuan/AX.QuartzServer（请选择性的忽略其他仓库的垃圾代码：）

本文将同步发布到个人的语雀博客，欢迎使用语雀的小伙伴相互关注。

https://www.yuque.com/cuxuan

参考

https://devblogs.microsoft.com/aspnet/net-core-workers-as-windows-services/

https://devblogs.microsoft.com/dotnet/net-core-and-systemd/

https://docs.microsoft.com/en-us/dotnet/core/extensions/generic-host

https://dejanstojanovic.net/aspnet/2018/june/setting-up-net-core-servicedaemon-on-linux-os/

https://dotnetcoretutorials.com/2019/12/07/creating-windows-services-in-net-core-part-3-the-net-core-worker-way/

http://www.cnblogs.com/podolski/p/13890572.html

https://www.cnblogs.com/xhy0826/p/Net_Core_Windows_Service_Quartz.html

https://segmentfault.com/a/1190000038753018