概述
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如何解析注解配置。