Spring源码解密之默认标签的解析

前言

紧跟上篇 spring解密 - xml解析 与 bean注册 ，我们接着往下分析源码，话不多说了，来一起看看详细的介绍吧。

解密

在 spring 的 xml 配置里面有两大类声明，一个是默认的如 <bean id="person" class="com.battcn.bean.person"/> ，另一类就是自定义的如<tx:annotation-driven /> ，两种标签的解析方式差异是非常大的。parsebeandefinitions 方法就是用来区分不同标签所使用的解析方式。通过 node.getnamespaceuri() 方法获取命名空间，判断是默认命名空间还是自定义命名空间，并与 spring 中固定的命名空间 http://www.springframework.org/schema/beans 进行比对，如果一致则采用parsedefaultelement(ele, delegate);否则就是delegate.parsecustomelement(ele);

默认标签的解析

parsedefaultelement 对 4 种不同的标签 import、alias、bean、beans 做了不同的处理，其中 bean 标签的解析最为复杂也最为重要，所以我们将从 bean 开始深入分析，如果能理解此标签的解析过程，其他标签的解析自然会迎刃而解。上一篇中只是简单描述了一下，本篇我们围绕解析模块详细的探讨一下

public class defaultbeandefinitiondocumentreader implements beandefinitiondocumentreader {
 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);
 }
 // import 标签解析
 else if (delegate.nodenameequals(ele, nested_beans_element)) {
 // beans标签解析 递归方式
 doregisterbeandefinitions(ele);
 }
 }
}

首先我们来分析下当类中的 processbeandefinition(ele, delegate)

protected void processbeandefinition(element ele, beandefinitionparserdelegate delegate) {
 // 委托beandefinitiondelegate类的parsebeandefinitionelement方法进行元素解析
 beandefinitionholder bdholder = delegate.parsebeandefinitionelement(ele);
 if (bdholder != null) {
 // 当返回的bdholder不为空的情况下若存在默认标签的子节点下再有自定义属性，还需要再次对自定义标签进行解析
 bdholder = delegate.decoratebeandefinitionifrequired(ele, bdholder);
 try {
 // 解析完成后需要对解析后的bdholder进行注册，注册操作委托给了beandefinitionreaderutils的registerbeandefinition方法
 beandefinitionreaderutils.registerbeandefinition(bdholder, getreadercontext().getregistry());
 }
 catch (beandefinitionstoreexception ex) {
 getreadercontext().error("failed to register bean definition with name '" +
 bdholder.getbeanname() + "'", ele, ex);
 }
 // 最后发出响应事件，通知相关监听器这个bean已经被加载
 getreadercontext().firecomponentregistered(new beancomponentdefinition(bdholder));
 }
}

这段代码中：

• 首先委托 beandefinitionparsedelegate 对节点做了解析，并返回了一个 beandefinitionholder 的实例，在这个实例中已经包含了配置文件中配置的各种属性了
• 如果在当前子节点中存在自定义属性，则还需要对自定义标签进行解析
• 解析完成后，需要对解析后的 bdholder 进行注册，同样注册操作委托给了 beandefinitionreaderutils
• 最后发出响应事件，通知相关监听器这个 bean 已经被加载

下面我们详细分析下，spring 是如何解析各个标签和节点的

bean 标签解析

public class beandefinitionparserdelegate {
 @nullable
 public beandefinitionholder parsebeandefinitionelement(element ele, @nullable beandefinition containingbean) {
 // 获取bean标签的id属性
 string id = ele.getattribute(id_attribute);
 // 获取bean标签的name属性
 string nameattr = ele.getattribute(name_attribute);
 list<string> aliases = new arraylist<>();
 if (stringutils.haslength(nameattr)) {
 // 将name属性的值通过,; 进行分割 转为字符串数字(即在配置文件中如配置多个name 在此做处理)
 string[] namearr = stringutils.tokenizetostringarray(nameattr, multi_value_attribute_delimiters);
 aliases.addall(arrays.aslist(namearr));
 }
 string beanname = id;
 // 如果id为空 使用配置的第一个name属性作为id
 if (!stringutils.hastext(beanname) && !aliases.isempty()) {
 beanname = aliases.remove(0);
 if (logger.isdebugenabled()) {
 logger.debug("no xml 'id' specified - using '" + beanname + "' as bean name and " + aliases + " as aliases");
 }
 }
 if (containingbean == null) {
 // 校验beanname和aliases的唯一性
 // 内部核心为使用usednames集合保存所有已经使用了的beanname和alisa
 checknameuniqueness(beanname, aliases, ele);
 }
 // 进一步解析其他所有属性到genericbeandefinition对象中
 abstractbeandefinition beandefinition = parsebeandefinitionelement(ele, beanname, containingbean);
 if (beandefinition != null) {
 // 如果bean没有指定beanname 那么使用默认规则为此bean生成beanname
 if (!stringutils.hastext(beanname)) {
 try {
 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.isdebugenabled()) {
 logger.debug("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);
 // 将信息封装到beandefinitionholder对象中
 return new beandefinitionholder(beandefinition, beanname, aliasesarray);
 }
 return null;
 }
}

该方法主要处理了 id、name、alias 等相关属性，生成了 beanname，并且在重载函数 parsebeandefinitionelement(ele, beanname, containingbean)方法中完成核心的标签解析。

接下来重点分析parsebeandefinitionelement(element ele, string beanname, @nullable beandefinition containingbean)

看下它是如何完成标签解析操作的

bean 节点与属性解析

@nullable
public abstractbeandefinition parsebeandefinitionelement(
 element ele, string beanname, @nullable beandefinition containingbean) {
 this.parsestate.push(new beanentry(beanname));
 // 获取bean标签的class属性
 string classname = null;
 if (ele.hasattribute(class_attribute)) {
 classname = ele.getattribute(class_attribute).trim();
 }
 // 获取bean标签的parent属性
 string parent = null;
 if (ele.hasattribute(parent_attribute)) {
 parent = ele.getattribute(parent_attribute);
 }
 try {
 // 创建用于承载属性的abstractbeandefinition
 abstractbeandefinition bd = createbeandefinition(classname, parent);
 // 获取bean标签各种属性
 parsebeandefinitionattributes(ele, beanname, containingbean, bd);
 // 解析description标签
 bd.setdescription(domutils.getchildelementvaluebytagname(ele, description_element));
 // 解析meta标签
 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) {
 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;
}

进一步解析其他属性和元素（元素和属性很多，所以这是一个庞大的工作量）并统一封装至 genericbeandefinition 中， 解析完成这些属性和元素之后，如果检测到 bean 没有指定的 beanname，那么便使用默认的规则为 bean 生成一个 beanname。

// beandefinitionparserdelegate.java
protected abstractbeandefinition createbeandefinition(@nullable string classname, @nullable string parentname)
 throws classnotfoundexception {
 return beandefinitionreaderutils.createbeandefinition(
 parentname, classname, this.readercontext.getbeanclassloader());
}
public class beandefinitionreaderutils {
 public static abstractbeandefinition createbeandefinition(
 @nullable string parentname, @nullable string classname, @nullable classloader classloader) throws classnotfoundexception {
 genericbeandefinition bd = new genericbeandefinition();
 // parentname可能为空
 bd.setparentname(parentname);
 // 如果classloader不为空
 // 则使用传入的classloader同一虚拟机加载类对象 否则只记录classloader
 if (classname != null) {
 if (classloader != null) {
 bd.setbeanclass(classutils.forname(classname, classloader));
 }
 else {
 bd.setbeanclassname(classname);
 }
 }
 return bd;
 }
}

beandefinition 是 <bean> 在容器中的内部表示形式，beandefinition 和 <bean> 是一一对应的。同时 beandefinition 会被注册到 beandefinitionregistry 中，beandefinitionregistry 就像 spring 配置信息的内存数据库。

至此 createbeandefinition(classname, parent); 已经说完了，而且我们也获得了 用于承载属性的abstractbeandefinition，接下来看看 parsebeandefinitionattributes(ele, beanname, containingbean, bd); 是如何解析 bean 中的各种标签属性的

public class beandefinitionparserdelegate {
 public abstractbeandefinition parsebeandefinitionattributes(element ele, string beanname,
 @nullable beandefinition containingbean, abstractbeandefinition bd) {
 // ...省略详细代码，该部分代码主要就是通过 if else 判断是否含有指定的属性，如果有就 bd.set(attribute);
 return bd;
 }
}
```

`bean` 标签的完整解析到这就已经全部结束了，其中 `bean` 标签下的元素解析都大同小异，有兴趣的可以自己跟踪一下源代码看看 `qualifier、lookup-method` 等解析方式（*相对 `bean` 而言不复杂*）。自定义标签内容较多会在下一章详细介绍。

最后将获取到的信息封装到 `beandefinitionholder` 实例中

``` java
// beandefinitionparserdelegate.java
@nullable
public beandefinitionholder parsebeandefinitionelement(element ele, @nullable beandefinition containingbean) {
 // ...
 return new beandefinitionholder(beandefinition, beanname, aliasesarray);
}

注册解析的 beandefinition

在解析完配置文件后我们已经获取了 bean 的所有属性，接下来就是对 bean 的注册了

public class beandefinitionreaderutils {
 public static void registerbeandefinition(
 beandefinitionholder definitionholder, beandefinitionregistry registry)
 throws beandefinitionstoreexception {
 // 使用 beanname 做唯一标识符
 string beanname = definitionholder.getbeanname();
 // 注册bean的核心代码
 registry.registerbeandefinition(beanname, definitionholder.getbeandefinition());
 // 为bean注册所有的别名
 string[] aliases = definitionholder.getaliases();
 if (aliases != null) {
 for (string alias : aliases) {
 registry.registeralias(beanname, alias);
 }
 }
 }
}

以上代码主要完成两个功能，一是使用 beanname 注册 beandefinition，二是完成了对别名的注册

beanname 注册 beandefinition

public class defaultlistablebeanfactory {
 @override
 public void registerbeandefinition(string beanname, beandefinition beandefinition)
 throws beandefinitionstoreexception {
 assert.hastext(beanname, "bean name must not be empty");
 assert.notnull(beandefinition, "beandefinition must not be null");
 if (beandefinition instanceof abstractbeandefinition) {
 try {
 // 注册前的最后一次校验，这里的校验不同于xml文件校验
 // 主要是对于abstractbeandefinition属性中的methodoverrides校验
 // 校验methodoverrides是否与工厂方法并存或者methodoverrides对于的方法根本不存在
 ((abstractbeandefinition) beandefinition).validate();
 }
 catch (beandefinitionvalidationexception ex) {
 throw new beandefinitionstoreexception(beandefinition.getresourcedescription(), beanname,
 "validation of bean definition failed", ex);
 }
 }
 beandefinition oldbeandefinition;
 // 获取缓存中的 beandefinition
 oldbeandefinition = this.beandefinitionmap.get(beanname);
 if (oldbeandefinition != null) {
 // 如果缓存中存在 判断是否允许覆盖
 if (!isallowbeandefinitionoverriding()) {
 throw new beandefinitionstoreexception(beandefinition.getresourcedescription(), beanname,
 "cannot register bean definition [" + beandefinition + "] for bean '" + beanname +
 "': there is already [" + oldbeandefinition + "] bound.");
 }
 else if (oldbeandefinition.getrole() < beandefinition.getrole()) {
 // e.g. was role_application, now overriding with role_support or role_infrastructure
 if (this.logger.iswarnenabled()) {
 this.logger.warn("overriding user-defined bean definition for bean '" + beanname +
 "' with a framework-generated bean definition: replacing [" +
 oldbeandefinition + "] with [" + beandefinition + "]");
 }
 }
 else if (!beandefinition.equals(oldbeandefinition)) {
 if (this.logger.isinfoenabled()) {
 this.logger.info("overriding bean definition for bean '" + beanname +
 "' with a different definition: replacing [" + oldbeandefinition +
 "] with [" + beandefinition + "]");
 }
 }
 else {
 if (this.logger.isdebugenabled()) {
 this.logger.debug("overriding bean definition for bean '" + beanname +
 "' with an equivalent definition: replacing [" + oldbeandefinition +
 "] with [" + beandefinition + "]");
 }
 }
 // 如果允许覆盖，保存beandefinition到beandefinitionmap中
 this.beandefinitionmap.put(beanname, beandefinition);
 }
 else {
 // 判断是否已经开始创建bean
 if (hasbeancreationstarted()) {
 // cannot modify startup-time collection elements anymore (for stable iteration)
 synchronized (this.beandefinitionmap) {
 // 保存beandefinition到beandefinitionmap中
 this.beandefinitionmap.put(beanname, beandefinition);
 // 更新已经注册的beanname
 list<string> updateddefinitions = new arraylist<>(this.beandefinitionnames.size() + 1);
 updateddefinitions.addall(this.beandefinitionnames);
 updateddefinitions.add(beanname);
 this.beandefinitionnames = updateddefinitions;
 if (this.manualsingletonnames.contains(beanname)) {
 set<string> updatedsingletons = new linkedhashset<>(this.manualsingletonnames);
 updatedsingletons.remove(beanname);
 this.manualsingletonnames = updatedsingletons;
 }
 }
 }
 else {
 // 还没开始创建bean
 this.beandefinitionmap.put(beanname, beandefinition);
 this.beandefinitionnames.add(beanname);
 this.manualsingletonnames.remove(beanname);
 }
 this.frozenbeandefinitionnames = null;
 }
 if (oldbeandefinition != null || containssingleton(beanname)) {
 // 重置beanname对应的缓存
 resetbeandefinition(beanname);
 }
 }
}

• 对 abstractbeandefinition 的校验，主要是针对 abstractbeandefinition 的 methodoverrides 属性的
• 对 beanname 已经注册的情况的处理，如果设置了不允许 bean 的覆盖，则需要抛出异常，否则直接覆盖
• 使用 beanname 作为 key，beandefinition 为 value 加入 beandefinitionmap 存储
• 如果缓存中已经存在，并且该 bean 为单例模式则清楚 beanname 对应的缓存

注册别名

注册好了 beandefinition，接下来就是注册 alias。注册的 alias 和 beanname 的对应关系存放在了 aliasmap 中，沿着类的继承链会发现 registeralias 的方法是在 simplealiasregistry 中实现的

public class simplealiasregistry {
 /** map from alias to canonical name */
 private final map<string, string> aliasmap = new concurrenthashmap<>(16);
 public void registeralias(string name, string alias) {
 assert.hastext(name, "'name' must not be empty");
 assert.hastext(alias, "'alias' must not be empty");
 if (alias.equals(name)) {
  // 如果beanname与alias相同的话不记录alias 并删除对应的alias
  this.aliasmap.remove(alias);
 } else {
  string registeredname = this.aliasmap.get(alias);
  if (registeredname != null) {
  if (registeredname.equals(name)) {
   // 如果别名已经注册过并且指向的name和当前name相同 不做任何处理
   return;
  }
  // 如果alias不允许被覆盖则抛出异常
  if (!allowaliasoverriding()) {
   throw new illegalstateexception("cannot register alias '" + alias + "' for name '" + name + "': it is already registered for name '" + registeredname + "'.");
  }
  }
  // 校验循环指向依赖 如a->b b->c c->a则出错
  checkforaliascircle(name, alias);
  this.aliasmap.put(alias, name);
 }
 }
}

通过 checkforaliascircle() 方法来检查 alias 循环依赖，当 a -> b 存在时，若再次出现 a -> c -> b 则会抛出异常:

protected void checkforaliascircle(string name, string alias) {
 if (hasalias(alias, name)) {
 throw new illegalstateexception("cannot register alias '" + alias +
 "' for name '" + name + "': circular reference - '" +
 name + "' is a direct or indirect alias for '" + alias + "' already");
 }
}
public boolean hasalias(string name, string alias) {
 for (map.entry<string, string> entry : this.aliasmap.entryset()) {
 string registeredname = entry.getvalue();
 if (registeredname.equals(name)) {
 string registeredalias = entry.getkey();
 return (registeredalias.equals(alias) || hasalias(registeredalias, alias));
 }
 }
 return false;
}

至此，注册别名也完成了，主要完成了以下几个工作

• 如果 beanname 与 alias 相同的话不记录 alias 并删除对应的 alias
• 如果别名已经注册过并且指向的name和当前name相同 不做任何处理
• 如果别名已经注册过并且指向的name和当前name不相同 判断是否允许被覆盖
• 校验循环指向依赖 如a->b b->c c->a则出错

发送通知

通知监听器解析及注册完成

//defaultbeandefinitiondocumentreader.java
protected void processbeandefinition(element ele, beandefinitionparserdelegate delegate) {
 // send registration event.
 getreadercontext().firecomponentregistered(new beancomponentdefinition(bdholder));
}

通过 firecomponentregistered 方法进行通知监听器解析及注册完成工作，这里的实现只为扩展，当程序开发人员需要对注册 beandefinition事件进行监听时，可以通过注册监听器的方式并将处理逻辑写入监听器中，目前 spring 中并没有对此事件做任何处理

其中 readercontext 是在类 xmlbeandefinitionreader 中调用 createreadercontext 生成的，然后调用 firecomponentregistered()

alias 标签解析

spring 提供了 <alias name="person" alias="p"/> 方式来进行别名的配置，该标签解析是在 processaliasregistration(element ele) 方法中完成的

public class defaultbeandefinitiondocumentreader {
 protected void processaliasregistration(element ele) {
 // 获取 alisa 标签 name 属性
 string name = ele.getattribute(name_attribute);
 // 获取 alisa 标签 alias 属性
 string alias = ele.getattribute(alias_attribute);
 boolean valid = true;
 if (!stringutils.hastext(name)) {
  getreadercontext().error("name must not be empty", ele);
  valid = false;
 } if (!stringutils.hastext(alias)) {
  getreadercontext().error("alias must not be empty", ele);
  valid = false;
 }
 if (valid) {
  try {
  // 进行别名注册
  getreadercontext().getregistry().registeralias(name, alias);
  } catch (exception ex) {
  getreadercontext().error("failed to register alias '" + alias +
   "' for bean with name '" + name + "'", ele, ex);
  }
  // 别名注册后告知监听器做相应处理
  getreadercontext().firealiasregistered(name, alias, extractsource(ele));
 }
 }
}

首先对 alias 标签属性进行提取校验，校验通过后进行别名注册，别名注册和 bean 标签解析中的别名注册一直，此处不再赘述

import 标签解析

public class defaultbeandefinitiondocumentreader {
 protected void importbeandefinitionresource(element ele) {
 // 获取import标签的resource属性
 string location = ele.getattribute(resource_attribute);
 // 如果不存在则不做任何处理
 if (!stringutils.hastext(location)) {
  getreadercontext().error("resource location must not be empty", ele);
  return;
 }
 // 解析占位符属性 格式如"${user.dir}"
 location = getreadercontext().getenvironment().resolverequiredplaceholders(location);
 set<resource> actualresources = new linkedhashset<>(4);
 // 判断资源是绝对路径还是相对路径
 boolean absolutelocation = false;
 try {
  absolutelocation = resourcepatternutils.isurl(location) || resourceutils.touri(location).isabsolute();
 } catch (urisyntaxexception ex) {
  // cannot convert to an uri, considering the location relative
  // unless it is the well-known spring prefix "classpath*:"
 }

 // 如果是绝对路径则直接根据地址加载对应的配置文件
 if (absolutelocation) {
  try {
  int importcount = getreadercontext().getreader().loadbeandefinitions(location, actualresources);
  if (logger.isdebugenabled()) {
   logger.debug("imported " + importcount + " bean definitions from url location [" + location + "]");
  }
  } catch (beandefinitionstoreexception ex) {
  getreadercontext().error("failed to import bean definitions from url location [" + location + "]", ele, ex);
  }
 } else {
  try {
  int importcount;
  // 根据相对路径加载资源
  resource relativeresource = getreadercontext().getresource().createrelative(location);
  if (relativeresource.exists()) {
   importcount = getreadercontext().getreader().loadbeandefinitions(relativeresource);
   actualresources.add(relativeresource);
  } else {
   string baselocation = getreadercontext().getresource().geturl().tostring();
   importcount = getreadercontext().getreader().loadbeandefinitions(stringutils.applyrelativepath(baselocation, location), actualresources);
  }
  if (logger.isdebugenabled()) {
   logger.debug("imported " + importcount + " bean definitions from relative location [" + location + "]");
  }
  } catch (ioexception ex) {
  getreadercontext().error("failed to resolve current resource location", ele, ex);
  } catch (beandefinitionstoreexception ex) {
  getreadercontext().error("failed to import bean definitions from relative location [" + location + "]", ele, ex);
  }
 }
 // 解析后进行监听器激活处理
 resource[] actresarray = actualresources.toarray(new resource[actualresources.size()]);
 getreadercontext().fireimportprocessed(location, actresarray, extractsource(ele));
 }
}

完成了对 import 标签的处理，首先就是获取 <import resource="beans.xml"/> resource 属性所表示的路径，接着解析路径中的属性占位符 如 ${user.dir} ，然后判定 location 是绝对路径还是相对路径，如果是绝对路径则递归调用 bean 的解析过程(loadbeandefinitions(location, actualresources);) ，进行另一次解析，如果是相对路径则计算出绝对路径并进行解析，最后通知监听器，解析完成

总结

熬过几个无人知晓的秋冬春夏，撑过去一切都会顺着你想要的方向走…

好了，以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对服务器之家的支持。

说点什么

全文代码：https://gitee.com/battcn/battcn-spring-source/tree/master/chapter1

原文链接：http://blog.battcn.com/2018/01/11/spring/spring-2/