Spring5源码分析(012)——IoC篇之解析bean标签：解析 BeanDefinition

注：《Spring5源码分析》汇总可参考：Spring5源码分析(002)——博客汇总

　　bean 标签解析的第一步，就是委托 BeanDefinitionParserDelegate.parseBeanDefinitionElement(Element ele) 方法进行元素解析，返回 BeanDefinitionHolder 实例对象 bdHolder ，即解析 BeanDefinition 。

如果解析成功，则 bdHolder 实例已经包含配置文件的各种属性，例如 class 、 name 、 id 、 alias 之类的属性。
- BeanDefinitionHolder 内部有 beanDefinition 、 beanName 、 aliases 3 个属性，而其中的 beanDefinition 则是 bean 的具体定义。
如果解析失败，则 bdHolder 实例为 null 。

接下来会对 parseBeanDefinitionElement(Element ele) 方法分析。本文目录结构如下：

1、parseBeanDefinitionElement(Element ele)
2、parseBeanDefinitionElement( Element ele, String beanName, @Nullable BeanDefinition containingBean)
- 2.1、createBeanDefinition
3、总结
4、参考

1、parseBeanDefinitionElement(Element ele)

　　BeanDefinitionParserDelegate.parseBeanDefinitionElement(Element ele) 方法，对 <bean> 标签进行元素解析，也即是解析 BeanDefinition 的过程，代码如下：

/**
 * Parses the supplied {@code <bean>} element. May return {@code null}
 * if there were errors during parse. Errors are reported to the
 * {@link org.springframework.beans.factory.parsing.ProblemReporter}.
 * <p>解析提供的 <bean> 标签元素。如果在解析过程中出现错误，可以返回 null 。
 * 错误将会报告给 {@link org.springframework.beans.factory.parsing.ProblemReporter} 进行处理。
 */
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
    return parseBeanDefinitionElement(ele, null);
}

/**
 * Parses the supplied {@code <bean>} element. May return {@code null}
 * if there were errors during parse. Errors are reported to the
 * {@link org.springframework.beans.factory.parsing.ProblemReporter}.
 */
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
    // 1.1、解析 id 、 name 属性
    String id = ele.getAttribute(ID_ATTRIBUTE);
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

    // 1.2、分割 name 属性，作为别名 alias 集合
    List<String> aliases = new ArrayList<>();
    if (StringUtils.hasLength(nameAttr)) {
        String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
        aliases.addAll(Arrays.asList(nameArr));
    }
    // 1.3、beanName ： 先默认使用 id
    String beanName = id;
    if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
        // 若 id 没有设置，则使用别名 alias 的第一个，同时移除这个别名
        beanName = aliases.remove(0);
        if (logger.isTraceEnabled()) {
            logger.trace("No XML 'id' specified - using '" + beanName +
                    "' as bean name and " + aliases + " as aliases");
        }
    }
    // 1.4、检查 beanName 和 alias 的唯一性
    if (containingBean == null) {
        checkNameUniqueness(beanName, aliases, ele);
    }
    // 2、解析属性，构造 AbstractBeanDefinition 对象
    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
    if (beanDefinition != null) {
        // 再次检查 beanName
        if (!StringUtils.hasText(beanName)) {
            try {
                if (containingBean != null) {
                    // 3.1、beanName 还是不存在，则根据 Spring 提供的命名规则生成唯一的 beanName ，
                    // 这个是内部 bean ，比较常见的格式就是： 类全限定名#十六进制字符串（对象的标识哈希码）
                    beanName = BeanDefinitionReaderUtils.generateBeanName(
                            beanDefinition, this.readerContext.getRegistry(), true);
                }
                else {
                    // 3.2、生成唯一的 beanName ，比较常见的格式就是： 类全限定名#counter(从0开始)
                    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.
                    // 增加别名 beanClassName ，兼容 1.2/2.0
                    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;
            }
        }
        // 4、创建 BeanDefinitionHolder 对象
        String[] aliasesArray = StringUtils.toStringArray(aliases);
        return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
    }

    return null;
}

　　这个方法大致可以分为3个部分，实际的 bean 解析也只是进行了委托处理。这 3 个部分处理如下：

1、beanName 和 aliad 的确定，即 beanNam 的命名规则，上面注释中的 1.1-1.4 和 3.1-3.2 便是这部分，命名规则如下
- 1.1、如果 <bean /> 标签的属性 id 不为空，则 beanName = id
- 1.2和1.3、如果 id 为空，但是 name 属性不为空，则会将其第一个配置设置为 beanName ，其他的依旧为 alias 。然后检查 id 和 alias 的唯一性。
- 1.4、如果都没有，则在解析完 bean 之后使用默认规则来设置 beanName：
  - 如果是 innerBean ，则生成规则是：类全限定名#十六进制字符串（对象的标识哈希码）
  - 如不是，则为：类全限定名#counter(从0开始)。
  - 具体参考： BeanDefinitionReaderUtils.generateBeanName(...)
- 检查 id 和 alias 唯一性的代码如下：

/**
 * Validate that the specified bean name and aliases have not been used already
 * within the current level of beans element nesting.
 */
protected void checkNameUniqueness(String beanName, List<String> aliases, Element beanElement) {
    // 检查 beanName 和 alias 是否已经被使用
    String foundName = null;

    if (StringUtils.hasText(beanName) && this.usedNames.contains(beanName)) {
        foundName = beanName;
    }
    if (foundName == null) {
        foundName = CollectionUtils.findFirstMatch(this.usedNames, aliases);
    }
    // 如果 beanName 已存在，则使用 problemReporter 提示错误
    if (foundName != null) {
        error("Bean name '" + foundName + "' is already used in this <beans> element", beanElement);
    }
    // 将 beanName 和 alias 添加到 usedNames 集合中
    this.usedNames.add(beanName);
    this.usedNames.addAll(aliases);
}

2、解析属性，构造 AbstractBeanDefinition 对象：此处调用了 parseBeanDefinitionElement(Element ele, String beanName, @Nullable BeanDefinition containingBean) 方法，对 bean 标签进行解析并封装成 AbstractBeanDefinition 实例 beanDefinition ，实则是 GenericBeanDefinition 实例对象后面会及进行分析。
3、根据 beanDefinition 、 beanName 、 aliases 构造 BeanDefinitionHolder 实例对象，然后返回。前面提到 BeanDefinitionHolder 有如下内部属性用于承载 bean：

private final BeanDefinition beanDefinition;

private final String beanName;

@Nullable
private final String[] aliases;

2、parseBeanDefinitionElement( Element ele, String beanName, @Nullable BeanDefinition containingBean)

　　这个方法就是 bean 解析的重头戏了，这里对 bean 标签的属性和子元素一一进行解析然后封装成 AbstractBeanDefinition 类型的 GenericBeanDefinition 实例对象，代码如下：

/**
 * Parse the bean definition itself, without regard to name or aliases. May return
 * {@code null} if problems occurred during the parsing of the bean definition.
 */
@Nullable
public AbstractBeanDefinition parseBeanDefinitionElement(
        Element ele, String beanName, @Nullable BeanDefinition containingBean) {

    this.parseState.push(new BeanEntry(beanName));

    // 解析 class 属性
    String className = null;
    if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
        className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
    }
    // 解析 parent 属性
    String parent = null;
    if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
        parent = ele.getAttribute(PARENT_ATTRIBUTE);
    }

    try {
        // 创建用于承载属性的 AbstractBeanDefinition 类型的 GenericBeanDefinition 实例对象
        AbstractBeanDefinition bd = createBeanDefinition(className, parent);
        // 解析默认 bean 标签的各种属性
        parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
        // 提取 description
        bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

        /// 下面这些是解析 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);

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

        return bd;
    }
    catch (ClassNotFoundException ex) {
        error("Bean class [" + className + "] not found", ele, ex);
    }
    catch (NoClassDefFoundError err) {
        error("Class that bean class [" + className + "] depends on not found", ele, err);
    }
    catch (Throwable ex) {
        error("Unexpected failure during bean definition parsing", ele, ex);
    }
    finally {
        this.parseState.pop();
    }

    return null;
}

　　到这里已经看到了 XML 配置中， bean 标签的很多属性以及各种子元素了。这里解析出来的 BeanDefinition 可以算是基本成型了。

2.1、createBeanDefinition

　　解析之前，当然就是先创建一个能够承载各种属性的 BeanDefinition 了，这里使用的是 AbstractBeanDefinition 类型的 GenericBeanDefinition 实例对象：

/**
 * Create a bean definition for the given class name and parent name.
 * @param className the name of the bean class
 * @param parentName the name of the bean's parent bean
 * @return the newly created bean definition
 * @throws ClassNotFoundException if bean class resolution was attempted but failed
 */
protected AbstractBeanDefinition createBeanDefinition(@Nullable String className, @Nullable String parentName)
        throws ClassNotFoundException {

    return BeanDefinitionReaderUtils.createBeanDefinition(
            parentName, className, this.readerContext.getBeanClassLoader());
}

/// org.springframework.beans.factory.support.BeanDefinitionReaderUtils

/**
 * Create a new GenericBeanDefinition for the given parent name and class name,
 * eagerly loading the bean class if a ClassLoader has been specified.
 * @param parentName the name of the parent bean, if any
 * @param className the name of the bean class, if any
 * @param classLoader the ClassLoader to use for loading bean classes
 * (can be {@code null} to just register bean classes by name)
 * @return the bean definition
 * @throws ClassNotFoundException if the bean class could not be loaded
 */
public static AbstractBeanDefinition createBeanDefinition(
        @Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {

    GenericBeanDefinition bd = new GenericBeanDefinition();
    bd.setParentName(parentName);
    if (className != null) {
        if (classLoader != null) {
            bd.setBeanClass(ClassUtils.forName(className, classLoader));
        }
        else {
            bd.setBeanClassName(className);
        }
    }
    return bd;
}

3、总结

　　至此已初步看到了 bean 标签的各种属性和子元素的解析委托了，而 bean 标签的属性和子元素比较多，后续将继续进行注意的分析。

4、参考

spring 官方文档 5.2.3.RELEASE：https://docs.spring.io/spring-framework/docs/5.2.3.RELEASE/spring-framework-reference/core.html
Spring源码深度解析（第2版），郝佳，P44-P72
相关注释可参考笔者 github 链接：https://github.com/wpbxin/spring-framework

posted @ 2020-08-23 23:17 心明谭阅读(277) 评论(0) 编辑收藏举报

刷新页面返回顶部

心明谭

探索与总结分享