使用 Topshelf 组件一步一步创建 Windows 服务 (2) 使用Quartz.net 调度

上一篇说了如何使用 Topshelf 组件快速创建Windows服务，接下来介绍如何使用 Quartz.net

关于Quartz.net的好处，网上搜索都是一大把一大把的，我就不再多介绍。

先介绍需要用到的插件：

Quartz版本我用的 2.6.2的， 没有用3.0以上的，因为你用了就会知道，会打印出一大堆坑爹的日志文件，

我是没有找到如何屏蔽的办法，如果你们谁有，欢迎分享出来，我也学习一下，哈哈。

整个项目结构如下：

AppConfigHelper 文件需要改动一下，增加如下属性

         /// <summary>
         /// 程序标识
         /// </summary>
         [ConfigurationProperty("AppKey", IsRequired = true)]
         public string AppKey
         {
             get { return base["AppKey"].ToString(); }
             internal set { base["AppKey"] = value; }
         }

         /// <summary>
         /// 程序集信息
         /// </summary>
         [ConfigurationProperty("TypeInfo", IsRequired = true)]
         public string TypeInfo
         {
             get { return base["TypeInfo"].ToString(); }
             internal set { base["TypeInfo"] = value; }
         }

AppConfig文件也做稍微改动

 <?xml version="1.0" encoding="utf-8" ?>
 <configuration>
   <!--该节点一定要放在最上边-->
   <configSections>
     <section name="AppConfigHelper" type="Quartz.WinService.AppConfigHelper,Quartz.WinService"/>
   </configSections>

   <!--TopSelf服务配置文件 -->
   <AppConfigHelper
     ServiceName="ProcessPrintLogService"
     Desc="日志打印服务"
     AppKey="ProcessPrintLogService"
     TypeInfo="ProcessService.ProcessPrintLogService,ProcessService"
   />

   <startup>
     <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
   </startup>
 </configuration>

ProcessPrintLogService 就是Windows服务要执行的逻辑程序文件，可以执行任何你想要的功能

ProcessService.ProcessPrintLogService,ProcessService 是 命名空间.类名,类名  的格式，用于后边反射程序集用

假如你要执行其他业务逻辑程序，只需要更换这里的配置就行，

ProcessPrintLogService 业务逻辑内容如下：这就是我们要执行的业务逻辑，定时打印一段日志内容，可以创建一个类库，里边专门存放你要执行的业务逻辑

 namespace ProcessService
 {
     /// <summary>
     /// 日志打印服务
     /// </summary>
     public class ProcessPrintLogService
     {
         private Logger log = LogManager.GetCurrentClassLogger();
         /// <summary>
         /// 服务入口
         /// </summary>
         public void DoWork()
         {
             //log.Info("******************排行榜服务开始执行******************");
             try
             {
                 PrintLogMethod();
             }
             catch (Exception ex)
             {
                 log.Error(string.Format("排行榜服务异常，原因：{0}", ex));
             }
             finally
             {
                 //log.Info("******************排行榜服务结束执行******************");
             }
         }

         private void PrintLogMethod()
         {
             log.Trace(string.Format("我是日志:{0}号", Thread.CurrentThread.ManagedThreadId));
         }
     }
 }

然后需要新增加两个文件：quartz.config  和  quartz_jobs.xml

quartz.config文件内容如下：

# You can configure your scheduler in either <quartz> configuration section
# or in quartz properties file
# Configuration section has precedence

quartz.scheduler.instanceName = ServiceQuartzScheduler

# configure thread pool info
quartz.threadPool.type = Quartz.Simpl.SimpleThreadPool, Quartz
quartz.threadPool.threadCount =
quartz.threadPool.threadPriority = Normal

# job initialization plugin handles our xml reading, without it defaults are used
quartz.plugin.xml.type = Quartz.Plugin.Xml.XMLSchedulingDataProcessorPlugin, Quartz
quartz.plugin.xml.fileNames = ~/quartz_jobs.xml

# .0以上用以下配置
# quartz.plugin.xml.type = Quartz.Plugin.Xml.XMLSchedulingDataProcessorPlugin, Quartz.Plugins
# quartz.plugin.xml.fileNames = ~/quartz_jobs.xml

# export this server to remoting context
# quartz.scheduler.exporter.type = Quartz.Simpl.RemotingSchedulerExporter, Quartz
# quartz.scheduler.exporter.port =
# quartz.scheduler.exporter.bindName = QuartzScheduler
# quartz.scheduler.exporter.channelType = tcp
# quartz.scheduler.exporter.channelName = httpQuartz

quartz.scheduler.instanceName = ServiceQuartzScheduler  是调度的实例名称，可以随意自定义命名
其他的都是固定的，不需要修改

quartz_jobs.xml 文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>

<job-scheduling-data xmlns="http://quartznet.sourceforge.net/JobSchedulingData" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.0">

  <processing-directives>
    <overwrite-existing-data>true</overwrite-existing-data>
  </processing-directives>
  <schedule>
    <!--调度配置-->
    <job>
      <name>ProcessPrintLogService</name>
      <group>ProcessPrintLogServiceGroup</group>
      <description>日志打印服务</description>
      <job-type>Quartz.WinService.QuartzWork,Quartz.WinService</job-type>
      <durable>true</durable>
      <recover>false</recover>
    </job>
    <trigger>
      <cron>
        <name>ProcessPrintLogServiceTrigger</name>
        <group>ProcessPrintLogServiceTriggerGroup</group>
        <job-name>ProcessPrintLogService</job-name>
        <job-group>ProcessPrintLogServiceGroup</job-group>
        <misfire-instruction>SmartPolicy</misfire-instruction>
        <cron-expression>/ * * * * ? </cron-expression>
      </cron>
    </trigger>
  </schedule>
</job-scheduling-data>

这个xml配置文件很重要! 需要重点说下

首先 job节点 和 trigger节点 都可以定义多个，也就是一个服务可以跑多个不同的业务逻辑程序

先说 job节点

• name(必填) 任务名称，多个job的name不能相同，这里一般使用业务逻辑程序的名称就行了
• group(选填) 任务所属分组，用于标识任务所属分组，一般用业务逻辑程序的名称+Group后缀   如:<group>sampleGroup</group>
• description(选填) 任务描述，用于描述任务具体内容，如:<description>打印日志服务</description>
• job-type(必填) 任务类型，任务的具体类型及所属程序集，格式：实现了IJob接口的包含完整命名空间的类名,程序集名称，如:<job-type>Quartz.Server.SampleJob, Quartz.Server</job-type>
• durable(选填) 具体作用不知，官方示例中默认为true，如:<durable>true</durable>
• recover(选填) 具体作用不知，官方示例中默认为false，如:<recover>false</recover>

这里的 job-type 节点调用的任务类型需要说下，这里设置的就是上边项目结构中的 QuartzWork 类，具体内容如下：

namespace Quartz.WinService
{
    public class QuartzWork : IJob
    {
        private Logger log = LogManager.GetCurrentClassLogger();
        //ConcurrentDictionary是线程安全的字典集
        private readonly ConcurrentDictionary<string, Lazy<Delegate>> _dynamicCache = new ConcurrentDictionary<string, Lazy<Delegate>>();

        //记录当前工作接口是否已经工作
        private static readonly Dictionary<string, bool> WorkingNow = new Dictionary<string, bool>();

        /// <summary>
        /// 任务调度执行入口
        /// 实现IJob的Execute方法,在Execute方法里编写要处理的业务逻辑，系统就会按照Quartz的配置，定时处理
        /// 当Job的trigger触发的时候, Execute(..) 方法就会在scheduler的工作线程中执行
        /// </summary>
        /// <param name="context"></param>
        public void Execute(IJobExecutionContext context)
        {
            try
            {
                Task.Factory.StartNew(() =>
                {
                    var service = AppConfigHelper.Initity();
                    WorkNow(service);
                });
            }
            catch (Exception ex)
            {
                log.Fatal($"执行Quartz调度异常，信息：{ex.Message}");
            }
            //return Task.FromResult(true);  //返回一个bool类型的Task, Quartz 3.0版本以上需要用到
        }

        private void WorkNow(AppConfigHelper service)
        {
            string key = service.AppKey;  //key值
            lock (this)
            {
                if (!WorkingNow.ContainsKey(key))
                {
                    WorkingNow.Add(key, false);
                }
                //如果执行则跳出
                if (WorkingNow[key])
                {
                    log.Trace($"服务key:{key} 正在运行,此次服务忽略");
                    return;
                }
                //并且设置为执行状态
                WorkingNow[key] = true;
            }
            try
            {
                var type = Type.GetType(service.TypeInfo);  //这里通过App.config文件设置
                if (type != null)
                {
                    //创建指定类型的实例,相当于通过反射new了一个对象实例
                    var provider = Activator.CreateInstance(type);
                    Dynamic(provider, "DoWork", key);
                }
                else
                {
                    log.Error($"任务:{key} 实例化失败");
                }
            }
            catch (Exception ex)
            {
                log.Fatal($"任务:{key} 实例化异常：{ex.Message}");
            }
            finally
            {
                WorkingNow[key] = false;
            }
        }

        //Delegate.CreateDelegate 官方定义:用来动态创建指定类型的委托，该委托可以对指定的类实例调用的指定的方法。
        //简单来说:就是可以调用指定类里边指定的方法,前提是,使用时需要实例化该类
        //GetOrAdd函数会根据指定key判断是否存在对应内容,存在则返回
        //DynamicInvoke 动态调用委托方法
        //obj参数就是指定类的实例化对象,methodName指定类中的方法名
        private void Dynamic(object obj, string methodName, string key)
        {
            var dmc = _dynamicCache.GetOrAdd(key, t => new Lazy<Delegate>(() => Delegate.CreateDelegate(typeof(Action), obj, methodName)));
            dmc.Value.DynamicInvoke();   //动态调用委托方法
        }

    }
}

接下来说 trigger  节点

trigger 任务触发器，用于定义使用何种方式出发任务(job)，同一个job可以定义多个trigger ，多个trigger 各自独立的执行调度，

每个trigger 中必须且只能定义一种触发器类型(calendar-interval、simple、cron)

说白些就是，假如你要一个服务分别在 上午 8:00~18:00   和  凌晨 00:00 ~ 6:00  这两个时间段执行任务，那么你可以设置两个 trigger 触发器，

分别设置为这两个时间段即可实现你要的结果，怎么样，很牛X吧

• name(必填) 触发器名称，一般以 业务逻辑类+Trigger结尾， 如果需要设置多个 trigger节点，该名称不能相同
• group(选填) 触发器组  一般以 业务逻辑类+TriggerGroup结尾，多个 trigger节点，该名称可以相同
• job-name(必填) 要调度的任务名称，该job-name必须和对应job节点中的name名称完全相同
• job-group(选填) 调度任务(job)所属分组，该值必须和job节点中的group名称完全相同
• misfire-instruction 不知道干啥用,这么写就行  <misfire-instruction>SmartPolicy</misfire-instruction>
• cron-expression(必填) cron表达式，如:<cron-expression>0/10 * * * * ?</cron-expression>每10秒执行一次

需要注意的是修改了quartz_jobs.xml文件后，quartz服务默认不会重新加载该文件，若要让修改后的文件生效需要重启下服务才行。

另外，quartz.config文件 和 quartz_jobs.xml文件 都需要在项目中设置，右键-->属性-->复制到输出目录-->始终复制

服务注册文件 RegistService 增加了自动重启功能，完整内容如下：

namespace Quartz.WinService
{
    public class RegistService
    {
        /// <summary>
        /// 注册入口
        /// </summary>
        /// <param name="config">配置文件</param>
        /// <param name="isreg">是否注册</param>
        public static void Regist(AppConfigHelper config, bool isreg = false)
        {
            //这里也可以使用HostFactory.Run()代替HostFactory.New()
            var host = HostFactory.New(x =>
            {
                x.Service<QuartzHost>(s =>
                {
                    //通过 new QuartzHost() 构建一个服务实例
                    s.ConstructUsing(name => new QuartzHost());
                    //当服务启动后执行什么
                    s.WhenStarted(tc => tc.Start());
                    //当服务停止后执行什么
                    s.WhenStopped(tc => tc.Stop());
                    //当服务暂停后执行什么
                    s.WhenPaused(w => w.Stop());
                    //当服务继续后执行什么
                    s.WhenContinued(w => w.Start());
                });

                if (!isreg) return; //false表示不注册

                //服务用本地系统账号来运行
                x.RunAsLocalSystem();

                //启用自动重启服务
                x.EnableServiceRecovery(v =>
                {
                    v.RestartService();  //2分钟后重启
                });

                //服务的描述信息
                x.SetDescription(config.Description);
                //服务的显示名称
                x.SetDisplayName(config.ServiceName);
                //服务的名称（最好不要包含空格或者有空格属性的字符）Windows 服务名称不能重复。
                x.SetServiceName(config.ServiceName);
            }).Run();   //启动服务  如果使用HostFactory.Run()则不需要该方法
        }
    }
}

服务注册中调用的 QuartzHost 类内容如下：

namespace Quartz.WinService
{
    public class QuartzHost
    {
        private Logger log = LogManager.GetCurrentClassLogger();
        private readonly IScheduler scheduler;
        public QuartzHost()
        {
            //初始化调度服务
            //scheduler = StdSchedulerFactory.GetDefaultScheduler().Result;  //3.0以上写法
            scheduler = StdSchedulerFactory.GetDefaultScheduler();
        }

        /// <summary>
        /// 调度开始
        /// </summary>
        public void Start()
        {
            try
            {
                scheduler.Start();
                log.Info("Quartz调度服务开始工作");
            }
            catch (Exception ex)
            {
                log.Fatal(string.Format("Quartz调度服务开始异常！错误信息：{0}", ex));
                throw;
            }
        }

        /// <summary>
        /// 调度停止
        /// </summary>
        public void Stop()
        {
            try
            {
                if (scheduler != null)
                {
                    scheduler.Shutdown(true);
                }
                log.Info("Quartz调度服务结束工作");
            }
            catch (Exception ex)
            {
                log.Fatal(string.Format("Quartz调度服务停止异常！错误信息：{0}", ex));
                throw;
            }
        }
    }
}

项目文件地址：https://gitee.com/gitee_zhang/Quartz.WinService.git

参考文档：

https://blog.csdn.net/clb929/article/details/90341485

https://blog.csdn.net/weixin_33948416/article/details/92989386

https://www.cnblogs.com/lzrabbit/archive/2012/04/14/2446942.html