XmlWebApplicationContext加载bean XML源码解析

    XmlWebApplicationContext是我们开发中用到的最多的ApplicationContext实现，我对其源代码详细的分析，以便以后复习的时候可以参考。

public   class  XmlWebApplicationContext  extends  AbstractRefreshableWebApplicationContext {
     /**  Default config location for the root context  */
     public   static   final  String DEFAULT_CONFIG_LOCATION  =   " /WEB-INF/applicationContext.xml " ;
     /**  Default prefix for building a config location for a namespace  */
     public   static   final  String DEFAULT_CONFIG_LOCATION_PREFIX  =   " /WEB-INF/ " ;
     /**  Default suffix for building a config location for a namespace  */
     public   static   final  String DEFAULT_CONFIG_LOCATION_SUFFIX  =   " .xml " ;

     protected   void  loadBeanDefinitions(DefaultListableBeanFactory beanFactory)  throws  IOException {
         //  创建BeanDefinitionReader，从XML中读取bean信息的读取器
        XmlBeanDefinitionReader beanDefinitionReader  =   new  XmlBeanDefinitionReader(beanFactory);
        beanDefinitionReader.setResourceLoader( this );
        beanDefinitionReader.setEntityResolver( new  ResourceEntityResolver( this ));

        initBeanDefinitionReader(beanDefinitionReader);
        loadBeanDefinitions(beanDefinitionReader);
    }

     protected   void  initBeanDefinitionReader(XmlBeanDefinitionReader beanDefinitionReader) {
    }

     protected   void  loadBeanDefinitions(XmlBeanDefinitionReader reader)  throws  BeansException, IOException {
        String[] configLocations  =  getConfigLocations();
         if  (configLocations  !=   null ) {
             for  ( int  i  =   0 ; i  <  configLocations.length; i ++ ) {
                reader.loadBeanDefinitions(configLocations[i]);
            }
        }
    }

     protected  String[] getDefaultConfigLocations() {
         if  (getNamespace()  !=   null ) {
             return   new  String[] {DEFAULT_CONFIG_LOCATION_PREFIX  +  getNamespace()  +                              DEFAULT_CONFIG_LOCATION_SUFFIX};
        }
         else  {
             return   new  String[] {DEFAULT_CONFIG_LOCATION};
        }
    }

}

 loadBeanDefinitions(String location)方法是在AbstractBeanDefinitionReader中实现的：

     public   int  loadBeanDefinitions(String location)  throws  BeanDefinitionStoreException {
        ResourceLoader resourceLoader  =  getResourceLoader();
         if  (resourceLoader  ==   null ) {
             throw   new  BeanDefinitionStoreException(
                     " Cannot import bean definitions from location [ "   +  location  +   " ]: no ResourceLoader available " );
        }

         if  (resourceLoader  instanceof  ResourcePatternResolver) {
             //  Resource pattern matching available.
             try  {
                Resource[] resources  =  ((ResourcePatternResolver) resourceLoader).getResources(location);
                 int  loadCount  =  loadBeanDefinitions(resources);
                 if  (logger.isDebugEnabled()) {
                    logger.debug( " Loaded  "   +  loadCount  +   "  bean definitions from location pattern [ "   +  location  +   " ] " );
                }
                 return  loadCount;
            }
             catch  (IOException ex) {
                 throw   new  BeanDefinitionStoreException(
                         " Could not resolve bean definition resource pattern [ "   +  location  +   " ] " , ex);
            }
        }
         else  {
             // 根据给定的路径获得Resource.
            Resource resource  =  resourceLoader.getResource(location);

            //根据XML文件的bean信息加载bean属性
             int  loadCount  =  loadBeanDefinitions(resource);
             if  (logger.isDebugEnabled()) {
                logger.debug( " Loaded  "   +  loadCount  +   "  bean definitions from location [ "   +  location  +   " ] " );
            }
             return  loadCount;
        }
    }

这儿，public int loadBeanDefinitions(Resource resource)方法是在其子类XmlBeanDefinitionReader中实现的：

    

        //把XML中bean的配置信息注册到BeanDefinition中去
        documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
         return  getBeanFactory().getBeanDefinitionCount()  -  countBefore;
    }

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());
        }

         try  {
             // 过的XML配置文件的输入流
            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);
        }
    }

     protected   int  doLoadBeanDefinitions(InputSource inputSource, Resource resource)
             throws  BeanDefinitionStoreException {
         try  {
             int  validationMode  =  getValidationModeForResource(resource);
            Document doc  =   this .documentLoader.loadDocument(
                    inputSource,  this .entityResolver,  this .errorHandler, validationMode,  this .namespaceAware);
             return  registerBeanDefinitions(doc, resource);
        }
         catch  (BeanDefinitionStoreException ex) {
             throw  ex;
        }
         catch  (ParserConfigurationException ex) {
             throw   new  BeanDefinitionStoreException(
                     " Parser configuration exception parsing XML from  "   +  resource, ex);
        }
         catch  (SAXParseException ex) {
             throw   new  BeanDefinitionStoreException(
                     " Line  "   +  ex.getLineNumber()  +   "  in XML document from  "   +  resource  +   "  is invalid " , ex);
        }
         catch  (SAXException ex) {
             throw   new  BeanDefinitionStoreException( " XML document from  "   +  resource  +   "  is invalid " , ex);
        }
         catch  (IOException ex) {
             throw   new  BeanDefinitionStoreException( " IOException parsing XML document from  "   +  resource, ex);
        }
         catch  (Throwable ex) {
             throw   new  BeanDefinitionStoreException( " Unexpected exception parsing XML document from  "   +  resource, ex);
        }
    }

     public   int  registerBeanDefinitions(Document doc, Resource resource)  throws  BeanDefinitionStoreException {
         //使用 XmlBeanDefinitionParser读取配置文件，但是现在已经反对使用此类
         if  ( this .parserClass  !=   null ) {
            XmlBeanDefinitionParser parser  =
                    (XmlBeanDefinitionParser) BeanUtils.instantiateClass( this .parserClass);
             return  parser.registerBeanDefinitions( this , doc, resource);
        }
         //Spring2.0以后都用BeanDefinitionDocumentReader来读取
        BeanDefinitionDocumentReader documentReader  =  createBeanDefinitionDocumentReader();
         int  countBefore  =  getBeanFactory().getBeanDefinitionCount();

BeanDefinitionDocumentReader有一个默认的实现类DefaultBeanDefinitionDocumentReader：

     public   void  registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
         this .readerContext  =  readerContext;

        logger.debug( " Loading bean definitions " );
        Element root  =  doc.getDocumentElement();

        BeanDefinitionParserDelegate delegate  =  createHelper(readerContext, root);

        preProcessXml(root);
        parseBeanDefinitions(root, delegate);
        postProcessXml(root);
    }

    //从根节点开始读取bean配置信息，并把属性一一复制到BeanDefinition中去
     protected   void  parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
         if  (delegate.isDefaultNamespace(root.getNamespaceURI())) {
            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;
                    String namespaceUri  =  ele.getNamespaceURI();
                     if  (delegate.isDefaultNamespace(namespaceUri)) {
                        parseDefaultElement(ele, delegate);
                    }
                     else  {
                        delegate.parseCustomElement(ele);
                    }
                }
            }
        }
         else  {
            delegate.parseCustomElement(root);
        }
    }