.Net Core 5.x Api开发笔记 -- 消息队列RabbitMQ实现事件总线EventBus(一)

本文主要围绕RabbitMQ消息队列和EventBus事件总线做笔记，其中有很多自己的理解和观点，有不对之处还望大神指出，我也学习一下。

1，消息队列

什么是消息队列就不说了，这里只介绍为什么用它！！！

RabbitMQ提供了可靠的消息机制、跟踪机制和灵活的消息路由，支持消息集群和分布式部署。适用于排队算法、秒杀活动、消息分发、异步处理、数据同步、处理耗时任务、CQRS等应用场景。它的以上好处在高并发等三高场景是十分必要的。

前提：使用RabbitMQ必须考虑高可用性

1、高可用：如果使用消息队列，基本要配合集群的，因为如果MQ服务器崩了，那就整个服务灾难了。

2、数据安全：必须保证数据不能丢失，也就是要考虑好最终一致性，做好补偿机制。

3、合理的消费。

2，事件总线

事件总线是对发布-订阅模式的一种实现。它是一种集中式事件处理机制，允许不同的组件之间进行彼此通信而又不需要相互依赖，达到一种解耦的目的。

说人话就是：集中对消息队列中处理的事件进行订阅和绑定管理。

实现事件总线的关键是：

• 事件总线维护一个事件源与事件处理的映射字典；
• 通过单例模式，确保事件总线的唯一入口；
• 利用反射完成事件源与事件处理的初始化绑定；
• 提供统一的事件注册、取消注册和触发接口；

public class EventBus
{
    /// <summary>
    /// EventBus 单例
    /// </summary>
    public static EventBus Default { get; private set; }

    /// <summary>
    /// 事件与事件的处理程序映射
    /// </summary>
    private static readonly ConcurrentDictionary<Type, List<Type>> m_EventAndHandlersMapping = new ConcurrentDictionary<Type, List<Type>>();

    /// <summary>
    /// 加锁对象
    /// </summary>
    private object m_lockObj;

    static EventBus()
    {
        Default = new EventBus();
    }

    private EventBus()
    {
        m_lockObj = new object();
    }

    /// <summary>
    /// 注册事件源和事件处理程序
    /// </summary>
    /// <typeparam name="TEvent">事件类型</typeparam>
    /// <typeparam name="THandler">处理程序类型</typeparam>
    public void RegisterHandler<T, THandler>()
        where T : EventBase
        where THandler : IEventHandler<T>
    {
        AddMapping(typeof(T), typeof(THandler));
    }

    /// <summary>
    /// 新增映射 事件源+事件处理程序
    /// </summary>
    /// <param name="eventType"></param>
    /// <param name="handlerType"></param>
    private void AddMapping(Type eventType, Type handlerType)
    {
        var handlers = m_EventAndHandlersMapping.GetOrAdd(eventType, type => new List<Type>());
        lock (m_lockObj)
        {
            if (!handlers.Contains(handlerType))
            {
                handlers.Add(handlerType);
            }
        }
    }
  
    /// <summary>
    /// 异步触发事件
    /// </summary>
    /// <param name="e"></param>
    /// <returns></returns>
    public async Task TriggerAsync<TEvent>(TEvent e)
        where TEvent : EventBase
    {
        List<Type> value;
        if (m_EventAndHandlersMapping.TryGetValue(e.GetType(), out value))
        {
            foreach (var handler in value.OrderBy(p => p.Name))
            {
                var instance = IocManager.ServiceProvider.GetService(handler) as IEventHandler<TEvent>;
                await instance?.HandleEvent(e);
            }
        }
    }
}

上边就是一个简单的事件总线管理类，主要任务就是对一个事件源与事件处理的映射，包括事件处理程序的触发。

3，事件源+事件处理

为了集中对事件进行处理，就需要进一步提取基类来处理，如下所示：

/// <summary>
/// 事件处理程序基类
/// </summary>
public interface IBaseEventHandler
{
}

/// <summary>
/// 事件处理程序
/// 解释：where T : EventBase 表示传入的类型必须继承 EventBase类
/// </summary>
public interface IEventHandler<T> : IBaseEventHandler
    where T : EventBase
{
    /// <summary>
    /// 处理事件
    /// </summary>
    /// <param name="e">事件传递的数据</param>
    Task HandleEvent(T e);
}

然后还需要声明一个事件基类来传递数据信息，这里声明一个强类型的带数据的事件

/// <summary>
/// 事件基类
/// </summary>
public abstract class EventBase
{
    protected EventBase()
        : this(null)
    { 
    }
    protected EventBase(object source)
    {
        this.Source = source;
    }
    /// <summary>
    /// 引发事件的源
    /// </summary>
    public object Source { get; private set; }
}

/// <summary>
/// 声明一个强类型的带数据的事件 传递数据
/// </summary>
public class EventWithData<TData> : EventBase
{

    /// <summary>
    /// 初始化 EventBase
    /// </summary>
    /// <param name="data">传递的数据</param>
    public EventWithData(TData data)
    {
        this.Data = data;
    }

    /// <summary>
    /// 事件传递的数据
    /// </summary>
    public TData Data { get; private set; }

    /// <summary>
    /// 创建 EventWithData'T'
    /// </summary>
    /// <param name="data">数据</param>
    /// <returns></returns>
    public static EventWithData<TData> New(TData data)
    {
        return new EventWithData<TData>(data);
    }
}

到这里关于事件总线的设计就初步完成了，接下来是关于消息队列 发布+订阅的设计。