.NET中通过代理实现面向方面编程(AOP)

AOP是OOP的延续，Aspect Oriented Programming的缩写，即面向方面编程。AOP是GoF设计模式的延续，设计模式追求的是调用者和被调用者之间的解耦，AOP也是这种目标的一种实现。

让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：国际域名空间、网站空间、营销软件、网站建设、鹿邑网站维护、网站推广。

我说到了在代码中可以利用泛型委托来封装异常处理,这样可以让程序看起来更加清晰,要想完成功能需要调用者调用指定的工厂方法才行,但要想改变某些程序员的编码习惯我想是一件比较困难的事情。有朋友说利用委托来实现异常处理并不算是真正意义上的AOP，因为传统的AOP并不需要客户端做代码结构的变更，最多也就是配置上的问题。但在.net中要想实现AOP，我想最方便的实现机制要属代理机制了，但只要利用代理，在性能上就会造成一定的影响。

如果开发过分布式服务，像remotion,wcf等，消息都是它们通信的重要手段。客户端通过方法调用形式体现的服务访问需要转换成具体的消息，然后经过编码才能利用传输通道发送给服务端，服务执行的结果也只能以消息的形式返回给调用方。

这些分布式服务有一共同特点：都通过代理方法间接的调用服务。服务代理，它自身并不提供服务的实现，只是起到一个中介作用，客户端把服务请求发送给服务代理，服务代理再去调真正的服务，同样服务返回时，也是返回给服务代理，再由服务代理返回给客户端。看到这，我想对于实现AOP的拦截就有点眉目了。在.net中，我们可以写自定义的RealProxy来实现AOP的方法拦截功能。

服务代理通常又分为以下两种：

1：透明代理。客户端在跨任何类型的远程处理边界使用对象时，对对象使用的实际上是透明代理。透明代理使人以为实际对象驻留在客户端空间中。它实现这一点的方法是：使用远程处理基础结构将对其进行的调用转发给真实对象。透明代理本身由 RealProxy 类型的托管运行时类的实例收容。RealProxy 实现从透明代理转发操作所需的部分功能。代理对象继承托管对象（例如垃圾回收、对成员和方法的支持）的关联语义，可以将其进行扩展以形成新类。这样，该代理具有双重性质，一方面，它需要充当与远程对象（透明代理）相同的类的对象；另一方面，它本身是托管对象。

2：真实代理。RealProxy来实现与远程服务进行通信,所以这里就是我们实现AOP的地方。

下图是透明代理与真实代理以及远程对象的调用关系图:

下图是利用自定义的RealProxy实现AOP方法拦截的原理图:

自定义异常代理类:

说明:1>自定义的代理类需要继承RealProxy。

2>从 RealProxy 继承时，必须重写 Invoke方法。

3>下面代码中的LogManage是一个log4net接口，我们可以把异常统一记录到日志中，供日后分析。

   
 
 
 
    
    
  
  
  
  1. ///   
    2.     
  
  
  
  2.     /// Aspect代理，在这个类里面，实现对方法的拦截  
    3.     
  
  
  
  3.     ///   
    4.     
  
  
  
  4.     public class AspectProxyErrorLog : RealProxy      
    5.     
  
  
  
  5.     {  
    6.     
  
  
  
  6.         AspectManagedAttribute attr;  
    7.     
  
  
  
  7.         ///   
    8.     
  
  
  
  8.         /// 默认构造函数  
    9.     
  
  
  
  9.         ///   
    10.     
  
  
  
  10.         public AspectProxyErrorLog() : base()  
    11.     
  
  
  
  11.         {  
    12.     
  
  
  
  12.         }  
    13.     
  
  
  
  13.         ///   
    14.     
  
  
  
  14.         /// 构造函数  
    15.     
  
  
  
  15.         ///   
    16.     
  
  
  
  16.         /// 被代理的类的类型  
    17.     
  
  
  
  17.         public AspectProxyErrorLog(Type myType) : base(myType)  
    18.     
  
  
  
  18.         {  
    19.     
  
  
  
  19.         }  
    20.     
  
  
  
  20.         ///   
    21.     
  
  
  
  21.         /// 构造函数  
    22.     
  
  
  
  22.         ///   
    23.     
  
  
  
  23.         /// 被代理的类的类型  
    24.     
  
  
  
  24.         /// 被代理的对象  
    25.     
  
  
  
  25.         public AspectProxyErrorLog(Type myType,MarshalByRefObject obj) : base(myType)  
    26.     
  
  
  
  26.         {  
    27.     
  
  
  
  27.             target=obj;  
    28.     
  
  
  
  28.         }  
    29.     
  
  
  
  29.         MarshalByRefObject target;  
    30.     
  
  
  
  30.         ILog LogManage;  
    31.     
  
  
  
  31.         ///   
    32.     
  
  
  
  32.         /// 当在派生类中重写时，在当前实例所表示的远程对象上调用在所提供的 IMessage 中指定的方法。  
    33.     
  
  
  
  33.         /// WebsharpAspect在这里执行对方法执行的拦截处理  
    34.     
  
  
  
  34.         ///   
    35.     
  
  
  
  35.         /// IMessage，包含有关方法调用的信息。  
    36.     
  
  
  
  36.         /// 调用的方法所返回的消息，包含返回值和所有 out 或 ref 参数。  
    37.     
  
  
  
  37.         public override IMessage Invoke(IMessage msg)  
    38.     
  
  
  
  38.         {  
    39.     
  
  
  
  39.             IMessage retMsg=null ;  
    40.     
  
  
  
  40.             IMethodCallMessage methodCall = (IMethodCallMessage)msg;  
    41.     
  
  
  
  41.             IMethodReturnMessage methodReturn = null;  
    42.     
  
  
  
  42.  object[] copiedArgs = Array.CreateInstance(typeof(object), methodCall.Args.Length) as object[];  
    43.     
  
  
  
  43.             methodCall.Args.CopyTo(copiedArgs, 0);  
    44.     
  
  
  
  44.             object[] attrs = null;  
    45.     
  
  
  
  45.             CoustomerErrorHandleAttribute ceha = null;  
    46.     
  
  
  
  46.             if (msg is IConstructionCallMessage)  
    47.     
  
  
  
  47.             {  
    48.     
  
  
  
  48.  
    49.     
  
  
  
  49.                 IConstructionCallMessage ccm = (IConstructionCallMessage)msg;  
    50.     
  
  
  
  50.                 RemotingServices.GetRealProxy(target).InitializeServerObject(ccm);  
    51.     
  
  
  
  51.                 ObjRef oRef = RemotingServices.Marshal(target);  
    52.     
  
  
  
  52.                 RemotingServices.Unmarshal(oRef);  
    53.     
  
  
  
  53. retMsg = EnterpriseServicesHelper.CreateConstructionReturnMessage(ccm, (MarshalByRefObject)this.GetTransparentProxy());  
    54.     
  
  
  
  54.  
    55.     
  
  
  
  55.             }  
    56.     
  
  
  
  56.             else 
    57.     
  
  
  
  57.             {  
    58.     
  
  
  
  58.                 IMethodCallMessage mcm = (IMethodCallMessage)msg;                  
    59.     
  
  
  
  59.                 attrs = methodCall.MethodBase.GetCustomAttributes(typeof(CoustomerErrorHandleAttribute), false);                 
    60.     
  
  
  
  60.                 ceha = LogManagerFactory.GetCoustomerErrorHandleAttribute(attrs, methodCall.MethodBase.Name );  
    61.     
  
  
  
  61.                 if (null != ceha)  
    62.     
  
  
  
  62.                 {  
    63.     
  
  
  
  63.                     LogManage = ceha.ILogName;  
    64.     
  
  
  
  64.                 }  
    65.     
  
  
  
  65.                 try 
    66.     
  
  
  
  66.                 {  
    67.     
  
  
  
  67.                     object returnValue = methodCall.MethodBase.Invoke(this.target, copiedArgs);  
    68.     
  
  
  
  68. methodReturn = new ReturnMessage(returnValue, copiedArgs, copiedArgs.Length, methodCall.LogicalCallContext, methodCall);  
    69.     
  
  
  
  69.                       
    70.     
  
  
  
  70.                 }  
    71.     
  
  
  
  71.                 catch (Exception ex)  
    72.     
  
  
  
  72.                 {  
    73.     
  
  
  
  73.                     if (null != ex.InnerException)  
    74.     
  
  
  
  74.                     {  
    75.     
  
  
  
  75.                         methodReturn = new ReturnMessage(ex.InnerException, methodCall);  
    76.     
  
  
  
  76.                     }  
    77.     
  
  
  
  77.                     else 
    78.     
  
  
  
  78.                     {  
    79.     
  
  
  
  79.                         methodReturn = new ReturnMessage(ex, methodCall);  
    80.     
  
  
  
  80.                     }  
    81.     
  
  
  
  81.                 }  
    82.     
  
  
  
  82.                 retMsg = methodReturn;  
    83.     
  
  
  
  83.  
    84.     
  
  
  
  84.             }  
    85.     
  
  
  
  85.             if (null != methodReturn)  
    86.     
  
  
  
  86.             {  
    87.     
  
  
  
  87.                 if (null != methodReturn.Exception )  
    88.     
  
  
  
  88.                 {  
    89.     
  
  
  
  89.                     if (null != this.LogManage )  
    90.     
  
  
  
  90.                     {  
    91.     
  
  
  
  91. this.LogManage.Error(ceha .MethodErrorText  + methodReturn.Exception.ToString());  
    92.     
  
  
  
  92.                     }  
    93.     
  
  
  
  93.  
    94.     
  
  
  
  94.                 }  
    95.     
  
  
  
  95.             }  
    96.     
  
  
  
  96.             return retMsg;  
    97.     
  
  
  
  97.  
    98.     
  
  
  
  98.         }  
    99.     
  
  
  
  99.     } 
    100.

延伸阅读

面向切面编程：Aspect Oriented Programming

AOP是OOP的延续，是（Aspect Oriented Programming）的缩写，意思是面向切面编程。

主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。

主要的意图是：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。

可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。

在Spring中提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。

本文标题：.NET中通过代理实现面向方面编程(AOP)
标题URL：http://www.shufengxianlan.com/qtweb/news42/255092.html

成都网站建设公司_创新互联，为您提供静态网站、网站设计、关键词优化、电子商务、标签优化、营销型网站建设

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站建设知识

同城分类信息

网站建设公司　　 　网络推广外包　　 　眉山联通机房　　 　免备案虚拟主机　　 　网站定制　　 　云主机　　 　成都门窗定制　　 　电商网站建设　　 　小程序开发　　 　成都网站设计　　 　平山县网站建设　　 　成都雪糕加盟　　 　高端品牌网站建设　　 　重庆电信回兴机房　　 　柔性防护网　　 　成都网站建设　　 　重庆机房托管　　 　成都雨棚定制　　 　营销型网站建设　　 　租用服务器