ABP框架理论学习之后台工作(Jobs)和后台工作者（Workers）

返回总目录

本篇目录

介绍
后台工作
后台工作者
让你的应用程序一直运行

介绍

ABP提供了后台工作和后台工作者，它们会在应用程序的后台线程中执行一些任务。

后台工作

后台工作以队列和持续的方式在后台给一些即将被执行的任务排队。你可能因为某些原因需要后台工作，比如：

执行长时间运行的任务。比如，一个用户按了“report”按钮来启动一个长时间运行的报告工作，点击了这个按钮你不可能让用户一直处于等待状态，所以你应该将这个工作（job）添加到 队列（queue）中，然后，当这项工作完成时，通过邮件将报告结果发送给该用户。
创建重复尝试（re-trying）和持续的任务来保证代码将会 成功执行。比如，你可以在后台工作中发送邮件以克服 临时失败，并保证邮件最终能够发送出去。因此，当发送邮件的时候用户不需要等待。

创建一个后台工作

我们可以通过继承BackgroundJob类或者直接实现 IBackgroundJob接口来创建一个后台工作类。

下面是一个最简单的后台工作：

public class TestJob : BackgroundJob<int>, ITransientDependency
{
    public override void Execute(int number)
    {
        Logger.Debug(number.ToString());
    }
}

该后台工作定义了一个需要输入参数的Execute方法。参数类型是泛型参数类型。

后台工作必须注册到依赖注入系统中，实现ITransientDependency是最简单的方式。

接下来定义一个更现实的工作，它会在后台队列中发送邮件：

public class SimpleSendEmailJob : BackgroundJob<SimpleSendEmailJobArgs>, ITransientDependency
{
    private readonly IRepository<User, long> _userRepository;
    private readonly IEmailSender _emailSender;
    public SimpleSendEmailJob(IRepository<User, long> userRepository, IEmailSender emailSender)
    {
        _userRepository = userRepository;
        _emailSender = emailSender;
    }
    public override void Execute(SimpleSendEmailJobArgs args)
    {
        var senderUser = _userRepository.Get(args.SenderUserId);
        var targetUser = _userRepository.Get(args.TargetUserId);
        _emailSender.Send(senderUser.EmailAddress, targetUser.EmailAddress, args.Subject, args.Body);
    }
}

我们注入了user仓储（为了获得用户信息）和email发送者（发送邮件的服务），然后简单地发送了该邮件。SimpleSendEmailJobArgs是该工作的参数，它定义如下：

[Serializable]
public class SimpleSendEmailJobArgs
{
    public long SenderUserId { get; set; }
    public long TargetUserId { get; set; }
    public string Subject { get; set; }
    public string Body { get; set; }
}

工作参数应该是serializable(可序列化)，因为要将它 序列化并存储到数据库中。虽然ABP默认的后台工作管理者使用了JSON序列化（它不需要[Serializable]特性），但是最好定义 [Serializable]特性，因为我们将来可能会转换到其他使用二进制序列化的工作管理者。

记住，要保持你的参数简单，不要在参数中包含实体或者其他非可序列化的对象。正如上面的例子演示的那样，我们只存储了实体的 Id，然后在该工作的内部从仓储中获得该实体。

添加新工作到队列

当定义了一个后台工作后，我们就可以注入并使用IBackgroundJobManager来添加一个工作到队列中。看上面定义的TestJob的例子：

public class MyService
{
    private readonly IBackgroundJobManager _backgroundJobManager;
    public MyService(IBackgroundJobManager backgroundJobManager)
    {
        _backgroundJobManager = backgroundJobManager;
    }
    public void Test()
    {
        _backgroundJobManager.Enqueue<TestJob, int>(42);
    }
}

当入队（Enqueue）时，我们将42作为参数传递。IBackgroundJobManager将会实例化并使用42作为参数执行TestJob。

让我们看一下如何为上面定义的SimpleSendEmailJob添加一个新的工作：

[AbpAuthorize]
public class MyEmailAppService : ApplicationService, IMyEmailAppService
{
    private readonly IBackgroundJobManager _backgroundJobManager;
    public MyEmailAppService(IBackgroundJobManager backgroundJobManager)
    {
        _backgroundJobManager = backgroundJobManager;
    }
    public async Task SendEmail(SendEmailInput input)
    {
            await _backgroundJobManager.EnqueueAsync<SimpleSendEmailJob, SimpleSendEmailJobArgs>(
            new SimpleSendEmailJobArgs
            {
                Subject = input.Subject,
                Body = input.Body,
                SenderUserId = AbpSession.GetUserId(),
                TargetUserId = input.TargetUserId
            });
    }
}

Enqueu (或 EnqueueAsync)方法还有其他的参数，比如 priority和 delay（优先级和延迟）。

默认的后台工作管理者

IBackgroundJobManager默认是由BackgroundJobManager实现的。它可以被其他的后台工作提供者替代（看后面的Hangfire集成）。关于默认的BackgroundJobManager一些信息如下：

它是一个在单线程中以FIFO（First In First Out）工作的简单工作队列，使用 IBackgroundJobStore来持久化工作。
它会重复尝试执行工作，直到工作成功执行（不会抛出任何异常）或者超时。默认的超时是一个工作2天。
当成功执行后，它会从存储（数据库）中删除该工作。如果超时了，就会将该工作设置为 abandoned（废弃的），并保留在数据库中。
在重复尝试一个工作之间会增加等待时间。第一次重试时等待1分钟，第二次等待2分钟，第三次等待4分钟等等。
在固定的时间间隔轮询工作的存储。查询工作时先按优先级排序，再按尝试次数排序。

后台工作存储

默认的BackgroundJobManager需要一个数据存储来保存、获得工作。如果你没有实现IBackgroundJobStore，那么它会使用 InMemoryBackgroundJobStore，它不会将工作持久化到数据库中。你可以简单地实现它来存储工作到数据库或者你可以使用module-zero，它已经实现了IBackgroundJobStore。

如果你正在使用第三方的工作管理者（像Hangfire），那么不需要实现IBackgroundJobStore。

配置

你可以在模块的PreInitialize方法中使用Configuration.BackgroundJobs来配置后台工作系统。

关闭工作执行功能

你可能想关闭应用程序的后台工作执行：

public class MyProjectWebModule : AbpModule
{
    public override void PreInitialize()
    {
        Configuration.BackgroundJobs.IsJobExecutionEnabled = false;
    }
    //...
}

这种情况很罕见，但是想一下，如果你正在对相同的数据库运行多个应用的实例（在web应用中）。在这种情况下，每个应用都会为工作查询相同的数据库并执行它们。这会导致相同工作的多次执行和一些其它问题。要阻止这种情况发生，你有两种选择：

你可以只为该应用的一个实例开启工作执行。
你可以为该web应用的所有实例关闭工作执行，然后创建一个会执行后台工作的独立应用（比如一个Windows服务）。

Hangfire集成

后台工作管理者设计成了可以被其他的后台工作管理者取代。查看Hangfire集成来替代默认的后台工作管理者。

后台工作者

后台工作者不同于后台工作。它们是运行在应用后台的简单独立线程。一般来说，它们会定期地执行一些任务。比如：

后台工作者可以定期运行来删除旧的日志。
后台工作者可以定期运行来确定不活跃的用户，并给他们发送邮件以使他们返回你的应用。

创建后台工作者

要创建后台工作者，我们应该实现IBackgroundWorker接口。除此之外，我们可以基于需求从 BackgroundWorkerBase或者 PeriodicBackgroundWorkerBase继承。

假设一个用户在过去30天内没有登录到该应用，那我们想要让Ta的状态为passive。看下面的代码：

public class MakeInactiveUsersPassiveWorker : PeriodicBackgroundWorkerBase, ISingletonDependency
{
    private readonly IRepository<User, long> _userRepository;
    public MakeInactiveUsersPassiveWorker(AbpTimer timer, IRepository<User, long> userRepository)
        : base(timer)
    {
        _userRepository = userRepository;
        Timer.Period = 5000; //5 seconds (good for tests, but normally will be more)
    }
    [UnitOfWork]
    protected override void DoWork()
    {
        using (CurrentUnitOfWork.DisableFilter(AbpDataFilters.MayHaveTenant))
        {
            var oneMonthAgo = Clock.Now.Subtract(TimeSpan.FromDays(30));
            var inactiveUsers = _userRepository.GetAllList(u =>
                u.IsActive &&
                ((u.LastLoginTime < oneMonthAgo && u.LastLoginTime != null) || (u.CreationTime < oneMonthAgo && u.LastLoginTime == null))
                );
            foreach (var inactiveUser in inactiveUsers)
            {
                inactiveUser.IsActive = false;
                Logger.Info(inactiveUser + " made passive since he/she did not login in last 30 days.");
            }
            CurrentUnitOfWork.SaveChanges();
        }
    }
}

这是现实中的代码，并且在具有module-zero模块的ABP中直接有效。

如果你从PeriodicBackgroundWorkerBase 类继承（如这个例子），那么你应该实现 DoWork方法来执行定期运行的代码。
如果从BackgroundWorkerBase继承或直接实现了 IBackgroundWorker，那么你要重写或者实现Start, Stop 和 WaitToStop方法。Start和Stop方法应该是 非阻塞的（non-blocking），WaitToStop方法应该等待工作者完成当前重要的工作。

注册后台工作者

创建一个后台工作者后，我们应该把它添加到IBackgroundWorkerManager，通常放在模块的PostInitialize方法中：

public class MyProjectWebModule : AbpModule
{
    //...
    public override void PostInitialize()
    {
        var workManager = IocManager.Resolve<IBackgroundWorkerManager>();
        workManager.Add(IocManager.Resolve<MakeInactiveUsersPassiveWorker>());
    }
}

虽然一般我们将工作者添加到PostInitialize方法中，但是没有强制要求。你可以在任何地方注入IBackgroundWorkerManager，在运行时添加工作者。

当应用要关闭时，IBackgroundWorkerManager会停止并释放所有注册的工作者。

后台工作者生命周期

后台工作者一般实现为单例的，但是没有严格限制。如果你需要相同工作者类的多个实例，那么可以使它成为transient（每次使用时创建），然后给IBackgroundWorkerManager添加多个实例。在这种情况下，你的工作者很可能会参数化（比如，你有单个LogCleaner类，但是两个LogCleaner工作者实例会监视并清除不同的log文件夹）。

让你的应用程序一直运行

只有当你的应用运行时，后台工作和工作者才会工作。如果一个Asp.Net 应用长时间没有执行请求，那么它默认会关闭（shutdown）。如果你想让后台工作一直在web应用中执行（这是默认行为），那么你要确保web应用配置成了总是运行。否则，后台工作只有在应用使用时才会执行。

有很多技术来实现这个目的。最简单的方法是从外部应用定期向你的web应用发送请求。这样，你可以检查web应用是否开启并且处于运行状态。Hangfire文档讲解了一些其他的方法。