Spring标签的解析包括2个部分，一部分是默认标签解析，另一部分是自定义标签的解析。而默认标签主要包含了如下四类：import、alias、bean、beans。
标签的解析是在函数parseBeanDefinitions中进行的
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
//检查Namespace是否为默认命名空间
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);
}
}
首先检查root元素的Namespace是否为默认的Namespace，如果不是那么判定为是自定义标签，如果是那就获取子节点进行逐个判断，如果是默认命名空间那么就是默认标签，并按照默认标签进行解析，否则按照自定义标签进行解析。默认标签的解析是从函数parseDefaultElement开始的，而自定义标签是从parseCustomElement开始是的。
Ps：自定义标签的解析都是在BeanDefinitionParserDelegate中进行实现的。而自定义标签则是在DefaultBeanDefinitionDocumentReader中进行实现的。
1、默认标签解析
A、数据解析的环境准备
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
//解析所有关于bean标签
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}
Spring解析标签是按照标签的类型进行解析的，而其中对bean的解析是最为复杂的。源码如下：
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
//解析<bean>标签元素
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// Register the final decorated instance.
//将解析得到的beanDefination和别名注册进容器
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// Send registration event.
//spring拓展功能
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
这段代码主要完成如下几个功能：
1、解析xml中配置的<bean>标签。
2、将解析的beanDefination注册进容器。
3、通知监听器解析以及注册已经完成（是spring提供的一个拓展功能）。
DefaultBeanDefinitionDocumentReader对xml转换为beanDefination是爱莫能助的，所以将其委托给BeanDefinitionParserDelegate去解析。
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
//获取bean的id
String id = ele.getAttribute(ID_ATTRIBUTE);
//获取name
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
//将多个name转换为数组
List<String> aliases = new ArrayList<>();
if (StringUtils.hasLength(nameAttr)) {
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
aliases.addAll(Arrays.asList(nameArr));
}
String beanName = id;
if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
beanName = aliases.remove(0);
if (logger.isTraceEnabled()) {
logger.trace("No XML 'id' specified - using '" + beanName +
"' as bean name and " + aliases + " as aliases");
}
}
if (containingBean == null) {
//校验名字是否唯一，同一个别名是否使用多次
checkNameUniqueness(beanName, aliases, ele);
}
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
if (beanDefinition != null) {
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.isTraceEnabled()) {
logger.trace("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);
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}
return null;
}
1、获取xml中配置的id以及name属性
2、创建GenericBeanDefinition实例，用于记录解析后的数据，并实现解析。
3、校验是否配置beanName（xml中的id），如果没有配置那么使用spring提供的默认机制生成id
4、一系列信息的封装，便于后续进行处理
bean标签的解析是在parseBeanDefinitionElement函数中进行的。
@Nullable
public AbstractBeanDefinition parseBeanDefinitionElement(
Element ele, String beanName, @Nullable BeanDefinition containingBean) {
//记录解析是bean
this.parseState.push(new BeanEntry(beanName));
//获取配置的class
String className = null;
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
//获取配置的parent
String parent = null;
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
try {
//创建<bean>标签元素的容器内部数据表示
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
//解析默认bean的各种属性
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
//提取description
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
//解析元数据
parseMetaElements(ele, bd);
//解析lookup-method
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
//解析replaced-method
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
//解析构造函数
parseConstructorArgElements(ele, bd);
//解析property子元素
parsePropertyElements(ele, bd);
//解析qualified子元素
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;
}
其中函数做了如下几件事儿：
1、将该beanName记录在parseState集合中；
2、创建数据的存储容器--GenericBeanDefinition实例；
3、各种数据结构的解析。
Ps：parseState集合是记录了该beanName处于解析的状态。
BeanDefinition是一个接口，定义了一系列BeanDefinition的基础操作；
AbstractBeanDefinition是一个抽象类，实现了部分方法，同时定义了<bean>标签一一对应的属性，是配置文件中<bean>的内部表示形式。而GenericBeanDefinition是AbstractBeanDefinition的一个实现类，除此之外还包括：RootBeanDefinition和ChildBeanDefinition。RootBeanDefinition是最常用的实现类，对应一般性的<bean>元素标签，GenericBeanDefinition是2.5以后加入的bean文件配置属性定义类，是一站式服务。ChildBeanDefinition定义的是子bean。