EnterpriseServerBase的AOP--EsbAOP实现-阿里云开发者社区

开发者社区> zhuweisky> 正文

EnterpriseServerBase的AOP--EsbAOP实现

简介: EsbAOP是EnterpriseServerBase类库中的轻量级AOP框架,它实现了AOP的主要思想--对方法调用进行截获,并加入自定义的预处理、后处理。 EsbAOP与其它很多开源的AOP实现有些不同,其不同之处主要在于EsbAOP并没有严格的实现AOP理论的各种设施,但是EsbAOP非常实用,在后续的文章中,大家可以看到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应用,比如权限管理、异常日志、异常关闭器......。

 

 

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
阿里云服务器怎么设置密码?怎么停机?怎么重启服务器?
如果在创建实例时没有设置密码,或者密码丢失,您可以在控制台上重新设置实例的登录密码。本文仅描述如何在 ECS 管理控制台上修改实例登录密码。
7378 0
阿里云服务器ECS远程登录用户名密码查询方法
阿里云服务器ECS远程连接登录输入用户名和密码,阿里云没有默认密码,如果购买时没设置需要先重置实例密码,Windows用户名是administrator,Linux账号是root,阿小云来详细说下阿里云服务器远程登录连接用户名和密码查询方法
9668 0
阿里云服务器端口号设置
阿里云服务器初级使用者可能面临的问题之一. 使用tomcat或者其他服务器软件设置端口号后,比如 一些不是默认的, mysql的 3306, mssql的1433,有时候打不开网页, 原因是没有在ecs安全组去设置这个端口号. 解决: 点击ecs下网络和安全下的安全组 在弹出的安全组中,如果没有就新建安全组,然后点击配置规则 最后如上图点击添加...或快速创建.   have fun!  将编程看作是一门艺术,而不单单是个技术。
9090 0
使用SSH远程登录阿里云ECS服务器
远程连接服务器以及配置环境
2126 0
阿里云服务器如何登录?阿里云服务器的三种登录方法
购买阿里云ECS云服务器后如何登录?场景不同,阿里云优惠总结大概有三种登录方式: 登录到ECS云服务器控制台 在ECS云服务器控制台用户可以更改密码、更换系.
10688 0
腾讯云服务器 设置ngxin + fastdfs +tomcat 开机自启动
在tomcat中新建一个可以启动的 .sh 脚本文件 /usr/local/tomcat7/bin/ export JAVA_HOME=/usr/local/java/jdk7 export PATH=$JAVA_HOME/bin/:$PATH export CLASSPATH=.
4456 0
阿里云ECS云服务器初始化设置教程方法
阿里云ECS云服务器初始化是指将云服务器系统恢复到最初状态的过程,阿里云的服务器初始化是通过更换系统盘来实现的,是免费的,阿里云百科网分享服务器初始化教程: 服务器初始化教程方法 本文的服务器初始化是指将ECS云服务器系统恢复到最初状态,服务器中的数据也会被清空,所以初始化之前一定要先备份好。
5967 0
+关注
zhuweisky
从事软件开发行业十多年,专注于网络通信技术和网络语音视频技术,擅长系统架构设计、系统性能优化等。zhuweisky.cnblogs.com
300
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
《Nacos架构&原理》
立即下载
《看见新力量:二》电子书
立即下载
云上自动化运维(CloudOps)白皮书
立即下载