欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-06-14 19:05:52
上一篇说了如何使用 Topshelf 组件快速创建Windows服务,接下来介绍如何使用 Quartz.net 关于Quartz.net的好处,网上搜索都是一大把一大把的,我就不再多介绍。 先介绍需要用到的插件: Quartz版本我用的 2.6.2的, 没有用3.0以上的,因为你用了就会知道,会打印 ......

上一篇说了如何使用 topshelf 组件快速创建windows服务,接下来介绍如何使用 quartz.net

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

先介绍需要用到的插件:

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

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

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

整个项目结构如下:

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

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