在aop原始碼解析二:postProcessBeforeInstantiation博文中 我們花了很長的一個篇幅介紹一個方法shouldSkip方法 雖然看名字很簡單 但裡面確實做了很多的事情 雖然最終也是沒有去建立代理 但這些工作並不是白做的 解析完以後快取起來了 後面就可以直接使用了 這次我們看下AnnotationAwareAspectJAutoProxyCreator##postProcessAfterInitialization(Object bean, String beanName)方法

    public Object postProcessAfterInitialization
 
(Object bean, String beanName) throws BeansException {
        if (bean != null) {
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (!this.earlyProxyReferences.containsKey(cacheKey)) {
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return
 
 bean;
    }

在這裡看到了我們一直想看到的代理相關的程式碼 因為建立代理是一件耗時的事情 要做很多的解析 轉換等工作 所以根據beanClass``beanName作為快取的key

    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        // 因為尋找切面方法等操作是很浪費時間的操作 所以如果不必操作的話或者已經建立過代理的話 儘量提前返回
        //已經建立過
        if (beanName != null && this
 
.targetSourcedBeans.containsKey(beanName)) {
            return bean;
        }
        //本身是切面類
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        }
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }

        // 可以看出作者的思路是很清晰的 幾句程式碼概括了要做的事情 然後在方法裡面展開
        // advice advisor pointcut 等之間的名次的區別與聯絡
        // advice : action to take at a joinpoint
        // 1. 尋找適合此bean的切面方法
        // 2. 建立代理
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            //建立代理物件 java動態代理或者是基於cglib的代理 cglib代理更高效
            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;
    }

我們又看到了shouldSkip(bean.getClass(), beanName)方法 跟我們上篇博文介紹的是同一個方法
這裡主要看下getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null)方法
其實這個方法的主要作用是對於尋找到的所有的切面對beanClass做過濾 涉及到切點的匹配 例如正則表示式 註解等

    @Override
    protected Object[] getAdvicesAndAdvisorsForBean(Class beanClass, String beanName, TargetSource targetSource) {
        // 尋找勝任的或者說適合此bean的advior
        List advisors = findEligibleAdvisors(beanClass, beanName);
        if (advisors.isEmpty()) {
            return DO_NOT_PROXY;
        }
        return advisors.toArray();
    }


        protected List<Advisor> findEligibleAdvisors(Class beanClass, String beanName) {
        //Advisor.class
        //尋找所有的候選項
        // 這裡注意 findCandidateAdvisors() 方法在AnnotationAwareAspectJAutoProxyCreator類有繼承
        List<Advisor> candidateAdvisors = findCandidateAdvisors();
        //從候選項中挑出適合此bean的advisor
        List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
        extendAdvisors(eligibleAdvisors);
        if (!eligibleAdvisors.isEmpty()) {
            //對advisor排序 按照順序:
            eligibleAdvisors = sortAdvisors(eligibleAdvisors);
        }
        return eligibleAdvisors;
    }

findCandidateAdvisors()方法 我們在介紹shouldSkip(xxx)方法的時候就已經講解過 不熟悉的讀者可以多讀幾遍 這個方法解析出了所有的advisor advisor包括advice``pointcut資訊

    protected List<Advisor> findAdvisorsThatCanApply(
            List<Advisor> candidateAdvisors, Class beanClass, String beanName) {

        ProxyCreationContext.setCurrentProxiedBeanName(beanName);
        try {
            return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
        }
        finally {
            ProxyCreationContext.setCurrentProxiedBeanName(null);
        }
    }

        public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
        if (candidateAdvisors.isEmpty()) {
            return candidateAdvisors;
        }
        List<Advisor> eligibleAdvisors = new LinkedList<Advisor>();
        for (Advisor candidate : candidateAdvisors) {
            if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
                eligibleAdvisors.add(candidate);
            }
        }
        boolean hasIntroductions = !eligibleAdvisors.isEmpty();
        for (Advisor candidate : candidateAdvisors) {
            if (candidate instanceof IntroductionAdvisor) {
                // already processed
                continue;
            }
            //todo 寫註釋
            if (canApply(candidate, clazz, hasIntroductions)) {
                eligibleAdvisors.add(candidate);
            }
        }
        return eligibleAdvisors;
    }

        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;
            return canApply(pca.getPointcut(), targetClass, hasIntroductions);
        }
        else {
            // It doesn't have a pointcut so we assume it applies.
            return true;
        }
    }

        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();
        IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
        if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
            introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
        }
        // 類繼承關係中 只要有一個類的一個方法被匹配 就返回true
        Set<Class> classes = new LinkedHashSet<Class>(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
        classes.add(targetClass);
        for (Class<?> clazz : classes) {
            Method[] methods = clazz.getMethods();
            for (Method method : methods) {
                if ((introductionAwareMethodMatcher != null &&
                        introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions)) ||
                        methodMatcher.matches(method, targetClass)) {
                    return true;
                }
            }
        }

        return false;
    }

最重要的還是最後一個canApply方法 根據pointcut資訊去做匹配 判斷是否符合要求 因為這裡是返回類的代理 所以只要有一個方法被匹配到 就人為滿足條件 至於是怎麼做匹配的 感興趣的讀者可以深入閱讀 我們這裡只要知道做了什麼就可以了
回到wrapIfNecessary方法 繼續往下看 下面的就是我們一直想看到的方法了 建立代理
看一下aop的相關配置

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

這行程式碼註冊了BPP 另外還指定了proxy-target-class屬性 值為true的意思是強制使用cglib建立代理 還有另外一種java jdk提供的代理 需要被代理的類的方法繼承自某個介面方法才可以 cglib並沒有這個限制 推薦使用cglib的方式 執行速度更快
但我們下面是以jdk建立代理為例講解 這種方式更簡單 讀者也可能更熟悉這種方式 那麼就把這行xml配置改成下面這樣

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

對java提供的動態代理實現不瞭解的讀者 建議先看這篇部落格java動態代理介紹 這樣下面的代理就更容易理解
我們看下createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean))方法

protected Object createProxy(
            Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {

        ProxyFactory proxyFactory = new ProxyFactory();
        // Copy our properties (proxyTargetClass etc) inherited from ProxyConfig.
        proxyFactory.copyFrom(this);

        //使用java動態代理
        if (!shouldProxyTargetClass(beanClass, beanName)) {
            // Must allow for introductions; can't just set interfaces to
            // the target's interfaces only.
            Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, this.proxyClassLoader);
            for (Class<?> targetInterface : targetInterfaces) {
                proxyFactory.addInterface(targetInterface);
            }
        }

        //
        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        for (Advisor advisor : advisors) {
            proxyFactory.addAdvisor(advisor);
        }

        proxyFactory.setTargetSource(targetSource);
        customizeProxyFactory(proxyFactory);

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

        return proxyFactory.getProxy(this.proxyClassLoader);
    }

ProxyFactory是一個很重要的類 裡面有各種與切面相關的屬性,方法等

public Object getProxy(ClassLoader classLoader) {
        return createAopProxy().getProxy(classLoader);
    }

getProxy(ClassLoader classLoader)方法返回的就是目標類的代理類 分成兩大步完成

• 返回要使用的AopProxy CglibAopProxy或者JdkDynamicAopProxy
• 建立代理

    protected final synchronized AopProxy createAopProxy() {
        if (!this.active) {
            activate();
        }
        //預設是DefaultAopProxyFactory
        return getAopProxyFactory().createAopProxy(this);
    }

    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            Class targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: " +
                        "Either an interface or a target is required for proxy creation.");
            }
            if (targetClass.isInterface()) {
                return new JdkDynamicAopProxy(config);
            }
            return CglibProxyFactory.createCglibProxy(config);
        }
        else {
            return new JdkDynamicAopProxy(config);
        }
    }

預設使用的建立AopProxy的是DefaultAopProxyFactory 是一個工廠類 類的實現很簡單 根據條件返回對應的AopProxy 當然都把proxyFactory作為引數傳遞了進去
我們接下來看JdkDynamicAopProxy##getProxy方法

public Object getProxy(ClassLoader classLoader) {
        if (logger.isDebugEnabled()) {
            logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
        }
        Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
        //尋找equals hashCode方法
        findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }

completeProxiedInterfaces(AdvisedSupport advised) 方法在代理類要實現的所有介面中加入了兩個介面SpringProxy與 Advised介面 SpringProxy是一個標誌介面 沒有什麼方法需要去實現 Advised提供的介面方法就比較多了 裡面有代理相關的所有配置屬性
下面就是建立代理了 相信讀者如果閱讀了java動態代理介紹這篇部落格的話 讀者應該理解做了什麼事情 在下一篇部落格中我們看一下方法的呼叫過程