第四章 Spring AOP源码分析笔记

妖狐艹你老母 2023-06-29 02:24 61阅读 0赞

## **一、AOP的配置使用** ##

### **1、AOP入口** ###

通过扫描注解@EnableAspectJAutoProxy(proxyTargetClass = true,exposeProxy = true)注册了AOP 入口类，具体看看注解里面的@Import(AspectJAutoProxyRegistrar.class)

*/\**  
*\** ***TODO 开启注解AOP***  
*\*  ****替代了：<aop:aspectj-autoproxy/>***  
*\* \*/*  
**@Service**  
**@EnableAspectJAutoProxy(proxyTargetClass = false,exposeProxy = true)**  
**public class** EnableAspectJAutoProxyBean \{   
\}

org.springframework.context.annotation.EnableAspectJAutoProxy

在这个类中，注册了AOP入口类 AnnotationAwareAspectJAutoProxyCreator

设置了两个属性：

proxyTargetClass = true

1）目标对象实现了接口 – 使用CGLIB代理机制

2）目标对象没有接口(只有实现类) – 使用CGLIB代理机制

proxyTargetClass = false

1）目标对象实现了接口 – 使用JDK动态代理机制(代理所有实现了的接口)

2）目标对象没有接口(只有实现类) – 使用CGLIB代理机制

@Target(ElementType.***TYPE***)  
@Retention(RetentionPolicy.***RUNTIME***)  
@Documented  
@Import(AspectJAutoProxyRegistrar.**class**)  
**public** @**interface** EnableAspectJAutoProxy \{   
   */\*\**  
*    \* Indicate whether subclass-based (CGLIB) proxies are to be created as opposed*  
*    \* to standard Java interface-based proxies.* *The default is \{* ***@code*** *false\}.*  
*    \*/*  
*   ***boolean** proxyTargetClass() **default false**;  
   */\*\**  
*    \** *Indicate that the proxy should be exposed by the AOP framework as a \{* ***@code*** *ThreadLocal\}*  
*    \* for retrieval via the \{* ***@link*** *org.springframework.aop.framework.AopContext\} class.*  
*    \* Off by default, i.e. no guarantees that \{* ***@code*** *AopContext\} access will work.*  
*    \** ***@since*** *4.3.1*  
*    \*/*  
*   ***boolean** exposeProxy() **default false**;  
\}

exposeProxy

该属性设置代理对象是否需要暴露，说白了就是是否需要把代理对象设置到ThreadLocal中。

AOP的其他入口类的配置是基于xml的形式

例如：

**  
<**aop****:aspectj-autoproxy** **proxy-target-class****="false"** **expose-proxy****="true"**/>

或者

<**aop****:config** **proxy-target-class****="false"**>  
    **  
*    *  
*    *<**aop****:pointcut** **id****="addpointcut"** **expression****="execution(public \* com.chj.service..\*.add(..))"**/>  
    <**aop****:pointcut** **id****="delpointcut"** **expression****="execution(public \* com.chj.service..\*.del\*(..))"**/>  
    <**aop****:pointcut** **id****="myMethods"** **expression****="execution(public \* com.chj.service..\*.\*(..))"**/>  
    **  
*    *<**aop****:advisor** **advice-ref****="beforeAdviceBean"** **order****="2"** **pointcut-ref****="myMethods"**/>  
    <**aop****:aspect** **id****="aspect1"** **ref****="aspectXml1"** **order****="0"**>  
        **  
*        *  
*        *  
*        *  
*        *<**aop****:pointcut** **id****="myMethod2"** **expression****="execution(public \* com.chj.service..\*.\*(..))**  
**            and @annotation(org.springframework.web.bind.annotation.RequestMapping)"**/>  
        <**aop****:before** **method****="before"** **pointcut-ref****="myMethods"**/>  
        <**aop****:after** **method****="after"** **pointcut-ref****="myMethod2"**/>  
        **  
*        *<**aop****:after-returning** **method****="afterReturning"** **returning****="returnVal"**  
**                             ****pointcut****="execution(public \* com.chj.service..\*.\*(..))"**/>  
        **  
*        *  
*        *<**aop****:around** **method****="around"** **pointcut-ref****="myMethod2"**/>  
    </**aop****:aspect**>  
</**aop****:config**>

### **2、是否生成代理** ###

当一个bean实例化完成后，会判断该bean是否生成代理，AOP的入口如下：

**2.1、Aop代理对象生产入口：**

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory\#doCreateBean

*// Initialize the bean instance.*  
Object exposedObject = bean;  
**try** \{   
   *//ioc di，依赖注入的核心方法，该方法必须看，重要程度：5*  
*   *populateBean(beanName, mbd, instanceWrapper);  
   *//bean 实例化+ioc依赖注入完以后的调用，非常重要，重要程度：5*  
*   *exposedObject = initializeBean(beanName, exposedObject, mbd);  
\}

在这个方法里面，具体是：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory\#initializeBean(String,Object, RootBeanDefinition)

**if** (mbd == **null** || !mbd.isSynthetic()) \{   
  ** *****//这个地方可能生出代理实例，是aop的入口***  
***   *****wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);**  
\}  
**return** wrappedBean;

这是一个BeanPostProcessor接口的运用，initializeBean方法我们都知道是一个bean实例化完成后做的操作，而这个代理实例生成也是在bean实例化完成后做的操作，其核心代码如下：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory\#applyBeanPostProcessorsAfterInitialization

@Override  
**public** Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)  
      **throws** BeansException \{   
   Object result = existingBean;  
   **for** (BeanPostProcessor processor : getBeanPostProcessors()) \{   
      Object current = processor.postProcessAfterInitialization(result, beanName);  
      **if** (current == **null**) \{   
         **return** result;  
      \}  
      result = current;  
   \}  
   **return** result;  
\}

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator\#postProcessAfterInitialization

@Override  
**public** Object postProcessAfterInitialization(@Nullable Object bean, String beanName) \{   
   **if** (bean != **null**) \{   
      Object cacheKey = getCacheKey(bean.getClass(), beanName);  
      **if** (!**this**.**earlyProxyReferences**.contains(cacheKey)) \{   
        ** return wrapIfNecessary(bean, beanName, cacheKey);**  
      \}  
   \}  
   **return** bean;  
\}

**2.2、如果这个bean有advice的话，创建当前bean的代理**

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator\#wrapIfNecessary

**protected** Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) \{   
   **if** (StringUtils.*hasLength*(beanName) && **this**.**targetSourcedBeans**.contains(beanName)) \{   
      **return** bean;  
   \}  
   **if** (Boolean.***FALSE***.equals(**this**.**advisedBeans**.get(cacheKey))) \{   
      **return** bean;  
   \}  
   **if** (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) \{   
      **this**.**advisedBeans**.put(cacheKey, Boolean.***FALSE***);  
      **return** bean;  
   \}  
**   *****//创建当前bean的代理，如果这个bean有advice的话，重点看，重要程度5***  
***   // Create proxy if we have advice.***  
***   *****Object\[\] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);**  
  ** *****//如果有切面，则生成该bean的代理***  
***   *****if (specificInterceptors !=** ***DO\_NOT\_PROXY*****) \{**   
      **this**.**advisedBeans**.put(cacheKey, Boolean.***TRUE***);  
    **  *****//把被代理对象bean实例封装到SingletonTargetSource对象中***  
***      *****Object proxy = createProxy(**  
**            bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));**  
      **this**.**proxyTypes**.put(cacheKey, proxy.getClass());  
      **return** proxy;  
   \}  
   **this**.**advisedBeans**.put(cacheKey, Boolean.***FALSE***);  
   **return** bean;  
\}

这个方法就是判断当前bean是否有切面advisor，如果有切面就会走到createProxy方法，生成代理对象然后返回。

**2.3、寻找当前bean的切面简单来说就两步：**

**第一步：从****spring****中找所有的切面，然后找到合格的切面**

找到候选的切面，其实就是一个寻找有@Aspectj注解的过程，把工程中所有有这个注解的类封装成Advisor返回；判断候选的切面是否作用在当前beanClass上面，就是一个匹配过程，现在就是一个匹配。

org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator\#getAdvicesAndAdvisorsForBean();

@Override  
@Nullable  
**protected** Object\[\] getAdvicesAndAdvisorsForBean( Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) \{   
**   *****//找到合格的切面，重点看***  
***   *****List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);**  
   **if** (advisors.isEmpty()) \{   
      **return** ***DO\_NOT\_PROXY***;  
   \}  
   **return** advisors.toArray();  
\}

**protected** List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) \{   
**   *****//找到候选的切面,其实就是一个寻找有@Aspectj注解的过程，把工程中所有有这个注解的类封装成Advisor返回***  
***   *****List<Advisor> candidateAdvisors = findCandidateAdvisors();**  
**   *****//判断候选的切面是否作用在当前beanClass上面，就是一个匹配过程。。现在就是一个匹配***  
***   *****List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);**  
   extendAdvisors(eligibleAdvisors);  
   **if** (!eligibleAdvisors.isEmpty()) \{   
      *//对有@Order@Priority进行排序*  
*      *eligibleAdvisors = sortAdvisors(eligibleAdvisors);  
   \}  
   **return** eligibleAdvisors;  
\}

**第二步：找到拦截当前****bean****的切面**

从spring中找所有切面， 先找到所有的beanDefinition对象对应的beanName，拿到对应的Class对象，判断该类上面是否有@Aspect注解，如果有则是我们要找的，循环该Class里面的除了@PointCut注解的方法，找到方法上面的Around.class,Before.class, After.class, AfterReturning.class, AfterThrowing.class 注解，并且把注解里面的信息，比如表达式：argNames，注解类型等信息封装成对象AspectJAnnotation，然后创建pointCut对象，把注解对象中的表达式设置到pointCut对象中，然后就是创建Advice对象，根据不同的注解类型创建出不同的Advice对象，对象如下：

AspectJAroundAdvice，AspectJAfterAdvice，AspectJAfterThrowingAdvice，AspectJMethodBeforeAdvice，AspectJAfterReturningAdvice最终把注解对应的Advice对象和pointCut对象封装成Advisor对象。

**protected** List<Advisor> findAdvisorsThatCanApply(  
      List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) \{   
   ProxyCreationContext.*setCurrentProxiedBeanName*(beanName);  
   **try** \{   
   **   *****//看看当前类是否在这些切面的pointCut中***  
***      *****return AopUtils.*****findAdvisorsThatCanApply*****(candidateAdvisors, beanClass);**  
   \} **finally** \{   
      ProxyCreationContext.*setCurrentProxiedBeanName*(**null**);  
   \}  
\}

**找到拦截当前****bean****的切面：**

从收集到的所有切面中，每一个切面都会有pointCut来进行模块匹配，其实这个过程就是一个匹配过程，看看pointCut表达式中的内容是否包含了当前bean，如果包含了，那么这个bean就有切面，就会生成代理。

*//创建当前bean的代理，如果这个bean有advice的话，重点看，重要程度5*  
*// Create proxy if we have advice.*  
Object\[\] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, **null**);  
*//如果有切面，则生成该bean的代理*  
**if** (specificInterceptors != ***DO\_NOT\_PROXY***) \{   
   **this**.**advisedBeans**.put(cacheKey, Boolean.***TRUE***);  
   *//把被代理对象bean实例封装到SingletonTargetSource对象中*  
*   *Object proxy = createProxy(  
         bean.getClass(), beanName, specificInterceptors, **new** SingletonTargetSource(bean));  
   **this**.**proxyTypes**.put(cacheKey, proxy.getClass());  
   **return** proxy;  
\}

## **二、代理类的调用** ##

### **1、代理类调用入口** ###

当判断bean有切面时也就是

***//如果有切面，则生成该bean的代理***  
**if** (specificInterceptors != ***DO\_NOT\_PROXY***) \{   
   **this**.**advisedBeans**.put(cacheKey, Boolean.***TRUE***);  
   ***//把被代理对象bean实例封装到SingletonTargetSource对象中***  
***   *****Object proxy = createProxy(**  
**         bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));**  
   **this**.**proxyTypes**.put(cacheKey, proxy.getClass());  
   **return** proxy;  
\}

这个数组不为空时，就会往下走，走到createProxy方法里面，这个方法就会生成bean的代理实例。

### **2、创建代理的过程：**  ###

1）创建代理工厂对象ProxyFactory

2）切面对象重新包装，会把自定义的MethodInterceptor类型的类包装成Advisor切面类并加入到代理工厂中

3）根据proxyTargetClass参数和是否实现接口来判断是采用jdk代理还是cglib代理

4）创建代理对象，并且把代理工厂对象传递到jdk和cglib中，注意这里的代理对象和jdk类和cglib类是一一对应的。

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator\#createProxy

**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** (shouldProxyTargetClass(beanClass, beanName)) \{   
**         *****//proxyTargetClass 是否对类进行代理，而不是对接口进行代理，设置为true时，使用CGLib代理。***  
***         *****proxyFactory.setProxyTargetClass(true);**  
      \}**else** \{   
         evaluateProxyInterfaces(beanClass, proxyFactory);  
      \}  
   \}  
**   *****//把advice类型的增强包装成advisor切面***  
***   *****Advisor\[\] advisors = buildAdvisors(beanName, specificInterceptors);**  
   proxyFactory.addAdvisors(advisors);  
   proxyFactory.setTargetSource(targetSource);  
   customizeProxyFactory(proxyFactory);  
   *//用来控制代理工厂被配置后，是否还允许修改代理的配置,默认为false*  
*   *proxyFactory.setFrozen(**this**.**freezeProxy**);  
   **if** (advisorsPreFiltered()) \{   
      proxyFactory.setPreFiltered(**true**);  
   \}  
   *//获取代理实例*  
*   ***return** proxyFactory.getProxy(getProxyClassLoader());  
\}

### **3、获取代理实例** ###

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator\#createProxy

*/获取代理实例*  
**return** proxyFactory.getProxy(getProxyClassLoader());

org.springframework.aop.framework.ProxyFactory\#getProxy(java.lang.ClassLoader)

**public** Object getProxy(@Nullable ClassLoader classLoader) \{   
   *//根据目标对象是否有接口来判断采用什么代理方式，cglib代理还是jdk动态代理*  
*   ***return** createAopProxy().getProxy(classLoader);  
\}

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70][]

org.springframework.aop.framework.ProxyCreatorSupport\#createAopProxy

org.springframework.aop.framework.DefaultAopProxyFactory\#createAopProxy

**判断是使用JDK代理还是cglib动态代理实现：**

**public class** DefaultAopProxyFactory **implements** AopProxyFactory, Serializable \{   
   @Override  
   **public** AopProxy createAopProxy(AdvisedSupport config) **throws** AopConfigException \{   
      **if** (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) \{   
         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."**);  
         \}

**// 判断代理类是否实现了接口（如果是使用JDK动态代理）**  
**         if (targetClass.isInterface() || Proxy.*****isProxyClass*****(targetClass)) \{**   
**            return new JdkDynamicAopProxy(config);**  
**         \}**  
         **return new** ObjenesisCglibAopProxy(config);  
      \} **else** \{   
         **return new** JdkDynamicAopProxy(config);  
      \}  
   \}

### **4、代理实例的调用** ###

上面我们已经创建出来了代理对象了，现在是拿到代理对象调用，以 jdk动态代理为例，cglib是一样的调用逻辑。

当发生代理对象调用时，肯定会调用到实现了invocationHandler接口的类，这个类就是：JdkDynamicAopProxy必定会调用到该类的invoke方法。

**我们看看****invoke****方法：**

org.springframework.aop.framework.JdkDynamicAopProxy\#invoke

**if** (**this**.**advised**.**exposeProxy**) \{   
   *// Make invocation available if necessary.*  
*   *oldProxy = AopContext.*setCurrentProxy*(proxy);  
   setProxyContext = **true**;  
\}

该参数如果为true会把代理对象存放到ThreadLocal中。我们在代理里面通过AopContext.currentProxy方法就可以拿到当前调用的代理类。实际上没啥用。

*// Get as late as possible to minimize the time we "own" the target,*  
*// in case it comes from a pool.*  
*//这个target就是被代理实例*  
target = targetSource.getTarget();  
Class<?> targetClass = (target != **null** ? target.getClass() : **null**);  
*// Get the interception chain for this method.*  
***//从代理工厂中拿过滤器链 Object是一个MethodInterceptor类型的对象，其实就是一个advice对象***  
**List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);**

org.springframework.aop.framework.JdkDynamicAopProxy\#getProxy(java.lang.ClassLoader)

@Override  
**public** Object getProxy(@Nullable ClassLoader classLoader) \{   
   **if** (***logger***.isTraceEnabled()) \{   
      ***logger***.trace(**"Creating JDK dynamic proxy: "** \+ **this**.**advised**.getTargetSource());  
   \}  
   *//advised是代理工厂对象*  
*   *Class<?>\[\] proxiedInterfaces = AopProxyUtils.*completeProxiedInterfaces*(**this**.**advised**, **true**);  
   findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);  
   **return** Proxy.*newProxyInstance*(classLoader, proxiedInterfaces, **this**);  
\}

从代理工厂中拿到切面，并且跟当前被代理类和当前被调用方法匹配，如果匹配就返回切面中的advice对象，这就是advice执行链。只是对advice进行了统一包装，如下代码：

### **5、advice执行链** ###

方法入口：org.springframework.aop.framework.JdkDynamicAopProxy\#invoke

*//从代理工厂中拿过滤器链 Object是一个MethodInterceptor类型的对象，其实就是一个advice对象*  
List<Object> chain = **this**.**advised**.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

org.springframework.aop.framework.AdvisedSupport\#getInterceptorsAndDynamicInterceptionAdvice

**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;  
\}

**5.1、获取过滤器链：**

org.springframework.aop.framework.DefaultAdvisorChainFactory\#getInterceptorsAndDynamicInterceptionAdvice

@Override  
**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.*  
*   *AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.*getInstance*();  
   *//从代理工厂中获得该被代理类的所有切面advisor，config就是代理工厂对象*  
*   *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) \{   
         *// Add it conditionally.*  
*         *PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;  
         *//如果切面的pointCut和被代理对象是匹配的，说明是切面要拦截的对象*  
*         ***if** (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) \{   
            MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();  
            **boolean** match;  
            **if** (mm **instanceof** IntroductionAwareMethodMatcher) \{   
               **if** (hasIntroductions == **null**) \{   
                  hasIntroductions = *hasMatchingIntroductions*(advisors, actualClass);  
               \}  
               match = ((IntroductionAwareMethodMatcher) mm).matches(method, actualClass, hasIntroductions);  
            \}**else** \{   
               *//接下来判断方法是否是切面pointcut需要拦截的方法*  
*               *match = mm.matches(method, actualClass);  
            \}  
            *//如果类和方法都匹配*  
*            ***if** (match) \{   
              ** *****//获取到切面advisor中的advice，并且包装成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));  
               \}  
            \}  
         \}  
      \}  
      *//如果是引介切面*  
*      ***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;  
\}

**5.2、获取到切面advisor中的advice，并且包装成MethodInterceptor类型的对象**

org.springframework.aop.framework.adapter.DefaultAdvisorAdapterRegistry\#getInterceptors

@Override  
**public** MethodInterceptor\[\] getInterceptors(Advisor advisor) **throws** UnknownAdviceTypeException \{   
   List<MethodInterceptor> interceptors = **new** ArrayList<>(3);  
   Advice advice = advisor.getAdvice();  
   *//如果是MethodInterceptor类型的，如：AspectJAroundAdvice*  
*   //AspectJAfterAdvice*  
*   //AspectJAfterThrowingAdvice*  
*   ***if** (advice **instanceof** MethodInterceptor) \{   
      interceptors.add((MethodInterceptor) advice);  
   \}  
 **  *****//处理 AspectJMethodBeforeAdvice  AspectJAfterReturningAdvice***  
***   *****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\]);  
\}

org.springframework.aop.framework.adapter.DefaultAdvisorAdapterRegistry\#getInterceptors

@Override  
**public** MethodInterceptor\[\] getInterceptors(Advisor advisor) **throws** UnknownAdviceTypeException \{   
   List<MethodInterceptor> interceptors = **new** ArrayList<>(3);  
   Advice advice = advisor.getAdvice();  
   *//如果是MethodInterceptor类型的，如：AspectJAroundAdvice*  
*   //AspectJAfterAdvice*  
*   //AspectJAfterThrowingAdvice*  
*   ***if** (advice **instanceof** MethodInterceptor) \{   
      interceptors.add((MethodInterceptor) advice);  
   \}  
   *//处理 AspectJMethodBeforeAdvice  AspectJAfterReturningAdvice*  
*   ***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\]);  
\}

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 1][]

**5.3、默认创建的增强：**

**private final** List<AdvisorAdapter> **adapters** = **new** ArrayList<>(3);  
**public** DefaultAdvisorAdapterRegistry() \{   
   registerAdvisorAdapter(**new** MethodBeforeAdviceAdapter());  
   registerAdvisorAdapter(**new** AfterReturningAdviceAdapter());  
   registerAdvisorAdapter(**new** ThrowsAdviceAdapter());  
\}

### **6、Aop链式调用过程** ###

最终会把箭头指向的这两种类型的advice包装成MethodInterceptor类型的advice，方便后续统一调用。

org.springframework.aop.framework.JdkDynamicAopProxy\#invoke

**else** \{   
   *// We need to create a method invocation...*  
*   *invocation = **new** ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);  
   *// Proceed to the joinpoint through the interceptor chain.*  
*   *retVal = invocation.proceed();  
\}

获取到这个执行链后，判断如果执行链为空，则直接反射调用方法，说明该方法没被拦截，如果不为空就会有一个链式调用过程。

**6.1、在ReflectiveMethodInvocation中维护了执行链数组和数组索引**

@Override  
@Nullable  
**public** Object proceed() **throws** Throwable \{   
   *// We start with an index of -1 and increment early.*  
*  ** //如果执行链中的advice全部执行完，则直接调用joinPoint方法，就是被代理方法*  
*   ***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;  
      Class<?> targetClass = (**this**.**targetClass** != **null** ? **this**.**targetClass** : **this**.**method**.getDeclaringClass());  
      **if** (dm.**methodMatcher**.matches(**this**.**method**, targetClass, **this**.**arguments**)) \{   
         **return** dm.**interceptor**.invoke(**this**);  
      \} **else** \{   
         *// Dynamic matching failed.*  
*         // Skip this interceptor and invoke the next in the chain.*  
*         ***return** proceed();  
      \}  
   \}**else** \{   
      *// It's an interceptor, so we just invoke it: The pointcut will have*  
*      // been evaluated statically before this object was constructed.*  
*      ****//调用MethodInterceptor中的invoke方法***  
***      *****return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);**  
   \}  
\}

**6.2、通过索引获取到数组里面的advice然后调用mi.proceed()**

我们举例说明，如果第一个advice调用到了beforeAdvice，如下：

**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 \{**   
**      this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());**  
**      return mi.proceed();**  
**   \}**  
\}

BeforeAdvice首先会调用自己advice对象中的method对象，而这个method对象就是有@Before注解的方法，我们通过解析方法上面的注解类型生成advice对象时把对应的method对象封装到了advice对象中，所以这里就只要反射调用method对象即可。

**6.3、Before方法与around方法链式调用**

**调用完后，这里有一个****mi.proceed()****这个方法又会回到****ReflectiveMethodInvocation****这个类中**

@Override  
@Nullable  
**public** Object proceed() **throws** Throwable \{

*//调用MethodInterceptor中的invoke方法*  
**return** ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(**this**);

**这时候索引又会****+1****，然后从链中后去下一个****advice****，然后下一个****advice****调用完后再****mi.proceed()****又会接着调用，其中后置增强是通过在finally块中执行的，就这样形成了一个链式调用过程。直到数组链中全部调用完后会调用到具体的****joinPoint****方法如下：**

@Override  
@Nullable  
**public** Object proceed() **throws** Throwable \{   
   *// We start with an index of -1 and increment early.*  
*   //如果执行链中的advice全部执行完，则直接调用joinPoint方法，就是被代理方法*  
*   ***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;  
      Class<?> targetClass = (**this**.**targetClass** != **null** ? **this**.**targetClass** : **this**.**method**.getDeclaringClass());  
      **if** (dm.**methodMatcher**.matches(**this**.**method**, targetClass, **this**.**arguments**)) \{   
         **return** dm.**interceptor**.invoke(**this**);  
      \}**else** \{   
         *// Dynamic matching failed.*  
*         // Skip this interceptor and invoke the next in the chain.*  
*         ***return** proceed();  
      \}  
   \}**else** \{   
      *// It's an interceptor, so we just invoke it: The pointcut will have*  
*      // been evaluated statically before this object was constructed.*  
*      //调用MethodInterceptor中的invoke方法*  
*      ***return** ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(**this**);  
   \}  
\}

当判断当前索引==执行链数组大小时就会调用到被代理方法，完成aop增强过程。

**6.4、后置after增强处理方法**

org.springframework.aop.aspectj.AspectJAfterAdvice\#invoke

@Override  
**public** Object invoke(MethodInvocation mi) **throws** Throwable \{   
   **try** \{   
      **return** mi.proceed();  
   \}  
   **finally** \{   
      invokeAdviceMethod(getJoinPointMatch(), **null**, **null**);  
   \}  
\}

三、AOP代理总结

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200109235754686.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200109235726245.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4,size_16,color_FFFFFF,t_70