2. 糟糕！XmlBeanFactory被废弃了
对Spring有些了解的应该XmlBeanFactory已经过时了。没错，本篇要讲的XmlBeanFactory在Spring3.1这个很久远版本就开始过时了。
@deprecated as of Spring 3.1 in favor of {@link DefaultListableBeanFactory}
取而代之的写法如下
ClassPathResource resource=new ClassPathResource("spring-config.xml");
DefaultListableBeanFactory beanFactory=new DefaultListableBeanFactory();
XmlBeanDefinitionReader beanDefinitionReader=new XmlBeanDefinitionReader(beanFactory);
beanDefinitionReader.loadBeanDefinitions(resource);
概括DefaultListableBeanFactory + XmlBeanDefinitionReader 取代了 XmlBeanFactory容器的创建和初始化，可以联想到通过组合的方式灵活度是比XmlBeanFactory高的，针对不同的资源读取组合的方式只需替换不同的读取器BeanDefinitionReader就可以了，而XmlBeanFactory中的读取器XmlBeanDefinitionReader限定其只能读取XML格式的文件资源，所以至于XmlBeanFactory被废弃的原因可想而知。
3. XmlBeanFactory？！XML,你会XML解析吗？
<?xml version="1.0" encoding=" UTF-8" standalone="yes"?><root>
<code>0</code>
<message>调用成功</message>
</root>
附上DOM4J解析的代码
String xml="<?xml version=\"1.0\" encoding=\" UTF-8\" standalone=\"yes\"?><root>\n" +
"<code>0</code>\n" +
"<message>调用成功</message>\n" +
"</root>";
Document document = DocumentHelper.parseText(xml);
Element root = document.getRootElement();
String code = root.elementText("code");
String message =root.elementText("message");
XML文档被解析成DOM树，其中Document是整个DOM的根节点，root为根元素，由根元素一层一层向下解析element元素，容器启动解析XML流程就是这样。
三. XmlBeanFactory启动流程分析
XmlBeanFactory容器启动就两行代码
ClassPathResource resource = new ClassPathResource("spring-config.xml");
XmlBeanFactory beanFactory = new XmlBeanFactory(resource);
怎么样？看似简单就证明了Java封装的强大，但背后藏了太多。 这里就送上XmlBeanFactory启动流程图，对应的就是上面的两行代码。
这是啥？!看得头晕的看官老爷们别急着给差评啊(瑟瑟发抖中)。这里精简下，想快速理解的话直接看精简版后的，想深入到细节建议看下上面的时序图。整个就是bean的加载阶段。通过解析XML中的标签元素生成beanDefinition注册到beanDefinitionMap中。
四. XmlBeanFactory启动源码解析
按照XmlBeanFactory启动流程的先后顺序整理的关键性代码索引列表，其中一级索引为类，二级索引对应其类下的方法。符号 ---▷表示接口的实现。建议可以观察方法索引的参数变化（资源转换）来分析整个流程，来加深对流程的理解。
好了，当你心里对这个流程有个大概的样子之后，这里就可以继续走下去。建议还是很模糊的同学自重，避免走火入魔想对我人身攻击的。下面就每个方法重要的点一一解析，严格按照方法的执行先后顺序来说明。
1.1 XmlBeanFactory(Resource resource)
功能概述： XmlBeanFactory的构造方法，整个容器启动的入口，完成bean工厂的实例化和BeanDefinition加载（解析和注册）。
/**
* XmlBeanFactory
**/
public XmlBeanFactory(Resource resource) throws BeansException {
this(resource, null);
}
public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
super(parentBeanFactory);
// 加载(解析注册)BeanDefinition
this.reader.loadBeanDefinitions(resource);
}
知识点：
2.1 loadBeanDefinitions(Resource resource)
功能概述： 上面根据ClassPathResource资源访问策略拿到了资源Resource，这里将Resource进行特定的编码处理，然后将编码后的Resource转换成SAX解析XML文件所需要的输入源InputSource。
/**
* XmlBeanDefinitionReader
**/
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
// 把从XML文件读取的Resource资源进行编码处理
return loadBeanDefinitions(new EncodedResource(resource));
}
/**
* XmlBeanDefinitionReader
**/
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
...
// 完成resource->inputStream->inputSource转换，使用SAX方式接收输入源InputSource解析XML
try (InputStream inputStream = encodedResource.getResource().getInputStream()) {
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
// 执行加载BeanDefinition
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
...
}
知识点：
2.2 doLoadBeanDefinitions(InputSource inputSource, Resource resource)
功能概述： 获取DOM Document对象，XmlBeanDefinitionReader本身没有对文档读取的能力，而是委托给DocumentLoader的实现类DefaultDocumentLoader去读取输入源InputResource从而得到Document对象。获得Document对象后，接下来就是BeanDefinition的解析和注册。
/**
* XmlBeanDefinitionReader
**/
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
throws BeanDefinitionStoreException {
...
try {
// inputSource->DOM Document
Document doc = doLoadDocument(inputSource, resource);
int count = registerBeanDefinitions(doc, resource);
return count;
}
...
}
知识点:
2.3 registerBeanDefinitions(Document doc, Resource resource)
功能概述： 解析DOM Document成容器的内部数据接口BeanDefinition并注册到容器内部。
/**
* XmlBeanDefinitionReader
**/
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
// 已注册的BeanDefinition的数量
int countBefore = getRegistry().getBeanDefinitionCount();
// DOM Document->BeanDefinition，注册BeanDefinition至容器
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
// 返回此次注册新增的BeanDefinition数量
return getRegistry().getBeanDefinitionCount() - countBefore;
}
知识点：
3.1 registerBeanDefinitions(Document doc, XmlReaderContext readerContext)
功能概述： 在此之前一直 是XML加载解析的准备阶段，在获取到Document对象之后就开始真正的解析了。
/**
* DefaultBeanDefinitionDocumentReader
**/
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
this.readerContext = readerContext;
doRegisterBeanDefinitions(doc.getDocumentElement());
}
3.2 doRegisterBeanDefinitions(Element root)
功能概述： 解析Element，DefaultBeanDefinitionDoucumentReader同样不具有解析Element的能力，委托给BeanDefinitionParserDelegate执行。
/**
* DefaultBeanDefinitionDocumentReader
**/
protected void doRegisterBeanDefinitions(Element root) {
BeanDefinitionParserDelegate parent = this.delegate;
this.delegate = createDelegate(getReaderContext(), root, parent);
...
// 解析前处理，留给子类实现
preProcessXml(root);
parseBeanDefinitions(root, this.delegate);
// 解析后处理，留给子类实现
postProcessXml(root);
this.delegate = parent;
}
知识点：
3.3 parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate)
功能概述： 判别XML中Bean的声明标签是默认的还是自定义的，执行不同的解析逻辑。对于根节点或者子节点是默认命名空间采用parseDefaultElement，否则使用parseCustomElement对自定义命名空间解析。
/**
* DefaultBeanDefinitionDocumentReader
**/
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate){
// 对beans的处理
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)) {
// 对默认的Bean标签解析
parseDefaultElement(ele, delegate);
}
else {
// 对自定义的Bean标签解析
delegate.parseCustomElement(ele);
}
}
}
}
else {
delegate.parseCustomElement(root);
}
}
知识点：
3.4 parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate)
功能概述： 上面说到Spring标签包括默认标签和自定义标签两种。解析这两种方式分别不同。以下就默认标签进行说明BeanDefinitionParseDelegate对Bean标签元素的解析过程。
/**
* DefaultBeanDefinitionDocumentReader
**/
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
// import标签
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(ele);
}
}
知识点：
3.5 processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate)
功能概述： 在4中默认标签当中，其中核心的是对bean标签的解析。以下就对bean标签的解析来看解析过程。
/**
* DefaultBeanDefinitionDocumentReader
**/
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate){
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); // 参考4.1源码
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder); // 参考4.2源码
try {
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()); // 参考5.1源码
}
...
// Send registration event.
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
流程解读：
4.1 registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
功能概述： 通过BeanDefinitionParseDelegate对Bean标签的解析，解析得到id和name这些信息封装到BeanDefinitionHolder并返回。
/**
* BeanDefinitionParseDelegate
**/
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
return parseBeanDefinitionElement(ele, null);
}
/**
* BeanDefinitionParseDelegate
**/
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
// 解析id属性
String id = ele.getAttribute(ID_ATTRIBUTE);
// 解析name属性
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
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 (containingBean == null) {
checkNameUniqueness(beanName, aliases, ele);
}
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
if (beanDefinition != null) {
...
String[] aliasesArray = StringUtils.toStringArray(aliases);
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}
}
4.2 decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd)
功能概述： 4.1是对默认标签的属性解析，那如果标签有自定义属性和自定义子节点，这时就要通过decorateBeanDefinitionIfRequired解析这些自定义属性和自定义子节点。
/**
* BeanDefinitionParseDelegate
**/
public BeanDefinitionHolder decorateBeanDefinitionIfRequired(
Element ele, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {
BeanDefinitionHolder finalDefinition = originalDef;
// Decorate based on custom attributes first.
// 首先对自定义属性解析和装饰
NamedNodeMap attributes = ele.getAttributes();
for (int i = 0; i < attributes.getLength(); i++) {
Node node = attributes.item(i);
finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
}
// Decorate based on custom nested elements.
// 装饰标签下的自定义子节点
NodeList children = ele.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
Node node = children.item(i);
if (node.getNodeType() == Node.ELEMENT_NODE) {
finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
}
}
return finalDefinition;
}
5.1 registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
功能概述： 通过beanName注册BeanDefinition至BeanDefinitionMap中去，至此完成Bean标签的解析，转换成Bean在容器中的数据结构BeanDefinition.
/**
* BeanDefinitionReaderUtils
**/
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
// Register bean definition under primary name.
// 使用beanName注册BeanDefinition
String beanName = definitionHolder.getBeanName();
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// Register aliases for bean name, if any.
// 使用别名注册BeanDefiniion
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
}
/**
* BeanDefinitionParseDelegate
**/
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
...
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
if (existingDefinition != null) {
...
this.beanDefinitionMap.put(beanName, beanDefinition);
}else{
if (hasBeanCreationStarted()) {
// beanDefinitionMap是全局变量，会存在并发访问问题
synchronized (this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
removeManualSingletonName(beanName);
}
}
else {
// Still in startup registration phase
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
removeManualSingletonName(beanName);
}
this.frozenBeanDefinitionNames = null;
}
...
}
五. 结语
总结Spring IOC基础容器XmlBeanFactory的启动流程概括如下：
本篇就XmlBeanFactory容器启动流程分析和源码解析两个角度来对Spring IOC容器有个基础的认识。有了这篇基础，下篇就开始对Spring的扩展容器ApplicationContext进行分析。最后希望大家看完都有所收获，可以的话给个关注，感谢啦。
六. 附录
附上我编译好的Spring源码，版本是当前最新版本5.3.0，欢迎star