概述
Spring默認的BeanFactory是DefaultListableBeanFactory類，spring創建DefaultListableBeanFactory對象後，會把配置信息轉換成一個一個的BeanDefinition對象，並把這些BeanDefinition對象註冊到DefaultListableBeanFactory對象中，以供bean工廠創建bean實例。BeanDefinition對象存儲的是單個bean的配置信息，比如依賴類、scope、是否延遲加載等等。
Spring可以通過4種方式配置bean，其一是基於xml的配置，其二種是基於xml+註解的配置，其三是基於java+註解的配置，其四是基於property文件的配置。前兩種的配置信息使用XmlBeanDefinitionReader對象來解析；第三種的配置信息使用AnnotatedBeanDefinitionReader對象來解析；最後一種的配置信息使用PropertiesBeanDefinitionReader對象來解析。
而這裏要討論的主題是xml配置的解析過程，因此我們的戰場在XmlBeanDefinitionReader，首先看看它的繼承結構，如下圖。
簡單的說XmlBeanDefinitionReader實現了BeanDefinitionReader接口，BeanDefinitionReader的設計用意是加載BeanDefintion對象，下面是它加載BeanDefintion的4個接口方法。
/**
* 從單個指定的資源對象中加載BeanDefintion，並返回加載的BeanDefintion個數
*/
int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;
/**
* 從多個指定的資源對象中加載BeanDefintion，並返回加載的BeanDefintion個數
*/
int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException;
/**
* 從單個指定的資源地址中加載BeanDefintion，並返回加載的BeanDefintion個數。
* 如果資源加載器是ResourcePatternResolver對象，那麼location參數可以使用通配符。
*/
int loadBeanDefinitions(String location) throws BeanDefinitionStoreException;
/**
* 從多個指定的資源地址中加載BeanDefintion，並返回加載的BeanDefintion個數。
*/
int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException;這4個接口在後面會一一談到，這裏還有個問題留給大家，既然是加載BeanDefintion，爲什麼不是返回所有加載的BeanDefintion對象，而是返回加載的個數？
在spring中直接使用XmlBeanDefinitionReader的容器有XmlWebApplicationContext、ClassPathXmlApplicationContext、FileSystemXmlApplicationContext。下面就從XmlWebApplicationContext爲例來探索xml配置的解析過程。
XmlWebApplicationContext解析配置文件分爲以下2個過程：
1） 創建並初始化XmlBeanDefinitionReader 對象。
2）使用XmlBeanDefinitionReader 對象提供的接口方法來加載BeanDefinition對象。
下面我們通過spring源碼來探討這個2個過程。
1 創建並初始化XmlBeanDefinitionReader 對象
XmlWebApplicationContext在創建完BeanFacotry的時候會調用它的loadBeanDefinitions(DefaultListableBeanFactory beanFactory)方法來加載BeanDefinition，loadBeanDefinitions方法的代碼如下。
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// 根據給定的bean工廠創建新的XmlBeanDefinitionReader對象
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
// 使XmlBeanDefinitionReader對象與上下文對象在同一個資源環境中
beanDefinitionReader.setEnvironment(this.getEnvironment());
// 使用上下文對象爲XmlBeanDefinitionReader對象的資源加載器
beanDefinitionReader.setResourceLoader(this);
// 設置EntityResolver對象，用於加載XML的xsd或者dtd文件
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
// 鉤子方法，允許子類在加載bean definition之前進一步設置XmlBeanDefinitionReader
// ->比如，更改XmlBeanDefinitionReader自己提供的DocumentLoader
// 或者BeanDefinitionDocumentReader等默認對象
initBeanDefinitionReader(beanDefinitionReader);
// 使用BeanDefinitionReader加載所有的BeanDefinition對象，見下面的代碼
loadBeanDefinitions(beanDefinitionReader);
}這段代碼是爲使用BeanDefinitionReader對象加載BeanDefinitioin對象做準備工作。BeanDefinitionRegistry對象是BeanDefinition對象的註冊表，並且它是XmlBeanDefinitionReader對象創建時必須提供的，除此之外，其它的都使用默認或者由使用者提供。在XmlWebApplicationContext容器裏，容器向BeanDefinitionReader提供了3個對象，第一個是資源環境Environment對象，它可用於判斷beans標籤的profile屬性，後面會談到；第二個是資源加載器ResourceLoader對象；最後一個是用於加載XML驗證文件（dtd或者xsd文件）的EntityResolver對象。如果這些還不夠，則可以擴展XmlWebApplicationContext容器，並重寫initBeanDefinitionReader方法對BeanDefinitionReader做更多的初始化。
2 使用XmlBeanDefinitionReader 對象來加載BeanDefinition
首先，還是先預覽一下XmlBeanDefinitionReader 加載BeanDefinition的流程：
上圖只是大致描述了XmlBeanDefinitionReader對象加載BeanDefinition的過程，還有些重點的旁枝末節沒有展現出來，但這並不影響我們瞭解XmlBeanDefinitionReader解析xml配置的過程。下面我們看看XmlWebApplicationContext如何使用XmlBeanDefinitionReader對象，以及XmlBeanDefinitionReader對象如何按照這個流程執行的。
創建完成BeanDefinitionReader對象後，XmlWebApplicationContext調用它的loadBeanDefinitions(XmlBeanDefinitionReader reader)方法來使用BeanDefinitionReader對象。下面是loadBeanDefinitions(XmlBeanDefinitionReader reader)方法的代碼。
/**
* 使用XmlBeanDefinitionReader加載所有的BeanDefinition對象
**/
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException {
// 獲取容器需要加載的配置文件的地址
String[] configLocations = getConfigLocations();
if (configLocations != null) {
for (String configLocation : configLocations) {
// 使用XmlBeanDefinitionReader一個一個的讀取spring配置文件
reader.loadBeanDefinitions(configLocation);
}
}
}這部分代碼是XmlBeanDefinitionReader 使用xml配置文件地址加載BeanDefinition對象的入口。這裏所調用XmlBeanDefinitionReader的loadBeanDefinitions方法繼承自XmlBeanDefinitionReader的父類AbstractBeanDefinitionReader。下面代碼是loadBeanDefinitions方法在AbstractBeanDefinitionReader類中的實現。
public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
return loadBeanDefinitions(location, null);
} public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
ResourceLoader resourceLoader = getResourceLoader();
if (resourceLoader == null) {
throw new BeanDefinitionStoreException(
"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
}
if (resourceLoader instanceof ResourcePatternResolver) {
// 使用資源模式解析器解析配置文件的路徑並加載資源
try {
// 加載所有與指定location參數匹配的所有資源
Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
// 加載指定的資源中的所有BeanDefinition
int loadCount = loadBeanDefinitions(resources);
if (actualResources != null) {
for (Resource resource : resources) {
actualResources.add(resource);
}
}
if (logger.isDebugEnabled()) {
logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
}
return loadCount;
} catch (IOException ex) {
throw new BeanDefinitionStoreException(
"Could not resolve bean definition resource pattern [" + location + "]", ex);
}
} else {
// 直接加載資源且只加載一個資源，默認使用DefaultResourceLoader的getResource方法
Resource resource = resourceLoader.getResource(location);
// 加載指定的resource中的所有BeanDefinition
int loadCount = loadBeanDefinitions(resource);
if (actualResources != null) {
actualResources.add(resource);
}
if (logger.isDebugEnabled()) {
logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
}
return loadCount;
}
} 這段代碼主要做的事情是，使用BeanDefinitionReader對象所持有的ResourceLoader來生成Resource對象。然後調用BeanDefinitionReader的loadBeanDefinitions(Resource… resources)或者loadBeanDefinitions(Resource resource)方法來執行加載BeanDefinition的代碼，其中，前一個方法通過多個資源文件來加載，後一個方法通過一個資源文件來加載。
首先我們從處理多個Resource對象的loadBeanDefinitions(Resource… resources)方法開始，這個方法已經在AbstractBeanDefinitionReader中有實現，並且XmlBeanDefinitionReader直接繼承了它，代碼如下。
public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
Assert.notNull(resources, "Resource array must not be null");
int counter = 0;
for (Resource resource : resources) {
// 一個一個資源文件的加載BeanDefinition
// 此接口方法在AbstractBeanDefinitionReader沒有實現
// XmlWebApplicationContext使用XmlBeanDefinitionReader
// ->則調用XmlBeanDefinitionReader的實現
counter += loadBeanDefinitions(resource);
}
return counter;
}這部分代碼的所做的事情是遍歷傳入的資源Resource對象，並調用loadBeanDefinitions(Resource resource)方法加載每一個資源。這個方法在AbstractBeanDefinitionReader並沒有實現，下面是此方法在XmlBeanDefinitionReader類中的實現代碼。
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
return loadBeanDefinitions(new EncodedResource(resource));
} public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
Assert.notNull(encodedResource, "EncodedResource must not be null");
if (logger.isInfoEnabled()) {
logger.info("Loading XML bean definitions from " + encodedResource.getResource());
}
Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
if (currentResources == null) {
currentResources = new HashSet<EncodedResource>(4);
this.resourcesCurrentlyBeingLoaded.set(currentResources);
}
if (!currentResources.add(encodedResource)) {
throw new BeanDefinitionStoreException(
"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
}
try {
// 讀取資源文件輸入流
InputStream inputStream = encodedResource.getResource().getInputStream();
try {
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
// 根據指定的XML文件加載BeanDefinition
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
finally {
inputStream.close();
}
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(
"IOException parsing XML document from " + encodedResource.getResource(), ex);
}
finally {
currentResources.remove(encodedResource);
if (currentResources.isEmpty()) {
this.resourcesCurrentlyBeingLoaded.remove();
}
}
}loadBeanDefinitions(EncodedResource encodedResource)方法主要做的事情是從Resource對象中獲取xml文件輸入流，並用它來創建InputSource對象。然後調用XmlBeanDefinitionReader的doLoadBeanDefinitions(InputSource inputSource, Resource resource)方法，代碼如下。
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
throws BeanDefinitionStoreException {
try {
// 加載Document對象
Document doc = doLoadDocument(inputSource, resource);
// 註冊BeanDefinition
return registerBeanDefinitions(doc, resource);
} catch (BeanDefinitionStoreException ex) {
throw ex;
} catch (SAXParseException ex) {
throw new XmlBeanDefinitionStoreException(resource.getDescription(),
"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
} catch (SAXException ex) {
throw new XmlBeanDefinitionStoreException(resource.getDescription(),
"XML document from " + resource + " is invalid", ex);
} catch (ParserConfigurationException ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"Parser configuration exception parsing XML from " + resource, ex);
} catch (IOException ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"IOException parsing XML document from " + resource, ex);
} catch (Throwable ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"Unexpected exception parsing XML document from " + resource, ex);
}
} /**
* 獲取Document對象
**/
protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
// 使用DocumentLoader來加載Document對象
return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler, getValidationModeForResource(resource), isNamespaceAware());
}
/**
* 獲得XML驗證模式，默認使用xsd
*/
protected int getValidationModeForResource(Resource resource) {
int validationModeToUse = getValidationMode();
if (validationModeToUse != VALIDATION_AUTO) {
return validationModeToUse;
}
int detectedMode = detectValidationMode(resource);
if (detectedMode != VALIDATION_AUTO) {
return detectedMode;
}
return VALIDATION_XSD;
}這部分代碼所做的事情首先是獲取xml文檔的驗證模式，spring使用的xsd模式；然後調用DocumentLoader的loadDocument來讀取InputSource對象中的XML內容並創建Document對象，XmlBeanDefinitionReader默認的DocumentLoader爲DefaultDocumentLoader；最後調用registerBeanDefinitions(Document doc, Resource resource)方法來處理剛創建的Document對象，下面是XmlBeanDefinitionReader類中registerBeanDefinitions方法的代碼。
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
// 創建BeanDefinitionDocumentReader對象
// 默認爲DefaultBeanDefinitionDocumentReader
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
// documentReader需要持有當前的環境對象
documentReader.setEnvironment(this.getEnvironment());
int countBefore = getRegistry().getBeanDefinitionCount();
//首先創建XmlReaderContext對象
// 通過BeanDefinitionDocumentReader註冊BeanDefinition
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
return getRegistry().getBeanDefinitionCount() - countBefore;
}從這部分代碼可以看出，XmlBeanDefinitionReader使用BeanDefinitionDocumentReader 對象來加載Document對象中的配置信息。
這部分代碼主要做的事情有3步。第一步是創建BeanDefinitionDocumentReader對象，默認是DefaultBeanDefinitionDocumentReader；第二步是創建調用它的registerBeanDefinitions方法所需要的XmlReaderContext上下文對象，XmlReaderContext對象持有當前要讀取的資源、xml命名空間處理；第三步是調用documentReader的registerBeanDefinitions(Document doc, XmlReaderContext readerContext)處理Document對象。下面分別探討這三步的代碼。
第一步創建BeanDefinitionDocumentReader對象。
/**
* 創建BeanDefinitionDocumentReader對象
**/
protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() {
return BeanDefinitionDocumentReader.class.cast(BeanUtils.instantiateClass(this.documentReaderClass));
}第二步：創建XmlReaderContext上下文對象。
/**
* 創建XmlReaderContext對象
**/
public XmlReaderContext createReaderContext(Resource resource) {
return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
this.sourceExtractor, this, getNamespaceHandlerResolver());
}
/**
* 創建NamespaceHandlerResolver對象
**/
public NamespaceHandlerResolver getNamespaceHandlerResolver() {
if (this.namespaceHandlerResolver == null) {
this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
}
return this.namespaceHandlerResolver;
}
/**
* 創建默認的命名空間處理器容器
**/
protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
return new DefaultNamespaceHandlerResolver(getResourceLoader().getClassLoader());
}第三步執行DefaultBeanDefinitionDocumentReader的registerBeanDefinitions(Document doc, XmlReaderContext readerContext)方法。
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
this.readerContext = readerContext;
logger.debug("Loading bean definitions");
// 獲得root節點
Element root = doc.getDocumentElement();
// 註冊root節點中的所有BeanDefinition
doRegisterBeanDefinitions(root);
}這一步是處理Document對象的重點也是入口。XML文件中只允許有一個根節點，上面的代碼所做的事情就是保存XmlReaderContext 對象並提取根節點，然後調用DefaultBeanDefinitionDocumentReader的doRegisterBeanDefinitions(Element root)方法，這個方法的代碼如下。
protected void doRegisterBeanDefinitions(Element root) {
// 在這個方法中，遞歸所有嵌套<beans>元素。
// 爲了正確地延用並保存<beans>元素的default-*屬性
// ->需要把父節點<beans>的delegate記錄下來，也許這個delegate可能爲null。
BeanDefinitionParserDelegate parent = this.delegate;
// 爲當前的<beans>節點創建delgate對象
this.delegate = createDelegate(getReaderContext(), root, parent);
if (this.delegate.isDefaultNamespace(root)) {
// 檢查beans標籤上的profile屬性
// 聲明：public static final String PROFILE_ATTRIBUTE = "profile";
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);
// 解析完嵌套的<beans>標籤後，還原父節點的delegate
this.delegate = parent;
}這段代碼主要也分成3步，第一步創建BeanDefinitionParserDelegate對象，這個對象的作用是代理DefaultBeanDefinitionDocumentReader解析BeanDefinition對象；第二步檢查bean標籤的profile屬性值是否與環境的匹配，如果不匹配則不處理而直接返回；第三步執行parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate)方法。下面分別探討第一步和第三步。
（1） 創建BeanDefinitionParserDelegate對象，代碼如下
protected BeanDefinitionParserDelegate createDelegate(
XmlReaderContext readerContext, Element root, BeanDefinitionParserDelegate parentDelegate) {
// 創建BeanDefinitionParserDelegate
BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext);
// 初始化delegate的Defaults
// 如果當前<beans>節點的屬性值等於默認值，則使用父節點<beans>對應的屬性值。
delegate.initDefaults(root, parentDelegate);
return delegate;
}
（2） 執行DefaultBeanDefinitionDocumentReader的parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate)方法，代碼如下
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
// 檢查root節點的命名空間是否爲默認命名空間
// spring配置文件中默認的命名空間爲"http://www.springframework.org/schema/beans"
if (delegate.isDefaultNamespace(root)) {
NodeList nl = root.getChildNodes();
// 遍歷root節點下的所有子節點
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);
}
}這段代碼主要是區分節點的命名空間，根據不同命名空間，調用相應的方法。如果節點在默認命名空間（http://www.springframework.org/schema/beans），則調用DefaultBeanDefinitionDocumentReader的parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate)方法，否則調用BeanDefinitionParserDelegate 的parseCustomElement(Element ele)方法。
（1）處理自定義命名空間下的節點。執行BeanDefinitionParserDelegate的 parseCustomElement(Element ele) 方法，代碼如下
public BeanDefinition parseCustomElement(Element ele) {
return parseCustomElement(ele, null);
} public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
String namespaceUri = getNamespaceURI(ele);
NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
if (handler == null) {
error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
return null;
}
return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}這部分代碼主要是獲取自定義命名空間的處理器，然後執行處理器的parse方法來創建一個BeanDefinition對象。
（2）處理默認命名空間下的節點。 執行DefaultBeanDefinitionDocumentReader的parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate)方法，代碼如下。
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
// 處理import節點元素
// 這裏同樣是獲取配置文件並把註冊BeanDefinition對象
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)) {
// 處理beans節點元素，遞歸調用doRegisterBeanDefinitions，詳見4.3
doRegisterBeanDefinitions(ele);
}
}這段代碼是處理import、beans、alias、bean標籤的入口方法。
- import標籤是引入其它spring配置文件；
- beans標籤是對bean進行分類配置，比如用一個beans來管理測試環境的bean，用另一個beans來管理生產環境的bean；
- alias標籤是爲一個已定義了的bean取別名，它的name屬性值是bean的id，alias屬性值是要取的別名，多個別名用英文逗號、分號或者空格隔開；
- bean標籤的信息就是spring要實例化的對象。
不管是什麼標籤，只有利用bean標籤纔會生成BeanDefinition對象，下面重點探討的bean標籤處理。 執行DefaultBeanDefinitionDocumentReader的processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate)方法，代碼如下。
/**
* 解析bean節點，並註冊BeanDefinition對象
*/
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
// 創建BeanDefinitionHolder
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
// 裝飾BeanDefinition
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// 註冊已經創建好的BeanDefintion
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));
}
}這段代碼分成三步。第一步，根據傳入的Element對象（bean標籤的）調用代理對象的parseBeanDefinitionElement(Element ele)方法創建BeanDefinitionHolder 對象，這個對象持有創建好的BeanDefinition對象、bean的id和bean的別名。
第二步，調用代理對象的decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder definitionHolder)來對BeanDefinition對象再加工，主要是解析bean標籤中自定義屬性和自定義標籤。
第三步，調用工具類BeanDefinitionReaderUtils的registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)方法，這個方法用於註冊創建好的BeanDefinition。
前面兩步主要是完成BeanDefintion的創建和自定義，在這裏不做更深入的探討，下面我們看看第三步，註冊BeanDefinition對象。 執行BeanDefinitionReaderUtils的registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)方法，把BeanDefinition對象註冊到BeanDefinitionRegistry 對象中
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
String beanName = definitionHolder.getBeanName();
// 把BeanDefinition對象註冊到BeanDefinitionRegistry 對象中
// 我們通過DefaultListableBeanFactory爲例，介紹BeanDefinition的註冊
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// 把bean id與別名關聯起來
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String aliase : aliases) {
registry.registerAlias(beanName, aliase);
}
}
}這部分代碼的作用是調用BeanDefinitionRegistry 的registerBeanDefinition(String beanName, BeanDefinition beanDefinition)方法來註冊BeanDefinition，然後調用它的registerAlias(String name, String alias)來使bean的id和別名關聯起來。
DefaultListableBeanFactory實現了BeanDefinitionRegistry 接口的registerBeanDefinition(String beanName, BeanDefinition beanDefinition)方法，代碼如下。
//---------------------------------------------------------------------
// Implementation of BeanDefinitionRegistry interface
//---------------------------------------------------------------------
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
} catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
BeanDefinition oldBeanDefinition;
oldBeanDefinition = this.beanDefinitionMap.get(beanName);
if (oldBeanDefinition != null) {
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
"': There is already [" + oldBeanDefinition + "] bound.");
} else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
if (this.logger.isWarnEnabled()) {
this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
"' with a framework-generated bean definition: replacing [" +
oldBeanDefinition + "] with [" + beanDefinition + "]");
}
} else if (!beanDefinition.equals(oldBeanDefinition)) {
if (this.logger.isInfoEnabled()) {
this.logger.info("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + oldBeanDefinition +
"] with [" + beanDefinition + "]");
}
} else {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + oldBeanDefinition +
"] with [" + beanDefinition + "]");
}
}
// 覆蓋原來的BeanDefinition
this.beanDefinitionMap.put(beanName, beanDefinition);
} else {
if (hasBeanCreationStarted()) {
// BeanDefintion已經註冊完成，而其他bean正在創建
synchronized (this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
if (this.manualSingletonNames.contains(beanName)) {
Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
updatedSingletons.remove(beanName);
this.manualSingletonNames = updatedSingletons;
}
}
} else {
// 註冊BeanDefintion還未完成
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
this.manualSingletonNames.remove(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (oldBeanDefinition != null || containsSingleton(beanName)) {
// 重置BeanDefintiion
resetBeanDefinition(beanName);
}
}這段代碼的主要作用是DefaultListableBeanFactory把創建完成的BeanDefinition保存到Map對象beanDefinitionMap中，同時還要把以前已經創建好的bean（如果存在）銷燬掉。
總結
1. XmlBeanDefinitionReader的真正身份
XmlBeanDefinitionReader並不是xml配置的真正解析者，它只是相當於一個指揮官。當它收到一條需要加載BeanDefinition對象的任務後，它只會協調手下去完成相應的工作，它的手下有：
ResourceLoader，它把指定的配置文件地址封裝成Resource對象。
DocumentLoader，它把Resource對象中的XML文件內容轉換爲Document對象。默認使用DocumentLoader的實現類DefaultDocumentLoader來加載Document對象。
BeanDefinitionDocumentReader，它把Document對象中包含的配置信息轉換成BeanDefinition對象並把它註冊到BeanDefintionRegistry對象中。默認使用DefaultBeanDefinitionDocumentReader來操作Document對象。在DefaultBeanDefinitionDocumentReader的實現中，它的責任是遍歷xml根節點下的子節點，並把處理bean標籤和自定義命名空間的標籤（比如aop:，context:，p:等）的細節委託給BeanDefinitionParserDelegate對象，BeanDefinitionParserDelegate纔是真正解析配置文件的地方。
NamespaceHandlerResolver，用於獲取非默認命名空間的處理器，默認是DefaultNamespaceHandlerResolver對象。它雖然由XmlBeanDefinitionReader提供，但真正的使用者是BeanDefinitionParserDelegate類。
2. 更改XmlBeanDefinitionReader的默認對象
比如需要更改DocumentLoader、NamespaceHandlerResolver或者BeanDefinitionDocumentReader,甚至是ResourceLoader。
繼承XmlWebApplicationContext，並重寫initBeanDefinitionReader(XmlBeanDefinitionReader beanDefinitionReader)，這個方法在XmlWebApplicationContext只是一個空實現，特意留給子類在使用XmlBeanDefinitionReader對象加載BeanDefinition之前對這個對象進行定製的。
遺留問題
這一篇文章只是大致的過了一下XmlBeanDefinitionReader如何根據指定的配置文件地址來加載並註冊BeanDefintion對象，至於以下細節並沒有過多的描述。
ResourceLoader如何根據指定的location生成Resource對象。
DocumentLoader如何根據xml輸入流生成爲Document對象。
Spring如何解析bean標籤的屬性以及子節點。
Spring如何解析非默認命名空間的配置。
Spring如何解析註解配置。