spring---aop（3）---Spring AOP的拦截器链

写在前面

　　时间断断续续，这次写一点关于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 的子类）。中间有经过转换，到了拦截器链中，作为拦截器统一处理。这次先不写转换为拦截器的过程