ABP.IO框架：同一微服务中处理多事件的实现方式咨询

是否需要部署三个微服务处理增删改事件？ #

不需要单独部署三个微服务来处理同一资源的创建、更新、删除事件。两种处理方式都可行，但更推荐为不同事件类型创建独立的事件处理类——这种方式符合单一职责原则，代码更清晰，后续维护、扩展也更方便。如果业务逻辑非常简单，用一个Handler通过事件类型区分处理也可以，但长期来看独立Handler的方案更优。

同一微服务内处理多个事件的示例 #

方案1：为每个事件类型创建独立处理类（推荐）

首先定义不同的事件传输对象（Eto）：

// 员工创建事件Eto
public class EmployeeCreatedEto : EtoBase
{
    public Guid Id { get; set; }
    public string Name { get; set; }
    public string Position { get; set; }
}

// 员工更新事件Eto
public class EmployeeUpdatedEto : EtoBase
{
    public Guid Id { get; set; }
    public string Name { get; set; }
    public string Position { get; set; }
}

// 员工删除事件Eto
public class EmployeeDeletedEto : EtoBase
{
    public Guid Id { get; set; }
}

然后分别创建对应的事件处理类，都在同一个微服务中：

// 处理员工创建事件
public class EmployeeCreatedHandler : IDistributedEventHandler<EmployeeCreatedEto>, ITransientDependency
{
    private readonly ILogger<EmployeeCreatedHandler> _logger;

    public EmployeeCreatedHandler(ILogger<EmployeeCreatedHandler> logger)
    {
        _logger = logger;
    }

    public async Task HandleEventAsync(EmployeeCreatedEto eventData)
    {
        // 执行创建相关业务逻辑，比如同步数据、发送通知等
        _logger.LogInformation($"处理员工创建事件：ID={eventData.Id}，姓名={eventData.Name}");
        // await _employeeSyncService.SyncCreatedEmployeeAsync(eventData);
        await Task.CompletedTask;
    }
}

// 处理员工更新事件
public class EmployeeUpdatedHandler : IDistributedEventHandler<EmployeeUpdatedEto>, ITransientDependency
{
    private readonly ILogger<EmployeeUpdatedHandler> _logger;

    public EmployeeUpdatedHandler(ILogger<EmployeeUpdatedHandler> logger)
    {
        _logger = logger;
    }

    public async Task HandleEventAsync(EmployeeUpdatedEto eventData)
    {
        // 执行更新相关业务逻辑
        _logger.LogInformation($"处理员工更新事件：ID={eventData.Id}，新姓名={eventData.Name}，新职位={eventData.Position}");
        // await _employeeSyncService.SyncUpdatedEmployeeAsync(eventData);
        await Task.CompletedTask;
    }
}

// 处理员工删除事件
public class EmployeeDeletedHandler : IDistributedEventHandler<EmployeeDeletedEto>, ITransientDependency
{
    private readonly ILogger<EmployeeDeletedHandler> _logger;

    public EmployeeDeletedHandler(ILogger<EmployeeDeletedHandler> logger)
    {
        _logger = logger;
    }

    public async Task HandleEventAsync(EmployeeDeletedEto eventData)
    {
        // 执行删除相关业务逻辑
        _logger.LogInformation($"处理员工删除事件：ID={eventData.Id}");
        // await _employeeSyncService.SyncDeletedEmployeeAsync(eventData.Id);
        await Task.CompletedTask;
    }
}

方案2：单一处理类通过事件类型区分处理

如果需要用统一的Eto承载不同事件类型，可以这样实现：

// 定义事件类型枚举
public enum EmployeeEventType
{
    Created,
    Updated,
    Deleted
}

// 统一的员工事件Eto
public class EmployeeEventEto : EtoBase
{
    public EmployeeEventType EventType { get; set; }
    public Guid Id { get; set; }
    public string Name { get; set; }
    public string Position { get; set; }
}

// 单一事件处理类
public class EmployeeEventHandler : IDistributedEventHandler<EmployeeEventEto>, ITransientDependency
{
    private readonly ILogger<EmployeeEventHandler> _logger;

    public EmployeeEventHandler(ILogger<EmployeeEventHandler> logger)
    {
        _logger = logger;
    }

    public async Task HandleEventAsync(EmployeeEventEto eventData)
    {
        switch (eventData.EventType)
        {
            case EmployeeEventType.Created:
                await HandleCreatedEvent(eventData);
                break;
            case EmployeeEventType.Updated:
                await HandleUpdatedEvent(eventData);
                break;
            case EmployeeEventType.Deleted:
                await HandleDeletedEvent(eventData);
                break;
            default:
                _logger.LogWarning($"未知的员工事件类型：{eventData.EventType}");
                break;
        }
    }

    private async Task HandleCreatedEvent(EmployeeEventEto eventData)
    {
        _logger.LogInformation($"处理员工创建事件：ID={eventData.Id}，姓名={eventData.Name}");
        // 执行创建逻辑
        await Task.CompletedTask;
    }

    private async Task HandleUpdatedEvent(EmployeeEventEto eventData)
    {
        _logger.LogInformation($"处理员工更新事件：ID={eventData.Id}，新姓名={eventData.Name}");
        // 执行更新逻辑
        await Task.CompletedTask;
    }

    private async Task HandleDeletedEvent(EmployeeEventEto eventData)
    {
        _logger.LogInformation($"处理员工删除事件：ID={eventData.Id}");
        // 执行删除逻辑
        await Task.CompletedTask;
    }
}

内容的提问来源于stack exchange，提问作者Gopi