spring源码之IOC - xml - 加载bean定义 2 解析import、alias标签

这一章开始真正解析xml的标签，逻辑不复杂，但是内容比较多，所有单独放一篇文章。继续上一章的BeanDefinitionDocumentReader.registerBeanDefinitions()，该接口只有一个实现类就是：DefaultBeanDefinitionDocumentReader。以下面xml为例

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:cache="http://www.springframework.org/schema/cache"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd">

    <import resource="classpath*:/spring/job-timer.xml" />

	<bean id="some" class="src.com.Some"/>
    <alias name="some" alias="someJava,oneBean,twoBean"/>
</beans>

区分xml结构定义

registerBeanDefinitions()处理逻辑从xml的根节点开始。调用doRegisterBeanDefinitions()，判断xml是否为spring所定义的xml结构，分别处理。

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
	this.readerContext = readerContext;
	logger.debug("Loading bean definitions");
	// 获取根节点标签 <beans>
	Element root = doc.getDocumentElement();
	doRegisterBeanDefinitions(root);
}

// 处理传入的节点标签下的子节点标签，存在递归调用
protected void doRegisterBeanDefinitions(Element root) {
	BeanDefinitionParserDelegate parent = this.delegate;
	this.delegate = createDelegate(getReaderContext(), root, parent);

	// 处理使用spring默认的xml结构定义
	// 例如：例子中http://www.springframework.org/schema/beans
	if (this.delegate.isDefaultNamespace(root)) {
		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)) {
				if (logger.isInfoEnabled()) {
					logger.info("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;
}

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
	// 处理使用spring默认的xml结构定义
	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 {
					// 如果没有使用spring默认的xml结构定义，则使用用户自定义的结构，进行解析
					delegate.parseCustomElement(ele);
				}
			}
		}
	} else {
		// 根节点没有使用spring的定义的xml结构
		// 使用自定义的解析规则解析根节点
		delegate.parseCustomElement(root);
	}
}

从上面代码看出，xml的文档接口，可以有我们自定义，也就是我们所说的DTD。spring默认的结构定义使用XSD，是基于 XML 的 DTD 替代者。

使用spring的xml结构解析

对xml结构解析是从parseDefaultElement()开始的，该方法分别对import、alias、bean、beans标签进行路由调用指定的方法。

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
	if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
		// 解析 <import> 标签
		importBeanDefinitionResource(ele);
	} else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
		// 解析 <alias> 标签
		processAliasRegistration(ele);
	} else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
		// 解析 <bean> 标签
		processBeanDefinition(ele, delegate);
	} else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
		// 递归调用，本篇开始的方法
		doRegisterBeanDefinitions(ele);
	}
}

解析 import 标签

importBeanDefinitionResource()，先获得resource属性的值，也就是需要导入的资源路径。判断该路径是否为绝对路径还是相对路径分别处理。逻辑跟ioc启动时传入的location地址处理方式大相径庭，先解析地址获得Resource对象，然后继续往下解析。

protected void importBeanDefinitionResource(Element ele) {
	// 获取resource参数的值，也就是要导入的文件路径
	// 例如：例子中的classpath*:/spring/job-timer.xml
	String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
	// 非空判断，不做处理
	if (!StringUtils.hasText(location)) {
		getReaderContext().error("Resource location must not be empty", ele);
		return;
	}

	// 使用系统变量值："${user.dir}"解析location值
	location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);

	Set<Resource> actualResources = new LinkedHashSet<>(4);

	// 标记location值是否为绝对路径
	boolean absoluteLocation = false;
	try {
		absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
	} catch (URISyntaxException ex) {
		// 不能转为URI对象，则为相对地址
	}

	if (absoluteLocation) {
		// 为绝对地址
		try {
			// 加载给定文件的bean资源。里面逻辑还是一样的，先获取到Resource对象，然后继续加载
			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()) {
				// 相对路径地址存在，继续加载Resource
				importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
				actualResources.add(relativeResource);
			} else {
				// 相对路径不存在，则使用ioc资源读取器的基本路径
				String baseLocation = getReaderContext().getResource().getURL().toString();
				// 使用ioc读取器的基本路径加载给定的路径资源
				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));
}

解析 alias 标签

processAliasRegistration()先获取到name、alias属性的值，非空处理之后，调用registerAlias()向IOC中注册别名。registerAlias()的逻辑为：将别名保存到Map中，由alias映射到name。

protected void processAliasRegistration(Element ele) {
	// 获得name属性、alias属性
	// 例如：例子中 name="some" alias="someJava,oneBean,twoBean"
	String name = ele.getAttribute(NAME_ATTRIBUTE);
	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));
	}
}

// SimpleAliasRegistry
public void registerAlias(String name, String alias) {
	// 非空处理
	Assert.hasText(name, "'name' must not be empty");
	Assert.hasText(alias, "'alias' must not be empty");
	// 如果alias和name一致，相当于没有取别名。
	// remove已注册的别名，节省别名映射的性能
	if (alias.equals(name)) {
		this.aliasMap.remove(alias);
	} else {
		String registeredName = this.aliasMap.get(alias);
		// 如果已注册该别名，则判断之前注册的和本次注册的是否指向同一个bean。否则抛异常
		// 之所以要判断之前注册的和本次注册的是否指向同一个bean，是因为在最后注册BeanDefinition要兼容其他的IOC容器，也会调用registerAlias()
		if (registeredName != null) {
			if (registeredName.equals(name)) {
				// An existing alias - no need to re-register
				return;
			}
			if (!allowAliasOverriding()) {
				throw new IllegalStateException("Cannot register alias '" + alias + "' for name '" +
						name + "': It is already registered for name '" + registeredName + "'.");
			}
		}
		checkForAliasCircle(name, alias);
		// 注册别名
		this.aliasMap.put(alias, name);
	}
}

解析 bean 标签

processBeanDefinition()先将bean标签解析成BeanDefinitionHolder，再将BeanDefinitionHolder注册到IOC中。而BeanDefinitionHolder是对BeanDefinition的封装。如果说BeanDefinition是bean的描述，那么BeanDefinitionHolder则是对这个描述取一个名字，告诉这个BeanDefinition属于谁。

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
	// 对bean标签进行解析
	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
	if (bdHolder != null) {
		bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
		try {
			// 这里是将BeanDefinition注册到IOC的入口
			BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
		} catch (BeanDefinitionStoreException ex) {
			getReaderContext().error("Failed to register bean definition with name '" +
					bdHolder.getBeanName() + "'", ele, ex);
		}
		// 发送BeanDefinition注册完成的事件通知
		getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
	}
}

其中最重要的两个方法parseBeanDefinitionElement()和registerBeanDefinition()，这里不方便细讲，bean标签里面的子标签、属性太多，留给一下章细说。