Spring中自動建立代理器

一、AbstractAutoProxyCreator

   該類繼承關係如代碼所示：

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {

首先，它繼承了ProxyProcessorSupport，查看該類：

// 顯然，它是個ProxyConfig 擁有AOP的基本配置
public class ProxyProcessorSupport extends ProxyConfig implements Ordered, BeanClassLoaderAware, AopInfrastructureBean {
    ...
    // 這是它最重要的一個方法：就是把該bean全部的實現的接口 都做用在ProxyFactory 上 固然是有過濾得
    protected void evaluateProxyInterfaces(Class<?> beanClass, ProxyFactory proxyFactory) {
        // 拿到該類全部實現的接口們~~~~
        Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, getProxyClassLoader());

        // 標記：是否存在「有問題的」代理接口  默認是false
        boolean hasReasonableProxyInterface = false;
        for (Class<?> ifc : targetInterfaces) {
            
            //判斷這些接口是不是「有問題的」：既咱們須要處理的
            if (!isConfigurationCallbackInterface(ifc) && !isInternalLanguageInterface(ifc) &&
                    ifc.getMethods().length > 0) {
                hasReasonableProxyInterface = true;
                break;
            }
        }
        
        // 說明除開哪些接口外，但凡是有一個有用的接口，就add進去（這樣就會採用JDK的動態代理了）
        if (hasReasonableProxyInterface) {
            for (Class<?> ifc : targetInterfaces) {
                proxyFactory.addInterface(ifc);
            }
        }
        // 不然直接採用CGLIB
        else {
            proxyFactory.setProxyTargetClass(true);
        }
    }
    // InitializingBean...Aware接口的子接口等等這些回調性質的接口
    protected boolean isConfigurationCallbackInterface(Class<?> ifc) {
        return (InitializingBean.class == ifc || DisposableBean.class == ifc || Closeable.class == ifc ||
                AutoCloseable.class == ifc || ObjectUtils.containsElement(ifc.getInterfaces(), Aware.class));
    }
    // 接口名稱爲這些的  也就是spring aop本身的東西
    protected boolean isInternalLanguageInterface(Class<?> ifc) {
        return (ifc.getName().equals("groovy.lang.GroovyObject") ||
                ifc.getName().endsWith(".cglib.proxy.Factory") ||
                ifc.getName().endsWith(".bytebuddy.MockAccess"));
    }
    
}

裏面最重要的方法是evaluateProxyInterfaces()，在AbstractAutoProxyCreator類中會調用該方法，判斷使用哪一種代理方式。

接下來將AbstractAutoProxyCreator貼在以下：

 

    public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {

    /**
     * Convenience constant for subclasses: Return value for "do not proxy".
     * @see #getAdvicesAndAdvisorsForBean
     */
    protected static final Object[] DO_NOT_PROXY = null;

    /**
     * Convenience constant for subclasses: Return value for
     * "proxy without additional interceptors, just the common ones".
     * @see #getAdvicesAndAdvisorsForBean
     */
    protected static final Object[] PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS = new Object[0];


    /** Logger available to subclasses */
    protected final Log logger = LogFactory.getLog(getClass());

    /** Default is global AdvisorAdapterRegistry */
    private AdvisorAdapterRegistry advisorAdapterRegistry = GlobalAdvisorAdapterRegistry.getInstance();

    /**
     * Indicates whether or not the proxy should be frozen. Overridden from super
     * to prevent the configuration from becoming frozen too early.
     */
    private boolean freezeProxy = false;

    /** Default is no common interceptors */
    private String[] interceptorNames = new String[0];

    private boolean applyCommonInterceptorsFirst = true;

    private TargetSourceCreator[] customTargetSourceCreators;

    private BeanFactory beanFactory;

    private final Set<String> targetSourcedBeans =
            Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));

    private final Map<Object, Object> earlyProxyReferences = new ConcurrentHashMap<Object, Object>(16);

    private final Map<Object, Class<?>> proxyTypes = new ConcurrentHashMap<Object, Class<?>>(16);

    private final Map<Object, Boolean> advisedBeans = new ConcurrentHashMap<Object, Boolean>(256);


    /**
     * Set whether or not the proxy should be frozen, preventing advice
     * from being added to it once it is created.
     * <p>Overridden from the super class to prevent the proxy configuration
     * from being frozen before the proxy is created.
     */
    @Override
    public void setFrozen(boolean frozen) {
        this.freezeProxy = frozen;
    }

    @Override
    public boolean isFrozen() {
        return this.freezeProxy;
    }

    /**
     * Specify the {@link AdvisorAdapterRegistry} to use.
     * <p>Default is the global {@link AdvisorAdapterRegistry}.
     * @see org.springframework.aop.framework.adapter.GlobalAdvisorAdapterRegistry
     */
    public void setAdvisorAdapterRegistry(AdvisorAdapterRegistry advisorAdapterRegistry) {
        this.advisorAdapterRegistry = advisorAdapterRegistry;
    }

    /**
     * Set custom {@code TargetSourceCreators} to be applied in this order.
     */
    public void setCustomTargetSourceCreators(TargetSourceCreator... targetSourceCreators) {
        this.customTargetSourceCreators = targetSourceCreators;
    }

    /**
     * Set the common interceptors. These must be bean names in the current factory.
     * They can be of any advice or advisor type Spring supports.
     */
    public void setInterceptorNames(String... interceptorNames) {
        this.interceptorNames = interceptorNames;
    }

    /**
     * Set whether the common interceptors should be applied before bean-specific ones.
     * Default is "true"; else, bean-specific interceptors will get applied first.
     */
    public void setApplyCommonInterceptorsFirst(boolean applyCommonInterceptorsFirst) {
        this.applyCommonInterceptorsFirst = applyCommonInterceptorsFirst;
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        this.beanFactory = beanFactory;
    }

    /**
     * Return the owning {@link BeanFactory}.
     * May be {@code null}, as this post-processor doesn't need to belong to a bean factory.
     */
    protected BeanFactory getBeanFactory() {
        return this.beanFactory;
    }


    @Override
    public Class<?> predictBeanType(Class<?> beanClass, String beanName) {
        if (this.proxyTypes.isEmpty()) {
            return null;
        }
        Object cacheKey = getCacheKey(beanClass, beanName);
        return this.proxyTypes.get(cacheKey);
    }

    @Override
    public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }
    // getEarlyBeanReference()它是爲了解決單例bean之間的循環依賴問題，提早將代理對象暴露出去
    @Override
    public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        this.earlyProxyReferences.put(cacheKey, bean);
        return wrapIfNecessary(bean, beanName, cacheKey);
    }

    // 這個很重要，在Bean實例化以前，先給一個機會，看看緩存裏有木有，有就直接返回得了
    // 簡單的說：其主要目的在於若是用戶使用了自定義的TargetSource對象，則直接使用該對象生成目標對象，而不會使用Spring的默認邏輯生成目標對象
    // 而且這裏會判斷各個切面邏輯是否能夠應用到當前bean上,若是是基礎設施類或者能夠進行跳過的會直接返回null
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        Object cacheKey = getCacheKey(beanClass, beanName);

        if (beanName == null || !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;
            }
        }

        // Create proxy here if we have a custom TargetSource.
        if (beanName != null) {
            TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
            if (targetSource != null) {
                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 boolean postProcessAfterInstantiation(Object bean, String beanName) {
        return true;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }

    /**
     * Create a proxy with the configured interceptors if the bean is
     *  earlyProxyReferences緩存：該緩存用於保存已經建立過代理對象的cachekey，**避免重複建立**
     *  最重要的是方法：wrapIfNecessary(bean, beanName, cacheKey)
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean != null) {
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (this.earlyProxyReferences.remove(cacheKey) != bean) {
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }


    /**
     * Build a cache key for the given bean class and bean name.
     */
    protected Object getCacheKey(Class<?> beanClass, String beanName) {
        if (StringUtils.hasLength(beanName)) {
            return (FactoryBean.class.isAssignableFrom(beanClass) ?
                    BeanFactory.FACTORY_BEAN_PREFIX + beanName : beanName);
        }
        else {
            return beanClass;
        }
    }

    /**
     * Wrap the given bean if necessary, i.e. if it is eligible for being proxied.
     */
    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        // 若此Bean已經在targetSourcedBeans裏，說明已經被代理過，那就直接返回便可
        // (postProcessBeforeInstantiation()中成功建立的代理對象都會將beanName加入到targetSourceBeans中)
        if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        }
        // 若是該Bean基礎框架Bean或者免代理得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;
        }

        // Create proxy if we have advice.
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        if (specificInterceptors != DO_NOT_PROXY) {
            // 緩存起來，賦值爲true，說明此key是被代理了的
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            // 建立這個代理對象
            Object proxy = createProxy(
                    bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
            // 不須要代理，也把這種不須要代理的對象給與緩存起來  賦值爲false
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }

        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

    /**
     * 判斷是不是基礎設施類
     */
    protected boolean isInfrastructureClass(Class<?> beanClass) {
        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;
    }

    /**
     * 判斷是否須要跳過，具體由子類進行實現
     */
    protected boolean shouldSkip(Class<?> beanClass, String beanName) {
        return false;
    }

    /**
     * 這個方法也很重要，若咱們本身要實現一個TargetSourceCreator ，就能夠實現咱們自定義的邏輯了
     * 若是沒有自定義的customTargetSourceCreators，那麼就會返回null
     * beanFactory不能爲null，並且其中必須包含beanName的Bean
     */
    protected TargetSource getCustomTargetSource(Class<?> beanClass, String beanName) {
        // We can't create fancy target sources for directly registered singletons.
        if (this.customTargetSourceCreators != null &&
                this.beanFactory != null && this.beanFactory.containsBean(beanName)) {
            for (TargetSourceCreator tsc : this.customTargetSourceCreators) {
                TargetSource ts = tsc.getTargetSource(beanClass, beanName);
                if (ts != null) {
                    // Found a matching TargetSource.
                    if (logger.isDebugEnabled()) {
                        logger.debug("TargetSourceCreator [" + tsc +
                                "] found custom TargetSource for bean with name '" + beanName + "'");
                    }
                    return ts;
                }
            }
        }
        // No custom TargetSource found.
        return null;
    }

    /**
     * Create an AOP proxy for the given bean.
     */
    protected Object createProxy(
            Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {

        if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
            AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
        }

        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.copyFrom(this);
        // 看看是不是基於類的代理（CGLIB），若表面上是基於接口的代理  咱們還須要進一步去檢測
        if (!proxyFactory.isProxyTargetClass()) {
            // shouldProxyTargetClass方法用於判斷是否應該使用targetClass類而不是接口來進行代理
            if (shouldProxyTargetClass(beanClass, beanName)) {
                proxyFactory.setProxyTargetClass(true);
            }
            else {
                //調用的是父類ProxyProcessorSupport方法，爲proxyFactory添加接口，沒有接口直接設置setProxyTargetClass(true)
                evaluateProxyInterfaces(beanClass, proxyFactory);
            }
        }
        // buildAdvisors：整理合並獲得最終的advisors
        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        proxyFactory.addAdvisors(advisors);
        proxyFactory.setTargetSource(targetSource);
        // 這個方法是交給子類的，子類能夠繼續去定製此proxyFactory
        customizeProxyFactory(proxyFactory);

        proxyFactory.setFrozen(this.freezeProxy);
        if (advisorsPreFiltered()) {
            proxyFactory.setPreFiltered(true);
        }

        return proxyFactory.getProxy(getProxyClassLoader());
    }
    /**
     * Determine whether the given bean should be proxied with its target class rather than its interfaces.
     * <p>Checks the {@link AutoProxyUtils#PRESERVE_TARGET_CLASS_ATTRIBUTE "preserveTargetClass" attribute}
     * of the corresponding bean definition.
     */
    protected boolean shouldProxyTargetClass(Class<?> beanClass, String beanName) {
        return (this.beanFactory instanceof ConfigurableListableBeanFactory &&
                AutoProxyUtils.shouldProxyTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName));
    }

    /**
     * Return whether the Advisors returned by the subclass are pre-filtered
     * to match the bean's target class already, allowing the ClassFilter check
     * to be skipped when building advisors chains for AOP invocations.
     * <p>Default is {@code false}. Subclasses may override this if they
     * will always return pre-filtered Advisors.
     */
    protected boolean advisorsPreFiltered() {
        return false;
    }

    /**
     * Determine the advisors for the given bean, including the specific interceptors
     * as well as the common interceptor, all adapted to the Advisor interface.
     * 將specificInterceptors中攔截器和commonInterceptors都轉換成Advisor的接口類型
     */
    protected Advisor[] buildAdvisors(String beanName, Object[] specificInterceptors) {
        // Handle prototypes correctly...
        Advisor[] commonInterceptors = resolveInterceptorNames();

        List<Object> allInterceptors = new ArrayList<Object>();
        if (specificInterceptors != null) {
            allInterceptors.addAll(Arrays.asList(specificInterceptors));
            if (commonInterceptors.length > 0) {
                if (this.applyCommonInterceptorsFirst) {
                    allInterceptors.addAll(0, Arrays.asList(commonInterceptors));
                }
                else {
                    allInterceptors.addAll(Arrays.asList(commonInterceptors));
                }
            }
        }
        if (logger.isDebugEnabled()) {
            int nrOfCommonInterceptors = commonInterceptors.length;
            int nrOfSpecificInterceptors = (specificInterceptors != null ? specificInterceptors.length : 0);
            logger.debug("Creating implicit proxy for bean '" + beanName + "' with " + nrOfCommonInterceptors +
                    " common interceptors and " + nrOfSpecificInterceptors + " specific interceptors");
        }

        Advisor[] advisors = new Advisor[allInterceptors.size()];
        for (int i = 0; i < allInterceptors.size(); i++) {
            advisors[i] = this.advisorAdapterRegistry.wrap(allInterceptors.get(i));
        }
        return advisors;
    }

    /**
     * Resolves the specified interceptor names to Advisor objects.
     */
    private Advisor[] resolveInterceptorNames() {
        ConfigurableBeanFactory cbf = (this.beanFactory instanceof ConfigurableBeanFactory ?
                (ConfigurableBeanFactory) this.beanFactory : null);
        List<Advisor> advisors = new ArrayList<Advisor>();
        for (String beanName : this.interceptorNames) {
            if (cbf == null || !cbf.isCurrentlyInCreation(beanName)) {
                Object next = this.beanFactory.getBean(beanName);
                advisors.add(this.advisorAdapterRegistry.wrap(next));
            }
        }
        return advisors.toArray(new Advisor[advisors.size()]);
    }

    /**
     * Subclasses may choose to implement this: for example,
     * to change the interfaces exposed.
     */
    protected void customizeProxyFactory(ProxyFactory proxyFactory) {
    }


    /**
     * Return whether the given bean is to be proxied, what additional
     * advices (e.g. AOP Alliance interceptors) and advisors to apply.
     */
    protected abstract Object[] getAdvicesAndAdvisorsForBean(
            Class<?> beanClass, String beanName, TargetSource customTargetSource) throws BeansException;

}

二、AbstractAdvisorAutoProxyCreator 

該類繼承了AbstractAutoProxyCreator，它的核心方法是實現了父類的：getAdvicesAndAdvisorsForBean來獲取Advisor們

public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator {

    // 這個類是重點，已經在隨機中寫過，主要就是從工廠中獲取全部的Advisor
    @Nullable
    private BeanFactoryAdvisorRetrievalHelper advisorRetrievalHelper;

    // 重寫了setBeanFactory方法，事須要保證bean工廠必須是ConfigurableListableBeanFactory
    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        super.setBeanFactory(beanFactory);
        if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
            throw new IllegalArgumentException(
                    "AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
        }
        // 就這一句話：this.advisorRetrievalHelper = new BeanFactoryAdvisorRetrievalHelperAdapter(beanFactory)
        // 對Helper進行初始化，找advisor最終事委託給他了的
        // BeanFactoryAdvisorRetrievalHelperAdapter繼承自BeanFactoryAdvisorRetrievalHelper,爲私有內部類，主要重寫了isEligibleBean（）方法，調用.this.isEligibleAdvisorBean(beanName)方法
        initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
    }

    // 這是複寫父類的方法，也是實現代理方式。找到做用在這個Bean裏面的切點方法
    // 固然 最終最終事委託給BeanFactoryAdvisorRetrievalHelper去作的
    @Override
    @Nullable
    protected Object[] getAdvicesAndAdvisorsForBean(
            Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {

        // findEligibleAdvisors：顯然這個是具體的實現方法了。
        // eligible：合格的  合適的
        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) {

        // 首先找出全部的候選的Advisors，（根據名字判斷）實現見下面~~~~
        List<Advisor> candidateAdvisors = findCandidateAdvisors();
        // 對上面找到的候選的Advisors們，進行過濾操做~~~  看看Advisor可否被用在Bean上（根據Advisor的PointCut判斷）
        // 主要依賴於AopUtils.findAdvisorsThatCanApply()方法  在工具類講解中有詳細分析的
        // 邏輯簡單概述爲：看目標類是否是符合代理對象的條件，若是符合就把Advisor加到集合中，最後返回集合
        // 簡單的說：它就是會根據ClassFilter和MethodMatcher等等各類匹配。（但凡只有有一個方法被匹配上了，就會給他建立代理類了）
        // 方法用的ReflectionUtils.getAllDeclaredMethods，**所以哪怕是私有方法，匹配上都會給建立的代理對象，這點務必要特別特別的注意**
        List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);

        //提供一個鉤子。子類能夠複寫此方法  而後對eligibleAdvisors進行處理（增長/刪除/修改等等）
        // AspectJAwareAdvisorAutoProxyCreator提供了實現
        extendAdvisors(eligibleAdvisors);

        // 若是有，那就排序
        if (!eligibleAdvisors.isEmpty()) {
            // 默認排序方式：AnnotationAwareOrderComparator.sort()排序  這個排序和Order接口有關~~~
            // 可是子類：AspectJAwareAdvisorAutoProxyCreator有複寫此排序方法，須要特別注意~~~
            eligibleAdvisors = sortAdvisors(eligibleAdvisors);
        }
        return eligibleAdvisors;
    }


    // 找到候選的Advisor們~~~~   抽象類本身的實現，是直接把這件事委託給了advisorRetrievalHelper
    // 關於它的具體邏輯  後文問詳細分析  畢竟屬於核心邏輯
    // AnnotationAwareAspectJAutoProxyCreator對它有複寫
    protected List<Advisor> findCandidateAdvisors() {
        Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
        return this.advisorRetrievalHelper.findAdvisorBeans();
    }

    // 判斷給定的BeanName這個Bean，是不是合格的(BeanFactoryAdvisorRetrievalHelper裏會用到這個屬性)
    // 其中：DefaultAdvisorAutoProxyCreator和InfrastructureAdvisorAutoProxyCreator有複寫
    protected boolean isEligibleAdvisorBean(String beanName) {
        return true;
    }

    // 此處複寫了父類的方法，返回true了，表示
    @Override
    protected boolean advisorsPreFiltered() {
        return true;
    }
}

這個抽象類主要是提供getAdvicesAndAdvisorsForBean()這個方法的獲取模版，雖然它沒有提供抽象方法給子類去實現，但子類複寫了protected方法，改變了一些默認行爲。可是各個實現類都各有不一樣，如今咱們看看實現：

DefaultAdvisorAutoProxyCreator、AspectJAwareAdvisorAutoProxyCreator、InfrastructureAdvisorAutoProxyCreator

四、如下只介紹：AspectJAwareAdvisorAutoProxyCreator

該類主要來處理AspectJ切面的。這也是當下最流行，也是功能最爲強大的一種方式；

// @since 2.0
public class AspectJAwareAdvisorAutoProxyCreator extends AbstractAdvisorAutoProxyCreator {

    // 默認的排序器，它就不是根據Order來了，而是根據@Afeter @Before相似的標註來排序
    private static final Comparator<Advisor> DEFAULT_PRECEDENCE_COMPARATOR = new AspectJPrecedenceComparator();

    // 核心邏輯：它重寫了排序
    // 這個排序和`org.aspectj.util`提供的PartialOrder和PartialComparable有關 具體不詳敘了
    // 這塊排序算法仍是比較複雜的，控制着最終的執行順序~
    protected List<Advisor> sortAdvisors(List<Advisor> advisors) {
        ...
    }
// 當使用Aspect的PointCut或者是Aspect的Adcice都會使用到
    // 它的做用：（若存在AspectJ的Advice），就會在advisors的第一個位置加入`ExposeInvocationInterceptor.ADVISOR`這個advisor
    @Override
    protected void extendAdvisors(List<Advisor> candidateAdvisors) {
        AspectJProxyUtils.makeAdvisorChainAspectJCapableIfNecessary(candidateAdvisors);
    }

    
    @Override
    protected boolean shouldSkip(Class<?> beanClass, String beanName) {
        List<Advisor> candidateAdvisors = findCandidateAdvisors();
        
        // 這個至關於AspectJPointcutAdvisor的子類不要攔截、AspectJ切面本身本身的全部方法不要去攔截。。。
        for (Advisor advisor : candidateAdvisors) {
            if (advisor instanceof AspectJPointcutAdvisor &&
                    ((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
                return true;
            }
        }
        // 父類返回的false
        return super.shouldSkip(beanClass, beanName);
    }
    ...
}

五、AnnotationAwareAspectJAutoProxyCreator

　　首先AnnotationAwareAspectJAutoProxyCreator它是AspectJAwareAdvisorAutoProxyCreator的子類。

而後從名字中可議看出，它和註解有關。所以其實咱們的@EnableAspectJAutoProxy它導入的就是這個自動代理建立器去幫咱們建立和AspectJ相關的代理對象的。
     

// @since 2.0
public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator {

    @Nullable
    private List<Pattern> includePatterns;
    //惟一實現類：ReflectiveAspectJAdvisorFactory
    // 做用：基於@Aspect時,建立Spring AOP的Advice
    // 裏面會對標註這些註解Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class的方法進行排序
    // 而後把他們都變成Advisor( getAdvisors()方法 )
    @Nullable
    private AspectJAdvisorFactory aspectJAdvisorFactory;
    //該工具類用來從bean容器，也就是BeanFactory中獲取全部使用了@AspectJ註解的bean
    //就是這個方法：aspectJAdvisorsBuilder.buildAspectJAdvisors()
    @Nullable
    private BeanFactoryAspectJAdvisorsBuilder aspectJAdvisorsBuilder;


    // 很顯然，它還支持咱們自定義一個正則的模版
    // isEligibleAspectBean()該方法使用此模版，從而決定使用哪些Advisor
    public void setIncludePatterns(List<String> patterns) {
        this.includePatterns = new ArrayList<>(patterns.size());
        for (String patternText : patterns) {
            this.includePatterns.add(Pattern.compile(patternText));
        }
    }
    
    // 能夠本身實現一個AspectJAdvisorFactory  不然用默認的ReflectiveAspectJAdvisorFactory
    public void setAspectJAdvisorFactory(AspectJAdvisorFactory aspectJAdvisorFactory) {
        Assert.notNull(aspectJAdvisorFactory, "AspectJAdvisorFactory must not be null");
        this.aspectJAdvisorFactory = aspectJAdvisorFactory;
    }

    // 此處必定要記得調用：super.initBeanFactory(beanFactory);
    @Override
    protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        super.initBeanFactory(beanFactory);
        if (this.aspectJAdvisorFactory == null) {
            this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
        }
        this.aspectJAdvisorsBuilder = new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
    }


    // 拿到全部的候選的advisor們。請注意：調用了父類的super.findCandidateAdvisors()  去容器裏找出來一些
    // 而後，而後本身又經過aspectJAdvisorsBuilder.buildAspectJAdvisors()  解析@Aspect的方法獲得一些Advisor
    @Override
    protected List<Advisor> findCandidateAdvisors() {
        List<Advisor> advisors = super.findCandidateAdvisors();
        if (this.aspectJAdvisorsBuilder != null) {
            advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
        }
        return advisors;
    }
    
    // 若是該Bean本身自己就是一個@Aspect， 那也認爲是基礎主鍵，不要切了
    @Override
    protected boolean isInfrastructureClass(Class<?> beanClass) {
        return (super.isInfrastructureClass(beanClass) ||
                (this.aspectJAdvisorFactory != null && this.aspectJAdvisorFactory.isAspect(beanClass)));
    }

    // 拿傳入的正則模版進行匹配（沒傳就返回true，全部的Advisor都會生效）
    protected boolean isEligibleAspectBean(String beanName) {
        if (this.includePatterns == null) {
            return true;
        }
        else {
            for (Pattern pattern : this.includePatterns) {
                if (pattern.matcher(beanName).matches()) {
                    return true;
                }
            }
            return false;
        }
    }
    ...
}