重拾-Spring AOP-自動代理

Mr_houzi 發(fā)布于2019-08-16 15:31 / 1649人閱讀

摘要：是通過判斷當前是否匹配，只有匹配的才會創(chuàng)建代理。實現(xiàn)分析類結(jié)構(gòu)從上圖類結(jié)構(gòu)，我們知道其實現(xiàn)與類似都是通過實現(xiàn)接口在完成實例化后進行自動代理處理。

概述

在上一篇 重拾-Spring AOP 中我們會發(fā)現(xiàn) Spring AOP 是通過類 ProxyFactoryBean 創(chuàng)建代理對象，其有個缺陷就是只能代理一個目標對象 bean, 當代理目標類過多時，配置文件臃腫不方便管理維護，因此 Spring 提供了能夠?qū)崿F(xiàn)自動創(chuàng)建代理的類 BeanNameAutoProxyCreator , DefaultAdvisorAutoProxyCreator ；下面我們看下二者是如何實現(xiàn)自動代理的。

BeanNameAutoProxyCreator

BeanNameAutoProxyCreator 是通過判斷當前 bean name 是否匹配，只有匹配的 bean 才會創(chuàng)建代理。

使用示例

Spring xml 配置








    
    
        
            userService
            demoService
        
    
    
    
        
            userAfterAdvice
            userBeforeAdvice

測試

ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("/org/springframework/aop/aop.xml");

UserService userService = (UserService) ctx.getBean("userService");

userService.say();

DemoService demoService = (DemoService) ctx.getBean("demoService");

demoService.demo();

運行結(jié)果

do before advice ....
do say method
do after return advice ....
do before advice ....
do demo.
do after return advice ....

實現(xiàn)分析

類結(jié)構(gòu)

如上圖 BeanNameAutoProxyCreator 類結(jié)構(gòu)可以看出，其實現(xiàn)了接口 BeanPostProcessor ; 那么我們可以大概猜測出其自動代理的實現(xiàn)原理與自動注入類似，都是在 bean 實例化后進行特殊的處理，下面就讓我們看下源碼驗證下吧。

分析

public Object postProcessAfterInitialization(Object bean, String name) throws BeansException {
    // Check for special cases. We don"t want to try to autoproxy a part of the autoproxying
    // infrastructure, lest we get a stack overflow.
    if (isInfrastructureClass(bean, name) || shouldSkip(bean, name)) {
        logger.debug("Did not attempt to autoproxy infrastructure class "" + bean.getClass() + """);
        return bean;
    }
    
    TargetSource targetSource = getTargetSource(bean, name);
    
    Object[] specificInterceptors = getInterceptorsAndAdvisorsForBean(bean, name);
    
    // proxy if we have advice or if a TargetSourceCreator wants to do some
    // fancy stuff such as pooling
    if (specificInterceptors != DO_NOT_PROXY || !(targetSource instanceof SingletonTargetSource)) {

        // handle prototypes correctly
        // 獲取容器中配置的 advisors 
        Advisor[] commonInterceptors = resolveInterceptorNames();

        List allInterceptors = new ArrayList();
        if (specificInterceptors != null) {
            allInterceptors.addAll(Arrays.asList(specificInterceptors));
            if (commonInterceptors != null) {
                if (this.applyCommonInterceptorsFirst) {
                    allInterceptors.addAll(0, Arrays.asList(commonInterceptors));
                }
                else {
                    allInterceptors.addAll(Arrays.asList(commonInterceptors));
                }
            }
        }
        if (logger.isInfoEnabled()) {
            int nrOfCommonInterceptors = commonInterceptors != null ? commonInterceptors.length : 0;
            int nrOfSpecificInterceptors = specificInterceptors != null ? specificInterceptors.length : 0;
            logger.info("Creating implicit proxy for bean "" +  name + "" with " + nrOfCommonInterceptors +
                                    " common interceptors and " + nrOfSpecificInterceptors + " specific interceptors");
        }
        ProxyFactory proxyFactory = new ProxyFactory();

        // copy our properties (proxyTargetClass) inherited from ProxyConfig
        proxyFactory.copyFrom(this);
        
        if (!getProxyTargetClass()) {
            // Must allow for introductions; can"t just set interfaces to
            // the target"s interfaces only.
            // 添加設(shè)置代理的接口
            Class[] targetsInterfaces = AopUtils.getAllInterfaces(bean);
            for (int i = 0; i < targetsInterfaces.length; i++) {
                proxyFactory.addInterface(targetsInterfaces[i]);
            }
        }
        
        for (Iterator it = allInterceptors.iterator(); it.hasNext();) {
            Advisor advisor = GlobalAdvisorAdapterRegistry.getInstance().wrap(it.next());
            // 添加 advisor
            proxyFactory.addAdvisor(advisor);
        }
        proxyFactory.setTargetSource(getTargetSource(bean, name));
        
        // 創(chuàng)建代理對象，依舊采用的 jdk 動態(tài)代理; 因為上面設(shè)置了代理的 interface
        return proxyFactory.getProxy();
    }
    else {
        return bean;
    }
}

protected Object[] getInterceptorsAndAdvisorsForBean(Object bean, String beanName) {
    if (this.beanNames != null) {
        // bean name 包含在配置的名稱列表中，說明需要代理
        if (this.beanNames.contains(beanName)) {
            return PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS;
        }
        for (Iterator it = this.beanNames.iterator(); it.hasNext();) {
            String mappedName = (String) it.next();
            // bean name 匹配通配符，說明需要代理
            if (isMatch(beanName, mappedName)) {
                return PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS;
            }
        }
    }
    // 說明 bean 不需要代理
    return DO_NOT_PROXY;
}

protected boolean isMatch(String beanName, String mappedName) {
    // bean name 匹配通配符
    return (mappedName.endsWith("*") && beanName.startsWith(mappedName.substring(0, mappedName.length() - 1))) ||
            (mappedName.startsWith("*") && beanName.endsWith(mappedName.substring(1, mappedName.length())));
}

從 BeanNameAutoProxyCreator 的源碼大概總結(jié)其自動代理流程：

判斷當前 bean name 是否匹配配置

加載配置的 advisor, 也就是配置的 interceptorNames

采用 jdk 動態(tài)代理創(chuàng)建 bean 的代理對象

DefaultAdvisorAutoProxyCreator

DefaultAdvisorAutoProxyCreator 會搜索 BeanFactory 容器內(nèi)部所有可用的 Advisor; 并為容器中匹配的 bean 創(chuàng)建代理。 在上一篇 重拾-Spring AOP 中我們知道 Spring AOP 會默認創(chuàng)建實例為 DefaultPointcutAdvisor 的 Advisor； 那么在分析 DefaultAdvisorAutoProxyCreator 之前，我們看下 Spring AOP 還為我們提供了哪些內(nèi)置的 Advisor 。

NameMatchMethodPointcutAdvisor

NameMatchMethodPointcutAdvisor 是按 method name 匹配，只有當目標類執(zhí)行方法匹配的時候，才會執(zhí)行 Advice

public class NameMatchMethodPointcut extends StaticMethodMatcherPointcut {

    // 配置攔截的 method name
    private String[] mappedNames = new String[0];

    public boolean matches(Method m, Class targetClass) {
        for (int i = 0; i
RegexpMethodPointcutAdvisor
RegexpMethodPointcutAdvisor 是按照正則表達式匹配方法，能夠精確定位到需要攔截的方法。
public class RegexpMethodPointcut extends StaticMethodMatcherPointcut implements ClassFilter { 

    public boolean matches(Method m, Class targetClass) { 
        // TODO use target class here?
        // 拼接表達式
        String patt = m.getDeclaringClass().getName() + "." + m.getName();
        for (int i = 0; i < this.compiledPatterns.length; i++) {
            // 正則匹配
            boolean matched = this.matcher.matches(patt, this.compiledPatterns[i]);
            if (logger.isDebugEnabled()) {
                logger.debug("Candidate is: "" + patt + ""; pattern is " + this.compiledPatterns[i].getPattern() +
                             "; matched=" + matched);
            }
            if (matched) {
                return true;
            }
        }
        return false;
    }

    public boolean matches(Class clazz) {
        // TODO do with regexp
        return true;
    }
    
    public ClassFilter getClassFilter() {
        return this;
    }

}
使用示例
xml 配置


    
    

    
    

    
    
        
            
            save*
        
        
            
        
    

    
        
            
            org.springframework.aop.*.del*.*
        
        
            
        
    

    

測試
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("/org/springframework/aop/aop.xml");

UserService userService = (UserService) ctx.getBean("userService");

userService.saveUser();

userService.delUser();

DemoService demoService = (DemoService) ctx.getBean("demoService");

demoService.saveDemo();

demoService.delDemo();
測試結(jié)果
do before advice ....
do save user ......
do del user ......
do after return advice ....
do before advice ....
do save demo ......
do del demo ......
do after return advice ....
從測試結(jié)果可以看出，通過配置不同 Advisor 匹配不同的 Method 采用相應(yīng)的 Advice 進行處理。
實現(xiàn)分析
類結(jié)構(gòu)

從上圖 DefaultAdvisorAutoProxyCreator  類結(jié)構(gòu)，我們知道其實現(xiàn)與 BeanNameAutoProxyCreator 類似；都是通過實現(xiàn)接口 BeanPostProcessor 在 bean 完成實例化后進行自動代理處理。
分析
因 DefaultAdvisorAutoProxyCreator 和 BeanNameAutoProxyCreator 都繼承了類 AbstractAutoProxyCreator ,所以從源碼中我們可以發(fā)現(xiàn)二者都重寫了方法 getInterceptorsAndAdvisorsForBean ，也就是在獲取當前 bean 所匹配的 Advisor 邏輯不一樣之外其他處理一致； 那么下面針對 DefaultAdvisorAutoProxyCreator 的實現(xiàn)我們主要看下方法 getInterceptorsAndAdvisorsForBean 的處理。
protected Object[] getInterceptorsAndAdvisorsForBean(Object bean, String name) {
    // 查找與當前 bean 匹配的 advisor
    List advices = findEligibleAdvisors(bean.getClass());
    if (advices.isEmpty()) {
        return DO_NOT_PROXY;
    }
    // 對 advisor 集合排序
    advices = sortAdvisors(advices);
    return advices.toArray();
}
查找匹配的 Advisor
protected List findEligibleAdvisors(Class clazz) {
    // 查找當前容器中所有定義的 advisor
    List candidateAdvice = findCandidateAdvisors();
    List eligibleAdvice = new LinkedList();
    for (int i = 0; i < candidateAdvice.size(); i++) {
        // Sun, give me generics, please!
        Advisor candidate = (Advisor) candidateAdvice.get(i);
        // 判斷 bean 是否可以應(yīng)用 advisor
        if (AopUtils.canApply(candidate, clazz, null)) {
            // 將 advisor 添加到匹配的集合中
            eligibleAdvice.add(candidate);
            logger.info("Candidate Advice [" + candidate + "] accepted for class [" + clazz.getName() + "]");
        }
        else {
            logger.info("Candidate Advice [" + candidate + "] rejected for class [" + clazz.getName() + "]");
        }
    }
    return eligibleAdvice;
}
獲取容器中所有的 Advisor
protected List findCandidateAdvisors() {
    if (!(getBeanFactory() instanceof ListableBeanFactory)) {
        throw new IllegalStateException("Cannot use DefaultAdvisorAutoProxyCreator without a ListableBeanFactory");
    }
    ListableBeanFactory owningFactory = (ListableBeanFactory) getBeanFactory();
    // 從容器中查找所有 bean 定義 type 為 Advisor 的 bean name
    String[] adviceNames = BeanFactoryUtils.beanNamesIncludingAncestors(owningFactory, Advisor.class);
    List candidateAdvisors = new LinkedList();
    for (int i = 0; i < adviceNames.length; i++) {
        String name = adviceNames[i];
        if (!this.usePrefix || name.startsWith(this.advisorBeanNamePrefix)) {
            // 獲取 advisor 實例
            Advisor advisor = (Advisor) owningFactory.getBean(name);
            candidateAdvisors.add(advisor);
        }
    }
    return candidateAdvisors;
}
判斷 bean 是否匹配 Advisor
public static boolean canApply(Advisor advisor, Class targetClass, Class[] proxyInterfaces) {
    if (advisor instanceof IntroductionAdvisor) {
        return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
    }
    else if (advisor instanceof PointcutAdvisor) {
        PointcutAdvisor pca = (PointcutAdvisor) advisor;
        // 通過 advisor 的 pointcut 判斷 bean 是否匹配
        return canApply(pca.getPointcut(), targetClass, proxyInterfaces);
    }
    else {
        // It doesn"t have a pointcut so we assume it applies
        return true;
    }
}


public static boolean canApply(Pointcut pc, Class targetClass, Class[] proxyInterfaces) {
    // 類是否匹配
    if (!pc.getClassFilter().matches(targetClass)) {
        return false;
    }
    
    // 判斷類中的 method 是否匹配
    // 獲取類下所有的method
    Method[] methods = targetClass.getMethods();
    for (int i = 0; i < methods.length; i++) {
        Method m = methods[i];
        // If we"re looking only at interfaces and this method
        // isn"t on any of them, skip it
        if (proxyInterfaces != null && !methodIsOnOneOfTheseInterfaces(m, proxyInterfaces)) {
            continue;
        }
        // 執(zhí)行 pointcut 的 method match
        if (pc.getMethodMatcher().matches(m, targetClass))
            return true;
    }
    return false;
}
從 DefaultAdvisorAutoProxyCreator 的源碼分析，可知其自動代理流程大概如下：

從容器中獲取所有 Advisor 實例
匹配 bean 所支持的 Advisor

采用 jdk 動態(tài)代理創(chuàng)建 bean 的代理對象

小結(jié)
從 BeanNameAutoProxyCreator , DefaultAdvisorAutoProxyCreator 二者的實現(xiàn)可以看出其相同點

都是基于實現(xiàn)接口 BeanPostProcessor 的實現(xiàn)
都是先獲取當前 bean 所匹配的 Advisor，后在創(chuàng)建代理對象

二者的不同點在于:

前者是基于 bean name 判斷是否判斷，后者是通過 Advisor 內(nèi)部的 Ponitcut 匹配判斷
前者的 Advisor 是用戶配置的，后者是容器中所有匹配的 Advisor