Spring系列之Spring框架和SpringAOP集成過程分析(十二)

轉載請註明出處：https://blog.csdn.net/zknxx/article/details/80808447
在這篇文章中我們接着上一篇的文章說。在上一篇文章中我們提到了getAdvicesAndAdvisorsForBean這個方法，這個方法的內容是爲目標對象挑選合適的Advisor類，其源碼如下：

    //targetSource 爲null
    protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
        List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
        //如果獲取的Advisor爲空的話，則直接返回DO_NOT_PROXY 返回這個值的時候 是不創建代理對象
        if (advisors.isEmpty()) {
            return DO_NOT_PROXY;
        }
        return advisors.toArray();
    }
    protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
        //這個方法我們在上一章中分析過了   獲取Spring容器中的所有的通知方法  封裝爲Advisor集合
        List<Advisor> candidateAdvisors = findCandidateAdvisors();
        //這一步就是爲目標對象挑選合適的Advisor 即目標對象和切點表達式相匹配
        //此處的分析  請參考這裏：https://blog.csdn.net/zknxx/article/details/79735405
        List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
        //這個方法做的事是向 上一步獲取到的Advisor中 插入ExposeInvocationInterceptor.ADVISOR 插在第一個位置
        extendAdvisors(eligibleAdvisors);
        if (!eligibleAdvisors.isEmpty()) {
            //排序  很複雜的實現  不說了  如果你對一個目標對象使用多個 相同類型的通知的話 請把這些通知放到不同的Aspect中，並實現Order接口或者使用Ordered註解標註順序
            eligibleAdvisors = sortAdvisors(eligibleAdvisors);
        }
        return eligibleAdvisors;
    }

最後我們再看看目標對象的創建過程：

    //specificInterceptors 上面的方法中獲取到的Advisor 
    //targetSource 爲 new SingletonTargetSource(bean) 
    //將Spring容器中創建出來的bean封裝爲了SingletonTargetSource
    protected Object createProxy(
            Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
        //這裏將目標Bean的Class設置爲BeanDefinition中的一個屬性 
        //在使用JDK動態代理的時候 可能會用到這個屬性  https://stackoverflow.com/questions/45463757/what-is-interface-based-proxying
        if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
            AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
        }
        //這裏創建了一個新的 ProxyFactory
        ProxyFactory proxyFactory = new ProxyFactory();
        //copy原類的配置 重寫賦值的動作   單例變多例
        proxyFactory.copyFrom(this);
        //這裏是 判斷是否強制使用 cglib
        if (!proxyFactory.isProxyTargetClass()) {
            //這裏 判斷是 使用jdk動態代理 還是cglib代理
            if (shouldProxyTargetClass(beanClass, beanName)) {
                proxyFactory.setProxyTargetClass(true);
            }
            else {
                evaluateProxyInterfaces(beanClass, proxyFactory);
            }
        }
        //這裏又重寫構建了一次 Advisor  看看是否 設置了通用的攔截
        //這裏講所有的Advisor和配置的通用攔截都轉換爲了Advisor類型
        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        for (Advisor advisor : advisors) {
            proxyFactory.addAdvisor(advisor);
        }
        //targetSource 裏是包含目標對象的
        proxyFactory.setTargetSource(targetSource);
        customizeProxyFactory(proxyFactory);

        proxyFactory.setFrozen(this.freezeProxy);
        if (advisorsPreFiltered()) {
            proxyFactory.setPreFiltered(true);
        }
        //創建代理對象 關於創建代理對象的分析 請參考：https://blog.csdn.net/zknxx/article/details/79764107
        return proxyFactory.getProxy(getProxyClassLoader());
    }

好了，到此關於AOP的分析就先暫時告一段落了。
轉載請註明出處：https://blog.csdn.net/zknxx/article/details/80808447