Spring.Net AOP的通知类型及通知链
首先介绍AOP通知的概念。
通知（Advice）：AOP框架在某个连接点（方法）中所采取的行为。在Spring.Net的通知类型分为环绕通知、前置通知、后置通知、异常通知。这四中通知类型以及这几通知综合运用形成的通知链。
关于各种通知类型我实现的编程方式、配置方式两种给大家介绍。这一节主要说说上述通知类型中的后三种通知，前一种通知在上一节中已经做了说明，所以不作为本节的重点了，但是几种通知的应用大致是一样的。
本节重点分如下两部分：
一、AOP的四种通知类型。
二、通知链的应用
首先还是介绍一下开发环境以及软件版本：
VS版本：VS2008 SP1、Spring版本：1.3.0。
一、AOP四种通知类型介绍
1、前置通知。我理解的前置通知是在目标对象连接点执行前的通知。
编程方式实现。这种方式主要应用了程序集Spring.Net中Spring.Aop.Framework命名空间下的ProxyFactory（代理工厂）类和Spring.Aop命名控件下的IMethodBeforeAdvice接口。
目标对象的代码如下：
代码
1 public interface ICommand
2 {
3 void Execute();
4 }
5
6 class ServiceCommand:ICommand
7 {
8 public void Execute()
9 {
10 Console.WriteLine("ServiceCommand execute");
11 }
12 }
通知的实现代码：
代码
1 class ConsoleLoggingBeforeAdvice:IMethodBeforeAdvice
2 {
3 public void Before(MethodInfo method, object[] args, object target)
4 {
5 Console.WriteLine("Method name is :{0}", method.Name);
6 if (args != null)
7 {
8 if (args.Length > 0)
9 {
10 for (int i = 0; i < args.Length; i++)
11 {
12 Console.WriteLine(" the {0} position argments in args is {1}", i, args[i]);
13 }
14 }
15 }
16 else
17 {
18 Console.WriteLine("args is null");
19 }
20 Console.WriteLine("the type target is {0}",target.GetType().ToString());
21 }
22 }
实现代码如下：
代码
1 ProxyFactory factory = new ProxyFactory(new ServiceCommand());
2 factory.AddAdvice(new ConsoleLoggingBeforeAdvice());
3 ICommand command = (ICommand)factory.GetProxy();
4 command.Execute();
运行结果图如下：
配置方式实现。配置代码如下：
代码
1 <objects xmlns="http://www.springframework.net" xmlns:aop="http://www.springframework.net/aop">
2 <object id="myServiceObject" type="Spring.Aop.Framework.ProxyFactoryObject">
3 <property name="Target">
4 <object type="SpringBeforeAdvice.ServiceCommand" singleton="0"></object>
5 </property>
6 <property name="InterceptorNames">
7 <list>
8 <value>beforeAdvice</value>
9 </list>
10 </property>
11 </object>
12 <object id="beforeAdvice" type="SpringBeforeAdvice.ConsoleLoggingBeforeAdvice"></object>
13 </objects>
实现代码如下：
代码
1 IApplicationContext context = ContextRegistry.GetContext();
2 ICommand command2 = (ICommand)context["myServiceObject"];
3 command2.Execute();
4 IDictionary dic = context.GetObjectsOfType(typeof(ICommand));
5 foreach (DictionaryEntry item in dic)
6 {
7 Console.WriteLine("key is :{0},value is :{1}", item.Key, item.Value);
8 }
运行结果如下图：
可以看到：出了运行连接点Execute执行运行的代码以外，还有通知采取的行为（Before的执行）。如果通过断点调试，可以看到在连接点执行前，Before执行了。
2、后置通知。后置通知正好是前置通知相反，是在目标对象连接点执行后的通知。它是实现了Spring.Aop命名空间下的IAfterReturningAdvice接口。
编程方式实现。
目标对象的实现代码和前置通知实现方式相同，这里就不给出实现代码了。后置通知的实现代码是：
代码
1 class ConsoleLoggingAfterAdvice: IAfterReturningAdvice
2 {
3 public void AfterReturning(object returnValue, MethodInfo method, object[] args, object target)
4 {
5 if (returnValue != null)
6 {
7 Console.WriteLine("the type of returnValue is :{0},returnValue is {1}", returnValue.GetType().ToString(), returnValue);
8 }
9 Console.WriteLine("method name is {0}", method.Name);
10 if (args != null && args.Length > 0)
11 {
12 foreach (object obj in args)
13 {
14 Console.WriteLine(obj);
15 }
16 }
17 Console.WriteLine("the type of target is :{0},returnValue is {1}", target.GetType().ToString(), target);
18 }
19 }
使用代码：
代码
1 ICommand target = new ServiceCommand();
2 ProxyFactory factory = new ProxyFactory(target);
3 factory.AddAdvice(new ConsoleLoggingAfterAdvice());
4
5 ICommand command = (ICommand)factory.GetProxy();
6 command.Execute("test string");
运行结果如下图：
配置方式实现。配置文件如下：
代码
1 <objects xmlns="http://www.springframework.net" xmlns:aop="http://www.springframework.net/aop">
2
3 <object id ="myServiceObject" type="Spring.Aop.Framework.ProxyFactoryObject" >
4 <property name="Target">
5 <object type="SpringAfterAdvice.ServiceCommand"></object>
6 </property>
7 <property name="InterceptorNames">
8 <list>
9 <value>afterAdvice</value>
10 </list>
11 </property>
12 </object>
13
14 <object id="afterAdvice" type="SpringAfterAdvice.ConsoleLoggingAfterAdvice" ></object>
15 </objects>
实现代码：
1 IApplicationContext context = ContextRegistry.GetContext();
2 ICommand command2 = (ICommand)context["myServiceObject"];
3 command2.Execute("config string");
运行结果如下图：
与前置通知相反，后置通知在目标对象连接点执行后再执行。
3、异常通知。我理解的是当目标对象的连接点执行出现异常的时候执行。异常通知是实现了Spring.Aop命名空间下的IThrowingAdvice接口。
编程方式实现：
异常通知实现代码如下：
代码
1 public void AfterThrowing(FormatException ex)
2 {
3 Console.WriteLine("异常通知执行");
4 Console.WriteLine(ex.Message);
5 }
6
7
8 public void AfterThrowing(UnauthorizedAccessException ex)
9 {
10 Console.Out.WriteLine("Advised method threw this exception : " + ex);
11 }
使用代码如下：
代码
1 ICommand target = new ServiceCommand();
2 ProxyFactory factory = new ProxyFactory(target);
3 factory.AddAdvice(new AroudAdvice());
4 factory.AddAdvice(new ConsoleLoggingThrowsAdvice());
5
6 ICommand command = (ICommand)factory.GetProxy();
7 command.Execute();
配置方式实现。配置文件如下：
代码
1 <objects xmlns="http://www.springframework.net" xmlns:aop="http://www.springframework.net/aop">
2
3 <object id="myServiceObject" type="Spring.Aop.Framework.ProxyFactoryObject">
4 <property name="Target">
5 <object type="SpringExceptionAdvice.ServiceCommand"></object>
6 </property>
7 <property name="InterceptorNames">
8 <list>
9 <value>aroundAdvice</value>
10 <value>exceptionAdvice</value>
11 </list>
12 </property>
13 </object>
14
15 <object id="exceptionAdvice" type="SpringExceptionAdvice.ConsoleLoggingThrowsAdvice"></object>
16 <object id="aroundAdvice" type="SpringExceptionAdvice.AroudAdvice"></object>
17 </objects>
1 IApplicationContext context = ContextRegistry.GetContext();
2 ICommand command2 = (ICommand)context["myServiceObject"];
3 command2.Execute();
注意：异常通知实现的IThrowsAdvice中没有任何方法。但是它的实现类中必须实现public void AfterThrowing方法。并且只有目标对象的连接点执行过程中发生异常类型与AfterThrowing方法的参数一样时，异常通知才会发生。当然，AfterThrowing可以有很多重载。
二、通知链
1、编程方式实现。各种通知的实现代码如下：
代码
1 //前置通知
2 class ConsoleLoggingBeforeAdvice : IMethodBeforeAdvice
3 {
4 public void Before(MethodInfo method, object[] args, object target)
5 {
6 Console.WriteLine("前置通知执行");
7 Console.WriteLine("method name is {0}",method.Name);
8 if (args != null)
9 {
10 for (int i = 0; i < args.Length; i++)
11 {
12 Console.WriteLine(" the {0} position args is :{1}", i, args[i]);
13 }
14 }
15 Console.WriteLine("type of target is :{0}", target.GetType().ToString());
16
17 }
18 }
19
20 //环绕通知
21 class ConsoleLoggingAroundAdvice:IMethodInterceptor
22 {
23 public object Invoke(IMethodInvocation invocation)
24 {
25 object obj = null;
26 Console.WriteLine("环绕通知执行");
27 try
28 {
29 obj = invocation.Proceed();
30 }
31 catch
32 {
33 Console.WriteLine("目标方法执行异常");
34 }
35 return obj;
36 }
37 }
38
39 //后置通知
40 class ConsoleLoggingAfterAdvice : IAfterReturningAdvice
41 {
42 public void AfterReturning(object returnValue, MethodInfo method, object[] args, object target)
43 {
44 Console.WriteLine("后置通知执行");
45 if (returnValue != null)
46 {
47 Console.WriteLine("returnValue is :{0}",returnValue);
48 }
49 Console.WriteLine("method name is :{0}", method.Name);
50 if (args != null)
51 {
52 for (int i = 0; i < args.Length; i++)
53 {
54 Console.WriteLine(" the {0} position args is :{1}",i,args[i]);
55 }
56 }
57 Console.WriteLine("type of target is :{0}",target.GetType().ToString());
58
59 }
60 }
61
62 //异常通知
63 class ConsoleLoggingThrowsAdvice:IThrowsAdvice
64 {
65 public void AfterThrowing(FormatException ex)
66 {
67 Console.WriteLine("发生异常通知");
68 Console.WriteLine(ex.Message);
69 }
70 }
代码
1 ProxyFactory factory = new ProxyFactory(new ServiceCommand());
2
3 factory.AddAdvice(new ConsoleLoggingBeforeAdvice());
4 factory.AddAdvice(new ConsoleLoggingAroundAdvice());
5 factory.AddAdvice(new ConsoleLoggingAfterAdvice());
6 factory.AddAdvice(new ConsoleLoggingThrowsAdvice());
7
8 ICommand command = (ICommand)factory.GetProxy();
9 command.Execute("spring advice link ---programming");
注意织入方式，即factory.AddAdvice添加通知的顺序。我个人感觉应该按照前置--环绕--后置的方式来进行织入。如果我改成
factory.AddAdvice(new ConsoleLoggingAroundAdvice());
factory.AddAdvice(new ConsoleLoggingAfterAdvice());
factory.AddAdvice(new ConsoleLoggingBeforeAdvice());
则运行结果如下图：
2、配置方式实现。
配置文件如下：
代码
1 <objects xmlns="http://www.springframework.net" xmlns:aop="http://www.springframework.net/aop">
2 <object id="myServiceObj" type="Spring.Aop.Framework.ProxyFactoryObject,Spring.Aop">
3 <property name="Target">
4 <object id="serviceCommand" type="SpringAdviceLink.ServiceCommand"></object>
5 </property>
6 <property name="InterceptorNames">
7 <list>
8 <value>beforAdvice</value>
9 <value>aroundAdvice</value>
10 <value>afterAdvice</value>
11 <value>exceptionAdvice</value>
12 </list>
13 </property>
14 </object>
15
16 <object id="beforAdvice" type="SpringAdviceLink.ConsoleLoggingBeforeAdvice"></object>
17 <object id="aroundAdvice" type="SpringAdviceLink.ConsoleLoggingAroundAdvice"></object>
18 <object id="afterAdvice" type="SpringAdviceLink.ConsoleLoggingAfterAdvice"></object>
19 <object id="exceptionAdvice" type="SpringAdviceLink.ConsoleLoggingThrowsAdvice"></object>
1 IApplicationContext context = ContextRegistry.GetContext();
2 ICommand command2 = (ICommand)context["myServiceObj"];
3 command2.Execute("spring advice link ---config");
在配置方式实现中，也要注意<property name="InterceptorNames"/>中list列表中的中值的顺序，顺序不一样执行的结果也不一样。我个人觉得应该是前置--环绕--后置的方式进行配置，至于异常通知的配置由于是连接点执行异常时才执行，所以它的为位置关系不重要。
总结：环绕通知实现的是AopAlliance.Intercept命名控件下的IMethodInterceptor接口，前置通知、后置通知、异常通知分别实现的是Spring.Aop命名空间下的IMethodBeforeAdvice、IAfterReturningAdvice、IThrowsAdvice接口.IThrowsAdvice的实现类必须有AfterThrowing方法，并且AfterThrowing可以有各种异常类型作为参数的重载。
参考文档：Spring.Net参考框架.
代码下载：代码Demo
