在这个微服务火热的时代，如果不懂一点微服务相关的技术，想吹下牛都没有法子。于是有必要了解学习一下。所以我最近看了下微服务相关的知识。
微服务所涉及的知识是很广的，我这里只是讲一下事件总线，当然，有现成很棒的框架如CAP，但是我这里只是为了去体验去更深入的了解事件总线，去了解它的工作流程，所以我自己写了一个基于RabbitMQ的事件总线。
1，运行rabbitmq；
2，创建解决方案，模拟分布式如下图（我这里之前学下了一下微服务的网关，所以会有Gateway，所以要运行3个程序，并且运行Consul做服务发现）：
 基于rabbitmq的事件总线_第1张图片
3，实现api1的发布功能：
     1，创建IEventBus作为抽象接口，实际上你可以用多个MQ来实现它，我这里只是使用RabbitMQ，所以建一个EventBusRabbitMQ来实现接口

 public interface IEventBus { } public class EventBusRabbitMQ : IEventBus { }

 

 
     2，然后新建一个类，用来实现事件总线的DI注入：

serviceDescriptors.AddTransient();

     3，发布消息，为了能够让不同的服务都这个消息类型，并且可以使其作为参数传递，所以我们需要一个基类作为消息的总线：EventData，然后我们服务定义的每一个消息类型都必须继承这个类：

 public class CreateUserEvent : EventData {  public string Name { get; set; }  public string Address { get; set; }  public DateTime CreateTime { get; set; } }

 

      既然有消息那就会有消息事件，还需要一个EventHandler来驱动，所以每个服务的消息对象都应该有一个事件驱动的类，当然这个驱动类应该在订阅方，应为发布方只负责发布消息，至于消息的处理事件则应该由订阅方实现，下面再讲。其中消息的发布是基于rabbitmq，网上有很多实现的例子，这里只是我的写法，以EventData作为参数：

 public void Publish(EventData eventData)  {   string routeKey = eventData.GetType().Name;   channel.QueueDeclare(queueName, true, false, false, null);   string message = JsonConvert.SerializeObject(eventData);   byte[] body = Encoding.UTF8.GetBytes(message);   channel.BasicPublish(exchangeName, routeKey, null, body);  }

 

    然后访问apil来模拟消息发布：

 [HttpGet]  [Route("api/user/eventbus")]  public IActionResult Eventbus()  {   CreateUserEvent user = new CreateUserEvent();   user.Name = "hanh";   user.Address = "hubei";   user.CreateTime = DateTime.Now;   _eventBus.Publish(user);   return Ok("ok");  }

 

4，实现api2的订阅功能
       刚已经将了订阅应该会实现消息的事件处理，那么就会有UserEventHandler，继承EventHandler，来处理消息：

 public class UserEventHandler : IEventHandler, IEventHandler {  private readonly ILogger _logger;  public UserEventHandler(ILogger logger)  {   _logger = logger;  }  public async Task Handler(CreateUserEvent eventData)  {   _logger.LogInformation(JsonConvert.SerializeObject(eventData));    await Task.FromResult(0);  }  public async Task Handler(UpdateUserEvent eventData)  {   await Task.FromResult(0);  } }

 

     然后会开始处理订阅，大致的思路就是根据EventData作为key，然后每个EventData都应该有一个泛型的EventHandler<>接口，然后将其作为value存入内存中，同时rabbitmq绑定消息队列，当消息到达时，自动处理消息事件，获取到发布消息的类型名字，然后我们根据类型名字从内从中获取到它的EventData的类型，接着再根据这个类型，通过.net core内置的IOC来获取到它的实现类，每个EventData的类型会匹配到不同的EventHandler，所以会完成CRUD。至此，大致的订阅已经实现了：

 public void AddSub()    where T : EventData    where TH : IEventHandler  {   Type eventDataType = typeof(T);   Type handlerType = typeof(TH);   if (!eventhandlers.ContainsKey(typeof(T)))    eventhandlers.TryAdd(eventDataType, handlerType);   if(!eventTypes.ContainsKey(eventDataType.Name))    eventTypes.TryAdd(eventDataType.Name, eventDataType);   if (assemblyTypes != null)   {    Type implementationType = assemblyTypes.FirstOrDefault(s => handlerType.IsAssignableFrom(s));    if (implementationType == null)     throw new ArgumentNullException("未找到{0}的实现类", handlerType.FullName);    _serviceDescriptors.AddTransient(handlerType, implementationType);   }  } public void Subscribe()   where T : EventData   where TH : IEventHandler  {   _eventBusManager.AddSub();   channel.QueueBind(queueName, exchangeName, typeof(T).Name);   channel.QueueDeclare(queueName, true, false, false, null);   var consumer = new EventingBasicConsumer(channel);   consumer.Received +=async (model, ea) =>   {    string eventName = ea.RoutingKey;    byte[] resp = ea.Body.ToArray();    string body = Encoding.UTF8.GetString(resp);    _log.LogInformation(body);    try    {     Type eventType = _eventBusManager.FindEventType(eventName);     T eventData = (T)JsonConvert.DeserializeObject(body, eventType);     IEventHandler eventHandler = _eventBusManager.FindHandlerType(eventType) as IEventHandler;     await eventHandler.Handler(eventData);    }    catch (Exception ex)    {     throw ex;    }   };   channel.BasicConsume(queueName, true, consumer);  }

 

5，测试，访问api1，发布成功，然后api2会同时打印出信息：
基于rabbitmq的事件总线_第2张图片
基于rabbitmq的事件总线_第3张图片

最后给大家贴出核心代码，如果想看完整的请访问地址 https://github.com/Hansdas/Micro
 

using Micro.Core.EventBus.RabbitMQ;using System;using System.Collections.Generic;using System.Text;namespace Micro.Core.EventBus{ public interface IEventBus {  ///   /// 发布  ///   ///   void Publish(EventData eventData);  ///   /// 订阅  ///   ///   ///   void Subscribe()   where T : EventData   where TH : IEventHandler;  ///   /// 取消订阅  ///   ///   ///   void Unsubscribe()    where T : EventData    where TH : IEventHandler; }}

 


    

using log4net;using Micro.Core.EventBus.RabbitMQ.IImplementation;using Microsoft.Extensions.DependencyInjection;using Microsoft.Extensions.DependencyInjection.Extensions;using Microsoft.Extensions.Logging;using Newtonsoft.Json;using RabbitMQ.Client;using RabbitMQ.Client.Events;using System;using System.Collections.Generic;using System.Reflection;using System.Text;namespace Micro.Core.EventBus.RabbitMQ{ public class EventBusRabbitMQ : IEventBus {  ///   /// 队列名称  ///   private string queueName = "QUEUE";  ///   /// 交换机名称  ///   private string exchangeName = "directName";  ///   /// 交换类型  ///   private string exchangeType = "direct";  private IFactoryRabbitMQ _factory;  private IEventBusManager _eventBusManager;  private ILogger _log;  private readonly IConnection connection;  private readonly IModel channel;  public EventBusRabbitMQ(IFactoryRabbitMQ factory, IEventBusManager eventBusManager, ILogger log)  {   _factory = factory;   _eventBusManager = eventBusManager;   _eventBusManager.OnRemoveEventHandler += OnRemoveEvent;   _log = log;   connection = _factory.CreateConnection();   channel = connection.CreateModel();  }  private void OnRemoveEvent(object sender, ValueTuple args)  {   channel.QueueUnbind(queueName, exchangeName, args.Item1.Name);  }  public void Publish(EventData eventData)  {   string routeKey = eventData.GetType().Name;   channel.QueueDeclare(queueName, true, false, false, null);   string message = JsonConvert.SerializeObject(eventData);   byte[] body = Encoding.UTF8.GetBytes(message);   channel.BasicPublish(exchangeName, routeKey, null, body);  }  public void Subscribe()   where T : EventData   where TH : IEventHandler  {   _eventBusManager.AddSub();   channel.QueueBind(queueName, exchangeName, typeof(T).Name);   channel.QueueDeclare(queueName, true, false, false, null);   var consumer = new EventingBasicConsumer(channel);   consumer.Received +=async (model, ea) =>   {    string eventName = ea.RoutingKey;    byte[] resp = ea.Body.ToArray();    string body = Encoding.UTF8.GetString(resp);    _log.LogInformation(body);    try    {     Type eventType = _eventBusManager.FindEventType(eventName);     T eventData = (T)JsonConvert.DeserializeObject(body, eventType);     IEventHandler eventHandler = _eventBusManager.FindHandlerType(eventType) as IEventHandler;     await eventHandler.Handler(eventData);    }    catch (Exception ex)    {     throw ex;    }   };   channel.BasicConsume(queueName, true, consumer);  }  public void Unsubscribe()   where T : EventData   where TH : IEventHandler  {   if (_eventBusManager.HaveAddHandler(typeof(T)))   {    _eventBusManager.RemoveEventSub();   }  } }}

 

using System;using System.Collections.Generic;using System.Text;namespace Micro.Core.EventBus{ public interface IEventBusManager {  ///   /// 取消订阅事件  ///   event EventHandler> OnRemoveEventHandler;  ///   /// 订阅  ///   ///   ///   void AddSub()   where T : EventData   where TH : IEventHandler;  ///   /// 取消订阅  ///   ///   ///   void RemoveEventSub()   where T : EventData   where TH : IEventHandler;  ///   /// 是否包含实体类型  ///   ///   ///   bool HaveAddHandler(Type eventDataType);  ///   /// 根据实体名称寻找类型  ///   ///   ///   Type FindEventType(string eventName);  ///   /// 根据实体类型寻找它的领域事件驱动  ///   ///   ///   object FindHandlerType(Type eventDataType); }}

 

using Micro.Core.Configure;using Microsoft.Extensions.DependencyInjection;using Microsoft.Extensions.DependencyInjection.Extensions;using System;using System.Collections.Concurrent;using System.Collections.Generic;using System.Linq;using System.Reflection;using System.Text;namespace Micro.Core.EventBus{ internal class EventBusManager : IEventBusManager {  public event EventHandler> OnRemoveEventHandler;  private static ConcurrentDictionary eventhandlers=new ConcurrentDictionary();  private readonly ConcurrentDictionary eventTypes = new ConcurrentDictionary();  private readonly IList assemblyTypes;  private readonly IServiceCollection _serviceDescriptors;  private Func _buildServiceProvider;  public EventBusManager(IServiceCollection serviceDescriptors,Func buildServiceProvicer)  {   _serviceDescriptors = serviceDescriptors;   _buildServiceProvider = buildServiceProvicer;   string dllName = ConfigurationProvider.configuration.GetSection("EventHandler.DLL").Value;   if (!string.IsNullOrEmpty(dllName))   {    assemblyTypes = Assembly.Load(dllName).GetTypes();   }  }  private void OnRemoveEvent(Type eventDataType, Type handler)  {   if (OnRemoveEventHandler != null)   {    OnRemoveEventHandler(this, new ValueTuple(eventDataType, handler));   }  }  public void AddSub()    where T : EventData    where TH : IEventHandler  {   Type eventDataType = typeof(T);   Type handlerType = typeof(TH);   if (!eventhandlers.ContainsKey(typeof(T)))    eventhandlers.TryAdd(eventDataType, handlerType);   if(!eventTypes.ContainsKey(eventDataType.Name))    eventTypes.TryAdd(eventDataType.Name, eventDataType);   if (assemblyTypes != null)   {    Type implementationType = assemblyTypes.FirstOrDefault(s => handlerType.IsAssignableFrom(s));    if (implementationType == null)     throw new ArgumentNullException("未找到{0}的实现类", handlerType.FullName);    _serviceDescriptors.AddTransient(handlerType, implementationType);   }  }  public void RemoveEventSub()   where T : EventData   where TH : IEventHandler  {   OnRemoveEvent(typeof(T), typeof(TH));  }  public bool HaveAddHandler(Type eventDataType)  {   if (eventhandlers.ContainsKey(eventDataType))    return true;   return false;  }  public Type FindEventType(string eventName)  {   if(!eventTypes.ContainsKey(eventName))    throw new ArgumentException(string.Format("eventTypes不存在类名{0}的key", eventName));   return eventTypes[eventName];  }  public object FindHandlerType(Type eventDataType)  {   if(!eventhandlers.ContainsKey(eventDataType))    throw new ArgumentException(string.Format("eventhandlers不存在类型{0}的key", eventDataType.FullName));   var obj = _buildServiceProvider(_serviceDescriptors).GetService(eventhandlers[eventDataType]);   if (eventhandlers[eventDataType].IsAssignableFrom(obj.GetType()))    return obj;   return null;  } }}

 

using Micro.Core.Configure;        using Micro.Core.EventBus.RabbitMQ;using Micro.Core.EventBus.RabbitMQ.IImplementation;using Microsoft.AspNetCore.Builder;using Microsoft.Extensions.DependencyInjection;using Microsoft.Extensions.DependencyInjection.Extensions;using System;using System.Collections.Generic;using System.Linq;using System.Reflection;using System.Text;namespace Micro.Core.EventBus{ public static class EventBusBuilder {  public static EventBusOption eventBusOption;  public static IServiceCollection AddEventBus(this IServiceCollection serviceDescriptors)  {   eventBusOption= ConfigurationProvider.GetModel("EventBusOption");   switch (eventBusOption.MQProvider)   {    case MQProvider.RabbitMQ:     serviceDescriptors.AddTransient();     serviceDescriptors.AddTransient(typeof(IFactoryRabbitMQ), factiory => {      return new FactoryRabbitMQ(eventBusOption);     });     break;   }   EventBusManager eventBusManager = new EventBusManager(serviceDescriptors,s=>s.BuildServiceProvider());   serviceDescriptors.AddSingleton(eventBusManager);   return serviceDescriptors;  } }}

api1

 public class Startup {  public Startup(IConfiguration configuration)  {   Configuration = configuration;  }  public IConfiguration Configuration { get; }  // This method gets called by the runtime. Use this method to add services to the container.  public void ConfigureServices(IServiceCollection services)  {   services.AddControllers();   services.AddEventBus();  }   }

 

api2:

using System;using System.Collections.Generic;using System.Linq;using System.Threading.Tasks;using Micro.Core.Configure;using Micro.Core.Consul;using Micro.Core.EventBus;using Micro.Services.Domain;using Microsoft.AspNetCore.Builder;using Microsoft.AspNetCore.Hosting;using Microsoft.AspNetCore.HttpsPolicy;using Microsoft.AspNetCore.Mvc;using Microsoft.Extensions.Configuration;using Microsoft.Extensions.DependencyInjection;using Microsoft.Extensions.Hosting;using Microsoft.Extensions.Logging;using ConfigurationProvider = Micro.Core.Configure.ConfigurationProvider;namespace WebApi3{ public class Startup {  public Startup(IConfiguration configuration)  {   Configuration = configuration;  }  public IConfiguration Configuration { get; }  // This method gets called by the runtime. Use this method to add services to the container.  public void ConfigureServices(IServiceCollection services)  {   services.AddControllers();   services.AddEventBus();  }  // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.  public void Configure(IApplicationBuilder app, IWebHostEnvironment env)  {   var eventBus= app.ApplicationServices.GetRequiredService();   eventBus.Subscribe>();   eventBus.Subscribe>();   if (env.IsDevelopment())   {    app.UseDeveloperExceptionPage();   }  } }}

 

ps:取消订阅还没有试过，我看了好多人写的取消订阅的方法是基于事件的思想，我也理解不了为啥，因为我觉得直接定义一个方法去实现就好了。

 

转自  天天博客，欢迎访问

基于rabbitmq的事件总线
文章转载：http://www.shaoqun.com/a/463241.html