在 Quartz.Net 中调度相关作业

Question

我需要一些帮助。我正在尝试弄清楚如何在 Quartz.Net 中安排工作。 Quartz 中的作业对应于我的 Web 应用程序中的任务，它们都是我的 Web 应用程序中作业的一部分。我希望用户能够按需启动作业（Web应用程序上下文）并使其立即运行或安排将来的作业，并且可能在给定的时间间隔内重复。我知道所有这些项目是如何在 Quartz 中单独完成的，但我很难将它们放在一起。

例如，在我的 Web 应用程序中，我可能有一项包含多个任务的工作，并且按特定顺序进行。我希望能够在quartz中安排这些任务，以便它们按照我的Web应用程序中确定的相同顺序执行。有人知道如何做到这一点吗？我读过 Quartz 文档，说要将下一个作业存储在 JobDataMap 中，只是在努力解决这个问题。

我目前正在等待创建 Quartz 作业，直到用户请求安排作业或运行它。您认为我应该创建作业并在 Web 应用程序中创建任务时触发，然后从任务对象中提取该信息以在 Quartz 中进行调度吗？

Answer 1

您需要的是 JobChainingJobListener 类，它可以帮助您按照您想要的特定顺序为作业创建执行链。

using System;
using System.Text;
using Quartz;
using Quartz.Impl;
using Quartz.Impl.Calendar;
using Quartz.Listener;
using Quartz.Impl.Matchers;
using System.Threading;

namespace QuartzNET.Samples
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create RAMJobStore instance
            DirectSchedulerFactory.Instance.CreateVolatileScheduler(5);
            ISchedulerFactory factory = DirectSchedulerFactory.Instance;

            // Get scheduler and add object
            IScheduler scheduler = factory.GetScheduler();          

            StringBuilder history = new StringBuilder("Runtime History: ");
            scheduler.Context.Add("History", history);

            JobKey firstJobKey = JobKey.Create("FirstJob", "Pipeline");
            JobKey secondJobKey = JobKey.Create("SecondJob", "Pipeline");
            JobKey thirdJobKey = JobKey.Create("ThirdJob", "Pipeline"); 

            // Create job and trigger
            IJobDetail firstJob = JobBuilder.Create<FirstJob>()
                                       .WithIdentity(firstJobKey)
                                       //.StoreDurably(true)
                                       .Build();

            IJobDetail secondJob = JobBuilder.Create<SecondJob>()
                                       .WithIdentity(secondJobKey)                                       
                                       .StoreDurably(true)                                       
                                       .Build();

            IJobDetail thirdJob = JobBuilder.Create<ThirdJob>() 
                                       .WithIdentity(thirdJobKey)
                                       .StoreDurably(true)
                                       .Build();

            ITrigger firstJobTrigger = TriggerBuilder.Create()
                                             .WithIdentity("Trigger", "Pipeline")
                                             .WithSimpleSchedule(x => x
                                                 .WithMisfireHandlingInstructionFireNow()
                                                .WithIntervalInSeconds(5)    
                                                .RepeatForever())
                                             .Build();

            JobChainingJobListener listener = new JobChainingJobListener("Pipeline Chain");
            listener.AddJobChainLink(firstJobKey, secondJobKey);
            listener.AddJobChainLink(secondJobKey, thirdJobKey);            

            scheduler.ListenerManager.AddJobListener(listener, GroupMatcher<JobKey>.GroupEquals("Pipeline"));

            // Run it all in chain
            scheduler.Start();
            scheduler.ScheduleJob(firstJob, firstJobTrigger);
            scheduler.AddJob(secondJob, false, true);
            scheduler.AddJob(thirdJob, false, true);

            Console.ReadLine();
            scheduler.Shutdown();
            Console.WriteLine("Scheduler shutdown.");
            Console.WriteLine(history);
            Console.ReadLine();
        }
    }

    class FirstJob : IJob
    {
        public void Execute(IJobExecutionContext context)
        {
            var history = context.Scheduler.Context["History"] as StringBuilder;
            history.AppendLine();
            history.AppendFormat("First {0}", DateTime.Now);            
            Console.WriteLine("First {0}", DateTime.Now);
        }
    }

    class SecondJob : IJob 
    {
        public void Execute(IJobExecutionContext context)
        {
            var history = context.Scheduler.Context["History"] as StringBuilder;
            history.AppendLine();
            history.AppendFormat("Second {0}", DateTime.Now);
            Console.WriteLine("Second {0}", DateTime.Now);            
        }
    }

    class ThirdJob : IJob
    {
        public void Execute(IJobExecutionContext context)
        {
            var history = context.Scheduler.Context["History"] as StringBuilder;
            history.AppendLine();
            history.AppendFormat("Third {0}", DateTime.Now);
            Console.WriteLine("Third {0}", DateTime.Now);
            Console.WriteLine();
        }
    }
}

Answer 2

关于第二段：如果我理解正确的话，您有一组作业，用户可以从中选择并按一定的执行顺序放置。我将通过创建用户选择的每种作业类型的作业实例来实现此目的。为了保持作业的顺序，您可以将下一个作业的组名和作业名存储在上一个作业的 JobDataMap 中。然后你就可以拥有一个通用的JobListener，它向所有作业注册。当作业执行时，侦听器将收到通知，并将作业包作为参数传递。 JobListener可以枚举刚刚执行的作业的JobDataMap。如果找到带有“nextjobname”键的键值对，JobListener 将向调度程序查询该作业。对作业包中也可用的调度程序的引用。如果调度程序返回给定名称的 JobDetail 实例，JobListener 将执行它，并在完成时收到通知，依此类推，直到它到达 JobDataMap 中具有“nextjobname”的作业。
或者，如果您不想拥有作业侦听器，则可以拥有一个实现此功能的作业基类。您的所有作业都将从此类派生并覆盖其虚拟 Execute 方法。您可以在重写实现返回之前调用 base.Execute(context) 。

public class Basejob : IJob
{
    public virtual void Execute(JobExecutionContext context)
    {
        string nextJob = context.MergedJobDataMap["nextjobname"];
        JobDetail nextjob = context.Scheduler.GetJobDetail(context.MergedJobDataMap["nextjobname"],
                                           context.MergedJobDataMap["nextjobgroupname"]);
        if(nextjob != null)
        {
            context.Scheduler.ScheduleJob(nextjob, new SimpleTrigger(nextjob.Name + "trigger")); // this will fire the job immediately
        }
    }
}

public class MyJob : BaseJob
{
    public override void Execute(JobExecutionContext context)
    {
        //do work
        base.Execute(context);
    }
}