@EnableAspectJAutoProxy

@EnableAspectJAutoProxy註解可以用來開啟AOP，那麼就從@EnableAspectJAutoProxy入手學習一下Spring AOP的實現原理。

1. @EnableAspectJAutoProxy匯入了AspectJAutoProxyRegistrar。
2. 定義了proxyTargetClass屬性，表示是否使用CGLIB生成代理物件，預設返回false，預設是使用JDK動態代理建立代理物件的。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)// 匯入了AspectJAutoProxyRegistrar
public @interface EnableAspectJAutoProxy {

    /**
     * 是否使用CGLIB生成代理物件，預設為false，預設是使用JDK動態代理建立代理物件的
     */
    boolean proxyTargetClass() default false;

    /**
     * 是否暴露代理
     */
    boolean exposeProxy() default false;

}
 

AspectJAutoProxyRegistrar

AspectJAutoProxyRegistrar是一個代理註冊器，它實現了ImportBeanDefinitionRegistrar介面，ImportBeanDefinitionRegistrar可以向容器中註冊bean，AspectJAutoProxyRegistrar實現了它應該是為了向容器中註冊bean，那麼看一下registerBeanDefinitions方法裡面註冊了什麼。

在registerBeanDefinitions方法中它呼叫了AopConfigUtils的registerAspectJAnnotationAutoProxyCreatorIfNecessary方法向容器中註冊了自動代理建立器，通過名稱可以看出它與AspectJ註解以及代理建立有關

/**
 * AspectJ自動代理註冊器
 */
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

    /**
     * 註冊BeanDefinitions
     */
    @Override
    public void registerBeanDefinitions(
            AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        // 向容器中註冊代理建立器
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
        AnnotationAttributes enableAspectJAutoProxy =
                AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
        if (enableAspectJAutoProxy != null) {
            // 獲取proxyTargetClass
            if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }
            // 獲取exposeProxy
            if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }
    }
}
 

註冊自動代理建立器

registerAspectJAnnotationAutoProxyCreatorIfNecessary在AopConfigUtils中實現：

1. 定義了一個自動代理建立器集合，是一個List，List裡面的儲存順序代表了優先順序，一共有三種代理建立器
   • InfrastructureAdvisorAutoProxyCreator：優先順序最低
   • AspectJAwareAdvisorAutoProxyCreator：優先順序較InfrastructureAdvisorAutoProxyCreator高
   • AnnotationAwareAspectJAutoProxyCreator：優先順序最高
2. Spring AOP預設使用的是AnnotationAwareAspectJAutoProxyCreator型別的建立器，向容器中註冊的時候會判斷容器中是否已經存在代理建立器：
   • 如果已經存在，從容器中取出建立器，判斷優先順序是否比AnnotationAwareAspectJAutoProxyCreator高，如果低於AnnotationAwareAspectJAutoProxyCreator，則使用AnnotationAwareAspectJAutoProxyCreator進行替換。
   • 如果不存在，直接向容器中註冊AnnotationAwareAspectJAutoProxyCreator型別的bean即可。

public abstract class AopConfigUtils {

    /**
     * 自動代理建立器beanName
     */
    public static final String AUTO_PROXY_CREATOR_BEAN_NAME =
            "org.springframework.aop.config.internalAutoProxyCreator";

    /**
     * 自動建立器集合，是一個List，List裡面的儲存順序代表了優先順序
     */
    private static final List<Class<?>> APC_PRIORITY_LIST = new ArrayList<>(3);

    static {
        // 向List中新增具體的代理建立器
        APC_PRIORITY_LIST.add(InfrastructureAdvisorAutoProxyCreator.class);
        APC_PRIORITY_LIST.add(AspectJAwareAdvisorAutoProxyCreator.class);
        APC_PRIORITY_LIST.add(AnnotationAwareAspectJAutoProxyCreator.class);
    }


    @Nullable
    public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
        // 呼叫下面的registerAspectJAnnotationAutoProxyCreatorIfNecessary方法
        return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
    }

    @Nullable
    public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
            BeanDefinitionRegistry registry, @Nullable Object source) {
        // 這裡可以看到，註冊的是AnnotationAwareAspectJAutoProxyCreator型別的
        return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
    }

    @Nullable
    private static BeanDefinition registerOrEscalateApcAsRequired(
            Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {

        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
        // 如果容器中已經包含名稱為AUTO_PROXY_CREATOR_BEAN_NAME的bean
        if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
            // 從容器中獲取
            BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
            // 如果當前要註冊的bean與容器中已經存在的bean型別不一致
            if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
                // 獲取容器中存在的bean的優先順序
                int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
                // 獲取要註冊的bean的優先順序
                int requiredPriority = findPriorityForClass(cls);
                // 容器中存在的bean的優先順序比當前要註冊的低
                if (currentPriority < requiredPriority) {
                    // 使用當的class進行註冊，也就是AnnotationAwareAspectJAutoProxyCreator
                    apcDefinition.setBeanClassName(cls.getName());
                }
            }
            return null;
        }
        // 建立BeanDefinition
        RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
        beanDefinition.setSource(source);
        beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
        beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        // 向容器中註冊
        registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
        return beanDefinition;
    }
}

AbstractAutoProxyCreator

自動代理建立器AbstractAutoProxyCreator用於建立代理物件，Spring AOP使用的是AnnotationAwareAspectJAutoProxyCreator型別的建立器，它是AbstractAutoProxyCreator的子類，繼承關係如下：

AnnotationAwareAspectJAutoProxyCreator的主要方法都在AbstractAutoProxyCreator中實現，AbstractAutoProxyCreator實現了SmartInstantiationAwareBeanPostProcessor，它是Spring的Bean後置處理器，後置處理器有兩個比較重要的方法：

postProcessBeforeInstantiation：在bean例項化之前執行的方法，如果有自定義的TargetSource則在這個時候就建立代理物件，可以先不管這裡，主要看postProcessAfterInitialization方法。

postProcessAfterInitialization：在bean初始化之後執行的方法，這時候bean已經例項化完畢但是還沒有設定屬性等資訊，呼叫了wrapIfNecessary方法判斷是否有必要生成代理物件，如果不需要建立代理物件直接返回即可，反之需要呼叫getAdvicesAndAdvisorsForBean獲取Advice和Advisor，然後建立代理物件。

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {

    /**
     * 在bean例項化之前執行的方法
     */
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
        Object cacheKey = getCacheKey(beanClass, beanName);

        if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
            if (this.advisedBeans.containsKey(cacheKey)) {
                return null;
            }
            if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
                this.advisedBeans.put(cacheKey, Boolean.FALSE);
                return null;
            }
        }

        // 如果有自定義的TargetSource則建立代理物件
        TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
        if (targetSource != null) {
            if (StringUtils.hasLength(beanName)) {
                this.targetSourcedBeans.add(beanName);
            }
            Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
            // 建立代理物件
            Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }

        return null;
    }

    /**
     * 在bean初始化之後執行的方法
     */
    @Override
    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
        if (bean != null) {
            // 構建快取Key
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (this.earlyProxyReferences.remove(cacheKey) != bean) {
                // 是否有必要建立代理
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }

    /**
     * 是否有必要生成代理物件
     */
    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;
        }
        // 如果是基礎類或者需要跳過則不建立代理物件,將bean加入到advisedBeans中即可
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }

        // 獲取bean的Advices和Advisors
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            // 建立代理
            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;
    }
}

跳過代理物件建立的判斷

跳過代理物件的建立主要通過以下兩個方法判斷的：

1.呼叫isInfrastructureClass判斷是否是基礎類，如果是則跳過代理建立。

2.呼叫shouldSkip方法判斷是否需要跳過建立代理。

isInfrastructureClass

需要注意AOP使用的是AnnotationAwareAspectJAutoProxyCreator作為代理建立器，所以需要先看AnnotationAwareAspectJAutoProxyCreator是否重寫了該方法，實際上它確實重寫isInfrastructureClass方法，在裡面它呼叫了父類的AbstractAutoProxyCreator的isInfrastructureClass和aspectJAdvisorFactory的isAspect進行判斷：

• isInfrastructureClass：如果是Advice、Pointcut、Advisor、AopInfrastructureBean及其子類則跳過建立，這些是Spring的基礎類，不需要進行代理。
• isAspect：是否有Aspect註解並且不是通過Ajc編譯的類則是一個切面。

總結：如果是Advice、Pointcut、Advisor、AopInfrastructureBean及其子類或者bean是一個切面並且不是通過Ajc編譯的則跳過代理建立，並將當前bean的快取key加入到advisedBeans中（wrapIfNecessary中可以看到）。

public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator {

    @Override
    protected boolean isInfrastructureClass(Class<?> beanClass) {
        // 呼叫AbstractAutoProxyCreator的isInfrastructureClass和aspectJAdvisorFactory的isAspect方法判斷,在AbstractAspectJAdvisorFactory中有實現
        return (super.isInfrastructureClass(beanClass) ||
                (this.aspectJAdvisorFactory != null && this.aspectJAdvisorFactory.isAspect(beanClass)));
    }
}

// AbstractAutoProxyCreator
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
    /**
     * 是否是基礎類
     */
    protected boolean isInfrastructureClass(Class<?> beanClass) {
        // 如果是Advice、Pointcut、Advisor、AopInfrastructureBean型別
        boolean retVal = Advice.class.isAssignableFrom(beanClass) ||
                Pointcut.class.isAssignableFrom(beanClass) ||
                Advisor.class.isAssignableFrom(beanClass) ||
                AopInfrastructureBean.class.isAssignableFrom(beanClass);
        if (retVal && logger.isTraceEnabled()) {
            logger.trace("Did not attempt to auto-proxy infrastructure class [" + beanClass.getName() + "]");
        }
        return retVal;
    }

}

// AbstractAspectJAdvisorFactory
public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFactory {
    /**
     * 是否是切面
     */
    @Override
    public boolean isAspect(Class<?> clazz) {
        // 是否有Aspect註解並且不是通過Ajc編譯的類
        return (hasAspectAnnotation(clazz) && !compiledByAjc(clazz));
    }

    // 判斷是否有Aspect註解
    private boolean hasAspectAnnotation(Class<?> clazz) {
        // 是否有Aspect註解
        return (AnnotationUtils.findAnnotation(clazz, Aspect.class) != null);
    }

    /**
     * 是否通過Ajc編譯
     */
    private boolean compiledByAjc(Class<?> clazz) {
        for (Field field : clazz.getDeclaredFields()) {
            if (field.getName().startsWith(AJC_MAGIC)) {
                return true;
            }
        }
        return false;
    }
}

shouldSkip

AnnotationAwareAspectJAutoProxyCreator中重寫的shouldSkip方法具體實現在父類AspectJAwareAdvisorAutoProxyCreator裡面，它獲取所有候選的Advisor進行遍歷，判斷Advisor是否是AspectJPointcutAdvisor型別並且當前的bean與advisor的AspectName切面名稱一致則跳過代理建立：

public class AspectJAwareAdvisorAutoProxyCreator extends AbstractAdvisorAutoProxyCreator {
    /**
     * 是否跳過代理建立
     */
    @Override
    protected boolean shouldSkip(Class<?> beanClass, String beanName) {
        // 獲取候選的Advisors
        List<Advisor> candidateAdvisors = findCandidateAdvisors();
        for (Advisor advisor : candidateAdvisors) {
            // 如果是AspectJPointcutAdvisor型別並且當前的bean與advisor的AspectName切面名稱一致，則跳過代理建立
            if (advisor instanceof AspectJPointcutAdvisor &&
                    ((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
                return true;
            }
        }
        // 呼叫父類的shouldSkip判斷
        return super.shouldSkip(beanClass, beanName);
    }
}

獲取所有的Advice和Advisor

getAdvicesAndAdvisorsForBean方法在AbstractAdvisorAutoProxyCreator中實現，它又呼叫了findEligibleAdvisors方法獲取所有可應用到當前bean的Advisors：

1. 呼叫findCandidateAdvisors獲取所有候選的Advisor，需要注意的是雖然AbstractAdvisorAutoProxyCreator類中實現了findCandidateAdvisors，但是向容器中註冊代理建立器實際的型別是AnnotationAwareAspectJAutoProxyCreator，它重寫了findCandidateAdvisors方法，所以會先進入AnnotationAwareAspectJAutoProxyCreator的findCandidateAdvisors方法，它裡面又呼叫了父類的findCandidateAdvisors，這時候才會進入AbstractAdvisorAutoProxyCreator的方法。
2. 從所有候選的Advisor中過濾出可以適用於當前bean的Advisor，findAdvisorsThatCanApply具體實現邏輯在AopUtils中。

public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator {
    @Override
    @Nullable
    protected Object[] getAdvicesAndAdvisorsForBean(
            Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
        // 呼叫findEligibleAdvisors獲取Advisor
        List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
        if (advisors.isEmpty()) {
            return DO_NOT_PROXY;
        }
        return advisors.toArray();
    }

    /**
     * 獲取Advisor
     */
    protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
        // 1.獲取所有的Advisor，需要注意實際的型別是AnnotationAwareAspectJAutoProxyCreator，所以會先進入它的findCandidateAdvisors方法中
        List<Advisor> candidateAdvisors = findCandidateAdvisors();
        // 2.獲取可以應用到當前bean的Advisor
        List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
        extendAdvisors(eligibleAdvisors);
        if (!eligibleAdvisors.isEmpty()) {
            eligibleAdvisors = sortAdvisors(eligibleAdvisors);
        }
        return eligibleAdvisors;
    }

    /**
     * AbstractAutoProxyCreator中獲取所有候選的Advisors方法，AnnotationAwareAspectJAutoProxyCreator中重寫的findCandidateAdvisors會呼叫這個方法
     */
    protected List<Advisor> findCandidateAdvisors() {
        Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
        // 具體的實現邏輯在advisorRetrievalHelper的findAdvisorBeans
        return this.advisorRetrievalHelper.findAdvisorBeans();
    }

    /**
     * 獲取可以應用到當前bean的Advisor
     */
    protected List<Advisor> findAdvisorsThatCanApply(
            List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {

        ProxyCreationContext.setCurrentProxiedBeanName(beanName);
        try {
            // 獲取可以應用到當前bean的Advisor
            return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
        } finally {
            ProxyCreationContext.setCurrentProxiedBeanName(null);
        }
    }
}

findCandidateAdvisors獲取所有候選的Advisors

AOP使用的是的AnnotationAwareAspectJAutoProxyCreator型別的建立器，它重寫了findCandidateAdvisors方法，方法的處理邏輯如下：

• 呼叫了父類的findCandidateAdvisors方法獲取候選的Advisors，也就是AbstractAdvisorAutoProxyCreator中實現的findCandidateAdvisors方法，這裡的Advisors指的是本身是Advisor型別的bean。=

• 呼叫了buildAspectJAdvisors方法構建Advisors，具體的實現在BeanFactoryAspectJAdvisorsBuilder中， 這裡的Advisors指的是使用了@AspectJ註解定義的切面，Spring會把它包裝成Advisor。

/**
 * AnnotationAwareAspectJAutoProxyCreator
 */
public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator {
    // Advisors構建工廠
    @Nullable
    private BeanFactoryAspectJAdvisorsBuilder aspectJAdvisorsBuilder;

    @Override
    protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        super.initBeanFactory(beanFactory);
        if (this.aspectJAdvisorFactory == null) {
            // 如果為空使用ReflectiveAspectJAdvisorFactory
            this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
        }
        // 初始化BeanFactoryAspectJAdvisorsBuilder,這裡使用的BeanFactoryAspectJAdvisorsBuilderAdapter
        this.aspectJAdvisorsBuilder =
                new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
    }

    protected List<Advisor> findCandidateAdvisors() {
        // 1.呼叫父類的findCandidateAdvisors獲取所有的Advisors，也就是AbstractAdvisorAutoProxyCreator中實現的findCandidateAdvisors方法
        List<Advisor> advisors = super.findCandidateAdvisors();
        if (this.aspectJAdvisorsBuilder != null) {
            // 2.構建Advisors，具體實現在BeanFactoryAspectJAdvisorsBuilder中
            advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
        }
        return advisors;
    }
}

/**
 * AbstractAdvisorAutoProxyCreator
 * 它是實現了findCandidateAdvisors
 */
public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator {
    @Nullable
    private BeanFactoryAdvisorRetrievalHelper advisorRetrievalHelper;

    protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 使用的BeanFactoryAdvisorRetrievalHelperAdapter
        this.advisorRetrievalHelper = new BeanFactoryAdvisorRetrievalHelperAdapter(beanFactory);
    }

    /**
     * 獲取所有的候選Advisors
     *
     * @return the List of candidate Advisors
     */
    protected List<Advisor> findCandidateAdvisors() {
        Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
        // 獲取候選的Advisor，具體的實現邏輯在advisorRetrievalHelper的findAdvisorBeans
        return this.advisorRetrievalHelper.findAdvisorBeans();
    }
}

1. findCandidateAdvisors獲取候選的Advisors

findCandidateAdvisors方法具體的實現在BeanFactoryAdvisorRetrievalHelper中，它從beanFactory中獲取了所有Advisor型別的bean：

public class BeanFactoryAdvisorRetrievalHelper {
    /**
     * 在當前的bean工廠中查詢所有Advisor型別的bean
     */
    public List<Advisor> findAdvisorBeans() {
        // 獲取快取的AdvisorBeanName
        String[] advisorNames = this.cachedAdvisorBeanNames;
        if (advisorNames == null) {
            advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                    this.beanFactory, Advisor.class, true, false);
            this.cachedAdvisorBeanNames = advisorNames;
        }
        // 如果未獲取到
        if (advisorNames.length == 0) {
            return new ArrayList<>();
        }
        List<Advisor> advisors = new ArrayList<>();
        // 遍歷所有的advisorNames
        for (String name : advisorNames) {
            if (isEligibleBean(name)) {
                // 如果bean正在建立中
                if (this.beanFactory.isCurrentlyInCreation(name)) {
                    if (logger.isTraceEnabled()) {
                        logger.trace("Skipping currently created advisor '" + name + "'");
                    }
                } else {
                    try {
                        // 從容器中獲取例項，可以看到這裡獲取的是Advisor型別的bean
                        advisors.add(this.beanFactory.getBean(name, Advisor.class));
                    } catch (BeanCreationException ex) {
                        // 省略了異常處理
                        throw ex;
                    }
                }
            }
        }
        return advisors;
    }
}

2. buildAspectJAdvisors構建Advisor

buildAspectJAdvisors在BeanFactoryAspectJAdvisorsBuilder中實現，這一步用於查詢所有使用@AspectJ註解的bean，並將其包裝成Advisor返回:

（1）從容器中獲取所有的bean，呼叫isEligibleBean方法判斷bean是否符合要求，如果符合進入下一步

（2）呼叫isAspect方法判斷bean是否是一個切面，如果是進入下一步

（3）判斷是否是單例模式

• 如果是，建立BeanFactoryAspectInstanceFactory型別的工廠，呼叫AspectJAdvisorFactory的getAdvisors方法獲取Advisor
• 如果不是單例模式，建立PrototypeAspectInstanceFactory型別的工廠，呼叫AspectJAdvisorFactory的getAdvisors方法獲取Advisor

public class BeanFactoryAspectJAdvisorsBuilder {
  
  	private final AspectJAdvisorFactory advisorFactory;
  
    /**
     *  在當前bean工廠中查詢所有使用@AspectJ註解的bean，幷包裝成Advisor返回
     */
    public List<Advisor> buildAspectJAdvisors() {
        // 獲取所有的切面beanName
        List<String> aspectNames = this.aspectBeanNames;
        // 如果為空
        if (aspectNames == null) {
            synchronized (this) {
                aspectNames = this.aspectBeanNames;
                if (aspectNames == null) {
                    List<Advisor> advisors = new ArrayList<>();
                    aspectNames = new ArrayList<>();
                    // 從容器中獲取所有的beanName
                    String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                            this.beanFactory, Object.class, true, false);
                    for (String beanName : beanNames) {
                        // 判斷是否符合條件，BeanFactoryAspectJAdvisorsBuilderAdapter中實現
                        if (!isEligibleBean(beanName)) {
                            continue;
                        }
                        // 根據BeanName獲取class型別
                        Class<?> beanType = this.beanFactory.getType(beanName);
                        if (beanType == null) {
                            continue;
                        }
                        // 是否是切面
                        if (this.advisorFactory.isAspect(beanType)) {
                            // 新增到aspectNames
                            aspectNames.add(beanName);
                            // 建立Aspect元資料資訊
                            AspectMetadata amd = new AspectMetadata(beanType, beanName);
                            // 單例模式
                            if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
                                // 建立MetadataAwareAspectInstanceFactory
                                MetadataAwareAspectInstanceFactory factory =
                                        new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
                                // 獲取Advisor
                                List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
                                if (this.beanFactory.isSingleton(beanName)) {
                                    this.advisorsCache.put(beanName, classAdvisors);
                                } else {
                                    this.aspectFactoryCache.put(beanName, factory);
                                }
                                advisors.addAll(classAdvisors);
                            } else {
                                // 原型模式
                                if (this.beanFactory.isSingleton(beanName)) {
                                    throw new IllegalArgumentException("Bean with name '" + beanName +
                                            "' is a singleton, but aspect instantiation model is not singleton");
                                }
                                MetadataAwareAspectInstanceFactory factory =
                                        new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
                                this.aspectFactoryCache.put(beanName, factory);
                                advisors.addAll(this.advisorFactory.getAdvisors(factory));
                            }
                        }
                    }
                    this.aspectBeanNames = aspectNames;
                    return advisors;
                }
            }
        }

        if (aspectNames.isEmpty()) {
            return Collections.emptyList();
        }
        List<Advisor> advisors = new ArrayList<>();
        for (String aspectName : aspectNames) {
            List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
            if (cachedAdvisors != null) {
                advisors.addAll(cachedAdvisors);
            } else {
                MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
                advisors.addAll(this.advisorFactory.getAdvisors(factory));
            }
        }
        return advisors;
    }
}

isEligibleBean的判斷

BeanFactoryAspectJAdvisorsBuilderAdapter是AnnotationAwareAspectJAutoProxyCreator的內部類，它繼承了BeanFactoryAspectJAdvisorsBuilder並重寫了isEligibleBean方法：

public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator {

    private class BeanFactoryAspectJAdvisorsBuilderAdapter extends BeanFactoryAspectJAdvisorsBuilder {

        @Override
        protected boolean isEligibleBean(String beanName) {
            // 呼叫isEligibleAspectBean
            return AnnotationAwareAspectJAutoProxyCreator.this.isEligibleAspectBean(beanName);
        }
    }

    /**
     * 校驗給定的切面是否符合要求
     */
    protected boolean isEligibleAspectBean(String beanName) {
        if (this.includePatterns == null) {
            return true;
        }
        else {
            for (Pattern pattern : this.includePatterns) {
                // 通過includePatterns進行匹配
                if (pattern.matcher(beanName).matches()) {
                    return true;
                }
            }
            return false;
        }
    }
}

isAspect的判斷

前面在講跳過代理物件的建立時已經看到isAspect的實現邏輯，如果使用了Aspect註解並且不是通過Ajc進行編譯的，則判定為切面：

// AbstractAspectJAdvisorFactory
public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFactory {

    /**
     * 是否是切面
     */
    @Override
    public boolean isAspect(Class<?> clazz) {
        // 是否有Aspect註解並且不是通過Ajc編譯的類
        return (hasAspectAnnotation(clazz) && !compiledByAjc(clazz));
    }

    // 判斷是否有Aspect註解
    private boolean hasAspectAnnotation(Class<?> clazz) {
        // 是否有Aspect註解
        return (AnnotationUtils.findAnnotation(clazz, Aspect.class) != null);
    }

    /**
     * 是否通過Ajc編譯
     */
    private boolean compiledByAjc(Class<?> clazz) {
        // 
        for (Field field : clazz.getDeclaredFields()) {
            if (field.getName().startsWith(AJC_MAGIC)) {
                return true;
            }
        }
        return false;
    }
}

AspectJAdvisorFactory獲取Advisor

AspectJAdvisorFactory是一個Advisor工廠，它的繼承關係如下：

AnnotationAwareAspectJAutoProxyCreator在初始化bean工廠的方法中，對AspectJAdvisorFactory進行了判斷，則如果為空使用ReflectiveAspectJAdvisorFactory：

public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator {
    // Advisors構建工廠
    @Nullable
    private BeanFactoryAspectJAdvisorsBuilder aspectJAdvisorsBuilder;

    @Override
    protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        super.initBeanFactory(beanFactory);
        if (this.aspectJAdvisorFactory == null) {
            // 如果為空使用ReflectiveAspectJAdvisorFactory
            this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
        }
        // 初始化BeanFactoryAspectJAdvisorsBuilder
        this.aspectJAdvisorsBuilder =
                new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
    }    
}

ReflectiveAspectJAdvisorFactory中實現了getAdvisor方法：

1. getAdvisorMethods獲取Advisor方法（也就是獲取通知），具體是根據方法上是否有Pointcut註解來判斷的，如果沒有Pointcut註解則判定為是Advisor方法
2. 呼叫getAdvisor方法將第1步中獲取到的Advisor方法構建為Advisor物件

public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFactory implements Serializable {
    @Override
    public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
        // 獲取Aspect類資訊
        Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
        String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
        validate(aspectClass);

        //  裝飾模式
        MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
                new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);

        List<Advisor> advisors = new ArrayList<>();
        // 獲取Advisor方法，也就是獲取沒有使用@Pointcut註解的方法
        for (Method method : getAdvisorMethods(aspectClass)) {
            // 將方法構建為Advisor物件
            Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
            if (advisor != null) {
                advisors.add(advisor);
            }
        }

        // If it's a per target aspect, emit the dummy instantiating aspect.
        if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
            Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
            advisors.add(0, instantiationAdvisor);
        }

        // Find introduction fields.
        for (Field field : aspectClass.getDeclaredFields()) {
            Advisor advisor = getDeclareParentsAdvisor(field);
            if (advisor != null) {
                advisors.add(advisor);
            }
        }

        return advisors;
    }

    // 獲取Advisor方法，也就是獲取切面中沒有被使用Pointcut註解的方法
    private List<Method> getAdvisorMethods(Class<?> aspectClass) {
        final List<Method> methods = new ArrayList<>();
        ReflectionUtils.doWithMethods(aspectClass, method -> {
            // 判斷是否有Pointcut註解，如果沒有則判定為是Advisor方法加入結果集中
            if (AnnotationUtils.getAnnotation(method, Pointcut.class) == null) {
                methods.add(method);
            }
        }, ReflectionUtils.USER_DECLARED_METHODS);
        if (methods.size() > 1) {
            methods.sort(METHOD_COMPARATOR);
        }
        return methods;
    }
}

構建Advisor的具體實現

ReflectiveAspectJAdvisorFactory的getAdvisor方法用於將方法封裝為Advisor物件，可以看到第一個引數叫candidateAdviceMethod（候選的通知方法），上一步中傳入的是獲取到的Advisor方法，所以Spring中Advisor方法指的就是使用了通知註解的方法，getAdvisor方法主要做了如下操作：

1. 構建AspectJExpressionPointcut切點表示式物件
   • 從通知方法上獲取切面相關注解，具體是通過判斷方法上是否有Pointcut、Around、Before、After、AfterReturning、AfterThrowing註解實現的
   • 從切面註解中獲取設定的切點表示式，用於之後判斷方法是否匹配使用，然後建立AspectJExpressionPointcut物件並設定獲取到的切點表示式
2. 將當前的Advisor方法、AspectJExpressionPointcut物件等資訊封裝為InstantiationModelAwarePointcutAdvisorImpl返回，它是一個Advisor

public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFactory implements Serializable {

    // 將Advisor方法構建為Advisor物件
    @Override
    @Nullable
    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;
        }
        // 封裝為InstantiationModelAwarePointcutAdvisorImpl
        return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
                this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
    }

    // 獲取切點表示式
    @Nullable
    private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
        // 獲取AspectJ註解，具體是通過判斷方法上是否有Pointcut、Around、Before、After、AfterReturning、AfterThrowing註解實現的
        AspectJAnnotation<?> aspectJAnnotation =
                AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
        if (aspectJAnnotation == null) {
            return null;
        }
        // 建立AspectJExpressionPointcut
        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;
    }

}

// AbstractAspectJAdvisorFactory
public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFactory {

    private static final Class<?>[] ASPECTJ_ANNOTATION_CLASSES = new Class<?>[]{
            Pointcut.class, Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class};

    /**
     * 判斷是否有AspectJ相關注解
     */
    @SuppressWarnings("unchecked")
    @Nullable
    protected static AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) {
        // 判斷方法上是否有Pointcut、Around、Before、After、AfterReturning、AfterThrowing註解
        for (Class<?> clazz : ASPECTJ_ANNOTATION_CLASSES) {
            AspectJAnnotation<?> foundAnnotation = findAnnotation(method, (Class<Annotation>) clazz);
            if (foundAnnotation != null) {
                return foundAnnotation;
            }
        }
        return null;
    }
}

InstantiationModelAwarePointcutAdvisorImpl封裝切面

InstantiationModelAwarePointcutAdvisorImpl是一個Adviosr，它對Aspect切面進行了封裝，裡面引用了Advice、Pointcut等切面相關資訊，在建構函式的最後，呼叫了instantiateAdvice對通知進行增強處理，也就是根據不同的通知型別，將其包裝為不同的Advice物件，具體的實現在ReflectiveAspectJAdvisorFactory中：

final class InstantiationModelAwarePointcutAdvisorImpl
        implements InstantiationModelAwarePointcutAdvisor, AspectJPrecedenceInformation, Serializable {
    // 切點表示式，用於匹配方法是否需要進行攔截
    private final AspectJExpressionPointcut declaredPointcut;

    // 通知
    private transient Method aspectJAdviceMethod;

    // AspectJAdvisorFactory
    private final AspectJAdvisorFactory aspectJAdvisorFactory;

    private final MetadataAwareAspectInstanceFactory aspectInstanceFactory;

    private final int declarationOrder;

    // 切面名稱
    private final String aspectName;

    // 切點
    private final Pointcut pointcut; 

    private final boolean lazy;

    // 通知
    @Nullable
    private Advice instantiatedAdvice; 

    @Nullable
    private Boolean isBeforeAdvice;

    @Nullable
    private Boolean isAfterAdvice;


    public InstantiationModelAwarePointcutAdvisorImpl(AspectJExpressionPointcut declaredPointcut,
                                                      Method aspectJAdviceMethod, AspectJAdvisorFactory aspectJAdvisorFactory,
                                                      MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {

        this.declaredPointcut = declaredPointcut;
        // 設定切面的類資訊
        this.declaringClass = aspectJAdviceMethod.getDeclaringClass();
        // 設定方法名稱
        this.methodName = aspectJAdviceMethod.getName();
        this.parameterTypes = aspectJAdviceMethod.getParameterTypes();
        // 通知
        this.aspectJAdviceMethod = aspectJAdviceMethod;
        // AspectJAdvisorFactory
        this.aspectJAdvisorFactory = aspectJAdvisorFactory;
        this.aspectInstanceFactory = aspectInstanceFactory;
        this.declarationOrder = declarationOrder;
        // 切面名稱
        this.aspectName = aspectName;

        if (aspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
            Pointcut preInstantiationPointcut = Pointcuts.union(
                    aspectInstanceFactory.getAspectMetadata().getPerClausePointcut(), this.declaredPointcut);
            this.pointcut = new PerTargetInstantiationModelPointcut(
                    this.declaredPointcut, preInstantiationPointcut, aspectInstanceFactory);
            this.lazy = true;
        } else {
            // A singleton aspect.
            this.pointcut = this.declaredPointcut;
            this.lazy = false;
            // 增強處理
            this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
        }
    }

    private Advice instantiateAdvice(AspectJExpressionPointcut pointcut) {
        // 呼叫ReflectiveAspectJAdvisorFactory獲取Advice
        Advice advice = this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pointcut,
                this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
        return (advice != null ? advice : EMPTY_ADVICE);
    }
}

ReflectiveAspectJAdvisorFactory

ReflectiveAspectJAdvisorFactory中的getAdvice方法中可以看到對通知進行了判斷，不同的通知使用不同的包裝類：

• 環繞通知，使用AspectJAroundAdvice
• 前置通知，使用AspectJMethodBeforeAdvice
• 後置通知，使用AspectJAfterAdvice
• 返回通知，使用AspectJAfterReturningAdvice
• 異常通知，使用AspectJAfterThrowingAdvice

public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFactory implements Serializable {
    @Override
    @Nullable
    public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
                            MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {

        Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
        validate(candidateAspectClass);
        // 獲取AspectJAnnotation
        AspectJAnnotation<?> aspectJAnnotation =
                AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
        if (aspectJAnnotation == null) {
            return null;
        }

        // 再次校驗是否是切面
        if (!isAspect(candidateAspectClass)) {
            throw new AopConfigException("Advice must be declared inside an aspect type: " +
                    "Offending method '" + candidateAdviceMethod + "' in class [" +
                    candidateAspectClass.getName() + "]");
        }

        if (logger.isDebugEnabled()) {
            logger.debug("Found AspectJ method: " + candidateAdviceMethod);
        }

        AbstractAspectJAdvice springAdvice;
        // 判斷通知型別
        switch (aspectJAnnotation.getAnnotationType()) {
            case AtPointcut: // 如果是一個切點
                if (logger.isDebugEnabled()) {
                    logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
                }
                return null;
            case AtAround: // 環繞通知，使用AspectJAroundAdvice封裝
                springAdvice = new AspectJAroundAdvice(
                        candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
                break;
            case AtBefore:// 前置通知，使用AspectJMethodBeforeAdvice
                springAdvice = new AspectJMethodBeforeAdvice(
                        candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
                break;
            case AtAfter:// 後置通知，使用AspectJAfterAdvice
                springAdvice = new AspectJAfterAdvice(
                        candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
                break;
            case AtAfterReturning:// 返回通知，使用AspectJAfterReturningAdvice
                springAdvice = new AspectJAfterReturningAdvice(
                        candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
                AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
                if (StringUtils.hasText(afterReturningAnnotation.returning())) {
                    springAdvice.setReturningName(afterReturningAnnotation.returning());
                }
                break;
            case AtAfterThrowing:// 異常通知，使用AspectJAfterThrowingAdvice
                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);
        }

        // Now to configure the advice...
        springAdvice.setAspectName(aspectName);
        springAdvice.setDeclarationOrder(declarationOrder);
        String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
        if (argNames != null) {
            springAdvice.setArgumentNamesFromStringArray(argNames);
        }
        springAdvice.calculateArgumentBindings();

        return springAdvice;
    }
}

findAdvisorsThatCanApply獲取可以應用到當前bean的Advisor

上一節中獲取到了所有的Advisor，接下來要過濾出可以應用到當前bean的Advisor，findAdvisorsThatCanApply在AopUtils中實現：

public abstract class AopUtils {

    public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
        if (candidateAdvisors.isEmpty()) {
            return candidateAdvisors;
        }
        List<Advisor> eligibleAdvisors = new ArrayList<>();
        for (Advisor candidate : candidateAdvisors) {
            // 是否是IntroductionAdvisor並且canApply,加入到eligibleAdvisors中
            if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
                eligibleAdvisors.add(candidate);
            }
        }
        boolean hasIntroductions = !eligibleAdvisors.isEmpty();
        // 再次遍歷候選的Advisor
        for (Advisor candidate : candidateAdvisors) {
            // 如果是IntroductionAdvisor，上面已經對IntroductionAdvisor進行了處理，這裡continue繼續下一個
            if (candidate instanceof IntroductionAdvisor) {
                // already processed
                continue;
            }
            // 呼叫canApply方法判斷
            if (canApply(candidate, clazz, hasIntroductions)) {
                eligibleAdvisors.add(candidate);
            }
        }
        return eligibleAdvisors;
    }
}

核心的邏輯在canApply方法中：

• 根據切點Pointcut的getClassFilter方法對類進行匹配，判斷targetClass目標類是否與切點匹配

• 從切點獲取MethodMatcher方法匹配器，通過MethodMatcher對目標類中的每一個方法進行匹配，也就是使用切點表示式對方法進行匹配，判斷方法是否需要攔截。

public abstract class AopUtils {
  
    /**
     * 是否可以應用到bean
     */
    public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
        if (advisor instanceof IntroductionAdvisor) {
            return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
        }
        else if (advisor instanceof PointcutAdvisor) {
            PointcutAdvisor pca = (PointcutAdvisor) advisor;
            // 繼續呼叫canApply
            return canApply(pca.getPointcut(), targetClass, hasIntroductions);
        }
        else {
            // It doesn't have a pointcut so we assume it applies.
            return true;
        }
    }
    /**
     * 是否可以應用到bean
     */
    public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
        Assert.notNull(pc, "Pointcut must not be null");
        // 通過切點進行匹配，先判斷類是否匹配
        if (!pc.getClassFilter().matches(targetClass)) {
            return false;
        }
        // 從切點中獲取方法匹配器
        MethodMatcher methodMatcher = pc.getMethodMatcher();
        if (methodMatcher == MethodMatcher.TRUE) {
            // No need to iterate the methods if we're matching any method anyway...
            return true;
        }
        IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
        // 如果是IntroductionAwareMethodMatcher
        if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
            introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
        }
        Set<Class<?>> classes = new LinkedHashSet<>();
        if (!Proxy.isProxyClass(targetClass)) {
            classes.add(ClassUtils.getUserClass(targetClass));
        }
        // 獲取類的所有介面
        classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));

        for (Class<?> clazz : classes) {
            // 獲取類中的所有方法
            Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
            // 遍歷方法
            for (Method method : methods) {
                if (introductionAwareMethodMatcher != null ?
                        introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
                        methodMatcher.matches(method, targetClass)) { // 呼叫方法的matches進行匹配
                    return true;
                }
            }
        }
        return false;
    }
}

建立代理物件

上一節中已經獲取到了可以應用到當前bean的Advisor，接下來就可以建立代理物件了，由於篇幅原因，建立代理的過程將另起一篇文章。