一、先期准备
前期准备工作参见 二、Spring之解析及注册 BeanDefinitions 前期准备
二、对 import/alias/bean/beans 标签解析的准备工作
-
- 2.
DefaultBeanDefinitionDocumentReader#parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate)- 2.1
DefaultBeanDefinitionDocumentReader#importBeanDefinitionResource(Element ele)：对 import 标签的处理 - 2.2
DefaultBeanDefinitionDocumentReader#processAliasRegistration(Element ele)：对 alias 标签的处理 - 2.3
DefaultBeanDefinitionDocumentReader#processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate)：对 bean 标签的处理 - 2.4
DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions(Element root)：对 beans 标签的处理
- 2.1
- 2.
-
DefaultBeanDefinitionDocumentReader#parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate)
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
// 对 beans 处理
/*
* Spring 的 XML 配置里有两大类 Bean 声明，一个是默认的，如：
* <bean id="test" class="test.TestBean" />
* 另一类是自定义的，如：
* <tx:annotation-driven />
* 两种方式的读取及解析差别是非常大的，如果采用 Spring 默认的配置，Spring 当然知道该怎么做，但是如果是自定义
* 的。那么就需要用户实现一些接口及配置了。对于根节点或者子节点如果是默认命名空间的话采用 parseDefaultElement()
* 方法进行解析，否则使用 delegate.parseCustomElement() 方法对自定义命名空间进行解析。而判断是否默认命名空间还是
* 自定义命名空间的办法其实是使用 node.getNamespaceURI() 获取命名空间，并与 Spring 中固定的命名空间
* http://www.springframework.org/schema/beans 进行对比。如果一致则认为是默认，否则就认为是自定义。
*/
if (delegate.isDefaultNamespace(root)) {
NodeList nl = root.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element ele = (Element) node;
if (delegate.isDefaultNamespace(ele)) {
parseDefaultElement(ele, delegate);
}
else {
delegate.parseCustomElement(ele);
}
}
}
}
else {
delegate.parseCustomElement(root);
}
}
-
DefaultBeanDefinitionDocumentReader#parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate)
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 标签的处理
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}
-
DefaultBeanDefinitionDocumentReader#importBeanDefinitionResource(Element ele)
- 获取
resource属性所表示的路径 - 解析路径中的系统属性，格式如：
“${user.dir}” - 判定
location决定是绝对路径还是相对路径 - 如果是绝对路径则递归调用
bean的解析过程，进行另一次的解析 - 如果是相对路径则计算出绝对路径并进行解析
- 通知监听器，解析完成
protected void importBeanDefinitionResource(Element ele) {
// 获取 resource 属性
String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
if (!StringUtils.hasText(location)) {
getReaderContext().error("Resource location must not be empty", ele);
return;
}
// Resolve system properties: e.g. "${user.dir}"
// 解析系统属性，格式如：“${user.dir}”
location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);
Set<Resource> actualResources = new LinkedHashSet<>(4);
// Discover whether the location is an absolute or relative URI
// 判定 location 决定是 URI 还是相对 URI
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*:"
}
// Absolute or relative?
// 若是绝对 URI 则直接根据地址加载对应的配置文件（若是绝对路径则递归调用 bean 的解析过程，进行另一次的解析）
if (absoluteLocation) {
try {
int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
if (logger.isTraceEnabled()) {
logger.trace("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 {
// No URL -> considering resource location as relative to the current file.
// 若是相对地址则根据相对地址计算出绝对地址
try {
int importCount;
/*
* Resource 存在多个子实现类，如 VfsResource、FileSystemResource 等，而每个 resource 的
* createRelative() 方法实现都不一样，所以这里先使用子类的方法尝试解析
*/
Resource relativeResource = getReaderContext().getResource().createRelative(location);
if (relativeResource.exists()) {
importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
actualResources.add(relativeResource);
}
else {
// 若解析不成功，则使用默认的解析器 ResourcePatternResolver 进行解析
String baseLocation = getReaderContext().getResource().getURL().toString();
importCount = getReaderContext().getReader().loadBeanDefinitions(
StringUtils.applyRelativePath(baseLocation, location), actualResources);
}
if (logger.isTraceEnabled()) {
logger.trace("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[0]);
getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
}
-
DefaultBeanDefinitionDocumentReader#processAliasRegistration(Element ele)
protected void processAliasRegistration(Element ele) {
// 获取 beanName
String name = ele.getAttribute(NAME_ATTRIBUTE);
// 获取 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 {
// 注册 alias
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));
}
}
-
DefaultBeanDefinitionDocumentReader#processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate)
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
/*
* 首先委托 BeanDefinitionParserDelegate 类的 parseBeanDefinitionElement() 方法进行元素解析，返回
* BeanDefinitionHolder 类型的实例 bdHolder，经过这个方法以后，bdHolder 实例已经包含我们配置文件中配
* 置的各种属性了，例如 class、name、id、alias 之类的属性
*/
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
/*
* 当返回的 bdHolder 不为空的情况下若存在默认标签的子节点下再有自定义属性，还需要再次对自定义标签进行
* 解析
*/
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// Register the final decorated instance.
/*
* 解析完成以后，需要对解析后的 bdHolder 进行注册，同样，注册委托给了 BeanDefinitionReaderUtils 的
* registerBeanDefinition() 方法
*/
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// Send registration event.
/*
* 最后发出响应事件，通知相关的监听器，这个 bean 已经加载完成
*/
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
-
DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions(Element root)
protected void doRegisterBeanDefinitions(Element root) {
// Any nested <beans> elements will cause recursion in this method. In
// order to propagate and preserve <beans> default-* attributes correctly,
// keep track of the current (parent) delegate, which may be null. Create
// the new (child) delegate with a reference to the parent for fallback purposes,
// then ultimately reset this.delegate back to its original (parent) reference.
// this behavior emulates a stack of delegates without actually necessitating one.
// 专门处理解析
BeanDefinitionParserDelegate parent = this.delegate;
this.delegate = createDelegate(getReaderContext(), root, parent);
if (this.delegate.isDefaultNamespace(root)) {
// 处理 profile 属性
/*
* 首先程序会获取 beans 节点是否定义了 profile 属性，若定义了则会需要到环境变量中去寻找。因为 profile 是
* 可以同时指定多个的，需要程序对其拆分，并解析每个 profile 是都符合环境变量中所定义的，不定义则不会浪费性能
* 去解析。
*/
String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
if (StringUtils.hasText(profileSpec)) {
String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
// We cannot use Profiles.of(...) since profile expressions are not supported
// in XML config. See SPR-12458 for details.
if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
if (logger.isDebugEnabled()) {
logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
"] not matching: " + getReaderContext().getResource());
}
return;
}
}
}
// 解析前处理，留给子类
preProcessXml(root);
parseBeanDefinitions(root, this.delegate);
// 解析前处理，留给子类
postProcessXml(root);
this.delegate = parent;
}
