Castle

Castle AOP 系列(一)：对类方法调用的拦截（有源码）

标签： aopAOPCastle对类方法调用的拦截

2012-11-09 16:51 4207人阅读 评论(1) 收藏 举报

 分类：

OO（17） 

版权声明：本文为博主原创文章，未经博主允许不得转载。

目录(?)[+]

Castle的相关网站：

http://www.castleproject.org/
http://www.castleproject.org/projects/dynamicproxy/
http://sourceforge.net/projects/castleproject/

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

所以，朋友们，不需要再去哪里找Castle.DynamicProxy2.dll了。

当然，除非你使用低于2.5的版本。

本文使用的Castle.Core.dll是3.1版本。

由于方法的拦载是动态构建类型，所以我们在拦截类方法时，可以采取用动态构造类的方式，从该类继承一个子类，重载并改写类中需要拦截的方法。

因此，我们不难理解，为什么在Castle 的 AOP中实现对类方法的拦截，都需要该类中的可被拦载的方法都是能够被子类重载的(override)。

CastleAOPTest.Lib.Person的代码

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. namespace CastleAOPTest.Lib
6. {
7. public class Person
8. {
9. public virtual void SayHello()
10. {
11. Console.WriteLine("您好！");
12. }
13. public virtual void SayName(string pHometown)
14. {
15. Console.WriteLine("我是天涯人，我来自：{0}。", pHometown);
16. }
17. public void SayOther()
18. {
19. Console.WriteLine("是的，我是中国人。");
20. }
21. }
22. }

这个类型没什么好说的，只是输出一些字符串而以。

惟一需要注意的是：前两个方法都是虚方法，而“SayOther”不是虚方法，即是说“SayOther”不可以用一般的方式重载。

方法拦载器CastleAOPTest.Lib.AOP.SimpleInterceptor的代码：

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. using CastleAOPTest.Lib;
6. using Castle.DynamicProxy;
7. namespace CastleAOPTest.Lib.AOP
8. {
9. public class SimpleInterceptor : StandardInterceptor
10. {
11. protected override void PreProceed(IInvocation invocation)
12. {
13. Console.WriteLine("调用前的拦截器，方法名是：{0}。", invocation.Method.Name);
14. base.PreProceed(invocation);
15. }
16. protected override void PerformProceed(IInvocation invocation)
17. {
18. Console.WriteLine("拦截的方法返回时调用的拦截器，方法名是：{0}。", invocation.Method.Name);
19. base.PerformProceed(invocation);
20. }
21. protected override void PostProceed(IInvocation invocation)
22. {
23. Console.WriteLine("调用后的拦截器，方法名是：{0}。", invocation.Method.Name);
24. base.PostProceed(invocation);
25. }
26. }
27. }

Castle DynamicProxy提供了一个标准的方法拦截器，在一般的情况下，从这个标准的拦截器继承便可以完成大部分方法拦载上面的需求。

StandardInterceptor中提供了三个可重载的方法：

1.PreProcced，在进入拦截的方法之前调用。

2.PerformProceed，在拦截的方法返回时调用。

3.PostProcced，在拦截的方法运行完成后调用。

如何使用这个写好的拦截器

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. using Castle.DynamicProxy;
6. using CastleAOPTest.Lib;
7. using CastleAOPTest.Lib.AOP;
8. namespace CastleAOPTest.Run
9. {
10. class Program
11. {
12. static void Main(string[] args)
13. {
14. ProxyGenerator generator = new ProxyGenerator();//实例化【代理类生成器】
15. SimpleInterceptor interceptor = new SimpleInterceptor();//实例化【拦截器】
16. //使用【代理类生成器】创建Person对象，而不是使用new关键字来实例化
17. Person person = generator.CreateClassProxy<Person>(interceptor);
18. Console.WriteLine("当前类型:{0},父类型:{1}",person.GetType(), person.GetType().BaseType);
19. Console.WriteLine();
20. person.SayHello();//跟普通调用没有两样吧？
21. Console.WriteLine();
22. person.SayName("福建");//跟普通调用没有两样吧？
23. Console.WriteLine();
24. person.SayOther();//它不是虚方法，无法拦截。待会检测输出情况就知道了。
25. Console.ReadLine();
26. }
27. }
28. }

ProxyGenerator其实是一个动态的类型构造器，它依据Person类型，并加入相应的拦载器构造出了一个新的类型，我们来查看一下运行输出：

根据输出的第一行，我们可以知道，ProxyGenerator构造了一个新的类型，这个类型继承自Person。

由于这个类型的SayOther方法不可以被子类重载，所以这个方法无法被拦截。