spring源码-增强容器xml解析-3.1

客官°小女子只卖身不卖艺 2022-05-16 11:26 126阅读 0赞

[原文链接][Link 1]

*摘要：* 　　一、ApplicationContext的xml解析工作是通过ClassPathXmlApplicationContext来实现的，其实看过ClassPathXmlApplicationContext的xml源码解析过程的其实都应该知道，xml的解析过程基本上就是用原来的XmlBeanFactory的解析过程完成的。

一、ApplicationContext的xml解析工作是通过ClassPathXmlApplicationContext来实现的，其实看过ClassPathXmlApplicationContext的xml源码解析过程的其实都应该知道，xml的解析过程基本上就是用原来的XmlBeanFactory的解析过程完成的。

二、为什么要拿出来单独说一下呢，其目的就是，了解怎么用同样的方式来实现xml解析过程。

三、xml解析过程是通过**refresh**下的**obtainFreshBeanFactory**函数实现，所以这里重点讲解**obtainFreshBeanFactory**的实现过程。

四、xml源码解析：**obtainFreshBeanFactory**

**　　**1）开端

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
            //解析过程
            this.refreshBeanFactory();
            //这里的beanFactory就是DefaultListableBeanFactory（后续会讲到）
            ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Bean factory for " + this.getDisplayName() + ": " + beanFactory);
            }
            return beanFactory;
        }

2）**refreshBeanFactory**

protected final void refreshBeanFactory() throws BeansException {
            if (this.hasBeanFactory()) {
                this.destroyBeans();
                this.closeBeanFactory();
            }
    
            try {
                //是不是很熟悉，这里也是通过DefaultListableBeanFactory的方式来实现的
                DefaultListableBeanFactory beanFactory = this.createBeanFactory();
                beanFactory.setSerializationId(this.getId());
                //自定义beanFactory，处理循环依赖
                //主要作用设置@Autowired和@Qualifier解析器QualifierAnnotationAutowireCandidateResolver
                this.customizeBeanFactory(beanFactory);
                //xml解析过程
                this.loadBeanDefinitions(beanFactory);
                Object var2 = this.beanFactoryMonitor;
                synchronized(this.beanFactoryMonitor) {
                    this.beanFactory = beanFactory;
                }
            } catch (IOException var4) {
                throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var4);
            }
        }

a、DefaultListableBeanFactory继承关系

![img_c041d06e4b7e8af550706a46c5a74d7e.png][]

这里其实就可以看出**ConfigurableListableBeanFactory**就是这里的**DefaultListableBeanFactory**

b、**customizeBeanFactory**（这里不详细介绍注解的解析过程）

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
            if (this.allowBeanDefinitionOverriding != null) {
                beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding.booleanValue());
            }
    
            if (this.allowCircularReferences != null) {
                beanFactory.setAllowCircularReferences(this.allowCircularReferences.booleanValue());
            }
    
            beanFactory.setParameterNameDiscoverer(new LocalVariableTableParameterNameDiscoverer());
            beanFactory.setAutowireCandidateResolver(new QualifierAnnotationAutowireCandidateResolver());
        }

c、**loadBeanDefinitions**

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
            //是不是又很熟悉，还是基于XmlBeanDefinitionReader来进行解析了
            XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
            beanDefinitionReader.setResourceLoader(this);
            beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
            //解析xml
            this.initBeanDefinitionReader(beanDefinitionReader);
            this.loadBeanDefinitions(beanDefinitionReader);
        }

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
            Resource[] configResources = this.getConfigResources();
            if (configResources != null) {
                reader.loadBeanDefinitions(configResources);
            }
            //这里是配置方式不一样，我们是通过configLocations进行配置
            String[] configLocations = this.getConfigLocations();
            if (configLocations != null) {
                //解析文件
                reader.loadBeanDefinitions(configLocations);
            }
    
        }

public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
            Assert.notNull(locations, "Location array must not be null");
            int counter = 0;
            String[] var6 = locations;
            int var5 = locations.length;
    
            for(int var4 = 0; var4 < var5; ++var4) {
                String location = var6[var4];
    　　　　　　　//主要目的计数
                counter += this.loadBeanDefinitions(location);
            }
    
            return counter;
        }

public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
            return this.loadBeanDefinitions(location, (Set)null);
        }
    
        public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
            ResourceLoader resourceLoader = this.getResourceLoader();
            if (resourceLoader == null) {
                throw new BeanDefinitionStoreException("Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
            } else {
                int loadCount;
                if (!(resourceLoader instanceof ResourcePatternResolver)) {
                    Resource resource = resourceLoader.getResource(location);
                    loadCount = this.loadBeanDefinitions((Resource)resource);
                    if (actualResources != null) {
                        actualResources.add(resource);
                    }
    
                    if (this.logger.isDebugEnabled()) {
                        this.logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
                    }
    
                    return loadCount;
                } else {
                    try {
                        Resource[] resources = ((ResourcePatternResolver)resourceLoader).getResources(location);
                        //包装成Resource，进行解析
                        loadCount = this.loadBeanDefinitions(resources);
                        if (actualResources != null) {
                            Resource[] var9 = resources;
                            int var8 = resources.length;
    
                            for(int var7 = 0; var7 < var8; ++var7) {
                                Resource resource = var9[var7];
                                actualResources.add(resource);
                            }
                        }
    
                        if (this.logger.isDebugEnabled()) {
                            this.logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
                        }
    
                        return loadCount;
                    } catch (IOException var10) {
                        throw new BeanDefinitionStoreException("Could not resolve bean definition resource pattern [" + location + "]", var10);
                    }
                }
            }
        }

public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
            Assert.notNull(resources, "Resource array must not be null");
            int counter = 0;
            Resource[] var6 = resources;
            int var5 = resources.length;
    
            for(int var4 = 0; var4 < var5; ++var4) {
                Resource resource = var6[var4];
                //单独解析没一个resource
                counter += this.loadBeanDefinitions((Resource)resource);
            }
    
            return counter;
        }

d、**loadBeanDefinitions（这里是不是很熟悉，这里的解析过程就是XmlBeanFactory里面的xml的核心解析过程）**

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
            return this.loadBeanDefinitions(new EncodedResource(resource));
        }
    
        public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
            Assert.notNull(encodedResource, "EncodedResource must not be null");
            if (this.logger.isInfoEnabled()) {
                this.logger.info("Loading XML bean definitions from " + encodedResource.getResource());
            }
    
            Set<EncodedResource> currentResources = (Set)this.resourcesCurrentlyBeingLoaded.get();
            if (currentResources == null) {
                currentResources = new HashSet(4);
                this.resourcesCurrentlyBeingLoaded.set(currentResources);
            }
    
            if (!((Set)currentResources).add(encodedResource)) {
                throw new BeanDefinitionStoreException("Detected cyclic loading of " + encodedResource + " - check your import definitions!");
            } else {
                int var6;
                try {
                    InputStream inputStream = encodedResource.getResource().getInputStream();
    
                    try {
                        InputSource inputSource = new InputSource(inputStream);
                        if (encodedResource.getEncoding() != null) {
                            inputSource.setEncoding(encodedResource.getEncoding());
                        }
    
                        var6 = this.doLoadBeanDefinitions(inputSource, encodedResource.getResource());
                    } finally {
                        inputStream.close();
                    }
                } catch (IOException var15) {
                    throw new BeanDefinitionStoreException("IOException parsing XML document from " + encodedResource.getResource(), var15);
                } finally {
                    ((Set)currentResources).remove(encodedResource);
                    if (((Set)currentResources).isEmpty()) {
                        this.resourcesCurrentlyBeingLoaded.remove();
                    }
    
                }
    
                return var6;
            }
        }

e、剩下的部分参考：[https://www.cnblogs.com/ll409546297/p/9451784.html][https_www.cnblogs.com_ll409546297_p_9451784.html]的源码解析部分第4）点

五、分析一下流程

1）通过**ClassPathXmlApplicationContext**来进行xml的解析工作

2）首先进行赋值到**configLocations**的属性上面

3）xml解析过程还是通过**XmlBeanDefinitionReader**来实现解析

4）xml解析不同的地方：

a、新增解析增加计数

b、返回类型使用接口**ConfigurableListableBeanFactory**

**　　**c、增加string的配置方式，代码编写感觉更好。

d、解析之前和之后，都做了很多其他工作。相比之下拓展了很多其他功能。

[Link 1]: http://click.aliyun.com/m/1000013194/
[img_c041d06e4b7e8af550706a46c5a74d7e.png]: /images/20220516/5bf20f848c5547d7b87b9eccd1f11c73.png
[https_www.cnblogs.com_ll409546297_p_9451784.html]: https://www.cnblogs.com/ll409546297/p/9451784.html