2019獨角獸企業重金招聘Python工程師標準>>>

一、什么是Ioc/DI？

IOC容器：主要是完成了 完成對象的創建和依賴的管理注入等。

先從我們自己設計這樣一個視角來考慮：

所謂控制反轉，就是把原先我們代碼里面需要實現的 對象創建、依賴的代碼，反轉給容器來幫忙實現。那么必然的1.我們需要創建一個容器，2.同時需要一種描述來讓容器知道需要創建的對象與對象的關系。這個描述最具體表現就是我們可配置的文件。

對象和對象關系怎么表示？

可以用xml、properties文件等語義化配置文件表示。

描述對象關系的文件存放在哪里？

可能是 classpath，fileSystem，或者是url網絡資源，servletContext等。

對配置文件的解析

不同的配置文件對對象的描述不一樣，如標準的，自定義聲明式的，如何統一？在內部需要有一個統一的關于對象的定義，所有外部的描述都必須轉化成為統一的描述定義。

如何對不同的配置文件進行解析？需要對不同的配置文件語法，采用不同的解析器。

Spring IOC 體系結構

Spring Bean的創建是典型的工廠模式，這一系列的Bean工廠，也既IOC容器為開發者管理對象間的依賴關系提供了很多便利和基礎服務，在Spring中有許多的IOC容器的實現供用戶選擇和使用，其相互關系如下：

其中Beanfactory作為最頂層的一個接口類，定義了IOC容器的基本功能規范，BeanFactory有三個子類：

• Listable BeanFactory：這些Bean是可列表的
• Hierarchical BeanFactory：這些Bean是有繼承關系的，
• AutowireCapable BeanFactory：定義Bean的自動裝配規則。 這三個接口共同定義了 Bean的集合、Bean之間的關系、以及Bean行為。

從上圖可發現最終的默認實現類是DefaultListableBeanFactory，他實現類所有的接口。

查看最基本的BeanFactory

public interface BeanFactory { //對FactoryBean的轉義定義，因為如果使用bean的名字檢索FactoryBean得到的對象是工廠生成的對象， //如果需要得到工廠本身，需要轉義 String FACTORY_BEAN_PREFIX = "&"; //根據bean的名字，獲取在IOC容器中得到bean實例 Object getBean(String name) throws BeansException; //根據bean的名字和Class類型來得到bean實例，增加了類型安全驗證機制。 Object getBean(String name, Class requiredType) throws BeansException; //提供對bean的檢索，看看是否在IOC容器有這個名字的bean boolean containsBean(String name); //根據bean名字得到bean實例，并同時判斷這個bean是不是單例 boolean isSingleton(String name) throws NoSuchBeanDefinitionException; //得到bean實例的Class類型 Class getType(String name) throws NoSuchBeanDefinitionException; //得到bean的別名，如果根據別名檢索，那么其原名也會被檢索出來 String[] getAliases(String name); }

在BeanFactory里只對IOC容器的最基本行為作了定義，不關心你的bean是如何定義和怎樣加載的。正如我們只關心工廠里得到什么的產品對象，只要工廠是怎么生產這些對象的，這個基本的接口不關心。

而要知道工廠是如何生產對象的，需要看IOC容器的實現，spring提供了許多IOC容器的實現，比如：

• XmlBeanFactory
• ClassPathxmlApplicationContext

其中XmlBeanFactory就是針對最基本的IOC容器的實現，這個IOC容器可以讀取XML文件定義的BeanDefinition（Xml文件中對bean的描述），如果說XMLBeanFactory是容器中的屌絲，ApplicationContext 應該算是容器中的高富帥。

ApplicationContext是Spring提供的一個高級的IOC容器，它處理能夠提供IOC容器的基本功能外，還為用戶提供了以下的附加服務。從ApplicationContext接口的實現，可以看出其特點。

支持信息源，可以實現國際化。（實現MessageSource接口）

訪問資源。（實現ResourcePatternResolver接口）

支持應用事件。（實現ApplicationEventPublisher接口）

ApplicationContext（應用上下文）常用的應用上下文：

AnnotationConfigApplicationContext：從一個或多個基于Java的配置類中加載Spring應用上下文。

AnnotationConfigWebApplicationContext:從一個或多個基于Java的配置類中加載Spring Web 應用上下文。

ClassPathXMLApplicationContext：從類路徑下的一個或多個xml配置文件中加載上下文定義，把應用上下文的定義文件作為類資源。

FileSystemXMlApplicationContext：從文件系統下的一個或多個XML配置文件中加載上下文定義。

XMLWebApplicationContext：從web應用下的一個或多個xml配置文件中加載上下文定義。

BeanDefinition：Bean的對象

SpringIOC容器管理了我們定義的各種Bean對象及其相互的關系，Bean對象在Spring實現中是以BeanDefinition來描述的，其繼承體系如下：

Bean的解析

Bean 的解析過程非常復雜，功能被分的很細，因為這里需要被擴展的地方很多，必須保證有足夠的靈活性，以應對可能的變化。Bean的解析主要就是對Spring配置文件的解析。這個解析過程主要通過下圖中的類完成：

IOC容器的初始化

IOC容器的初始化包括 BeanDefinition的Resource定義，載入和注冊這桑基本的過程。我們以ApplicationContext為例講解。其繼承體系如下圖所示：

ApplicationContext允許上下文嵌套，通過保持父上下文可以維持一個上下文體系。對于Bean的查找可以在這個上下文體系中發生，首先檢查當前上下文，其次是父上下文，逐級向上，這樣為不同的Spring應用提供了一個共享的Bean定義環境。

XMLBeanFactory（屌絲IOC）的整個流程

通過XmlBeanFactory源碼可以發現：

public class XmlBeanFactory extends DefaultListableBeanFactory{private final XmlBeanDefinitionReader reader; public XmlBeanFactory(Resource resource)throws BeansException{this(resource, null);}public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory)throws BeansException{super(parentBeanFactory);this.reader = new XmlBeanDefinitionReader(this);this.reader.loadBeanDefinitions(resource);}} //根據Xml配置文件創建Resource資源對象，該對象中包含了BeanDefinition的信息ClassPathResource resource =new ClassPathResource("application-context.xml"); //創建DefaultListableBeanFactoryDefaultListableBeanFactory factory =new DefaultListableBeanFactory(); //創建XmlBeanDefinitionReader讀取器，用于載入BeanDefinition。之所以需要BeanFactory作為參數，是因為會將讀取的信息回調配置給factoryXmlBeanDefinitionReader reader =new XmlBeanDefinitionReader(factory); //XmlBeanDefinitionReader執行載入BeanDefinition的方法，最后會完成Bean的載入和注冊。完成后Bean就成功的放置到IOC容器當中，以后我們就可以從中取得Bean來使用reader.loadBeanDefinitions(resource);

通過前面的源碼，this.reader = new XmlBeanDefinitionReader(this); 中其中this 傳的是factory對象

2、FileSystemXmlApplicationContext 的IOC容器流程

高富帥IOC剖解

1 ApplicationContext =new FileSystemXmlApplicationContext(xmlPath);

先看其構造函數：

/** * Create a new FileSystemXmlApplicationContext, loading the definitions * from the given XML files and automatically refreshing the context. * @param configLocations array of file paths * @throws BeansException if context creation failed*/public FileSystemXmlApplicationContext(String... configLocations) throws BeansException {this(configLocations, true, null);}

實際調用

public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) throws BeansException { super(parent); setConfigLocations(configLocations); if (refresh) { refresh(); } }

2、設置資源加載器和資源定位

通過分析FileSystemXmlApplicationContext的源代碼可以知道，在創建FileSystemXmlApplicationContext容器時，構造方法做以下兩項重要工作：

首先，調用父類容器的構造方法(super(parent)方法)為容器設置好Bean資源加載器。

然后，再調用父類AbstractRefreshableConfigApplicationContext的setConfigLocations(configLocations)方法設置Bean定義資源文件的定位路徑。

通過追蹤FileSystemXmlApplicationContext的繼承體系，發現其父類的父類AbstractApplicationContext中初始化IoC容器所做的主要源碼如下：

public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext, DisposableBean { //靜態初始化塊，在整個容器創建過程中只執行一次 static { //為了避免應用程序在Weblogic8.1關閉時出現類加載異常加載問題，加載IoC容 //器關閉事件(ContextClosedEvent)類 ContextClosedEvent.class.getName(); } //FileSystemXmlApplicationContext調用父類構造方法調用的就是該方法 public AbstractApplicationContext(ApplicationContext parent) { this.parent = parent; this.resourcePatternResolver = getResourcePatternResolver(); } //獲取一個Spring Source的加載器用于讀入Spring Bean定義資源文件 protected ResourcePatternResolver getResourcePatternResolver() { // AbstractApplicationContext繼承DefaultResourceLoader，也是一個S //Spring資源加載器，其getResource(String location)方法用于載入資源 return new PathMatchingResourcePatternResolver(this); } …… }

AbstractApplicationContext構造方法中調用PathMatchingResourcePatternResolver的構造方法創建Spring資源加載器：

public PathMatchingResourcePatternResolver(ResourceLoader resourceLoader) { Assert.notNull(resourceLoader, "ResourceLoader must not be null"); //設置Spring的資源加載器 this.resourceLoader = resourceLoader; }

在設置容器的資源加載器之后，接下來FileSystemXmlApplicationContet執行setConfigLocations方法通過調用其父類AbstractRefreshableConfigApplicationContext的方法進行對Bean定義資源文件的定位，該方法的源碼如下：

//處理單個資源文件路徑為一個字符串的情況 public void setConfigLocation(String location) { //String CONFIG_LOCATION_DELIMITERS = ",; /t/n"; //即多個資源文件路徑之間用” ,; /t/n”分隔，解析成數組形式 setConfigLocations(StringUtils.tokenizeToStringArray(location, CONFIG_LOCATION_DELIMITERS)); } //解析Bean定義資源文件的路徑，處理多個資源文件字符串數組 public void setConfigLocations(String[] locations) { if (locations != null) { Assert.noNullElements(locations, "Config locations must not be null"); this.configLocations = new String[locations.length]; for (int i = 0; i < locations.length; i++) { // resolvePath為同一個類中將字符串解析為路徑的方法 this.configLocations[i] = resolvePath(locations[i]).trim(); } } else { this.configLocations = null; } }

通過這兩個方法的源碼我們可以看出，我們既可以使用一個字符串來配置多個Spring Bean定義資源文件，也可以使用字符串數組，即下面兩種方式都是可以的：

a. ClasspathResource res = new ClasspathResource(“a.xml,b.xml,……”);多個資源文件路徑之間可以是用” ,; /t/n”等分隔。b. ClasspathResource res = new ClasspathResource(newString[]{“a.xml”,”b.xml”,……});

至此，Spring IoC容器在初始化時將配置的Bean定義資源文件定位為Spring封裝的Resource。

3、AbstractApplicationContext的refresh函數載入Bean定義過程：

Spring IoC容器對Bean定義資源的載入是從refresh()函數開始的，refresh()是一個模板方法，refresh()方法的作用是：在創建IoC容器前，如果已經有容器存在，則需要把已有的容器銷毀和關閉，以保證在refresh之后使用的是新建立起來的IoC容器。refresh的作用類似于對IoC容器的重啟，在新建立好的容器中對容器進行初始化，對Bean定義資源進行載入

FileSystemXmlApplicationContext通過調用其父類AbstractApplicationContext的refresh()函數啟動整個IoC容器對Bean定義的載入過程：

public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { //調用容器準備刷新的方法，獲取容器的當時時間，同時給容器設置同步標識 prepareRefresh(); //告訴子類啟動refreshBeanFactory()方法，Bean定義資源文件的載入從 //子類的refreshBeanFactory()方法啟動 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); //為BeanFactory配置容器特性，例如類加載器、事件處理器等 prepareBeanFactory(beanFactory); try { //為容器的某些子類指定特殊的BeanPost事件處理器 postProcessBeanFactory(beanFactory); //調用所有注冊的BeanFactoryPostProcessor的Bean invokeBeanFactoryPostProcessors(beanFactory); //為BeanFactory注冊BeanPost事件處理器. //BeanPostProcessor是Bean后置處理器，用于監聽容器觸發的事件 registerBeanPostProcessors(beanFactory); //初始化信息源，和國際化相關. initMessageSource(); //初始化容器事件傳播器. initApplicationEventMulticaster(); //調用子類的某些特殊Bean初始化方法 onRefresh(); //為事件傳播器注冊事件監聽器. registerListeners(); //初始化所有剩余的單態Bean. finishBeanFactoryInitialization(beanFactory); //初始化容器的生命周期事件處理器，并發布容器的生命周期事件 finishRefresh(); } catch (BeansException ex) { //銷毀以創建的單態Bean destroyBeans(); //取消refresh操作，重置容器的同步標識. cancelRefresh(ex); throw ex; } } }

refresh()方法主要為IoC容器Bean的生命周期管理提供條件，Spring IoC容器載入Bean定義資源文件從其子類容器的refreshBeanFactory()方法啟動，所以整個refresh()中“ConfigurableListableBeanFactory beanFactory =obtainFreshBeanFactory();”這句以后代碼的都是注冊容器的信息源和生命周期事件，載入過程就是從這句代碼啟動。

refresh()方法的作用是：在創建IoC容器前，如果已經有容器存在，則需要把已有的容器銷毀和關閉，以保證在refresh之后使用的是新建立起來的IoC容器。refresh的作用類似于對IoC容器的重啟，在新建立好的容器中對容器進行初始化，對Bean定義資源進行載入

AbstractApplicationContext的obtainFreshBeanFactory()方法調用子類容器的refreshBeanFactory()方法，啟動容器載入Bean定義資源文件的過程，代碼如下：

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() { //這里使用了委派設計模式，父類定義了抽象的refreshBeanFactory()方法，具體實現調用子類容器的refreshBeanFactory()方法refreshBeanFactory(); ConfigurableListableBeanFactory beanFactory = getBeanFactory(); if (logger.isDebugEnabled()) { logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory); } return beanFactory; }

AbstractApplicationContext子類的refreshBeanFactory()方法：AbstractApplicationContext類中只抽象定義了refreshBeanFactory()方法，容器真正調用的是其子類AbstractRefreshableApplicationContext實現的 refreshBeanFactory()方法，方法的源碼如下：

protected final void refreshBeanFactory() throws BeansException { if (hasBeanFactory()) {//如果已經有容器，銷毀容器中的bean，關閉容器 destroyBeans(); closeBeanFactory(); } try { //創建IoC容器 DefaultListableBeanFactory beanFactory = createBeanFactory(); beanFactory.setSerializationId(getId()); //對IoC容器進行定制化，如設置啟動參數，開啟注解的自動裝配等 customizeBeanFactory(beanFactory); //調用載入Bean定義的方法，主要這里又使用了一個委派模式，在當前類中只定義了抽象的loadBeanDefinitions方法，具體的實現調用子類容器 loadBeanDefinitions(beanFactory); synchronized (this.beanFactoryMonitor) { this.beanFactory = beanFactory; } } catch (IOException ex) { throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex); } }

在這個方法中，先判斷BeanFactory是否存在，如果存在則先銷毀beans并關閉beanFactory，接著創建DefaultListableBeanFactory，并調用loadBeanDefinitions(beanFactory)裝載bean定義。

5、AbstractRefreshableApplicationContext子類的loadBeanDefinitions方法：

AbstractRefreshableApplicationContext中只定義了抽象的loadBeanDefinitions方法，容器真正調用的是其子類AbstractXmlApplicationContext對該方法的實現，AbstractXmlApplicationContext的主要源碼如下：loadBeanDefinitions方法同樣是抽象方法，是由其子類實現的，也即在AbstractXmlApplicationContext中。

public abstract class AbstractXmlApplicationContext extends AbstractRefreshableConfigApplicationContext { …… //實現父類抽象的載入Bean定義方法 @Override protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException { //創建XmlBeanDefinitionReader，即創建Bean讀取器，并通過回調設置到容器中去，容 器使用該讀取器讀取Bean定義資源 XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory); //為Bean讀取器設置Spring資源加載器，AbstractXmlApplicationContext的 //祖先父類AbstractApplicationContext繼承DefaultResourceLoader，因此，容器本身也是一個資源加載器 beanDefinitionReader.setResourceLoader(this); //為Bean讀取器設置SAX xml解析器 beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this)); //當Bean讀取器讀取Bean定義的Xml資源文件時，啟用Xml的校驗機制 initBeanDefinitionReader(beanDefinitionReader); //Bean讀取器真正實現加載的方法 loadBeanDefinitions(beanDefinitionReader); } //Xml Bean讀取器加載Bean定義資源 protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException { //獲取Bean定義資源的定位 Resource[] configResources = getConfigResources(); if (configResources != null) { //Xml Bean讀取器調用其父類AbstractBeanDefinitionReader讀取定位 //的Bean定義資源 reader.loadBeanDefinitions(configResources); } //如果子類中獲取的Bean定義資源定位為空，則獲取FileSystemXmlApplicationContext構造方法中setConfigLocations方法設置的資源 String[] configLocations = getConfigLocations(); if (configLocations != null) { //Xml Bean讀取器調用其父類AbstractBeanDefinitionReader讀取定位 //的Bean定義資源 reader.loadBeanDefinitions(configLocations); } } //這里又使用了一個委托模式，調用子類的獲取Bean定義資源定位的方法 //該方法在ClassPathXmlApplicationContext中進行實現，對于我們 //舉例分析源碼的FileSystemXmlApplicationContext沒有使用該方法 protected Resource[] getConfigResources() { return null; } …… 41}

Xml Bean讀取器(XmlBeanDefinitionReader)調用其父類AbstractBeanDefinitionReader的 reader.loadBeanDefinitions方法讀取Bean定義資源。由于我們使用FileSystemXmlApplicationContext作為例子分析，因此getConfigResources的返回值為null，因此程序執行reader.loadBeanDefinitions(configLocations)分支。

6、AbstractBeanDefinitionReader讀取Bean定義資源：

AbstractBeanDefinitionReader的loadBeanDefinitions方法源碼如下： 可以到org.springframework.beans.factory.support看一下BeanDefinitionReader的結構

在其抽象父類AbstractBeanDefinitionReader中定義了載入過程

//重載方法，調用下面的loadBeanDefinitions(String, Set<Resource>);方法 public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException { return loadBeanDefinitions(location, null); } public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException { //獲取在IoC容器初始化過程中設置的資源加載器 ResourceLoader resourceLoader = getResourceLoader(); if (resourceLoader == null) { throw new BeanDefinitionStoreException( "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available"); } if (resourceLoader instanceof ResourcePatternResolver) { try { //將指定位置的Bean定義資源文件解析為Spring IoC容器封裝的資源 //加載多個指定位置的Bean定義資源文件 Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location); //委派調用其子類XmlBeanDefinitionReader的方法，實現加載功能 int loadCount = loadBeanDefinitions(resources); if (actualResources != null) { for (Resource resource : resources) { actualResources.add(resource); } } 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 { //將指定位置的Bean定義資源文件解析為Spring IoC容器封裝的資源 //加載單個指定位置的Bean定義資源文件 Resource resource = resourceLoader.getResource(location); //委派調用其子類XmlBeanDefinitionReader的方法，實現加載功能 int loadCount = loadBeanDefinitions(resource); if (actualResources != null) { actualResources.add(resource); } if (logger.isDebugEnabled()) { logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]"); } return loadCount; } } //重載方法，調用loadBeanDefinitions(String); public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException { Assert.notNull(locations, "Location array must not be null"); int counter = 0; for (String location : locations) { counter += loadBeanDefinitions(location); } return counter; }

loadBeanDefinitions(Resource...resources)方法和上面分析的3個方法類似，同樣也是調用XmlBeanDefinitionReader的loadBeanDefinitions方法。

從對AbstractBeanDefinitionReader的loadBeanDefinitions方法源碼分析可以看出該方法做了以下兩件事：

首先，調用資源加載器的獲取資源方法resourceLoader.getResource(location)，獲取到要加載的資源。

其次，真正執行加載功能是其子類XmlBeanDefinitionReader的loadBeanDefinitions方法。

看到第8、16行，結合上面的ResourceLoader與ApplicationContext的繼承關系圖，可以知道此時調用的是DefaultResourceLoader中的getSource()方法定位Resource，因為FileSystemXmlApplicationContext本身就是DefaultResourceLoader的實現類，所以此時又回到了FileSystemXmlApplicationContext中來。

7、資源加載器獲取要讀入的資源：

XmlBeanDefinitionReader通過調用其父類DefaultResourceLoader的getResource方法獲取要加載的資源，其源碼如下

//獲取Resource的具體實現方法 public Resource getResource(String location) { Assert.notNull(location, "Location must not be null"); //如果是類路徑的方式，那需要使用ClassPathResource 來得到bean 文件的資源對象 if (location.startsWith(CLASSPATH_URL_PREFIX)) { return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader()); } try { // 如果是URL 方式，使用UrlResource 作為bean 文件的資源對象 URL url = new URL(location); return new UrlResource(url); } catch (MalformedURLException ex) { } //如果既不是classpath標識，又不是URL標識的Resource定位，則調用 //容器本身的getResourceByPath方法獲取Resource return getResourceByPath(location); }

FileSystemXmlApplicationContext容器提供了getResourceByPath方法的實現，就是為了處理既不是classpath標識，又不是URL標識的Resource定位這種情況。

protected Resource getResourceByPath(String path) { if (path != null && path.startsWith("/")) { path = path.substring(1); } //這里使用文件系統資源對象來定義bean 文件return new FileSystemResource(path); }

這樣代碼就回到了 FileSystemXmlApplicationContext 中來，他提供了FileSystemResource 來完成從文件系統得到配置文件的資源定義。

這樣，就可以從文件系統路徑上對IOC 配置文件進行加載 - 當然我們可以按照這個邏輯從任何地方加載，在Spring 中我們看到它提供 的各種資源抽象，比如ClassPathResource, URLResource,FileSystemResource 等來供我們使用。上面我們看到的是定位Resource 的一個過程，而這只是加載過程的一部分.

8、XmlBeanDefinitionReader加載Bean定義資源：

Bean定義的Resource得到了， 繼續回到XmlBeanDefinitionReader的loadBeanDefinitions(Resource …)方法看到代表bean文件的資源定義以后的載入過程。 //XmlBeanDefinitionReader加載資源的入口方法 public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException { //將讀入的XML資源進行特殊編碼處理 return loadBeanDefinitions(new EncodedResource(resource)); } //這里是載入XML形式Bean定義資源文件方法public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException { ....... try { //將資源文件轉為InputStream的IO流 InputStream inputStream = encodedResource.getResource().getInputStream(); try { //從InputStream中得到XML的解析源 InputSource inputSource = new InputSource(inputStream); if (encodedResource.getEncoding() != null) { inputSource.setEncoding(encodedResource.getEncoding()); } //這里是具體的讀取過程 return doLoadBeanDefinitions(inputSource, encodedResource.getResource()); } finally { //關閉從Resource中得到的IO流 inputStream.close(); } } ......... 26} //從特定XML文件中實際載入Bean定義資源的方法 protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException { try { int validationMode = getValidationModeForResource(resource); //將XML文件轉換為DOM對象，解析過程由documentLoader實現 Document doc = this.documentLoader.loadDocument( inputSource, this.entityResolver, this.errorHandler, validationMode, this.namespaceAware); //這里是啟動對Bean定義解析的詳細過程，該解析過程會用到Spring的Bean配置規則return registerBeanDefinitions(doc, resource); } ....... }

通過源碼分析，載入Bean定義資源文件的最后一步是將Bean定義資源轉換為Document對象，該過程由documentLoader實現

9、DocumentLoader將Bean定義資源轉換為Document對象：

DocumentLoader將Bean定義資源轉換成Document對象的源碼如下：

//使用標準的JAXP將載入的Bean定義資源轉換成document對象 public Document loadDocument(InputSource inputSource, EntityResolver entityResolver, ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception { //創建文件解析器工廠 DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware); if (logger.isDebugEnabled()) { logger.debug("Using JAXP provider [" + factory.getClass().getName() + "]"); } //創建文檔解析器 DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler); //解析Spring的Bean定義資源 return builder.parse(inputSource); } protected DocumentBuilderFactory createDocumentBuilderFactory(int validationMode, boolean namespaceAware) throws ParserConfigurationException { //創建文檔解析工廠 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setNamespaceAware(namespaceAware); //設置解析XML的校驗 if (validationMode != XmlValidationModeDetector.VALIDATION_NONE) { factory.setValidating(true); if (validationMode == XmlValidationModeDetector.VALIDATION_XSD) { factory.setNamespaceAware(true); try { factory.setAttribute(SCHEMA_LANGUAGE_ATTRIBUTE, XSD_SCHEMA_LANGUAGE); } catch (IllegalArgumentException ex) { ParserConfigurationException pcex = new ParserConfigurationException( "Unable to validate using XSD: Your JAXP provider [" + factory + "] does not support XML Schema. Are you running on Java 1.4 with Apache Crimson? " + "Upgrade to Apache Xerces (or Java 1.5) for full XSD support."); pcex.initCause(ex); throw pcex; } } } return factory; }

該解析過程調用JavaEE標準的JAXP標準進行處理。

至此Spring IoC容器根據定位的Bean定義資源文件，將其加載讀入并轉換成為Document對象過程完成。

接下來我們要繼續分析Spring IoC容器將載入的Bean定義資源文件轉換為Document對象之后，是如何將其解析為Spring IoC管理的Bean對象并將其注冊到容器中的。

10、XmlBeanDefinitionReader解析載入的Bean定義資源文件：

XmlBeanDefinitionReader類中的doLoadBeanDefinitions方法是從特定XML文件中實際載入Bean定義資源的方法，該方法在載入Bean定義資源之后將其轉換為Document對象，接下來調用registerBeanDefinitions啟動Spring IoC容器對Bean定義的解析過程，registerBeanDefinitions方法源碼如下：

//按照Spring的Bean語義要求將Bean定義資源解析并轉換為容器內部數據結構 public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException { //得到BeanDefinitionDocumentReader來對xml格式的BeanDefinition解析 BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader(); //獲得容器中注冊的Bean數量 int countBefore = getRegistry().getBeanDefinitionCount(); //解析過程入口，這里使用了委派模式，BeanDefinitionDocumentReader只是個接口，//具體的解析實現過程有實現類DefaultBeanDefinitionDocumentReader完成 documentReader.registerBeanDefinitions(doc, createReaderContext(resource)); //統計解析的Bean數量 return getRegistry().getBeanDefinitionCount() - countBefore; } //創建BeanDefinitionDocumentReader對象，解析Document對象 protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() { return BeanDefinitionDocumentReader.class.cast(BeanUtils.instantiateClass(this.documentReaderClass)); }

Bean定義資源的載入解析分為以下兩個過程：

首先，通過調用XML解析器將Bean定義資源文件轉換得到Document對象，但是這些Document對象并沒有按照Spring的Bean規則進行解析。這一步是載入的過程

其次，在完成通用的XML解析之后，按照Spring的Bean規則對Document對象進行解析。

按照Spring的Bean規則對Document對象解析的過程是在接口BeanDefinitionDocumentReader的實現類DefaultBeanDefinitionDocumentReader中實現的。

11、DefaultBeanDefinitionDocumentReader對Bean定義的Document對象解析：

BeanDefinitionDocumentReader接口通過registerBeanDefinitions方法調用其實現類DefaultBeanDefinitionDocumentReader對Document對象進行解析，解析的代碼如下：

//根據Spring DTD對Bean的定義規則解析Bean定義Document對象 public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) { //獲得XML描述符 this.readerContext = readerContext; logger.debug("Loading bean definitions"); //獲得Document的根元素 Element root = doc.getDocumentElement(); //具體的解析過程由BeanDefinitionParserDelegate實現， //BeanDefinitionParserDelegate中定義了Spring Bean定義XML文件的各種元素 BeanDefinitionParserDelegate delegate = createHelper(readerContext, root); //在解析Bean定義之前，進行自定義的解析，增強解析過程的可擴展性 preProcessXml(root); //從Document的根元素開始進行Bean定義的Document對象 parseBeanDefinitions(root, delegate); //在解析Bean定義之后，進行自定義的解析，增加解析過程的可擴展性 postProcessXml(root); } //創建BeanDefinitionParserDelegate，用于完成真正的解析過程 protected BeanDefinitionParserDelegate createHelper(XmlReaderContext readerContext, Element root) { BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext); //BeanDefinitionParserDelegate初始化Document根元素 delegate.initDefaults(root); return delegate; } //使用Spring的Bean規則從Document的根元素開始進行Bean定義的Document對象 protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) { //Bean定義的Document對象使用了Spring默認的XML命名空間 if (delegate.isDefaultNamespace(root)) { //獲取Bean定義的Document對象根元素的所有子節點 NodeList nl = root.getChildNodes(); for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); //獲得Document節點是XML元素節點 if (node instanceof Element) { Element ele = (Element) node; //Bean定義的Document的元素節點使用的是Spring默認的XML命名空間 if (delegate.isDefaultNamespace(ele)) { //使用Spring的Bean規則解析元素節點 parseDefaultElement(ele, delegate); } else { //沒有使用Spring默認的XML命名空間，則使用用戶自定義的解//析規則解析元素節點 delegate.parseCustomElement(ele); } } } } else { //Document的根節點沒有使用Spring默認的命名空間，則使用用戶自定義的 //解析規則解析Document根節點 delegate.parseCustomElement(root); } } //使用Spring的Bean規則解析Document元素節點 private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) { //如果元素節點是<Import>導入元素，進行導入解析 if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) { importBeanDefinitionResource(ele); } //如果元素節點是<Alias>別名元素，進行別名解析 else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) { processAliasRegistration(ele); } //元素節點既不是導入元素，也不是別名元素，即普通的<Bean>元素， //按照Spring的Bean規則解析元素 else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) { processBeanDefinition(ele, delegate); } } //解析<Import>導入元素，從給定的導入路徑加載Bean定義資源到Spring IoC容器中 protected void importBeanDefinitionResource(Element ele) { //獲取給定的導入元素的location屬性 String location = ele.getAttribute(RESOURCE_ATTRIBUTE); //如果導入元素的location屬性值為空，則沒有導入任何資源，直接返回 if (!StringUtils.hasText(location)) { getReaderContext().error("Resource location must not be empty", ele); return; } //使用系統變量值解析location屬性值 location = SystemPropertyUtils.resolvePlaceholders(location); Set<Resource> actualResources = new LinkedHashSet<Resource>(4); //標識給定的導入元素的location是否是絕對路徑 boolean absoluteLocation = false; try { absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute(); } catch (URISyntaxException ex) { //給定的導入元素的location不是絕對路徑 } //給定的導入元素的location是絕對路徑 if (absoluteLocation) { try { //使用資源讀入器加載給定路徑的Bean定義資源 int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources); if (logger.isDebugEnabled()) { logger.debug("Imported " + importCount + " bean definitions from URL location [" + location + "]"); } } catch (BeanDefinitionStoreException ex) { getReaderContext().error( "Failed to import bean definitions from URL location [" + location + "]", ele, ex); } } else { //給定的導入元素的location是相對路徑 try { int importCount; //將給定導入元素的location封裝為相對路徑資源 Resource relativeResource = getReaderContext().getResource().createRelative(location); //封裝的相對路徑資源存在 if (relativeResource.exists()) { //使用資源讀入器加載Bean定義資源 importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource); actualResources.add(relativeResource); } //封裝的相對路徑資源不存在 else { //獲取Spring IoC容器資源讀入器的基本路徑 String baseLocation = getReaderContext().getResource().getURL().toString(); //根據Spring IoC容器資源讀入器的基本路徑加載給定導入 //路徑的資源 importCount = getReaderContext().getReader().loadBeanDefinitions( StringUtils.applyRelativePath(baseLocation, location), actualResources); } if (logger.isDebugEnabled()) { logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]"); } } catch (IOException ex) { getReaderContext().error("Failed to resolve current resource location", ele, ex); } catch (BeanDefinitionStoreException ex) { getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]", ele, ex); } } Resource[] actResArray = actualResources.toArray(new Resource[actualResources.size()]); //在解析完<Import>元素之后，發送容器導入其他資源處理完成事件 getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele)); } //解析<Alias>別名元素，為Bean向Spring IoC容器注冊別名 protected void processAliasRegistration(Element ele) { //獲取<Alias>別名元素中name的屬性值 String name = ele.getAttribute(NAME_ATTRIBUTE); //獲取<Alias>別名元素中alias的屬性值 String alias = ele.getAttribute(ALIAS_ATTRIBUTE); boolean valid = true; //<alias>別名元素的name屬性值為空 if (!StringUtils.hasText(name)) { getReaderContext().error("Name must not be empty", ele); valid = false; } //<alias>別名元素的alias屬性值為空 if (!StringUtils.hasText(alias)) { getReaderContext().error("Alias must not be empty", ele); valid = false; } if (valid) { try { //向容器的資源讀入器注冊別名 getReaderContext().getRegistry().registerAlias(name, alias); } catch (Exception ex) { getReaderContext().error("Failed to register alias '" + alias + "' for bean with name '" + name + "'", ele, ex); } //在解析完<Alias>元素之后，發送容器別名處理完成事件 getReaderContext().fireAliasRegistered(name, alias, extractSource(ele)); } } //解析Bean定義資源Document對象的普通元素 protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) { // BeanDefinitionHolder是對BeanDefinition的封裝，即Bean定義的封裝類 //對Document對象中<Bean>元素的解析由BeanDefinitionParserDelegate實現 BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); if (bdHolder != null) { bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder); try { //向Spring IoC容器注冊解析得到的Bean定義，這是Bean定義向IoC容器注冊的入口 BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()); } catch (BeanDefinitionStoreException ex) { getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, ex); } //在完成向Spring IoC容器注冊解析得到的Bean定義之后，發送注冊事件 getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder)); } }

通過上述Spring IoC容器對載入的Bean定義Document解析可以看出，我們使用Spring時，在Spring配置文件中可以使用<Import>元素來導入IoC容器所需要的其他資源，Spring IoC容器在解析時會首先將指定導入的資源加載進容器中。使用<Ailas>別名時，Spring IoC容器首先將別名元素所定義的別名注冊到容器中。

對于既不是<Import>元素，又不是<Alias>元素的元素，即Spring配置文件中普通的<Bean>元素的解析由BeanDefinitionParserDelegate類的parseBeanDefinitionElement方法來實現。

12、BeanDefinitionParserDelegate解析Bean定義資源文件中的<Bean>元素：

Bean定義資源文件中的<Import>和<Alias>元素解析在DefaultBeanDefinitionDocumentReader中已經完成，對Bean定義資源文件中使用最多的<Bean>元素交由BeanDefinitionParserDelegate來解析，其解析實現的源碼如下：

//解析<Bean>元素的入口 public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) { return parseBeanDefinitionElement(ele, null); } //解析Bean定義資源文件中的<Bean>元素，這個方法中主要處理<Bean>元素的id，name //和別名屬性 public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) { //獲取<Bean>元素中的id屬性值 String id = ele.getAttribute(ID_ATTRIBUTE); //獲取<Bean>元素中的name屬性值 String nameAttr = ele.getAttribute(NAME_ATTRIBUTE); 獲取<Bean>元素中的alias屬性值 List<String> aliases = new ArrayList<String>(); //將<Bean>元素中的所有name屬性值存放到別名中 if (StringUtils.hasLength(nameAttr)) { String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, BEAN_NAME_DELIMITERS); aliases.addAll(Arrays.asList(nameArr)); } String beanName = id; //如果<Bean>元素中沒有配置id屬性時，將別名中的第一個值賦值給beanName if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) { beanName = aliases.remove(0); if (logger.isDebugEnabled()) { logger.debug("No XML 'id' specified - using '" + beanName + "' as bean name and " + aliases + " as aliases"); } } //檢查<Bean>元素所配置的id或者name的唯一性，containingBean標識<Bean> //元素中是否包含子<Bean>元素 if (containingBean == null) { //檢查<Bean>元素所配置的id、name或者別名是否重復 checkNameUniqueness(beanName, aliases, ele); } //詳細對<Bean>元素中配置的Bean定義進行解析的地方 AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean); if (beanDefinition != null) { if (!StringUtils.hasText(beanName)) { try { if (containingBean != null) { //如果<Bean>元素中沒有配置id、別名或者name，且沒有包含子//<Bean>元素，為解析的Bean生成一個唯一beanName并注冊 beanName = BeanDefinitionReaderUtils.generateBeanName( beanDefinition, this.readerContext.getRegistry(), true); } else { //如果<Bean>元素中沒有配置id、別名或者name，且包含了子//<Bean>元素，為解析的Bean使用別名向IoC容器注冊 beanName = this.readerContext.generateBeanName(beanDefinition); //為解析的Bean使用別名注冊時，為了向后兼容 //Spring1.2/2.0，給別名添加類名后綴 String beanClassName = beanDefinition.getBeanClassName(); if (beanClassName != null && beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() && !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) { aliases.add(beanClassName); } } if (logger.isDebugEnabled()) { logger.debug("Neither XML 'id' nor 'name' specified - " + "using generated bean name [" + beanName + "]"); } } catch (Exception ex) { error(ex.getMessage(), ele); return null; } } String[] aliasesArray = StringUtils.toStringArray(aliases); return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray); } //當解析出錯時，返回null return null; } //詳細對<Bean>元素中配置的Bean定義其他屬性進行解析，由于上面的方法中已經對//Bean的id、name和別名等屬性進行了處理，該方法中主要處理除這三個以外的其他屬性數據 public AbstractBeanDefinition parseBeanDefinitionElement( Element ele, String beanName, BeanDefinition containingBean) { //記錄解析的<Bean> this.parseState.push(new BeanEntry(beanName)); //這里只讀取<Bean>元素中配置的class名字，然后載入到BeanDefinition中去 //只是記錄配置的class名字，不做實例化，對象的實例化在依賴注入時完成 String className = null; if (ele.hasAttribute(CLASS_ATTRIBUTE)) { className = ele.getAttribute(CLASS_ATTRIBUTE).trim(); } try { String parent = null; //如果<Bean>元素中配置了parent屬性，則獲取parent屬性的值 if (ele.hasAttribute(PARENT_ATTRIBUTE)) { parent = ele.getAttribute(PARENT_ATTRIBUTE); } //根據<Bean>元素配置的class名稱和parent屬性值創建BeanDefinition //為載入Bean定義信息做準備 AbstractBeanDefinition bd = createBeanDefinition(className, parent); //對當前的<Bean>元素中配置的一些屬性進行解析和設置，如配置的單態(singleton)屬性等 parseBeanDefinitionAttributes(ele, beanName, containingBean, bd); //為<Bean>元素解析的Bean設置description信息 bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT)); //對<Bean>元素的meta(元信息)屬性解析 parseMetaElements(ele, bd); //對<Bean>元素的lookup-method屬性解析 parseLookupOverrideSubElements(ele, bd.getMethodOverrides()); //對<Bean>元素的replaced-method屬性解析 parseReplacedMethodSubElements(ele, bd.getMethodOverrides()); //解析<Bean>元素的構造方法設置 parseConstructorArgElements(ele, bd); //解析<Bean>元素的<property>設置 parsePropertyElements(ele, bd); //解析<Bean>元素的qualifier屬性 parseQualifierElements(ele, bd); //為當前解析的Bean設置所需的資源和依賴對象 bd.setResource(this.readerContext.getResource()); bd.setSource(extractSource(ele)); return bd; } catch (ClassNotFoundException ex) { error("Bean class [" + className + "] not found", ele, ex); } catch (NoClassDefFoundError err) { error("Class that bean class [" + className + "] depends on not found", ele, err); } catch (Throwable ex) { error("Unexpected failure during bean definition parsing", ele, ex); } finally { this.parseState.pop(); } //解析<Bean>元素出錯時，返回null return null; }

只要使用過Spring，對Spring配置文件比較熟悉的人，通過對上述源碼的分析，就會明白我們在Spring配置文件中<Bean>元素的中配置的屬性就是通過該方法解析和設置到Bean中去的。

注意：在解析<Bean>元素過程中沒有創建和實例化Bean對象，只是創建了Bean對象的定義類BeanDefinition，將<Bean>元素中的配置信息設置到BeanDefinition中作為記錄，當依賴注入時才使用這些記錄信息創建和實例化具體的Bean對象。

上面方法中一些對一些配置如元信息(meta)、qualifier等的解析，我們在Spring中配置時使用的也不多，我們在使用Spring的<Bean>元素時，配置最多的是<property>屬性，因此我們下面繼續分析源碼，了解Bean的屬性在解析時是如何設置的。

13、BeanDefinitionParserDelegate解析<property>元素：

BeanDefinitionParserDelegate在解析<Bean>調用parsePropertyElements方法解析<Bean>元素中的<property>屬性子元素，解析源碼如下：

//解析<Bean>元素中的<property>子元素 public void parsePropertyElements(Element beanEle, BeanDefinition bd) { //獲取<Bean>元素中所有的子元素 NodeList nl = beanEle.getChildNodes(); for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); //如果子元素是<property>子元素，則調用解析<property>子元素方法解析 if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) { parsePropertyElement((Element) node, bd); } } } //解析<property>元素 public void parsePropertyElement(Element ele, BeanDefinition bd) { //獲取<property>元素的名字 String propertyName = ele.getAttribute(NAME_ATTRIBUTE); if (!StringUtils.hasLength(propertyName)) { error("Tag 'property' must have a 'name' attribute", ele); return; } this.parseState.push(new PropertyEntry(propertyName)); try { //如果一個Bean中已經有同名的property存在，則不進行解析，直接返回。 //即如果在同一個Bean中配置同名的property，則只有第一個起作用 if (bd.getPropertyValues().contains(propertyName)) { error("Multiple 'property' definitions for property '" + propertyName + "'", ele); return; } //解析獲取property的值 Object val = parsePropertyValue(ele, bd, propertyName); //根據property的名字和值創建property實例 PropertyValue pv = new PropertyValue(propertyName, val); //解析<property>元素中的屬性 parseMetaElements(ele, pv); pv.setSource(extractSource(ele)); bd.getPropertyValues().addPropertyValue(pv); } finally { this.parseState.pop(); } } //解析獲取property值 public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) { String elementName = (propertyName != null) ? "<property> element for property '" + propertyName + "'" : "<constructor-arg> element"; //獲取<property>的所有子元素，只能是其中一種類型:ref,value,list等 NodeList nl = ele.getChildNodes(); Element subElement = null; for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); //子元素不是description和meta屬性 if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) && !nodeNameEquals(node, META_ELEMENT)) { if (subElement != null) { error(elementName + " must not contain more than one sub-element", ele); } else {//當前<property>元素包含有子元素 subElement = (Element) node; } } } //判斷property的屬性值是ref還是value，不允許既是ref又是value boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE); boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE); if ((hasRefAttribute && hasValueAttribute) || ((hasRefAttribute || hasValueAttribute) && subElement != null)) { error(elementName + " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele); } //如果屬性是ref，創建一個ref的數據對象RuntimeBeanReference，這個對象 //封裝了ref信息 if (hasRefAttribute) { String refName = ele.getAttribute(REF_ATTRIBUTE); if (!StringUtils.hasText(refName)) { error(elementName + " contains empty 'ref' attribute", ele); } //一個指向運行時所依賴對象的引用 RuntimeBeanReference ref = new RuntimeBeanReference(refName); //設置這個ref的數據對象是被當前的property對象所引用 ref.setSource(extractSource(ele)); return ref; } //如果屬性是value，創建一個value的數據對象TypedStringValue，這個對象 //封裝了value信息 else if (hasValueAttribute) { //一個持有String類型值的對象 TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE)); //設置這個value數據對象是被當前的property對象所引用 valueHolder.setSource(extractSource(ele)); return valueHolder; } //如果當前<property>元素還有子元素 else if (subElement != null) { //解析<property>的子元素 return parsePropertySubElement(subElement, bd); } else { //propery屬性中既不是ref，也不是value屬性，解析出錯返回null error(elementName + " must specify a ref or value", ele); return null; } }

通過對上述源碼的分析，我們可以了解在Spring配置文件中，<Bean>元素中<property>元素的相關配置是如何處理的：

a. ref被封裝為指向依賴對象一個引用。

b.value配置都會封裝成一個字符串類型的對象。

c.ref和value都通過“解析的數據類型屬性值.setSource(extractSource(ele));”方法將屬性值/引用與所引用的屬性關聯起來。

在方法的最后對于<property>元素的子元素通過parsePropertySubElement 方法解析，我們繼續分析該方法的源碼，了解其解析過程。

14、解析<property>元素的子元素：

在BeanDefinitionParserDelegate類中的parsePropertySubElement方法對<property>中的子元素解析，源碼如下：

//解析<property>元素中ref,value或者集合等子元素 public Object parsePropertySubElement(Element ele, BeanDefinition bd, String defaultValueType) { //如果<property>沒有使用Spring默認的命名空間，則使用用戶自定義的規則解析//內嵌元素 if (!isDefaultNamespace(ele)) { return parseNestedCustomElement(ele, bd); } //如果子元素是bean，則使用解析<Bean>元素的方法解析 else if (nodeNameEquals(ele, BEAN_ELEMENT)) { BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd); if (nestedBd != null) { nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd); } return nestedBd; } //如果子元素是ref，ref中只能有以下3個屬性：bean、local、parent else if (nodeNameEquals(ele, REF_ELEMENT)) { //獲取<property>元素中的bean屬性值，引用其他解析的Bean的名稱 //可以不再同一個Spring配置文件中，具體請參考Spring對ref的配置規則 String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE); boolean toParent = false; if (!StringUtils.hasLength(refName)) { //獲取<property>元素中的local屬性值，引用同一個Xml文件中配置 //的Bean的id，local和ref不同，local只能引用同一個配置文件中的Bean refName = ele.getAttribute(LOCAL_REF_ATTRIBUTE); if (!StringUtils.hasLength(refName)) { //獲取<property>元素中parent屬性值，引用父級容器中的Bean refName = ele.getAttribute(PARENT_REF_ATTRIBUTE); toParent = true; if (!StringUtils.hasLength(refName)) { error("'bean', 'local' or 'parent' is required for <ref> element", ele); return null; } } } //沒有配置ref的目標屬性值 if (!StringUtils.hasText(refName)) { error("<ref> element contains empty target attribute", ele); return null; } //創建ref類型數據，指向被引用的對象 RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent); //設置引用類型值是被當前子元素所引用 ref.setSource(extractSource(ele)); return ref; } //如果子元素是<idref>，使用解析ref元素的方法解析 else if (nodeNameEquals(ele, IDREF_ELEMENT)) { return parseIdRefElement(ele); } //如果子元素是<value>，使用解析value元素的方法解析 else if (nodeNameEquals(ele, VALUE_ELEMENT)) { return parseValueElement(ele, defaultValueType); } //如果子元素是null，為<property>設置一個封裝null值的字符串數據 else if (nodeNameEquals(ele, NULL_ELEMENT)) { TypedStringValue nullHolder = new TypedStringValue(null); nullHolder.setSource(extractSource(ele)); return nullHolder; } //如果子元素是<array>，使用解析array集合子元素的方法解析 else if (nodeNameEquals(ele, ARRAY_ELEMENT)) { return parseArrayElement(ele, bd); } //如果子元素是<list>，使用解析list集合子元素的方法解析 else if (nodeNameEquals(ele, LIST_ELEMENT)) { return parseListElement(ele, bd); } //如果子元素是<set>，使用解析set集合子元素的方法解析 else if (nodeNameEquals(ele, SET_ELEMENT)) { return parseSetElement(ele, bd); } //如果子元素是<map>，使用解析map集合子元素的方法解析 else if (nodeNameEquals(ele, MAP_ELEMENT)) { return parseMapElement(ele, bd); } //如果子元素是<props>，使用解析props集合子元素的方法解析 else if (nodeNameEquals(ele, PROPS_ELEMENT)) { return parsePropsElement(ele); } //既不是ref，又不是value，也不是集合，則子元素配置錯誤，返回null else { error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele); return null; } }

通過上述源碼分析，我們明白了在Spring配置文件中，對<property>元素中配置的Array、List、Set、Map、Prop等各種集合子元素的都通過上述方法解析，生成對應的數據對象，比如ManagedList、ManagedArray、ManagedSet等，這些Managed類是Spring對象BeanDefiniton的數據封裝，對集合數據類型的具體解析有各自的解析方法實現，解析方法的命名非常規范，一目了然，我們對<list>集合元素的解析方法進行源碼分析，了解其實現過程。

15、解析<list>子元素：

在BeanDefinitionParserDelegate類中的parseListElement方法就是具體實現解析<property>元素中的<list>集合子元素，源碼如下：

//解析<list>集合子元素 public List parseListElement(Element collectionEle, BeanDefinition bd) { //獲取<list>元素中的value-type屬性，即獲取集合元素的數據類型 String defaultElementType = collectionEle.getAttribute(VALUE_TYPE_ATTRIBUTE); //獲取<list>集合元素中的所有子節點 NodeList nl = collectionEle.getChildNodes(); //Spring中將List封裝為ManagedList ManagedList<Object> target = new ManagedList<Object>(nl.getLength()); target.setSource(extractSource(collectionEle)); //設置集合目標數據類型 target.setElementTypeName(defaultElementType); target.setMergeEnabled(parseMergeAttribute(collectionEle)); //具體的<list>元素解析 parseCollectionElements(nl, target, bd, defaultElementType); return target; } //具體解析<list>集合元素，<array>、<list>和<set>都使用該方法解析 protected void parseCollectionElements( NodeList elementNodes, Collection<Object> target, BeanDefinition bd, String defaultElementType) { //遍歷集合所有節點 for (int i = 0; i < elementNodes.getLength(); i++) { Node node = elementNodes.item(i); //節點不是description節點 if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT)) { //將解析的元素加入集合中，遞歸調用下一個子元素 target.add(parsePropertySubElement((Element) node, bd, defaultElementType)); } } }

經過對Spring Bean定義資源文件轉換的Document對象中的元素層層解析，Spring IoC現在已經將XML形式定義的Bean定義資源文件轉換為Spring IoC所識別的數據結構——BeanDefinition，它是Bean定義資源文件中配置的POJO對象在Spring IoC容器中的映射，我們可以通過AbstractBeanDefinition為入口，榮IoC容器進行索引、查詢和操作。

通過Spring IoC容器對Bean定義資源的解析后，IoC容器大致完成了管理Bean對象的準備工作，即初始化過程，但是最為重要的依賴注入還沒有發生，現在在IoC容器中BeanDefinition存儲的只是一些靜態信息，接下來需要向容器注冊Bean定義信息才能全部完成IoC容器的初始化過程

##16、解析過后的BeanDefinition在IoC容器中的注冊：

讓我們繼續跟蹤程序的執行順序，接下來會到我們第3步中分析DefaultBeanDefinitionDocumentReader對Bean定義轉換的Document對象解析的流程中，在其parseDefaultElement方法中完成對Document對象的解析后得到封裝BeanDefinition的BeanDefinitionHold對象，然后調用BeanDefinitionReaderUtils的registerBeanDefinition方法向IoC容器注冊解析的Bean，BeanDefinitionReaderUtils的注冊的源碼如下：

//將解析的BeanDefinitionHold注冊到容器中 public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException { //獲取解析的BeanDefinition的名稱String beanName = definitionHolder.getBeanName(); //向IoC容器注冊BeanDefinition registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition()); //如果解析的BeanDefinition有別名，向容器為其注冊別名 String[] aliases = definitionHolder.getAliases(); if (aliases != null) { for (String aliase : aliases) { registry.registerAlias(beanName, aliase); } } }

當調用BeanDefinitionReaderUtils向IoC容器注冊解析的BeanDefinition時，真正完成注冊功能的是DefaultListableBeanFactory。

17、DefaultListableBeanFactory向IoC容器注冊解析后的BeanDefinition：

DefaultListableBeanFactory中使用一個HashMap的集合對象存放IoC容器中注冊解析的BeanDefinition，向IoC容器注冊的主要源碼如下：

//存儲注冊的俄BeanDefinition private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(); //向IoC容器注冊解析的BeanDefiniton public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException { Assert.hasText(beanName, "Bean name must not be empty"); Assert.notNull(beanDefinition, "BeanDefinition must not be null"); //校驗解析的BeanDefiniton if (beanDefinition instanceof AbstractBeanDefinition) { try { ((AbstractBeanDefinition) beanDefinition).validate(); } catch (BeanDefinitionValidationException ex) { throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", ex); } } //注冊的過程中需要線程同步，以保證數據的一致性 synchronized (this.beanDefinitionMap) { Object oldBeanDefinition = this.beanDefinitionMap.get(beanName); //檢查是否有同名的BeanDefinition已經在IoC容器中注冊，如果已經注冊， //并且不允許覆蓋已注冊的Bean，則拋出注冊失敗異常 if (oldBeanDefinition != null) { if (!this.allowBeanDefinitionOverriding) { throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName + "': There is already [" + oldBeanDefinition + "] bound."); } else {//如果允許覆蓋，則同名的Bean，后注冊的覆蓋先注冊的 if (this.logger.isInfoEnabled()) { this.logger.info("Overriding bean definition for bean '" + beanName + "': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]"); } } } //IoC容器中沒有已經注冊同名的Bean，按正常注冊流程注冊 else { this.beanDefinitionNames.add(beanName); this.frozenBeanDefinitionNames = null; } this.beanDefinitionMap.put(beanName, beanDefinition); //重置所有已經注冊過的BeanDefinition的緩存 resetBeanDefinition(beanName); } }

至此，Bean定義資源文件中配置的Bean被解析過后，已經注冊到IoC容器中，被容器管理起來，真正完成了IoC容器初始化所做的全部工作。現 在IoC容器中已經建立了整個Bean的配置信息，這些BeanDefinition信息已經可以使用，并且可以被檢索，IoC容器的作用就是對這些注冊的Bean定義信息進行處理和維護。這些的注冊的Bean定義信息是IoC容器控制反轉的基礎，正是有了這些注冊的數據，容器才可以進行依賴注入。

總結：

現在通過上面的代碼，總結一下IOC容器初始化的基本步驟：

u 初始化的入口在容器實現中的 refresh()調用來完成

u 對 bean 定義載入 IOC 容器使用的方法是 loadBeanDefinition,其中的大致過程如下：通過 ResourceLoader 來完成資源文件位置的定位，DefaultResourceLoader 是默認的實現，同時上下文本身就給出了 ResourceLoader 的實現，可以從類路徑，文件系統, URL 等方式來定為資源位置。如果是 XmlBeanFactory作為 IOC 容器，那么需要為它指定 bean 定義的資源，也就是說 bean 定義文件時通過抽象成 Resource 來被 IOC 容器處理的，容器通過 BeanDefinitionReader來完成定義信息的解析和 Bean 信息的注冊,往往使用的是XmlBeanDefinitionReader 來解析 bean 的 xml 定義文件 - 實際的處理過程是委托給 BeanDefinitionParserDelegate 來完成的，從而得到 bean 的定義信息，這些信息在 Spring 中使用 BeanDefinition 對象來表示 - 這個名字可以讓我們想到loadBeanDefinition,RegisterBeanDefinition 這些相關的方法 - 他們都是為處理 BeanDefinitin 服務的， 容器解析得到 BeanDefinitionIoC 以后，需要把它在 IOC 容器中注冊，這由 IOC 實現 BeanDefinitionRegistry 接口來實現。注冊過程就是在 IOC 容器內部維護的一個HashMap 來保存得到的 BeanDefinition 的過程。這個 HashMap 是 IoC 容器持有 bean 信息的場所，以后對 bean 的操作都是圍繞這個HashMap 來實現的.

u 然后我們就可以通過 BeanFactory 和 ApplicationContext 來享受到 Spring IOC 的服務了,在使用 IOC 容器的時候，我們注意到除了少量粘合代碼，絕大多數以正確 IoC 風格編寫的應用程序代碼完全不用關心如何到達工廠，因為容器將把這些對象與容器管理的其他對象鉤在一起。基本的策略是把工廠放到已知的地方，最好是放在對預期使用的上下文有意義的地方，以及代碼將實際需要訪問工廠的地方。 Spring 本身提供了對聲明式載入 web 應用程序用法的應用程序上下文,并將其存儲在ServletContext 中的框架實現。具體可以參見以后的文章

在使用 Spring IOC 容器的時候我們還需要區別兩個概念:

Beanfactory 和 Factory bean，其中 BeanFactory 指的是 IOC 容器的編程抽象，比如 ApplicationContext， XmlBeanFactory 等，這些都是 IOC 容器的具體表現，需要使用什么樣的容器由客戶決定,但 Spring 為我們提供了豐富的選擇。 FactoryBean 只是一個可以在 IOC而容器中被管理的一個 bean,是對各種處理過程和資源使用的抽象,Factory bean 在需要時產生另一個對象，而不返回 FactoryBean本身,我們可以把它看成是一個抽象工廠，對它的調用返回的是工廠生產的產品。所有的 Factory bean 都實現特殊的org.springframework.beans.factory.FactoryBean 接口，當使用容器中 factory bean 的時候，該容器不會返回 factory bean 本身,而是返回其生成的對象。Spring 包括了大部分的通用資源和服務訪問抽象的 Factory bean 的實現，其中包括:對 JNDI 查詢的處理，對代理對象的處理，對事務性代理的處理，對 RMI 代理的處理等，這些我們都可以看成是具體的工廠,看成是SPRING 為我們建立好的工廠。也就是說 Spring 通過使用抽象工廠模式為我們準備了一系列工廠來生產一些特定的對象,免除我們手工重復的工作，我們要使用時只需要在 IOC 容器里配置好就能很方便的使用了

四、IOC容器的依賴注入

轉載于:https://my.oschina.net/u/3421984/blog/1624443

總結

以上是生活随笔為你收集整理的Spring：源码解读Spring IOC原理的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。