EnterpriseServerBase的AOP－－EsbAOP实现
EsbAOP是EnterpriseServerBase类库中的轻量级AOP框架，它实现了AOP的主要思想－－对方法调用进行截获，并加入自定义的预处理、后处理。 EsbAOP与其它很多开源的AOP实现有些不同，其不同之处主要在于EsbAOP并没有严格的实现AOP理论的各种设施，但是EsbAOP非常实用，在后续的文章中，大家可以看到EsbAOP是如何运用于实际的系统开发中的。
理解EsbAOP系列文章需要Remoting和消息方面的知识作为基础，如果你以前没有接触过这些内容，可以阅读《.NET 本质论》的第七章。下面就来开始我们的EsbAOP之旅吧。
既然AOP的核心思想是对方法调用进行截获，并加入自定义的预处理、后处理，那么我们可以很直观的定义出IAspect（方面）接口。而“特定方面”就是实现了IAspect接口的类，什么是“特定方面”？“特定方面”就是完成某一特定目的的一个Aspect，比如权限方面的特定目的就是进行权限管理。即，一个特定的方面，就代表了一个特定目的的前处理和后处理！
{
void PreProcess(IMethodCallMessage requestMsg ,object aspectClassArgument ,object aspectMethodArgument) ;
void PostProcess(IMethodCallMessage requestMsg ,ref IMethodReturnMessage respond ,object aspectClassArgument ,object aspectMethodArgument) ;
}
其中参数requestMsg表示方法调用的请求消息，而respond表示方法调用的结果。注意，如果目标方法在运行的过程中抛出了一个异常，那么该异常也表现为一个IMethodReturnMessage消息。注意，respond参数加上了ref关键字，表示EsbAOP不仅可以截获方法调用，而且还能改变方法运行的结果，这是多么神奇的功能啊！
另外还有两个参数aspectClassArgument和aspectMethodArgument，为了更方便地说明它们的作用，非得举个例子不可，如下一个应用权限Aspect的例子。
public class Example :ContextBoundObject
{
[AspectSwitcher(typeof(PermissionAspectWrap) ,true ,Permission.Super)]
public void SayHello(string name)
{
Console.WriteLine("Hello ," + name) ;
}
}
方法上有个AspectSwitcher特性，它的第三个参数就是aspectMethodArgument。在本例中，这个参数规定了调用SayHello方法所需要的权限是Super。而aspectClassArgument参数位于PermissionAspectWrap的包装之中，它主要用于特定的方面（本例中是PermissionAspect）在执行预处理/后处理时所需要的设施，比如本例中，PermissionAspect就需要通过aspectClassArgument传入一个IPermissionVerifier引用，这个IPermissionVerifier用于对权限是否满足进行判断。
看了这段描述，不知道你对这两个参数有点了解了没有，不是太明白也没关系，对它们的认识后面会慢慢清晰起来的。
上面Example类上用的“Aspect”特性，这个特性的定义如下：
/// AspectAttribute 把被修饰类的实例委托给代理AspectChainProxy ，如此可以截获被修饰类的方法调用
/// </summary>
[AttributeUsage(AttributeTargets.Class ,AllowMultiple = false)]
public class AspectAttribute : ProxyAttribute
{
private Type[] theAspectProcessorWrapTypes = null ;
public AspectAttribute(params Type[] wrapTypes)
{
this.theAspectProcessorWrapTypes = wrapTypes ;
}
#region CreateInstance
/// <summary>
/// 获得目标对象的自定义透明代理，该方法由系统调用
/// </summary>
public override MarshalByRefObject CreateInstance(Type serverType)//serverType是被AopProxyAttribute修饰的类
{
//未初始化的实例的默认透明代理
MarshalByRefObject target = base.CreateInstance (serverType); //得到未初始化的实例（ctor未执行）
object[] args = {target ,serverType} ;
//得到自定义的真实代理
RealProxy rp = new AspectChainProxy(target ,serverType ,this.theAspectProcessorWrapTypes) ;//new AopControlProxy(target ,serverType) ;
return (MarshalByRefObject)rp.GetTransparentProxy() ;
}
#endregion
}
可以看到，该特性的主要任务是把目标实例委托给AspectChainProxy代理，使截获方法调用得以顺利切入！AspectAttribute的构造参数由params修饰，表示其可接受多个参数，每一个参数对应这一个特定目的的方面（最终，AspectAttribute把这些参数传给了AspectChainProxy代理），这表示前面的例子中可以这样：
public class Example :ContextBoundObject
这样就在Example类上运用了两个方面，一个用于权限管理，一个用于异常日志。
AspectChainProxy代理用于管理所有运用于目标类（如上面的Example类）上的所有方面，使在运行时，CLR能调用所有方面的前处理和后处理，AspectChainProxy实现如下：
{
private MarshalByRefObject target = null;
private Type[] theAspectProcessorWrapTypes = null;
private ArrayList aspectCallerList = new ArrayList() ;//集合中为AspectCaller实例
public AspectChainProxy(MarshalByRefObject target ,Type serverType ,params Type[] aopProcessorWrapTypes): base(serverType)
{
this.target = target;
this.theAspectProcessorWrapTypes = aopProcessorWrapTypes ;
}
#region Invoke
public override IMessage Invoke(IMessage msg)
{
IMethodCallMessage call = (IMethodCallMessage)msg ;
this.FillAspectCallerList(call) ;
//如果触发的是构造函数，此时target的构建还未开始
IConstructionCallMessage ctor = call as IConstructionCallMessage ;
if(ctor != null)
{
//获取最底层的默认真实代理
RealProxy default_proxy = RemotingServices.GetRealProxy(this.target) ;
default_proxy.InitializeServerObject(ctor) ;
MarshalByRefObject tp = (MarshalByRefObject)this.GetTransparentProxy() ; //自定义的透明代理 this
return EnterpriseServicesHelper.CreateConstructionReturnMessage(ctor,tp);
}
this.PreProcess(call) ;
IMethodReturnMessage result_msg = RemotingServices.ExecuteMessage(this.target ,call) ; //将消息转化为堆栈，并执行目标方法，方法完成后，再将堆栈转化为消息
this.PostProcess(call ,ref result_msg) ;
return result_msg ;
}
#endregion
#region FillAspectCallerList
private void FillAspectCallerList(IMethodCallMessage call)
{
this.aspectCallerList.Clear() ;
if(this.theAspectProcessorWrapTypes == null)
{
return ;
}
//显式启动了方面的WrapType
ArrayList overtWrapTypeList = new ArrayList() ;
//查询目标方法是否 "显式" 启用AOP的MethodAopSwitcherAttribute
foreach(Attribute attr in call.MethodBase.GetCustomAttributes(false))
{
AspectSwitcherAttribute aspectSwitcher = attr as AspectSwitcherAttribute ;
if(aspectSwitcher == null)
{
continue ;
}
if(aspectSwitcher.DestAspectProcessorWrapType == null)
{
continue ;
}
overtWrapTypeList.Add(aspectSwitcher.DestAspectProcessorWrapType) ;
if (! aspectSwitcher.UseAspect)
{
continue ;
}
IAspectProcessorWrap processorWrap = this.GetAspectProcessorWrap(aspectSwitcher.DestAspectProcessorWrapType);
if(processorWrap == null)
{
continue ;
}
AspectCaller caller = new AspectCaller() ;
caller.AspectMethodArgument = aspectSwitcher.AopArgument ;
caller.CurProcessorWrap = processorWrap ;
this.aspectCallerList.Add(caller) ;
}
//非显式启用的方面
foreach(Type wrapType in this.theAspectProcessorWrapTypes)
{
bool passIt = this.WrapTypeIsInOvertWrapTypeList(wrapType ,overtWrapTypeList) ;
if(! passIt)
{
IAspectProcessorWrap processorWrap = (IAspectProcessorWrap)Activator.CreateInstance(wrapType) ;
if(processorWrap.DefaultAspectSwitcherState == AspectSwitcherState.On)
{
AspectCaller caller = new AspectCaller() ;
caller.CurProcessorWrap = processorWrap ;
this.aspectCallerList.Add(caller) ;
}
}
}
}
private bool WrapTypeIsInOvertWrapTypeList(Type wrapType ,ArrayList overtWrapTypeList)
{
foreach(Type tempWrapType in overtWrapTypeList)
{
if(wrapType == tempWrapType)
{
return true ;
}
}
return false ;
}
#endregion
#region GetAspectProcessorWrap
private IAspectProcessorWrap GetAspectProcessorWrap(Type aspectProcesserWrapType)
{
foreach(Type wrapType in this.theAspectProcessorWrapTypes)
{
if(wrapType == aspectProcesserWrapType)
{
IAspectProcessorWrap wrap = (IAspectProcessorWrap)Activator.CreateInstance(wrapType) ;
return wrap ;
}
}
return null ;
}
#endregion
#region PreProcess ,PostProcess
private void PreProcess(IMethodCallMessage requestMsg)
{
foreach(AspectCaller caller in this.aspectCallerList)
{
IAspect aspectProcessor = (IAspect)Activator.CreateInstance(caller.CurProcessorWrap.AspectProcessorType) ;
if(aspectProcessor != null)
{
aspectProcessor.PreProcess(requestMsg ,caller.CurProcessorWrap.AspectClassArgument ,caller.AspectMethodArgument) ;
}
}
}
private void PostProcess(IMethodCallMessage requestMsg, ref IMethodReturnMessage respond)
{
foreach(AspectCaller caller in this.aspectCallerList)
{
IAspect aspectProcessor = (IAspect)Activator.CreateInstance(caller.CurProcessorWrap.AspectProcessorType) ;
if(aspectProcessor != null)
{
aspectProcessor.PostProcess(requestMsg ,ref respond ,caller.CurProcessorWrap.AspectClassArgument ,caller.AspectMethodArgument) ;
}
}
}
#endregion
}
/// <summary>
/// AspectCaller 针对某一特定的方法，实施的一次Aspect调用
/// </summary>
public class AspectCaller
{
public IAspectProcessorWrap CurProcessorWrap = null ;
public object AspectMethodArgument = null ;
}
AspectChainProxy的第四个构造参数正是从AspectAttribute传递过来的，这个参数包含了运用于目标类的所有特定方面的相关信息。AspectChainProxy的核心方法是Invoke方法，该方法由CLR在进入截获阶段时调用。Invoke方法的流程一目了然。
上文已经有几个地方已经涉及了IAspectProcessorWrap 接口了，正如其名，它是一个包装，包装中的主要内容是一个Asepect，以及提供与该Aspect相关的其它信息。
/// IAspectProcessorWrap 对某一Aspect类型和对应的AspectClassArgument进行封装
/// </summary>
public interface IAspectProcessorWrap
{
Type AspectProcessorType{get ;} //返回的是IAspect的实现
object AspectClassArgument{get ;}
/// <summary>
/// 当一个方法没有被某个方面的AspectSwitcherAttribute修饰时，是否启用该方面
/// </summary>
AspectSwitcherState DefaultAspectSwitcherState{get ;}
}
注释已经很好的解释了IAspectProcessorWrap 接口的方方面面，到这里，你也许发现了，AspectAttribute的构造参数就是实现了IAspectProcessorWrap 的类型。一个特定目的方面（如PermissionAspect）就对应着一个包装（PermissionAspectWrap）。
关于这个轻量级的AOP实现，还有一个基础设施没有介绍，那就是AspectSwitcherAttribute，这也是一个特性，主要用于修饰方法。它的目的有两个：
（1）决定被修饰方法针对某特定方面是否启用截获。比如当Example类上使用权限Aspect时，对每个方法的调用都将进行权限判断，然而有些方法调用可能是不需要权限判断的，这种一锅端的做法存在很多AOP实现中，而EsbAOP通过AspectSwitcherAttribute很好的解决了这个问题。并且，IAspectProcessorWrap 接口的DefaultAspectSwitcherState属性更是对此支持的增强。
（2）传递前述的aspectMethodArgument给预处理和后处理。这个前面已经见过了。
AspectSwitcherAttribute的定义如下：
public class AspectSwitcherAttribute : Attribute
{
private bool useAspect = false ;
private object theAopArgument = null ;
private Type destAspectProcessorWrapType = null ;
public AspectSwitcherAttribute(Type destAspectWrapType ,bool useAop)
{
this.destAspectProcessorWrapType = destAspectWrapType ;
this.useAspect = useAop ;
}
public AspectSwitcherAttribute(Type destAspectWrapType ,bool useAop ,object aopArg)
{
this.useAspect = useAop ;
this.theAopArgument = aopArg ;
this.destAspectProcessorWrapType = destAspectWrapType ;
}
public bool UseAspect
{
get
{
return this.useAspect ;
}
}
public object AopArgument
{
get
{
return this.theAopArgument ;
}
}
public Type DestAspectProcessorWrapType
{
get
{
return this.destAspectProcessorWrapType ;
}
}
}
public enum AspectSwitcherState
{
On ,Off
}
EsbAOP的所有实现就介绍完了，如果讲述有不清楚的地方，请留言，我会根据反馈进行修改。在后续的文章中，将在EsbAOP的基础上开展AOP应用，比如权限管理、异常日志、异常关闭器......。
