轉(zhuǎn)自：https://javadoop.com/post/spring-ioc

Spring 最重要的概念是 IOC 和 AOP，本篇文章其實(shí)就是要帶領(lǐng)大家來(lái)分析下 Spring 的 IOC 容器匾旭。既然大家平時(shí)都要用到 Spring，怎么可以不好好了解 Spring 呢？閱讀本文并不能讓你成為 Spring 專家太惠，不過(guò)一定有助于大家理解 Spring 的很多概念唠叛，幫助大家排查應(yīng)用中和 Spring 相關(guān)的一些問(wèn)題改备。

閱讀建議：讀者至少需要知道怎么配置 Spring，了解 Spring 中的各種概念下梢，少部分內(nèi)容我還假設(shè)讀者使用過(guò) SpringMVC。本文要說(shuō)的 IOC 總體來(lái)說(shuō)有兩處地方最重要塞蹭，一個(gè)是創(chuàng)建 Bean 容器（DefaultListableBeanFactory）孽江，一個(gè)是初始化 Bean（doCreateBean），如果讀者覺(jué)得一次性看完本文壓力有點(diǎn)大番电，那么可以按這個(gè)思路分兩次消化岗屏。讀者不一定對(duì) Spring 容器的源碼感興趣辆琅，也許附錄部分介紹的知識(shí)對(duì)讀者有些許作用。

我采用的源碼版本是 4.3.11.RELEASE这刷，算是 5.0.x 前比較新的版本了婉烟。為了降低難度，本文所說(shuō)的所有的內(nèi)容都是基于 xml 的配置的方式暇屋，實(shí)際使用已經(jīng)很少人這么做了，至少不是純 xml 配置咐刨，不過(guò)從理解源碼的角度來(lái)看用這種方式來(lái)說(shuō)無(wú)疑是最合適的叔营。如果讀者對(duì)注解方式的源碼感興趣，也許等我有時(shí)間的時(shí)候可以寫(xiě)篇文章介紹介紹所宰。

我希望能將此文寫(xiě)成一篇 Spring IOC 源碼分析的好文章绒尊，希望通過(guò)本文可以讓讀者不懼怕閱讀 Spring 源碼。

為了保持文章的嚴(yán)謹(jǐn)性仔粥，如果讀者發(fā)現(xiàn)我哪里說(shuō)錯(cuò)了請(qǐng)一定不吝指出婴谱，非常希望可以聽(tīng)到讀者的聲音。

引言

先看下最基本的啟動(dòng) Spring 容器的例子：

public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationfile.xml");
}

以上代碼就可以利用配置文件來(lái)啟動(dòng)一個(gè) Spring 容器了躯泰，請(qǐng)使用 maven 的小伙伴直接在 dependencies 中加上以下依賴即可谭羔，我比較反對(duì)那些不知道要添加什么依賴，然后把 Spring 的所有相關(guān)的東西都加進(jìn)來(lái)的方式麦向。

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>4.3.11.RELEASE</version>
</dependency>

spring-context 會(huì)自動(dòng)將 spring-core瘟裸、spring-beans、spring-aop诵竭、spring-expression 這幾個(gè)基礎(chǔ) jar 包帶進(jìn)來(lái)话告。
多說(shuō)一句，很多開(kāi)發(fā)者入門(mén)就直接接觸的 SpringMVC卵慰，對(duì) Spring 其實(shí)不是很了解沙郭，Spring 是漸進(jìn)式的工具，并不具有很強(qiáng)的侵入性裳朋，它的模塊也劃分得很合理病线，即使你的應(yīng)用不是 web 應(yīng)用，或者之前完全沒(méi)有使用到 Spring鲤嫡，而你就想用 Spring 的依賴注入這個(gè)功能送挑，其實(shí)完全是可以的，它的引入不會(huì)對(duì)其他的組件產(chǎn)生沖突暖眼。

廢話說(shuō)完惕耕，我們繼續(xù)。ApplicationContext context = new ClassPathXmlApplicationContext(…) 其實(shí)很好理解罢荡，從名字上就可以猜出一二赡突，就是在 ClassPath 中尋找 xml 配置文件对扶，根據(jù) xml 文件內(nèi)容來(lái)構(gòu)建 ApplicationContext。當(dāng)然惭缰，除了 ClassPathXmlApplicationContext 以外浪南，我們也還有其他構(gòu)建 ApplicationContext 的方案可供選擇，我們先來(lái)看看大體的繼承結(jié)構(gòu)是怎么樣的：

ApplicationContext.png

讀者可以大致看一下類名漱受，源碼分析的時(shí)候不至于找不著看哪個(gè)類络凿，因?yàn)?Spring 為了適應(yīng)各種使用場(chǎng)景，提供的各個(gè)接口都可能有很多的實(shí)現(xiàn)類昂羡。對(duì)于我們來(lái)說(shuō)絮记，就是揪著一個(gè)完整的分支看完。當(dāng)然虐先，讀本文的時(shí)候讀者也不必太擔(dān)心怨愤，每個(gè)代碼塊分析的時(shí)候，我都會(huì)告訴讀者我們?cè)谡f(shuō)哪個(gè)類第幾行蛹批。
我們可以看到撰洗，ClassPathXmlApplicationContext 兜兜轉(zhuǎn)轉(zhuǎn)了好久才到 ApplicationContext 接口，同樣的腐芍，我們也可以使用綠顏色的 FileSystemXmlApplicationContext 和 AnnotationConfigApplicationContext 這兩個(gè)類差导。

FileSystemXmlApplicationContext 的構(gòu)造函數(shù)需要一個(gè) xml 配置文件在系統(tǒng)中的路徑，其他和 ClassPathXmlApplicationContext 基本上一樣猪勇。

AnnotationConfigApplicationContext 是基于注解來(lái)使用的设褐，它不需要配置文件，采用 java 配置類和各種注解來(lái)配置泣刹，是比較簡(jiǎn)單的方式助析，也是大勢(shì)所趨吧。

不過(guò)本文旨在幫助大家理解整個(gè)構(gòu)建流程项玛，所以決定使用 ClassPathXmlApplicationContext 進(jìn)行分析貌笨。

我們先來(lái)一個(gè)簡(jiǎn)單的例子來(lái)看看怎么實(shí)例化 ApplicationContext。

首先襟沮，定義一個(gè)接口：

public interface MessageService {
    String getMessage();
}

定義接口實(shí)現(xiàn)類：

public class MessageServiceImpl implements MessageService {
 
    public String getMessage() {
        return "hello world";
    }
}

接下來(lái)，我們?cè)?resources 目錄新建一個(gè)配置文件昌腰，文件名隨意开伏，通常叫 application.xml 或 application-xxx.xml就可以了：

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd" default-autowire="byName">
 
    <bean id="messageService" class="com.javadoop.example.MessageServiceImpl"/>
</beans>

這樣，我們就可以跑起來(lái)了：

public class App {
    public static void main(String[] args) {
        // 用我們的配置文件來(lái)啟動(dòng)一個(gè) ApplicationContext
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:application.xml");
 
        System.out.println("context 啟動(dòng)成功");
 
        // 從 context 中取出我們的 Bean遭商，而不是用 new MessageServiceImpl() 這種方式
        MessageService messageService = context.getBean(MessageService.class);
        // 這句將輸出: hello world
        System.out.println(messageService.getMessage());
    }
}

以上例子很簡(jiǎn)單固灵，不過(guò)也夠引出本文的主題了，就是怎么樣通過(guò)配置文件來(lái)啟動(dòng) Spring 的 ApplicationContext劫流？也就是我們今天要分析的 IOC 的核心了巫玻。ApplicationContext 啟動(dòng)過(guò)程中丛忆，會(huì)負(fù)責(zé)創(chuàng)建實(shí)例 Bean，往各個(gè) Bean 中注入依賴等仍秤。

BeanFactory 簡(jiǎn)介

初學(xué)者可別以為我之前說(shuō)那么多和 BeanFactory 無(wú)關(guān)熄诡，前面說(shuō)的 ApplicationContext 其實(shí)就是一個(gè) BeanFactory。我們來(lái)看下和 BeanFactory 接口相關(guān)的主要的繼承結(jié)構(gòu)：

BeanFactory.png

我想诗力，大家看完這個(gè)圖以后凰浮，可能就不是很開(kāi)心了。ApplicationContext 往下的繼承結(jié)構(gòu)前面一張圖說(shuō)過(guò)了苇本，這里就不重復(fù)了袜茧。這張圖呢，背下來(lái)肯定是不需要的瓣窄，有幾個(gè)重點(diǎn)和大家說(shuō)明下就好笛厦。

ApplicationContext 繼承了 ListableBeanFactory，這個(gè) Listable 的意思就是俺夕，通過(guò)這個(gè)接口裳凸，我們可以獲取多個(gè) Bean，最頂層 BeanFactory 接口的方法都是獲取單個(gè) Bean 的啥么。
ApplicationContext 繼承了 HierarchicalBeanFactory登舞，Hierarchical 單詞本身已經(jīng)能說(shuō)明問(wèn)題了，也就是說(shuō)我們可以在應(yīng)用中起多個(gè) BeanFactory悬荣，然后可以將各個(gè) BeanFactory 設(shè)置為父子關(guān)系菠秒。
AutowireCapableBeanFactory 這個(gè)名字中的 Autowire 大家都非常熟悉，它就是用來(lái)自動(dòng)裝配 Bean 用的氯迂，但是仔細(xì)看上圖践叠，ApplicationContext 并沒(méi)有繼承它，不過(guò)不用擔(dān)心嚼蚀，不使用繼承禁灼，不代表不可以使用組合，如果你看到 ApplicationContext 接口定義中的最后一個(gè)方法 getAutowireCapableBeanFactory() 就知道了轿曙。
ConfigurableListableBeanFactory 也是一個(gè)特殊的接口弄捕，看圖，特殊之處在于它繼承了第二層所有的三個(gè)接口导帝，而 ApplicationContext 沒(méi)有守谓。這點(diǎn)之后會(huì)用到。
請(qǐng)先不用花時(shí)間在其他的接口和類上您单，先理解我說(shuō)的這幾點(diǎn)就可以了斋荞。
然后，請(qǐng)讀者打開(kāi)編輯器虐秦，翻一下 BeanFactory平酿、ListableBeanFactory凤优、HierarchicalBeanFactory、AutowireCapableBeanFactory蜈彼、ApplicationContext 這幾個(gè)接口的代碼筑辨，大概看一下各個(gè)接口中的方法，大家心里要有底柳刮，限于篇幅挖垛，我就不貼代碼介紹了。

啟動(dòng)過(guò)程分析

下面將會(huì)是冗長(zhǎng)的代碼分析秉颗，請(qǐng)讀者先喝個(gè)水痢毒。記住，一定要在電腦中打開(kāi)源碼蚕甥，不然純看是很累的哪替。

第一步，我們肯定要從 ClassPathXmlApplicationContext 的構(gòu)造方法說(shuō)起菇怀。

public class ClassPathXmlApplicationContext extends AbstractXmlApplicationContext {
  // 將配置文件作為資源都存放到這個(gè)數(shù)組中
  private Resource[] configResources;
 
  // 如果已經(jīng)有 ApplicationContext 并需要配置成父子關(guān)系凭舶，那么調(diào)用這個(gè)構(gòu)造方法
  public ClassPathXmlApplicationContext(ApplicationContext parent) {
    super(parent);
  }
  ...
  public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
      throws BeansException {
 
    super(parent);
     // 解析配置文件列表，放置到上面說(shuō)的那個(gè) configResources 數(shù)組中
    setConfigLocations(configLocations);
    if (refresh) {
      refresh(); // 核心方法
    }
  }
    ...
}

接下來(lái)爱沟，就是 refresh()帅霜，這里簡(jiǎn)單說(shuō)下為什么是 refresh()，而不是 init() 這種名字的方法呼伸。因?yàn)?ApplicationContext 建立起來(lái)以后身冀，其實(shí)我們是可以通過(guò)調(diào)用 refresh() 這個(gè)方法重建的，這樣會(huì)將原來(lái)的 ApplicationContext 銷毀括享，然后再重新執(zhí)行一次初始化操作搂根。

往下看，refresh() 方法里面調(diào)用了那么多方法铃辖，就知道肯定不簡(jiǎn)單了剩愧，請(qǐng)讀者先看個(gè)大概，細(xì)節(jié)之后會(huì)詳細(xì)說(shuō)娇斩。

@Override
public void refresh() throws BeansException, IllegalStateException {
   // 來(lái)個(gè)鎖仁卷，不然 refresh() 還沒(méi)結(jié)束，你又來(lái)個(gè)啟動(dòng)或銷毀容器的操作犬第，那不就亂套了嘛
   synchronized (this.startupShutdownMonitor) {
 
      // 準(zhǔn)備工作五督，記錄下容器的啟動(dòng)時(shí)間、標(biāo)記“已啟動(dòng)”狀態(tài)瓶殃、處理配置文件中的占位符
      prepareRefresh();
 
      // 這步比較關(guān)鍵，這步完成后副签，配置文件就會(huì)解析成一個(gè)個(gè) Bean 定義遥椿，注冊(cè)到 BeanFactory 中基矮，
      // 當(dāng)然，這里說(shuō)的 Bean 還沒(méi)有初始化冠场，只是配置信息都提取出來(lái)了家浇，
      // 注冊(cè)也只是將這些信息都保存到了注冊(cè)中心(說(shuō)到底核心是一個(gè) beanName-> beanDefinition 的 map)
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 
      // 設(shè)置 BeanFactory 的類加載器，添加幾個(gè) BeanPostProcessor碴裙，手動(dòng)注冊(cè)幾個(gè)特殊的 bean
      // 這塊待會(huì)會(huì)展開(kāi)說(shuō)
      prepareBeanFactory(beanFactory);
 
      try {
         // 【這里需要知道 BeanFactoryPostProcessor 這個(gè)知識(shí)點(diǎn)钢悲，Bean 如果實(shí)現(xiàn)了此接口，
         // 那么在容器初始化以后舔株，Spring 會(huì)負(fù)責(zé)調(diào)用里面的 postProcessBeanFactory 方法莺琳。】
         // 這里是提供給子類的擴(kuò)展點(diǎn)载慈，到這里的時(shí)候惭等，所有的 Bean 都加載、注冊(cè)完成了办铡，但是都還沒(méi)有初始化
         // 具體的子類可以在這步的時(shí)候添加一些特殊的 BeanFactoryPostProcessor 的實(shí)現(xiàn)類或做點(diǎn)什么事
         postProcessBeanFactory(beanFactory);

         // 調(diào)用 BeanFactoryPostProcessor 各個(gè)實(shí)現(xiàn)類的 postProcessBeanFactory(factory) 方法
         invokeBeanFactoryPostProcessors(beanFactory);
 
         // 注冊(cè) BeanPostProcessor 的實(shí)現(xiàn)類辞做，注意看和 BeanFactoryPostProcessor 的區(qū)別
         // 此接口兩個(gè)方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
         // 兩個(gè)方法分別在 Bean 初始化之前和初始化之后得到執(zhí)行。注意寡具，到這里 Bean 還沒(méi)初始化
         registerBeanPostProcessors(beanFactory);
 
         // 初始化當(dāng)前 ApplicationContext 的 MessageSource秤茅，國(guó)際化這里就不展開(kāi)說(shuō)了，不然沒(méi)完沒(méi)了了
         initMessageSource();
 
         // 初始化當(dāng)前 ApplicationContext 的事件廣播器童叠，這里也不展開(kāi)了
         initApplicationEventMulticaster();
 
         // 從方法名就可以知道框喳，典型的模板方法(鉤子方法)，
         // 具體的子類可以在這里初始化一些特殊的 Bean（在初始化 singleton beans 之前）
         onRefresh();
 
         // 注冊(cè)事件監(jiān)聽(tīng)器拯钻，監(jiān)聽(tīng)器需要實(shí)現(xiàn) ApplicationListener 接口帖努。這也不是我們的重點(diǎn)，過(guò)
         registerListeners();
 
         // 重點(diǎn)粪般，重點(diǎn)拼余，重點(diǎn)
         // 初始化所有的 singleton beans
         //（lazy-init 的除外）
         finishBeanFactoryInitialization(beanFactory);
 
         // 最后，廣播事件亩歹，ApplicationContext 初始化完成
         finishRefresh();
      }
 
      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }
 
         // Destroy already created singletons to avoid dangling resources.
         // 銷毀已經(jīng)初始化的 singleton 的 Beans匙监，以免有些 bean 會(huì)一直占用資源
         destroyBeans();
 
         // Reset 'active' flag.
         cancelRefresh(ex);
 
         // 把異常往外拋
         throw ex;
      }
 
      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...
         resetCommonCaches();
      }
   }
}

下面，我們開(kāi)始一步步來(lái)肢解這個(gè) refresh() 方法小作。

創(chuàng)建 Bean 容器前的準(zhǔn)備工作

這個(gè)比較簡(jiǎn)單亭姥，直接看代碼中的幾個(gè)注釋即可。

protected void prepareRefresh() {
   // 記錄啟動(dòng)時(shí)間顾稀，
   // 將 active 屬性設(shè)置為 true达罗，closed 屬性設(shè)置為 false，它們都是 AtomicBoolean 類型
   this.startupDate = System.currentTimeMillis();
   this.closed.set(false);
   this.active.set(true);
 
   if (logger.isInfoEnabled()) {
      logger.info("Refreshing " + this);
   }
 
   // Initialize any placeholder property sources in the context environment
   initPropertySources();
 
   // 校驗(yàn) xml 配置文件
   getEnvironment().validateRequiredProperties();
 
   this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
}

創(chuàng)建 Bean 容器，加載粮揉、解析巡李、注冊(cè) Bean

注意，這個(gè)方法是全文最重要的部分之一扶认，這里將會(huì)初始化 BeanFactory侨拦、加載 Bean、注冊(cè) Bean 等等辐宾。

當(dāng)然狱从，這步結(jié)束后，Bean 并沒(méi)有完成初始化叠纹。

創(chuàng)建 Bean 容器

// AbstractApplicationContext.java

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   // 關(guān)閉舊的 BeanFactory (如果有)季研，創(chuàng)建新的 BeanFactory，加載 Bean 定義吊洼、注冊(cè) Bean 等等
   refreshBeanFactory();
 
   // 返回剛剛創(chuàng)建的 BeanFactory
   ConfigurableListableBeanFactory beanFactory = getBeanFactory();
   if (logger.isDebugEnabled()) {
      logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
   }
   return beanFactory;
}

// AbstractRefreshableApplicationContext.java 120

@Override
protected final void refreshBeanFactory() throws BeansException {
   // 如果 ApplicationContext 中已經(jīng)加載過(guò) BeanFactory 了训貌，銷毀所有 Bean，關(guān)閉 BeanFactory
   // 注意冒窍，應(yīng)用中 BeanFactory 本來(lái)就是可以多個(gè)的递沪，這里可不是說(shuō)應(yīng)用全局是否有 BeanFactory，而是當(dāng)前
   // ApplicationContext 是否有 BeanFactory
   if (hasBeanFactory()) {
      destroyBeans();
      closeBeanFactory();
   }
   try {
      // 初始化一個(gè) DefaultListableBeanFactory综液，為什么用這個(gè)款慨，我們馬上說(shuō)。
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      // 用于 BeanFactory 的序列化谬莹，我想不部分人應(yīng)該都用不到
      beanFactory.setSerializationId(getId());
 
      // 下面這兩個(gè)方法很重要檩奠，別跟丟了，具體細(xì)節(jié)之后說(shuō)
      // 設(shè)置 BeanFactory 的兩個(gè)配置屬性：是否允許 Bean 覆蓋附帽、是否允許循環(huán)引用
      customizeBeanFactory(beanFactory);
 
      // 加載 Bean 到 BeanFactory 中
      loadBeanDefinitions(beanFactory);
      synchronized (this.beanFactoryMonitor) {
         this.beanFactory = beanFactory;
      }
   }
   catch (IOException ex) {
      throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
   }
}

看到這里的時(shí)候埠戳，我覺(jué)得讀者就應(yīng)該站在高處看 ApplicationContext 了，ApplicationContext 繼承自 BeanFactory蕉扮，但是它不應(yīng)該被理解為 BeanFactory 的實(shí)現(xiàn)類整胃，而是說(shuō)其內(nèi)部持有一個(gè)實(shí)例化的 BeanFactory（DefaultListableBeanFactory）。以后所有的 BeanFactory 相關(guān)的操作其實(shí)是給這個(gè)實(shí)例來(lái)處理的喳钟。
我們說(shuō)說(shuō)為什么選擇實(shí)例化 DefaultListableBeanFactory 屁使？前面我們說(shuō)了有個(gè)很重要的接口 ConfigurableListableBeanFactory，它實(shí)現(xiàn)了 BeanFactory 下面一層的所有三個(gè)接口奔则，我把之前的繼承圖再拿過(guò)來(lái)大家再仔細(xì)看一下：

DefaultListableBeanFactory.png

我們可以看到 ConfigurableListableBeanFactory 只有一個(gè)實(shí)現(xiàn)類 DefaultListableBeanFactory蛮寂，而且實(shí)現(xiàn)類 DefaultListableBeanFactory 還通過(guò)實(shí)現(xiàn)右邊的 AbstractAutowireCapableBeanFactory 通吃了右路。所以結(jié)論就是易茬，最底下這個(gè)家伙 DefaultListableBeanFactory 基本上是最牛的 BeanFactory 了酬蹋，這也是為什么這邊會(huì)使用這個(gè)類來(lái)實(shí)例化的原因。

在繼續(xù)往下之前，我們需要先了解 BeanDefinition除嘹。我們說(shuō) BeanFactory 是 Bean 容器写半，那么 Bean 又是什么呢？

這里的 BeanDefinition 就是我們所說(shuō)的 Spring 的 Bean尉咕，我們自己定義的各個(gè) Bean 其實(shí)會(huì)轉(zhuǎn)換成一個(gè)個(gè) BeanDefinition 存在于 Spring 的 BeanFactory 中。

所以璃岳，如果有人問(wèn)你 Bean 是什么的時(shí)候年缎，你要知道 Bean 在代碼層面上是 BeanDefinition 的實(shí)例。

BeanDefinition 中保存了我們的 Bean 信息铃慷，比如這個(gè) Bean 指向的是哪個(gè)類单芜、是否是單例的、是否懶加載犁柜、這個(gè) Bean 依賴了哪些 Bean 等等洲鸠。

BeanDefinition 接口定義

我們來(lái)看下 BeanDefinition 的接口定義：

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
 
   // 我們可以看到，默認(rèn)只提供 sington 和 prototype 兩種馋缅，
   // 很多讀者都知道還有 request, session, globalSession, application, websocket 這幾種扒腕，
   // 不過(guò)，它們屬于基于 web 的擴(kuò)展萤悴。
   String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
   String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
 
   // 比較不重要瘾腰，直接跳過(guò)吧
   int ROLE_APPLICATION = 0;
   int ROLE_SUPPORT = 1;
   int ROLE_INFRASTRUCTURE = 2;
 
   // 設(shè)置父 Bean，這里涉及到 bean 繼承覆履，不是 java 繼承蹋盆。請(qǐng)參見(jiàn)附錄介紹
   void setParentName(String parentName);
 
   // 獲取父 Bean
   String getParentName();
 
   // 設(shè)置 Bean 的類名稱
   void setBeanClassName(String beanClassName);
 
   // 獲取 Bean 的類名稱
   String getBeanClassName();
 
   // 設(shè)置 bean 的 scope
   void setScope(String scope);
 
   String getScope();
 
   // 設(shè)置是否懶加載
   void setLazyInit(boolean lazyInit);
 
   boolean isLazyInit();
 
   // 設(shè)置該 Bean 依賴的所有的 Bean，注意硝全，這里的依賴不是指屬性依賴(如 @Autowire 標(biāo)記的)栖雾，
   // 是 depends-on="" 屬性設(shè)置的值。
   void setDependsOn(String... dependsOn);
 
   // 返回該 Bean 的所有依賴
   String[] getDependsOn();
 
   // 設(shè)置該 Bean 是否可以注入到其他 Bean 中伟众，只對(duì)根據(jù)類型注入有效析藕，
   // 如果根據(jù)名稱注入，即使這邊設(shè)置了 false赂鲤，也是可以的
   void setAutowireCandidate(boolean autowireCandidate);
 
   // 該 Bean 是否可以注入到其他 Bean 中
   boolean isAutowireCandidate();
 
   // 主要的噪径。同一接口的多個(gè)實(shí)現(xiàn)，如果不指定名字的話数初，Spring 會(huì)優(yōu)先選擇設(shè)置 primary 為 true 的 bean
   void setPrimary(boolean primary);
 
   // 是否是 primary 的
   boolean isPrimary();
 
   // 如果該 Bean 采用工廠方法生成找爱，指定工廠名稱。對(duì)工廠不熟悉的讀者泡孩，請(qǐng)參加附錄
   void setFactoryBeanName(String factoryBeanName);

   // 獲取工廠名稱
   String getFactoryBeanName();

   // 指定工廠類中的 工廠方法名稱
   void setFactoryMethodName(String factoryMethodName);

   // 獲取工廠類中的 工廠方法名稱
   String getFactoryMethodName();
 
   // 構(gòu)造器參數(shù)
   ConstructorArgumentValues getConstructorArgumentValues();
 
   // Bean 中的屬性值车摄，后面給 bean 注入屬性值的時(shí)候會(huì)說(shuō)到
   MutablePropertyValues getPropertyValues();
 
   // 是否 singleton
   boolean isSingleton();
 
   // 是否 prototype
   boolean isPrototype();
 
   // 如果這個(gè) Bean 原生是抽象類，那么不能實(shí)例化
   boolean isAbstract();
 
   int getRole();
   String getDescription();
   String getResourceDescription();
   BeanDefinition getOriginatingBeanDefinition();
}

這個(gè) BeanDefinition 其實(shí)已經(jīng)包含很多的信息了，暫時(shí)不清楚所有的方法對(duì)應(yīng)什么東西沒(méi)關(guān)系吮播，希望看完本文后讀者可以徹底搞清楚里面的所有東西变屁。

這里接口雖然那么多，但是沒(méi)有類似 getInstance() 這種方法來(lái)獲取我們定義的類的實(shí)例意狠，真正的我們定義的類生成的實(shí)例到哪里去了呢粟关？別著急，這個(gè)要很后面才能講到环戈。
有了 BeanDefinition 的概念以后闷板，我們?cè)偻驴?refreshBeanFactory() 方法中的剩余部分：

customizeBeanFactory(beanFactory);
loadBeanDefinitions(beanFactory);

雖然只有兩個(gè)方法，但路還很長(zhǎng)啊院塞。遮晚。。

customizeBeanFactory(beanFactory) 比較簡(jiǎn)單拦止，就是配置是否允許 BeanDefinition 覆蓋县遣、是否允許循環(huán)引用。

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
   if (this.allowBeanDefinitionOverriding != null) {
      // 是否允許 Bean 定義覆蓋
      beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
   }
   if (this.allowCircularReferences != null) {
      // 是否允許 Bean 間的循環(huán)依賴
      beanFactory.setAllowCircularReferences(this.allowCircularReferences);
   }
}

BeanDefinition 的覆蓋
就是在配置文件中定義 bean 時(shí)使用了相同的 id 或 name汹族，默認(rèn)情況下萧求，allowBeanDefinitionOverriding 屬性為 null，如果在同一配置文件中重復(fù)了鞠抑，會(huì)拋錯(cuò)饭聚，但是如果不是同一配置文件中，會(huì)發(fā)生覆蓋搁拙。

循環(huán)引用
A 依賴 B秒梳，而 B 依賴 A』伲或 A 依賴 B青责，B 依賴 C荣月，而 C 依賴 A棍苹。

默認(rèn)情況下肤视，Spring 允許循環(huán)依賴，當(dāng)然如果你在 A 的構(gòu)造方法中依賴 B字柠，在 B 的構(gòu)造方法中依賴 A 是不行的探越。

至于這兩個(gè)屬性怎么配置？我在附錄中進(jìn)行了介紹窑业，尤其對(duì)于覆蓋問(wèn)題钦幔，很多人都希望禁止出現(xiàn) Bean 覆蓋，可是 Spring 默認(rèn)是不同文件的時(shí)候可以覆蓋的常柄。

之后的源碼中還會(huì)出現(xiàn)這兩個(gè)屬性鲤氢，讀者有個(gè)印象就可以了搀擂。

加載 Bean: loadBeanDefinitions(beanFactory)

接下來(lái)是最重要的 loadBeanDefinitions(beanFactory) 方法了，這個(gè)方法將根據(jù)配置卷玉，加載各個(gè) Bean哨颂，然后放到 BeanFactory 中。

讀取配置的操作在 XmlBeanDefinitionReader 中相种，其負(fù)責(zé)加載配置威恼、解析。

// AbstractXmlApplicationContext.java 80

/** 我們可以看到蚂子，此方法將通過(guò)一個(gè) XmlBeanDefinitionReader 實(shí)例來(lái)加載各個(gè) Bean沃测。*/
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
   // 給這個(gè) BeanFactory 實(shí)例化一個(gè) XmlBeanDefinitionReader
   XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
 
   // Configure the bean definition reader with this context's
   // resource loading environment.
   beanDefinitionReader.setEnvironment(this.getEnvironment());
   beanDefinitionReader.setResourceLoader(this);
   beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
 
   // 初始化 BeanDefinitionReader，其實(shí)這個(gè)是提供給子類覆寫(xiě)的（鉤子方法）食茎，
   // 我看了一下，沒(méi)有類覆寫(xiě)這個(gè)方法馏谨，我們姑且當(dāng)做不重要吧
   initBeanDefinitionReader(beanDefinitionReader);
   // 重點(diǎn)來(lái)了别渔，繼續(xù)往下
   loadBeanDefinitions(beanDefinitionReader);
}

現(xiàn)在還在這個(gè)類中，接下來(lái)用剛剛初始化的 Reader 開(kāi)始來(lái)加載 xml 配置惧互，這塊代碼讀者可以選擇性跳過(guò)哎媚，不是很重要。也就是說(shuō)喊儡，下面這個(gè)代碼塊拨与，讀者可以很輕松地略過(guò)。

// AbstractXmlApplicationContext.java 120

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
   Resource[] configResources = getConfigResources();
   if (configResources != null) {
      // 往下看
      reader.loadBeanDefinitions(configResources);
   }
   String[] configLocations = getConfigLocations();
   if (configLocations != null) {
      reader.loadBeanDefinitions(configLocations);
   }
}
 
// 上面雖然有兩個(gè)分支艾猜，不過(guò)第二個(gè)分支很快通過(guò)解析路徑轉(zhuǎn)換為 Resource 以后也會(huì)進(jìn)到這里
@Override
public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
   Assert.notNull(resources, "Resource array must not be null");
   int counter = 0;
   // 注意這里是個(gè) for 循環(huán)买喧，也就是每個(gè)文件是一個(gè) resource
   for (Resource resource : resources) {
      // 繼續(xù)往下看
      counter += loadBeanDefinitions(resource);
   }
   return counter;
}

// XmlBeanDefinitionReader 303

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

// XmlBeanDefinitionReader 314

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());
   }
   // 用一個(gè) ThreadLocal 來(lái)存放所有的配置文件資源
   Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
   if (currentResources == null) {
      currentResources = new HashSet<EncodedResource>(4);
      this.resourcesCurrentlyBeingLoaded.set(currentResources);
   }
   if (!currentResources.add(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();
      }
   }
}
 
// 還在這個(gè)文件中，第 388 行
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
      throws BeanDefinitionStoreException {
   try {
      // 這里就不看了
      Document doc = doLoadDocument(inputSource, resource);
      // 繼續(xù)
      return registerBeanDefinitions(doc, resource);
   }
   catch (...
}
// 還在這個(gè)文件中匆赃，第 505 行
// 返回從當(dāng)前配置文件加載了多少數(shù)量的 Bean
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
   BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
   int countBefore = getRegistry().getBeanDefinitionCount();
   documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
   return getRegistry().getBeanDefinitionCount() - countBefore;
}

// DefaultBeanDefinitionDocumentReader 90

@Override
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
   this.readerContext = readerContext;
   logger.debug("Loading bean definitions");
   Element root = doc.getDocumentElement();
   doRegisterBeanDefinitions(root);
}

解析bean

經(jīng)過(guò)漫長(zhǎng)的鏈路淤毛，一個(gè)配置文件終于轉(zhuǎn)換為一顆 DOM 樹(shù)了，注意算柳，這里指的是其中一個(gè)配置文件低淡，不是所有的，讀者可以看到上面有個(gè) for 循環(huán)的瞬项。下面從根節(jié)點(diǎn)開(kāi)始解析：

// DefaultBeanDefinitionDocumentReader 116

protected void doRegisterBeanDefinitions(Element root) {
   // 我們看名字就知道蔗蹋，BeanDefinitionParserDelegate 必定是一個(gè)重要的類，它負(fù)責(zé)解析 Bean 定義囱淋，
   // 這里為什么要定義一個(gè) parent? 看到后面就知道了猪杭，是遞歸問(wèn)題，
   // 因?yàn)?<beans /> 內(nèi)部是可以定義 <beans /> 的绎橘，所以這個(gè)方法的 root 其實(shí)不一定就是 xml 的根節(jié)點(diǎn)胁孙，
   //也可以是嵌套在里面的 <beans /> 節(jié)點(diǎn)唠倦，從源碼分析的角度，我們當(dāng)做根節(jié)點(diǎn)就好了
   BeanDefinitionParserDelegate parent = this.delegate;
   this.delegate = createDelegate(getReaderContext(), root, parent);
 
   if (this.delegate.isDefaultNamespace(root)) {
      // 這塊說(shuō)的是根節(jié)點(diǎn) <beans ... profile="dev" /> 中的 profile 是否是當(dāng)前環(huán)境需要的涮较，
      // 如果當(dāng)前環(huán)境配置的 profile 不包含此 profile稠鼻，那就直接 return 了，不對(duì)此 <beans /> 解析
      // 不熟悉 profile 為何物狂票，不熟悉怎么配置 profile 讀者的請(qǐng)移步附錄區(qū)
      String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
      if (StringUtils.hasText(profileSpec)) {
         String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
               profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
         if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
            if (logger.isInfoEnabled()) {
               logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                     "] not matching: " + getReaderContext().getResource());
            }
            return;
         }
      }
   }
 
   preProcessXml(root); // 鉤子
   parseBeanDefinitions(root, this.delegate);
   postProcessXml(root); // 鉤子
 
   this.delegate = parent;
}

這里涉及到了 profile 的問(wèn)題候齿，對(duì)于不了解的讀者，我在附錄中對(duì) profile 做了簡(jiǎn)單的解釋闺属，讀者可以參考一下慌盯。

接下來(lái)，看核心解析方法 parseBeanDefinitions(root, this.delegate) :

// default namespace 涉及到的就四個(gè)標(biāo)簽 <import />掂器、<alias />亚皂、<bean /> 和 <beans />，
// 其他的屬于 custom 的
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
   if (delegate.isDefaultNamespace(root)) {
      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;
            if (delegate.isDefaultNamespace(ele)) {
               parseDefaultElement(ele, delegate);
            }
            else {
               delegate.parseCustomElement(ele);
            }
         }
      }
   }
   else {
      delegate.parseCustomElement(root);
   }
}

從上面的代碼国瓮，我們可以看到灭必，對(duì)于每個(gè)配置來(lái)說(shuō)，分別進(jìn)入到 parseDefaultElement(ele, delegate); 和 delegate.parseCustomElement(ele); 這兩個(gè)分支了乃摹。

parseDefaultElement(ele, delegate) 代表解析的節(jié)點(diǎn)是 <import />禁漓、<alias />、<bean />孵睬、<beans /> 這幾個(gè)播歼。

這里的四個(gè)標(biāo)簽之所以是 default 的，是因?yàn)樗鼈兪翘幱谶@個(gè) namespace 下定義的：http://www.springframework.org/schema/beans

又到初學(xué)者科普時(shí)間掰读，不熟悉 namespace 的讀者請(qǐng)看下面貼出來(lái)的 xml秘狞，這里的第二行 xmlns 就是咯。

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd"
       default-autowire="byName">

而對(duì)于其他的標(biāo)簽磷支，將進(jìn)入到 delegate.parseCustomElement(element) 這個(gè)分支谒撼。如我們經(jīng)常會(huì)使用到的 <mvc />、<task />雾狈、<context />廓潜、<aop />等。

這些屬于擴(kuò)展善榛，如果需要使用上面這些 ”非 default“ 標(biāo)簽辩蛋，那么上面的 xml 頭部的地方也要引入相應(yīng)的 namespace 和 .xsd 文件的路徑，如下所示移盆。同時(shí)代碼中需要提供相應(yīng)的 parser 來(lái)解析悼院，如 MvcNamespaceHandler、TaskNamespaceHandler咒循、ContextNamespaceHandler据途、AopNamespaceHandler 等绞愚。

假如讀者想分析 <context:property-placeholder location=”classpath:xx.properties” /> 的實(shí)現(xiàn)原理，就應(yīng)該到 ContextNamespaceHandler 中找答案颖医。

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns="http://www.springframework.org/schema/beans"
      xmlns:context="http://www.springframework.org/schema/context"
      xmlns:mvc="http://www.springframework.org/schema/mvc"
      xsi:schemaLocation="
http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans.xsd 
http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-context.xsd 
http://www.springframework.org/schema/mvc 
http://www.springframework.org/schema/mvc/spring-mvc.xsd" 
default-autowire="byName">

回過(guò)神來(lái)位衩，看看處理 default 標(biāo)簽的方法：

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
   if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
      // 處理 <import /> 標(biāo)簽
      importBeanDefinitionResource(ele);
   }
   else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
      // 處理 <alias /> 標(biāo)簽定義
      // <alias name="fromName" alias="toName"/>
      processAliasRegistration(ele);
   }
   else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
      // 處理 <bean /> 標(biāo)簽定義，這也算是我們的重點(diǎn)吧
      processBeanDefinition(ele, delegate);
   }
   else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
      // 如果碰到的是嵌套的 <beans /> 標(biāo)簽熔萧，需要遞歸
      doRegisterBeanDefinitions(ele);
   }
}

如果每個(gè)標(biāo)簽都說(shuō)糖驴，那我不吐血，你們都要吐血了佛致。我們挑我們的重點(diǎn) <bean /> 標(biāo)簽出來(lái)說(shuō)贮缕。

processBeanDefinition

下面是 processBeanDefinition 解析 <bean /> 標(biāo)簽：

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
   // 將 <bean /> 節(jié)點(diǎn)中的信息提取出來(lái)，然后封裝到一個(gè) BeanDefinitionHolder 中俺榆，細(xì)節(jié)往下看
   BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
 
   // 下面的幾行先不要看感昼，跳過(guò)先，跳過(guò)先罐脊，跳過(guò)先抑诸，后面會(huì)繼續(xù)說(shuō)的
 
   if (bdHolder != null) {
      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
      try {
         // Register the final decorated instance.
         BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
      }
      catch (BeanDefinitionStoreException ex) {
         getReaderContext().error("Failed to register bean definition with name '" +
               bdHolder.getBeanName() + "'", ele, ex);
      }
      // Send registration event.
      getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
   }
}

繼續(xù)往下看怎么解析之前，我們先看下 <bean /> 標(biāo)簽中可以定義哪些屬性：

上面表格中的內(nèi)容我想大家都非常熟悉吧，如果不熟悉畔派，那就是你不夠了解 Spring 的配置了铅碍。

簡(jiǎn)單地說(shuō)就是像下面這樣子：

<bean id="exampleBean" name="name1, name2, name3" class="com.javadoop.ExampleBean"
      scope="singleton" lazy-init="true" init-method="init" destroy-method="cleanup">
 
    <!-- 可以用下面三種形式指定構(gòu)造參數(shù) -->
  <constructor-arg type="int" value="7500000"/>
    <constructor-arg name="years" value="7500000"/>
    <constructor-arg index="0" value="7500000"/>
 
    <!-- property 的幾種情況 -->
    <property name="beanOne">
        <ref bean="anotherExampleBean"/>
    </property>
    <property name="beanTwo" ref="yetAnotherBean"/>
    <property name="integerProperty" value="1"/>
</bean>

當(dāng)然，除了上面舉例出來(lái)的這些线椰，還有 <factory-bean>胞谈、<factory-method>、<lockup-method />憨愉、<replaced-method />烦绳、<meta />、<qualifier /> 這幾個(gè)配紫，大家是不是熟悉呢径密？

有了以上這些知識(shí)以后，我們?cè)倮^續(xù)往里看怎么解析 bean 元素躺孝，是怎么轉(zhuǎn)換到 BeanDefinitionHolder 的享扔。

// BeanDefinitionParserDelegate 428

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
    return parseBeanDefinitionElement(ele, null);
}
 
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
   String id = ele.getAttribute(ID_ATTRIBUTE);
   String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
 
   List<String> aliases = new ArrayList<String>();
 
   // 將 name 屬性的定義按照 ”逗號(hào)底桂、分號(hào)、空格“ 切分惧眠，形成一個(gè)別名列表數(shù)組籽懦，
   // 當(dāng)然，如果你不定義的話锉试，就是空的了
   // 我在附錄中簡(jiǎn)單介紹了一下 id 和 name 的配置猫十，大家可以看一眼，有個(gè)20秒就可以了
   if (StringUtils.hasLength(nameAttr)) {
      String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
      aliases.addAll(Arrays.asList(nameArr));
   }
 
   String beanName = id;
   // 如果沒(méi)有指定id, 那么用別名列表的第一個(gè)名字作為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");
      }
   }
 
   if (containingBean == null) {
      checkNameUniqueness(beanName, aliases, ele);
   }
 
   // 根據(jù) <bean ...>...</bean> 中的配置創(chuàng)建 BeanDefinition呆盖，然后把配置中的信息都設(shè)置到實(shí)例中,
   // 細(xì)節(jié)后面再說(shuō)
   AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
 
   // 到這里拖云，整個(gè) <bean /> 標(biāo)簽就算解析結(jié)束了，一個(gè) BeanDefinition 就形成了应又。
   if (beanDefinition != null) {
      // 如果都沒(méi)有設(shè)置 id 和 name宙项，那么此時(shí)的 beanName 就會(huì)為 null，進(jìn)入下面這塊代碼產(chǎn)生
      // 如果讀者不感興趣的話株扛，我覺(jué)得不需要關(guān)心這塊代碼尤筐，對(duì)本文源碼分析來(lái)說(shuō)，這些東西不重要
      if (!StringUtils.hasText(beanName)) {
         try {
            if (containingBean != null) {// 按照我們的思路洞就，這里 containingBean 是 null 的
               beanName = BeanDefinitionReaderUtils.generateBeanName(
                     beanDefinition, this.readerContext.getRegistry(), true);
            }
            else {
               // 如果我們不定義 id 和 name盆繁，那么我們引言里的那個(gè)例子：
               //   1. beanName 為：com.javadoop.example.MessageServiceImpl#0
               //   2. beanClassName 為：com.javadoop.example.MessageServiceImpl
 
               beanName = this.readerContext.generateBeanName(beanDefinition);
 
               String beanClassName = beanDefinition.getBeanClassName();
               if (beanClassName != null &&
                     beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
                     !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
                  // 把 beanClassName 設(shè)置為 Bean 的別名
                  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);
      // 返回 BeanDefinitionHolder
      return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
   }
 
   return null;
}

看看怎么根據(jù)配置創(chuàng)建 BeanDefinition：

public AbstractBeanDefinition parseBeanDefinitionElement(
      Element ele, String beanName, BeanDefinition containingBean) {
 
   this.parseState.push(new BeanEntry(beanName));
 
   String className = null;
   if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
      className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
   }
 
   try {
      String parent = null;
      if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
         parent = ele.getAttribute(PARENT_ATTRIBUTE);
      }
      // 創(chuàng)建 BeanDefinition，然后設(shè)置類信息而已旬蟋，很簡(jiǎn)單油昂，就不貼代碼了
      AbstractBeanDefinition bd = createBeanDefinition(className, parent);
 
      // 設(shè)置 BeanDefinition 的一堆屬性，這些屬性定義在 AbstractBeanDefinition 中
      parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
      bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
 
      /**
       * 下面的一堆是解析 <bean>......</bean> 內(nèi)部的子元素倾贰，
       * 解析出來(lái)以后的信息都放到 bd 的屬性中
       */
 
      // 解析 <meta />
      parseMetaElements(ele, bd);
      // 解析 <lookup-method />
      parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
      // 解析 <replaced-method />
      parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
    // 解析 <constructor-arg />
      parseConstructorArgElements(ele, bd);
      // 解析 <property />
      parsePropertyElements(ele, bd);
      // 解析 <qualifier />
      parseQualifierElements(ele, bd);
 
      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();
   }
 
   return null;
}

到這里冕碟，我們已經(jīng)完成了根據(jù) <bean /> 配置創(chuàng)建了一個(gè) BeanDefinitionHolder 實(shí)例。注意匆浙，是一個(gè)安寺。

我們回到解析 <bean /> 的入口方法:

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
   // 將 <bean /> 節(jié)點(diǎn)轉(zhuǎn)換為 BeanDefinitionHolder，就是上面說(shuō)的一堆
   BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
   if (bdHolder != null) {
      // 如果有自定義屬性的話首尼，進(jìn)行相應(yīng)的解析挑庶，先忽略
      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
      try {
         // 我們把這步叫做 注冊(cè)Bean 吧
         BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
      }
      catch (BeanDefinitionStoreException ex) {
         getReaderContext().error("Failed to register bean definition with name '" +
               bdHolder.getBeanName() + "'", ele, ex);
      }
      // 注冊(cè)完成后，發(fā)送事件饰恕，本文不展開(kāi)說(shuō)這個(gè)
      getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
   }
}

大家再仔細(xì)看一下這塊吧挠羔，我們后面就不回來(lái)說(shuō)這個(gè)了。這里已經(jīng)根據(jù)一個(gè) <bean /> 標(biāo)簽產(chǎn)生了一個(gè) BeanDefinitionHolder 的實(shí)例埋嵌，這個(gè)實(shí)例里面也就是一個(gè) BeanDefinition 的實(shí)例和它的 beanName破加、aliases 這三個(gè)信息，注意雹嗦，我們的關(guān)注點(diǎn)始終在 BeanDefinition 上：

public class BeanDefinitionHolder implements BeanMetadataElement {
 
  private final BeanDefinition beanDefinition;
 
  private final String beanName;
 
  private final String[] aliases;
...

然后我們準(zhǔn)備注冊(cè)這個(gè) BeanDefinition范舀，最后合是，把這個(gè)注冊(cè)事件發(fā)送出去。

下面锭环，我們開(kāi)始說(shuō)注冊(cè) Bean 吧聪全。

注冊(cè) Bean

// BeanDefinitionReaderUtils 143

public static void registerBeanDefinition(
      BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
      throws BeanDefinitionStoreException {
 
   String beanName = definitionHolder.getBeanName();
   // 注冊(cè)這個(gè) Bean
   registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
 
   // 如果還有別名的話，也要根據(jù)別名統(tǒng)統(tǒng)注冊(cè)一遍辅辩，不然根據(jù)別名就找不到 Bean 了难礼，這我們就不開(kāi)心了
   String[] aliases = definitionHolder.getAliases();
   if (aliases != null) {
      for (String alias : aliases) {
         // alias -> beanName 保存它們的別名信息，這個(gè)很簡(jiǎn)單玫锋，用一個(gè) map 保存一下就可以了蛾茉，
         // 獲取的時(shí)候，會(huì)先將 alias 轉(zhuǎn)換為 beanName撩鹿，然后再查找
         registry.registerAlias(beanName, alias);
      }
   }
}

別名注冊(cè)的放一邊谦炬，畢竟它很簡(jiǎn)單，我們看看怎么注冊(cè) Bean节沦。

// DefaultListableBeanFactory 793

@Override
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");
 
   if (beanDefinition instanceof AbstractBeanDefinition) {
      try {
         ((AbstractBeanDefinition) beanDefinition).validate();
      }
      catch (BeanDefinitionValidationException ex) {
         throw new BeanDefinitionStoreException(...);
      }
   }
 
   // old? 還記得 “允許 bean 覆蓋” 這個(gè)配置嗎键思？allowBeanDefinitionOverriding
   BeanDefinition oldBeanDefinition;
 
   // 之后會(huì)看到，所有的 Bean 注冊(cè)后會(huì)放入這個(gè) beanDefinitionMap 中
   oldBeanDefinition = this.beanDefinitionMap.get(beanName);
 
   // 處理重復(fù)名稱的 Bean 定義的情況
   if (oldBeanDefinition != null) {
      if (!isAllowBeanDefinitionOverriding()) {
         // 如果不允許覆蓋的話甫贯，拋異常
         throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription()...
      }
      else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
         // log...用框架定義的 Bean 覆蓋用戶自定義的 Bean 
      }
      else if (!beanDefinition.equals(oldBeanDefinition)) {
         // log...用新的 Bean 覆蓋舊的 Bean
      }
      else {
         // log...用同等的 Bean 覆蓋舊的 Bean吼鳞，這里指的是 equals 方法返回 true 的 Bean
      }
      // 覆蓋
      this.beanDefinitionMap.put(beanName, beanDefinition);
   }
   else {
      // 判斷是否已經(jīng)有其他的 Bean 開(kāi)始初始化了.
      // 注意，"注冊(cè)Bean" 這個(gè)動(dòng)作結(jié)束叫搁，Bean 依然還沒(méi)有初始化赖条，我們后面會(huì)有大篇幅說(shuō)初始化過(guò)程，
      // 在 Spring 容器啟動(dòng)的最后常熙，會(huì) 預(yù)初始化 所有的 singleton beans
      if (hasBeanCreationStarted()) {
         // Cannot modify startup-time collection elements anymore (for stable iteration)
         synchronized (this.beanDefinitionMap) {
            this.beanDefinitionMap.put(beanName, beanDefinition);
            List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
            updatedDefinitions.addAll(this.beanDefinitionNames);
            updatedDefinitions.add(beanName);
            this.beanDefinitionNames = updatedDefinitions;
            if (this.manualSingletonNames.contains(beanName)) {
               Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
               updatedSingletons.remove(beanName);
               this.manualSingletonNames = updatedSingletons;
            }
         }
      }
      else {
         // 最正常的應(yīng)該是進(jìn)到這里。
 
         // 將 BeanDefinition 放到這個(gè) map 中碱茁，這個(gè) map 保存了所有的 BeanDefinition
         this.beanDefinitionMap.put(beanName, beanDefinition);
         // 這是個(gè) ArrayList裸卫，所以會(huì)按照 bean 配置的順序保存每一個(gè)注冊(cè)的 Bean 的名字
         this.beanDefinitionNames.add(beanName);
         // 這是個(gè) LinkedHashSet，代表的是手動(dòng)注冊(cè)的 singleton bean纽竣，
         // 注意這里是 remove 方法墓贿，到這里的 Bean 當(dāng)然不是手動(dòng)注冊(cè)的
         // 手動(dòng)指的是通過(guò)調(diào)用以下方法注冊(cè)的 bean ：
         // registerSingleton(String beanName, Object singletonObject)
         // 這不是重點(diǎn)，解釋只是為了不讓大家疑惑蜓氨。Spring 會(huì)在后面"手動(dòng)"注冊(cè)一些 Bean聋袋，如 "environment"、"systemProperties" 等 bean
         this.manualSingletonNames.remove(beanName);
      }
      // 這個(gè)不重要穴吹，在預(yù)初始化的時(shí)候會(huì)用到幽勒，不必管它。
      this.frozenBeanDefinitionNames = null;
   }
 
   if (oldBeanDefinition != null || containsSingleton(beanName)) {
      resetBeanDefinition(beanName);
   }
}

總結(jié)一下港令，到這里已經(jīng)初始化了 Bean 容器啥容，<bean /> 配置也相應(yīng)的轉(zhuǎn)換為了一個(gè)個(gè) BeanDefinition锈颗，然后注冊(cè)了各個(gè) BeanDefinition 到注冊(cè)中心，并且發(fā)送了注冊(cè)事件咪惠。

Bean 容器實(shí)例化完成后

說(shuō)到這里击吱，我們回到 refresh() 方法，我重新貼了一遍代碼遥昧，看看我們說(shuō)到哪了覆醇。是的，我們才說(shuō)完 obtainFreshBeanFactory() 方法炭臭。

考慮到篇幅永脓，這里開(kāi)始大幅縮減掉沒(méi)必要詳細(xì)介紹的部分，大家直接看下面的代碼中的注釋就好了徽缚。

@Override
public void refresh() throws BeansException, IllegalStateException {
   // 來(lái)個(gè)鎖憨奸，不然 refresh() 還沒(méi)結(jié)束，你又來(lái)個(gè)啟動(dòng)或銷毀容器的操作凿试，那不就亂套了嘛
   synchronized (this.startupShutdownMonitor) {
 
      // 準(zhǔn)備工作排宰，記錄下容器的啟動(dòng)時(shí)間、標(biāo)記“已啟動(dòng)”狀態(tài)那婉、處理配置文件中的占位符
      prepareRefresh();
 
      // 這步比較關(guān)鍵板甘，這步完成后，配置文件就會(huì)解析成一個(gè)個(gè) Bean 定義详炬，注冊(cè)到 BeanFactory 中盐类，
      // 當(dāng)然，這里說(shuō)的 Bean 還沒(méi)有初始化呛谜，只是配置信息都提取出來(lái)了在跳，
      // 注冊(cè)也只是將這些信息都保存到了注冊(cè)中心(說(shuō)到底核心是一個(gè) beanName-> beanDefinition 的 map)
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 
      // 設(shè)置 BeanFactory 的類加載器，添加幾個(gè) BeanPostProcessor隐岛，手動(dòng)注冊(cè)幾個(gè)特殊的 bean
      // 這塊待會(huì)會(huì)展開(kāi)說(shuō)
      prepareBeanFactory(beanFactory);
 
      try {
         // 【這里需要知道 BeanFactoryPostProcessor 這個(gè)知識(shí)點(diǎn)猫妙，Bean 如果實(shí)現(xiàn)了此接口，
         // 那么在容器初始化以后聚凹，Spring 會(huì)負(fù)責(zé)調(diào)用里面的 postProcessBeanFactory 方法割坠。】
 
         // 這里是提供給子類的擴(kuò)展點(diǎn)妒牙，到這里的時(shí)候彼哼，所有的 Bean 都加載、注冊(cè)完成了湘今，但是都還沒(méi)有初始化
         // 具體的子類可以在這步的時(shí)候添加一些特殊的 BeanFactoryPostProcessor 的實(shí)現(xiàn)類或做點(diǎn)什么事
         postProcessBeanFactory(beanFactory);
         // 調(diào)用 BeanFactoryPostProcessor 各個(gè)實(shí)現(xiàn)類的 postProcessBeanFactory(factory) 方法
         invokeBeanFactoryPostProcessors(beanFactory);
 
         // 注冊(cè) BeanPostProcessor 的實(shí)現(xiàn)類敢朱，注意看和 BeanFactoryPostProcessor 的區(qū)別
         // 此接口兩個(gè)方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
         // 兩個(gè)方法分別在 Bean 初始化之前和初始化之后得到執(zhí)行。注意，到這里 Bean 還沒(méi)初始化
         registerBeanPostProcessors(beanFactory);
 
         // 初始化當(dāng)前 ApplicationContext 的 MessageSource蔫饰，國(guó)際化這里就不展開(kāi)說(shuō)了琅豆，不然沒(méi)完沒(méi)了了
         initMessageSource();
 
         // 初始化當(dāng)前 ApplicationContext 的事件廣播器，這里也不展開(kāi)了
         initApplicationEventMulticaster();
 
         // 從方法名就可以知道篓吁，典型的模板方法(鉤子方法)茫因，
         // 具體的子類可以在這里初始化一些特殊的 Bean（在初始化 singleton beans 之前）
         onRefresh();
 
         // 注冊(cè)事件監(jiān)聽(tīng)器，監(jiān)聽(tīng)器需要實(shí)現(xiàn) ApplicationListener 接口杖剪。這也不是我們的重點(diǎn)冻押，過(guò)
         registerListeners();
 
         // 重點(diǎn)，重點(diǎn)盛嘿，重點(diǎn)
         // 初始化所有的 singleton beans
         //（lazy-init 的除外）
         finishBeanFactoryInitialization(beanFactory);
 
         // 最后洛巢，廣播事件，ApplicationContext 初始化完成
         finishRefresh();
      }
 
      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }
 
         // Destroy already created singletons to avoid dangling resources.
         // 銷毀已經(jīng)初始化的 singleton 的 Beans次兆，以免有些 bean 會(huì)一直占用資源
         destroyBeans();
 
         // Reset 'active' flag.
         cancelRefresh(ex);
 
         // 把異常往外拋
         throw ex;
      }
 
      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...
         resetCommonCaches();
      }
   }
}

準(zhǔn)備 Bean 容器: prepareBeanFactory(factory)

這里簡(jiǎn)單介紹下 prepareBeanFactory(factory) 方法：

/**
 * Configure the factory's standard context characteristics,
 * such as the context's ClassLoader and post-processors.
 * @param beanFactory the BeanFactory to configure
 */
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   // 設(shè)置 BeanFactory 的類加載器稿茉，我們知道 BeanFactory 需要加載類，也就需要類加載器芥炭，
   // 這里設(shè)置為當(dāng)前 ApplicationContext 的類加載器
   beanFactory.setBeanClassLoader(getClassLoader());
   // 設(shè)置 BeanExpressionResolver
   beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
   // 
   beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
 
   // 添加一個(gè) BeanPostProcessor漓库，這個(gè) processor 比較簡(jiǎn)單，
   // 實(shí)現(xiàn)了 Aware 接口的幾個(gè)特殊的 beans 在初始化的時(shí)候园蝠，這個(gè) processor 負(fù)責(zé)回調(diào)
   beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
 
   // 下面幾行的意思就是渺蒿，如果某個(gè) bean 依賴于以下幾個(gè)接口的實(shí)現(xiàn)類，在自動(dòng)裝配的時(shí)候忽略它們彪薛，
   // Spring 會(huì)通過(guò)其他方式來(lái)處理這些依賴茂装。
   beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
   beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
   beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
   beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
   beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
   beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
 
   /**
    * 下面幾行就是為特殊的幾個(gè) bean 賦值，如果有 bean 依賴了以下幾個(gè)善延，會(huì)注入這邊相應(yīng)的值少态，
    * 之前我們說(shuō)過(guò)，"當(dāng)前 ApplicationContext 持有一個(gè) BeanFactory"易遣，這里解釋了第一行
    * ApplicationContext 繼承了 ResourceLoader况增、ApplicationEventPublisher、MessageSource
    * 所以對(duì)于這幾個(gè)训挡，可以賦值為 this，注意 this 是一個(gè) ApplicationContext
    * 那這里怎么沒(méi)看到為 MessageSource 賦值呢歧强？那是因?yàn)?MessageSource 被注冊(cè)成為了一個(gè)普通的 bean
    */
   beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
   beanFactory.registerResolvableDependency(ResourceLoader.class, this);
   beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
   beanFactory.registerResolvableDependency(ApplicationContext.class, this);
 
   // 這個(gè) BeanPostProcessor 也很簡(jiǎn)單澜薄，在 bean 實(shí)例化后，如果是 ApplicationListener 的子類摊册，
   // 那么將其添加到 listener 列表中肤京，可以理解成：注冊(cè)事件監(jiān)聽(tīng)器
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
 
   // Detect a LoadTimeWeaver and prepare for weaving, if found.
   // 這里涉及到特殊的 bean，名為：loadTimeWeaver，這不是我們的重點(diǎn)忘分，忽略它
   if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
      // Set a temporary ClassLoader for type matching.
      beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
   }
 
   /**
    * 從下面幾行代碼我們可以知道棋枕，Spring 往往很 "智能" 就是因?yàn)樗鼤?huì)幫我們默認(rèn)注冊(cè)一些有用的 bean，
    * 我們也可以選擇覆蓋
    */
 
   // 如果沒(méi)有定義 "environment" 這個(gè) bean妒峦，那么 Spring 會(huì) "手動(dòng)" 注冊(cè)一個(gè)
   if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
      beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
   }
   // 如果沒(méi)有定義 "systemProperties" 這個(gè) bean重斑，那么 Spring 會(huì) "手動(dòng)" 注冊(cè)一個(gè)
   if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
      beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
   }
   // 如果沒(méi)有定義 "systemEnvironment" 這個(gè) bean，那么 Spring 會(huì) "手動(dòng)" 注冊(cè)一個(gè)
   if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
      beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
   }
}

在上面這塊代碼中肯骇，Spring 對(duì)一些特殊的 bean 進(jìn)行了處理窥浪，讀者如果暫時(shí)還不能消化它們也沒(méi)有關(guān)系，慢慢往下看笛丙。