Spring AOP(二) 修飾者模式、JDK Proxy以及源碼分析

在上邊一篇文章中我們介紹了Spring AOP的基本概念，今天我們就來學習一下與AOP實現相關的修飾者模式和Java Proxy相關的原理，以及AOP的源碼分析。

修飾者模式

Java設計模式中的修飾者模式能動態地給目標對象增加額外的職責(Responsibility)。它使用組合(object composition)，即將目標對象作爲修飾者對象(代理)的成員變量，由修飾者對象決定調用目標對象的時機和調用前後所要增強的行爲。
裝飾模式包含如下組成部分：

Component: 抽象構件，也就是目標對象所實現的接口，有operation函數
ConcreteComponent: 具體構件，也就是目標對象的類
Decorator: 抽象裝飾類，也實現了抽象構件接口，也就是目標類和裝飾類都實現了相同的接口
ConcreteDecorator: 具體裝飾類，其中addBeavior函數就是增強的行爲，裝飾類可以自己決定addBeavior函數和目標對象函數operation函數的調用時機。

修飾者模式調用的時序圖如下圖所示。程序首先創建目標對象，然後創建修飾者對象，並將目標對象傳入作爲其成員變量。當程序調用修飾者對象的operation函數時，修飾者對象會先調用目標對象的operation函數，然後再調用自己的addBehavior函數。這就是類似於AOP的後置增強器，在目標對象的行爲之後添加新的行爲。

Spring AOP的實現原理和修飾者模式類似。在上一篇文章中說到AOP的動態代理有兩種實現方式，分別是JDK Proxy和cglib。
如下圖所示，JDK Proxy的類結構和上文中修飾者的類圖結構類似，都是代理對象和目標對象都實現相同的接口，代理對象持有目標對象和切面對象，並且決定目標函數和切面增強函數的調用時機。
而cglib的實現略有不同，它沒有實現實現相同接口，而是代理對象繼承目標對象類。

本文後續就講解一下JDK Proxy的相關源碼分析。

JDK Proxy

JDK提供了Proxy類來實現動態代理的，可通過它的newProxyInstance函數來獲得代理對象。JDK還提供了InvocationHandler類，代理對象的函數被調用時，會調用它的invoke函數，程序員可以在其中實現所需的邏輯。
JDK Proxy的基本語法如下所示。先構造一個InvocationHandler的實現類，然後調用Proxy的newProxyInstance函數生成代理對象，傳入類加載器，目標對象的接口和自定義的InvocationHandler實例。

public class CustomInvocationHandler implements InvocationHandler {
    private Object target;
    
      public CustomInvocationHandler(Object target) {
        this.target = target;
    }
       
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before invocation");
        Object retVal = method.invoke(target, args);
        System.out.println("After invocation");
        return retVal;
}
}
        CustomInvocationHandler customInvocationHandler = new CustomInvocationHandler(
        helloWord);//通過Proxy.newProxyInstance生成代理對象
ProxyTest proxy = (ProxyTest) Proxy.newProxyInstance(
        ProxyTest.class.getClassLoader(),
       proxyObj.getClass().getInterfaces(), customInvocationHandler);

生成代理對象
我們首先來看一下Proxy的newProxyInstance函數。newProxyInstance函數的邏輯大致如下：

首先根據傳入的目標對象接口動態生成代理類
然後獲取代理類的構造函數實例
最後將InvocationHandler作爲參數通過反射調用構造函數實例，生成代理類對象。
具體源碼如下所示。

public static Object newProxyInstance(ClassLoader loader,
                                        Class<?>[] interfaces,
                                        InvocationHandler h)
    throws IllegalArgumentException{
                final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }
    // 1 動態生成代理對象的類
    Class<?> cl = getProxyClass0(loader, intfs);
               // ... 代碼省略，下邊代碼其實是在try catch中的
    if (sm != null) {
        checkNewProxyPermission(Reflection.getCallerClass(), cl);
    }
    // 2 獲取代理類的構造函數
    final Constructor<?> cons = cl.getConstructor(constructorParams);
    final InvocationHandler ih = h;
    if (!Modifier.isPublic(cl.getModifiers())) {
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {
                cons.setAccessible(true);
                return null;
            }
        });
    }
    // 3調用構造函數，傳入InvocationHandler對象
    return cons.newInstance(new Object[]{h});}
 getProxyClass0函數的源碼如下所示，通過代理類緩存獲取代理類信息，如果不存在則會生成代理類。
// 生成代理類private static Class<?> getProxyClass0(ClassLoader loader,
                                        Class<?>... interfaces) {
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }
            // 如果已經有Proxy類的緩存則直接返回，否則要進行創建
    return proxyClassCache.get(loader, interfaces);}

生成代理類
JDK Proxy通過ProxyClassFactory生成代理類。其apply函數大致邏輯如下：

校驗接口是否符合規範· 生成代理類的名稱和包名
生成代理類字節碼
根據字節碼生成代理類Class

// 生成代理類的工廠類
private static final class ProxyClassFactory
    implements BiFunction<ClassLoader, Class<?>[], Class<?>>{
    // 所有代理類名的前綴
    private static final String proxyClassNamePrefix = "$Proxy";
             // 生成唯一類名的原子Long對象
    private static final AtomicLong nextUniqueNumber = new AtomicLong();
                 @Override
    public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
                 Map<Class<?>, Boolean> interfaceSet = new
 IdentityHashMap<>(interfaces.length);
        for (Class<?> intf : interfaces) {
            // 通過loader找到接口對應的類信息。
            Class<?> interfaceClass = null;
            try {
                interfaceClass = Class.forName(intf.getName(), false, loader);
            } catch (ClassNotFoundException e) {
            }
            if (interfaceClass != intf) {
                throw new IllegalArgumentException(
                    intf + " is not visible from class loader");
            }
            // 判斷找出來的類確實是一個接口
            if (!interfaceClass.isInterface()) {
                throw new IllegalArgumentException(
                    interfaceClass.getName() + " is not an interface");
            }
            // 判斷接口是否重複
            if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                throw new IllegalArgumentException(
                    "repeated interface: " + interfaceClass.getName());
            }
        }
        // 代理類的包路徑
        String proxyPkg = null;
        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
                  // 記錄非公開的代理接口，以便於生成的代理類和原來的類在同一個路徑下。
         for (Class<?> intf : interfaces) {
            int flags = intf.getModifiers();
            if (!Modifier.isPublic(flags)) {
                accessFlags = Modifier.FINAL;
                String name = intf.getName();
                int n = name.lastIndexOf('.');
                String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                if (proxyPkg == null) {
                    proxyPkg = pkg;
                } else if (!pkg.equals(proxyPkg)) {
                    throw new IllegalArgumentException(
                        "non-public interfaces from different packages");
                }
            }
        }
        // 如果沒有非公開的Proxy接口，使用com.sun.proxy報名
        if (proxyPkg == null) {
            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
        }
                  long num = nextUniqueNumber.getAndIncrement();
        // 默認情況下，代理類的完全限定名爲：com.sun.proxy.$Proxy0，$Proxy1……依次遞增
          String proxyName = proxyPkg + proxyClassNamePrefix + num;
                 // 生成代理類字節碼
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
            proxyName, interfaces, accessFlags);
        try {
            // 根據字節碼返回相應的Class實例
            return defineClass0(loader, proxyName,
                                proxyClassFile, 0, proxyClassFile.length);
        } catch (ClassFormatError e) {
            throw new IllegalArgumentException(e.toString());
        }
}
}

其中關於字節碼生成的部分邏輯我們就暫時不深入介紹了，感興趣的同學可以自行研究。

$Proxy反編譯

我們來看一下生成的代理類的反編譯代碼。代理類實現了Object的基礎函數，比如toString、hasCode和equals，也實現了目標接口中定義的函數，比如說ProxyTest接口的test函數。
$Proxy中函數的實現都是直接調用了InvocationHandler的invoke函數。

public final class $Proxy0 extends Proxy
  implements ProxyTest // 會實現目標接口，但是由於集成了Proxy，所以無法再集成其他類{
  private static Method m1;
  private static Method m0;
  private static Method m3;
  private static Method m2;
  // 構造函數要傳入一個InvocationHandler對象
  public $Proxy0(InvocationHandler paramInvocationHandler)
    throws
   {
    super(paramInvocationHandler);
  }
  // equal函數
  public final boolean equals(Object paramObject)
    throws 
  { 
     try
    {
      return ((Boolean)this.h.invoke(this, m1, new Object[]
 { paramObject })).booleanValue();
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }
      public final int hashCode()
    throws
   {
    try
    {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }
  // test函數，也就是ProxyTest接口中定義的函數
  public final void test(String paramString)
    throws
   {
    try
    {
      // 調用InvocationHandler的invoke函數
      this.h.invoke(this, m3, new Object[] { paramString });
      return;
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }
           public final String toString()
    throws
   {
    try
    {
      return (String)this.h.invoke(this, m2, null);
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }
  // 獲取各個函數的Method對象
  static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      m3 = Class.forName("com.proxy.test2.HelloTest").getMethod("say", new Class[] { Class.forName("java.lang.String") });
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
    }
    throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
  }
}

Spring AOP是Spring的兩大基石之一，接下來是源碼的解析。
從代碼執行角度來看，Spring AOP的執行過程分爲四大步驟：

步驟一：Spring框架生成Advisor實例，可以是@Aspect，@Async等註解生成的實例，也可以是程序員自定義的AbstractAdvisor子類的實例.
步驟二：Spring框架在目標實例初始化完成後，也就是使用BeanPostProcessor的postProcessAfterInitialization方法，根據Advisor實例中切入點Pointcut的定義，選擇出適合該目標對象的Advisor實例。
步驟三：Spring框架根據Advisor實例生成代理對象。
步驟四：調用方法執行過程時，Spring框架執行Advisor實例的通知Advice邏輯。
由於這四個步驟涉及的源碼量較大，一篇文章無法直接完全講解完，本篇文章只講解第一步Advisor實例生成的源碼分析。接下來我們就依次講解一下後續步驟中比較關鍵的邏輯。
Advisor類架構
Spring中有大量的機制都是通過AOP實現的，比如說@Async的異步調用和@Transational。此外，用戶也可以使用@Aspect註解定義切面或者直接繼承AbstractPointcutAdvisor來提供切面邏輯。上述這些情況下，AOP都會生成對應的Advisor實例。
我們先來看一下Advisor的相關類圖。首先看一下org.aopalliance包下的類圖。aopalliance是AOP組織下的公用包，用於AOP中方法增強和調用，相當於一個jsr標準，只有接口和異常，在AspectJ、Spring等AOP框架中使用。

aopalliance定義了AOP的通知Advice和連接點Joinpoint接口，並且還有繼承上述接口的MethodInterceptor和MethodInvocation。這兩個類相信大家都很熟悉。
然後我們來看一下Spring AOP中Advisor相關的類圖。Advisor是Spring AOP獨有的概念，比較重要的類有AbstractPointcutAdvisor和InstantiationModelAwarePointcutAdvisor。相關的講解都在圖中表明瞭，如果這張圖中的概念和類同學們都熟識，那麼對AOP的瞭解就已經很深入了。

獲取所有Advisor實例
AOP生成Advisor實例的函數入口是AbstractAdvisorAutoProxyCreator的findCandidateAdvisors函數。

// AbstractAdvisorAutoProxyCreator.java 找出當前所有的Advisorprotected List<Advisor> findCandidateAdvisors() {
    Assert.state(this.advisorRetrievalHelper != null, "No
     BeanFactoryAdvisorRetrievalHelper available");
    return this.advisorRetrievalHelper.findAdvisorBeans();}
    // AnnotationAwareAspectJAutoProxyCreator，是AbstractAdvisorAutoProxyCreator的子類@Overrideprotected List<Advisor> findCandidateAdvisors() {
    // 調用父類的findCandidateAdvisor函數，一般找出普通的直接
    // 繼承Advisor接口的實例，比如說`@Async`所需的`AsyncAnnotationAdvisor`
    List<Advisor> advisors = super.findCandidateAdvisors();
    // 爲AspectJ的切面構造Advisor，也就是說處理@Aspect修飾的類，生成上文中說的`InstantiationModelAwarePointcutAdvisor`實例
    if (this.aspectJAdvisorsBuilder != null) {
        advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
    }return advisors;
}

相關的ProxyCreator也有一個類體系，不過太過繁雜，而且重要性不大，我們就先略過，直接將具體的類。由上邊代碼可知AbstractAdvisorAutoProxyCreator的findCandidateAdvisors函數是直接獲取Spring容器中的Advisor實例，比如說AsyncAnnotationAdvisor實例，或者說我們自定義的AbstractPointcutAdvisor的子類實例。AdvisorRetrievalHelper的findAdvisorBeans函數通過BeanFactory的getBean獲取了所有類型爲Advisor的實例。
而AnnotationAwareAspectJAutoProxyCreator看其類名就可知，是與AspectJ相關的創建器，用來獲取@Aspect定義的Advisor實例，也就是InstantiationModelAwarePointcutAdvisor實例。
接下去我們看一下BeanFactoryAspectJAdvisorsBuilder的buildAspectJAdvisors函數，它根據@Aspect修飾的切面實例生成對應的Advisor實例。

public List<Advisor> buildAspectJAdvisors() {
    List<String> aspectNames = this.aspectBeanNames;
    // 第一次初始化，synchronized加雙次判斷，和經典單例模式的寫法一樣。
    if (aspectNames == null) {
        synchronized (this) {
            aspectNames = this.aspectBeanNames;
            if (aspectNames == null) {
                // Spring源碼並沒有buildAspectJAdvisorsFirstly函數，爲了方便理解添加。
                // 獲取aspectNames，創建Advisor實例，並且存入aspectFactoryCache緩存 
               return buildAspectJAdvisorsFirstly(); 
           }
        }
    }
            if (aspectNames.isEmpty()) {
        return Collections.emptyList();
    }
    List<Advisor> advisors = new ArrayList<>();
    // 遍歷aspectNames,依次獲取對應的Advisor實例，或者是MetadataAwareAspectInstanceFactory生成的Advisor實例
    for (String aspectName : aspectNames) {
        List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
        // cache可以取到實例，該Advisor是單例的
        if (cachedAdvisors != null) {
            advisors.addAll(cachedAdvisors);
        }
        else {
            // 取得Advisor對應的工廠類實例，再次生成Advisor實例，該Advisor是多實例的。
            MetadataAwareAspectInstanceFactory factory =
 this.aspectFactoryCache.get(aspectName);
            advisors.addAll(this.advisorFactory.getAdvisors(factory));
        }
    }return advisors;
}

buildAspectJAdvisors函數執行時分爲兩種情況，第一個未初始化時，也就是aspectNames爲null時，執行buildAspectJAdvisorsFirstly進行第一次初始化，在這一過程中生成切面名稱列表aspectBeanNames和要返回的Advisor列表，並且將生成的Advisor實例放置到advisorsCache中。
第二種情況則是已經初始化後再次調用，遍歷aspectNames，從advisorsCache取出對應的Advisor實例，或者從advisorsCache取出Advisor對應的工廠類對象，再次生成Advisor實例。

public List<Advisor> buildAspectJAdvisorsFirstly() {
    List<Advisor> advisors = new ArrayList<>();
    List<String> aspectNames = new ArrayList<>();
    // 調用BeanFactoryUtils獲取所有bean的名稱
    String[] beanNames =
 BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
            this.beanFactory, Object.class, true, false);
    for (String beanName : beanNames) {
        if (!isEligibleBean(beanName)) {
            continue;
        }
        // 獲取對應名稱的bean實例
        Class<?> beanType = this.beanFactory.getType(beanName);
        if (beanType == null) {
            continue;
        }
        /**
         * AbstractAspectJAdvisorFactory類的isAspect函數來判斷是否爲切面實例
         * 判斷條件爲是否被@Aspect修飾或者是由AspectJ編程而來。
         */
        if (this.advisorFactory.isAspect(beanType)) {
            aspectNames.add(beanName);
            AspectMetadata amd = new AspectMetadata(beanType, beanName);
            // 切面的屬性爲單例模式
            if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
                MetadataAwareAspectInstanceFactory factory =
                        new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
                // 獲取一個切面中所有定義的Advisor實例。一個切面可以定義多個Advisor。
                List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);                
                // 單例模式，只需要將生成的Advisor添加到緩存
                if (this.beanFactory.isSingleton(beanName)) {
                    this.advisorsCache.put(beanName, classAdvisors);
                }
                // 多實例模式，需要保存工廠類，便於下一次再次生成Advisor實例。
                else {
                    this.aspectFactoryCache.put(beanName, factory);
                }
                advisors.addAll(classAdvisors);
            }
            else {
                MetadataAwareAspectInstanceFactory factory =
                        new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
                this.aspectFactoryCache.put(beanName, factory);
                advisors.addAll(this.advisorFactory.getAdvisors(factory));
            }
        }
    }
    this.aspectBeanNames = aspectNames;return advisors;
}

buildAspectJAdvisorsFirstly函數的邏輯如下：

首先使用BeanFactoryUtils獲取了BeanFactory中所有的BeanName，然後進而使用BeanFactory獲取所有的Bean實例。
遍歷Bean實例，通過ReflectiveAspectJAdvisorFactory的isAspect函數判斷該實例是否爲切面實例，也就是被@Aspect註解修飾的實例。
如果是，則使用ReflectiveAspectJAdvisorFactory，根據切面實例的定義來生成對應的多個Advisor實例，並且將其加入到advisorsCache中。
生成InstantiationModelAwarePointcutAdvisorImpl實例
ReflectiveAspectJAdvisorFactory的getAdvisors函數會獲取@Aspect修飾的實例中所有沒有被@Pointcut修飾的方法，然後調用getAdvisor函數，並且將這些方法作爲參數。

public Advisor getAdvisor(Method candidateAdviceMethod,
 MetadataAwareAspectInstanceFactory aspectInstanceFactory,
        int declarationOrderInAspect, String aspectName) {
           validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
    // 獲得該方法上的切入點條件表達式
    AspectJExpressionPointcut expressionPointcut = getPointcut(
            candidateAdviceMethod,
 aspectInstanceFactory.getAspectMetadata().getAspectClass());
    if (expressionPointcut == null) {
        return null;
    }
    // 生成Advisor實例
    return new
 InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
            this, aspectInstanceFactory, declarationOrderInAspect, aspectName);}
private AspectJExpressionPointcut getPointcut(Method
 candidateAdviceMethod, Class<?> candidateAspectClass) {
    // 獲得該函數上@Pointcut, @Around, @Before, @After, @AfterReturning, @AfterThrowing註解的信息
    AspectJAnnotation<?> aspectJAnnotation =            AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
    // 沒有上述註解，則直接返回
    if (aspectJAnnotation == null) {
        return null;
    }
         AspectJExpressionPointcut ajexp =
            new AspectJExpressionPointcut(candidateAspectClass, new String[0], new
 Class<?>[0]);
    // 獲得註解信息中的切入點判斷表達式
            ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
    if (this.beanFactory != null) {
        ajexp.setBeanFactory(this.beanFactory);
    }return ajexp;
}

getAdvisor函數就是根據作爲參數傳入的切面實例的方法上的註解來生成Advisor實例，也就是InstantiationModelAwarePointcutAdvisorImpl對象。依據方法上的切入點表達式生成AspectJExpressionPointcut。
我們都知道PointcutAdvisor實例中必然有一個Pointcut和Advice實例。修飾在方法上的註解包括：@Pointcut, @Around, @Before, @After, @AfterReturning和@AfterThrowing，所以InstantiationModelAwarePointcutAdvisorImpl會依據不同的不同的註解生成不同的Advice通知。

public
 InstantiationModelAwarePointcutAdvisorImpl(AspectJExpressionPointcut declaredPointcut,
        Method aspectJAdviceMethod, AspectJAdvisorFactory aspectJAdvisorFactory,
        MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
    // .... 省略成員變量的直接賦值
                // 單例模式時
    this.pointcut = this.declaredPointcut;
    this.lazy = false;
    // 按照註解解析 Advice
    this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);}

InstantiationModelAwarePointcutAdvisorImpl的構造函數中會生成對應的Pointcut和Advice。instantiateAdvice函數調用了ReflectiveAspectJAdvisorFactory的getAdvice函數。

// ReflectiveAspectJAdvisorFactorypublic Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
        MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
               Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
    validate(candidateAspectClass);
    // 獲取 Advice 註解
    AspectJAnnotation<?> aspectJAnnotation =
AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
    if (aspectJAnnotation == null) {
        return null;
    }
             // 檢查是否爲AspectJ註解
    if (!isAspect(candidateAspectClass)) {
        throw new AopConfigException("Advice must be declared inside an aspect type: " +
                "Offending method '" + candidateAdviceMethod + "' in class [" +
                candidateAspectClass.getName() + "]");
    }
        AbstractAspectJAdvice springAdvice;
    // 按照註解類型生成相應的 Advice 實現類
    switch (aspectJAnnotation.getAnnotationType()) {
        case AtPointcut:
            if (logger.isDebugEnabled()) {
               logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
            }
            return null;
        case AtAround:
 // @Before 生成 AspectJMethodBeforeAdvice
            springAdvice = new AspectJAroundAdvice(
                    candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            break;
        case AtBefore:
 // @After 生成 AspectJAfterAdvice
            springAdvice = new AspectJMethodBeforeAdvice(
                    candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            break;
        case AtAfter: // @AfterReturning 生成 AspectJAfterAdvice
            springAdvice = new AspectJAfterAdvice(
                    candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            break;
        case AtAfterReturning:
 // @AfterThrowing 生成 AspectJAfterThrowingAdvice
            springAdvice = new AspectJAfterReturningAdvice(
                    candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            AfterReturning afterReturningAnnotation = (AfterReturning)
 aspectJAnnotation.getAnnotation();
            if (StringUtils.hasText(afterReturningAnnotation.returning())) {
                springAdvice.setReturningName(afterReturningAnnotation.returning());
            }
            break;
        case AtAfterThrowing:
 // @Around 生成 AspectJAroundAdvice
            springAdvice = new AspectJAfterThrowingAdvice(
                    candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            AfterThrowing afterThrowingAnnotation = (AfterThrowing)
 aspectJAnnotation.getAnnotation();
            if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
                springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
            }
            break;
        default:
            throw new UnsupportedOperationException(
                    "Unsupported advice type on method: " + candidateAdviceMethod);
    }
 // 配置Advice
    springAdvice.setAspectName(aspectName);
    springAdvice.setDeclarationOrder(declarationOrder);
    // 獲取方法的參數列表方法
    String[] argNames =
 this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
    if (argNames != null) {
        // 設置參數名稱 
       springAdvice.setArgumentNamesFromStringArray(argNames); 
   }
    springAdvice.calculateArgumentBindings();
            return springAdvice;
}

至此，Spring AOP就獲取了容器中所有的Advisor實例，下一步在每個實例初始化完成後，根據這些Advisor的Pointcut切入點進行篩選，獲取合適的Advisor實例，並生成代理實例。
我這兒整理了比較全面的JAVA相關的面試資料，
需要領取面試資料的同學，請加羣：473984645

獲取更多學習資料，可以加羣：473984645或掃描下方二維碼

Spring AOP(二) 修飾者模式、JDK Proxy以及源碼分析

修飾者模式

JDK Proxy

$Proxy反編譯

Java架構進階之Redis內存回收策略

深入剖析HashMap應用原理

redis源碼分析—基本數據結構

Java高併發網絡編程

Java高併發- 鎖的優化及 JVM 對鎖優化所做的努力

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結