接着上篇文章的最後代碼繼續我們接下來的分析，接下來會進入下述方法中；
//註冊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;
}