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

上一节说了事件总线

本节在消息队列中实现事件处理：.Net Core 5.x Api开发笔记 -- 消息队列RabbitMQ实现事件总线EventBus(一)

既然是消息队列，就需要有生产者和消费者(订阅)

public interface IMessageQueue
{
    /// <summary>
    /// 发布消息
    /// </summary>
    void Publish<T>(T message, string exchangeName = "default", string queueName = "") where T : class;

    /// <summary>
    /// 订阅消息
    /// </summary>
    void Consume<T>(Func<T, Task<bool>> func, string queueName = "");
}

生产者端实现发布消息接口:

public class RabbitMQPublishClient : IMessageQueue
{
    private static ConcurrentDictionary<string, string> QueueDic = new ConcurrentDictionary<string, string>();
    public RabbitMQPublishClient(){}
    
    /// <summary>
    /// 发布消息
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="message">消息实体</param>
    /// <param name="exchangeName">交换机名称（默认default）</param>
    /// <param name="queueName">队列名称（默认类名）</param>
    public void Publish<T>(T message, string exchangeName = "default", string queueName = "") where T : class
    {
        using (var conn = GetConnection())
        {
            using (var channel = conn.CreateModel())
            {
                if (!QueueDic.ContainsKey(queueName) || QueueDic[queueName] != exchangeName)
                {
                    CreateQueue(channel, exchangeName, queueName, true);
                    QueueDic.TryAdd(queueName, exchangeName);
                }
                var props = channel.CreateBasicProperties();
                props.Persistent = true;  //消息持久化
                props.DeliveryMode = 2;   //消息持久化
                props.CorrelationId = Guid.NewGuid().ToString();

                string content = JsonConvert.SerializeObject(message);
                var body = Encoding.UTF8.GetBytes(content);
                channel.BasicPublish(exchange: exchangeName, routingKey: queueName, basicProperties: props, body: body);
            }
        }
    }

    /// <summary>
    /// 创建队列，绑定到交换机
    /// </summary>
    private void CreateQueue(IModel channel, string exchangeName, string queueName, bool isDurable = true)
    {
        channel.ExchangeDeclare(exchangeName, ExchangeType.Direct, durable: isDurable, autoDelete: false, arguments: null);
        channel.QueueDeclare(queueName, durable: isDurable, exclusive: false, autoDelete: false, arguments: null);
        channel.QueueBind(queueName, exchangeName, routingKey: queueName);
    }
}

消费者(订阅者)实现订阅接口

public class RabbitMQConsumerClient : IMessageQueue
{
    public RabbitMQConsumerClient(){}

    /// <summary>
    /// 订阅消息
    /// </summary>
    public void Consume<T>(Func<T, Task<bool>> func, string queueName = "")
    {
        string exchangeName = exchangeName.Equals("default") ? $"{customKey}.default" : $"{customKey}.{queueName}";

        var collection = GetConnection();
        var channel = collection.CreateModel();
        channel.ExchangeDeclare(exchangeName, "direct", durable: true, autoDelete: false, arguments: null);
        channel.QueueDeclare(queue: queueName, durable: true, exclusive: false, autoDelete: false, arguments: null);
        channel.QueueBind(queueName, exchangeName, routingKey: queueName, arguments: null);

        //消费事件
        var consumer = new EventingBasicConsumer(channel);
        consumer.Received += async (sender, e) =>
        {
            try
            {
                string content = Encoding.UTF8.GetString(e.Body.ToArray());
                T message = JsonConvert.DeserializeObject<T>(content);
                bool isSuccess = await func.Invoke(message);    //执行func委托  这里才是真正执行传入的事件处理程序
                if (isSuccess)
                {
                    channel.BasicAck(e.DeliveryTag, false);     //手动确认消息消费成功
                }
                else
                {
                   channel.BasicReject(e.DeliveryTag, true);    //手动打回队列，下次重新消费
                }
            }
            catch (Exception ex)
            {
                channel.BasicAck(e.DeliveryTag, false);
            }
        };

        channel.BasicQos(0, 1, false);  //限制同时接收消息数量为1，true是将限制应用于channel级，false是将限制应用于consumer级
        channel.BasicConsume(queue: queueName, autoAck: false, consumer: consumer);   //订阅消息   autoAck: false 表示手动确认消息
    }
}

上边都是平时很常用的功能逻辑，接下来是才是重点！！！

1，事件总线有了

2，生产者订阅者也有了

接下来还需要做至少3件事：

1，创建事件处理程序，就是真正干活的

2，注册消费者、注册事件处理程序、绑定事件源和事件处理程序（在订阅端）

3，订阅端启动消费者订阅监控，并触发事件处理程序

4，发布消息测试

-----------------------------------------------------------------

1，创建事件处理程序

/// <summary>
/// 事件处理程序，真正干活的是我
/// 继承IEventHandler<T>接口，其中T必须用EventWithData<TData>类型，因为EventWithData<TData>继承了EventBase类
/// </summary>
public class Person_EventHandler : IEventHandler<EventWithData<Person>>
{
    //最终干活的
    public async Task HandleEvent(EventWithData<Person> eventWithData)
    {
        var data = eventWithData.Data;
        if (data == null)
        {
            Console.WriteLine("么有数据呀!");
        }
        else
        {
            try
            {
                Console.WriteLine($"{DateTime.Now}-------" + JsonConvert.SerializeObject(data));
            }
            catch (Exception ex)
            {
                Console.WriteLine("异常：" + ex.Message);
            }
        }
    }
}

2，注册消费者、注册事件处理程序、绑定事件源和事件处理程序（在订阅端），这一步在 Startup 中实现！！！

public IServiceCollection ServiceCollection { get; private set; }
public void ConfigureServices(IServiceCollection services)
{
    ServiceCollection = services;    //将services传递给ServiceCollection
    services.AddControllersWithViews();

    //注册消费者
    services.AddSingleton<IMessageQueue, RabbitMQConsumerClient>();
    //注册事件处理程序，绑定事件源：IEventHandler<EventWithData<Person>>和事件处理程序：Person_EventHandler的关系
    services.AddSingleton<Person_EventHandler>();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    //绑定事件源和事件处理程序的映射关系  
    //这里跟上边的绑定不是一回事，这里仅仅就是绑定了一个映射关系，等到后边事件触发的时候需要用到该处映射关系
    EventBus.Default.RegisterHandler<EventWithData<Person>, Person_EventHandler>();

    //其它中间件。。
    。。。

    //启动消费者订阅监控入口
    app.Consumer(app.ApplicationServices, ServiceCollection);
}

3，启动消费者订阅监控，并触发事件处理程序

/// <summary>
/// 启动消费者订阅监控入口
/// </summary>
public static void Consumer(this IApplicationBuilder app, IServiceProvider provider, IServiceCollection services)
{
    //获取实例对象 
    IMessageQueue queue = provider.GetService<IMessageQueue>();   

    //异步调用，这里接收的消息类型T为：EventWithData<Person>  也可以是其它自定义消息类型,没有限制
    queue.Consume<EventWithData<Person>>(async message =>
    {
        using (var currentContainer = services.BuildServiceProvider().CreateScope())   //使用系统内置服务容器
        {
            IocManager.Configure(currentContainer.ServiceProvider);                //将容器服务传递过去
            
            var e = EventWithData<Person>.New(message.Data);      //这里要传递的消息类型必须使用 EventWithData<TData>类型初始化消息
            
            await EventBus.Default.TriggerAsync(e);               //调用触发事件逻辑(需要提前绑定映射关系和注册容器)
            
            return true;
        }
    });
}

说明：

IocManager.Configure(currentContainer.ServiceProvider)  实际上就是声明了一个全局的 IServiceProvider 变量，然后将当前的ServiceProvider赋值给全局变量

await EventBus.Default.TriggerAsync(e)   执行的就是上一节事件总线中的 public async Task TriggerAsync<TEvent>(TEvent e)  方法

到这里 事件源和事件处理程序就一一对应上了。

接下来开始测试一下是否可用，先在发布的应用程序Startup中注册一下消息队列容器

services.AddSingleton<IMessageQueue, RabbitMQPublishClient>();

然后发布一条消息，注意：这里消息的类型EventWithData<Person>没有限制的，你可以不使用EventWithData<Person>类型的消息也行

//发布消息
var message = EventWithData<Person>.New(
    new Person()
    {
        UserId = 1,
        UserName = "张三"
    }
);

messageQueue.Publish(message);

最后测试，订阅者成功消费了刚刚生产的消息