nopCommerce 3.9 大波浪系列 之 事件机制（生产者、消费者）

一.nop事件机制简介

nop事件机制使用到“生产者/消费者”模式。生产者只负责发布事件，并不需要关心谁来处理，相反消费者只用来处理事件。那生产者和消费者是如何进行关联的呢？nop实现是非常简单的，通过泛型来定义一个事件类，如果生产者和消费者都使用同一个事件类，那么就关联到一起了称之为订阅。负责实现事件机制的部分称之为缓冲区，缓冲区的作用是通过解耦的方式实现消息机制。生产者和消费者是一对多的关系。下图简单介绍下生产者消费者关系。

using System;
using System.Linq;
using Nop.Core.Infrastructure;
using Nop.Core.Plugins;
using Nop.Services.Logging;

namespace Nop.Services.Events
{
/// <summary>
/// Evnt publisher
/// </summary>
public class EventPublisher : IEventPublisher
{
private readonly ISubscriptionService _subscriptionService;

/// <summary>
/// Ctor
/// </summary>
/// <param name="subscriptionService"></param>
public EventPublisher(ISubscriptionService subscriptionService)
{
_subscriptionService = subscriptionService;
}

/// <summary>
/// Publish to cunsumer
/// </summary>
/// <typeparam name="T">Type</typeparam>
/// <param name="x">Event consumer</param>
/// <param name="eventMessage">Event message</param>
protected virtual void PublishToConsumer<T>(IConsumer<T> x, T eventMessage)
{
//Ignore not installed plugins
var plugin = FindPlugin(x.GetType());
if (plugin != null && !plugin.Installed)
return;

try
{
//消费者处理方法
x.HandleEvent(eventMessage);
}
catch (Exception exc)
{
//log error
var logger = EngineContext.Current.Resolve<ILogger>();
//we put in to nested try-catch to prevent possible cyclic (if some error occurs)
try
{
logger.Error(exc.Message, exc);
}
catch (Exception)
{
//do nothing
}
}
}

/// <summary>
/// Find a plugin descriptor by some type which is located into its assembly
/// </summary>
/// <param name="providerType">Provider type</param>
/// <returns>Plugin descriptor</returns>
protected virtual PluginDescriptor FindPlugin(Type providerType)
{
if (providerType == null)
throw new ArgumentNullException("providerType");

if (PluginManager.ReferencedPlugins == null)
return null;

foreach (var plugin in PluginManager.ReferencedPlugins)
{
if (plugin.ReferencedAssembly == null)
continue;

if (plugin.ReferencedAssembly.FullName == providerType.Assembly.FullName)
return plugin;
}

return null;
}

/// <summary>
/// 发送事件
/// </summary>
/// <typeparam name="T">Type</typeparam>
/// <param name="eventMessage">Event message</param>
public virtual void Publish<T>(T eventMessage)
{
var subscriptions = _subscriptionService.GetSubscriptions<T>();//获取订阅消费者
subscriptions.ToList().ForEach(x => PublishToConsumer(x, eventMessage));
}

}
}

EventPublisher

using System.Collections.Generic;
using Nop.Core.Infrastructure;

namespace Nop.Services.Events
{
/// <summary>
/// 事件订阅服务
/// </summary>
public class SubscriptionService : ISubscriptionService
{
/// <summary>
/// 获取事件订阅
/// </summary>
/// <typeparam name="T">Type</typeparam>
/// <returns>Event consumers</returns>
public IList<IConsumer<T>> GetSubscriptions<T>()
{
return EngineContext.Current.ResolveAll<IConsumer<T>>();
}
}
}

二.消费者IConsermer<T>注册

//注册事件消费者
var consumers = typeFinder.FindClassesOfType(typeof(IConsumer<>)).ToList();
foreach (var consumer in consumers)
{
builder.RegisterType(consumer)
.As(consumer.FindInterfaces((type, criteria) =>
{
var isMatch = type.IsGenericType && ((Type)criteria).IsAssignableFrom(type.GetGenericTypeDefinition());
return isMatch;
}, typeof(IConsumer<>)))
.InstancePerLifetimeScope();
}

三.创建消费者

using System;
using Nop.Core;
using Nop.Core.Domain.Orders;
using Nop.Core.Plugins;
using Nop.Services.Events;
using Nop.Services.Orders;

namespace Nop.Plugin.SMS
{
public class OrderPaidSMSEventConsumer : IConsumer<OrderPaidEvent>
{

private readonly IOrderService _orderService;

public OrderPaidSMSEventConsumer(
IOrderService orderService,
IStoreContext storeContext)
{
this._orderService = orderService;
this._storeContext = storeContext;
}

/// <summary>
/// 事件处理.
/// </summary>
/// <param name="eventMessage">The event message.</param>
public void HandleEvent(OrderPaidEvent  eventMessage)
{

var order = eventMessage.Order;//获取订单

//发送短息通知代码
//....................
}
}
}

using System;
using Nop.Core;
using Nop.Core.Domain.Orders;
using Nop.Core.Plugins;
using Nop.Services.Events;
using Nop.Services.Orders;

namespace Nop.Plugin.Email
{
public class OrderPaidEmailEventConsumer : IConsumer<OrderPaidEvent>
{

private readonly IOrderService _orderService;
private readonly IStoreContext _storeContext;

public OrderPaidEmailEventConsumer(
IOrderService orderService,
IStoreContext storeContext)
{

this._orderService = orderService;
this._storeContext = storeContext;
}

/// <summary>
/// 邮件处理
/// </summary>
/// <param name="eventMessage">The event message.</param>
public void HandleEvent(OrderPaidEvent eventMessage)
{

var order = eventMessage.Order;

//发送邮件通知客户
//............................
}
}
}

四.生产消息

五.nop中常用的事件整理

Nop.Web.Infrastructure.Cache.ModelCacheEventConsumer:前台模型相关

Nop.Admin.Infrastructure.Cache.ModelCacheEventConsumer：后台模型相关

Nop.Services.Discounts.Cache.DiscountEventConsumer：折扣相关

Nop.Services.Catalog.Cache.PriceCacheEventConsumer：价格相关

Nop.Services.Customers.Cache.CustomerCacheEventConsumer：密码修改

六.总结

文中有错误的理解和不正确的观点，请留言，一起交流共同进步。

本文地址：http://www.cnblogs.com/yaoshangjin/p/7234522.html

本文为大波浪原创、转载请注明出处。