AOP切面排序以及排序后的调用原理

AOP切面的组织过程以及创建道理对象的过程

org.springframework.aop.framework.ReflectiveMethodInvocation这个方法是执行链调用的时候的判断逻辑

1. AbstractAutoProxyCreator创建代理对象的实现了
   postProcessAfterInitialization的bean实例化的后置方法

AbstractAutoProxyCreator
   public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
       if (bean != null) {
           Object cacheKey = this.getCacheKey(bean.getClass(), beanName);
           if (!this.earlyProxyReferences.contains(cacheKey)) {
               return this.wrapIfNecessary(bean, beanName, cacheKey);
           }
       }
       return bean;
   }
AbstractAutoProxyCreator
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
       if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
           return bean;
       } else if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
           return bean;
       } else if (!this.isInfrastructureClass(bean.getClass()) && !this.shouldSkip(bean.getClass(), beanName)) {
           Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, (TargetSource)null);
           if (specificInterceptors != DO_NOT_PROXY) {
               this.advisedBeans.put(cacheKey, Boolean.TRUE);
               Object proxy = this.createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
               this.proxyTypes.put(cacheKey, proxy.getClass());
               return proxy;
           } else {
               this.advisedBeans.put(cacheKey, Boolean.FALSE);
               return bean;
           }
       } else {
           this.advisedBeans.put(cacheKey, Boolean.FALSE);
           return bean;
       }
   }

protected Object createProxy(Class<?> beanClass, @Nullable String beanName, @Nullable Object[] specificInterceptors, TargetSource targetSource) {
       if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
           AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory)this.beanFactory, beanName, beanClass);
       }

       ProxyFactory proxyFactory = new ProxyFactory();
       proxyFactory.copyFrom(this);
       if (!proxyFactory.isProxyTargetClass()) {
           if (this.shouldProxyTargetClass(beanClass, beanName)) {
               proxyFactory.setProxyTargetClass(true);
           } else {
               this.evaluateProxyInterfaces(beanClass, proxyFactory);
           }
       }

       Advisor[] advisors = this.buildAdvisors(beanName, specificInterceptors);
       proxyFactory.addAdvisors(advisors);//在这个位置将拦截器的advisor放入到ProxyFactory中
       proxyFactory.setTargetSource(targetSource);
       this.customizeProxyFactory(proxyFactory);
       proxyFactory.setFrozen(this.freezeProxy);
       if (this.advisorsPreFiltered()) {
           proxyFactory.setPreFiltered(true);
       }

       return proxyFactory.getProxy(this.getProxyClassLoader());
   }

1. org.springframework.aop.framework.ProxyFactory Spring的代理对象工厂用来创建代理对象

ProxyFactory
public Object getProxy(@Nullable ClassLoader classLoader) {
       return this.createAopProxy().getProxy(classLoader);
   }

org.springframework.aop.framework.ProxyCreatorSupport
protected final synchronized AopProxy createAopProxy() {
       if (!this.active) {
           this.activate();
       }
       return this.getAopProxyFactory().createAopProxy(this);//得到了AopProxyFactory
   }
   
   这个实体类的作用是
public class DefaultAopProxyFactory implements AopProxyFactory

   org.springframework.aop.framework.DefaultAopProxyFactory
   public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
       if (!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
           return new JdkDynamicAopProxy(config);//创建Jdk的代理过程
       } else {
           Class<?> targetClass = config.getTargetClass();
           if (targetClass == null) {
               throw new AopConfigException("TargetSource cannot determine target class: Either an interface or a target is required for proxy creation.");
           } else {//创建cglib的代理过程
               return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass) ? new ObjenesisCglibAopProxy(config) : new JdkDynamicAopProxy(config));
           }
       }
   }

org.springframework.aop.framework.AdvisedSupport对象的作用

1. 添加拦截器的addAdvisors方法的实现是在AdvisedSupport的class这个实体类proxyFactory.addAdvisors(advisors);//在这个位置将拦截器的advisor放入到ProxyFactory中

org.springframework.aop.framework.CglibAopProxy代理执行的过程AOP执行链的调用逻辑

 @Nullable
       public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
           Object oldProxy = null;
           boolean setProxyContext = false;
           Object target = null;
           TargetSource targetSource = this.advised.getTargetSource();
           Object var16;
           try {
               if (this.advised.exposeProxy) {
                   oldProxy = AopContext.setCurrentProxy(proxy);
                   setProxyContext = true;
               }
               target = targetSource.getTarget();
               Class<?> targetClass = target != null ? target.getClass() : null;
               //获得AOP的执行链过程
               
               List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
               
               Object retVal;
               if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
                   Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                   retVal = methodProxy.invoke(target, argsToUse);
               } else {
                   retVal = (new CglibAopProxy.CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy)).proceed();
               }
               retVal = CglibAopProxy.processReturnType(proxy, target, method, retVal);
               var16 = retVal;
           } finally {
               if (target != null && !targetSource.isStatic()) {
                   targetSource.releaseTarget(target);
               }
               if (setProxyContext) {
                   AopContext.setCurrentProxy(oldProxy);
               }

           }

           return var16;
       }

获得AOP的执行链过程

AdvisedSupport的方法

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

        return cached;
    }
AdvisorChainFactory
DefaultAdvisorChainFactory实现类
 public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Advised config, Method method, @Nullable Class<?> targetClass) {
        List<Object> interceptorList = new ArrayList(config.getAdvisors().length);
        Class<?> actualClass = targetClass != null ? targetClass : method.getDeclaringClass();
        boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);
        AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
        Advisor[] var8 = config.getAdvisors();
        int var9 = var8.length;

        for(int var10 = 0; var10 < var9; ++var10) {
            Advisor advisor = var8[var10];
            MethodInterceptor[] interceptors;
            if (advisor instanceof PointcutAdvisor) {
                PointcutAdvisor pointcutAdvisor = (PointcutAdvisor)advisor;
                if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
                    interceptors = registry.getInterceptors(advisor);
                    MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
                    if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {
                        if (mm.isRuntime()) {
                            MethodInterceptor[] var15 = interceptors;
                            int var16 = interceptors.length;

                            for(int var17 = 0; var17 < var16; ++var17) {
                                MethodInterceptor interceptor = var15[var17];
                                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)) {
                    interceptors = registry.getInterceptors(advisor);
                    interceptorList.addAll(Arrays.asList(interceptors));
                }
            } else {
                Interceptor[] interceptors = registry.getInterceptors(advisor);
                interceptorList.addAll(Arrays.asList(interceptors));
            }
        }

        return interceptorList;
    }

DefaultAdvisorChainFactory的方法实现拦截器的获取呢？

主要关注registry.getInterceptors(advisor);
这个registry是一个DefaultAdvisorAdapterRegistry对象，并且在对象创建的时候，就注册了三个代理对象

public DefaultAdvisorAdapterRegistry() {
		registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
		registerAdvisorAdapter(new AfterReturningAdviceAdapter());
		registerAdvisorAdapter(new ThrowsAdviceAdapter());
	}

getInterceptors

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);
		}
		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为例来看一下如何获取拦截器

lass MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {

	@Override
	//如果是前置通知，那么可以通过这个对象来得到拦截器
	public boolean supportsAdvice(Advice advice) {
		return (advice instanceof MethodBeforeAdvice);
	}

	@Override
	public MethodInterceptor getInterceptor(Advisor advisor) {
		MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
//这是最终获取到的拦截器对象，也就是最终调用的invoke就是MethodBeforeAdviceInterceptor的invoke
		return new MethodBeforeAdviceInterceptor(advice);
	}

}

下面来看下，剥丝抽茧后最终得到的MethodBeforeAdviceInterceptor

public class MethodBeforeAdviceInterceptor implements MethodInterceptor, BeforeAdvice, Serializable {
	private final MethodBeforeAdvice advice;

	/**
	 * Create a new MethodBeforeAdviceInterceptor for the given advice.
	 * @param advice the MethodBeforeAdvice to wrap
	 */
	public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
		Assert.notNull(advice, "Advice must not be null");
		this.advice = advice;
	}
	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
	//先调用before实现前置增强
		this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
		//再去调用proceed进行下一个拦截器的执行
		return mi.proceed();
	}
}

至于后置与异常增强的适配器与相应的拦截器都是一样的原理，
在适配器里判断是否是对应的增强类型，在通过getInterceptor方法获取到对应的拦截器。
后置增强

public Object invoke(MethodInvocation mi) throws Throwable {
		Object retVal = mi.proceed();
		this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
		return retVal;
	}

异常增强

public Object invoke(MethodInvocation mi) throws Throwable {
		try {
			return mi.proceed();
		}
		catch (Throwable ex) {
			Method handlerMethod = getExceptionHandler(ex);
			if (handlerMethod != null) {
				invokeHandlerMethod(mi, ex, handlerMethod);
			}
			throw ex;
		}
	}
	```