在这个微服务火热的时代，如果不懂一点微服务相关的技术，想吹下牛都没有法子。于是有必要了解学习一下。所以我最近看了下微服务相关的知识。
微服务所涉及的知识是很广的，我这里只是讲一下事件总线，当然，有现成很棒的框架如CAP，但是我这里只是为了去体验去更深入的了解事件总线，去了解它的工作流程，所以我自己写了一个基于RabbitMQ的事件总线。
1，运行rabbitmq；
2，创建解决方案，模拟分布式如下图（我这里之前学下了一下微服务的网关，所以会有Gateway，所以要运行3个程序，并且运行Consul做服务发现）：
3，实现api1的发布功能：
1，创建IEventBus作为抽象接口，实际上你可以用多个MQ来实现它，我这里只是使用RabbitMQ，所以建一个EventBusRabbitMQ来实现接口
public interface IEventBus { } public class EventBusRabbitMQ : IEventBus { }
2，然后新建一个类，用来实现事件总线的DI注入：
serviceDescriptors.AddTransient<IEventBus, EventBusRabbitMQ>();
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<CreateUserEvent>, IEventHandler<UpdateUserEvent> { private readonly ILogger<UserEventHandler> _logger; public UserEventHandler(ILogger<UserEventHandler> 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<T, TH>() 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<T, TH>() where T : EventData where TH : IEventHandler { _eventBusManager.AddSub<T, TH>(); 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<T> eventHandler = _eventBusManager.FindHandlerType(eventType) as IEventHandler<T>; await eventHandler.Handler(eventData); } catch (Exception ex) { throw ex; } }; channel.BasicConsume(queueName, true, consumer); }
5，测试，访问api1，发布成功，然后api2会同时打印出信息：
最后给大家贴出核心代码，如果想看完整的请访问地址 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 { /// <summary> /// 发布 /// </summary> /// <param name="eventData"></param> void Publish(EventData eventData); /// <summary> /// 订阅 /// </summary> /// <typeparam name="T"></typeparam> /// <typeparam name="TH"></typeparam> void Subscribe<T, TH>() where T : EventData where TH : IEventHandler; /// <summary> /// 取消订阅 /// </summary> /// <typeparam name="T"></typeparam> /// <typeparam name="TH"></typeparam> void Unsubscribe<T, TH>() 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 { /// <summary> /// 队列名称 /// </summary> private string queueName = "QUEUE"; /// <summary> /// 交换机名称 /// </summary> private string exchangeName = "directName"; /// <summary> /// 交换类型 /// </summary> private string exchangeType = "direct"; private IFactoryRabbitMQ _factory; private IEventBusManager _eventBusManager; private ILogger<EventBusRabbitMQ> _log; private readonly IConnection connection; private readonly IModel channel; public EventBusRabbitMQ(IFactoryRabbitMQ factory, IEventBusManager eventBusManager, ILogger<EventBusRabbitMQ> log) { _factory = factory; _eventBusManager = eventBusManager; _eventBusManager.OnRemoveEventHandler += OnRemoveEvent; _log = log; connection = _factory.CreateConnection(); channel = connection.CreateModel(); } private void OnRemoveEvent(object sender, ValueTuple<Type, Type> 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<T, TH>() where T : EventData where TH : IEventHandler { _eventBusManager.AddSub<T, TH>(); 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<T> eventHandler = _eventBusManager.FindHandlerType(eventType) as IEventHandler<T>; await eventHandler.Handler(eventData); } catch (Exception ex) { throw ex; } }; channel.BasicConsume(queueName, true, consumer); } public void Unsubscribe<T, TH>() where T : EventData where TH : IEventHandler { if (_eventBusManager.HaveAddHandler(typeof(T))) { _eventBusManager.RemoveEventSub<T, TH>(); } } } }
using System; using System.Collections.Generic; using System.Text; namespace Micro.Core.EventBus { public interface IEventBusManager { /// <summary> /// 取消订阅事件 /// </summary> event EventHandler<ValueTuple<Type, Type>> OnRemoveEventHandler; /// <summary> /// 订阅 /// </summary> /// <typeparam name="T"></typeparam> /// <typeparam name="TH"></typeparam> void AddSub<T, TH>() where T : EventData where TH : IEventHandler; /// <summary> /// 取消订阅 /// </summary> /// <typeparam name="T"></typeparam> /// <typeparam name="TH"></typeparam> void RemoveEventSub<T, TH>() where T : EventData where TH : IEventHandler; /// <summary> /// 是否包含实体类型 /// </summary> /// <param name="type"></param> /// <returns></returns> bool HaveAddHandler(Type eventDataType); /// <summary> /// 根据实体名称寻找类型 /// </summary> /// <param name="eventName"></param> /// <returns></returns> Type FindEventType(string eventName); /// <summary> /// 根据实体类型寻找它的领域事件驱动 /// </summary> /// <param name="eventDataType"></param> /// <returns></returns> 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<ValueTuple<Type, Type>> OnRemoveEventHandler; private static ConcurrentDictionary<Type, Type> eventhandlers=new ConcurrentDictionary<Type, Type>(); private readonly ConcurrentDictionary<string, Type> eventTypes = new ConcurrentDictionary<string, Type>(); private readonly IList<Type> assemblyTypes; private readonly IServiceCollection _serviceDescriptors; private Func<IServiceCollection, IServiceProvider> _buildServiceProvider; public EventBusManager(IServiceCollection serviceDescriptors,Func<IServiceCollection,IServiceProvider> 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<Type, Type>(eventDataType, handler)); } } public void AddSub<T, TH>() 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<T, TH>() 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>("EventBusOption"); switch (eventBusOption.MQProvider) { case MQProvider.RabbitMQ: serviceDescriptors.AddTransient<IEventBus, EventBusRabbitMQ>(); serviceDescriptors.AddTransient(typeof(IFactoryRabbitMQ), factiory => { return new FactoryRabbitMQ(eventBusOption); }); break; } EventBusManager eventBusManager = new EventBusManager(serviceDescriptors,s=>s.BuildServiceProvider()); serviceDescriptors.AddSingleton<IEventBusManager>(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<IEventBus>(); eventBus.Subscribe<CreateUserEvent, IEventHandler<CreateUserEvent>>(); eventBus.Subscribe<UpdateUserEvent, IEventHandler<UpdateUserEvent>>(); if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } } } }
ps:取消订阅还没有试过，我看了好多人写的取消订阅的方法是基于事件的思想，我也理解不了为啥，因为我觉得直接定义一个方法去实现就好了。
转自 天天博客，欢迎访问