eShopOnContainers 知多少[5]：EventBus With RabbitMQ

1. 引言

事件总线这个概念对你来说可能很陌生，但提到观察者（发布-订阅）模式，你也许就很熟悉。事件总线是对发布-订阅模式的一种实现。它是一种集中式事件处理机制，允许不同的组件之间进行彼此通信而又不需要相互依赖，达到一种解耦的目的。从上图可知，核心就4个角色：

1. 事件（事件源+事件处理）

2. 事件发布者

3. 事件订阅者

4. 事件总线

实现事件总线的关键是：

1. 事件总线维护一个事件源与事件处理的映射字典；

2. 通过单例模式，确保事件总线的唯一入口；

3. 利用反射完成事件源与事件处理的初始化绑定；

4. 提供统一的事件注册、取消注册和触发接口。

以上源于我在事件总线知多少（1）中对于EventBus的分析和简单总结。基于以上的简单认知，我们来梳理下eShopOnContainers中EventBus的实现机制。

2. 高屋建瓴--看类图

我们直接以上帝视角，来看下其实现机制，上类图。

我们知道事件的本质是：事件源+事件处理。 针对事件源，其定义了 Handle方法用于响应事件。不同之处在于方法参数的类型： 第一个接受的是一个强类型的 dynamic。 为什么要单独提供一个事件源为 dynamic可以简化事件源的构建，更趋于灵活。

有了事件源和事件处理，接下来就是事件的注册和订阅了。为了方便进行订阅管理，系统提供了额外的一层抽象 InMemoryEventBusSubscriptionsManager就是使用内存进行存储事件源和事件处理的映射字典。 从类图中看 SubscriptionInfo，其主要用于表示事件订阅方的订阅类型和事件处理的类型。

我们来近距离看下

1. //InMemoryEventBusSubscriptionsManager.cs

2. //定义的事件名称和事件订阅的字典映射（1:N）

3. private readonly Dictionary<string, List<SubscriptionInfo>> _handlers;

4. //保存所有的事件处理类型

5. private readonly List<Type> _eventTypes;

6. //定义事件移除后事件

7. public event EventHandler<string> OnEventRemoved;

8. 


9. //构造函数初始化

10. public InMemoryEventBusSubscriptionsManager()

11. {

12.    _handlers = new Dictionary<string, List<SubscriptionInfo>>();

13.    _eventTypes = new List<Type>();

14. }

15. //添加动态类型事件订阅（需要手动指定事件名称）

16. public void AddDynamicSubscription<TH>(string eventName)

17.    where TH : IDynamicIntegrationEventHandler

18. {

19.    DoAddSubscription(typeof(TH), eventName, isDynamic: true);

20. }

21. //添加强类型事件订阅（事件名称为事件源类型）

22. public void AddSubscription<T, TH>()

23.    where T : IntegrationEvent

24.    where TH : IIntegrationEventHandler<T>

25. {

26.    var eventName = GetEventKey<T>();

27. 


28.    DoAddSubscription(typeof(TH), eventName, isDynamic: false);

29. 


30.    if (!_eventTypes.Contains(typeof(T)))

31.    {

32.        _eventTypes.Add(typeof(T));

33.    }

34. }

35. //移除动态类型事件订阅

36. public void RemoveDynamicSubscription<TH>(string eventName)

37.    where TH : IDynamicIntegrationEventHandler

38. {

39.    var handlerToRemove = FindDynamicSubscriptionToRemove<TH>(eventName);

40.    DoRemoveHandler(eventName, handlerToRemove);

41. }

42. 


43. //移除强类型事件订阅

44. public void RemoveSubscription<T, TH>()

45.    where TH : IIntegrationEventHandler<T>

46.    where T : IntegrationEvent

47. {

48.    var handlerToRemove = FindSubscriptionToRemove<T, TH>();

49.    var eventName = GetEventKey<T>();

50.    DoRemoveHandler(eventName, handlerToRemove);

51. }

添加了这么一层抽象，即符合了单一职责原则，又完成了代码重用。 IEventBusSubscriptionsManager的依赖，即可完成订阅管理。 你这里可能会好奇，为什么要暴露一个 EventBusRabbitMQ源码亲密接触。

3.3.1. 构造函数定义

IRabbitMQPersistentConnection

以便连接到对应的Broke。

• 使用空对象模式注入 OnEventRemoved事件，取消队列的绑定。（这也就回答了上面遗留的问题）

3.3.2. 事件订阅的逻辑：

1. public void Publish(IntegrationEvent @event)

2. {

3.    if (!_persistentConnection.IsConnected)

4.    {

5.        _persistentConnection.TryConnect();

6.    }

7. 
   

8.    var policy = RetryPolicy.Handle<BrokerUnreachableException>()

9.        .Or<SocketException>()

10.        .WaitAndRetry(_retryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) =>

11.        {

12.            _logger.LogWarning(ex.ToString());

13.        });

14. 
    

15.    using (var channel = _persistentConnection.CreateModel())

16.    {

17.        var eventName = @event.GetType()

18.            .Name;

19. 
    

20.        channel.ExchangeDeclare(exchange: BROKER_NAME, type: "direct");

21. 
    

22.        var message = JsonConvert.SerializeObject(@event);

23.        var body = Encoding.UTF8.GetBytes(message);

24. 
    

25.        policy.Execute(() =>

26.        {

27.            var properties = channel.CreateBasicProperties();

28.            properties.DeliveryMode = 2; // persistent

29. 
    

30.            channel.BasicPublish(exchange: BROKER_NAME, routingKey: eventName, mandatory:true, basicProperties: properties, body: body);

31.        });

32.    }

33. }

这里面有以下几个知识点：

1. 使用Polly，以2的阶乘的时间间隔进行重试。（第一次2s后，第二次4s后，第三次8s后...重试）

2. 使用direct全匹配、单播形式的路由机制进行消息分发

3. 消息主体是格式化的json字符串

4. 指定 mandatory:true告知服务器当根据指定的routingKey和消息找不到对应的队列时，直接返回消息给生产者。

3.3.4. 然后看看事件消息的监听

Received事件委托处理消息接收事件

调用 

以上代码主要包括以下知识点：

4. EventBus的集成和使用

以上介绍了EventBus的实现要点，那各个微服务是如何集成呢？

1. 注册

2. 注册单例模式的 services.AddSingleton<IEventBusSubscriptionsManager,InMemoryEventBusSubscriptionsManager>();

3. 注册单例模式的

完成了以上集成，就可以在代码中使用事件总线进行事件的发布和订阅。

4. 发布事件

若要发布事件，需要根据是否需要事件源（参数传递）来决定是否需要申明相应的集成事件，需要则继承自 IEventBus的实例的

IIntegrationEventHandler

或 IEventBus的实例调用

TestEvent

事件，B服务订阅该事件，同样需要在B服务复制定义一个 <code class="prettyprint code-in-text prettyprinted" style="box-sizing: border-box;background: rgb(243, 241, 241);color: rgb(88, 88, 88);line-height: 18px;font-family: consolas, menlo, courier, monospace, " initial="" microsoft="" !important;"="" 0px="">TestEvent




。 这也是微服务的一个通病，重复代码。




5. 最后

通过一步一步的源码梳理，我们发现eShopOnContainers中事件总线的总体实现思路与引言部分的介绍十分契合。所以对于事件总线，不要觉得高深，明确参与的几个角色以及基本的实现步骤，那么不管是基于RabbitMQ实现也好还是基于Azure Service Bus也好，万变不离其宗！







1. //定义事件处理

2. public class ProductPriceChangedIntegrationEventHandler : IIntegrationEventHandler<ProductPriceChangedIntegrationEvent>

3. {

4.    public async Task Handle(ProductPriceChangedIntegrationEvent @event)

5.    {

6.        //do something

7.    }

8. }

9. //事件源的声明

10. public class ProductPriceChangedIntegrationEvent : IntegrationEvent

11. {        

12.    public int ProductId { get; private set; }

13. 
    

14.    public decimal NewPrice { get; private set; }

15. 
    

16.    public decimal OldPrice { get; private set; }

17. 
    

18.    public ProductPriceChangedIntegrationEvent(int productId, decimal newPrice, decimal oldPrice)

19.    {

20.        ProductId = productId;

21.        NewPrice = newPrice;

22.        OldPrice = oldPrice;

23.    }

24. }

25. services.AddSingleton<IEventBus, EventBusRabbitMQ>(sp =>

26. {

27.    var rabbitMQPersistentConnection = sp.GetRequiredService<IRabbitMQPersistentConnection>();

28.    var iLifetimeScope = sp.GetRequiredService<ILifetimeScope>();

29.    var logger = sp.GetRequiredService<ILogger<EventBusRabbitMQ>>();

30.    var eventBusSubcriptionsManager = sp.GetRequiredService<IEventBusSubscriptionsManager>();

31. 
    

32.    var retryCount = 5;

33.    if (!string.IsNullOrEmpty(Configuration["EventBusRetryCount"]))

34.    {

35.        retryCount = int.Parse(Configuration["EventBusRetryCount"]);

36.    }

37. 
    

38.    return new EventBusRabbitMQ(rabbitMQPersistentConnection, logger, iLifetimeScope, eventBusSubcriptionsManager, subscriptionClientName, retryCount);

39. });

40. services.AddSingleton<IRabbitMQPersistentConnection>(sp =>

41. {

42.    var logger = sp.GetRequiredService<ILogger<DefaultRabbitMQPersistentConnection>>();

43.    //...

44.    return new DefaultRabbitMQPersistentConnection(factory, logger, retryCount);

45. });

1. Json字符串的反序列化

2. 利用依赖注入容器解析集成事件（Integration Event）和事件处理（Event Handler）类型

3. 反射调用具体的事件处理方法

1. private async Task ProcessEvent(string eventName, string message)

2. {

3.    if (_subsManager.HasSubscriptionsForEvent(eventName))

4.    {

5.        using (var scope = _autofac.BeginLifetimeScope(AUTOFAC_SCOPE_NAME))

6.        {

7.            var subscriptions = _subsManager.GetHandlersForEvent(eventName);

8.            foreach (var subscription in subscriptions)

9.            {

10.                if (subscription.IsDynamic)

11.                {

12.                    var handler = scope.ResolveOptional(subscription.HandlerType) as IDynamicIntegrationEventHandler;

13.                    dynamic eventData = JObject.Parse(message);

14.                    await handler.Handle(eventData);

15.                }

16.                else

17.                {

18.                    var eventType = _subsManager.GetEventTypeByName(eventName);

19.                    var integrationEvent = JsonConvert.DeserializeObject(message, eventType);

20.                    var handler = scope.ResolveOptional(subscription.HandlerType);

21.                    var concreteType = typeof(IIntegrationEventHandler<>).MakeGenericType(eventType);

22.                    await (Task)concreteType.GetMethod("Handle").Invoke(handler, new object[] { integrationEvent });

23.                }

24.            }

25.        }

26.    }

27. }