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源碼分析三》