Spring IoC 源码系列（一）BeanDefinition 初始化与注册

古城微笑少年丶 2023-07-01 06:30 22阅读 0赞

### 一、BeanDefinition ###

#### 1.1 什么是 BeanDefinition ####

在一般的 Spring 项目中，主要通过 XML 的方式配置 bean，而 `BeanDefinition` 就是 XML 配置属性的载体，XML 文件首先会被转化成 `Document` 对象，通过解析 `Document`，把 XML 中 `<bean />` 标签转化成 `BeanDefinition` 供 IoC 容器创建 bean 时使用。

我们可以来做个测试。

<bean id="typeMismatch" class="org.springframework.tests.sample.beans.TestBean" scope="prototype">
            <property name="name"><value>typeMismatch</value></property>
            <property name="age"><value>34x</value></property>
            <property name="spouse"><ref bean="rod"/></property>
        </bean>

下面是 debug 后抓到的 `BeanDefinition` 属性。

![format_png][]

#### 1.2 BeanDefinition 初始化流程图 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvZGVqYXM_size_16_color_FFFFFF_t_70]

### 二、源码分析 ###

Debug 测试类入口：`org.springframework.beans.factory.xml.XmlBeanDefinitionReaderTests#withOpenInputStream`。

下面只是把核心流程拿出来作了分析，一些细节知识点，有兴趣的可以自行了解。

测试代码如下

@Test(expected = BeanDefinitionStoreException.class)
        public void withOpenInputStream() { 
            /** * 注意这里初始化的是 SimpleBeanDefinitionRegistry 不具备 BeanFactory 功能 * 仅仅用来注册 BeanDefinition，不能用来创建 bean */
            SimpleBeanDefinitionRegistry registry = new SimpleBeanDefinitionRegistry();
            Resource resource = new InputStreamResource(getClass().getResourceAsStream("test.xml"));
            new XmlBeanDefinitionReader(registry).loadBeanDefinitions(resource);
        }

`loadBeanDefinitions` 源码如下

@Override
        public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException { 
            // 使用 EncodedResource 包装 Resource，EncodedResource 可以指定字符集编码
            return loadBeanDefinitions(new EncodedResource(resource));
        }
    
        public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException { 
            Assert.notNull(encodedResource, "EncodedResource must not be null");
            if (logger.isTraceEnabled()) { 
                logger.trace("Loading XML bean definitions from " + encodedResource);
            }
    
            // 获取已经加载过的资源集合
            Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
            if (currentResources == null) { 
                // 初始化 currentResources
                currentResources = new HashSet<>(4);
                // 设置初始化的 currentResources
                this.resourcesCurrentlyBeingLoaded.set(currentResources);
            }
            if (!currentResources.add(encodedResource)) { 
                throw new BeanDefinitionStoreException(
                        "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
            }
            try { 
                // 根据 Resource 获取输入流
                InputStream inputStream = encodedResource.getResource().getInputStream();
                try { 
                    InputSource inputSource = new InputSource(inputStream);
                    if (encodedResource.getEncoding() != null) { 
                        inputSource.setEncoding(encodedResource.getEncoding());
                    }
                    // 核心逻辑，加载 bean 资源
                    return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
                }
                finally { 
                    inputStream.close();
                }
            }
            catch (IOException ex) { 
                throw new BeanDefinitionStoreException(
                        "IOException parsing XML document from " + encodedResource.getResource(), ex);
            }
            finally { 
                currentResources.remove(encodedResource);
                if (currentResources.isEmpty()) { 
                    this.resourcesCurrentlyBeingLoaded.remove();
                }
            }
        }

#### 2.1 获取输入流 ####

测试类中定义的是 `InputStreamResource`，下面 `InputStreamResource` 中 `getInputStream()` 的实现。

@Override
        public InputStream getInputStream() throws IOException { 
            InputStream is;
            if (this.clazz != null) { 
                is = this.clazz.getResourceAsStream(this.path);
            }
            else if (this.classLoader != null) { 
                is = this.classLoader.getResourceAsStream(this.path);
            }
            else { 
                is = ClassLoader.getSystemResourceAsStream(this.path);
            }
            if (is == null) { 
                throw new FileNotFoundException(getDescription() + " cannot be opened because it does not exist");
            }
            return is;
        }

#### 2.2 转化 `Document` 对象 ####

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
                throws BeanDefinitionStoreException { 
            try { 
                // 获取 XML 对应 document 实例
                Document doc = doLoadDocument(inputSource, resource);
                // 调用 registerBeanDefinitions 方法注册 BeanDefinitions
                int count = registerBeanDefinitions(doc, resource);
                if (logger.isDebugEnabled()) { 
                    logger.debug("Loaded " + count + " bean definitions from " + resource);
                }
                return count;
            }
            catch (Throwable ex) { 
                throw new BeanDefinitionStoreException(resource.getDescription(),
                        "Unexpected exception parsing XML document from " + resource, ex);
            }
        }

`doLoadBeanDefinitions` 方法中调用 `doLoadDocument` 初始化 `Document` 对象，内部实现比较简单，下面一起来看一下。

protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception { 
            return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
                    getValidationModeForResource(resource), isNamespaceAware());
        }

上面涉及到几个关于 XML 的知识点，下面简单的介绍一下，最后有列出参考文章，有兴趣的可以翻翻。

*  `EntityResolver`：XML 文件解析器
 *  `errorHandler`：解析出错处理机制
 *  `getValidationModeForResource()`： 获取 XML 验证格式，XML 一般支持 DTD 与 XSD，也可以自定义，主要用来约束与验证 XML 文档格式
 *  `isNamespaceAware()`：判断解析器是否支持解析当前 XML 文件,`<beans xmlns=""/>` 其中 `xmlns` 就是命名空间

@Override
        public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
                ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception { 
    
            // 创建 DocumentBuilderFactory
            DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
            if (logger.isTraceEnabled()) { 
                logger.trace("Using JAXP provider [" + factory.getClass().getName() + "]");
            }
            // 创建一个 DocumentBuilder
            DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
            // 以 SAX 形式解析 XML
            return builder.parse(inputSource);
        }

上面 `DocumentBuilderFactory` 与 `DocumentBuilder` 都是 JDK 中提供的类，根据 XML 输入流获取 `Document` 的过程没有深入跟踪，这里就不展开分析了。

#### 2.3 处理 `Document` 节点 ####

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException { 
            // 通过反射创建一个 BeanDefinitionDocumentReader 对象
            BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
            // 获取已经注册的 BeanDefinition 的数量，-> beanDefinitionMap 的 size
            int countBefore = getRegistry().getBeanDefinitionCount();
            // 创建 XmlReaderContext，注册 BeanDefinitions
            documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
            // 返回最新注册的 bean 的数量
            return getRegistry().getBeanDefinitionCount() - countBefore;
        }
    
    
        @Override
        public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) { 
            this.readerContext = readerContext;
            doRegisterBeanDefinitions(doc.getDocumentElement());
        }
    
        protected void doRegisterBeanDefinitions(Element root) { 
            BeanDefinitionParserDelegate parent = this.delegate;
            this.delegate = createDelegate(getReaderContext(), root, parent);
    
            // 检查 <beans> 标签的命名空间是否为空，或者是 http://www.springframework.org/schema/beans
            if (this.delegate.isDefaultNamespace(root)) { 
                // 获取 profile 的值，beans 标签可以设置 profile 属性用于多环境配置管理
                String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
                if (StringUtils.hasText(profileSpec)) { 
                    // 处理 profile 多个值
                    String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                            profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
                    // 判断是否有默认启用的 profile
                    if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) { 
                        if (logger.isDebugEnabled()) { 
                            logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                                    "] not matching: " + getReaderContext().getResource());
                        }
                        return;
                    }
                }
            }
    
            // 解析前处理，空实现，可自定义
            preProcessXml(root);
            // 解析 document 实例
            parseBeanDefinitions(root, this.delegate);
            // 解析后处理，空实现，可自定义
            postProcessXml(root);
    
            this.delegate = parent;
        }
    
        protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) { 
            // 命名空间检查，Spring XML 中不仅可以配置 <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)) { 
                            parseDefaultElement(ele, delegate);
                        }
                        else { 
                            delegate.parseCustomElement(ele);
                        }
                    }
                }
            }
            else { 
                // samples：<tx:annotation-driven>
                delegate.parseCustomElement(root);
            }
        }
    
        private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) { 
            // import，samples：<import resource="classpath:/org/springframework/beans/factory/xml/test.xml"/>
            if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) { 
                // 根据 resource 值定位资源，递归调用 loadBeanDefinitions 逐个加载
                importBeanDefinitionResource(ele);
            }
            // alias
            else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) { 
                // 处理别名标签，最终注册到 aliasMap 中
                processAliasRegistration(ele);
            }
            // bean
            else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) { 
                // 转化成 BeanDefinition
                processBeanDefinition(ele, delegate);
            }
            // beans
            else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { 
                // 递归调用
                doRegisterBeanDefinitions(ele);
            }
        }

在获取 `Document` 对象后，后续流程会遍历所有子节点，根据子标签名分别走不同的处理流程，我们主要是来了解怎么初始化与注册 `BeanDefinition` 的，其他标签就不详细介绍了。

1.  利用反射创建 `BeanDefinitionDocumentReader` 对象
2.  获取已经注册的 `BeanDefinition` 的数量，其实就是 `beanDefinitionMap` 的 size 大小
3.  检查 `<beans />` 标签命名空间是否为空，或者配置为 `http://www.springframework.org/schema/beans`，如果条件满足，获取 `profile` 指定的环境属性值，判断指定的环境是否有处于启用状态的，都不启用直接返回，不会对 `Document` 进行解析，关于 `profile` 属性的作用，最后会给一些参考文章
4.  解析前置处理，空实现，可自定义
5.  如果是默认命名空间，获取 下所有子标签，进行遍历，判断子标签是 `import`、`alias`、`bean` 还是 `beans`
6.  解析后置处理，空实现，可自定义

#### 2.3 BeanDefinition 初始化 ####

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) { 
            // 处理 <bean /> 标签，把标签属性与子标签信息封装在 BeanDefinition 中
            BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
            if (bdHolder != null) { 
                // 装饰 BeanDefinition
                bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
                try { 
                    // Register the final decorated instance.
                    // 注册 BeadDefinition
                    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));
            }
        }
    
        @Nullable
        public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) { 
            return parseBeanDefinitionElement(ele, null);
        }
    
        @Nullable
        public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) { 
            // <bean name="b1,b2,b3" /> id 与 name 的属性功能类似，name 属性支持创建多个别名
            // 获取 id 属性
            String id = ele.getAttribute(ID_ATTRIBUTE);
            // 获取 name 属性
            String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
    
            // 处理 name 属性的别名
            List<String> aliases = new ArrayList<>();
            if (StringUtils.hasLength(nameAttr)) { 
                String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
                aliases.addAll(Arrays.asList(nameArr));
            }
    
            // 优先使用 id 属性的别名
            String beanName = id;
            // 如果 id 属性为空，且 name 属性不为空使用 name 属性中的第一个
            if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) { 
                // 移出别名集合
                beanName = aliases.remove(0);
                if (logger.isTraceEnabled()) { 
                    logger.trace("No XML 'id' specified - using '" + beanName +
                            "' as bean name and " + aliases + " as aliases");
                }
            }
    
            // 需要检查 beanName 的唯一性，避免与其他 bean 重复
            if (containingBean == null) { 
                checkNameUniqueness(beanName, aliases, ele);
            }
    
            // 获取 AbstractBeanDefinition 实例，该对象中保存了 <bean /> 标签中的基本属性信息
            AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
            if (beanDefinition != null) { 
                // TODO 定义一个 bean 并不一必须定要为其定义 id、name 属性
                // 如果没有定义 id 或者 name 属性，则想办法生成 beanName
                if (!StringUtils.hasText(beanName)) { 
                    try { 
                        if (containingBean != null) { 
                            /** * 使用 className 属性生成 beanName * beanName + # + beanDefinition 哈希值的十六进制字符 */
                            beanName = BeanDefinitionReaderUtils.generateBeanName(
                                    beanDefinition, this.readerContext.getRegistry(), true);
                        }
                        else { 
                            beanName = this.readerContext.generateBeanName(beanDefinition);
                            String beanClassName = beanDefinition.getBeanClassName();
                            if (beanClassName != null &&
                                    beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
                                    !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) { 
                                aliases.add(beanClassName);
                            }
                        }
                        if (logger.isTraceEnabled()) { 
                            logger.trace("Neither XML 'id' nor 'name' specified - " +
                                    "using generated bean name [" + beanName + "]");
                        }
                    }
                    catch (Exception ex) { 
                        error(ex.getMessage(), ele);
                        return null;
                    }
                }
                // 构造 BeanDefinitionHolder 对象并返回
                String[] aliasesArray = StringUtils.toStringArray(aliases);
                return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
            }
    
            return null;
        }
    
        @Nullable
        public AbstractBeanDefinition parseBeanDefinitionElement(
                Element ele, String beanName, @Nullable BeanDefinition containingBean) { 
    
            // 将 beanName 存储到一个 LinkedList 中
            this.parseState.push(new BeanEntry(beanName));
    
            // 记录 className
            String className = null;
            // 获取 class 属性
            if (ele.hasAttribute(CLASS_ATTRIBUTE)) { 
                className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
            }
            String parent = null;
            // 判断是否有 parent 属性
            if (ele.hasAttribute(PARENT_ATTRIBUTE)) { 
                parent = ele.getAttribute(PARENT_ATTRIBUTE);
            }
    
            try { 
                // 创建用于承载 XML 属性配置的 AbstractBeanDefinition 实例
                AbstractBeanDefinition bd = createBeanDefinition(className, parent);
    
                // 解析 <bean /> 标签的各种属性，比如 scope、lazy-init、autowire 等
                parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
                // 解析描述信息
                bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
    
                /** * 以下处理 <bean /> 的子标签，这里可以优化，循环一次对子标签分类处理 * 下面每处理一个子标签就需要循环一次 <bean /> 所有的子标签 */
    
                // 处理 <meta/>
                parseMetaElements(ele, bd);
                // 解析 lookup-method 属性 <lookup-method />
                parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
                // 解析 replaced-method 属性 <replaced-method />
                parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
    
                // 解析构造函数参数 <constructor-arg />
                parseConstructorArgElements(ele, bd);
                // 解析 property 子元素 <property />
                parsePropertyElements(ele, bd);
                // 解析 qualifier 子元素 <qualifier />
                parseQualifierElements(ele, bd);
    
                // 设置 Resource 实例
                bd.setResource(this.readerContext.getResource());
                bd.setSource(extractSource(ele));
    
                return bd;
            }
            catch (Throwable ex) { 
                error("Unexpected failure during bean definition parsing", ele, ex);
            }
            finally { 
                this.parseState.pop();
            }
    
            return null;
        }

初始化 `BeanDefinition` 的过程就是把 `<bean />` 标签及子标签的属性保存到 `BeanDefinition` 中，没有什么复杂的逻辑。

#### 2.4 注册 BeanDefinition ####

public static void registerBeanDefinition(
                BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
                throws BeanDefinitionStoreException { 
    
            // Register bean definition under primary name.
            // 获取 beanName 并根据 beanName 注册 BeanDefinition
            String beanName = definitionHolder.getBeanName();
            registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
    
            // Register aliases for bean name, if any.
            // 从 BeanDefinition 中获取所有的别名，并根据 beanName 注册别名
            String[] aliases = definitionHolder.getAliases();
            if (aliases != null) { 
                for (String alias : aliases) { 
                    // 注册所有的别名，保存到 aliasMap 中
                    registry.registerAlias(beanName, alias);
                }
            }
        }
    
        @Override
        public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
                throws BeanDefinitionStoreException { 
    
            Assert.hasText(beanName, "'beanName' must not be empty");
            Assert.notNull(beanDefinition, "BeanDefinition must not be null");
            // 保存到 beanDefinitionMap 中
            this.beanDefinitionMap.put(beanName, beanDefinition);
        }

因为测试类中定义的是 `SimpleBeanDefinitionRegistry`，因此应该定位到 `SimpleBeanDefinitionRegistry` 中的 `registerBeanDefinition`，这里的处理流程很简单，直接把 `BeanDefinition` 与 `beanName` 关联保存到 `beanDefinitionMap` 中。

`SimpleBeanDefinitionRegistry` 并不是一个工厂，不具备初始化 bean 的能力。后面在创建 bean 的流程中还会接触到 `DefaultListableBeanFactory#registerBeanDefinition` 注册流程，稍微比这个复杂些，但是其核心逻辑都是保存到 `beanDefinitionMap` 。

### 参考阅读 ###

[XML中DTD,XSD的区别与应用][XML_DTD_XSD]  
[xsd，dtd，tld有什么区别和联系？][xsd_dtd_tld]  
[细说java解析XML文档的常用方法（含实例）][java_XML]  
[详解Spring中的Profile][Spring_Profile]

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL3pjaGVuOTYvc3ByaW5nLWZyYW1ld29yay01LjEuNy1zb3VyY2UtY29kZS1yZWFkL21hc3Rlci9pbWFnZS9pb2MvQmVhbkRlZmluaXRpb24yLnBuZw?x-oss-process=image/format,png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvZGVqYXM_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200413203758798.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NvZGVqYXM=,size_16,color_FFFFFF,t_70
[XML_DTD_XSD]: https://www.jianshu.com/p/13b205ba2175
[xsd_dtd_tld]: https://www.zhihu.com/question/38843167
[java_XML]: https://zhuanlan.zhihu.com/p/66284713
[Spring_Profile]: https://www.jianshu.com/p/948c303b2253