public class XmlBeanFactory extends DefaultListableBeanFactory {
    public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
        // 1 加载数据前，还有一个调用父类构造函数初始化的过程，主要是忽略给定接口的自动装配功能。详见如下代码及备注
        super(parentBeanFactory);
        // 2 加载数据，见下个小节分析
        this.reader.loadBeanDefinitions(resource);
    }
}

public abstract class AbstractAutowireCapableBeanFactory{

    // 忽略给定接口的自动装配功能说明 
    public AbstractAutowireCapableBeanFactory() {
		super();
		/**
		 * Spring采用的是懒加载方式，当类 A 中有属性 B 时，在从容器中获取 A 对象时会查看属性是否初始化，没有的话会自动初始化 B。
		 * 然而有些情况下是不希望初始化属性 B 的。例如 B 实现了 BeanNameAware、BeanFactoryAware、
		 * BeanClassLoaderAware 接口(该接口作用是获取其在容器中的名称、容器、类加载器)。
		 */
		ignoreDependencyInterface(BeanNameAware.class);
		ignoreDependencyInterface(BeanFactoryAware.class);
		ignoreDependencyInterface(BeanClassLoaderAware.class);
	}
}

public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {
    @Override
	public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
		// 1. 封装资源文件，以及处理可能的编码问题 new EncodedResource(resource)：
		return loadBeanDefinitions(new EncodedResource(resource));
	}
}

public class EncodedResource implements InputStreamSource {
    // 设置编码属性，后续 Spring 会使用相应的编码作为输入流的编码
    public Reader getReader() throws IOException {
		if (this.charset != null) {
			return new InputStreamReader(this.resource.getInputStream(), this.charset);
		}
		else if (this.encoding != null) {
			return new InputStreamReader(this.resource.getInputStream(), this.encoding);
		}
	}
}

public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {
    public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
        // 2 获取输入流
		try (InputStream inputStream = encodedResource.getResource().getInputStream()) {
			// org.xml.sax.InputSource
			InputSource inputSource = new InputSource(inputStream);
			if (encodedResource.getEncoding() != null) {
				inputSource.setEncoding(encodedResource.getEncoding());
			}
			// 3 根据前面参数，继续调用 doLoadBeanDefinitions，这块是核心逻辑
			return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
		}
    }

    protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {

        // 3.1 获取对 XML 文件的验证模式。
        // 3.2 加载 XML 文件，并得到对应的 Document。
        Document doc = doLoadDocument(inputSource, resource);

        // 3.3 根据返回的 Document 注册 Bean 信息。
        int count = registerBeanDefinitions(doc, resource);
        if (logger.isDebugEnabled()) {
            logger.debug("Loaded " + count + " bean definitions from " + resource);
        }
        return count;
		
	}
}

public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {
    protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
		// 3.1 获取对 XML 文件的验证模式。
		// 3.2 加载 XML 文件，并得到对应的 Document。
		// loadDocument 委托给了 DocumentLoader 去执行，真正调用的是其子类，DefaultDocumentLoader。注意 getEntityResolver() 方法
		return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
				getValidationModeForResource(resource), isNamespaceAware());
	}

    // 3.1 获取对 XML 文件的验证模式。
    protected int getValidationModeForResource(Resource resource) {
		int validationModeToUse = getValidationMode();
		// 1 如果手动指定了验证模式则使用指定的验证模式
		if (validationModeToUse != VALIDATION_AUTO) {
			return validationModeToUse;
		}
		// 2 如果未指定则使用自动检测，将自动检测验证模式的工作委托给了专门处理类 XmlValidationModeDetector
		int detectedMode = detectValidationMode(resource);
		if (detectedMode != VALIDATION_AUTO) {
			return detectedMode;
		}
		return VALIDATION_XSD;
	}
}

public class DefaultDocumentLoader implements DocumentLoader {

    // 3.2 加载 XML 文件，并得到对应的 Document。
    @Override
	public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
			ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {

		DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
		if (logger.isTraceEnabled()) {
			logger.trace("Using JAXP provider [" + factory.getClass().getName() + "]");
		}
		DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
		return builder.parse(inputSource);
	}
}

public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {

    public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
		// 使用 DefaultBeanDefinitionDocumentReader 实例化 BeanDefinitionDocumentReader
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		// 在实例化 BeanDefinitionReader 时候会将 BeanDefinitionRegistry 传入，默认使用继承自 DefaultListableBeanFactory 的子类
		// 记录统计前 BeanDefinition 的加载个数
		int countBefore = getRegistry().getBeanDefinitionCount();
		// 重点：加载及注册 bean 的核心处理逻辑
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		// 记录本次加载的 BeanDefinition 个数
		return getRegistry().getBeanDefinitionCount() - countBefore;
	}
}

public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocumentReader {
    @Override
	public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
		this.readerContext = readerContext;
		doRegisterBeanDefinitions(doc.getDocumentElement());
	}

    protected void doRegisterBeanDefinitions(Element root) {
		// 专门处理解析
		BeanDefinitionParserDelegate parent = this.delegate;
		this.delegate = createDelegate(getReaderContext(), root, parent);

		if (this.delegate.isDefaultNamespace(root)) {
			// 处理 profile 属性，注意：没有该 profile 时，是直接 return 掉的
			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.isDebugEnabled()) {
						logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
								"] not matching: " + getReaderContext().getResource());
					}
					return;
				}
			}
		}

		// 解析前处理，留给子类实现
		preProcessXml(root);
		// 重点：解析并注册 BeanDefinition 的核心处理逻辑
		parseBeanDefinitions(root, this.delegate);
		// 解析后处理，留给子类实现
		postProcessXml(root);

		this.delegate = parent;
	}
}

public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocumentReader {
    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)) {
                        // SPRING 对 默认标签 beans 的处理
                        parseDefaultElement(ele, delegate);
                    }
                    else {
                        // SPRING 对 自定义标签 beans 的处理
                        delegate.parseCustomElement(ele);
                    }
                }
            }
        }
        else {
            // SPRING 对 自定义标签 beans 的处理
            delegate.parseCustomElement(root);
        }
    }
}