EventBus模块

EventBus 是一种事件发布订阅模式,借助 EventBus 我们可以很好的实现组件之间，服务之间，系统之间的解耦以及相互通信的问题。

EventBus 相当于是定义一些抽象接口，可以用 MQ 来实现EventBus

1、模块的预处理模块，定义预处理方法，增加实现ILocalEventHandler，IDistributedEventHandler的服务增加到配置

LocalEventBusOptions、DistributedEventBusOptions，分别存储ITypeList<IEventHandler> Handlers { get; }

2、IEventHandle接口，分ILocalEventHandler<in TEvent>，IDistributedEventHandler

        /// <summary>
        /// Handler handles the event by implementing this method.
        /// </summary>
        /// <param name="eventData">Event data</param>
        Task HandleEventAsync(TEvent eventData);

IEventHandlerFactory,负责得到或创建事件处理器，三个实现IocEventHandlerFactory，SingleInstanceHandlerFactory，TransientEventHandlerFactory

 IEventHandlerDisposeWrapper GetHandler();


  public interface IEventHandlerDisposeWrapper : IDisposable
    {
        IEventHandler EventHandler { get; }
    }

  public class EventHandlerDisposeWrapper : IEventHandlerDisposeWrapper
    {
        public IEventHandler EventHandler { get; }

        private readonly Action _disposeAction;

        public EventHandlerDisposeWrapper(IEventHandler eventHandler, Action disposeAction = null)
        {
            _disposeAction = disposeAction;
            EventHandler = eventHandler;
        }

        public void Dispose()
        {
            _disposeAction?.Invoke();
        }
    }

3、EventBus：用来发布/订阅/取消订阅事件

public abstract Task PublishAsync(Type eventType, object eventData);

public abstract IDisposable Subscribe(Type eventType, IEventHandlerFactory factory);


 public abstract void Unsubscribe<TEvent>(Func<TEvent, Task> action) where TEvent : class;

 public abstract void Unsubscribe(Type eventType, IEventHandler handler);
 public abstract void Unsubscribe(Type eventType, IEventHandlerFactory factory);
public abstract void Unsubscribe(Type eventType, IEventHandlerFactory factory);
public abstract void UnsubscribeAll(Type eventType);

二、AbpRabbitMqModule

 [DependsOn(
        typeof(AbpJsonModule),
        typeof(AbpThreadingModule)
        )]
    public class AbpRabbitMqModule : AbpModule
    {
        public override void ConfigureServices(ServiceConfigurationContext context)
        {
            var configuration = context.Services.GetConfiguration();
            Configure<AbpRabbitMqOptions>(configuration.GetSection("RabbitMQ"));
        }

        public override void OnApplicationShutdown(ApplicationShutdownContext context)
        {
            context.ServiceProvider
                .GetRequiredService<IChannelPool>()
                .Dispose();

            context.ServiceProvider
                .GetRequiredService<IConnectionPool>()
                .Dispose();
        }

三、AbpEventBusRabbitMqModule

public override Task PublishAsync(Type eventType, object eventData)
        {
            var eventName = EventNameAttribute.GetNameOrDefault(eventType);
            var body = Serializer.Serialize(eventData);

            using (var channel = ConnectionPool.Get(RabbitMqEventBusOptions.ConnectionName).CreateModel())
            {
                channel.ExchangeDeclare(
                    RabbitMqEventBusOptions.ExchangeName,
                    "direct",
                    durable: true
                );
                
                var properties = channel.CreateBasicProperties();
                properties.DeliveryMode = RabbitMqConsts.DeliveryModes.Persistent;

                channel.BasicPublish(
                   exchange: RabbitMqEventBusOptions.ExchangeName,
                    routingKey: eventName,
                    mandatory: true,
                    basicProperties: properties,
                    body: body
                );
            }

            return Task.CompletedTask;
        }

        public override IDisposable Subscribe(Type eventType, IEventHandlerFactory factory)
        {
            var handlerFactories = GetOrCreateHandlerFactories(eventType);
            
            handlerFactories.Add(factory);

            if (handlerFactories.Count == 1) //TODO: Multi-threading!
            {
                Consumer.BindAsync(EventNameAttribute.GetNameOrDefault(eventType));
            }

            return new EventHandlerFactoryUnregistrar(this, eventType, factory);
        }

一、AbpLocalEventBusOptions,AbpDistributedEventBusOptions

IEventHandler是一个空方法，分为ILocalEventHandler<TEvent>,IDistributedEventHandler<TEvent>方法，它需要注入到容器。

具有HandleEventAsync（EventType eventData)）方法

保存着IEventHandler的实现类型，它通过OnRegistered遍历IServiceCollection服务的委托方法，将ILocalEventHandler<EventType>方法保存在AbpLocalEventBusOptions下列表

将IDistributedEventHandler<EventType>保存在AbpDistributedEventBusOptions下列表里

而ActionEventHandle<T> 是本地ILocalEventHandle的方法，它是 TransientDependency方法，它执行是委托方法。

二、IEventBus，它执行的是发布事件，订阅和取消订阅，EventBus是抽象方法，它的实现有NullDistributedEventBus, 这个不注入容器的

它的实现方法将Option的IEventHandler列表方法,将IEventHandle<eventType>的eventType以及EventHandlerFactory（多个实例），即从容器根据HandlerType获取IEventHandler,进行订阅在EventBus里

（1）、Local

(1)LocalBus：ISingletonDependency
订阅方法：保存EventType,以及工厂方法保存在字典里

protected ConcurrentDictionary<Type, List<IEventHandlerFactory>> HandlerFactories { get; }

IEventHandleFactory工厂方法GetHandler(),IsInFactories(List(IEventHandlerFactory)),有以下3个
>>SingleInstanceHandlerFactory：
IEventHandle来自外部赋值，每次执行都是使用同一个实例
Subscribe(Type eventType, IEventHandler handler)
Subscribe<TEvent>（TEvent委托，使用是的ActionEventHandler<TEvent>）

 public IEventHandlerDisposeWrapper GetHandler()
        {
            return new EventHandlerDisposeWrapper(HandlerInstance);
        }

>>TransientEventHandlerFactory：每次都创建

Subscribe<TEvent, THandler>()

 protected virtual IEventHandler CreateHandler()
        {
            return (IEventHandler) Activator.CreateInstance(HandlerType);
        }
        public virtual IEventHandlerDisposeWrapper GetHandler()
        {
            var handler = CreateHandler();
            return new EventHandlerDisposeWrapper(
                handler,
                () => (handler as IDisposable)?.Dispose()
            );
        }

>>IocEventHandlerFactory，Option的默认，在容器里依赖注入服务
Subscribe(Type eventType, IEventHandlerFactory factory)

     public IEventHandlerDisposeWrapper GetHandler()
        {
            var scope = ScopeFactory.CreateScope();
            return new EventHandlerDisposeWrapper(
                (IEventHandler) scope.ServiceProvider.GetRequiredService(HandlerType),
                () => scope.Dispose()
            );
        }

如果EventType是泛型，泛型的参数只有一个，而且这个泛型是继承自IEventDataWithInheritableGenericArgument，实现之一>entityEventData<TEntity>,

entityEventData<TEntity> 实现类型 entityChangedEventData<T> ，EntityChangingEventData<T>

entityChangedEventData<T> 其实现类型有EntityCreatedEventData<T>、EntityUpdatedEventData<T>、EntityDeletedEventData<T>

EntityChangingEventData<T> 其实现类型有<T> ,EntityUpdatingEventData<T>,EntityDeletingEventData<T>

EntityChangeReport 三个List，在AbpDbContext的SaveChangesAsync进行创建，赋值

1、EntityChangeEntry （类型是否Created、Updated、Deleted），使用的是options.EtoMappings，若没有，使用是 EntityEto

EntityCreatedEto<EntityEto>，EntityUpdatedEto<EntityEto>，EntityDeletedEto<EntityEto>

2、DomainEvents （LocalEvent)

3、DistributedEvents: 使用的Eto,在聚合根手工赋值，不是使用automaper

LocalBus提交的类型是EntityCreatingEventData<>，EntityCreatedEventData<>

DistributedEventBus提交是EntityCreatedEto<>，EntityUpdatedEto<>,EntityDeletedEto<>

依赖EntityToEtoMapper如何将entity转成dto,再发送到EventBus里

   private void ConfigureDistributedEventBus()
        {
           Configure<AbpDistributedEventBusOptions>(options =>
           {
               options.EtoMappings.Add<Person, PersonEto>();
           });
        }

另外是LocalEvent、DistributedEvents

TEntity泛型参数的BaseType，也要执行一次

直到底层Object（Object是一切对象的基型）,也要执行

 if (eventType.GetTypeInfo().IsGenericType &&
                eventType.GetGenericArguments().Length == 1 &&
                typeof(IEventDataWithInheritableGenericArgument).IsAssignableFrom(eventType))
            {
                var genericArg = eventType.GetGenericArguments()[0];
                var baseArg = genericArg.GetTypeInfo().BaseType;
                if (baseArg != null)
                {
                    var baseEventType = eventType.GetGenericTypeDefinition().MakeGenericType(baseArg);
                    var constructorArgs = ((IEventDataWithInheritableGenericArgument)eventData).GetConstructorArgs();
                    var baseEventData = Activator.CreateInstance(baseEventType, constructorArgs);
                    await PublishAsync(baseEventType, baseEventData);
                }
            }

将Option的handler订阅在EventBus里

 protected virtual void SubscribeHandlers(ITypeList<IEventHandler> handlers)
        {
            foreach (var handler in handlers)
            {
                var interfaces = handler.GetInterfaces();
                foreach (var @interface in interfaces)
                {
                    if (!typeof(IEventHandler).GetTypeInfo().IsAssignableFrom(@interface))
                    {
                        continue;
                    }

                    var genericArgs = @interface.GetGenericArguments();
                    if (genericArgs.Length == 1)
                    {
                        Subscribe(genericArgs[0], new IocEventHandlerFactory(ServiceScopeFactory, handler));
                    }
                }
            }
        }

取消订阅：取消对应类型TEvent，ACtion方法==》ActionHandle<TEvent> 处理Handle   ====>针对SingleInstanceHandlerFactory
工厂方法，取消所有订阅，=》对列表的Factories

 public abstract void Unsubscribe<TEvent>(Func<TEvent, Task> action) where TEvent : class;
 public abstract void Unsubscribe(Type eventType, IEventHandler handler);
 public abstract void Unsubscribe(Type eventType, IEventHandlerFactory factory);
  public abstract void UnsubscribeAll(Type eventType);

（2）Distributed

1）LocalDistributedEventBus,它是TryRegister方法，它是SingletonDependency方法，它暴露是的服务接口是IDistributedEventBus以LocalDistributedEventBus

并没有继承EventBus抽象方法

三、Publish方法

Task PublishAsync(Type eventType, object eventData);
Task PublishAsync<TEvent>(TEvent eventData)
            where TEvent : class;

执行ILocalEventHandler和 IDistributedEventHandler方法

查找对应EventType有多少个可执行的注册的IEventHandleFactory，每个EventType有多个List<IEventHandlerFactory> EventHandlerFactories

还需注意其基类也要执行（见下红色），比如执行是EntityCreatedEventData，其下的EntityChangedEventData也应该执行

    protected override IEnumerable<EventTypeWithEventHandlerFactories> GetHandlerFactories(Type eventType)
        {
            var handlerFactoryList = new List<EventTypeWithEventHandlerFactories>();

            foreach (var handlerFactory in HandlerFactories.Where(hf => ShouldTriggerEventForHandler(eventType, hf.Key)))
            {
                handlerFactoryList.Add(new EventTypeWithEventHandlerFactories(handlerFactory.Key, handlerFactory.Value));
            }

            return handlerFactoryList.ToArray();
        }

  private static bool ShouldTriggerEventForHandler(Type targetEventType, Type handlerEventType)
        {
            //Should trigger same type
            if (handlerEventType == targetEventType)
            {
                return true;
            }

            //Should trigger for inherited types
            if (handlerEventType.IsAssignableFrom(targetEventType))
            {
                return true;
            }

            return false;
        }

   await new SynchronizationContextRemover();

            foreach (var handlerFactories in GetHandlerFactories(eventType))
            {
                foreach (var handlerFactory in handlerFactories.EventHandlerFactories)
                {
                    await TriggerHandlerAsync(handlerFactory, handlerFactories.EventType, eventData, exceptions);
                }
            }

 protected virtual async Task TriggerHandlerAsync(IEventHandlerFactory asyncHandlerFactory, Type eventType, object eventData, List<Exception> exceptions)
        {
            using (var eventHandlerWrapper = asyncHandlerFactory.GetHandler())
            {
                try
                {
                    var handlerType = eventHandlerWrapper.EventHandler.GetType();

                    if (ReflectionHelper.IsAssignableToGenericType(handlerType, typeof(ILocalEventHandler<>)))
                    {
                        var method = typeof(ILocalEventHandler<>)
                            .MakeGenericType(eventType)
                            .GetMethod(
                                nameof(ILocalEventHandler<object>.HandleEventAsync),
                                new[] { eventType }
                            );

                        await (Task)method.Invoke(eventHandlerWrapper.EventHandler, new[] { eventData });
                    }
                    else if (ReflectionHelper.IsAssignableToGenericType(handlerType, typeof(IDistributedEventHandler<>)))
                    {
                        var method = typeof(IDistributedEventHandler<>)
                            .MakeGenericType(eventType)
                            .GetMethod(
                                nameof(IDistributedEventHandler<object>.HandleEventAsync),
                                new[] { eventType }
                            );

                        await (Task)method.Invoke(eventHandlerWrapper.EventHandler, new[] { eventData });
                    }
                    else
                    {
                        throw new AbpException("The object instance is not an event handler. Object type: " + handlerType.AssemblyQualifiedName);
                    }
                }
                catch (TargetInvocationException ex)
                {
                    exceptions.Add(ex.InnerException);
                }
                catch (Exception ex)
                {
                    exceptions.Add(ex);
                }
            }
        }

四、RabbbitMQ