基于Mongodb的轻量级领域驱动框架（序）

本文内容纲要：

混园子也有些年头了，从各个大牛那儿学了很多东西。技术这东西和中国的料理一样，其中技巧和经验，代代相传（这不是舌尖上的中国广告）。转身回头一望，几年来自己也积累了一些东西，五花八门涉猎到各种方向，今日开始选一些有价值的开博分享。

首篇分享的是一个基于Mongodb的轻量级领域驱动框架，创作的起源比较杂，首先来自Mongodb，能够直接存储对象。例如：

publicclassPerson { publicPerson(stringname) { Name=name; } publicObjectIdId{get;privateset;} publicstringName{get;privateset;} publicPersonChangeName(stringname) { Name=name; returnthis; } } varperson=newPerson("丁丁"); MongoCollection<Person>persons=database.GetCollection<Person>(typeof(Person).Name); persons.Insert(person); person.ChangeName("丁丁2"); persons.Save(person);

如上所示，有一个Person的类，创建一个Person实例，插入到mongo里，然后执行Person的方法，将改变了属性的Person实例保存到mongo里，这是最简单的Mongo用法。

那么，有没有可能通过某种方式，让对象的实例自身就具有持久化的能力呢？比如像传统仓储的做法那样，在一个聚合根里注入仓储。比如，把Person改造一下，像这样：

publicclassPerson { publicPerson(stringname) { persons=CollectionFactory<Person>.GetCollection(); Name=name; persons.Insert(this); } MongoCollection<Person>persons; publicObjectIdId{get;privateset;} publicstringName{get;privateset;} publicPersonChangeName(stringname) { Name=name; persons.Save(this); returnthis; } }

Person中内置了Mongo集合通过工厂注入的实例，于是Person就可以这么用了：

varperson=newPerson("丁丁"); person.ChangeName("丁丁2");

好，到这儿，一切都很顺利。不过Person是个信息量很少很简单的对象。如果Person是一个结构非常复杂的对象，每次使用persons.Save(this)，是将整个对象更新，非常占用网络流量，这样使用场景就很有限了。有没有什么改进的办法，比如Save(this)变成将有改动的属性更新掉？

Mongo的原生驱动没有提供局部更新的功能，想要实现只有自己写。那么能否监视一个对象的状态改变呢？AOP动态织入好像可以做到。CastleDynamicProxy是很牛逼的东西，可以用它来试试。

首先，改造一下Person，将属性和方法都变成虚的，让它能被Castle所用：

publicclassPerson { publicPerson(stringname) { Name=name; } publicvirtualObjectIdId{get;privateset;} publicvirtualstringName{get;privateset;} publicvirtualPersonChangeName(stringname) { Name=name; returnthis; } }

然后写一个泛型拦截器，在方法执行前对真实对象进行深拷贝，然后在方法执行后将执行前后的对象传入更新委托：

classDataInterceptor<T_AggregateRoot>:StandardInterceptorwhereT_AggregateRoot:class { publicDataInterceptor(Action<T_AggregateRoot,T_AggregateRoot>updateAction,Action<T_AggregateRoot>deleteAction) { this.updateAction=updateAction; this.deleteAction=deleteAction; aggregateRootType=typeof(T_AggregateRoot); } Action<T_AggregateRoot,T_AggregateRoot>updateAction; Action<T_AggregateRoot>deleteAction; T_AggregateRootaggregateRoot1; T_AggregateRootaggregateRoot2; TypeaggregateRootType; protectedoverridevoidPreProceed(IInvocationinvocation) { if(!invocation.Method.Name.StartsWith("get_")&&!invocation.Method.Name.StartsWith("set_")&&!invocation.Method.Name.Equals("Abadon")) { try { aggregateRoot1=NClone.Clone.ObjectGraph((((T_AggregateRoot)invocation.InvocationTarget))); } catch(Exceptionexception) { Logger.Exception(exception); } } } protectedoverridevoidPostProceed(IInvocationinvocation) { if(!invocation.Method.Name.StartsWith("get_")&&!invocation.Method.Name.StartsWith("set_")) { aggregateRoot2=(T_AggregateRoot)invocation.InvocationTarget; if(invocation.Method.Name.Equals("Abadon")) { deleteAction.Invoke(aggregateRoot2); } else { updateAction.Invoke(aggregateRoot1,aggregateRoot2); } } } }

通过对象深比较得到差异，编译成Mongo更新语句执行更新：

///<summary> ///局部更新 ///</summary> ///<remarks> ///比较对象，找到不一致的地方，进行 ///</remarks> ///<paramname="aggregateRoot1"></param> ///<paramname="aggregateRoot2"></param> ///<returns></returns> internalvoidUpdate(T_AggregateRootaggregateRoot1,T_AggregateRootaggregateRoot2) { if(aggregateRoot1==null) return; CompareObjectscompareObjs=newCompareObjects(); compareObjs.MaxDifferences=int.MaxValue; //比较私有属性 compareObjs.ComparePrivateProperties=true; compareObjs.Compare(aggregateRoot1,aggregateRoot2); varid=BsonValue.Create(((dynamic)aggregateRoot2).Id); IMongoQueryquery=Query.EQ("_id",id); IMongoUpdateupdates; List<IMongoUpdate>allChanges=newList<IMongoUpdate>(); List<IMongoUpdate>allChangesForDelete=newList<IMongoUpdate>(); //分别对null值，集合元素的增删改，进行不同的处理 foreach(DifferencedifincompareObjs.Differences) { stringfieldName=dif.PropertyName.Substring(1); fieldName=fieldName.Replace("[",".").Replace("]",""); BsonValuefieldValue=null; //处理数组删除的情况 if(dif.IsDelete) { IMongoUpdateupdate2=MongoDB.Driver.Builders.Update.PopLast(fieldName); allChangesForDelete.Add(update2); continue; } //处理null值 if(dif.Object2.Target==null&&dif.Object2Value==null) { try { dynamicnullValueLogContent=newExpandoObject(); nullValueLogContent.AggregateRoot1=aggregateRoot1; nullValueLogContent.AggregateRoot2=aggregateRoot2; nullValueLogContent.Differences=compareObjs.Differences; } catch{} fieldValue=BsonNull.Value; IMongoUpdateupdate2=MongoDB.Driver.Builders.Update.Set(fieldName,fieldValue); allChanges.Add(update2); continue; } //原始类型或字符串直接使用对象 //对象类型则转为.ToBsonDocument(); if(dif.Object2.Target.GetType().IsPrimitive||dif.Object2.Target.GetType().Equals(typeof(string))|| dif.Object2.Target.GetType().IsEnum) { fieldValue=dif.Object2.Target==null?BsonValue.Create(dif.OriginObject2):BsonValue.Create(dif.Object2.Target); } else { //更新整个集合类 if(dif.Object2.Target.GetType().GetInterface(typeof(IDictionary).FullName)!=null ||dif.Object2.Target.GetType().GetInterface(typeof(IList).FullName)!=null) { fieldValue=BsonValue.Create(dif.OriginObject2); } elseif(dif.Object2.Target.GetType()==typeof(DateTime)) { fieldValue=dif.Object2.Target==null?BsonDateTime.Create(dif.OriginObject2):BsonDateTime.Create(dif.Object2.Target); } else { //处理普通的class类型 //由于这里OriginObject2一定不会被释放(强引用)，所以使用dif.Object2.Target或者dif.OriginObject2都可以 fieldValue=BsonValue.Create(dif.Object2.Target.ToBsonDocument()); } } IMongoUpdateupdate=MongoDB.Driver.Builders.Update.Set(fieldName,fieldValue); allChanges.Add(update); } //有更新才处理 if(allChanges.Count>0) { updates=MongoDB.Driver.Builders.Update.Combine(allChanges); collection.Update(query,updates); } foreach(IMongoUpdateupinallChangesForDelete) { collection.Update(query,up); } }

写一个类似Collection的泛型类，提供集合类操作，在操作末尾对对象的实例动态织入：

///<summary> ///创建代理 ///</summary> ///<paramname="aggregateRoot"></param> ///<returns></returns> T_AggregateRootCreateProxy(T_AggregateRootaggregateRoot) { varaggregateRootType=aggregateRoot.GetType(); varconstructor=aggregateRootType.GetConstructors().OrderBy(c=>c.GetParameters().Length).First(); varparameters=constructor.GetParameters().Select(p=>default(object)).ToArray(); return(T_AggregateRoot)proxyGenerator.CreateClassProxyWithTarget(aggregateRootType,aggregateRoot,parameters,newDataInterceptor<T_AggregateRoot>(this.Update,this.Remove)); }

最终，这一系列思路的产物就是一个聚合跟集合：

///<summary> ///聚合根泛型集合类 ///</summary> publicclassAggregateRootCollection<T_AggregateRoot>whereT_AggregateRoot:class { ... }

然后用法类似这样：

varpersons=newAggregateRootCollection<Person>("TestDb"); varpersonProxy=persons.Add(newPerson("丁丁")); personProxy.ChangeName("丁丁2");

第一行实例化聚合跟集合，第二行用Add方法对新的实例进行动态织入返回代理，第三行就是神奇的执行方法后，状态的变化就立刻持久化了。

以上是这个轻量级领域驱动框架的大致介绍，目前还未发布到Github和nuget上，后续会一篇篇的更新它的实现原理。它适用于一些事务性不强的工程，让开发人员所有关注点就在业务逻辑上，告别持久化。

本文内容总结：

原文链接：https://www.cnblogs.com/royding/p/3711751.html