spring源码之容器加载XmlBeanFactory实现过程

最新推荐文章于 2024-04-03 11:03:23 发布

凌尘若水

最新推荐文章于 2024-04-03 11:03:23 发布

阅读量175

点赞数

分类专栏： spring源码

本文链接：https://blog.csdn.net/lcrs_vgpal/article/details/83247527

版权

spring源码专栏收录该内容

1 篇文章 0 订阅

订阅专栏

xml配置文件的读取是spring中重要的功能，而xml加载则是通过下边代码实现的：

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

在spring中，通过ClassPathResource的构造函数来构造Resource资源文件的实例对象，有了Resource后就可以进行XmlBeanFactory的初始化了。而Resource资源又是如何加载的？

通过上面的代码我们可以看到是通过XmlBeanFactory来实现的，那XmlBeanFactory又是如何具体实现的呢？阅读过源码，我们就会发现是在XmlBeanFactory构造函数中调用了XmlBeandefinitionReader类型的reader属性提供的方法this.reader.loadBeanDefinitions(resource)，这句代码则是整个资源加载的切入点。

先看下这个方法的时序图：

根据时序图我们来看下这里究竟在做什么。

处理过程如下：

（1）封装资源文件当进入XMLBeanDefinitionReader 后首先对参数Resource 使用EncodeResource类封装

（2）获取输入流。从Resource中获取对应的inputStream并构造InputSource

（3）通过构造InputSource实例和Resource实例继续调用函数doLoadBeanDefinitions。

loadBeanDefinitions函数的具体实现过程如下：

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
return loadBeanDefinitions(new EncodedResource(resource));
}

EncodedResource的主要作用是对资源文件的编码进行处理，其主要逻辑在getReader() 方法中，当设置了编码属性的时候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);
       }
       else {
           return new InputStreamReader(this.resource.getInputStream());
       }
   }

上面的代码构造了一个有编码(encode)的InputStreamReader。当构造好encodedResource对象后，再次传入了可服用的方法，loadBeanDefinitions(new EncodedResource(resource))。

这个内部方法才是真正的数据准备阶段，也是时序图索描述的逻辑：

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
       Assert.notNull(encodedResource, "EncodedResource must not be null");
       if (logger.isTraceEnabled()) {
           logger.trace("Loading XML bean definitions from " + encodedResource);
       }
       //通过属性来记录已经加载的资源
       Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
       if (currentResources == null) {
           currentResources = new HashSet<>(4);
           this.resourcesCurrentlyBeingLoaded.set(currentResources);
       }
       if (!currentResources.add(encodedResource)) {
           throw new BeanDefinitionStoreException(
                   "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
       }
       try {
           //从inputResource中获取已经封装的Resource对象并在此从Resource中获取其中的inputStream
           InputStream inputStream = encodedResource.getResource().getInputStream();
           try {
               InputSource inputSource = new InputSource(inputStream);
               if (encodedResource.getEncoding() != null) {
                   inputSource.setEncoding(encodedResource.getEncoding());
               }
               //真正进入的核心部分
               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();
           }
       }
   }

再次梳理下数据真被阶段的逻辑，首先对传入的Resource 参数做封装，目的是考虑到Resource可能存在的编码要求，其次通过SAX读取xml文件的方式来准备InputSource对象，最后将准备的数据通过参数传入真正的核心处理部分doLoadBeanDefinitions(inputSource, encodedResource.getResource())。

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

       try {
           Document doc = doLoadDocument(inputSource, resource);
           int count = registerBeanDefinitions(doc, resource);
           if (logger.isDebugEnabled()) {
               logger.debug("Loaded " + count + " bean definitions from " + resource);
           }
           return count;
       }
       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);
       }
   }