《Spring2.0 技术手册》读书笔记六-Spring AOP 提供的四个Advice（1）

在《静态代理和动态代理》中提到了面向方面编程，主要就是基于动态代理。单独抽象出非业务的功能，服务于某些业务方法。Spring提供了四种很实用的Advice，分别为：Before Advice, After Returning Advice, Around Advice, After throwing Advice。都是方法级别的，就是在某个方法执行前后插入一些非业务的操作，如打日志或者判断权限等。

对于这四种advice的实现，spring都提供了三种方法，分别为基于接口、基于xml和基于annotation(注释)。Before Advice会在目标对象的方法执行之前被调用；After Advice会在目标方法执行之后被调用；Around Advice则可以在目标方法执行前后同时加上相关服务；Throw Advice是在异常发生后执行某些操作。

1.基于接口的Advice

这个就需要自定义的Aspect实现Spring接口。

BeforeAdvice需要实现org.springframework.aop.MethodBeforeAdvice接口：

/** * Advice invoked before a method is invoked. Such advices cannot * prevent the method call proceeding, unless they throw a Throwable. */ public interface MethodBeforeAdvice extends BeforeAdvice { /** * Callback before a given method is invoked. * @param method method being invoked * @param args arguments to the method * @param target target of the method invocation. May be <code>null</code>. * @throws Throwable if this object wishes to abort the call. * Any exception thrown will be returned to the caller if it's * allowed by the method signature. Otherwise the exception * will be wrapped as a runtime exception. */ void before(Method method, Object[] args, Object target) throws Throwable; } 

After Advice实现org.springframework.aop.AfterReturningAdvice接口：

/** * After returning advice is invoked only on normal method return, not if an * exception is thrown. Such advice can see the return value, but cannot change it. */ public interface AfterReturningAdvice extends AfterAdvice { /** * Callback after a given method successfully returned. * @param returnValue the value returned by the method, if any * @param method method being invoked * @param args arguments to the method * @param target target of the method invocation. May be <code>null</code>. * @throws Throwable if this object wishes to abort the call. * Any exception thrown will be returned to the caller if it's * allowed by the method signature. Otherwise the exception * will be wrapped as a runtime exception. */ void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable; } 

Around Advice需要实现org.aopalliance.intercept.MethodInterceptor接口：

/** * <p>The user should implement the {@link #invoke(MethodInvocation)} * method to modify the original behavior. E.g. the following class * implements a tracing interceptor (traces all the calls on the * intercepted method(s)): * * <pre class=code> * class TracingInterceptor implements MethodInterceptor { * Object invoke(MethodInvocation i) throws Throwable { * System.out.println("method "+i.getMethod()+" is called on "+ * i.getThis()+" with args "+i.getArguments()); * Object ret=i.proceed(); * System.out.println("method "+i.getMethod()+" returns "+ret); * return ret; * } * } * </pre> */ public interface MethodInterceptor extends Interceptor { /** * Implement this method to perform extra treatments before and * after the invocation. Polite implementations would certainly * like to invoke {@link Joinpoint#proceed()}. * * @param invocation the method invocation joinpoint * @return the result of the call to {@link * Joinpoint#proceed()}, might be intercepted by the * interceptor. * * @throws Throwable if the interceptors or the * target-object throws an exception. */ Object invoke(MethodInvocation invocation) throws Throwable; } 

类前面的注释说明了该方法的使用，就是要在invoke()方法中调用MethodInvocation.proceed()，将执行传给下一个Interceptor，最终执行目标方法。在proceed()方法前后加操作，到达Aroud advice的作用。

在Aspect定义好后，就需要在bean定义文件中进行配置，通过org.springframework.aop.framework.ProxyFactoryBean的配置，指出接口、目标类和Aspect。如下：

<bean id="helloProxy" class="org.springframework.aop.framework.ProxyFactoryBean"> <!-- 业务接口 --> <property name="proxyInterfaces" value="spring.advice.IHello"/> <!-- 实现该接口的目标类 --> <property name="target" ref="helloSpeaker"/> <!-- 要应用的解释器，即实现非业务操作的Aspect --> <property name="interceptorNames"> <list> <value>throwAdvice</value> <!-- 还可以继续加,如 <value>logBeforeAdvice</value> --> </list> </property> </bean> 

补充下，其中的目标类、解释器(Aspect)都要在Bean定义文件中先进行定义，然后才可以引用的。我们使用时，代码如下：

IHello helloProxy=(IHello)context.getBean("helloProxy"); helloProxy.hello(); 

在Bean定义文件中配置的Aspect就会在合适的joinPoint应用到目标方法上。补：IHello接口中有hello()方法，HelloSpeaker类实现了IHello接口。

以免糊涂，给个实例如下，功能是在hello()方法前后加入日志记录。

public class AroundAdvice implements MethodInterceptor{ private Logger logger= Logger.getLogger(this.getClass().getName()); @Override public Object invoke(MethodInvocation methodInvocation) throws Throwable { logger.log(Level.INFO, "method starts..."+methodInvocation.getMethod()); Object result=methodInvocation.proceed(); logger.log(Level.INFO,"method ends..."+methodInvocation.getMethod()); return result; } } 

配置：

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <bean id="helloSpeaker" class="spring.advice.HelloSpeaker"/> <bean id="aroundAdvice" class="spring.advice.AroundAdvice"/> <bean id="helloProxy" class="org.springframework.aop.framework.ProxyFactoryBean"> <property name="proxyInterfaces" value="spring.advice.IHello" /> <property name="target" ref="helloSpeaker"/> <property name="interceptorNames"> <list> <value>aroundAdvice</value> </list> </property> </bean> </beans> 

IHello helloProxy=(IHello)context.getBean("helloProxy");helloProxy.hello("前后加日志");就会出现如下结果：