08.Spring Bean 解析 - BeanDefinitionDocumentReader

基本概念

BeanDefinitionDocumentReader ，该类的作用有两个，完成 BeanDefinition 的解析和注册 。

解析：其实是解析 Ddocument 的内容并将其添加到 BeanDefinition 实例的过程。

注册：就是将 BeanDefinition 添加进 BeanDefinitionHolder 的过程，这样做的目的是保存它的信息。

下面来看它的接口定义，该接口只定义了一个方法负责完成解析和注册的工作：

public interface BeanDefinitionDocumentReader {

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

}

再来看它的继承关系，默认只有一个实现类：

源码分析

接下来来看 DefaultBeanDefinitionDocumentReader 类中的 registerBeanDefinitions 方法。

首先来看该方法的入参：

Document：代指 Spring 的配置文件信息，通过 BeanDefinitionReader 解析 Resrouce 实例得到。

XmlReaderContext ：主要包含了 BeanDefinitionReader 和 Resrouce 。

再来看它的具体流程：

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
this.readerContext = readerContext;

// 日志输出...

// 取得根元素，即 XML 文件中的 <beans> 标签
Element root = doc.getDocumentElement();

// 关键 -> 继续 Document 的解析
doRegisterBeanDefinitions(root);
}

关于 doRegisterBeanDefinitions，该方法的主要作用有：

创建 BeanDefinitionParserDelegate 对象，用于将 Document 的内容转成 BeanDefinition 实例，也就是上面提到的解析过程，BeanDefinitionDocumentReader 本身不具备该功能而是交给了该类来完成。

取得 beans 标签中 profile 的属性内容，该标签主要用于环境的切换。例如开发过程中，一般存在测试环境和正式环境，两者之间可能存在不同的数据源。若想要实现环境的快速切换，就可以利用 profile 来配置。具体实现这里暂不探究。

protected void doRegisterBeanDefinitions(Element root) {
// 创建 delegate 对象
BeanDefinitionParserDelegate parent = this.delegate;
this.delegate = createDelegate(getReaderContext(), root, parent);

// 验证 XML 文件的命名空间，即判断是否含有 xmlns="http://www.springframework.org/schema/beans"
if (this.delegate.isDefaultNamespace(root)) {

// 解析 profile
String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);

if (StringUtils.hasText(profileSpec)) {

String[] specifiedProfiles = StringUtils.tokenizeToStringArray(profileSpec,
BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);

if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
return;
}
}
}

// 空方法
preProcessXml(root);

// 关键 -> 开始解析 Bean 定义
parseBeanDefinitions(root, this.delegate);

// 空方法
postProcessXml(root);

this.delegate = parent;
}

下面开始通过遍历取得 beans 元素的所有子节点。

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
// 验证 XML 文件的命名空间
if (delegate.isDefaultNamespace(root)) {
// 取得 <beans> 的所有子节点
NodeList nl = root.getChildNodes();

// 遍历 <beans> 的子节点
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);

// 判断节点是不是 Element 类型
if (node instanceof Element) {
Element ele = (Element) node;

if (delegate.isDefaultNamespace(ele)) {
// 关键 -> 解析 <beans> 子节点的内容
parseDefaultElement(ele, delegate);

}else {
// 解析自定义元素，暂不探究
delegate.parseCustomElement(ele);
}
}
}
}else {
delegate.parseCustomElement(root);
}
}

在拿到了子节点后，开始解析 beans 标签的子节点，常见的标签有 import，alias，bean，beans 等。

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
// 处理 <import> 标签，将资源进行合并再统一解析
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
// 处理 <alias> 标签
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
// 关键-> 处理 <bean> 标签
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
// 处理 <beans> 标签，回到开始解析 document 的地方
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}

这里关键来探究下 bean 的解析过程：

上面提到 bean 标签的具体解析工作交给 BeanDefinitionParserDelegate 类来完成。

在完成解析取得 BeanDefinition（被添加进了 BeanDefinitionHolder ） 对象之后利用 BeanDefinitionRegistry 完成注册过程。

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {

// 关键 -> ①交给委托类 delegate 来完成解析过程 ，并返回 BeanDefinitionHolder 对象
// 该对象存储了 BeanDefinition 的基本信息
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

// 交给委托类 delegate 来完成修饰过程，这里暂不探究
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// 关键 -> ②注册最后的装饰实例
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

}catch (BeanDefinitionStoreException ex) {
//错误输出...
}

// Send registration event.
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}

观察上述代码，发现 DefaultBeanDefinitionDocumentReader 的主要职责是解析 Document ，取得配置文件（这里指 xml ）中定义的标签内容；而解析标签的过程交给 BeanDefinitionParserDelegate 类完成；注册过程交给了 BeanDefinitionRegistry 接口来完成。

1.BeanDefinition 解析

在 DefaultBeanDefinitionDocumentReader 关于 bean 标签的解析方法如下：

BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

下面来看下 BeanDefinitionParserDelegate 的 parseBeanDefinitionElement 方法。

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
return parseBeanDefinitionElement(ele, null);
}

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
// 取得 <bean> 标签的 id 属性
String id = ele.getAttribute(ID_ATTRIBUTE);

// 取得 <bean> 标签的 name 属性
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

// 创建 List 用于存方法 alsas（别名）集合
List<String> aliases = new ArrayList<String>();

if (StringUtils.hasLength(nameAttr)) {
// 将 nameArr 按照（，）或（;）分割成数组
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);

// 添加进行别名集合
aliases.addAll(Arrays.asList(nameArr));
}

// 判断 id 是否为空，若为空则取别名集合的第一个元素当作 id ，并将其从别名集合当中移除
String beanName = id;
if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
beanName = aliases.remove(0);
// 日志输出...
}

// 检查 id（标识）和 alias（名别）是否唯一
if (containingBean == null) {
checkNameUniqueness(beanName, aliases, ele);
}

// 关键 -> 解析 <bean> 标签的 class 属性 以及相关特性标签，并将其添加进 beanDefinition 返回
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);

if (beanDefinition != null) {

// 判断是否存在 beanName（id）
if (!StringUtils.hasText(beanName)) {
try {

if (containingBean != null) {
beanName = BeanDefinitionReaderUtils.generateBeanName(beanDefinition, this.readerContext.getRegistry(), true);
}else {

// 由 Spring 自动生成 beanName（id）
beanName = this.readerContext.generateBeanName(beanDefinition);

// 取得 bean 的 完整类名可用
String beanClassName = beanDefinition.getBeanClassName();

// 将 beanName 添加进 alais 集合
if (beanClassName != null &&
beanName.startsWith(beanClassName) &&
beanName.length() > beanClassName.length() &&
!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {

aliases.add(beanClassName);
}
}

// 日志输出...

}catch (Exception ex) {
error(ex.getMessage(), ele);
return null;
}
}

// 将 aliases 集合数组化
String[] aliasesArray = StringUtils.toStringArray(aliases);

// 关键 -> 返回一个 BeanDefinitionHolder 实例，用于存储信息
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}

return null;
}

再来看解析 bean 标签的 class 属性以及相关特性标签，并将其添加进 beanDefinition 返回的具体过程：

public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, BeanDefinition containingBean) {

// 入栈操作，往 parseState 中添加一个 新建的 BeanEntry
this.parseState.push(new BeanEntry(beanName));

// 取得 <bean> 标签的 class 属性
String className = null;
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}

try {
// 取得 <bean> 标签的 parent 属性
String parent = null;
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}

// 根据 class，parent 的属性值创建一个 BeanDefinition
AbstractBeanDefinition bd = createBeanDefinition(className, parent);

// 取得 <bean> 标签的其他特性属性，并添加进 BeanDefinition 。如：
// scope、
// lazy-init
// autowire
// primary、autowire-candidate
// depends-on、dependency-check
// init-method、destroy-method
// factory-method、factory-bean
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);

bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

// 解析 <mate> 标签
parseMetaElements(ele, bd);

// 解析 <lookup-method> 标签
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());

// 解析 <replaced-method> 标签
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

// 解析 <constructor-arg> 标签
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) {
// 错误输出...
}catch (NoClassDefFoundError err) {
// 错误输出...
}catch (Throwable ex) {
// 错误输出...
}finally {
// 出栈操作
this.parseState.pop();
}

return null;
}

2.Beandefinition 注册

在 DefaultBeanDefinitionDocumentReader 关于 bean 标签的注册方法如下：

BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

下面来看 BeanDefinitionReaderUtils 的 registerBeanDefinition 方法。该方法的主要作用是调用注册器完成注册过程。

public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {

// 取得 BeanDefinition 实例的标识
String beanName = definitionHolder.getBeanName();

// 关键 -> 调用注册器实现注册过程
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

// 取得 BeanDefinition 实例的所有别名
String[] aliases = definitionHolder.getAliases();

if (aliases != null) {
for (String alias : aliases) {
// 往注册器的 aliasMap 添加 alias 的过程
registry.registerAlias(beanName, alias);
}
}
}

这里通过 getRegistry 方法取得注册器为 DefaultListableBeanFactory 类，该类是 BeanDefinitionRegistry 接口的基本实现类 ，因此具体的注册过程是通过 BeanDefinitionRegistry 来实现的。

总结

最后通过流程图来简单看下 BeanDefinitionDocumentReader 的工作流程：