XmlBeanFactory加载BeanDefinition的流程

发表于 分类于 Waline： 阅读次数：

XmlBeanFactory 是一个最简单的 BeanFactory 实现，它支持通过 xml 的形式配置和管理 bean。本文主要关注其解析 xml 和加载 BeanDefinition 的流程。

XmlBeanFactory 继承自 DefaultListableBeanFactory，后者是一个功能完备的 BeanFactory 实现类，XmlBeanFactory 在它的基础上增加了读取 xml 解析 BeanDefinition 的功能。XmlBeanFactory 并没有自己完成这些工作，而是交给了 XmlBeanDefinitionReader 类来实现。

1
2
3
4
5
6
7
8
9
10
11
public class XmlBeanFactory extends DefaultListableBeanFactory {
   private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);

   // 省略其他无关代码。。。
	 
   public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
      super(parentBeanFactory);
      // 解析 xml，加载 bean definition
      this.reader.loadBeanDefinitions(resource);
   }
}

Document 的加载

在获取到表示资源的 Resource 对象之后，首先要从中读取 inputStream 并转换成用于表示 xml 文档的 Document 对象。

Document 的加载是委托给 DefaultDocumentLoader 类来处理的。DefaultDocumentLoader 是 DocumentLoader 的默认实现，它使用标准的 JAXP XML 解析器加载 Document。它的类继承结构如下图所示：

image-20200410011926136

loadDocument 方法用于解析输入流，生成 Document 对象，主要流程如下：

  1. 构建 DocumentBuilderFactory
  2. 通过 DocumentBuilderFactory 构建 DocumentBuilder
  3. 使用 builder 解析输入流，生成 Document 对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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);
   
   // 解析输入流
   return builder.parse(inputSource);
}

DocumentBuilderFactory 的构建

DocumentBuilderFactory 是通过它的工厂方法创建的，根据验证模式（DTD模式、XSD 模式）的不同需设置不同的属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
protected DocumentBuilderFactory createDocumentBuilderFactory(int validationMode, boolean namespaceAware) throws ParserConfigurationException {

   DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
   factory.setNamespaceAware(namespaceAware);

   if (validationMode != XmlValidationModeDetector.VALIDATION_NONE) {
      factory.setValidating(true);

      // XSD模式的独有逻辑
      if (validationMode == XmlValidationModeDetector.VALIDATION_XSD) {
         factory.setNamespaceAware(true);
         try {
            // 设置固定属性
            factory.setAttribute(SCHEMA_LANGUAGE_ATTRIBUTE, XSD_SCHEMA_LANGUAGE);
         }
         catch (IllegalArgumentException ex) {
            // 忽略异常的构建
            throw pcex;
         }
      }
   }

   return factory;
}

DocumentBuilder 的构建

DocumentBuilder 是通过 DocumentBuilderFactory 创建的，另外需要设置 EntityResolver 和 ErrorHandler

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
protected DocumentBuilder createDocumentBuilder(DocumentBuilderFactory factory,
      @Nullable EntityResolver entityResolver, @Nullable ErrorHandler errorHandler)
      throws ParserConfigurationException {

   // 创建一个新的 DocumentBuilder
   // 通过调用 com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl
   // 创建 com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderImpl 实例
   DocumentBuilder docBuilder = factory.newDocumentBuilder();

   // 设置 SAX EntityResolver
   if (entityResolver != null) {
      docBuilder.setEntityResolver(entityResolver);
   }

   // 设置 SAX ErrorHandler
   if (errorHandler != null) {
      docBuilder.setErrorHandler(errorHandler);
   }
   return docBuilder;
}

其中 EntityResolver 用于解析外部实体，需要根据 publicId 和 systemId 定位到资源，并将其解析为 InputResource 对象，如下是一个示例

1
2
3
4
5
6
7
8
9
10
11
12
public class MyResolver implements EntityResolver {
    public InputSource resolveEntity(String publicId, String systemId) {
        if (systemId.equals("http://www.myhost.com/today")) {
            // return a special input source
            MyReader reader = new MyReader();
            return new InputSource(reader);
        } else {
            // use the default behaviour
            return null;
        }
    }
}

Spring 通过 DelegatingEntityResolver 来完成 DTD 或 XSD 文档的解析。

1
2
3
4
5
6
7
8
9
10
11
12
13
public InputSource resolveEntity(String publicId, @Nullable String systemId) throws SAXException, IOException {
   if (systemId != null) {
      if (systemId.endsWith(DTD_SUFFIX)) {
         // dtd 格式文档解析
         return this.dtdResolver.resolveEntity(publicId, systemId);
      }
      else if (systemId.endsWith(XSD_SUFFIX)) {
         // xsd 格式文档解析，默认到 META-INF/spring.schemas 中查找
         return this.schemaResolver.resolveEntity(publicId, systemId);
      }
   }
   return null;
}

DelegatingEntityResolver 并不是一个真正的执行者，它将 DTD 和 XSD 格式的文档的解析分别委托给 BeansDtdResolver 和 PluggableSchemaResolver

如下为 PluggableSchemaResolver 的解析方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public InputSource resolveEntity(String publicId, @Nullable String systemId) throws IOException {
   if (systemId != null) {
      // 获取 systemId 对应的本地文件位置
      String resourceLocation = getSchemaMappings().get(systemId);
      if (resourceLocation != null) {
         // 加载文件
         Resource resource = new ClassPathResource(resourceLocation, this.classLoader);
         try {
            // 封装为 InputSource
            InputSource source = new InputSource(resource.getInputStream());
            source.setPublicId(publicId);
            source.setSystemId(systemId);
            
            return source;
         }
         catch (FileNotFoundException ex) {
            // 忽略日志
         }
      }
   }
   return null;
}

它的 getSchemaMappings 方法会从 META-INF/spring.schemas 文件中读取配置信息（systemId 到 XSD 文档的映射关系），这样 resolveEntity 方法就可以根据 systemId 找到 class path 下的 XSD 文档并加载为 InputSource，从而避免了从网络下载文档的不稳定性

1
2
3
// 加载 META-INF/spring.schemas 文件配置
Properties mappings =
      PropertiesLoaderUtils.loadAllProperties(this.schemaMappingsLocation, this.classLoader);

解析 inputSource

有了 DocumentBuilder 后就可以解析输入流了

1
return builder.parse(inputSource);

这里的 inputSource 是一个 InputSource 类型的实例，它封装了 inputStream，并且设置了编码。具体的 parse 流程就不贴出来了。

1
2
3
4
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
   inputSource.setEncoding(encodedResource.getEncoding());
}

创建 BeanDefinitionDocumentReader

上一步已经构建好了 Document 对象，接下来看下要怎么读取、解析和注册 BeanDefinition。

BeanDefinitionDocumentReader

BeanDefinitionDocumentReader 用于读取 Document 对象，完成 BeanDefintion 的注册。

DefaultBeanDefinitionDocumentReader 是 BeanDefinitionDocumentReader 的一个默认实现类，它的继承结构如下图所示：

image-20200410014832813

createBeanDefinitionDocumentReader

如下是创建 DefaultBeanDefinitionDocumentReader 实例的代码，可以看出是通过反射创建的。

1
2
3
4
5
private Class<? extends BeanDefinitionDocumentReader> documentReaderClass =
			DefaultBeanDefinitionDocumentReader.class;
protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() {
   return BeanUtils.instantiateClass(this.documentReaderClass);
}

registerBeanDefinitions

有了 BeanDefinitionDocumentReader 之后就可以处理 Document 了，这是通过它的 registerBeanDefinitions 方法实现的

1
2
void registerBeanDefinitions(Document doc, XmlReaderContext readerContext)
      throws BeanDefinitionStoreException;

createReaderContext

registerBeanDefinitions 入参中有一个 XmlReaderContext 对象，它是通过如下方式创建的：

1
2
3
4
public XmlReaderContext createReaderContext(Resource resource) {
   return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
         this.sourceExtractor, this, getNamespaceHandlerResolver());
}

注意到最后一个参数是通过 getNamespaceHandlerResolver 方法获取到的，该方法返回了一个 NamespaceHandlerResolver 类型的对象，它的默认类是 DefaultNamespaceHandlerResolver

image-20200410015824553

NamespaceHandlerResolver 接口提供了一个 resolve 方法，它可以从 META-INF/spring.handlers 文件中读取 namespaceUri 到 NamespaceHandler 的映射关系，在使用时根据 namespaceUri 返回对应的 NamespaceHandler，这可以用于自定义 namespace 处理逻辑。如下是一个 META-INF/spring.handlers 文件的示例：

1
2
3
http\://www.springframework.org/schema/c=org.springframework.beans.factory.xml.SimpleConstructorNamespaceHandler
http\://www.springframework.org/schema/p=org.springframework.beans.factory.xml.SimplePropertyNamespaceHandler
http\://www.springframework.org/schema/util=org.springframework.beans.factory.xml.UtilNamespaceHandler

createDelegate

创建委托类，用于解析 XML bean 定义

1
2
3
BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext);
delegate.initDefaults(root, parentDelegate);
return delegate;

initDefaults 方法会为 DocumentDefaultsDefinition 设置默认属性值，设置完之后发送事件通知

1
2
3
4
5
6
7
public void initDefaults(Element root, @Nullable BeanDefinitionParserDelegate parent) {
   // 填充默认值
   populateDefaults(this.defaults, (parent != null ? parent.defaults : null), root);

   // 通知已设置完默认值
   this.readerContext.fireDefaultsRegistered(this.defaults);
}

填充默认值

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
protected void populateDefaults(DocumentDefaultsDefinition defaults, @Nullable DocumentDefaultsDefinition parentDefaults, Element root) {
   String lazyInit = root.getAttribute(DEFAULT_LAZY_INIT_ATTRIBUTE);
   if (isDefaultValue(lazyInit)) {
      // Potentially inherited from outer <beans> sections, otherwise falling back to false.
      // lazyInit默认值为false
      lazyInit = (parentDefaults != null ? parentDefaults.getLazyInit() : FALSE_VALUE);
   }
   defaults.setLazyInit(lazyInit);

   String merge = root.getAttribute(DEFAULT_MERGE_ATTRIBUTE);
   if (isDefaultValue(merge)) {
      // Potentially inherited from outer <beans> sections, otherwise falling back to false.
      merge = (parentDefaults != null ? parentDefaults.getMerge() : FALSE_VALUE);
   }
   defaults.setMerge(merge);

   String autowire = root.getAttribute(DEFAULT_AUTOWIRE_ATTRIBUTE);
   if (isDefaultValue(autowire)) {
      // Potentially inherited from outer <beans> sections, otherwise falling back to 'no'.
      // autoWire默认值为no
      autowire = (parentDefaults != null ? parentDefaults.getAutowire() : AUTOWIRE_NO_VALUE);
   }
   defaults.setAutowire(autowire);

   if (root.hasAttribute(DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE)) {
      defaults.setAutowireCandidates(root.getAttribute(DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE));
   }
   else if (parentDefaults != null) {
      defaults.setAutowireCandidates(parentDefaults.getAutowireCandidates());
   }

   if (root.hasAttribute(DEFAULT_INIT_METHOD_ATTRIBUTE)) {
      defaults.setInitMethod(root.getAttribute(DEFAULT_INIT_METHOD_ATTRIBUTE));
   }
   else if (parentDefaults != null) {
      defaults.setInitMethod(parentDefaults.getInitMethod());
   }

   if (root.hasAttribute(DEFAULT_DESTROY_METHOD_ATTRIBUTE)) {
      defaults.setDestroyMethod(root.getAttribute(DEFAULT_DESTROY_METHOD_ATTRIBUTE));
   }
   else if (parentDefaults != null) {
      defaults.setDestroyMethod(parentDefaults.getDestroyMethod());
   }

   defaults.setSource(this.readerContext.extractSource(root));
}

处理 profile

如果是默认的 namespace，则检查 profile 是否生效

1
2
3
4
5
6
7
8
9
10
11
12
13
14
if (this.delegate.isDefaultNamespace(root)) {
   // 解析 profile 属性，比如每个环境对应一套 bean 配置
   String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
   if (StringUtils.hasText(profileSpec)) {
      String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
            profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
      // We cannot use Profiles.of(...) since profile expressions are not supported
      // in XML config. See SPR-12458 for details.
      if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
         
         return;
      }
   }
}

parseBeanDefinitions

到这里要开始处理 Document 文档，解析 BeanDefinition 了。如果是默认的 namespace，则循环遍历节点。如果 Element 是默认 namespace 的，则需按照默认元素处理。其他情况按照自定义元素处理

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
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);
   }
}

默认 namspace 的处理

根据节点名的不同分别进行处理

解析 import 元素

  1. 解析 location，替换 placeholder，得到实际的 location

  2. 判断是否为绝对路径，如果是绝对路径，则直接通过 XmlBeanDefinitionReader 加载 BeanDefinition

    1
    int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);

  3. 否则，按照相对路径处理

    1. 根据相对路径加载资源

      1
      Resource relativeResource = getReaderContext().getResource().createRelative(location)

    2. 判断 Resource 是否存在，若存在则可以直接加载

      1
      2
      3
      4
      if (relativeResource.exists()) {
         importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
         actualResources.add(relativeResource);
      }

    3. 否则，通过URL拼接路径后加载

      1
      2
      3
      String baseLocation = getReaderContext().getResource().getURL().toString();
      importCount = getReaderContext().getReader().loadBeanDefinitions(
            StringUtils.applyRelativePath(baseLocation, location), actualResources);

  4. 发送 import 完成事件

    1
    2
    Resource[] actResArray = actualResources.toArray(new Resource[0]);
    getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));

解析 alias 元素

主要就是获取 alias name，然后往 AliasRegistry 中注册

1
getReaderContext().getRegistry().registerAlias(name, alias);

同样也会发送完成事件

1
getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));

解析 bean 元素

这个是注册 BeanDefinition的关键

委托 delegate 解析元素
1
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

主要就是解析 xml 元素的值，然后设置到 beanDefinition 中

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
28
29
// 创建beanDefinition，仅设置类相关信息
AbstractBeanDefinition bd = createBeanDefinition(className, parent);

// 解析并设置bean属性
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

// 解析meta数据
parseMetaElements(ele, bd);

// Lookup元素
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());

// 方法覆盖
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

// 构造函数参数
parseConstructorArgElements(ele, bd);

// 属性
parsePropertyElements(ele, bd);

// qualifier
parseQualifierElements(ele, bd);

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

return bd;

如果 xml 中未设置 bean 的 id 和 name，还要生成一个唯一的 id

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
if (containingBean != null) {
   // 生成一个在bean容器中唯一的名字
   beanName = BeanDefinitionReaderUtils.generateBeanName(
         beanDefinition, this.readerContext.getRegistry(), true);
}
else {
   beanName = this.readerContext.generateBeanName(beanDefinition);
   // Register an alias for the plain bean class name, if still possible,
   // if the generator returned the class name plus a suffix.
   // This is expected for Spring 1.2/2.0 backwards compatibility.
   String beanClassName = beanDefinition.getBeanClassName();
   if (beanClassName != null &&
         beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
         !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
      aliases.add(beanClassName);
   }
}

最终的结果会封装为 BeanDefinitionHolder

1
2
// 封装结果并返回
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
进行必要的装饰
1
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

前面提到了 NamespaceHandler 的注册，这里就是用它进行 decorate 的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) {
   NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
   if (handler != null) {
      BeanDefinitionHolder decorated =
            handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
      if (decorated != null) {
         return decorated;
      }
   }
   else if (namespaceUri.startsWith("http://www.springframework.org/")) {
      error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);
   }
   else {
      // 忽略
   }
}
注册最终装饰过的实例
1
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

如下是 BeanDefintion 注册的相关代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static void registerBeanDefinition(
      BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
      throws BeanDefinitionStoreException {

   // Register bean definition under primary name.
   // 注册beanDefinition
   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 alias : aliases) {
         registry.registerAlias(beanName, alias);
      }
   }
}

主要是往 BeanDefinitionRegistry 中注册 beanName 到 BeanDefintion 的映射关系，如果有别名，还需要一并注册进去

发送注册通知事件
1
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder))

解析嵌套 bean 元素

递归处理元素

1
doRegisterBeanDefinitions(ele);

自定义 namspace 的处理

Spring 还可以自定义 XSD 元素，并提供对应的元素处理器

getNamespaceURI

获取 element 的 namespace uri

1
2
3
public String getNamespaceURI(Node node) {
   return node.getNamespaceURI();
}

getNamespaceHandler

1
NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
  1. 首先要获取 NamespaceHandlerResolver，取到的是 DefaultNamespaceHandlerResolver，这是在前面 createReaderContext 的时候创建的
  2. 根据 namespaceUri 获取 NamespaceHandler
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public NamespaceHandler resolve(String namespaceUri) {
   // URI -> NamespaceHandler的实例或类名
   Map<String, Object> handlerMappings = getHandlerMappings();

   // 根据 namespaceUri 获取 handler
   Object handlerOrClassName = handlerMappings.get(namespaceUri);

   if (handlerOrClassName == null) {
      return null;
   }
   // 取到的是实例
   else if (handlerOrClassName instanceof NamespaceHandler) {
      return (NamespaceHandler) handlerOrClassName;
   }
   // 取到的是类名
   else {
      String className = (String) handlerOrClassName;
      try {
         Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
         if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
            throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
                  "] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
         }

         // 实例化
         NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);

         // 初始化
         namespaceHandler.init();

         // 放到 map 中
         // 下次获取到的就是实例，而不是 class name
         handlerMappings.put(namespaceUri, namespaceHandler);

         return namespaceHandler;
      }
      catch (ClassNotFoundException ex) {
         throw new FatalBeanException("Could not find NamespaceHandler class [" + className +
               "] for namespace [" + namespaceUri + "]", ex);
      }
      catch (LinkageError err) {
         throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" +
               className + "] for namespace [" + namespaceUri + "]", err);
      }
   }
}

其中 HandlerMapping 是解析 META-INF/spring.handlers 的结果

使用 NamespaceHandler 解析元素

1
2
// parse
return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));

整体流程

下图是整体处理流程

image-20200411125807780

相关文章
  • 2020-04-18
    dubbo的Reference注解是如何生效的

    在 dubbo的Reference注解实现原理 中提到，@Reference 注解用于实现 RPC client 代理的自动注入，这是通过 ReferenceAnnotationBeanPostProcessor 来实现的。若要让其生效，还需要在这之前将其注册到 BeanFactory 中。

  • 2020-01-14
    Spring源码阅读：BeanDefinitionRegistry接口

    BeanDefinitionRegistry 是一个接口，从名字上就可以看出来，它是一个管理 BeanDefinition 的注册中心。通常情况下，BeanFactory 的具体实现类也会实现该接口，用于管理 AbstractBeanDefinition 继承结构下的 BeanDefinition 实例，例如 RootBeanDefinition 和 ChildBeanDefinition 实例。

  • 2020-01-22
    Spring源码阅读：XmlBeanFactory的继承结构

    XmlBeanFactory 可以说是 Spring 中一个最简单的 BeanFactory，通过它可以了解 Spring 的设计思路。

  • 2017-06-20
    Hello World

    Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

    Quick Start

    Create a new post

    1
    $ hexo new "My New Post"

  • 2020-01-17
    Spring源码阅读：BeanDefinition接口

    前面说到 BeanDefinitionRegistry 是用来管理 BeanDefinition 的注册中心，但是还没看到 BeanDefinition 长什么样，下面就来了解下。