spring AOP源碼分析（一）

對於springAOP的源碼分析，我打算分三部分來講解：1.配置文件的解析，解析為BeanDefination和其他信息然后注冊到BeanFactory中；2.為目標對象配置增強行為以及代理對象的生成，可以理解為AOP的准備階段；3.代理對象調用方法，增強行為的觸發執行，此時是AOP生效的階段。我們可以把1,2理解為IOC階段；2,3理解為AOP階段。

我們先看第一部分：BeanDefination的解析注冊過程

由一個demo進入源碼分析，創建一個接口UserDao

public interface UserDao {
    void addUser();
    void deleteUser();
}

創建UserDaoImpl類

public class UserDaoImpl implements UserDao{

    public void addUser() {
        System.out.println("add user ");
    }

    public void deleteUser() {
        System.out.println("delete user ");
    }

}

創建一個Logger類

public class Logger {
    
    public void recordBefore(){
        System.out.println("recordBefore");
    }
    
    public void recordAfter(){
        System.out.println("recordAfter");
    }
    
}

在aop.xml中添加配置信息

    <bean id="userDao" class="com.demo.aop.sourcecode.UserDaoImpl"/>
    
    <bean id="logger" class="com.demo.aop.sourcecode.Logger" />
    
    <!-- 切面：切入點和通知 -->
    <aop:config>
        <aop:aspect id="logger" ref="logger">
            <aop:pointcut expression="execution(* com.demo.aop.sourcecode..*.*(..))" id="udpateUserMethod" />
            <aop:before method="recordBefore" pointcut-ref="udpateUserMethod" />
            <aop:after method="recordAfter" pointcut-ref="udpateUserMethod" />
        </aop:aspect>
    </aop:config>    

寫測試方法

@Test
    public void testAop(){
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("aop.xml");//BeanDefination的解析注冊，代理對象的生成        
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");//可以看到userDao類型是以$Proxy開頭的，說明是通過JDK動態代理的方式獲取的
        userDao.addUser();//增強行為發生的時刻
    }

進入到AbstractApplicationContext類中的refresh方法

    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
　　　　　　　//BeanDefination的解析注冊在這個方法中發生，進入這個方法
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();

                // Reset 'active' flag.
                cancelRefresh(ex);

                // Propagate exception to caller.
                throw ex;
            }

            finally {
                // Reset common introspection caches in Spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }

通過一步步追蹤，我們可以進入DefaultBeanDefinitionDocumentReader類中的parseBeanDefinitions方法

    protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
        //判斷是否是默認的命名空間，默認的命名空間是 http://www.springframework.org/schema/beans if (delegate.isDefaultNamespace(root)) {
　　　　　　　//獲取所有的子節點，然后循環處理　
            NodeList nl = root.getChildNodes();
            for (int i = 0; i < nl.getLength(); i++) {
                Node node = nl.item(i);
                if (node instanceof Element) {
                    Element ele = (Element) node;
                    if (delegate.isDefaultNamespace(ele)) {
　　　　　　　　　　　　　　 //在aop.xml文件中，對userDao和logger的定義將在這里處理
                        parseDefaultElement(ele, delegate);
                    }
                    else {
　　　　　　　　　　　　　　 //對<aop:config>的定義在這里處理，因為它的命名空間是 http://www.springframework.org/schema/aop 進入該方法
                        delegate.parseCustomElement(ele);
                    }
                }
            }
        }
        else {
            delegate.parseCustomElement(root);
        }
    }

進入parseCustomElement方法，然后可以追蹤到以下方法

    public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
        String namespaceUri = getNamespaceURI(ele);
　　　　  //此處的handler為AopNamespaceHandler，接下來將用它對<aop:config>進行解析
        NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
        if (handler == null) {
            error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
            return null;
        }
        //進入該方法 return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
    }

進入NamespaceHandlerSupport類中的parse方法

public BeanDefinition parse(Element element, ParserContext parserContext) {
        return findParserForElement(element, parserContext).parse(element, parserContext);
    }

由於<aop:config>的解析是由ConfigBeanDefinitionParser類來完成的，所以進入該類的parse方法，看解析過程

@Override
    public BeanDefinition parse(Element element, ParserContext parserContext) {
        CompositeComponentDefinition compositeDef =
                new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
        parserContext.pushContainingComponent(compositeDef);

        configureAutoProxyCreator(parserContext, element);
　　　　 //獲取子節點，根據aop.xml文件中的配置，子節點為<aop:aspect>
        List<Element> childElts = DomUtils.getChildElements(element);
        for (Element elt: childElts) {
            String localName = parserContext.getDelegate().getLocalName(elt);
            if (POINTCUT.equals(localName)) {
                parsePointcut(elt, parserContext);
            }
            else if (ADVISOR.equals(localName)) {
                parseAdvisor(elt, parserContext);
            }
            else if (ASPECT.equals(localName)) {
                //進入該方法，解析<aop:aspect>
                parseAspect(elt, parserContext);
            }
        }

        parserContext.popAndRegisterContainingComponent();
        return null;
    }

 進入parseAspect方法

private void parseAspect(Element aspectElement, ParserContext parserContext) {
        //獲取定義的切面ID和ref
        String aspectId = aspectElement.getAttribute(ID);
        String aspectName = aspectElement.getAttribute(REF);

        try {
            //將獲取到的切面ID和ref封裝到AspectEntry這個類中 this.parseState.push(new AspectEntry(aspectId, aspectName));
            //把<aop:before>等通知相關的信息封裝到AspectJPointcutAdvisor中，然后放到該集合里
            List<BeanDefinition> beanDefinitions = new ArrayList<BeanDefinition>();
　　　　     //把ref相關的信息如aop.xml中的logger，updateUserMethod等封裝到RunTimeBeanReference中，然后放到這個集合中
            List<BeanReference> beanReferences = new ArrayList<BeanReference>();

            List<Element> declareParents = DomUtils.getChildElementsByTagName(aspectElement, DECLARE_PARENTS);
            for (int i = METHOD_INDEX; i < declareParents.size(); i++) {
                Element declareParentsElement = declareParents.get(i);
                beanDefinitions.add(parseDeclareParents(declareParentsElement, parserContext));
            }

            // We have to parse "advice" and all the advice kinds in one loop, to get the
            // ordering semantics right.
            NodeList nodeList = aspectElement.getChildNodes();
            boolean adviceFoundAlready = false;
            //循環切面的子節點，然后判斷是否是通知，然后進行對應的處理 for (int i = 0; i < nodeList.getLength(); i++) {
                Node node = nodeList.item(i);
                if (isAdviceNode(node, parserContext)) {
                    if (!adviceFoundAlready) {
                        adviceFoundAlready = true;
                        if (!StringUtils.hasText(aspectName)) {
                            parserContext.getReaderContext().error(
                                    "<aspect> tag needs aspect bean reference via 'ref' attribute when declaring advices.",
                                    aspectElement, this.parseState.snapshot());
                            return;
                        }
                        //封裝ref信息
                        beanReferences.add(new RuntimeBeanReference(aspectName));
                    }
                    //把通知相關信息封裝到AspectJPointcutAdvisor這個類中，同時封裝ref信息然后放到BeanReferences中
　　　　　　　　　　　　//這個是解析通知的方法，可以進入看看
                    AbstractBeanDefinition advisorDefinition = parseAdvice(
                            aspectName, i, aspectElement, (Element) node, parserContext, beanDefinitions, beanReferences);
                    beanDefinitions.add(advisorDefinition);
                }
            }
　　　　　　　//把切面信息和通知信息封裝到這個類中　
            AspectComponentDefinition aspectComponentDefinition = createAspectComponentDefinition(
                    aspectElement, aspectId, beanDefinitions, beanReferences, parserContext);
            parserContext.pushContainingComponent(aspectComponentDefinition);
　　　　　　　//解析切入點，然后封裝信息　
            List<Element> pointcuts = DomUtils.getChildElementsByTagName(aspectElement, POINTCUT);
            for (Element pointcutElement : pointcuts) {
　　　　　　　　   //這個是具體解析切入點的方法
                parsePointcut(pointcutElement, parserContext);
            }

            parserContext.popAndRegisterContainingComponent();
        }
        finally {
            this.parseState.pop();
        }
    }

其實我們可以看到，這個方法的目的就是解析<aop:aspect>中的配置信息然后封裝到類中，最終都存放在了containingComponents這個棧中，方便后面使用，這就是整個解析過程。

在接下來的一篇博文中，我們講解代理對象的生成，如何給目標對象配置增強行為的，也就是第二個階段。

《springAOP源碼分析二》

《springAOP源碼分析三》