IOC实现之XML元素解析过程(三)

接着上篇文章的最后代码继续我们接下来的分析，接下来会进入下述方法中；

	//注册beanDefinition
	public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
		//默认使用DefaultBeanDefinitionDocumentReader类
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		documentReader.setEnvironment(getEnvironment());
		int countBefore = getRegistry().getBeanDefinitionCount();
		//借助于bean定义文档读取器来完成对Document的解析操作
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		return getRegistry().getBeanDefinitionCount() - countBefore;
	}
	
	public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
		this.readerContext = readerContext;
		logger.debug("Loading bean definitions");
		//拿到根元素，我们在下面的图中可以看看它是什么，其实就是我们在XML中的<beans>元素的配置内容啦!
		Element root = doc.getDocumentElement();
		doRegisterBeanDefinitions(root);
	}

protected void doRegisterBeanDefinitions(Element root) {
		BeanDefinitionParserDelegate parent = this.delegate;
		//创建一个BeanDefinitionParserDelegate类，后面会委托它去对Element元素进行解析
		this.delegate = createDelegate(getReaderContext(), root, parent);

		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)) {
					return;
				}
			}
		}
	
		preProcessXml(root);
		//解析Element
		parseBeanDefinitions(root, this.delegate);
		postProcessXml(root);

		this.delegate = parent;
	}
	
	protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
		//如果该元素是默认的命名空间里的元素，所谓默认命名空间，也就是我们在XML中配置的http://www.springframework.org/schema/beans
		//有可能不是这个命名空间，如果配置了<context:component-scan base-package=""/> 
		//那它的命名空间就是http://www.springframework.org/schema/context
		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);
		}
	}

我们继续深入parseDefaultElement方法中看到底是怎么解析我们刚才拿到的Element元素的，也就是我们的这一行配置

<bean id="pants" class="com.fyrj.compoment.spring.test.ioc.Pants">
	<constructor-arg index="0" name="color" value="黄色"/>
</bean>

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)) {
			//我们的元素是bean元素，接下来深入此方法看看
			processBeanDefinition(ele, delegate);
		}
		//如果是beans元素
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}
	
	//根据给予的元素处理解析出BeanDefinition
	protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		//借助于前面创建好的BeanDefinitionParserDelegate去做解析操作
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				// Register the final decorated instance.
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
			}
			catch (BeanDefinitionStoreException ex) {
				getReaderContext().error("Failed to register bean definition with name '" +
						bdHolder.getBeanName() + "'", ele, ex);
			}
			// Send registration event.
			getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
		}
	}

接下来开始进入BeanDefinitionParserDelegate的一系列方法之中，DefaultBeanDefinitionDocumentReader类的方法已经全部调用完毕；结合上一篇文章与上面的代码，我们可以得出一个小结论，那就是：

XmlBeanDefinitionReader的职责是获取到Resource并将其转换为输入流，然后再将输入流转换成Document对象，接下来，它创建好DefaultBeanDefinitionDocumentReader对象，然后交给它去做接下来的解析动作，具体的Document的解析过程，它就不去关心了；

DefaultBeanDefinitionDocumentReader的职责是通过Document树拿到Element根元素，然后对根元素做遍历操作，根据每一个元素的命名空间不同以及元素名字不同而采取不同的解析过程，至于更加具体的解析工作，它就不去关心了，比如对bean元素的解析，它将会委托给BeanDefinitionParserDelegate去做；

接着我们来看看BeanDefinitionParserDelegate是怎么将配置转换为beanDefinition对象的；

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
		return parseBeanDefinitionElement(ele, null);
	}
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
		//拿到我们配置的id的值，这里会拿到pants
		String id = ele.getAttribute(ID_ATTRIBUTE);
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

		List<String> aliases = new ArrayList<String>();
		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.isDebugEnabled()) {
				logger.debug("No XML 'id' specified - using '" + beanName +
						"' as bean name and " + aliases + " as aliases");
			}
		}

		if (containingBean == null) {
			//验证这个bean名称以及别名是否已被其它bean使用，如果是，方法内部将抛出异常！
			checkNameUniqueness(beanName, aliases, ele);
		}
		
		//调用该方法解析出BeanDefinition，这个方法非常重要！！
		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.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);
			return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
		}

		return null;
	}
	
	public AbstractBeanDefinition parseBeanDefinitionElement(
			Element ele, String beanName, BeanDefinition containingBean) {

		this.parseState.push(new BeanEntry(beanName));

		String className = null;
		if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
			//拿到配置好的class值，com.fyrj.compoment.spring.test.ioc.Pants
			className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
		}

		try {
			String parent = null;
			if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
				parent = ele.getAttribute(PARENT_ATTRIBUTE);
			}
			//通过BeanDefinitionReaderUtils创建一个GenericBeanDefinition
			AbstractBeanDefinition bd = createBeanDefinition(className, parent);
			
			//设置好bd的通用属性值，比如lazy-init属性，init-method等等...如果我们没有在xml中指定这些属性，
			//将会去它内部的defaults里面拿到默认值来进行填充,这个过程很简单，自己进去看看就知道了,截取一小段内部代码如下：
			//
			//	String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
			//	if (DEFAULT_VALUE.equals(lazyInit)) {
			//		lazyInit = this.defaults.getLazyInit();
			//	}
			//	bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
			
			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
			
			//设置好bd的元数据信息，如果我们配置了这个的话
			//<bean><meta key="" value=""/></bean>
			parseMetaElements(ele, bd);
			
			//设置好bd的方法注入信息，如果我们配置了这个的话
			//<bean><lookup-method/><?bean>
			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
			
			//设置好bd的需要重载的方法信息，如果我们配置了这个的话
			//<bean><replaced-method/><?bean>
			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
			
			//重点解析，设置好我们配置的构造参数
			parseConstructorArgElements(ele, bd);
			//重点解析，设置好我们配置的属性参数
			parsePropertyElements(ele, bd);
			
			//设置好通过Qualifier指定注入bean的名称，如果我们配置了这个的话
			//<bean><qualifier/></bean>
			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;
	}

Ok，我们看到了在parseBeanDefinitionElement方法中，有针对各种子元素的不同解析方法，有针对于构造器constructor-arg的，也有针对于property的，也就是我上面注释中写的两处需要重点解析的地方！这里放到下一篇文章中再作深入的研究，研究完后我们再画个图做做总结... 因为我觉得一篇文章写太长的话...读者会不耐烦的...