使用 Topshelf 组件和Quartz.net 库调度创建 Windows 服务

使用 Topshelf 组件和Quartz.net 库调度创建 Windows 服务 

• 使用Topshelf组件 一步一步创建 Windows 服务

   

  我们先来介绍一下使用它的好处，以下论述参考自其他大神。

  topshelf是创建windows服务的一种方式，相比原生实现ServiceBase、Install.Installer更为简单方便， 我们只需要几行代码即可实现windows服务的开发。

  topshelf本身支持windows及linux下mono上部署安装，同样也是开源的。

  topshelf相对原生来说，调试起来比较方便，可以在开发时以控制台的形式直接f5调试，发布时用命令以服务的形式部署。

  还一个比较有用的特性是支持多实例的部署，这样可以在一台机器上部署多个相对的服务。类似的工具有instsrv和srvany。

  多实例有一个好处就是容灾，当一个服务部署多份时，这样其中任何一个服务实例挂了，剩余的可以继续执行。

  多实例可以是主备的方式，主挂了备服务才会执行。也可以以负载均衡的方式实现，多实例抢占进程锁或分布式锁，谁拿到谁执行。

  先写出具体步骤：

  // 新建控制台应用程序
  // 使用Nuget安装Topshelf，选择能用的最新版本
  // 使用Nuget安装NLog和NLog.config，选择能用的最新版本,用于打印日志 Nlog需要配置文件,详见NLog.config
  // 初始化配置文件，创建AppConfigHelper类，继承 ConfigurationSection (需要引用System.Configuration程序集)
  // 完善App.Config配置文件,读取App.Config配置文件，具体查看AppConfigHelper类
  // 创建一个注册服务类TopshelfRegistService，初始化Topshelf注册
  // 我们的目标很简单，就是让服务打印一个日志文件
  // 编译并生成项目,进入 binDebug 目录下,找到xxx.exe 执行 install 命令,Windows 服务就诞生了
  // 注意：如果出现需要以管理员身份启动的提示，重新以管理员身份启动 cmd

  //接下来直接上代码与截图

  

   

   

   卸载服务：

  

  当我们启动服务的时候，成功打印出了日志，表示一切成功

  

  程序结构很简单，如下图所示：

  

   接下来，我们直接上实现代码，我会按照步骤依次给出：

  1，Program主程序代码

   1 namespace ProcessPrintLogService
   2 {
   3     class Program
   4     {
   5         public static readonly Logger log = LogManager.GetCurrentClassLogger();
   6         private static readonly AppConfigHelper config = AppConfigHelper.Initity();
   7         static void Main(string[] args)
   8         {
   9             TopshelfRegistService.Regist(config, true);
  10         }
  11     }
  12 }

  2.AppConfigHelper类，用于读取配置文件，使用配置文件的方式可以使你后期将该服务应用于多个应用程序

  namespace ProcessPrintLogService
  {
      public class AppConfigHelper : ConfigurationSection
      {
          private static AppConfigHelper _AppConfig = null;
          private static readonly object LockThis = new object();
  
          /// <summary>
          /// 获取当前配置 获取section节点的内容
          /// 使用单例模式
          /// </summary>
          /// <returns></returns>
          public static AppConfigHelper Initity()
          {
              if (_AppConfig == null)
              {
                  lock (LockThis)
                  {
                      if (_AppConfig == null)
                      {
                          //获取app.config文件中的section配置节点
                          _AppConfig = (AppConfigHelper)ConfigurationManager.GetSection("AppConfigHelper");
                      }
                  }
              }
              return _AppConfig;
          }
  
  
          //创建一个AppConfigHelper节点
          //属性分别为：ServiceName、Desc 等....
          //这里介绍一下属性标签：ConfigurationProperty 它可以在配置文件中根据属性名获取Value值
          //可以参考文章https://www.cnblogs.com/liunlls/p/configuration.html
  
  
          /// <summary>
          /// 服务名称
          /// </summary>
          [ConfigurationProperty("ServiceName", IsRequired = true)]
          public string ServiceName
          {
              get { return base["ServiceName"].ToString(); }
              internal set { base["ServiceName"] = value; }
          }
  
          /// <summary>
          /// 描述
          /// </summary>
          [ConfigurationProperty("Desc", IsRequired = true)]
          public string Description
          {
              get { return base["Desc"].ToString(); }
              internal set { base["Desc"] = value; }
          }
  
      }
  }

  3.Topshelf组件注册服务

  namespace ProcessPrintLogService
  {
      /// <summary>
      /// Topshelf组件注册服务
      /// </summary>
      internal class TopshelfRegistService
      {
          /// <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; //默认不注册
  
                  //服务用本地系统账号来运行
                  x.RunAsLocalSystem();
                  //服务的描述信息
                  x.SetDescription(config.Description);
                  //服务的显示名称
                  x.SetDisplayName(config.ServiceName);
                  //服务的名称（最好不要包含空格或者有空格属性的字符）Windows 服务名称不能重复。
                  x.SetServiceName(config.ServiceName);
              });
              host.Run();  //启动服务  如果使用HostFactory.Run()则不需要该方法
          }
      }
  
      /// <summary>
      /// 自定义服务
      /// </summary>
      internal class QuartzHost
      {
          public readonly Logger log = LogManager.GetLogger("QuartzHost");
  
          public QuartzHost()
          {
              var service = AppConfigHelper.Initity();
          }
  
          //服务开始
          public void Start()
          {
              try
              {
                  Task.Run(() =>
                  {
                      log.Info($"服务开始成功!");
                  });
              }
              catch (Exception ex)
              {
                  Task.Run(() =>
                  {
                      log.Fatal(ex, $"服务开始失败！错误信息：{0}", ex);
                  });
                  throw;
              }
          }
  
          //服务停止
          public void Stop()
          {
              Task.Run(() =>
              {
                  log.Trace("服务结束工作");
              });
          }
      }
  
  }

  4.App.config配置文件

  <?xml version="1.0" encoding="utf-8" ?>
  <configuration>
  
    <!--该节点一定要放在最上边-->
    <configSections>
      <section name="AppConfigHelper" type="ProcessPrintLogService.AppConfigHelper,ProcessPrintLogService"/>
    </configSections>
  
    <!--TopSelf服务配置文件 -->
    <AppConfigHelper
      ServiceName="Process_PrintLogService"
      Desc="日志打印服务"
      />
  
    <!--数据库连接字符串 -->
    <connectionStrings>
      <add name="ConnectionString" connectionString="123123123"/>
    </connectionStrings>
  
    <startup>
      <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
    </startup>
  </configuration>

  5.Nlog.config日志配置文件

  <?xml version="1.0" encoding="utf-8" ?>
  <nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    <targets>
      <!--type="File|Console" 属性是设置日志输出目标是"File"(文件)或者"Console"（控制台）-->
      <!--fileName="${basedir}/logs/${shortdate}/${level}/${callsite}.log" 设置日记记录文件的路径和名称-->
      <!--layout="${longdate} ${level} ${callsite}:${message}" 设置日志输出格式-->
      <target name="t1"
              type="File"
              fileName="${basedir}/logs/${shortdate}/${level} ${callsite}.log"
              layout="${longdate} ${level} ${callsite}:${message}"
            archiveAboveSize="3145728"
            archiveNumbering="Rolling"
            concurrentWrites="false"
            keepFileOpen="true"
            maxArchiveFiles ="20"
      />
  
      <!--输出至控制台-->
      <target name="t2" type="Console" layout="${longdate} ${level} ${callsite}:${message}" />
    </targets>
  
    <rules>
      <!--如果填*，则表示所有的Logger都运用这个规则,将所有级别的日志信息都写入到“t1”和“t2”这两个目标里-->
      <logger name="*" writeTo="t1,t2"/>
    </rules>
  </nlog>

  以上就是此次示例的全部代码，到此你也许会有一个问题，就是我想定时执行我的任务？比如每天几点执行，或者每几分钟执行一次等等，那我们该怎么做呢?

  答案是使用：Quartz.net ，接下来我将会使用 Quartz.net 实现上述的定时任务。

  参考文献：

  https://www.jianshu.com/p/f2365e7b439c

  http://www.80iter.com/blog/1451523192435464/ 
  https://www.itsvse.com/thread-7503-1-1.html?tdsourcetag=s_pctim_aiomsg

  https://www.cnblogs.com/yanglang/p/7199913.html

• 使用Quartz.net 调度

   

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

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

  先介绍需要用到的插件：

  

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

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

  整个项目结构如下：

  

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

   1         /// <summary>
   2         /// 程序标识
   3         /// </summary>
   4         [ConfigurationProperty("AppKey", IsRequired = true)]
   5         public string AppKey
   6         {
   7             get { return base["AppKey"].ToString(); }
   8             internal set { base["AppKey"] = value; }
   9         }
  10 
  11         /// <summary>
  12         /// 程序集信息
  13         /// </summary>
  14         [ConfigurationProperty("TypeInfo", IsRequired = true)]
  15         public string TypeInfo
  16         {
  17             get { return base["TypeInfo"].ToString(); }
  18             internal set { base["TypeInfo"] = value; }
  19         }

  AppConfig文件也做稍微改动

   1 <?xml version="1.0" encoding="utf-8" ?>
   2 <configuration>
   3   <!--该节点一定要放在最上边-->
   4   <configSections>
   5     <section name="AppConfigHelper" type="Quartz.WinService.AppConfigHelper,Quartz.WinService"/>
   6   </configSections>
   7 
   8   <!--TopSelf服务配置文件 -->
   9   <AppConfigHelper
  10     ServiceName="ProcessPrintLogService"
  11     Desc="日志打印服务"
  12     AppKey="ProcessPrintLogService"
  13     TypeInfo="ProcessService.ProcessPrintLogService,ProcessService"
  14   />
  15 
  16   <startup>
  17     <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
  18   </startup>
  19 </configuration>

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

  ProcessService.ProcessPrintLogService,ProcessService 是 命名空间.类名,类名  的格式，用于后边反射程序集用
  
  假如你要执行其他业务逻辑程序，只需要更换这里的配置就行，

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

   1 namespace ProcessService
   2 {
   3     /// <summary>
   4     /// 日志打印服务
   5     /// </summary>
   6     public class ProcessPrintLogService
   7     {
   8         private Logger log = LogManager.GetCurrentClassLogger();
   9         /// <summary>
  10         /// 服务入口
  11         /// </summary>
  12         public void DoWork()
  13         {
  14             //log.Info("******************排行榜服务开始执行******************");
  15             try
  16             {
  17                 PrintLogMethod();
  18             }
  19             catch (Exception ex)
  20             {
  21                 log.Error(string.Format("排行榜服务异常，原因：{0}", ex));
  22             }
  23             finally
  24             {
  25                 //log.Info("******************排行榜服务结束执行******************");
  26             }
  27         }
  28 
  29 
  30         private void PrintLogMethod()
  31         {
  32             log.Trace(string.Format("我是日志:{0}号", Thread.CurrentThread.ManagedThreadId));
  33         }
  34     }
  35 }

  然后需要新增加两个文件：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 = 10
  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
  
  # 3.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 = 555
  # 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>0/3 * * * * ? </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);  //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