EnterpriseServerBase的AOP－－EsbAOP实现

    EsbAOP是EnterpriseServerBase类库中的轻量级AOP框架，它实现了AOP的主要思想－－对方法调用进行截获，并加入自定义的预处理、后处理。 EsbAOP与其它很多开源的AOP实现有些不同，其不同之处主要在于EsbAOP并没有严格的实现AOP理论的各种设施，但是EsbAOP非常实用，在后续的文章中，大家可以看到EsbAOP是如何运用于实际的系统开发中的。

    理解EsbAOP系列文章需要Remoting和消息方面的知识作为基础，如果你以前没有接触过这些内容，可以阅读《.NET 本质论》的第七章。下面就来开始我们的EsbAOP之旅吧。

    既然AOP的核心思想是对方法调用进行截获，并加入自定义的预处理、后处理，那么我们可以很直观的定义出IAspect（方面）接口。而“特定方面”就是实现了IAspect接口的类，什么是“特定方面”？“特定方面”就是完成某一特定目的的一个Aspect，比如权限方面的特定目的就是进行权限管理。即，一个特定的方面，就代表了一个特定目的的前处理和后处理！

    public   interface  IAspect
    {    
         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的例子。

    [Aspect( typeof (PermissionAspectWrap)  )]        
     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”特性，这个特性的定义如下：

    ///   <summary>
     ///  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代理），这表示前面的例子中可以这样：

    [AspectAttribute( typeof (PermissionAspectWrap) , typeof (ExceptionLoggerAspectWrap))]        
     public   class  Example :ContextBoundObject

    这样就在Example类上运用了两个方面，一个用于权限管理，一个用于异常日志。

    AspectChainProxy代理用于管理所有运用于目标类（如上面的Example类）上的所有方面，使在运行时，CLR能调用所有方面的前处理和后处理，AspectChainProxy实现如下：

    public   class  AspectChainProxy: RealProxy 
    {
         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相关的其它信息。

///   <summary>
     ///  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的定义如下：

    [AttributeUsage(AttributeTargets.Method ,AllowMultiple  =   true  )]
     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应用，比如权限管理、异常日志、异常关闭器......。