Spring AOP代理执行解析

我会带着你远行 2022-05-14 08:55 303阅读 0赞

# 准备 #

*  `Spring版本：5.0.8`

# 执行过程解析 #

根据时序图进行分析，这里以前置方法 `before` 为例  
![AOP前置方法before执行流程01][AOP_before_01]

`JdkDynamicAopProxy` 实现了 `InvocationHandler`，在调用时会执行 `invoke()` 方法

// JdkDynamicAopProxy
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       MethodInvocation invocation;
       Object oldProxy = null;
       boolean setProxyContext = false;
    
       TargetSource targetSource = this.advised.targetSource;
       Object target = null;
    
       try {
          // equals方法处理
          if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
             // The target does not implement the equals(Object) method itself.
             return equals(args[0]);
          }
          // hashCode方法处理
          else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
             // The target does not implement the hashCode() method itself.
             return hashCode();
          }
          else if (method.getDeclaringClass() == DecoratingProxy.class) {
             // There is only getDecoratedClass() declared -> dispatch to proxy config.
             return AopProxyUtils.ultimateTargetClass(this.advised);
          }
          else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                method.getDeclaringClass().isAssignableFrom(Advised.class)) {
             // Service invocations on ProxyConfig with the proxy config...
             return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
          }
    
          Object retVal;
          // 目标对象内部的自我调用无法应用切面中的增强需要通过expose-proxy属性暴露代理
          if (this.advised.exposeProxy) {
             // Make invocation available if necessary.
             oldProxy = AopContext.setCurrentProxy(proxy);
             setProxyContext = true;
          }
    
          // Get as late as possible to minimize the time we "own" the target,
          // in case it comes from a pool.
          target = targetSource.getTarget();
          Class<?> targetClass = (target != null ? target.getClass() : null);
    
          // 获取当前方法的拦截器链
          List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
    
          if (chain.isEmpty()) {
             Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
             // 没有拦截器则直接调用切点方法
             retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
          }
          else {
             // 将拦截器封装在ReflectiveMethodInvocation 以便使用其proceed方法调用拦截器
             invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
             // 执行拦截器链
             retVal = invocation.proceed();
          }
    
          Class<?> returnType = method.getReturnType();
          if (retVal != null && retVal == target &&
                returnType != Object.class && returnType.isInstance(proxy) &&
                !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
             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()) {
             // Must have come from TargetSource.
             targetSource.releaseTarget(target);
          }
          if (setProxyContext) {
             // Restore old proxy.
             AopContext.setCurrentProxy(oldProxy);
          }
       }
    }

// AdvisedSupport
    public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, @Nullable Class<?> targetClass) {
       MethodCacheKey cacheKey = new MethodCacheKey(method);
       List<Object> cached = this.methodCache.get(cacheKey);
       if (cached == null) {
          // 获取拦截器链
          cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
                this, method, targetClass);
          this.methodCache.put(cacheKey, cached);
       }
       return cached;
    }

// DefaultAdvisorChainFactory
    public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
          Advised config, Method method, @Nullable Class<?> targetClass) {
    
       // This is somewhat tricky... We have to process introductions first,
       // but we need to preserve order in the ultimate list.
       List<Object> interceptorList = new ArrayList<>(config.getAdvisors().length);
       Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
       boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);
       AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
    
       for (Advisor advisor : config.getAdvisors()) {
          if (advisor instanceof PointcutAdvisor) {
             // Add it conditionally.
             PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
             if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
                // 获取方法拦截器数组
                MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
                MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
                if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {
                   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));
                   }
                }
             }
          }
          else if (advisor instanceof IntroductionAdvisor) {
             IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
             if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
                Interceptor[] interceptors = registry.getInterceptors(advisor);
                interceptorList.addAll(Arrays.asList(interceptors));
             }
          }
          else {
             Interceptor[] interceptors = registry.getInterceptors(advisor);
             interceptorList.addAll(Arrays.asList(interceptors));
          }
       }
    
       return interceptorList;
    }

// DefaultAdvisorAdapterRegistry
    public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
       List<MethodInterceptor> interceptors = new ArrayList<>(3);
       Advice advice = advisor.getAdvice();
       if (advice instanceof MethodInterceptor) {
          interceptors.add((MethodInterceptor) advice);
       }
       /** * 在初始化时注册了三个增强器适配器 * MethodBeforeAdviceAdapter * AfterReturningAdviceAdapter * ThrowsAdviceAdapter */
       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]);
    }

// MethodBeforeAdviceAdapter
    public MethodInterceptor getInterceptor(Advisor advisor) {
    
       MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
       return new MethodBeforeAdviceInterceptor(advice);
    }

下面看 `ReflectiveMethodInvocation` 的 `proceed()` 方法执行拦截器链

![AOP前置方法before执行流程02][AOP_before_02]

// ReflectiveMethodInvocation
    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);
       if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
          // Evaluate dynamic method matcher here: static part will already have
          // been evaluated and found to match.
          // 动态匹配
          InterceptorAndDynamicMethodMatcher dm =
                (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
          if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
             return dm.interceptor.invoke(this);
          }
          else {
             // 不匹配则不执行拦截器
             return proceed();
          }
       }
       else {
          // 普通拦截器直接调用 将this作为参数传递以保证当前实例中拦截器执行
          return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
       }
    }

调用 `MethodBeforeAdviceInterceptor` 的 `invoke` 方法

// MethodBeforeAdviceInterceptor
    public Object invoke(MethodInvocation mi) throws Throwable {
       // 执行before方法
       this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
       return mi.proceed();
    }

// AspectJMethodBeforeAdvice
    public void before(Method method, Object[] args, @Nullable Object target) throws Throwable {
       invokeAdviceMethod(getJoinPointMatch(), null, null);
    }

// AbstractAspectJAdvice
    protected Object invokeAdviceMethod(
          @Nullable JoinPointMatch jpMatch, @Nullable Object returnValue, @Nullable Throwable ex)
          throws Throwable {
    
       return invokeAdviceMethodWithGivenArgs(argBinding(getJoinPoint(), jpMatch, returnValue, ex));
    }

// AbstractAspectJAdvice
    protected Object invokeAdviceMethodWithGivenArgs(Object[] args) throws Throwable {
       Object[] actualArgs = args;
       if (this.aspectJAdviceMethod.getParameterCount() == 0) {
          actualArgs = null;
       }
       try {
          ReflectionUtils.makeAccessible(this.aspectJAdviceMethod);
          // 调用增强方法
          return this.aspectJAdviceMethod.invoke(this.aspectInstanceFactory.getAspectInstance(), actualArgs);
       }
       catch (IllegalArgumentException ex) {
          throw new AopInvocationException("Mismatch on arguments to advice method [" +
                this.aspectJAdviceMethod + "]; pointcut expression [" +
                this.pointcut.getPointcutExpression() + "]", ex);
       }
       catch (InvocationTargetException ex) {
          throw ex.getTargetException();
       }
    }

整个 `AOP` 执行流程完成。

# 参考资料 #

Spring源码深度解析

[AOP_before_01]: /images/20220514/58edf0400bbe4b0fabacae96ae78dc4e.png
[AOP_before_02]: /images/20220514/d6dd50ffba6543ef904a93438d2fda03.png