3Spring 源码学习 ~ 默认标签的解析之 Bean 标签解析
Posted 戴泽supp
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了3Spring 源码学习 ~ 默认标签的解析之 Bean 标签解析相关的知识，希望对你有一定的参考价值。
默认标签的解析之 Bean 标签解析
前言
第二章讲过 Spring 中的标签包括默认标签和自定义标签两种，而两种标签的用法和解析存在着很大不同，本章跟大家一起来学习下默认标签的解析过程。
默认标签是在 DefaultBeanDefinitionDocumentReader#parseDefaultElement 函数中进行的，parseDefaultElement 函数代码如下：
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);
分别对 4 种不同的标签（import、alias、bean、beans）做了不同的处理。
首先我们来对 bean 标签的解析来进行分析，进入函数 processBeanDefinition(ele, 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));
大致逻辑如下：
- 1、委托 BeanDefinitionParserDelegate 类的 parseBeanDefinitionElement 方法进行元素解析，返回 BeanDefinitionHolder 类的实例 bdHolder，经过这个方法后，bdHolder 已经包含配置文件的各个属性了，如 class、name、id、alias 等。
- 2、当返回的 bdHolder 不为 null 的情况下，若存在默认标签的子节点下有自定义属性，还需要对自定义标签进行解析
- 3、解析完成后，需要对解析后的 bdHolder 进行注册，注册操作委托给了 BeanDefinitionReaderUtils#registerBeanDefinition 方法
- 4、最后发出响应时间，通知相关监听器，到这里，这个 bean 就加在完成了。
它的时序图如下
一、解析 BeanDefinition
接下来我们针对各个操作做具体分析，先从元素解析和信息提取入手，即
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
具体代码如下：
@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)
//解析 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));
String beanName = id;
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");
if (containingBean == null)
checkNameUniqueness(beanName, aliases, ele);
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
if (beanDefinition != null)
if (!StringUtils.hasText(beanName))
try
// 如果不存在 beanName，那么根据 Spring 中提供的命名规则，生成当前 bean 对应的 beanName
if (containingBean != null)
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);
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;
String[] aliasesArray = StringUtils.toStringArray(aliases);
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
return null;
以上代码逻辑思路总结如下：
- 1、提取元素中的 id 及 name 属性。
- 2、进一步解析其他所有属性，并统一封装至 GenericBeanDefinition 类的实例中。
- 3、如果检测到 bean 没有指定 beanName，那么使用默认规则，为此 Bean 生成 beanName。
- 4、将获取到的信息封装到 BeanDefinitionHolder 实例中。
进一步解析步骤 2，即方法 parseBeanDefinitionElement，具体代码如下：
@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);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
//解析元数据
parseMetaElements(ele, bd);
//解析 lookup-method 属性
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
//解析 replaced-method 属性
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
//解析构造函数参数
parseConstructorArgElements(ele, bd);
//解析 property 子元素
parsePropertyElements(ele, bd);
//解析 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;
到此，bean 标签的所有属性，不论是常用的还是不常用的属性，我们都在这里看到了解析逻辑，我们继续来看下一些复杂标签属性的解析。
1、创建用于属性承载的 BeanDefinition
BeanDefinition 是一个接口，在 Spring 中有三种实现：RootBeanDefinition、ChildBeanDefinition 和 GenericBeanDefinition 。三种实现均继承了 AbstractBeanDefinition，BeanDefinition 是配置文件 <bean> 元素标签在容器中的内部表示形式。<bean> 标签拥有配置属性，在 BeanDefinition 中则有一一的对应关系（如class -> beanClass、lazy-init -> lazyInit 等），RootBeanDefinition 是最常用的实现类，GenericBeanDefinition 是自 2.5 版本后新加入的 bean 标签配置属性定义类，是一站式服务类。
在配置文件中可以定义父子 bean，父 bean 用 RootBeanDefinition（没有父 bean 的 bean，也用它表示） 表示，子 bean 用 ChildBeanDefinition 表示，AbstractBeanDefinition 是对两者共同的类信息进行的抽象类。**Spring 将这些解析好的 BeanDefinition 注册到 BeanDefinitionRegistry 中，BeanDefinitionRegistry 就像 Spring 配置信息的内存数据库，主要以 map 形式保存。**他们之间的关系图如下：
所以解析属性会先创建承载属性的实例，即 GenericBeanDefinition 实例，这就是 createBeanDefinition 方法干的事
protected AbstractBeanDefinition createBeanDefinition(@Nullable String className, @Nullable String parentName)
throws ClassNotFoundException
return BeanDefinitionReaderUtils.createBeanDefinition(
parentName, className, this.readerContext.getBeanClassLoader());
BeanDefinitionReaderUtils.java
public static AbstractBeanDefinition createBeanDefinition(
@Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException
GenericBeanDefinition bd = new GenericBeanDefinition();
// parentName 可能为空
bd.setParentName(parentName);
if (className != null)
//如果 classLoader 不为空，则使用传入的 classLoader 同一虚拟机加载类对象
// 否则只是记录 className
if (classLoader != null)
bd.setBeanClass(ClassUtils.forName(className, classLoader));
else
bd.setBeanClassName(className);
return bd;
2、解析各种属性
创建好 bean 信息的承载实例后，就开始进行 bean 信息的各种属性解析了，先来看 parseBeanDefinitionAttributes 方法，它是对所有元素属性进行解析
public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
@Nullable BeanDefinition containingBean, AbstractBeanDefinition bd)
//singleton 属性已弃用，使用 scope 属性来代替
if (ele.hasAttribute(SINGLETON_ATTRIBUTE))
error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
// 解析 scope 属性
else if (ele.hasAttribute(SCOPE_ATTRIBUTE))
bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
else if (containingBean != null)
// Take default from containing bean in case of an inner bean definition.
// 在嵌入 beanDefinition 情况下，且没有单独指定 scope 属性，则使用父类默认的属性
bd.setScope(containingBean.getScope());
// 解析 abstract 属性
if (ele.hasAttribute(ABSTRACT_ATTRIBUTE))
bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
// 解析 lazy-init 属性
String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
if (isDefaultValue(lazyInit))
lazyInit = this.defaults.getLazyInit();
// 除设置为 true 外，其他均为 false
bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
// 解析 autowire 属性
String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
bd.setAutowireMode(getAutowireMode(autowire));
// 解析 depends-on 属性
if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE))
String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
// 解析 autowire-candidate 属性
String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
if (isDefaultValue(autowireCandidate))
String candidatePattern = this.defaults.getAutowireCandidates();
if (candidatePattern != null)
String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);
bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
else
bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
// 解析 primary 属性
if (ele.hasAttribute(PRIMARY_ATTRIBUTE))
bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
// 解析 init-method 属性
if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE))
String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
bd.setInitMethodName(initMethodName);
else if (this.defaults.getInitMethod() != null)
bd.setInitMethodName(this.defaults.getInitMethod());
bd.setEnforceInitMethod(false);
// 解析 destroy-method 属性
if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE))
String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
bd.setDestroyMethodName(destroyMethodName);
else if (this.defaults.getDestroyMethod() != null)
bd.setDestroyMethodName(this.defaults.getDestroyMethod());
bd.setEnforceDestroyMethod(false);
// 解析 factory-method 属性
if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE))
bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
// 解析 factory-bean 属性
if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE))
bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
return bd;
我们清晰的看到了 Spring 完成了对所有 bean 属性的解析。有不熟悉的属性含义的，请参阅官方文档学习。
3、解析子元素 meta
meta 属性的使用如下：
<bean id="testBean" class="com.luo.spring.guides.helloworld.common.TestBean">
<meta key="testStr" value="aaaaa"/>
</bean>
它是一个额外的声明，当需要使用时，可以通过 BeanDefinition 的 getAttribute(key) 方法获取，对 meta 属性的解析代码如下：
public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor)
// 获取当前节点的所有子元素
NodeList nl = ele.getChildNodes();
for (7Spring 源码学习 ~ 默认标签的解析之嵌入式 beans 标签的解析
7Spring 源码学习 ~ 默认标签的解析之嵌入式 beans 标签的解析