Spring AOP 通知的调用——AOP 源码解析（三）

一、概述

上一章我们分析了通知是如何实现的，本章我们看下通知是如何被调用的。我们知道，一个切点可以有多个切面，多个通知，需要有这么一个对象，负责把这些通知组织起来，然后逐个去调用。这个职责由ProxyMethodInvocation接口，默认的实现就是就是ReflectiveMethodInvocation。

二、ReflectiveMethodInvocation

ReflectiveMethodInvocation从名字就可以看出来，使用反射实现。先看看他的几个属性

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;//拦截器链
private int currentInterceptorIndex = -1;//调用链计数器，记录拦截器执行到哪里了

这些属性包含了一个方法被代理执行需要的所有要素，包括被代理对象/方法/参数/类等等，最重要的是interceptorsAndDynamicMethodMatchers这个拦截器链，就是那些@Befor/@After/@Around等通知，不纠结它是怎么被创建的，就看他是怎么执行的，直接看proceed方法，被代理方法执行的，就是这个。

public Object proceed() throws Throwable {
	// 递归出口，拦截器链执行完毕，则调用真正被代理的方法
	// We start with an index of -1 and increment early.
	if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
		return invokeJoinpoint();
	}
	// 获取拦截器
	Object interceptorOrInterceptionAdvice =
			this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
    // 拦截器分动态匹配/静态匹配两种实现
    // 动态匹配还要再执行一下matches方法判断，静态则初始化的时候已经匹配好了，直接执行
    if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
        InterceptorAndDynamicMethodMatcher dm =
        (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
        Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
        // 动态匹配，匹配成功，则执行拦截器的invoke - 一般拦截器也会调用proceed，所以其实还是递归
        if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
            return dm.interceptor.invoke(this);
        }
        else {
            // 无法匹配，执行下一个拦截器，递归调用
            return proceed();
        }
    }
    else {
        // It's an interceptor, so we just invoke it: The pointcut will have
        // been evaluated statically before this object was constructed.
        // 一般拦截器也会调用proceed，所以其实还是递归
        return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
    }
}
源码出自:ReflectiveMethodInvocation.proceed()

看到上面代码中的proceed()方法，不知道你有没有种似曾相识的感觉，没错，上一章中，也出现了proceed()方法的调用，我帮你回忆一下：

@Override
public Object invoke(MethodInvocation mi) throws Throwable {
    // 先执行通知方法
    this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
    // 再执行原来的方法
    return mi.proceed();
}
源码出自：MethodBeforeAdviceInterceptor#invoke

通知在执行原来的方法时，执行的就是proceed()方法，ReflectiveMethodInvocation实现了MethodInvocation接口，上面最后一行在执行通知的时候，就把自己（this）作为参数，传递给了通知的拦截器（MethodInterceptor）。下面我们看下类图：

从类图中就可以清晰的看出，ReflectiveMethodInvocation实现了MethodInvocation接口，在调用MethodInterceptor接口的invoke方法时，会把自己（this）作为参数传递进去。同时，ReflectiveMethodInvocation有一个interceptorsAndDynamicMethodMatchers属性，存放被代理对象的各种通知。这两者是互相依赖的，在proceed方法中调用invoke，在invoke中再调用proceed，两者互相调用，形成了一种递归。直到整个拦截器链运行完成，也就是执行到this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1成立的时候。除非是环绕通知，因为是否执行、什么时候执行，这都是由通知的实现自行决定的。

三、遗留问题

上一章留了一个尾巴：

环绕通知，会把MethodInvocation包装成ProceedingJoinPoint，这很好理解，ProceedingJoinPoint比普通的JoinPoint多暴露出来了一个proceed方法，用于通知自行调用。但是，在执行proceed方法时，会对methodInvocation做一个浅拷贝，为什么呢？

为什么呢，我们看下注释：

/**
* This implementation returns a shallow copy of this invocation object,
* using the given arguments array for the clone.
* <p>We want a shallow copy in this case: We want to use the same interceptor
* chain and other object references, but we want an independent value for the
* current interceptor index.
* @see java.lang.Object#clone()
*/
@Override
public MethodInvocation invocableClone(Object... arguments) {
	// Force initialization of the user attributes Map,
	// for having a shared Map reference in the clone.
	if (this.userAttributes == null) {
		this.userAttributes = new HashMap<>();
	}
	// Create the MethodInvocation clone.
	try {
		ReflectiveMethodInvocation clone = (ReflectiveMethodInvocation) clone();
		clone.arguments = arguments;
		return clone;
	}
	catch (CloneNotSupportedException ex) {
		throw new IllegalStateException(
				"Should be able to clone object of type [" + getClass() + "]: " + ex);
	}
}
源码出自：ReflectiveMethodInvocation.invocableClone(Object...)

注释大概就是说，主要是为了有个独立的interceptor index，也就是拦截器计数器，记录了当前执行到了哪个拦截器。复制它有什么用呢？ 复制后就可以重复调用了。通常proceed只要调用一次就可以了，但是如果暴露给了用户，用户可以不调用，也可以调用多次，那么如果index是一个的话，则只有第一次会继续后续的拦截器调用，其余的时候，都只调用被代理方法本身。这就是要保持一个独立的interceptor index的原因。

系列所有文章