Quartz修改任务

参考文献： 

https://blog.csdn.net/loveLifeLoveCoding/article/details/80449077

https://www.cnblogs.com/wolfocme110/p/12197257.html

 

修改、删除、新增

public async static Task InitSchedulerSocket()
        {
            try
            {
                HubConnection hub = new HubConnectionBuilder().WithUrl(config["SocketUrl"]).Build();

                await hub.StartAsync();

                await hub.InvokeAsync("SendMsg", new { Message = "客户端发送" });
                hub.Closed += async (ex) =>
                {
                    NLog.Web.NLogBuilder.ConfigureNLog("NLog.config").GetCurrentClassLogger().Error(new NlogMessageHelper("socket断开；", string.Format("连接异常/n/n {0}", ex.Message)).GetNlogMessage().ToString());
                    while (hub.State == HubConnectionState.Disconnected)
                    {
                        try
                        {
                            await Task.Delay(2 * 60 * 1000);
                            await hub.StartAsync();
                        }
                        catch (Exception)
                        {

                        }
                        finally
                        {
                            NLog.Web.NLogBuilder.ConfigureNLog("NLog.config").GetCurrentClassLogger().Info(new NlogMessageHelper("socket断开；", string.Format("连接异常/n/n {0}", "Socket重新连接")).GetNlogMessage().ToString());
                        }
                    }
                    if (hub.State == HubConnectionState.Connected)
                        NLog.Web.NLogBuilder.ConfigureNLog("NLog.config").GetCurrentClassLogger().Info(new NlogMessageHelper("socket断开；", "socket重新连接成功；").GetNlogMessage().ToString());
                };
                hub.On<TaskMessageHubModel>("Show", (info) =>
                {
                    if (info == null || string.IsNullOrEmpty(info.JobName))
                        return;

                    var jobs = scheduler.GetCurrentlyExecutingJobs().Result;
                    var allTriggerKeys = scheduler.GetTriggerKeys(GroupMatcher<TriggerKey>.AnyGroup()).Result;
                    foreach (var triggerKey in allTriggerKeys)
                    {
                        ITrigger trigger = scheduler.GetTrigger(triggerKey).Result;
                        var implTrigger = ((Quartz.Impl.Triggers.AbstractTrigger)trigger);
                        implTrigger.MisfireInstruction = 1;

                        if (implTrigger.JobName == info.JobName)
                        {
                            if (info.IntervalUnit == 1)
                            {//秒

                                ((CalendarIntervalTriggerImpl)implTrigger).RepeatIntervalUnit = IntervalUnit.Second;
                            }
                            else if (info.IntervalUnit == 2)
                            {//分钟
                                ((CalendarIntervalTriggerImpl)implTrigger).RepeatIntervalUnit = IntervalUnit.Minute;
                            }
                            else if (info.IntervalUnit == 3)
                            {//小时
                                ((CalendarIntervalTriggerImpl)implTrigger).RepeatIntervalUnit = IntervalUnit.Hour;
                            }
                            else if (info.IntervalUnit == 4)
                            {//小时
                                ((CalendarIntervalTriggerImpl)implTrigger).RepeatIntervalUnit = IntervalUnit.Day;
                            }
                            else if (info.IntervalUnit == 5)
                            {//月
                                ((CalendarIntervalTriggerImpl)implTrigger).RepeatIntervalUnit = IntervalUnit.Month;
                            }
                            ((CalendarIntervalTriggerImpl)implTrigger).RepeatInterval = info != null ? (int)info.IntervalTime : 0;
                            var jobDetail = scheduler.GetJobDetail(implTrigger.JobKey).Result;
                            if (info.IsEnable == 0)//停止
                            {
                                scheduler.PauseTrigger(implTrigger.Key);
                                scheduler.UnscheduleJob(implTrigger.Key);
                                scheduler.DeleteJob(implTrigger.JobKey);
                                Console.WriteLine("删除Job：" + info.JobName);
                                NLog.Web.NLogBuilder.ConfigureNLog("NLog.config").GetCurrentClassLogger().Info(new NlogMessageHelper("Job任务操作；", "Job：" + info.JobName + "任务删除；").GetNlogMessage().ToString());
                            }
                            else if (info.IsEnable == 1)//启动
                            {
                                //scheduler.DeleteJob(implTrigger.JobKey);
                                //scheduler.ScheduleJob(jobDetail, implTrigger);
                                scheduler.RescheduleJob(implTrigger.Key, implTrigger);
                                Console.WriteLine("修改Job：" + info.JobName);
                                NLog.Web.NLogBuilder.ConfigureNLog("NLog.config").GetCurrentClassLogger().Info(new NlogMessageHelper("Job任务操作；", "Job：" + info.JobName + "任务修改；").GetNlogMessage().ToString());
                            }
                            return;
                        }
                    }
                    //任务不存在并且需要启动，新建job
                    if (info.IsEnable == 1)
                    {
                        var r = GetSchedulers(ConfigurationFileMap(info), true).Result;

                        Console.WriteLine("新增Job：" + info.JobName);
                        if (r)
                            NLog.Web.NLogBuilder.ConfigureNLog("NLog.config").GetCurrentClassLogger().Info(new NlogMessageHelper("Job任务操作；", "Job：" + info.JobName + "新增任务；").GetNlogMessage().ToString());
                    }
                });
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                NLog.Web.NLogBuilder.ConfigureNLog("NLog.config").GetCurrentClassLogger().Error(new NlogMessageHelper("Socket连接", string.Format("客户端连接异常/n/n {0}", ex.Message)).GetNlogMessage().ToString());
            }
            
        }

 

 

public async static Task<bool> GetSchedulers(SchedulerConfig config,bool resume=false) {
            
            //通过设置job的附加属性，标识job的业务函数 
            var jobDataMap = new JobDataMap();
            //jobDataMap.Add(config.JobConfig.JobDataMapKey, config.JobConfig.JobName);
            jobDataMap.Add("ServiceName", config.JobConfig.ServiceName);

            JobBuilder jobBuilder;
            if (config.JobConfig.Concurrent)
            {
                jobBuilder = JobBuilder.Create<ConcurrentJob>();
            }
            else
            {
                jobBuilder = JobBuilder.Create<WeiBatcherJob>();
            }

            // 创建一个作业
            IJobDetail job = jobBuilder
                .WithIdentity(config.JobConfig.JobName, config.JobConfig.JobGroup)
                .UsingJobData(jobDataMap)
                .StoreDurably()
                .Build();
            
            var item = config.TriggerConfigs;
            //创建一个触发器
            ITrigger trig = TriggerBuilder.Create()
           .WithIdentity(item.TriggerName, item.TriggerGroup)   
           .WithCalendarIntervalSchedule(w => {
               
               if (item.WithIntervalInSeconds > 0)
               {
                   w.WithIntervalInSeconds(item.WithIntervalInSeconds);
               }
               else if (item.WithIntervalInMinutes > 0)
               {
                   w.WithIntervalInMinutes(item.WithIntervalInMinutes);
               }
               else if (item.WithIntervalInHours > 0)
               {
                   w.WithIntervalInHours(item.WithIntervalInHours);
               }
               else if (item.WithIntervalInDays > 0)
               {
                   w.WithIntervalInDays(item.WithIntervalInDays);
               }
               else if (item.WithIntervalInMonths > 0)
               {
                   w.WithInterval(item.WithIntervalInMonths, IntervalUnit.Month);
               }
               //之前丢失的立即补执行一次，之后执行时间点和周期不会发生变化
               w.WithMisfireHandlingInstructionFireAndProceed();
           })
           .WithPriority(item.Priority)
           .Build();

            if (! await scheduler.CheckExists(job.Key))
                await scheduler.ScheduleJob(job, trig);
            if (resume)
            {
                await scheduler.ResumeTrigger(trig.Key);
            }
            return true;
        }

 

2020-08-18

如果启动则新增触发器，禁用直接删除

if (info.IsEnable == 1)
            {
                var r = NewScheduler(ConfigurationFileMap(info), true).Result;

                Console.WriteLine("新增Job：" + info.JobName);
                if (r)
                    logger.Warn(new NlogMessageHelper("Job任务操作；", "Job：" + info.JobName + "新增任务；").GetNlogMessage().ToString());
            }
            else
            {
                var allTriggerKeys = scheduler.GetTriggerKeys(GroupMatcher<TriggerKey>.AnyGroup()).Result;
                foreach (var triggerKey in allTriggerKeys)
                {
                    ITrigger trigger = scheduler.GetTrigger(triggerKey).Result;


                    var implTrigger = ((Quartz.Impl.Triggers.AbstractTrigger)trigger);


                    implTrigger.MisfireInstruction = 1;

                    if (implTrigger.JobName == info.JobName)
                    {
                        scheduler.PauseTrigger(implTrigger.Key);
                        Console.WriteLine("暂停Job：" + info.JobName);
                        scheduler.UnscheduleJob(implTrigger.Key);
                        scheduler.DeleteJob(implTrigger.JobKey);

                        Console.WriteLine("删除Job：" + info.JobName);
                        break;
                    }
                }
            }

 

新建触发器，如果存在则覆盖并重启

public async static Task<bool> NewScheduler(SchedulerConfig config, bool resume = false)
        {

            //通过设置job的附加属性，标识job的业务函数 
            var jobDataMap = new JobDataMap();
            //jobDataMap.Add(config.JobConfig.JobDataMapKey, config.JobConfig.JobName);
            jobDataMap.Add("ServiceName", config.JobConfig.ServiceName);

            JobBuilder jobBuilder;
            if (config.JobConfig.Concurrent)
            {
                jobBuilder = JobBuilder.Create<ConcurrentJob>();
            }
            else
            {
                jobBuilder = JobBuilder.Create<WeiBatcherJob>();
            }

            // 创建一个作业
            IJobDetail job = jobBuilder
                .WithIdentity(config.JobConfig.JobName, config.JobConfig.JobGroup)
                .UsingJobData(jobDataMap)
                .StoreDurably()
                .Build();


            //创建一个触发器
            var trigBuilder = TriggerBuilder.Create().WithIdentity(config.TriggerConfig.TriggerName, config.TriggerConfig.TriggerGroup);

            //bool isStart = false;
            //if (config.TriggerConfigs.StartAt != null)
            //{
            //    var startAt = DateTime.SpecifyKind(config.TriggerConfigs.StartAt.Value, DateTimeKind.Utc);

            //    Console.WriteLine("开始时间："+ startAt);
            //    trigBuilder.StartAt(startAt);
            //    isStart = true;
            //}

            //if (config.TriggerConfigs.EndAt != null)
            //{
            //    var endAt = DateTime.SpecifyKind(config.TriggerConfigs.EndAt.Value, DateTimeKind.Utc);

            //    Console.WriteLine(endAt);
            //    trigBuilder.EndAt(endAt);
            //    isStart = true;
            //}

            if (!string.IsNullOrEmpty(config.TriggerConfig.CronExpression))
            {//cron表达式
                trigBuilder.WithCronSchedule(config.TriggerConfig.CronExpression,w=> {
                    w.WithMisfireHandlingInstructionDoNothing();
                });
            }
            else if (config.TriggerConfig.WithIntervalInSeconds > 0 || config.TriggerConfig.WithIntervalInMinutes > 0 || config.TriggerConfig.WithIntervalInHours > 0 || config.TriggerConfig.WithIntervalInDays > 0 || config.TriggerConfig.WithIntervalInDays > 0 || config.TriggerConfig.WithIntervalInMonths > 0)
            {
                trigBuilder.WithCalendarIntervalSchedule(w =>
                {
                    if (config.TriggerConfig.WithIntervalInSeconds > 0)
                    {
                        w.WithIntervalInSeconds(config.TriggerConfig.WithIntervalInSeconds);
                    }
                    else if (config.TriggerConfig.WithIntervalInMinutes > 0)
                    {
                        w.WithIntervalInMinutes(config.TriggerConfig.WithIntervalInMinutes);
                    }
                    else if (config.TriggerConfig.WithIntervalInHours > 0)
                    {
                        w.WithIntervalInHours(config.TriggerConfig.WithIntervalInHours);
                    }
                    else if (config.TriggerConfig.WithIntervalInDays > 0)
                    {
                        w.WithIntervalInDays(config.TriggerConfig.WithIntervalInDays);
                    }
                    else if (config.TriggerConfig.WithIntervalInMonths > 0)
                    {
                        w.WithIntervalInMonths(config.TriggerConfig.WithIntervalInMonths);
                    }
                    //之前丢失的立即补执行一次，之后执行时间点和周期不会发生变化
                    w.WithMisfireHandlingInstructionFireAndProceed();
                });
            }
            //trigBuilder.WithPriority(config.TriggerConfig.Priority);

            if (config.TriggerConfig.StartAt != null && config.TriggerConfig.StartAt != DateTime.MinValue)
            {
                var startAt = (DateTime)config.TriggerConfig.StartAt;
                trigBuilder.StartAt(startAt.ToDateTimeOffset());
            }
            
            if (config.TriggerConfig.EndAt != null && config.TriggerConfig.EndAt != DateTime.MinValue)
            {
                var endAt = (DateTime)config.TriggerConfig.EndAt;
                trigBuilder.EndAt(endAt.ToDateTimeOffset());
            }



            ITrigger trigger = trigBuilder.Build();
            

            if (!await scheduler.CheckExists(job.Key))
                await scheduler.ScheduleJob(job, trigger);
            if (resume)
            {
                await scheduler.AddJob(job,true);
                await scheduler.ResumeTrigger(trigger.Key);
                //await scheduler.RescheduleJob(trigger.Key, trigger);
            }
            //await scheduler.ScheduleJob(job, trigger);
            return true;
        }