菜鸟的spring 3.0源码学习之旅（5）

今天天气大范围降温，或许对于南方还是阳春三月的气候，但是对于我们这里，就将要进入千里冰封万里雪飘的季节了，不仅如此，我柔弱的手机也禁不住这大范围的降温也因此进入了休眠状态

不过阵阵的寒意毅然挡不住我学习的热情，我下定决心，在我变身成为冰雕之前，一定要先把spring的源码搞懂，因为吧spring都搞懂了，春天还远吗

不瞎扯了，言归正传吧

昨天呢，我们讲述了XmlBeanFactory的字段实例化所发生的动作，那么今天呢，我们主要是讨论一下构造器里发生的一切,

首先，我们再看一下这个构造器

public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {

              super(parentBeanFactory);

              this.reader.loadBeanDefinitions(resource);  //加载BeanDefinitions信息

}

在这个构造器里，第一句的意思是说，吧parentBeanFactory交给父类的构造器来处理，

public AbstractAutowireCapableBeanFactory() {

              super();

              ignoreDependencyInterface(BeanNameAware.class);

              ignoreDependencyInterface(BeanFactoryAware.class);

              ignoreDependencyInterface(BeanClassLoaderAware.class);

       }

       public AbstractAutowireCapableBeanFactory(BeanFactory parentBeanFactory) {

              this();

              setParentBeanFactory(parentBeanFactory);

       }

在这个构造器里，我们可以看到，构造器里实际上做了两个工作，一个是调用ignoreDependencyInterface,一个是调用了其父类的setParentBeanFactory,第一个工作实际上是往private final Set<Class> ignoredDependencyInterfaces = new HashSet<Class>();这个字段里设置添加参数，第二个呢，是吧这个入参设置到父类的私有字段里

不过呢，当这个类在实例化的同时，这个静态代码会先获得执行

private static Class javaxInjectProviderClass = null;

static {

              ClassLoader cl = DefaultListableBeanFactory.class.getClassLoader();

              try {

                     javaxInjectProviderClass = cl.loadClass("javax.inject.Provider");

              }

              catch (ClassNotFoundException ex) {

              }

       }

这个是为该字段动态的添加类实例信息，这个我到目前还没有发现有什么有用的地方，所以咱们暂时先忽略这个地方

XmlBeanFactory构造器里第一行代码就执行完了，那么我们就开始研究第二行代码吧

this.reader.loadBeanDefinitions(resource);

这个呢，是XmlBeanFactory的字段调用了loadBeanDefinition方法，那么，我们就欣赏一下这个方法的实现吧

org.springframework.beans.factory.xml.XmlBeanDefinitionReader#loadBeanDefinitions

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {

              return loadBeanDefinitions(new EncodedResource(resource));

       }

这个方法的主要作用是吧Resource封装成EncodedResource类，这个EncodedResource类呢，有两个字段，一个是字符串类型的编码格式字段，另一个是Resource信息，这样大家应该就了解的差不多了吧，所以也不再赘述，我们然后再往下看

org.springframework.beans.factory.xml.XmlBeanDefinitionReader#loadBeanDefinitions

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

              }

 

              Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();

              if (currentResources == null) {  //如果变量为null,则实例化，并添加到本地线程中

                     currentResources = new HashSet<EncodedResource>(4);

                     this.resourcesCurrentlyBeingLoaded.set(currentResources);

              }

              if (!currentResources.add(encodedResource)) {   //如果currentResources包含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());

                            }

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

                     }

              }

       }

这个方法貌似比较复杂，不过我们别着急，看我耐着心给大家分析

Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();

              if (currentResources == null) {  //如果变量为null,则实例化，并添加到本地线程中

                     currentResources = new HashSet<EncodedResource>(4);

                     this.resourcesCurrentlyBeingLoaded.set(currentResources);

              }

              if (!currentResources.add(encodedResource)) {   //如果currentResources包含encodedResource，则抛出异常

                     throw new BeanDefinitionStoreException(

                                   "Detected cyclic loading of " + encodedResource + " - check your import definitions!");

              }

这个主要是往字段中添加资源，这个字段是用本地线程包装的，我们来看这个字段

private final ThreadLocal<Set<EncodedResource>> resourcesCurrentlyBeingLoaded =

                     new NamedThreadLocal<Set<EncodedResource>>("XML bean definition resources currently being loaded");

然后我让大家看下面的这个语句段

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

                     }

InputSource是对要解析的XML文件的一个抽象，资源返回输出流，然后由InputSource实例化，如果资源的编码方式不为null，则设置其格式，然后将会执行doLoadBeanDefinitions方法

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)

                     throws BeanDefinitionStoreException {

              try {

                     int validationMode = getValidationModeForResource(resource);  //XSD

                     Document doc = this.documentLoader.loadDocument(

                                   inputSource, getEntityResolver(), this.errorHandler, validationMode, isNamespaceAware()); 

                     return registerBeanDefinitions(doc, resource);

              }

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

              }

       }

这个是本类的doLoadBeanDefinitions方法，在这个方法里，主要是吧InputSource还有资源文件解析成Document，我想这个大家应该一目了然，也不需要多说，

int validationMode = getValidationModeForResource(resource);

在此方法中的这个字段是为了获得validationMode的值，在这里，此值默认为xsd,

getEntityResolver()此方法是为了实例化EntityResolver，

不过，在这个方法里，真正的重点是这个

Document doc = this.documentLoader.loadDocument(

                                   inputSource, getEntityResolver(), this.errorHandler, validationMode, isNamespaceAware()); 

这个字段正是此方法的核心所在，那么我们看看loadDocument方法都进行了什么处理了

public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,

                     ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {

 

              DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);//实例化此类，并且把验证方式设为dtd验证，支持名称空间

              if (logger.isDebugEnabled()) {

                     logger.debug("Using JAXP provider [" + factory.getClass().getName() + "]");

              }

              DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);   //实例化该类，并且指定使用 EntityResolver 解析要解析的 XML 文档中存在的实体，使用指定解析器要使用的 ErrorHandler

              return builder.parse(inputSource);

       }

大家看了这个方法，我想都明白了吧，我也就不多说什么了，接着继续

当执行完doLoadBeanDefinitions以后，紧接着就要执行registerBeanDefinitions方法了

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {

              BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();  //实例化BeanDefinitionDocumentReader

              int countBefore = getRegistry().getBeanDefinitionCount();

              documentReader.registerBeanDefinitions(doc, createReaderContext(resource));

              return getRegistry().getBeanDefinitionCount() - countBefore;

       }

在这个方法里，将完成对Document的解析的工作,而这个方法的核心是这个字段

documentReader.registerBeanDefinitions(doc, createReaderContext(resource));

那么我们就主要看一下registerBeanDefinition方法吧

org.springframework.beans.factory.xml. DefaultBeanDefinitionDocumentReader#registerBeanDefinitions

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {

              this.readerContext = readerContext;

 

              logger.debug("Loading bean definitions");

              Element root = doc.getDocumentElement();   //获得根元素

 

              BeanDefinitionParserDelegate delegate = createHelper(readerContext, root);   //初始化bean中的信息

 

              preProcessXml(root);   //空方法

              parseBeanDefinitions(root, delegate);

              postProcessXml(root);

       }

那么我们看看createHelper方法都定义了什么吧

protected BeanDefinitionParserDelegate createHelper(XmlReaderContext readerContext, Element root) {

              BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext);

              delegate.initDefaults(root);  //初始化bean中的属性

              return delegate;

       }

在这个方法里，它的核心是这个字段

delegate.initDefaults(root);

那么我们再看看initDefaults方法吧

public void initDefaults(Element root) {

              populateDefaults(this.defaults, root);

              this.readerContext.fireDefaultsRegistered(this.defaults);   //尚不清楚作用

       }

下面的这个方法主要对资源中的各个属性取出，设置到DocumentDefaultsDefinition中，      

protected void populateDefaults(DocumentDefaultsDefinition defaults, Element root) {

              defaults.setLazyInit(root.getAttribute(DEFAULT_LAZY_INIT_ATTRIBUTE));

              defaults.setMerge(root.getAttribute(DEFAULT_MERGE_ATTRIBUTE));

              defaults.setAutowire(root.getAttribute(DEFAULT_AUTOWIRE_ATTRIBUTE));

              defaults.setDependencyCheck(root.getAttribute(DEFAULT_DEPENDENCY_CHECK_ATTRIBUTE));

              if (root.hasAttribute(DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE)) {

                     defaults.setAutowireCandidates(root.getAttribute(DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE));

              }

              if (root.hasAttribute(DEFAULT_INIT_METHOD_ATTRIBUTE)) {

                     defaults.setInitMethod(root.getAttribute(DEFAULT_INIT_METHOD_ATTRIBUTE));

              }

              if (root.hasAttribute(DEFAULT_DESTROY_METHOD_ATTRIBUTE)) {

                     defaults.setDestroyMethod(root.getAttribute(DEFAULT_DESTROY_METHOD_ATTRIBUTE));

              }

              defaults.setSource(this.readerContext.extractSource(root));    //尚不清楚作用

       }

好了，讲到这里，我就把XmlBeanFactory的实例化过程大体上给梳理了一遍，本人愚笨，用了两天的时间才把其中的缘由搞明白，我想大家都比我聪明，所以还应多请教为是