写在前面
时间断断续续，这次写一点关于spring aop拦截器链的记载。至于如何获取spring的拦截器，前一篇博客已经写的很清楚（spring---aop（2）---Spring AOP的JDK动态代理）
获取拦截器链
final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
...
//获取拦截器链
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
// Check whether we have any advice. If we don't, we can fallback on direct
if (chain.isEmpty()) {
// 如果拦截器链为空，则执行目标方法
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
}
else {
// 封装拦截器链的执行方法
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// 拦截器链执行
retVal = invocation.proceed();
}
...
}
ReflectiveMethodInvocation 的结构
public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Cloneable {
protected final Object proxy;
protected final Object target;
protected final Method method;
protected Object[] arguments;
private final Class<?> targetClass;
private Map<String, Object> userAttributes;
//拦截器链
protected final List<?> interceptorsAndDynamicMethodMatchers;
//起始基数 默认为-1
private int currentInterceptorIndex = -1;
@Override//拦截器执行入口
public Object proceed() throws Throwable {
// 如果自增系数和拦截器链中拦截器数量相同（则代表，拦截器依次执行完毕）
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
//拦截器执行完毕，执行目标方法;
return invokeJoinpoint();
}
//根据起始基数，依次获对应的拦截器。（每次获取拦截器，起始基数都自增一次）
Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
//这里获取的具体拦截器只会是两种类型（InterceptorAndDynamicMethodMathcher或者MethodInterceptor）
InterceptorAndDynamicMethodMathcher:拦截器的动态方法匹配（这个用的比较少）
MethodInterceptor ：方法拦截器（我们的aop拦截基本上都是methodInterceptor）
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
// Evaluate dynamic method matcher here: static part will already have
InterceptorAndDynamicMethodMatcher dm =(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
return dm.interceptor.invoke(this);
}
else {// Skip this interceptor and invoke the next in the chain.
return proceed();
}
}
else {
// 具体的拦截器执行执行自己的invoke方法，将拦截器链传到里面去了。类似一个链，做递归调用，最有一个拦截器执行完毕（自增系数会和拦截器数量相同，执行目标方法），最后每一个拦截器依次返回，拦截器链执行完毕
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
}
实现类 ReflectiveMethodInvocation 实现接口 ProxyMethodInvocation 继承接口 MethodInvocation 继承接口 Invocation 继承接口 Joinpoint
接口 MethodInterceptor 继承接口 Interceptor 继承接口 Advice 可以看看 MethodInterceptor 自己的抽象方法
public interface MethodInterceptor extends Interceptor {
//拦截器就是通过这个方法的实现，一次执行拦截器链，直到拦截器链中的拦截器执行完毕
Object invoke(MethodInvocation invocation) throws Throwable;
}
看一个 MethodInterceptor 的具体实现 ： TransactionInterceptor（事务通知）
public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable {
@Override
public Object invoke(final MethodInvocation invocation) throws Throwable {
Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
//先准备事物的环境,执行事物执行的相关操作,具体见之前的博客 (spring---transaction（1）---源代码分析(事务的拦截器TransactionInterceptor))
return invokeWithinTransaction(invocation.getMethod(), targetClass, new InvocationCallback() {
@Override
public Object proceedWithInvocation() throws Throwable {
//准备好环境之后，回调拦截器链，拦截器链中的起始基数自增，执行下一个拦截器的invoke方法。如果这是最后一个拦截器，那么拦截器链中的起始基数和拦截器数相同，执行目标方法
return invocation.proceed();
}
});
}
}
再看一个 MethodInterceptor 的实现：MethodBeforeAdviceInterceptor（前置通知）
public class MethodBeforeAdviceInterceptor implements MethodInterceptor, Serializable {
private MethodBeforeAdvice advice;
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
//执行前置通知的具体方法
this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() );
//执行完成之后，回调拦截器链，执行下一个拦截器的invoke方法
return mi.proceed();
}
}
再看一个 MethodInterceptor 的实现：AspectJAfterAdvice（后置通知）
public class AspectJAfterAdvice extends AbstractAspectJAdvice implements MethodInterceptor, AfterAdvice {
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
try {
//因为是后置通知，直接调用拦截器链的下一个拦截器。如果拦截器全部调用完毕，会执行目标方法
return mi.proceed();
}
finally {
//后置通知具体方法执行。到这里，所有的拦截器以及全部执行完毕，且目标方法已经执行。所有在这里执行后置拦截器的后置方法
invokeAdviceMethod(getJoinPointMatch(), null, null);
}
}
}
再看一个 MethodInterceptor 的实现：AspectJAfterThrowingAdvice（环绕通知）
public class AspectJAfterThrowingAdvice extends AbstractAspectJAdvice implements MethodInterceptor, AfterAdvice {
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
try {
//因为是环绕通知，直接调用拦截器链的下一个拦截器。将目标方法的执行方法try cathch 代码块中
return mi.proceed();
}
catch (Throwable t) {
//判断是否是目标方法的异常信息
if (shouldInvokeOnThrowing(t)) {
//如果目标方法在执行的过程中 抛出异常，则执行环绕通知的异常方法。
invokeAdviceMethod(getJoinPointMatch(), null, t);
}
//继续抛出异常，不影响正常的业务逻辑
throw t;
}
}
}
一张图清晰解释拦截器原则
总结一下：
spring的aop设计，并不是所有的通知对象一产生出来就是拦截器，spring是将所有的通知转化为了拦截器（MethodInterceptor 的子类）。中间有经过转换，到了拦截器链中，作为拦截器统一处理。这次先不写转换为拦截器的过程