Spring源码解析之AOP 中对拦截器调用的实现 - 博文

前面我们分析了 Spring AOP 实现中得到 Proxy 对象的过程，下面我们看看在 Spring AOP 中拦截器链是怎样被调用的，也就是 Proxy 模式是怎样起作用的，或者说 Spring 是怎样为我们提供 AOP 功能的；在 JdkDynamicAopProxy 中生成 Proxy 对象的时候：

1return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);

这里的 this 参数对应的是 InvocationHandler 对象,这里我们的 JdkDynamicAopProxy 实现了这个接口，也就是说当 Proxy 对象的函数被调用的时候，这个 InvocationHandler 的 invoke 方法会被作为回调函数调用，下面我们看看这个方法的实现：

 1public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
 2    MethodInvocation invocation = null; 
 3    Object oldProxy = null; 
 4    boolean setProxyContext = false; 
 5
 6    TargetSource targetSource = this.advised.targetSource; 
 7    Class targetClass = null; 
 8    Object target = null; 
 9
10    try { 
11        // Try special rules for equals() method and implementation of the 
12        // Advised AOP configuration interface. 
13
14        if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) { 
15            // What if equals throws exception!? 
16            // This class implements the equals(Object) method itself. 
17            return equals(args[0]) ? Boolean.TRUE : Boolean.FALSE; 
18        } 
19        if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) { 
20            // This class implements the hashCode() method itself. 
21            return new Integer(hashCode()); 
22        } 
23        if (Advised.class == method.getDeclaringClass()) { 
24            // service invocations on ProxyConfig with the proxy config 
25            return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args); 
26        } 
27
28        Object retVal = null; 
29
30        if (this.advised.exposeProxy) { 
31            // make invocation available if necessary 
32            oldProxy = AopContext.setCurrentProxy(proxy); 
33            setProxyContext = true; 
34        } 
35
36        // May be <code>null</code>. Get as late as possible to minimize the time we "own" the target, 
37        // in case it comes from a pool. 
38        // 这里是得到目标对象的地方，当然这个目标对象可能来自于一个实例池或者是一个简单的 JAVA 对象 
39        target = targetSource.getTarget(); 
40        if (target != null) { 
41            targetClass = target.getClass(); 
42        } 
43
44        // get the interception chain for this method 
45        // 这里获得定义好的拦截器链 
46        List chain = this.advised.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(this.advised, proxy, method, targetClass); 
47
48        // Check whether we have any advice. If we don't, we can fallback on direct 
49        // reflective invocation of the target, and avoid creating a MethodInvocation. 
50        // 如果没有设定拦截器，那么我们就直接调用目标的对应方法 
51        if (chain.isEmpty()) { 
52            // We can skip creating a MethodInvocation: just invoke the target directly 
53            // Note that the final invoker must be an InvokerInterceptor so we know it does 
54            // nothing but a reflective operation on the target, and no hot swapping or fancy proxying 
55            retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args); 
56        } else { 
57            // We need to create a method invocation... 
58            // invocation = advised.getMethodInvocationFactory().getMethodInvocation( 
59            // proxy, method, targetClass, target, args, chain, advised); 
60            // 如果有拦截器的设定，那么需要调用拦截器之后才调用目标对象的相应方法 
61            // 这里通过构造一个 ReflectiveMethodInvocation 来实现，下面我们会看这个 ReflectiveMethodInvocation 类 
62            invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain); 
63
64            // proceed to the joinpoint through the interceptor chain 
65            // 这里通过 ReflectiveMethodInvocation 来调用拦截器链和相应的目标方法 
66            retVal = invocation.proceed(); 
67        } 
68
69        // massage return value if necessary 
70        if (retVal != null && retVal == target && method.getReturnType().isInstance(proxy)) { 
71            // Special case: it returned "this" and the return type of the method is type-compatible 
72            // Note that we can't help if the target sets 
73            // a reference to itself in another returned object. 
74            retVal = proxy; 
75        } 
76        return retVal; 
77    } finally { 
78        if (target != null && !targetSource.isStatic()) { 
79            // must have come from TargetSource 
80            targetSource.releaseTarget(target); 
81        } 
82
83        if (setProxyContext) { 
84            // restore old proxy 
85            AopContext.setCurrentProxy(oldProxy); 
86        } 
87    } 
88}

我们先看看目标对象方法的调用，这里是通过 AopUtils 的方法调用 - 使用反射机制来对目标对象的方法进行调用：

 1public static Object invokeJoinpointUsingReflection(Object target, Method method, Object[] args) throws Throwable { 
 2
 3    // Use reflection to invoke the method. 
 4    // 利用放射机制得到相应的方法，并且调用 invoke 
 5    try { 
 6        if (!Modifier.isPublic(method.getModifiers()) || 
 7            !Modifier.isPublic(method.getDeclaringClass().getModifiers())) { 
 8                method.setAccessible(true); 
 9        } 
10        return method.invoke(target, args); 
11    } catch (InvocationTargetException ex) { 
12        // Invoked method threw a checked exception. 
13        // We must rethrow it. The client won't see the interceptor. 
14        throw ex.getTargetException(); 
15    } catch (IllegalArgumentException ex) { 
16        throw new AopInvocationException("AOP configuration seems to be invalid: tried calling method [" + method + "] on target [" + target + "]", ex); 
17    } catch (IllegalAccessException ex) { 
18        throw new AopInvocationException("Couldn't access method: " + method, ex); 
19    } 
20}

对拦截器链的调用处理是在 ReflectiveMethodInvocation 里实现的：

 1public Object proceed() throws Throwable { 
 2    // We start with an index of -1 and increment early. 
 3    // 这里直接调用目标对象的方法，没有拦截器的调用或者拦截器已经调用完了，这个 currentInterceptorIndex 的初始值是 0 
 4    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size()) { 
 5        return invokeJoinpoint(); 
 6    } 
 7
 8    Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(this.currentInterceptorIndex); 
 9    if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) { 
10        // Evaluate dynamic method matcher here: static part will already have 
11        // been evaluated and found to match. 
12        // 这里获得相应的拦截器，如果拦截器可以匹配的上的话，那就调用拦截器的 invoke 方法 
13        InterceptorAndDynamicMethodMatcher dm = (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice; 
14        if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) { 
15            return dm.interceptor.invoke(nextInvocation()); 
16        } else { 
17            // Dynamic matching failed. 
18            // Skip this interceptor and invoke the next in the chain. 
19            // 如果拦截器匹配不上，那就调用下一个拦截器，这个时候拦截器链的位置指示后移并迭代调用当前的 proceed 方法 
20            this.currentInterceptorIndex++; 
21            return proceed(); 
22        } 
23    } 
24    else { 
25        // It's an interceptor, so we just invoke it: The pointcut will have 
26        // been evaluated statically before this object was constructed. 
27        return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(nextInvocation()); 
28    } 
29}

这里把当前的拦截器链以及在拦截器链的位置标志都 clone 到一个 MethodInvocation 对象了，作用是当前的拦截器执行完之后，会继续沿着得到这个拦截器链执行下面的拦截行为，也就是会迭代的调用上面这个 proceed:

1private ReflectiveMethodInvocation nextInvocation() throws CloneNotSupportedException { 
2    ReflectiveMethodInvocation invocation = (ReflectiveMethodInvocation) clone(); 
3    invocation.currentInterceptorIndex = this.currentInterceptorIndex + 1; 
4    invocation.parent = this; 
5    return invocation; 
6}

这里的 nextInvocation 就已经包含了当前的拦截链的基本信息，我们看到在 Interceptor 中的实现比如 TransactionInterceptor 的实现中：

 1public Object invoke(final MethodInvocation invocation) throws Throwable { 
 2    ...//这里是 TransactionInterceptor 插入的事务处理代码，我们会在后面分析事务处理实现的时候进行分析 
 3        try { 
 4            //这里是对配置的拦截器链进行迭代处理的调用 
 5            retVal = invocation.proceed(); 
 6        } 
 7    ...//省略了和事务处理的异常处理代码 ，也是 TransactionInterceptor 插入的处理 
 8    else { 
 9        try { 
10            Object result = ((CallbackPreferringPlatformTransactionManager) getTransactionManager.execute(txAttr, new TransactionCallback() { 
11                public Object doInTransaction(TransactionStatus status) { 
12                    //这里是 TransactionInterceptor 插入对事务处理的代码 
13                    TransactionInfo txInfo = prepareTransactionInfo(txAttr, joinpointIdentification, status); 
14                    //这里是对配置的拦截器链进行迭代处理的调用，接着顺着拦截器进行处理 
15                    try { 
16                        return invocation.proceed(); 
17                    } 
18    ...//省略了和事务处理的异常处理代码 ，也是 TransactionInterceptor 插入的处理 
19}