前言
紧跟上篇 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 开始深入分析，如果能理解此标签的解析过程，其他标签的解析自然会迎刃而解。上一篇中只是简单描述了一下，本篇我们围绕解析模块详细的探讨一下
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
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)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
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 标签解析
|
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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
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 节点与属性解析
|
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
48
49
50
51
52
|
@nullablepublic 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。
|
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
|
// beandefinitionparserdelegate.javaprotected 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 中的各种标签属性的
|
1
2
3
4
5
6
7
8
|
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` 实例中
|
1
2
3
4
5
6
7
|
``` java// beandefinitionparserdelegate.java@nullablepublic beandefinitionholder parsebeandefinitionelement(element ele, @nullable beandefinition containingbean) { // ... return new beandefinitionholder(beandefinition, beanname, aliasesarray);} |
注册解析的 beandefinition
在解析完配置文件后我们已经获取了 bean 的所有属性，接下来就是对 bean 的注册了
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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
|
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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
|
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 中实现的
|
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
|
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 则会抛出异常:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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则出错
发送通知
通知监听器解析及注册完成
|
1
2
3
4
5
|
//defaultbeandefinitiondocumentreader.javaprotected 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) 方法中完成的
|
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
|
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 标签解析
|
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
48
49
50
51
52
53
54
55
56
57
|
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/
