BeanDefinition的定位，载入和注册

第一章 SpringFramework的核心：IOC容器的实现

 

1. 总览

   我们知道，IOC容器的工厂化管理实现了控制反转，将Bean的依赖的关系从对象本身解耦，将控制权交由外部工厂进行处理。从而使代码更加灵活，所以IOC容器的实现至关重要。IOC容器实际上是将BeanDefinition处理封装成Spring内部的Bean规则的数据结构。其过程可以分成资源的定位，解析，注册。refresh()是Spring中比较核心的方法，Spring所有的初始化都在这个方法中完成。

1. public void refresh() throws BeansException, IllegalStateException {  

2.         synchronized (this.startupShutdownMonitor) {  

3.             //准备启动spring容器，设置容器的启动日期和活动标志  

4.             prepareRefresh();  

5.   

6.             ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();//获得容器ApplicationContext的子类BeanFactory。步骤如下：如果已经有了BeanFactory就销毁它里面的单例Bean并关闭这个BeanFactory。2.创建一个新的BeanFactory。3.对这个BeanFactory进行定制（customize),如allowBeanDefinitionOverriding，allowCircularReferences。4.装载BeanDefinitions(读取配置文件，将xml转换成对应得BeanDefinition)。5.检查是否同时启动了两个BeanFactory。    

7.   

8.             // 通过XmlBeanDefinitionReader加载bean定义.  

9.             prepareBeanFactory(beanFactory);  

10.   

11.             try {  

12.                 // Allows post-processing of the bean factory in context subclasses.  

13.                 postProcessBeanFactory(beanFactory);  

14.   

15.                 // Invoke factory processors registered as beans in the context.  

16.                 invokeBeanFactoryPostProcessors(beanFactory);  

17.   

18.                 // 注册 bean processors   

19.                 registerBeanPostProcessors(beanFactory);  

20.   

21.                 // Initialize message source for this context.  

22.                 initMessageSource();  

23.   

24.                 // Initialize event multicaster for this context.  

25.                 initApplicationEventMulticaster();  

26.   

27.                 // Initialize other special beans in specific context subclasses.  

28.                 onRefresh();  

29.   

30.                 // Check for listener beans and register them.  

31.                 registerListeners();  

32.   

33.                 // Instantiate all remaining (non-lazy-init) singletons.  

34.                 finishBeanFactoryInitialization(beanFactory);  

35.   

36.                 // Last step: publish corresponding event.  

37.                 finishRefresh();  

38.             }  

39.   

40.             catch (BeansException ex) {  

41.                 // Destroy already created singletons to avoid dangling resources.  

42.                 destroyBeans();  

43.   

44.                 // Reset 'active' flag.  

45.                 cancelRefresh(ex);  

46.   

47.                 // Propagate exception to caller.  

48.                 throw ex;  

49.             }  

50.         }  

51.     }  

 

 

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); 
此方法比较关键，代码也比较多 

Java代码  

1. protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {  

2.         refreshBeanFactory();  

3.         ConfigurableListableBeanFactory beanFactory = getBeanFactory();  

4.         if (logger.isDebugEnabled()) {  

5.             logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);  

6.         }  

7.         return beanFactory;  

8.     }  

refreshBeanFactory(); 

Java代码  

1. @Override  

2.     protected final void refreshBeanFactory() throws BeansException {  

3.         if (hasBeanFactory()) {  

4.             destroyBeans();  

5.             closeBeanFactory();  

6.         }  

7.         try {  

8.             DefaultListableBeanFactory beanFactory = createBeanFactory();  

9.             beanFactory.setSerializationId(getId());  

10.             customizeBeanFactory(beanFactory);  

11.             loadBeanDefinitions(beanFactory);  

12.             synchronized (this.beanFactoryMonitor) {  

13.                 this.beanFactory = beanFactory;  

14.             }  

15.         }  

16.         catch (IOException ex) {  

17.             throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);  

18.         }  

19.     }  

loadBeanDefinitions(beanFactory); 

Java代码  

1. @Override  

2.     protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {  

3.         // Create a new XmlBeanDefinitionReader for the given BeanFactory.  

4.         XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);  

5.   

6.         // Configure the bean definition reader with this context's  

7.         // resource loading environment.  

8.         beanDefinitionReader.setEnvironment(this.getEnvironment());  

9.         beanDefinitionReader.setResourceLoader(this);  

10.         beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));  

11.   

12.         // Allow a subclass to provide custom initialization of the reader,  

13.         // then proceed with actually loading the bean definitions.  

14.         initBeanDefinitionReader(beanDefinitionReader);  

15.         loadBeanDefinitions(beanDefinitionReader);  

16.     }  

loadBeanDefinitions(beanDefinitionReader);装载xml文件到XmlBeanDefinitionReader的过程 

Java代码  

1. protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {  

2.         Resource[] configResources = getConfigResources();  

3.         if (configResources != null) {  

4.             reader.loadBeanDefinitions(configResources);  

5.         }  

6.         String[] configLocations = getConfigLocations();  

7.         if (configLocations != null) {  

8.             reader.loadBeanDefinitions(configLocations);  

9.         }  

10.     }  

 

 

IOC的初始化过程可以分为定位，解析和注册三个方面。下面我将解释这三个方面：

（1）定位：Resource接口对各种形式的BeanDefinition的使用提供了统一接口。BeanDefinition是对Bean定义信息的抽象。（对此处的抽象进行解释：计算机的数据是对现实数据的抽象，将现实事物所具有的属性和行为进行描述，将其描述为计算机可以识别的编码信息。而BeanDefinition也是对Bean的抽象，它将Bean的各个信息抽象成一个数据类型，当然BeanDefintion定义的方式有很多，Spring中主要是以XML的形式进行定义BeanDefinition。这个BeanDefinition对这个Bean的一些属性进行了解析，例如其className等等）。

（2）载入：将Bean表示成IOC容器内部的数据结构。BeanDefinition是POJO对象在IOC容器中的抽象。通过BeanDefinition定义的数据结构，使IOC容器能够方便地对POJO对象也就是Bean进行管理。

（3）
注册：把解析得到的BeanDefinition向IOC容器中进行注册，将BeanDefintion注入到一个HashMap中去。

2.BeanDefinition的定位：

①首先定义一个Resource来定义容器使用的BeanDefinition，BeanDefinition的获取是从传入的xml文件中获取的。

②Resource资源不能直接交给BeanFactory使用，需要BeanDefinition的loadBeanDefinitions()方法进行处理。

③ApplicationContext是相对BeanFactory的高级IOC容器。它将BeanFactory对Resource资源的定位，载入，注册进行了封装，但是降低了IOC容器的灵活性。

 

关于Resource的定位，方式有很多。下面我们以FileSystemXmlApplicationContext进行举例。它具备了ResourceLoader读入Resource定义的BeanDefinition的能力。之前我们说过，整个IOC容器的实现都是调用了refresh（）方法。其中refreshBeanFactory（）方法被调用,在这个方法中，通过createBeanFactory()方法构建了一个IOC容器供ApplicationContext使用，这个容器就是DefaultListableBeanFactory，同时，它启动了loadBeanDefinitions来载入BeanDefinition。.关于具体的代码实现可以参考书33页的代码清单2-5，以上就是BeanDefinition的定位过程，我们在获取了Resource对象之后，就可以对BeanDefinition的载入创造IO操作的准备了

3.BeanDefinition的载入和解析

载入：整个载入过程，相当于把定义的BeanDefinition在IOC容器中转化成一个Spring内部表示的数据结构的过程。载入IOC容器对Bean的管理和依赖注入功能的实现，是通过对其持有的BeanDefinition进行各种相关操作来完成的。

在创建IOC容器之前，如果之前已经有容器存在，那么需要把已经存在的容器进行销毁和关闭，保证refresh之后建立起来的都是新建立的IOC容器。下图为BeanDefinition的载入交互过程所调用的方法。

 

 

 

 

在loadBeanDefinitions中，初始化了读取器XmlBeanDefinitionReader，然后把这个读取器在IOC容器中设置好，最后是启动读取器来完成BeanDefinition在IOC容器中的载入。

 

 

 

接下来就是loadBeanDefinitions(XmlBeanDefinitionReader reader)的实现方法。

 

 

 

在这个方法调用了reader.loadBeanDefinitions(Resource[] resources)方法

 

 

 

 

之前我们说过，Resource对象封装了对XML文件的I/O操作，所以读取器可以在打开I/O流后得到XML的文件对象，之后就可以按照Spring的Bean定义规则对这个XML文档树进行解析了。这个解析是交给BeanDefinitionParserDelegate来完成。

 

 

 

 

 

 

 

 

 

Spring的BeanDefinition是怎样按照Spring的Bean语意要求进行解析并转化为容器的内部数据结构的，这个过程是在registerBeanDefinition(doc,resource)中完成的。

Bean的载入分成两个部分，首先调用了XML的解析器得到document对象。之后通过documentReader这个方法将其按照Spring的Bean规则进行解析。对BeanDefinition的处理结果由BeanDefinitionHolder对象进行持有，这个对象除了持有BeanDefinition对象之外，还持有其他与BeanDefinition的使用相关的信息。比如Bean的名字，别名集合等。

对Bean元素进行解析的过程，也就是BeanDefinition依据XML的<bean>定义被创建的过程。这个Bean可以看成是对<bean>定义的抽象。

4. BeanDefinition在IOC容器中的注册。

我们知道，经过载入和解析之后，BeanDefinition已经在IOC容器中建立起了自己的数据结构以及相关的数据表示。但这些数据还不能供IOC容器使用，还需要进行注册。在IOC容器中，是通过一个HashMap来持有所有的载入的BeanDifinition的。

 

 

 

 

注册的过程并不复杂，就是把解析得到的BeanDefinition设置到hashMap中。