AOP 执行链的创建和执行原理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   		MethodInvocation invocation;
   		// 存储在调用方法之前，当前线程中的方法调用链中的上一个代理对象。
   		// 比如 代理A -> 代理B -> 当前代理方法。那么方法内 oldProxy 会存储前面的代理对象。因为在这个方法执行完之前，会将
   		// 一个全局的ThreadLocal变量置换为当前的代理对象，旧的值需要缓存起来，等到当前方法执行结束，再设置回原值。
   		Object oldProxy = null;
   		boolean setProxyContext = false;
   
   		// 从代理工厂中拿到TargetSource对象，该对象包装了被代理实例bean
   		TargetSource targetSource = this.advised.targetSource;
   		Object target = null;
   
   		try {
   			// 被代理对象的equals方法和hashCode方法不被代理的，不会走切面，此处代码省略...
   
   			Object retVal;
   			// 如果需要暴露代理对象（在配置文件或者注解中全局配置的），则将当前代理对象放入到一个全局的ThreadLocal变量中。
   			if (this.advised.exposeProxy) {
   				oldProxy = AopContext.setCurrentProxy(proxy);
   				setProxyContext = true;
   			}
   
   			// 这个target就是被代理实例
   			target = targetSource.getTarget();
   			Class<?> targetClass = (target != null ? target.getClass() : null);
   
   			// 从代理工厂中拿过滤器链 Object是一个MethodInterceptor类型的对象，其实就是一个advice对象，或者说是MethodInterceptor
   			List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
   
   			// 如果该方法没有执行链，则说明这个方法不需要被拦截，则直接反射调用。
   			// 因为执行链不论是否为空，都会被缓存到一个ConcurrentHashMap中，执行只有第一次相对较慢。
   			if (chain.isEmpty()) {
   				Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
   				// 这里返回了method.invoke()执行后的返回值。
   				retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
   			}
   			else {
   				// 这里面调用了执行链，在执行链的调用中，会进行火炬传递。具体执行流程，重点在ReflectiveMethodInvocation.proceed()。
   				invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
   				// 在递归结束后，这里最终也会返回实际方法的返回值。火炬传递的过程，实际上也是递归，只是将ReflectiveMethodInvocation
   				// 本身当做参数不断地向下传递。
   				retVal = invocation.proceed();
   			}
            // 省略无关代码...
   			return retVal;
   		}finally {
   		    // 单例情况下，targetSource类型是SingletonTargetSource，这个类中的releaseTarget是个空方法，不用看。
   			if (target != null && !targetSource.isStatic()) {
   				targetSource.releaseTarget(target);
   			}// 如果配置了允许暴露代理对象，在前面设置ThreadLocal变量时，会把局部变量setProxyContext设置为true
   			if (setProxyContext) {
   				// 将旧的代理对象设置到当前代理对象中，这里和执行链火炬传递式无关的。
   				// 如果当前代理方法是从一个代理对象方法内调用过来的，那么这个ThreadLocal变量中是有值的，执行当前代理对象方法时，
   				// 设置为当前的代理对象，执行完后，需要重新设置回原来的代理对象，这样才不会乱套。
   				// 其用途是，当项目中配置允许暴露代理对象时，可以通过AopContext.currentProxy() 来获取到当前线程正在执行的代理对象。
   				// Restore old proxy.
   				AopContext.setCurrentProxy(oldProxy);
   			}
   		}
   	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class AdvisedSupport extends ProxyConfig implements Advised {
    public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, @Nullable Class<?> targetClass) {
		MethodCacheKey cacheKey = new MethodCacheKey(method);
		List<Object> cached = this.methodCache.get(cacheKey);
		if (cached == null) {
			// 根据Method来获取执行链。将获取到的执行链加入到缓存中，键值是根据MethodCacheKey，实际上包装的就是Method对象。
			cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
					this, method, targetClass);
			this.methodCache.put(cacheKey, cached);
		}
		return cached;
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

public class DefaultAdvisorChainFactory implements AdvisorChainFactory, Serializable {

	@Override
	public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
			Advised config, Method method, @Nullable Class<?> targetClass) {

		AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
		Advisor[] advisors = config.getAdvisors();
		List<Object> interceptorList = new ArrayList<>(advisors.length);
		Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
		Boolean hasIntroductions = null;

		for (Advisor advisor : advisors) {
			if (advisor instanceof PointcutAdvisor) {
				PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
				if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
					MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
					boolean match;
					// 省略部分代码...
					match = mm.matches(method, actualClass);
					
					if (match) {
						// TODO 重点 获取MethodInterceptor列表。
						MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
						if (mm.isRuntime()) {
							// Creating a new object instance in the getInterceptors() method
							// isn't a problem as we normally cache created chains.
							for (MethodInterceptor interceptor : interceptors) {
								interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
							}
						}
						else {
							interceptorList.addAll(Arrays.asList(interceptors));
						}
					}
				}
			}
			// 省略...
		}

		return interceptorList;
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable {
    public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
		// 从Advice获取MethodInterceptor。before、afterReturning的增强会被AdvisorAdapter匹配到。
		// 其他自定义的增强方法，都是MethodInterceptor类型，被强转后，直接加入到interceptors中。
		List<MethodInterceptor> interceptors = new ArrayList<>(3);
		Advice advice = advisor.getAdvice();
		// 如果是MethodInterceptor，将其添加到拦截器链中
		if (advice instanceof MethodInterceptor) {
			interceptors.add((MethodInterceptor) advice);
		}
		// 如果有AdviceorAdapter支持当前advice，进行适配，获取interceptor。adapters变量的值，是在无参构造函数中初始化的。
		for (AdvisorAdapter adapter : this.adapters) {
			if (adapter.supportsAdvice(advice)) {
				interceptors.add(adapter.getInterceptor(advisor));
			}
		}
		if (interceptors.isEmpty()) {
			throw new UnknownAdviceTypeException(advisor.getAdvice());
		}
		return interceptors.toArray(new MethodInterceptor[0]);
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {
	// 是否支持指定的 Advice
	@Override
	public boolean supportsAdvice(Advice advice) {
		return (advice instanceof MethodBeforeAdvice);
	}
	// 从Advisor中获取Advice，并封装到MethodBeforeAdviceInterceptor
	@Override
	public MethodInterceptor getInterceptor(Advisor advisor) {
		MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
		return new MethodBeforeAdviceInterceptor(advice);
	}

}

1
2
3
4
5
6
7
8
9

class AfterReturningAdviceAdapter implements AdvisorAdapter, Serializable {
	@Override
	public boolean supportsAdvice(Advice advice) { return (advice instanceof AfterReturningAdvice); }
	@Override
	public MethodInterceptor getInterceptor(Advisor advisor) {
		AfterReturningAdvice advice = (AfterReturningAdvice) advisor.getAdvice();
		return new AfterReturningAdviceInterceptor(advice);
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Cloneable {
    // 当前执行链的索引，标识执行到哪一个通知方法了。
    private int currentInterceptorIndex = -1;
	public Object proceed() throws Throwable {
		//	We start with an index of -1 and increment early.
		// 如果执行链中的advice全部执行完，则直接调用joinPoint方法，就是被代理方法。
		// 这里的成员变量currentInterceptorIndex会记录目前执行到哪一个增强方法了。
		// 最终一定会返回代理方法的返回值，因为没有其他路径返回了，其他路径都是递归调用。
		if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
			return invokeJoinpoint();
		}

		// 执行到这个方法，说明进入到了增强方法，当前执行的索引+1，当执行到最后一个时，此值会与执行链的长度-1相等，这时候就会调用被代理方法。
		Object interceptorOrInterceptionAdvice =
				this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
		// 这段不用看，直接看else里面的代码。
		if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
			// 省略...
		}
		else {
			// 调用MethodInterceptor中的invoke方法,并将自身作为参数向下传递，这里就是个火炬传递的过程。
			// It's an interceptor, so we just invoke it: The pointcut will have
			// been evaluated statically before this object was constructed.
			return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
		}
	}
}