Spring源码解析(十一)-Aop拦截器链调用的实现

Aop的实现可以看成由基础设施准备和Aop运行辅助两个部分组成。AopProxy对象的生成,可以看成是一个静态的Aop基础设施的建立过程。对于应用触发的Aop应用,会涉及Aop框架的运行和对Aop基础设施的使用。这些动态部分就是拦截器回调的入口的开始,也是拦截器调用的实现原理。下面我们以JdkDynamicAopProxy的invoke拦截举例。

JdkDynamicAopProxy的invoke拦截
final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
      //构造方法
      public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {
          Assert.notNull(config, "AdvisedSupport must not be null");
          if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
              throw new AopConfigException("No advisors and no TargetSource specified");
          }
          //为当前对象设置AOP配置
          this.advised = config;
    }
      
   //AopProxy代理对象的回调方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        MethodInvocation invocation;
        Object oldProxy = null;
        boolean setProxyContext = false;
        //目标源
        TargetSource targetSource = this.advised.targetSource;
        Class targetClass = null;
        Object target = null;

        try {
            if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
                //如果目标对象没有实现Object类的基本方法:equals.
                return equals(args[0]);
            }
            if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                //如果目标对象没有实现Object类的基本方法:hashCode .
                return hashCode();
            }
            if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                    method.getDeclaringClass().isAssignableFrom(Advised.class)) {
                // 如果AOP配置了通知,使用反射机制调用通知的同名方法...
                return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
            }

            Object retVal;
            //如果当前通知暴露了代理,则将当前代理使用currentProxy()方法变为可用代理
            if (this.advised.exposeProxy) {
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }

            // 获得目标对象.
            target = targetSource.getTarget();
            if (target != null) {
                targetClass = target.getClass();
            }

            // 获得该方法定义好的连接器链.
            List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

            // 如果拦截器为空,那么直接调用target的对应方法,并获取方法返回值.
            if (chain.isEmpty()) {
                Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
            }
            else {
                // 为目标对象创建方法回调对象,需要在调用通知之后才调用目标对象的方法
                invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                // 依次调用拦截器链,这是一个递归实现.
                retVal = invocation.proceed();
            }

            // 方法有返回值,则将代理对象作为方法返回.
            Class returnType = method.getReturnType();
            if (retVal != null && retVal == target && returnType.isInstance(proxy) &&
                    !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
                //特殊情况:方法返回this,该方法的返回类型是兼容的。
                //如果目标在另一个返回的对象中设置对自身的引用,我们将无法帮助
                retVal = proxy;
            }
            else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
                throw new AopInvocationException(
                        "Null return value from advice does not match primitive return type for: " + method);
            }
            return retVal;
        }
        finally {
            if (target != null && !targetSource.isStatic()) {
                // 释放目标对象
                targetSource.releaseTarget(target);
            }
            if (setProxyContext) {
                //释放代理对象.
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }
}
 
 
ReflectiveMethodInvocation的proceed方法
   //处理AOP配置的通知
   public Object proceed() throws Throwable {
        //从索引为-1的拦截器开始调用,并按序递增
        //若拦截器链中的拦截器迭代调用完毕,则就是调用target的函数
        //这个函数是通过反射机制完成的,具体实现在AopUtils.invokeJoinpointUsingReflection方法中
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            return invokeJoinpoint();
        }
        //获取配置的Advice
        Object interceptorOrInterceptionAdvice =
                this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
        //通知器或通知是动态匹配方法拦截器类型
        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
            //动态匹配方法拦截器 .
            InterceptorAndDynamicMethodMatcher dm =
                    (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
            //进行匹配,如果这里和定义的Pointcut匹配,则调用这个advice
            if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
                return dm.interceptor.invoke(this);
            }
            else {
                //不匹配,则递归调用.
                return proceed();
            }
        }
        else {
            //如果是一个interceptor,直接调用这个interceptor对应的方法.
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        }
    }
以上是AOP拦截器链调用的实现,看到这就会有几个问题:这些advisor是怎么从配置文件中获得,并配置到proxy的拦截器链中去的?我们配置的Advice通知是怎么起作用的?这些我们在下章分析。

你可能感兴趣的:(Spring源码解析(十一)-Aop拦截器链调用的实现)