本文轉載自網際網路，侵刪

本系列文章將整理到我在GitHub上的《Java面試指南》倉庫，更多精彩內容請到我的倉庫裡檢視
> https://github.com/h2pl/Java-Tutorial

喜歡的話麻煩點下Star哈

文章將同步到我的個人部落格：
> www.how2playlife.com

本文是微信公眾號【Java技術江湖】的《Spring和SpringMVC原始碼分析》其中一篇，本文部分內容來源於網路，為了把本文主題講得清晰透徹，也整合了很多我認為不錯的技術部落格內容，引用其中了一些比較好的部落格文章，如有侵權，請聯絡作者。

該系列博文會告訴你如何從spring基礎入手，一步步地學習spring基礎和springmvc的框架知識，並上手進行專案實戰，spring框架是每一個Java工程師必須要學習和理解的知識點，進一步來說，你還需要掌握spring甚至是springmvc的原始碼以及實現原理，才能更完整地瞭解整個spring技術體系，形成自己的知識框架。

後續還會有springboot和springcloud的技術專題，陸續為大家帶來，敬請期待。

為了更好地總結和檢驗你的學習成果，本系列文章也會提供部分知識點對應的面試題以及參考答案。

如果對本系列文章有什麼建議，或者是有什麼疑問的話，也可以關注公眾號【Java技術江湖】聯絡作者，歡迎你參與本系列博文的創作和修訂。

## 前言

本文大致地介紹了IOC容器的初始化過程，只列出了比較重要的過程和程式碼，可以從中看出IOC容器執行的大致流程。

接下來的文章會更加深入剖析Bean容器如何解析xml，註冊和初始化bean，以及如何獲取bean例項等詳細的過程。

轉自：[http://www.importnew.com/19243.html](http://www.importnew.com/19243.html)

1\. 初始化

大致單步跟了下Spring IOC的初始化過程，整個脈絡很龐大，初始化的過程主要就是讀取XML資源，並解析，最終註冊到Bean Factory中：

[![](https://cloud.githubusercontent.com/assets/1736354/7897341/032179be-070b-11e5-9ecf-d7befc804e9d.png "flow")](https://cloud.githubusercontent.com/assets/1736354/7897341/032179be-070b-11e5-9ecf-d7befc804e9d.png "flow")

在完成初始化的過程後，Bean們就在BeanFactory中蓄勢以待地等呼叫了。下面透過一個具體的例子，來詳細地學習一下初始化過程，例如當載入下面一個bean：

```
<bean id="XiaoWang" class="com.springstudy.talentshow.SuperInstrumentalist">
    <property name="instruments">
        <list>
            <ref bean="piano"></ref>
            <ref bean="saxophone"></ref>
        </list>
    </property>
</bean>
```

載入時需要讀取、解析、註冊bean，這個過程具體的呼叫棧如下所示：
[![](https://cloud.githubusercontent.com/assets/1736354/7896285/8a488060-06e6-11e5-9ad9-4ddd3375984f.png "load")](https://cloud.githubusercontent.com/assets/1736354/7896285/8a488060-06e6-11e5-9ad9-4ddd3375984f.png "load")

下面對每一步的關鍵的程式碼進行詳細分析：

## 準備

儲存配置位置，並重新整理
在呼叫ClassPathXmlApplicationContext後，先會將配置位置資訊儲存到configLocations，供後面解析使用，之後，會呼叫`AbstractApplicationContext`的refresh方法進行重新整理：

```
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh,
        ApplicationContext parent) throws BeansException {

super(parent);
    // 儲存位置資訊，比如`com/springstudy/talentshow/talent-show.xml`
    setConfigLocations(configLocations);
    if (refresh) {
        // 重新整理
        refresh();
    }
}

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        prepareRefresh();
        // Tell the subclass to refresh the internal bean factory.
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        // Prepare the bean factory for use in this context.
        prepareBeanFactory(beanFactory);
        try {
            // Allows post-processing of the bean factory in context subclasses.
            postProcessBeanFactory(beanFactory);
            // Invoke factory processors registered as beans in the context.
            invokeBeanFactoryPostProcessors(beanFactory);
            // Register bean processors that intercept bean creation.
            registerBeanPostProcessors(beanFactory);
            // Initialize message source for this context.
            initMessageSource();
            // Initialize event multicaster for this context.
            initApplicationEventMulticaster();
            // Initialize other special beans in specific context subclasses.
            onRefresh();
            // Check for listener beans and register them.
            registerListeners();
            // Instantiate all remaining (non-lazy-init) singletons.
            finishBeanFactoryInitialization(beanFactory);
            // Last step: publish corresponding event.
            finishRefresh();
        }
        catch (BeansException ex) {
            // Destroy already created singletons to avoid dangling resources.
            destroyBeans();
            // Reset 'active' flag.
            cancelRefresh(ex);
            // Propagate exception to caller.
            throw ex;
        }
    }
}
```

建立載入BeanFactory

```
protected final void refreshBeanFactory() throws BeansException {
    // ... ...
    DefaultListableBeanFactory beanFactory = createBeanFactory();
    // ... ...
    loadBeanDefinitions(beanFactory);
    // ... ...
}
```

建立XMLBeanDefinitionReader

```
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
     throws BeansException, IOException {
    // Create a new XmlBeanDefinitionReader for the given BeanFactory.
    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
    // ... ...
    // Allow a subclass to provide custom initialization of the reader,
    // then proceed with actually loading the bean definitions.
    initBeanDefinitionReader(beanDefinitionReader);
    loadBeanDefinitions(beanDefinitionReader);
```

## 讀取

建立處理每一個resource

```
public int loadBeanDefinitions(String location, Set<resource> actualResources)
     throws BeanDefinitionStoreException {
    // ... ...
    // 透過Location來讀取Resource
    Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
    int loadCount = loadBeanDefinitions(resources);
    // ... ...
}

public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
    Assert.notNull(resources, "Resource array must not be null");
    int counter = 0;
    for (Resource resource : resources) {
        // 載入每一個resource
        counter += loadBeanDefinitions(resource);
    }
    return counter;
}
```

處理XML每個元素

```
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    // ... ...
    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)) {
                // 處理每個xml中的元素，可能是import、alias、bean
                parseDefaultElement(ele, delegate);
            }
            else {
                delegate.parseCustomElement(ele);
            }
        }
    }
    // ... ...
}
```

解析和註冊bean

```
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    // 解析
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    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));
    }
}
```

本步驟中，透過parseBeanDefinitionElement將XML的元素解析為BeanDefinition，然後存在BeanDefinitionHolder中，然後再利用BeanDefinitionHolder將BeanDefinition註冊，實質就是把BeanDefinition的例項put進BeanFactory中，和後面將詳細的介紹解析和註冊過程。

## 解析

[![](https://cloud.githubusercontent.com/assets/1736354/7896302/eae02bc6-06e6-11e5-941a-d1f59e3b363f.png "process")](https://cloud.githubusercontent.com/assets/1736354/7896302/eae02bc6-06e6-11e5-941a-d1f59e3b363f.png "process")

處理每個Bean的元素

```
public AbstractBeanDefinition parseBeanDefinitionElement(
        Element ele, String beanName, BeanDefinition containingBean) {

// ... ...
    // 建立beandefinition
    AbstractBeanDefinition bd = createBeanDefinition(className, parent);

parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
    bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

parseMetaElements(ele, bd);
    parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
    parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
    // 處理“Constructor”
    parseConstructorArgElements(ele, bd);
    // 處理“Preperty”
    parsePropertyElements(ele, bd);
    parseQualifierElements(ele, bd);
    // ... ...
}
```

處理屬性的值

```
public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {
    String elementName = (propertyName != null) ?
                    "<property> element for property '" + propertyName + "'" :
                    "<constructor-arg> element";

// ... ...
    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.setSource(extractSource(ele));
        return ref;
    }
    else if (hasValueAttribute) {
    // 處理值
        TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
        valueHolder.setSource(extractSource(ele));
        return valueHolder;
    }
    else if (subElement != null) {
    // 處理子型別（比如list、map等）
        return parsePropertySubElement(subElement, bd);
    }
    // ... ...
}

```

1.4 註冊

```
public static void registerBeanDefinition(
        BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
        throws BeanDefinitionStoreException {

// Register bean definition under primary name.
    String beanName = definitionHolder.getBeanName();
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

// Register aliases for bean name, if any.
    String[] aliases = definitionHolder.getAliases();
    if (aliases != null) {
        for (String alias : aliases) {
            registry.registerAlias(beanName, alias);
        }
    }
}

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
        throws BeanDefinitionStoreException {

// ......

// 將beanDefinition註冊
    this.beanDefinitionMap.put(beanName, beanDefinition);

// ......
}

```

註冊過程中，最核心的一句就是：this.beanDefinitionMap.put(beanName, beanDefinition)，也就是說註冊的實質就是以beanName為key，以beanDefinition為value，將其put到HashMap中。

## 註冊

```
    public static void registerBeanDefinition(
        BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
        throws BeanDefinitionStoreException {

// Register bean definition under primary name.
    String beanName = definitionHolder.getBeanName();
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

// Register aliases for bean name, if any.
    String[] aliases = definitionHolder.getAliases();
    if (aliases != null) {
        for (String alias : aliases) {
            registry.registerAlias(beanName, alias);
        }
    }
}

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
        throws BeanDefinitionStoreException {

// ......

// 將beanDefinition註冊
    this.beanDefinitionMap.put(beanName, beanDefinition);

// ......

```

理解了以上兩個過程，我們就可以自己實現一個簡單的Spring框架了。於是，我根據自己的理解實現了一個簡單的IOC框架Simple Spring，有興趣可以看看。

註冊過程中，最核心的一句就是：`this.beanDefinitionMap.put(beanName, beanDefinition)`，也就是說註冊的實質就是以beanName為key，以beanDefinition為value，將其put到HashMap中。

### 注入依賴

當完成初始化IOC容器後，如果bean沒有設定lazy-init(延遲載入)屬性，那麼bean的例項就會在初始化IOC完成之後，及時地進行初始化。初始化時會先建立例項，然後根據配置利用反射對例項進行進一步操作，具體流程如下所示：
[![](https://cloud.githubusercontent.com/assets/1736354/7929429/615570ea-0930-11e5-8097-ae982ef7709d.png "bean_flow")](https://cloud.githubusercontent.com/assets/1736354/7929429/615570ea-0930-11e5-8097-ae982ef7709d.png "bean_flow")

建立bean的例項
建立bean的例項過程函式呼叫棧如下所示：
[![](https://cloud.githubusercontent.com/assets/1736354/7929379/cec01bcc-092f-11e5-81ad-88c285f33845.png "create_bean")](https://cloud.githubusercontent.com/assets/1736354/7929379/cec01bcc-092f-11e5-81ad-88c285f33845.png "create_bean")

注入bean的屬性
注入bean的屬性過程函式呼叫棧如下所示：
[![](https://cloud.githubusercontent.com/assets/1736354/7929381/db58350e-092f-11e5-82a4-caaf349291ea.png "inject_property")](https://cloud.githubusercontent.com/assets/1736354/7929381/db58350e-092f-11e5-82a4-caaf349291ea.png "inject_property")

在建立bean和注入bean的屬性時，都是在doCreateBean函式中進行的，我們重點看下：

```
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd,
            final Object[] args) {
        // Instantiate the bean.
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            // 建立bean的例項
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }

// ... ...

// Initialize the bean instance.
        Object exposedObject = bean;
        try {
            // 初始化bean的例項，如注入屬性
            populateBean(beanName, mbd, instanceWrapper);
            if (exposedObject != null) {
                exposedObject = initializeBean(beanName, exposedObject, mbd);
            }
        }

// ... ...
    }

```

理解了以上兩個過程，我們就可以自己實現一個簡單的Spring框架了。於是，我根據自己的理解實現了一個簡單的IOC框架[Simple Spring](https://github.com/Yikun/simple-spring)，有興趣可以看看。</constructor-arg></property></resource>

Spring原始碼剖析2：初探Spring IOC核心流程

相關文章