1. XML读取

一、Xml 文件读取流程

1. 通过继承自 AbstractBeanDefinitionReader 中的方法，来使用 ResourceLoader 将资源文件路径转换为对应的 Resource 文件；

2. 通过 DocumentLoader 对 Resource 文件进行转换，将 Resource 文件转换为 Document 文件；

3. 通过实现接口 BeanDefinitionDocumentReader 的 DefaultBeanDefinitionDocumentReader 类对 Document 进行解析，并使用 BeanDefinitionParserDelegate 对 Element 进行解析。

 二、源代码阅读入口

BeanFactory bf = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
BookService bookService = (BookService) bf.getBean("bookService");

三、源码解析

1. Resource创建

　　创建 Resource 对象，并对成员变量 path、classLoader(用于加载文件流：java.lang.ClassLoader#getResourceAsStream(String)) 赋值。

public ClassPathResource(String path) {
    this(path, (ClassLoader) null);
}

public ClassPathResource(String path, ClassLoader classLoader) {
    Assert.notNull(path, "Path must not be null");
    String pathToUse = StringUtils.cleanPath(path);
    if (pathToUse.startsWith("/")) {
        pathToUse = pathToUse.substring(1);
    }
    this.path = pathToUse;
    this.classLoader = (classLoader != null ? classLoader : ClassUtils.getDefaultClassLoader());
}

扩展：Resource 有多种实现类，用于读取不同场景下的文件。读取文件（FileSystemResource）、读取Classpath资源（ClassPathResource）、读取Url资源（UrlResource）、读取InputStream资源（InputStreamResource），等等。

2. 忽略给定接口自动装配功能

　　先说结论：将影响初始化的条件先忽略掉。

　　举个例子：在Bean初始化时，如果存在 A 依赖 B，Spring会自动初始化 B，但是当 B 实现了 BeanNameAware 接口时，就无法初始化，这个时候，我们就需要先将影响初始化的条件忽略掉。

    public XmlBeanFactory(Resource resource) throws BeansException {
        this(resource, null);
    }
    public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
        super(parentBeanFactory);
        this.reader.loadBeanDefinitions(resource);
    }
    public DefaultListableBeanFactory(BeanFactory parentBeanFactory) {
        super(parentBeanFactory);
    }
    public AbstractAutowireCapableBeanFactory(BeanFactory parentBeanFactory) {
        this();
        setParentBeanFactory(parentBeanFactory);
    }
    public AbstractAutowireCapableBeanFactory() {
        super();
        ignoreDependencyInterface(BeanNameAware.class);
        ignoreDependencyInterface(BeanFactoryAware.class);
        ignoreDependencyInterface(BeanClassLoaderAware.class);
    }

3. 将 Resource 转换为 Document 文件

1. 使用 EncodedResource 对 Resource 进行封装，对资源文件进行编码处理

2. 使用 ThreadLocal 检测是否存在循环加载

3. 从 Resource 中获取 InputStream 构造 InputSource

4. 将 Resource 转换为 Document（DOM解析）

    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());
        }
        
        // resourcesCurrentlyBeingLoaded是一个ThreadLocal
        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文件
                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();
            }
        }
    }
    
    protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
            throws BeanDefinitionStoreException {
        try {
            Document doc = doLoadDocument(inputSource, resource);
            return registerBeanDefinitions(doc, resource);
        }
        // ...
        // 一堆catch和throw
    }
    
    // getValidationModeForResource(resource)：获取Xml验证格式（DTD or XSD）
    // getEntityResolver()：获取EntityResolver（该类用于自定义寻找DTD文件方法，DTD文件默认从网络读取）
    protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
        return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
                getValidationModeForResource(resource), isNamespaceAware());
    }
    
    // 创建Document并解析，创建Factory，然后再创建实例，最后通过Source转换为Document（DOM解析）
    public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
            ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {

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

4. 解析Xml

1. 解析前准备：创建documentReader、记录之前的BeanDefinition个数

2. 处理Profile属性，如果当前文件环境与Profile不一致，则不解析

3. 对root节点进行解析：

　　3.1 对于beans节点，使用bean解析

　　3.2 针对其他类型节点，使用自定义解析器解析

    public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
        // 使用DefaultBeanDefinitionDocumentReader实例化BeanDefinitionDocumentReader
        BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
        // 设置环境变量，XmlBeanDefinitionReader初始化时创建的
        documentReader.setEnvironment(getEnvironment());
        // 记录之前加载的BeanDefinition个数
        int countBefore = getRegistry().getBeanDefinitionCount();
        // Bean加载
        documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
        // 返回本次加载的BeanDefinition个数
        return getRegistry().getBeanDefinitionCount() - countBefore;
    }
    
    public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
        this.readerContext = readerContext;
        logger.debug("Loading bean definitions");
        Element root = doc.getDocumentElement();
        // 解析 root 下面所有节点
        doRegisterBeanDefinitions(root);
    }
    
    protected void doRegisterBeanDefinitions(Element root) {
        //专门处理解析
        BeanDefinitionParserDelegate parent = this.delegate;
        this.delegate = createDelegate(getReaderContext(), root, parent);
        
        // 处理profile属性，如果当前环境与profile不同，则不解析
        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);
        parseBeanDefinitions(root, this.delegate);
        // 解析后处理，由子类实现
        postProcessXml(root);

        this.delegate = parent;
    }
    
    protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
        // 判断节点是否为beans（使用节点的命名空间与Spring固定的命名空间进行比较http://www.springframework.org/schema/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)) {
                        parseDefaultElement(ele, delegate);
                    }
                    else {
                        delegate.parseCustomElement(ele);
                    }
                }
            }
        }
        // 自定义标签解析，例如 <tx:annotation-driven />
        else {
            delegate.parseCustomElement(root);
        }
    }