死磕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;
    }

作用：

a)

注册每个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


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

    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


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

        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。

最后总结：

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

解析bean标签，委托给**Reader,*Parser实现，最后完成bean的注册，又由DefaultListableBeanFactory实现。 大家如有兴趣，可以仔细想想，很有意思的。

为什么要这样？ 这样做有什么好处？

最后，由于篇幅，源码解析，这节课就到这里了。但bean标签的解析和beanfinition 的注册还有很多细节要一一死磕到底。

大家如有共同兴趣，和我一样对Spring深深迷恋，加入我们的交流群：301587239。大家一起交流学习。

本文出自 “简单” 博客，请务必保留此出处http://dba10g.blog.51cto.com/764602/1726519

时间： 2024-08-08 02:15:12

死磕Spring系列之二,bean标签的解析和BeanDefinition的注册的相关文章

死磕Spring系列之一：准备阅读Spring源码环境

原创作品,允许转载,转载时请务必以超链接形式标明文章 原始出处 .作者信息和本声明.否则将追究法律责任.http://dba10g.blog.51cto.com/764602/1726509 死磕Spring系列前言 死磕spring系列博客,是对Spring进行源码级阅读.工作以来,一直接触spring框架,可以说对spring框架的配置使用已经非常熟练了.个人感觉:Spring技术非常强大,简单的xml标签配置,就可以开启非常强大的支持功能,囊括J2EE企业应用的方方面面.使用归使用,但是却

死磕Spring系列之四 BeanDefinition接口、BeanFactory接口

原创作品,允许转载,转载时请务必以超链接形式标明文章 原始出处 .作者信息和本声明.否则将追究法律责任.http://dba10g.blog.51cto.com/764602/1728512 通过前面的介绍,相信大家对bean的解析,注册的整体流程了解了,知道Spring怎么一步步将xml文档内的配置信息纳入容器中.有几个非常重要的接口,不得不谈. 1.BeanDefinition接口 这个接口,可以理解为xml bean元素的数据载体.通过对比xml bean标签的属性列表和BeanDefin

死磕Spring系列之三,XML解析相关

原创作品,允许转载,转载时请务必以超链接形式标明文章 原始出处 .作者信息和本声明.否则将追究法律责任.http://dba10g.blog.51cto.com/764602/1728020 通过第2章的介绍,应该知道Spring如何从XML一步步解析成BD对象并注册到容器中,这一过程有个概要认识了. 接下来开始详细分析与XML相关的那些事. 首先看一下使用的XML文档. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

Struts1.x系列教程（6）：Bean标签库

Bean标签库共有11个标签.这些标签可以完成如下五种工作: 1.获得HTTP请求信息 2.访问Java对象 3.访问JSP内嵌对象和Struts配置对象 4.访问Web资源和属性文件 5.输出信息 下面我们就来分别介绍一下如何使用Bean标签库中的标签来完成上述的工作. 一.获得HTTP请求信息 使用Bean标签库中的标签可以访问Cookie.HTTP请求头以及请求参数. 1.<bean:cookie>标签 <bean:cookie>标签用于获得一个Cookie对象,并创建一个p

死磕Tomcat7源码之二:web组件初始化

原创作品,允许转载,转载时请务必以超链接形式标明文章 原始出处 .作者信息和本声明.否则将追究法律责任.http://dba10g.blog.51cto.com/764602/1775827 经过死磕Tomcat7源码之一:解析web.xml,已经知道webapp的配置信息是如何解析到内存中.接下来,就是如何将对应的组件对象初始化化.分析所有的组件初始化过程,根本不可能.本文重点针对阐明3个主要组件的初始化过程,分别是:servlet,listener,filter.通过本文,你可以掌握以下知识

Android高效率编码-第三方SDK详解系列(二)——Bmob后端云开发，实现登录注册，更改资料，修改密码，邮箱验证，上传，下载，推送消息，缩略图加载等功能

Android高效率编码-第三方SDK详解系列(二)--Bmob后端云开发,实现登录注册,更改资料,修改密码,邮箱验证,上传,下载,推送消息,缩略图加载等功能 我的本意是第二篇写Mob的shareSDK分享组件的,奈何需要去注册各平台的账号,还要审核,有些审核还挺久,就没办法,改为写这个Bmob了,相信大家对Bmob都是挺期待的吧,因为他作为Android后端的实现很好的支持,国内很多软件都在使用它,他的功能也是特别神奇,这里就不一一细说了,我们用实际的例子来见证他的神奇 官网:http://w

解决Spring中singleton的Bean依赖于prototype的Bean的问题

    当Spring容器中作用域不同的Bean相互依赖时,可能出现一些问题,例如:一个作用域为Singleton的Bean(设为A)依赖于一个作用域为prototype的Bean(设为B).由于A是单例的,只有一次初始化的机会,它的依赖关系也只在初始化阶段被设置,但它所依赖的B每次都会创建一个全新的实例,这将使A中的B不能及时得到更新.这样将导致如果客户端多次请求A,并调用A中B的某个方法(或获取A中B的某个属性),服务端总是返回同一个B,但客户端直接请求B却能获得最新的对象,这就产生了对象不

美女、犯案、“死磕”希拉里，黑客 Kim Dotcom 的恣意人生

       如果在你心目中,黑客打上了"死宅"."沉默寡言"--的标签了的话,Kim Dotcom 绝对是可以颠覆你对黑客传统印象的那一个. 在雷锋网(公众号:雷锋网)报道了黑客 Kim Dotcom 在希拉里生日这天献上了一份让她可能与美国总统职位之间又生障碍的"大礼"后,雷锋网决定再仔细扒一扒这个传奇黑客. 与两次牢狱之灾擦肩而过 Kim Dotcom 原来叫 Kim Schmitz,为了纪念互联网的发展,把姓氏改为了Dotcom. 在 K

站内优化系列教程二：网站头部和底部优化

前面给大家讲了<站内优化系列教程一:导航优化和结构优化>和<站内优化系列教程二:URL和网站地图优化>两课,今天讲第三课<站内优化系列教程二:网站头部和底部优化>.给网站做站优化最基本的目的就是为了提高网站的排名,相对来说这也是大部分站长优化的主要目的,毕竟如果网站排名不靠前,自然就无法从搜索引挚获取大量的流量,而对于网站运营.提高网站知名度.打造网站特有的品牌则是难之又难.回归正题,大部分站长做网站优化都是特别的重视站外优化,而忽视站内的基本优化,其实最基本的提高用户