石英、Unity 和。网

Question

是否可以注册一个quartz作业来始终使用由Unity DI容器注入的相同的IJob实例？我有一个来自 Unity DI 的类 Monitor 的单个实例“监视器”，我将其注册为：

container.RegisterType<IMonitor, Monitor>(new ContainerControlledLifetimeManager())

并且我的 IJob 实现期望将该监视器实例注入其中：

class MyJob : IJob {
...
[Dependency] IMonitor monitor {get; set;}
...
void Execute()
...
}

但是当quartz 事件触发时，会在注入依赖项之前调用 IJob.Execute() 实现。我应该如何让它发挥作用？我应该考虑其他 DI 容器或调度程序吗？

谢谢

Answer 1

Quartz 将在每次火灾事件时重新实例化作业接口实现。如果您想保留状态，建议使用IStatefulJob作业执行之间：

IStatefulJob 实例遵循与常规规则略有不同的规则
IJob 实例。关键区别在于它们关联的 JobDataMap
每次执行作业后都会重新保留，从而保留
下一次执行的状态。另一个区别是有状态的
作业不允许同时执行，这意味着新的触发器
在 IJob.Execute 方法完成之前发生的事件将是
延迟。

来自 Quartz 教程：

有状态作业

现在，关于作业状态数据（又名 JobDataMap）的一些附加说明：
作业实例可以定义为“有状态”或“无状态”。
无状态作业仅在其执行时存储其 JobDataMap
被添加到调度程序中。这意味着对
作业执行期间作业数据映射的内容将会丢失，
并且下次执行作业时不会看到它。你有
可能猜到了，有状态作业正好相反 - 它的 JobDataMap
每次执行作业后都会重新存储。其副作用之一是
使作业有状态的原因是它不能同时执行。或者
换句话说：如果作业是有状态的，并且触发器尝试“触发”
当作业已经执行时，触发器将阻塞（等待）
直到上一次执行完成。

通过让 Job 实现 StatefulJob 来将其“标记”为有状态
接口，而不是 Job 接口。

您的另一个选择是实现您自己的 JobFactory：

作业“实例”

关于这个主题的最后一点现在可能很明显，也可能不明显：
您可以创建一个作业类，并存储许多“实例”
通过创建多个实例在调度程序中对其进行定义
JobDetails - 每个都有自己的一组属性和 JobDataMap -
并将它们全部添加到调度程序中。

当触发器触发时，与其关联的作业将通过以下方式实例化
Scheduler 上配置的 JobFactory。默认的JobFactory
只需在作业类上调用 newInstance() 即可。 您可能想要创建
您自己实现 JobFactory 来完成以下任务
让应用程序的 IoC 或 DI 容器生成/初始化
作业实例。

Answer 2

看看 Quartz.Unity。

https://www.nuget.org/packages/Quartz.Unity/1.0.1

文档非常稀疏，但看起来您需要做的就是将 nuget 包和以下行添加到容器配置中。

var container = new UnityContainer().AddNewExtension<Quartz.Unity.QuartzUnityExtension>();

Answer 3

您可以通过实现自己的 JobFactory 来做到这一点。您必须实现 IJobFactory 接口：

public interface IJobFactory
{
    /// <summary> 
    /// Called by the scheduler at the time of the trigger firing, in order to
    /// produce a <see cref="IJob" /> instance on which to call Execute.
    /// </summary>
    /// <remarks>
    /// <p>
    /// It should be extremely rare for this method to throw an exception -
    /// basically only the the case where there is no way at all to instantiate
    /// and prepare the Job for execution.  When the exception is thrown, the
    /// Scheduler will move all triggers associated with the Job into the
    /// <see cref="TriggerState.Error" /> state, which will require human
    /// intervention (e.g. an application restart after fixing whatever 
    /// configuration problem led to the issue wih instantiating the Job. 
    /// </p>
    /// 
/// </remarks>
    /// <param name="bundle">
    /// The TriggerFiredBundle from which the <see cref="JobDetail" />
    /// and other info relating to the trigger firing can be obtained.
    /// </param>
    /// <throws>  SchedulerException if there is a problem instantiating the Job. </throws>
    /// <returns> the newly instantiated Job
    /// </returns>
    IJob NewJob(TriggerFiredBundle bundle);
}

然后，将调度程序的quartz.scheduler.jobFactory.type 属性设置为作业工厂的类型。

作为参考，这是quartz.net 使用的默认作业工厂：

public class SimpleJobFactory : IJobFactory
{
    private static readonly ILog Log = LogManager.GetLogger(typeof (SimpleJobFactory));

    /// <summary>
    /// Called by the scheduler at the time of the trigger firing, in order to
    /// produce a <see cref="IJob" /> instance on which to call Execute.
    /// </summary>
    /// <remarks>
    /// It should be extremely rare for this method to throw an exception -
    /// basically only the the case where there is no way at all to instantiate
    /// and prepare the Job for execution.  When the exception is thrown, the
    /// Scheduler will move all triggers associated with the Job into the
    /// <see cref="TriggerState.Error" /> state, which will require human
    /// intervention (e.g. an application restart after fixing whatever
    /// configuration problem led to the issue wih instantiating the Job.
/// </remarks>
    /// <param name="bundle">The TriggerFiredBundle from which the <see cref="JobDetail" />
    /// and other info relating to the trigger firing can be obtained.</param>
    /// <returns>the newly instantiated Job</returns>
    /// <throws>  SchedulerException if there is a problem instantiating the Job. </throws>
    public virtual IJob NewJob(TriggerFiredBundle bundle)
    {
        JobDetail jobDetail = bundle.JobDetail;
        Type jobType = jobDetail.JobType;
        try
        {
            if (Log.IsDebugEnabled)
            {
                Log.Debug(string.Format(CultureInfo.InvariantCulture, "Producing instance of Job '{0}', class={1}", jobDetail.FullName, jobType.FullName));
            }

            return (IJob) ObjectUtils.InstantiateType(jobType);
        }
        catch (Exception e)
        {
            SchedulerException se = new SchedulerException(string.Format(CultureInfo.InvariantCulture, "Problem instantiating class '{0}'", jobDetail.JobType.FullName), e);
            throw se;
        }
    }
}

有趣的行是：

  return (IJob) ObjectUtils.InstantiateType(jobType);

Answer 4

创建一个覆盖 SimpleJobFactory 的 CustomJobfactory 并使用 spring 实例化作业类。

/// <summary>
/// Custom Job Factory
/// </summary>
public class CustomJobFactory : SimpleJobFactory
{
    /// <summary>
    /// Application context
    /// </summary>
    private IApplicationContext context;

    /// <summary>
    /// Initializes a new instance of the <see cref="CustomJobFactory" /> class.
    /// </summary>
    public CustomJobFactory()
    {
        this.context = ContextRegistry.GetContext();
    }

    /// <summary>
    /// Creates a new job instance
    /// </summary>
    /// <param name="bundle">Trigger bundle</param>
    /// <param name="scheduler">Job scheduler</param>
    /// <returns></returns>
    public override IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler)
    {
        IJobDetail jobDetail = bundle.JobDetail;
        Type jobType = jobDetail.JobType;
        return this.context.GetObject(jobType.Name) as IJob;
    }

    /// <summary>
    /// Return job
    /// </summary>
    /// <param name="job">Job instance</param>
    public override void ReturnJob(IJob job)
    {
    }
}