基于RabbitMQ的事件总线
在上文中，我们讨论了事件处理器中对象生命周期的问题，在进入新的讨论之前，首先让我们总结一下，我们已经实现了哪些内容。下面的类图描述了我们已经实现的组件及其之间的关系，貌似系统已经变得越来越复杂了。
class_diagram_chapter2
其中绿色的部分就是上文中新实现的部分，包括一个简单的Event Store，一个事件处理器执行上下文的接口，以及一个基于ASP.NET Core依赖注入框架的执行上下文的实现。接下来，我们打算淘汰PassThroughEventBus，然后基于RabbitMQ实现一套新的事件总线。
事件总线的重构
根据前面的结论，事件总线的执行需要依赖于事件处理器执行上下文，也就是上面类图中PassThroughEventBus对于IEventHandlerExecutionContext的引用。更具体些，是在事件总线订阅某种类型的事件时，需要将事件处理器注册到IEventHandlerExecutionContext中。那么在实现RabbitMQ时，也会有着类似的设计需求，即RabbitMQEventBus也需要依赖IEventHandlerExecutionContext接口，以保证事件处理器生命周期的合理性。
为此，我们新建一个基类：BaseEventBus，并将这部分公共的代码提取出来，需要注意以下几点：
1.通过BaseEventBus的构造函数传入IEventHandlerExecutionContext实例，也就限定了所有子类的实现中，必须在构造函数中传入IEventHandlerExecutionContext实例，这对于框架的设计非常有利：在实现新的事件总线时，框架的使用者无需查看API文档，即可知道事件总线与IEventHandlerExecutionContext之间的关系，这符合SOLID原则中的Open/Closed Principle
2.BaseEventBus的实现应该放在EdaSample.Common程序集中，更确切地说，它应该放在EdaSample.Common.Events命名空间下，因为它是属于框架级别的组件，并且不会依赖任何基础结构层的组件
BaseEventBus的代码如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public abstract class BaseEventBus : IEventBus
{
protected readonly IEventHandlerExecutionContext eventHandlerExecutionContext;
protected BaseEventBus(IEventHandlerExecutionContext eventHandlerExecutionContext)
{
this.eventHandlerExecutionContext = eventHandlerExecutionContext;
}
public abstract Task PublishAsync(TEvent @event, CancellationToken cancellationToken = default) where TEvent : IEvent;
public abstract void Subscribe()
where TEvent : IEvent
where TEventHandler : IEventHandler;
// Disposable接口实现代码省略
}
在上面的代码中，PublishAsync和Subscribe方法是抽象方法，以便子类根据不同的需要来实现。
接下来就是调整PassThroughEventBus，使其继承于BaseEventBus：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public sealed class PassThroughEventBus : BaseEventBus
{
private readonly EventQueue eventQueue = new EventQueue();
private readonly ILogger logger;
public PassThroughEventBus(IEventHandlerExecutionContext context,
ILogger logger)
: base(context)
{
this.logger = logger;
logger.LogInformation($"PassThroughEventBus构造函数调用完成。Hash Code：{this.GetHashCode()}.");
eventQueue.EventPushed += EventQueue_EventPushed;
}
private async void EventQueue_EventPushed(object sender, EventProcessedEventArgs e)
=> await this.eventHandlerExecutionContext.HandleEventAsync(e.Event);
public override Task PublishAsync(TEvent @event, CancellationToken cancellationToken = default)
{
return Task.Factory.StartNew(() => eventQueue.Push(@event));
}
public override void Subscribe()
{
if (!this.eventHandlerExecutionContext.HandlerRegistered())
{
this.eventHandlerExecutionContext.RegisterHandler();
}
}
// Disposable接口实现代码省略
}
代码都很简单，也就不多做说明了，接下来，我们开始实现RabbitMQEventBus。
RabbitMQEventBus的实现
首先需要新建一个.NET Standard 2.0的项目，使用.NET Standard 2.0的项目模板所创建的项目，可以同时被.NET Framework 4.6.1或者.NET Core 2.0的应用程序所引用。创建新的类库项目的目的，是因为RabbitMQEventBus的实现需要依赖RabbitMQ C#开发库这个外部引用。因此，为了保证框架核心的纯净和稳定，需要在新的类库项目中实现RabbitMQEventBus。
Note：对于RabbitMQ及其C#库的介绍，本文就不再涉及了，网上有很多资料和文档，博客园有很多朋友在这方面都有使用经验分享，RabbitMQ官方文档也写得非常详细，当然是英文版的，如果英语比较好的话，建议参考官方文档。
以下就是在EdaSample案例中，RabbitMQEventBus的实现，我们先读一读代码，再对这部分代码做些分析。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
public class RabbitMQEventBus : BaseEventBus
{
private readonly IConnectionFactory connectionFactory;
private readonly IConnection connection;
private readonly IModel channel;
private readonly string exchangeName;
private readonly string exchangeType;
private readonly string queueName;
private readonly bool autoAck;
private readonly ILogger logger;
private bool disposed;
public RabbitMQEventBus(IConnectionFactory connectionFactory,
ILogger logger,
IEventHandlerExecutionContext context,
string exchangeName,
string exchangeType = ExchangeType.Fanout,
string queueName = null,
bool autoAck = false)
: base(context)
{
this.connectionFactory = connectionFactory;
this.logger = logger;
this.connection = this.connectionFactory.CreateConnection();
this.channel = this.connection.CreateModel();
this.exchangeType = exchangeType;
this.exchangeName = exchangeName;
this.autoAck = autoAck;
this.channel.ExchangeDeclare(this.exchangeName, this.exchangeType);
this.queueName = this.InitializeEventConsumer(queueName);
logger.LogInformation($"RabbitMQEventBus构造函数调用完成。Hash Code：{this.GetHashCode()}.");
}
public override Task PublishAsync(TEvent @event, CancellationToken cancellationToken = default(CancellationToken))
{
var json = JsonConvert.SerializeObject(@event, new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.All });
var eventBody = Encoding.UTF8.GetBytes(json);
channel.BasicPublish(this.exchangeName,
@event.GetType().FullName,
null,
eventBody);
return Task.CompletedTask;
}
public override void Subscribe()
{
if (!this.eventHandlerExecutionContext.HandlerRegistered())
{
this.eventHandlerExecutionContext.RegisterHandler();
this.channel.QueueBind(this.queueName, this.exchangeName, typeof(TEvent).FullName);
}
}
protected override void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
this.channel.Dispose();
this.connection.Dispose();
logger.LogInformation($"RabbitMQEventBus已经被Dispose。Hash Code:{this.GetHashCode()}.");
}
disposed = true;
base.Dispose(disposing);
}
}
private string InitializeEventConsumer(string queue)
{
var localQueueName = queue;
if (string.IsNullOrEmpty(localQueueName))
{
localQueueName = this.channel.QueueDeclare().QueueName;
}
else
{
this.channel.QueueDeclare(localQueueName, true, false, false, null);
}
var consumer = new EventingBasicConsumer(this.channel);
consumer.Received += async (model, eventArgument) =>
{
var eventBody = eventArgument.Body;
var json = Encoding.UTF8.GetString(eventBody);
var @event = (IEvent)JsonConvert.DeserializeObject(json, new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.All });
await this.eventHandlerExecutionContext.HandleEventAsync(@event);
if (!autoAck)
{
channel.BasicAck(eventArgument.DeliveryTag, false);
}
};
this.channel.BasicConsume(localQueueName, autoAck: this.autoAck, consumer: consumer);
return localQueueName;
}
}
阅读上面的代码，需要注意以下几点：
1.正如上面所述，构造函数需要接受IEventHandlerExecutionContext对象，并通过构造函数的base调用，将该对象传递给基类
2.构造函数中，queueName参数是可选参数，也就是说：
1.如果通过RabbitMQEventBus发送事件消息，则无需指定queueName参数，仅需指定exchangeName即可，因为在RabbitMQ中，消息的发布方无需知道消息是发送到哪个队列中
2.如果通过RabbitMQEventBus接收事件消息，那么也分两种情况：
1.如果两个进程在使用RabbitMQEventBus时，同时指定了queueName参数，并且queueName的值相同，那么这两个进程将会轮流处理路由至queueName队列的消息
2.如果两个进程在使用RabbitMQEventBus时，同时指定了queueName参数，但queueName的值不相同，或者都没有指定queueName参数，那么这两个进程将会同时处理路由至queueName队列的消息
3.有关Exchange和Queue的概念，请参考RabbitMQ的官方文档
3.在Subscribe方法中，除了将事件处理器注册到事件处理器执行上下文之外，还通过QueueBind方法，将指定的队列绑定到Exchange上
4.事件数据都通过Newtonsoft.Json进行序列化和反序列化，使用TypeNameHandling.All这一设定，使得序列化的JSON字符串中带有类型名称信息。在此处这样做既是合理的，又是必须的，因为如果没有带上类型名称的信息，JsonConvert.DeserializeObject反序列化时，将无法判定得到的对象是否可以转换为IEvent对象，这样就会出现异常。但如果是实现一个更为通用的消息系统，应用程序派发出去的事件消息可能还会被由Python或者Java所实现的应用程序所使用，那么对于这些应用，它们并不知道Newtonsoft.Json是什么，也无法通过Newtonsoft.Json加入的类型名称来获知事件消息的初衷（Intent），Newtonsoft.Json所带的类型信息又会显得冗余。因此，简单地使用Newtonsoft.Json作为事件消息的序列化、反序列化工具，其实是欠妥的。更好的做法是，实现自定义的消息序列化、反序列化器，在进行序列化的时候，将.NET相关的诸如类型信息等，作为Metadata（元数据）附着在序列化的内容上。理论上说，在序列化的数据中加上一些元数据信息是合理的，只不过我们对这些元数据做一些标注，表明它是由.NET框架产生的，第三方系统如果不关心这些信息，可以对元数据不做任何处理
5.在Dispose方法中，注意将RabbitMQ所使用的资源dispose掉