AOP原理解析及Castle、Autofac、Unity框架使用

最新推荐文章于 2021-07-22 21:08:18 发布
最新推荐文章于 2021-07-22 21:08:18 发布
阅读量163 收藏
点赞数
文章标签： 游戏
原文链接：http://www.cnblogs.com/chenyishi/p/9676011.html
版权

转自：https://www.cnblogs.com/neverc/p/5241466.html

AOP介绍

面向切面编程（Aspect Oriented Programming,英文缩写为AOP），通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

AOP是OOP的延续，是软件开发中的一个热点.

常用于：

Authentication 

Caching

Lazy loading

Transactions

 

AOP基本原理

普通类

1
2
3
4
5
6
7
8
9
class  Person : MarshalByRefObject
{
     public  string  Say()
     {
         const  string  str =  "Person's say is called" ;
         Console.WriteLine(str);
         return  str;
     }
}

代理类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public  class  Proxy<T> : RealProxy  where  T :  new ()
{
     private  object  _obj;
     public  Proxy( object  obj)
         :  base ( typeof (T))
     {
         _obj = obj;
     }
     public  override  IMessage Invoke(IMessage msg)
     {
         Console.WriteLine( "{0}:Invoke前" , DateTime.Now);
         var  ret = ((IMethodCallMessage)msg).MethodBase.Invoke(_obj,  null );
         Console.WriteLine( "{0}:Invoke后" , DateTime.Now);
         return  new  ReturnMessage(ret,  null , 0,  null ,  null );
     }
}

执行

1
2
3
4
5
6
7
8
9
10
static  void  Main( string [] args)
{
     var  per =  new  Proxy<Person>( new  Person()).GetTransparentProxy()  as  Person;
     if  (per !=  null )
     {
         var  str = per.Say();
         Console.WriteLine( "返回值:"  + str);
     }
     Console.ReadKey();
}

 

AOP框架

AOP有动态代理和静态IL织入.

本节主要介绍动态代理方式,静态可参考PostSharp.

 

Castle Core

原理:本质是创建继承原来类的代理类.重写虚方法实现AOP功能.

 

只需引用:

Install-Package Castle.Core

(在Castle的2.5以上版本，已经将 Castle.DynamicProxy2.dll 里有内容，集成到 Castle.Core.dll 中。)

 

Simple Class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public  abstract  class  Person
{
     public  virtual  void  SayHello()
     {
         Console.WriteLine( "我是{0}方法" ,  "SayHello" );
     }
 
     public  virtual  void  SayName( string  name)
     {
         Console.WriteLine( "我是{0}方法,参数值:{1}" ,  "SayName" , name);
     }
 
     public  abstract  void  AbstactSayOther();
 
     public  void  SayOther()
     {
         Console.WriteLine( "我是{0}方法" ,  "SayOther" );
     }
}

 

interceptor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public  class  SimpleInterceptor : StandardInterceptor
{
     protected  override  void  PreProceed(IInvocation invocation)
     {
         Console.WriteLine( "拦截器调用方法前，方法名是：{0}。" , invocation.Method.Name);
     }
 
     protected  override  void  PerformProceed(IInvocation invocation)
     {
         Console.WriteLine( "拦截器开始调用方法，方法名是：{0}。" , invocation.Method.Name);
         var  attrs = invocation.MethodInvocationTarget.Attributes.HasFlag(MethodAttributes.Abstract); //过滤abstract方法
         if  (!attrs)
         {
             base .PerformProceed(invocation); //此处会调用真正的方法 invocation.Proceed();
         }
     }
 
     protected  override  void  PostProceed(IInvocation invocation)
     {
         Console.WriteLine( "拦截器调用方法后，方法名是：{0}。" , invocation.Method.Name);
     }
}

 

Main

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
static  void  Main( string [] args)
{
     var  generator =  new  ProxyGenerator();        //实例化【代理类生成器】 
     var  interceptor =  new  SimpleInterceptor();   //实例化【拦截器】 
 
     //使用【代理类生成器】创建Person对象，而不是使用new关键字来实例化 
     var  person = generator.CreateClassProxy<Person>(interceptor);
 
     Console.WriteLine( "当前类型:{0},父类型:{1}" , person.GetType(), person.GetType().BaseType);
     Console.WriteLine();
 
     person.SayHello(); //拦截
     Console.WriteLine();
 
     person.SayName( "Never、C" ); //拦截
     Console.WriteLine();
 
     person.SayOther(); //普通方法,无法拦截    
     person.AbstactSayOther(); //抽象方法,可以拦截    
 
     Console.ReadLine();
 
}

 

Castle Windsor

特性式AOP

1
2
3
4
5
6
7
8
9
10
11
12
13
public  interface  IPerson
{
     void  Say();
}
 
[Interceptor( typeof (LogInterceptor))]
public  class  Person : IPerson
{
     public  void  Say()
     {
         Console.WriteLine( "Person's Say Method is called!" );
     }
}

 

1
2
3
4
5
6
7
8
9
public  class  LogInterceptor : IInterceptor
{
     public  void  Intercept(IInvocation invocation)
     {
         Console.WriteLine( "{0}:拦截{1}方法{2}前," , DateTime.Now.ToString( "O" ), invocation.InvocationTarget.GetType().BaseType, invocation.Method.Name);
         invocation.Proceed();
         Console.WriteLine( "{0}:拦截{1}方法{2}后," , DateTime.Now.ToString( "O" ), invocation.InvocationTarget.GetType().BaseType, invocation.Method.Name);
     }
}

 

1
2
3
4
5
6
7
8
9
10
11
static  void  Main( string [] args)
{
     using  ( var  container =  new  WindsorContainer())
     {
         container.Register(Component.For<Person, IPerson>());
         container.Register(Component.For<LogInterceptor, IInterceptor>());
         var  person = container.Resolve<IPerson>();
         person.Say();
     }
     Console.ReadKey();
}


非侵入式AOP

1
2
3
4
5
6
7
8
9
10
11
12
public  interface  IPerson
{
     void  Say();
}
 
public  class  Person : IPerson
{
     public  void  Say()
     {
         Console.WriteLine( "Person's Say Method is called!" );
     }
}

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
internal  static  class  LogInterceptorRegistrar
{
     public  static  void  Initialize(WindsorContainer container)
     {
         container.Kernel.ComponentRegistered += Kernel_ComponentRegistered;
     }
 
     private  static  void  Kernel_ComponentRegistered( string  key, IHandler handler)
     {
         handler.ComponentModel.Interceptors.Add( new  InterceptorReference( typeof (LogInterceptor)));
     }
}
public  class  LogInterceptor : IInterceptor
{
     public  void  Intercept(IInvocation invocation)
     {
         Console.WriteLine( "{0}:拦截{1}方法{2}前," , DateTime.Now.ToString( "O" ), invocation.InvocationTarget.GetType().BaseType, invocation.Method.Name);
         invocation.Proceed();
         Console.WriteLine( "{0}:拦截{1}方法{2}后," , DateTime.Now.ToString( "O" ), invocation.InvocationTarget.GetType().BaseType, invocation.Method.Name);
     }
}

 

1
2
3
4
5
6
7
8
9
10
11
12
static  void  Main( string [] args)
{
     using  ( var  container =  new  WindsorContainer())
     {
         container.Register(Component.For<IInterceptor, LogInterceptor>()); //先注入拦截器
         LogInterceptorRegistrar.Initialize(container);
         container.Register(Component.For<IPerson, Person>());
         var  person = container.Resolve<IPerson>();
         person.Say();
     }
     Console.ReadKey();
}

 

Autofac

Install-Package Autofac.Aop

通过特性标签绑定

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class  LogInterceptor : IInterceptor
  {
      public  void  Intercept(IInvocation invocation)
      {
          Console.WriteLine( "{0}:拦截{1}方法{2}前," , DateTime.Now.ToString( "O" ), invocation.InvocationTarget.GetType().BaseType, invocation.Method.Name);
          invocation.Proceed();
          Console.WriteLine( "{0}:拦截{1}方法{2}后," , DateTime.Now.ToString( "O" ), invocation.InvocationTarget.GetType().BaseType, invocation.Method.Name);
      }
  }
 
  public  interface  IPerson
  {
      void  Say();
  }
 
  [Intercept( typeof (LogInterceptor))]
  public  class  Person : IPerson
  {
      public  void  Say()
      {
          Console.WriteLine( "Person's Say Method is called!" );
      }
  }

 

启用拦截器执行

1
2
3
4
5
6
7
8
9
10
11
static  void  Main( string [] args)
{
     var  builder =  new  ContainerBuilder();
     builder.RegisterType<Person>().As<IPerson>().EnableInterfaceInterceptors();
     builder.RegisterType<LogInterceptor>();
     using  ( var  container = builder.Build())
     {
         container.Resolve<IPerson>().Say();
     }
     Console.ReadLine();
}

 

或采用非侵入性方法(去掉class上的特性仍可以)

1
2
3
4
5
6
7
8
9
10
11
static  void  Main( string [] args)
{
     var  builder =  new  ContainerBuilder();
     builder.RegisterType<Person>().As<IPerson>().EnableInterfaceInterceptors().InterceptedBy( typeof (LogInterceptor));
     builder.RegisterType<LogInterceptor>();
     using  ( var  container = builder.Build())
     {
         container.Resolve<IPerson>().Say();
     }
     Console.ReadLine();
}

　　

 

Unity

Unity默认提供了三种拦截器：TransparentProxyInterceptor、InterfaceInterceptor、VirtualMethodInterceptor。

TransparentProxyInterceptor：代理实现基于.NET Remoting技术，它可拦截对象的所有函数。缺点是被拦截类型必须派生于MarshalByRefObject。

InterfaceInterceptor：只能对一个接口做拦截，好处时只要目标类型实现了指定接口就可以拦截。

VirtualMethodInterceptor：对virtual函数进行拦截。缺点是如果被拦截类型没有virtual函数则无法拦截，这个时候如果类型实现了某个特定接口可以改用

 

Install-Package Unity.Interception

1
2
3
4
5
6
7
8
9
10
11
12
13
public  class  MyHandler : ICallHandler
{
     public  int  Order {  get ;  set ; } //这是ICallHandler的成员，表示执行顺序
     public  IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
     {
         Console.WriteLine( "方法执行前" );
         //这之前插入方法执行前的处理
         var  retvalue = getNext()(input, getNext); //在这里执行方法
         //这之后插入方法执行后的处理
         Console.WriteLine( "方法执行后" );
         return  retvalue;
     }
}

 

1
2
3
4
5
6
7
public  class  MyHandlerAttribute : HandlerAttribute
{
     public  override  ICallHandler CreateHandler(IUnityContainer container)
     {
         return  new  MyHandler(); //返回MyHandler
     }
}

 

1
2
3
4
5
6
7
8
9
10
11
12
13
public  interface  IPerson
{
     void  Say();
}
 
[MyHandler]
public  class  Person : IPerson
{
     public  virtual  void  Say()
     {
         Console.WriteLine( "Person's Say Method is called!" );
     }
}

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
static  void  Main( string [] args)
{
     using  ( var  container =  new  UnityContainer())
     {
         container.AddNewExtension<Interception>();
         //1.TransparentProxyInterceptor
         //container.Configure<Interception>().SetInterceptorFor<IPerson>(new TransparentProxyInterceptor());
 
         //2.InterfaceInterceptor (使用1,2,3均可,这种侵入性最小)
         container.Configure<Interception>().SetInterceptorFor<IPerson>( new  InterfaceInterceptor());
 
         //3.VirtualMethodInterceptor
         //container.Configure<Interception>().SetInterceptorFor<Person>(new VirtualMethodInterceptor());
         container.RegisterType<IPerson, Person>();
         container.Resolve<IPerson>().Say();
     }
     Console.ReadKey();
}

转载于:https://www.cnblogs.com/chenyishi/p/9676011.html

weixin_30653023
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Springaop原理及各种应用场景
01-27
AOP是...实现的关键就在于AOP框架自动创建的AOP代理，AOP代理则可分为静态代理和动态代理两大类，其中静态代理是指使用 AOP框架提供的命令进行编译，从而在编译阶段就可生成AOP代理类，因此也称为编译
IOC容器之Unity与AutoFac
王者南哥
01-07 4035
文章目录一、控制反转是什么（IOC）二、实现策略三、IOC的优缺点四、IOC容器的应用 一、控制反转是什么（IOC） 控制反转（Inversion of Control，英文缩写为 IOC）是框架的重要特征，是一种思想，是一个目标。它是一种全新的设计模式。 应用控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。所以，控...
[Solution] AOP原理解析及Castle、Autofac、Unity框架使用
weixin_34255055的博客
05-08 303
AOP介绍面向切面编程（Aspect Oriented Programming,英文缩写为AOP），通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点.常用于：AuthenticationCachingLazy loadingTransactionsAOP基本原理普通类123456789classPerson :...
IOC控制反转依赖注入框架(Unity、AutoFac)
u013934107的博客
08-09 370
控制反转(Inversion of Control,缩写为IoC)，是面向对象编程中的一种设计原则，可以用来降低代码之间的耦合度。 别外:依赖注入(Dependency Injection,简称DI) IoC常用框架:Unity、Autofac 1.Unity实现案例 注:需要在NuGet包管理器中添加Unity并安装 using IOC_DEMO.DAL; using IOC_DEMO.IDAL; using System; using System.Collections.Generic;.
.NET中三种AOP实现方式：Remoting、Castle、Autofac
逍遥小丿年的博客
08-29 3801
.NET中三种AOP实现方式前言基本概念AOPIOC和DI实现方式动态代理：静态代理：Remoting实现方式Castle实现方式依赖注入的实现添加拦截器完整代码Autofac实现方式依赖注入的实现添加拦截器完整代码后记 前言 一直忙于撸码，难得有时间，研究了下AOP，与大家分享一下，也便于以后查看。(￣▽￣)~* 因为.NET CORE中集成的IOC容器是Castle，日常大家常用的是Autof...
Spring AspectJ AOP框架注解原理解析
09-07
主要介绍了Spring AspectJ AOP框架注解原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
使用SPRINGAOP框架和EJB组件
02-27
Spring托管的组件（POJO）可以与EJB共存，并允许使用AOP方法来处理企业应用程序中的横切方面——从监控和审计、缓存及应用程序级的安全性开始，直到处理特定于应用程序的业务需求。本文将向您介绍Spring的AOP框架在...
在Spring Boot框架中使用AOP的正确姿势
08-27
aop是spring的两大功能模块之一，功能非常强大，为解耦提供了非常优秀的解决方案。下面这篇文章主要给大家介绍了如何在Spring Boot框架中使用AOP的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考下
Autofac（IOC框架）速度比拼
热门推荐
蓝叶菱的专栏
12-24 1万+
原帖：http://www.cnblogs.com/xupng/archive/2011/07/12/2104766.html Autofac为何物？它是.NET世界里现存的几种IOC框架其中之一，传说是速度最快的一个，同类的框架还有用过Castle Windsor、StructureMap、Unity等，如果你用过其中之一，那就好办了*^_^*。什么？你不知道什么是IOC，好吧，这
autofac-unity5
06-26
autofac-unity5 这只是在 Unity 5.0b 中使用Autofac的概念证明 由于与 .Net 4 不兼容，它使用 2.6x 系列的旧版本 注意：工厂委托在 iOS 下不起作用。
.NET依赖注入开发——Autofac篇
Mr.Color
12-15 6223
.NET依赖注入（DI）依赖注入是做什么用的？ 依赖注入又称之为控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。 控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。依赖注入应用比较广泛。引用自百度百
【C#】使用 Castle 实现 AOP，以及 Autofac 集成 Castle
chinaherolts2008的博客
07-22 666
Castle 是 2003 年诞sql教程生于 Apache Avalon 项目，目的java基础教程是为了创建一个IOC 框架。发展到现在已经有四个组件： ORM组件：ActiveRecord IOC组件：Windsor 动态代理组件：DynamicProxy Web MVC组件：MonoRail 本文主python基础教程要介绍 动态代理组件Castle.DynamicProxy 基本用法 Castle.DynamicProxy是通过 Emit 反射动态生成c#教程代理类来实现的，效率相..
多个IoC容器适配器设计及性能测试(Castle.Windsor Autofac Spring.Core)
weixin_30888413的博客
08-10 237
[转]多个IoC容器适配器设计及性能测试和容器选择 1. 采用的IoC容器和版本 Autofac.2.6.3.862 Castle.Windsor.3.1.0 Spring.Core.2.0.0 2. 基础类库：服务类库和组件类库及相关的辅助类库 辅助类库：Demo.Common.dll 服务接口类库：Demo.Lib.dll Oracle组件类库：Demo.L...
Ioc容器Autofac系列（1）-- 初窥
weixin_30294021的博客
11-21 162
前言 第一次接触Autofac是因为CMS系统--Orchard，后来在一个开源爬虫系统--NCrawler中也碰到过，随着深入了解，我越发觉得Ioc容器是Web开发中必不可少的利器。那么，Ioc容器是用来做什么的？用了有什么好处？我相信如果不明白这两点就很难敞开心扉接受Ioc容器。 传统解耦设计的弊端 为方便描述，举个日志的栗子。我简化实现，一个Log类，一个SaveLog方法。如果其他类...
Castle Windsor 文档
极客神殿
12-20 1598
Castle Windsor 文档 Castle Windsor是最好的，可用于.NET的成熟的Inversion of Control容器。 从NuGet获取官方版本：PM> Install-Package Castle.Windsor 或者在构建之前获得预发布软件包 显示我的代码 Windsor的使用非常简单。下面的代码不只是hello world - 这是多少大现实生活应用程序使用
依赖反转Ioc和unity,autofac,castle框架教程及比较
weixin_33894640的博客
08-26 1038
1、依赖倒置的相关概念 http://www.cnblogs.com/fuchongjundream/p/3873073.html IoC模式（依赖、依赖倒置、依赖注入、控制反转） 2、依赖倒置的方式 http://www.cnblogs.com/muzinian/p/3357741.html 于依赖反转原则、控制反转和依赖注入的抽象的初学者指南 3、主流ioc框架 http://w...
spring.net、castle windsor、unity实现aop、ioc的方式和简单区别
weixin_30270889的博客
12-21 310
本文不讲这3大框架的内部实现原理，只是提供了一个demo，分别实现了它们实现注入属性、拦截消息的例子，以写日志为例，写日志方式用异步还是同步ILogType作为写日志方式，注入日志存放地方ILogStore来演示基本的aop、ioc功能。spring.net用的1.3.1，官网http://www.springframework.net/，castle windsor用的2.5.2，官网http:...
在Spring框架中，AOP的实现原理
最新发布
06-09
在Spring框架中，AOP的实现原理是通过使用代理模式来实现的。 当你使用Spring框架创建一个Bean时，如果这个Bean实现了一个接口，Spring就会使用JDK动态代理来创建一个代理对象。这个代理对象实现了这个接口，并且将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值