死磕Spring系列之二,bean标签的解析和BeanDefinition的注册-阿里云开发者社区

原创作品，允许转载，转载时请务必以超链接形式标明文章原始出处、作者信息和本声明。否则将追究法律责任。 http://dba10g.blog.51cto.com/764602/1726519

书接上回。到现在环境已经配置完毕，已经可以跑一个简单的HELLOWORLD了。正式进入源码阅读的阶段。使用过Spring的都知道，我们只需要在配置文件中配置好对象规则（比如类，依赖，属性...)，然后我们就可以在程序中使用对象了。

我们可以做一个假设，如果让我们写一个程序，根据XML配置信息，生成想要的对象。

可以简单想象成：

XML:某产品的设计图纸

工厂类：生产流水线

对象：想要的产品。

生产流水线，想要根据图纸生成想要的产品。需要做哪些工作呢。

1.读懂图纸上的所有代表元素

2.产品规则记录入档，供批量生产使用

3..获取产品的原材料

4.产出产品

.....

还记得我们测试类吗？通过它，作为我们的阅读入口。

public class IOCBeanFactoryTest {
    public static void main(String[] args) {
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();//构造工厂
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);//新增Xml阅读器
        reader.loadBeanDefinitions(new ClassPathResource("IOCBeanFactoryTest.xml"));//规则注册入容器
        Object bean = factory.getBean("miyue");
        if(bean!=null){
            User miyue = (User)bean;
            System.out.println(miyue.getEmail());
            System.out.println(miyue.getUserName());
            List<Card> cardList = miyue.getCardList();
            for(Card c:cardList){
                System.out.println(c);
            }
        }
    }
}

XmlBeanDefinitionReader （简称XBDR)

XML格式的对象定义规则阅读器，通过委派BeanDefinitionDocumentReader进行阅读

上面是XBDR的类图，我们可以从整体了解下这个类。它主要完整读取XML规则，并将规则写入内存。让我们一步步开始剖析。

1.XmlBeanDefinitionReader.loadBeanDefinitions

方法的全名

int org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException

     int
 
org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(EncodedResource
 encodedResource) throws BeanDefinitionStoreException{
       ...
        try {
        //获取输入流
            InputStream inputStream = encodedResource.getResource().getInputStream();
            try {
                InputSource inputSource = new InputSource(inputStream);
                if (encodedResource.getEncoding() != null) {
                    inputSource.setEncoding(encodedResource.getEncoding());
                }
            //具体的加载过程
                return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
            }
            finally {
                inputStream.close();
            }
        }
        ...
   }

主要作用:完成从资源文件中获取数据流。

2.XmlBeanDefinitionReader.doLoadBeanDefinitions

int org.springframework.beans.factory.xml.XmlBeanDefinitionReader.doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException

            int validationMode = getValidationModeForResource(resource);
            Document doc = this.documentLoader.loadDocument(
                    inputSource, getEntityResolver(), this.errorHandler, validationMode, isNamespaceAware());
            return registerBeanDefinitions(doc, resource);

主要完成

a.XML的验证模式，XSD OR DTD

b.委派DefaultDocumentLoader，生成Document对象。准备解析。

3.XmlBeanDefinitionReader.registerBeanDefinitions

int org.springframework.beans.factory.xml.XmlBeanDefinitionReader.registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException

    public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
        BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
        documentReader.setEnvironment(getEnvironment());
        int countBefore = getRegistry().getBeanDefinitionCount();
     
        return getRegistry().getBeanDefinitionCount() - countBefore;
    }

作用

a)委派BeanDefinitionDocumentReader，解析Document,解析并注册bean definitions.

到这里，也算找到重点了。精彩继续。

注册流程

4.DefaultBeanDefinitionDocumentReader.registerBeanDefinitions

void org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.registerBeanDefinitions(Document doc, XmlReaderContext readerContext)

    public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
        this.readerContext = readerContext;
        logger.debug("Loading bean definitions");
        Element root = doc.getDocumentElement();
        doRegisterBeanDefinitions(root);
    }
    
        protected void doRegisterBeanDefinitions(Element root) {
        String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
        if (StringUtils.hasText(profileSpec)) {
            String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                    profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
            if (!getEnvironment().acceptsProfiles(specifiedProfiles)) {
                return;
            }
        }
        //这样做，是为了应付beans嵌套,递归
        BeanDefinitionParserDelegate parent = this.delegate;
        this.delegate = createDelegate(this.readerContext, root, parent);

        preProcessXml(root);
      
        postProcessXml(root);

        this.delegate = parent;
    }

作用：

注册每个beans元素下的bean definition。

5.DefaultBeanDefinitionDocumentReader.parseBeanDefinitions

void org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate)

    protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
        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)) {
                        parseDefaultElement(ele, delegate);
                    }
                    else {
                        delegate.parseCustomElement(ele);
                    }
                }
            }
        }
        else {
            delegate.parseCustomElement(root);
        }
    }

作用：

a)解析默认标签元素"import", "alias", "bean".

b)解析自定义标签(扩展性体现所在）

6.DefaultBeanDefinitionDocumentReader.parseDefaultElement

void org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate)

    private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
        if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
            importBeanDefinitionResource(ele);
        }
        else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
            processAliasRegistration(ele);
        }
        else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
            processBeanDefinition(ele, delegate);
        }
        else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
            // recurse
            doRegisterBeanDefinitions(ele);
        }
    }

作用：解析import，alias,bean，beans标签的入口。

其他都不重要，现在我们的重点是研究普通bean标签，其他先放一放。所以接下来我们需要进入processBeanDefinition(ele, delegate)

7.DefaultBeanDefinitionDocumentReader.processBeanDefinition

void org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate)

    protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if (bdHolder != null) {
        //装饰
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
            try {
                // Register the final decorated instance.
                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
            }
            catch (BeanDefinitionStoreException ex) {
                getReaderContext().error("Failed to register bean definition with name '" +
                        bdHolder.getBeanName() + "'", ele, ex);
            }
            // Send registration event.
            getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
        }
    }

作用：委派BeanDefinitionParserDelegate 解析bean元素。然后注册

8.BeanDefinitionParserDelegate.parseBeanDefinitionElement

BeanDefinitionHolder org.springframework.beans.factory.xml.BeanDefinitionParserDelegate.parseBeanDefinitionElement(Element ele, BeanDefinition containingBean)

        String id = ele.getAttribute(ID_ATTRIBUTE);
        String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
        ...
        AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
        return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);

作用：获取bean元素的id,name,最后返回BeanDefinitionHolder（bean definition 数据载体）

9.BeanDefinitionParserDelegate.parseBeanDefinitionElement

AbstractBeanDefinition org.springframework.beans.factory.xml.BeanDefinitionParserDelegate.parseBeanDefinitionElement(Element ele, String beanName, BeanDefinition containingBean)

    public AbstractBeanDefinition parseBeanDefinitionElement(
            Element ele, String beanName, BeanDefinition containingBean) {

      ...

        try {
            String parent = null;
            if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
                parent = ele.getAttribute(PARENT_ATTRIBUTE);
            }
            AbstractBeanDefinition bd = createBeanDefinition(className, parent);

            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

            parseMetaElements(ele, bd);
            parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
            parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

            parseConstructorArgElements(ele, bd);
            parsePropertyElements(ele, bd);
            parseQualifierElements(ele, bd);

            bd.setResource(this.readerContext.getResource());
            bd.setSource(extractSource(ele));

            return bd;
        }
        ...

作用：解析<bean>的子元素，并影响BeanDefinition。

这里，就是我们苦苦寻找的Bean标签的解析方法。

10.BeanDefinitionParserDelegate.decorateBeanDefinitionIfRequired

BeanDefinitionHolder org.springframework.beans.factory.xml.BeanDefinitionParserDelegate.decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder definitionHolder)

  
      public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder definitionHolder) {
        return decorateBeanDefinitionIfRequired(ele, definitionHolder, null);
    }
  
    public BeanDefinitionHolder decorateBeanDefinitionIfRequired(
            Element ele, BeanDefinitionHolder definitionHolder, BeanDefinition containingBd) {

        BeanDefinitionHolder finalDefinition = definitionHolder;

        // Decorate based on custom attributes first.
        NamedNodeMap attributes = ele.getAttributes();
        for (int i = 0; i < attributes.getLength(); i++) {
            Node node = attributes.item(i);
            finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
        }

        // Decorate based on custom nested elements.
        NodeList children = ele.getChildNodes();
        for (int i = 0; i < children.getLength(); i++) {
            Node node = children.item(i);
            if (node.getNodeType() == Node.ELEMENT_NODE) {
                finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
            }
        }
        return finalDefinition;
    }
    //装饰???
        private BeanDefinitionHolder decorateIfRequired(
            Node node, BeanDefinitionHolder originalDef, BeanDefinition containingBd) {

        String namespaceUri = getNamespaceURI(node);
        if (!isDefaultNamespace(namespaceUri)) {
            NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
            if (handler != null) {
            
                return handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
            }
            else if (namespaceUri != null && namespaceUri.startsWith("http://www.springframework.org/")) {
                error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);
            }
            else {
                // A custom namespace, not to be handled by Spring - maybe "xml:...".
                if (logger.isDebugEnabled()) {
                    logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");
                }
            }
        }
        return originalDef;
    }

作用，如有需要，对BeanDefinition,进行装饰。

到现在为止，我们已经清楚bean标签的整个解析过程了，但这还没有完全结束，我们还搞不太清楚，最后生成的BeanDefinitionHolder,到底保存到哪里了。

回到第7步，processBeanDefinition方法。

11.BeanDefinitionReaderUtils.registerBeanDefinition

void org.springframework.beans.factory.support.BeanDefinitionReaderUtils.registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException

 
         public 
         static 
         void 
         registerBeanDefinition( 
        
         BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) 
        
         throws 
         BeanDefinitionStoreException { 
        
         // Register bean definition under primary name. 
        
         String beanName = definitionHolder.getBeanName(); 
        
         //注册 
        
         registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition()); 
        
         // Register aliases for bean name, if any. 
        
         String[] aliases = definitionHolder.getAliases(); 
        
         if 
         (aliases != 
         null
         ) { 
        
         for 
         (String aliase : aliases) { 
        
         registry.registerAlias(beanName, aliase); 
        
         } 
        
         } 
        
         }

12.DefaultListableBeanFactory.registerBeanDefinition

void org.springframework.beans.factory.support.DefaultListableBeanFactory.registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException

 
         BeanDefinition oldBeanDefinition; 
        
         synchronized 
         (
         this
         .beanDefinitionMap) { 
        
         oldBeanDefinition = 
         this
         .beanDefinitionMap.get(beanName); 
        
         if 
         (oldBeanDefinition != 
         null
         ) { 
        
         if 
         (!
         this
         .allowBeanDefinitionOverriding) { 
        
         throw 
         new 
         BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, 
        
         "Cannot register bean definition [" 
         + beanDefinition + 
         "] for bean '" 
         + beanName + 
        
         "': There is already [" 
         + oldBeanDefinition + 
         "] bound."
         ); 
        
         } 
        
         else 
         { 
        
         if 
         (
         this
         .logger.isInfoEnabled()) { 
        
         this
         .logger.info(
         "Overriding bean definition for bean '" 
         + beanName + 
        
         "': replacing [" 
         + oldBeanDefinition + 
         "] with [" 
         + beanDefinition + 
         "]"
         ); 
        
         } 
        
         } 
        
         } 
        
         else 
         { 
        
         this
         .beanDefinitionNames.add(beanName); 
        
         this
         .frozenBeanDefinitionNames = 
         null
         ; 
        
         } 
        
         this
         .beanDefinitionMap.put(beanName, beanDefinition); 
        
         } 
        
         if 
         (oldBeanDefinition != 
         null 
         || containsSingleton(beanName)) { 
        
         resetBeanDefinition(beanName); 
        
         }

作用：注册bean，写入DefaultListableBeanFactory.beanDefinitionMap中

这里，就是我们苦苦寻找的Bean标签的解析方法。

感觉从解析标签开始，到注册。感觉像是兜了一圈。

从DefaultListableBeanFactory ->XmlBeanDefinitionReader ->DefaultBeanDefinitionDocumentReader ->BeanDefinitionParserDelegate
->BeanDefinitionReaderUtils ->DefaultListableBeanFactory。

最后总结：

一图胜千言，我使用工具画了一个序列图，通过序列图，可以很清楚知晓这几个类之间的调用顺序和关系。