# [.NET领域驱动设计实战系列]专题八：DDD案例：网上书店分布式消息队列和分布式缓存的实现
## 一、引言
在上一专题中，商家发货和用户确认收货功能引入了消息队列来实现的，引入消息队列的好处可以保证消息的顺序处理，并且具有良好的可扩展性。但是上一专题消息队列是基于内存中队列对象来实现，这样实现有一个弊端，就是一旦服务重启或出现故障时，此时消息队列中的消息会丢失，并且也记录不了日志。所以就会出现，商家发货成功后，用户并没有收到邮件通知，并且也没有日志让我们发现是否发送了邮件通知。为了解决这个问题，就需要引入一种可恢复的消息队列。目前有很多开源的消息队列都支持可恢复的，例如TibcoEms.net等。然而，微软的MSMQ也是支持这种特性的。并且MSMQ还支持分布式部署，关于MSMQ更多内容可以参考：[http://www.cnblogs.com/zhili/p/MSMQ.html](http://www.cnblogs.com/zhili/p/MSMQ.html)
在本专题中将介绍为网上书店案例引入分布式消息队列和分布式缓存的实现。
## 二、分布式消息队列的实现
MSMQ的实现原理是：消息的发送者把自己想要发送的信息放入一个容器，然后把它保存到一个系统公用空间的消息队列中，本地或异地的消息接收程序再从该队列中取出发给它的消息进行处理。所以，即使服务器突然重启，消息也会存在于系统公用空间的消息队列中，待服务器重新启动后，可以继续接受消息进行处理，从而解决上一专题存在的问题。另外，上一专题的消息队列只能被用在当前服务器中，而MSMQ支持分布式部署，不同机器都可以对MSMQ进行接收消息来处理，此时MSMQ起到一个中间件的作用。
在为网上书店引入分布式消息队列之前，让我们先理一下实现思路：
* 上一专题中把发货事件和收货事件发布到EventBus中，而此时需要用MsmqEventBus来替代EventBus。而MsmqEventBus的实现就很简单了，完全可以参考EventBus来实现，只是此时消息并不是进入Queue对象中，而是通过[MessageQueue](https://msdn.microsoft.com/zh-cn/library/System.Messaging.MessageQueue(v=vs.110).aspx%20)对象发送到系统的消息队列中。
* 而Commit方法即从系统的消息队列中出队来获得消息。再获得消息的处理器时，与上一专题的实现有点不同，因为把事件对象发送到消息队列时，需要先把事件对象先序列化为Message对象再放入消息队列中，而出队的也是消息对象，而不是上一专题中的发货事件对象。所以此时需要把出队的消息对象反序列化为对应的事件对象。
有了上面的实现思路，接下来让我们一起看看MsmqEventBus的具体实现代码吧。
```
public class MsmqEventBus : DisposableObject, IEventBus
{
public void Publish<TMessage>(TMessage message) where TMessage : class, IEvent
{
// 将消息放入Message中Body属性进行序列化发送到消息队列中
var msmqMessage = new Message(message) { Formatter = new XmlMessageFormatter(new[] { message.GetType() }), Label = message.GetType().ToString()};
_messageQueue.Send(msmqMessage);
_committed = false;
}
public void Publish<TMessage>(IEnumerable<TMessage> messages) where TMessage : class, IEvent
{
messages.ToList().ForEach(m =>
{
_messageQueue.Send(m);
_committed = false;
});
}
public void Commit()
{
if (this._useInternalTransaction)
{
using (var transaction = new MessageQueueTransaction())
{
try
{
transaction.Begin();
var message = _messageQueue.Receive();
if (message != null)
{
message.Formatter = new XmlMessageFormatter(new[] { typeof(string) });
var evntType = ConvertStringToType(message.Body.ToString());
var method = _publishMethod.MakeGenericMethod(evntType);
var evnt = Activator.CreateInstance(evntType);
method.Invoke(_aggregator, new object[] { evnt });
transaction.Commit();
}
}
catch
{
transaction.Abort();
throw;
}
}
}
else
{
// 从msmq消息队列中出队，此时获得的对象是消息对象
var message = _messageQueue.Receive();
if (message != null)
{
// 指定反序列化的对象，由于我们之前把对应的事件类型保存在MessageQueue中的Label属性
// 所以此时可以通过Label属性来获得目标序列化类型
message.Formatter = new XmlMessageFormatter(new[] { ConvertStringToType(message.Label) });
// 这样message.Body获得就是对应的事件对象，后面的处理逻辑就和EventBus一样了
var evntType =message.Body.GetType();
var method = _publishMethod.MakeGenericMethod(evntType);
method.Invoke(_aggregator, new object[] { message.Body });
}
}
_committed = true;
}
}
```
结合上面代码的注释和前面实现思路的介绍，相信理解MsmqEventBus应该没什么问题了。接下来，我们需要在配置文件中指定EventBus为MsmqEventBus类，另外**需要在你本地专有队列中创建"OnlineStoreQueue"队列来接受消息**。具体的配置文件修改为：
```
<!--Event Bus-->
<!--<register type="OnlineStore.Events.Bus.IEventBus, OnlineStore.Events" mapTo="OnlineStore.Events.Bus.EventBus, OnlineStore.Events">
<lifetime type="singleton" />
</register>-->
<!--注入MsmqEventBus-->
<register type="OnlineStore.Events.Bus.IEventBus, OnlineStore.Events"
mapTo="OnlineStore.Events.Bus.MsmqEventBus, OnlineStore.Events">
<lifetime type="singleton" />
<constructor>
<param name="path" value=".\Private$\OnlineStoreQueue" />
</constructor>
</register>
</container>
```
到此，分布式消息队列的实现就完成了，具体分布式消息队列的实现效果和上一专题使用EventBus的效果是一样的，这里就不再贴图了，大家可以自行下载源码查看。
## 三、缓存的实现
在实际开发过程中，缓存的实现是必不可少的，对于已经查询过的数据可以直接从缓存中进行读取返回给调用者，利用缓存不但可以加快响应速度，还能减轻数据库服务器的压力。在大型电子商务网站中，缓存的实现更是必不可少的功能。然而缓存的实现也有两种，一种是分布式缓存，另一种本地缓存。在大型网站中，更多实现的是分布式缓存，对于一些少用户的企业系统，可能才会使用到本地缓存。所以在本专题中，将在网上书店案例中对这两种缓存分别进行实现。
## 3.1 本地缓存的实现
首先，我们来介绍本地缓存的实现。由于这里需要实现两种缓存，根据面向接口编程原则，我们自然首先需要定义一个缓存接口，然后这两种具体缓存都需要实现该接口。针对缓存接口，无非是缓存数据的添加，移除，更新等操作，所以缓存接口的定义如下所示：
```
// 缓存接口的定义
public interface ICacheProvider
{
/// <summary>
/// 向缓存中添加一个对象
/// </summary>
/// <param name="key">缓存的键值</param>
/// <param name="valueKey">缓存值的键值</param>
/// <param name="value">缓存的对象</param>
void Add(string key, string valueKey, object value);
void Update(string key, string valueKey, object value);
object Get(string key, string valueKey);
void Remove(string key);
bool Exists(string key);
bool Exists(string key, string valueKey);
}
```
在介绍本地缓存的实现之前，让我们先来思考下本地缓存的实现思路——就是在本地缓存类中定义一个字典对象，添加缓存就是往该字典插入键值对而已，其中key就是缓存数据对应的键值，value就是真正的缓存数据，如果缓存在字典中存在的话，就直接根据键值查找出缓存数据进行返回。
然而网上书店的本地缓存是基于Enterprise Library Caching库来实现的，其实现思路和我之前介绍的思路也是一样的，只不过此时字典对象不需要我们在类中定义，此时直接用Enterprise Library Caching库中定义的就好。有了上面的分析，本地缓存的实现理解起来也就不那么难了，具体本地缓存的实现代码如下所示：
```
// 表示基于Microsoft Patterns & Practices - Enterprise Library Caching Application Block的缓存机制的实现
// 该类简单理解为对Enterprise Library Caching中的CacheManager封装
// 该缓存实现不支持分布式缓存，更多信息参考:
// http://stackoverflow.com/questions/7799664/enterpriselibrary-caching-in-load-balance
public class EntLibCacheProvider : ICacheProvider
{
// 获得CacheManager实例，该实例的注册通过cachingConfiguration进行注册进去的，具体看配置文件
private readonly ICacheManager _cacheManager = CacheFactory.GetCacheManager();
#region ICahceProvider
public void Add(string key, string valueKey, object value)
{
Dictionary<string, object> dict = null;
if (_cacheManager.Contains(key))
{
dict = (Dictionary<string, object>) _cacheManager[key];
dict[valueKey] = value;
}
else
{
dict = new Dictionary<string, object> { { valueKey, value }};
}
_cacheManager.Add(key, dict);
}
public void Update(string key, string valueKey, object value)
{
Add(key, valueKey, value);
}
public object Get(string key, string valueKey)
{
if (!_cacheManager.Contains(key)) return null;
var dict = (Dictionary<string, object>)_cacheManager[key];
if (dict != null && dict.ContainsKey(valueKey))
return dict[valueKey];
else
return null;
}
// 从缓存中移除对象
public void Remove(string key)
{
_cacheManager.Remove(key);
}
// 判断指定的键值的缓存是否存在
public bool Exists(string key)
{
return _cacheManager.Contains(key);
}
// 判断指定的键值和缓存键值的缓存是否存在
public bool Exists(string key, string valueKey)
{
return _cacheManager.Contains(key) &&
((Dictionary<string, object>)_cacheManager[key]).ContainsKey(valueKey);
}
#endregion
}
```
到此，网上书店案例中本地缓存的实现就完成了。由于本地缓存不支持分布式部署，所有的缓存都存在于单独缓存服务器中，然而，针对一些大型网站来说，这样的实现并不适合，因为在大型网站中，需要通过多个缓存服务进行集群，需要使得缓存均匀分布在集群中的缓存服务器中。此时就需要引入分布式缓存的实现。下面让我们具体看看分布式缓存如何在该案例中实现。
## 3.2 分布式缓存的实现
分布式缓存可以通过具体的算法把缓存均匀地分布在集群中缓存服务器中，从而用户请求的不同数据可以路由到对应的缓存服务器中进行添加、更新或获得。分布式缓存的实现有很多种方式，可以利用Memcached和Redis开源库来实现。然而，微软的Windows Azure也提供了分布式缓存的实现，本案例中分布式缓存就是基于Windows Azure的。在对分布式缓存实现之前，需要先下载对应的dll，然后再在项目中进行引用。需要下载的dll已经包含在项目根目录下的libs文件夹下，具体需要下载的程序集截图如下所示：
然后在基础设施层引入这些程序集，之前就可以去实现基于Windows Azure的分布式缓存了。具体的实现代码如下所示：
```
// 分布式缓存，该类是对微软分布式缓存服务的封装
// 在该案例中没用用到该缓存，但是提供在这里让大家明白微软的分布式缓存实现，并不是只有memcached和Redis
// Redis参考：http://www.cnblogs.com/ceecy/p/3279407.html 和 http://blog.csdn.net/suifeng3051/article/details/23739295
// 关于微软分布式缓存更多介绍参考：http://www.cnblogs.com/shanyou/archive/2010/06/29/AppFabricCaching.html
// 和http://www.cnblogs.com/mlj322/archive/2010/04/05/1704624.html
public class AppfabricCacheProvider : ICacheProvider
{
private readonly DataCacheFactory _factory = new DataCacheFactory();
private readonly DataCache _cache;
public AppfabricCacheProvider()
{
this._cache = _factory.GetDefaultCache();
}
#region ICacheProvider Members
public void Add(string key, string valueKey, object value)
{
// DataCache中不包含Contain方法，所有用Get方法来判断对应的key值是否在缓存中存在
var val = (Dictionary<string, object>)_cache.Get(key);
if (val == null)
{
val = new Dictionary<string, object> {{ valueKey, value}};
_cache.Add(key, val);
}
else
{
if (!val.ContainsKey(valueKey))
val.Add(valueKey, value);
else
val[valueKey] = value;
_cache.Put(key, val);
}
}
public void Update(string key, string valueKey, object value)
{
Add(key, valueKey, value);
}
public object Get(string key, string valueKey)
{
return Exists(key, valueKey) ? ((Dictionary<string, object>)_cache.Get(key))[valueKey] : null;
}
public void Remove(string key)
{
_cache.Remove(key);
}
public bool Exists(string key)
{
return _cache.Get(key) != null;
}
public bool Exists(string key, string valueKey)
{
var val = _cache.Get(key);
if (val == null)
return false;
return ((Dictionary<string, object>)val).ContainsKey(valueKey);
}
#endregion
}
```
通过上面的步骤，分布式缓存的实现就完成了。其实，分布式缓存和本地缓存不同之处就在于：分布式缓存支持对应的算法可以把缓存存放在不同的服务器上，而本地缓存只能存在于本地，而不能跨机器分布。所以对于大型网站，分布式缓存才是最好的选择，由于分布式缓存的实现和部署，无疑会增加开发和维护成本，所以对于一些小型系统（指定是单数据库服务器系统），可以考虑使用本地缓存。
在本案例中，由于本人没有Windows Azure环境，所以对于分布式缓存的实现也不能进行测试，所以本案例中使用的还是本地缓存。要使缓存生效，还需要对配置文件进行修改。具体配置文件修改为：
```
<unity xmlns="http://schemas.microsoft.com/practices/2010/unity">
<sectionExtension type="Microsoft.Practices.Unity.InterceptionExtension.Configuration.InterceptionConfigurationExtension, Microsoft.Practices.Unity.Interception.Configuration" />
<container>
<extension type="Interception" />
** <!--Cache Provider-->
<register type="OnlineStore.Infrastructure.Caching.ICacheProvider, OnlineStore.Infrastructure" mapTo="OnlineStore.Infrastructure.Caching.EntLibCacheProvider, OnlineStore.Infrastructure" />**
<!--........-->
</container>
</unity>
```
其实，通过上面的配置之后，缓存还是不能生效的，因为我们一般把缓存放在获得数据方法之前进行调用，在用户对获得数据方法调用之前，首先从缓存中进行查找，如果存在，则直接返回缓存中的数据给调用者就可以了，如果不存在再调用获得数据方法从数据库中读取，读取成功后添加到缓存中再返回给调用者。既然要在方法调用前来查找缓存，从中你是否想到了什么呢？不错，就是面向切面编程，即AOP。所以要让缓存生效，在该案例中还需要支持AOP。至于AOP的支持，我将会在下一专题进行介绍。
## 四、总结
到这里，本专题的内容就结束了，正如前面所说的，在下一专题，我将在网上书店案例中引入对AOP的支持。
本专题所有源码下载地址：[https://github.com/lizhi5753186/OnlineStore_Second/](https://github.com/lizhi5753186/OnlineStore_Second/)
- C# 基础知识系列
- C# 基础知识系列 专题一：深入解析委托——C#中为什么要引入委托
- C# 基础知识系列 专题二：委托的本质论
- C# 基础知识系列 专题三：如何用委托包装多个方法——委托链
- C# 基础知识系列 专题四：事件揭秘
- C# 基础知识系列 专题五：当点击按钮时触发Click事件背后发生的事情
- C# 基础知识系列 专题六:泛型基础篇——为什么引入泛型
- C# 基础知识系列 专题七: 泛型深入理解(一)
- C# 基础知识系列 专题八: 深入理解泛型(二)
- C# 基础知识系列 专题九: 深入理解泛型可变性
- C#基础知识系列 专题十:全面解析可空类型
- C# 基础知识系列 专题十一:匿名方法解析
- C#基础知识系列 专题十二:迭代器
- C#基础知识 专题十三：全面解析对象集合初始化器、匿名类型和隐式类型
- C# 基础知识系列 专题十四：深入理解Lambda表达式
- C# 基础知识系列 专题十五：全面解析扩展方法
- C# 基础知识系列 专题十六：Linq介绍
- C#基础知识系列 专题十七：深入理解动态类型
- 你必须知道的异步编程 C# 5.0 新特性——Async和Await使异步编程更简单
- 全面解析C#中参数传递
- C#基础知识系列 全面解析C#中静态与非静态
- C# 基础知识系列 C#中易混淆的知识点
- C#进阶系列
- C#进阶系列 专题一：深入解析深拷贝和浅拷贝
- C#进阶系列 专题二：你知道Dictionary查找速度为什么快吗？
- C# 开发技巧系列
- C# 开发技巧系列 使用C#操作Word和Excel程序
- C# 开发技巧系列 使用C#操作幻灯片
- C# 开发技巧系列 如何动态设置屏幕分辨率
- C# 开发技巧系列 C#如何实现图片查看器
- C# 开发技巧 如何防止程序多次运行
- C# 开发技巧 实现属于自己的截图工具
- C# 开发技巧 如何使不符合要求的元素等于离它最近的一个元素
- C# 线程处理系列
- C# 线程处理系列 专题一：线程基础
- C# 线程处理系列 专题二：线程池中的工作者线程
- C# 线程处理系列 专题三：线程池中的I/O线程
- C# 线程处理系列 专题四：线程同步
- C# 线程处理系列 专题五：线程同步——事件构造
- C# 线程处理系列 专题六：线程同步——信号量和互斥体
- C# 多线程处理系列专题七——对多线程的补充
- C#网络编程系列
- C# 网络编程系列 专题一：网络协议简介
- C# 网络编程系列 专题二：HTTP协议详解
- C# 网络编程系列 专题三：自定义Web服务器
- C# 网络编程系列 专题四：自定义Web浏览器
- C# 网络编程系列 专题五：TCP编程
- C# 网络编程系列 专题六：UDP编程
- C# 网络编程系列 专题七：UDP编程补充——UDP广播程序的实现
- C# 网络编程系列 专题八：P2P编程
- C# 网络编程系列 专题九：实现类似QQ的即时通信程序
- C# 网络编程系列 专题十：实现简单的邮件收发器
- C# 网络编程系列 专题十一：实现一个基于FTP协议的程序——文件上传下载器
- C# 网络编程系列 专题十二：实现一个简单的FTP服务器
- C# 互操作性入门系列
- C# 互操作性入门系列(一)：C#中互操作性介绍
- C# 互操作性入门系列(二)：使用平台调用调用Win32 函数
- C# 互操作性入门系列(三)：平台调用中的数据封送处理
- C# 互操作性入门系列(四)：在C# 中调用COM组件
- CLR
- 谈谈: String 和StringBuilder区别和选择
- 谈谈：程序集加载和反射
- 利用反射获得委托和事件以及创建委托实例和添加事件处理程序
- 谈谈：.Net中的序列化和反序列化
- C#设计模式
- UML类图符号 各种关系说明以及举例
- C#设计模式(1)——单例模式
- C#设计模式(2)——简单工厂模式
- C#设计模式(3)——工厂方法模式
- C#设计模式(4)——抽象工厂模式
- C#设计模式(5)——建造者模式（Builder Pattern）
- C#设计模式(6)——原型模式（Prototype Pattern）
- C#设计模式(7)——适配器模式（Adapter Pattern）
- C#设计模式(8)——桥接模式（Bridge Pattern）
- C#设计模式(9)——装饰者模式（Decorator Pattern）
- C#设计模式(10)——组合模式（Composite Pattern）
- C#设计模式(11)——外观模式（Facade Pattern）
- C#设计模式(12)——享元模式（Flyweight Pattern）
- C#设计模式(13)——代理模式（Proxy Pattern）
- C#设计模式(14)——模板方法模式（Template Method）
- C#设计模式(15)——命令模式（Command Pattern）
- C#设计模式(16)——迭代器模式（Iterator Pattern）
- C#设计模式(17)——观察者模式（Observer Pattern）
- C#设计模式(18)——中介者模式（Mediator Pattern）
- C#设计模式(19)——状态者模式（State Pattern）
- C#设计模式(20)——策略者模式（Stragety Pattern）
- C#设计模式(21)——责任链模式
- C#设计模式(22)——访问者模式（Vistor Pattern）
- C#设计模式(23)——备忘录模式（Memento Pattern）
- C#设计模式总结
- WPF快速入门系列
- WPF快速入门系列(1)——WPF布局概览
- WPF快速入门系列(2)——深入解析依赖属性
- WPF快速入门系列(3)——深入解析WPF事件机制
- WPF快速入门系列(4)——深入解析WPF绑定
- WPF快速入门系列(5)——深入解析WPF命令
- WPF快速入门系列(6)——WPF资源和样式
- WPF快速入门系列(7)——深入解析WPF模板
- WPF快速入门系列(8)——MVVM快速入门
- WPF快速入门系列(9)——WPF任务管理工具实现
- ASP.NET 开发
- ASP.NET 开发必备知识点(1)：如何让Asp.net网站运行在自定义的Web服务器上
- ASP.NET 开发必备知识点(2)：那些年追过的ASP.NET权限管理
- ASP.NET中实现回调
- 跟我一起学WCF
- 跟我一起学WCF(1)——MSMQ消息队列
- 跟我一起学WCF(2)——利用.NET Remoting技术开发分布式应用
- 跟我一起学WCF(3)——利用Web Services开发分布式应用
- 跟我一起学WCF(3)——利用Web Services开发分布式应用
- 跟我一起学WCF(4)——第一个WCF程序
- 跟我一起学WCF(5)——深入解析服务契约 上篇
- 跟我一起学WCF(6)——深入解析服务契约 下篇
- 跟我一起学WCF(7)——WCF数据契约与序列化详解
- 跟我一起学WCF(8)——WCF中Session、实例管理详解
- 跟我一起学WCF(9)——WCF回调操作的实现
- 跟我一起学WCF(10)——WCF中事务处理
- 跟我一起学WCF(11)——WCF中队列服务详解
- 跟我一起学WCF(12)——WCF中Rest服务入门
- 跟我一起学WCF(13)——WCF系列总结
- .NET领域驱动设计实战系列
- .NET领域驱动设计实战系列 专题一：前期准备之EF CodeFirst
- .NET领域驱动设计实战系列 专题二：结合领域驱动设计的面向服务架构来搭建网上书店
- .NET领域驱动设计实战系列 专题三：前期准备之规约模式(Specification Pattern)
- .NET领域驱动设计实战系列 专题四：前期准备之工作单元模式(Unit Of Work)
- .NET领域驱动设计实战系列 专题五：网上书店规约模式、工作单元模式的引入以及购物车的实现
- .NET领域驱动设计实战系列 专题六：DDD实践案例：网上书店订单功能的实现
- .NET领域驱动设计实战系列 专题七：DDD实践案例：引入事件驱动与中间件机制来实现后台管理功能
- .NET领域驱动设计实战系列 专题八：DDD案例：网上书店分布式消息队列和分布式缓存的实现
- .NET领域驱动设计实战系列 专题九：DDD案例：网上书店AOP和站点地图的实现
- .NET领域驱动设计实战系列 专题十：DDD扩展内容：全面剖析CQRS模式实现
- .NET领域驱动设计实战系列 专题十一：.NET 领域驱动设计实战系列总结