Spring IOC_ZenDei技術網路在線

前言 Spring框架為什麼如此流行? 原來Spring框架解決了一個很關鍵的問題，它可以把對象之間的依賴關係轉為用配置文件來管理，也就是它的依賴註入機制。IOC容器用來管理這些Bean，管理Bean的關係以及生命周期，然而這與之前將應用程式主動new對象不同，Spring實現使用IOC容器創建對象 ...

前言

Spring框架為什麼如此流行?

原來Spring框架解決了一個很關鍵的問題，它可以把對象之間的依賴關係轉為用配置文件來管理，也就是它的依賴註入機制。IOC容器用來管理這些Bean，管理Bean的關係以及生命周期，然而這與之前將應用程式主動new對象不同，Spring實現使用IOC容器創建對象，對象的獲取方式反轉了，所以IOC容器也稱為控制反轉。面對繁瑣的依賴關係，我們不用一個一個去new對象，直接使用IOC創建好的對象，這也正是IOC的方便之處。

Spring 核心組件：Bean Context，Core

Bean

Bean組件在org.springframework.beans包下，這個包下所有的類解決了Bean的定義，創建以及解析。

1.Bean的定義：主要有BeanDefinition描述，也可以說Spring中的Bean就是BeanDefinition的實例。Spring成功解析一個<bean/>節點後,在Spring的內部它就被轉化為BeanDefinition對象。

2.Bean的創建：.Spring Bean的創建是典型的工廠設計模式，頂級介面是BeanFactory

3.Bean的解析：Bean的解析主要是對配置文件的解析

Context

context組件在org.framework.context包下,主要就是Bean關係的集合。給Spring提供了一個運行時環境用於存儲對象的狀態。ApplicationContext是頂級的父類

ApplicationContext繼承了BeanFactory說明瞭Spring容器運行的主要對象是Bean

ApplicationContext實現了ResourceLoader介面說明ApplicationContext可以訪問到外部資源。

Core

core組件就是發現，建立和維護每個Bean之間關係所需要的一系列工具。core組件其中一個重要的組成部分就是定義了資源的訪問方式。

IOC的工作原理

下麵我們看看IOC是怎樣工作的呢？

先來一個小demo

MessageService.java

public interface MessageService {
    String getMessage();
}

MessageServiceImpl.java

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

application.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.kristin.spring.ioc.MessageServiceImpl"/>
</beans>

TestMessage.java

public class TestMessage {
    public static void main(String[] args) {
        // 用我們的配置文件來啟動一個 ApplicationContext
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:application.xml");

        System.out.println("context 啟動成功");

        // 從 context 中取出我們的 Bean，而不是用 new MessageServiceImpl() 這種方式
        MessageService messageService = context.getBean(MessageService.class);
        // 這句將輸出: hello world
        System.out.println(messageService.getMessage());
    }
}

運行結果:

IOC運行分析　　

從上面代碼可以發現，IOC的入口就是ClassPathXmlApplicationContext的構造方法,下麵我們看看源碼是怎樣寫的

ClassPathXmlApplicationContext.java

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
	this(new String[] {configLocation}, true, null);
}

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

    super(parent);
    setConfigLocations(configLocations);    //根據提供的路徑，處理成配置文件數組(以分號、逗號、空格、tab、換行符分割)
    if (refresh) {
        refresh();  //這裡是核心代碼
    }
}

下麵我們看一下refresh()

ClassPathXmlApplicationContext.java

@Override
public void refresh() throws BeansException, IllegalStateException {
    //這裡加鎖,防止多個線程同時refresh()時出現問題
    synchronized (this.startupShutdownMonitor) {
        // 為刷新準備新的context,記錄下容器的啟動時間、標記“已啟動”狀態、處理配置文件中的占位符
        prepareRefresh();

        // 刷新所有BeanFactory的子容器
        // 這步比較關鍵，這步完成後，配置文件就會解析成一個個 Bean 定義，註冊到 BeanFactory 中，
        // 當然，這裡說的 Bean 還沒有初始化，只是配置信息都提取出來了，
        // 註冊也只是將這些信息都保存到了註冊中心(說到底核心是一個 beanName-> beanDefinition 的 map)
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // 準備BeanFactory,設置 BeanFactory 的類載入器，添加幾個 BeanPostProcessor，手動註冊幾個特殊的 bean
        prepareBeanFactory(beanFactory);

        try {
            // 這裡是提供給子類的擴展點，到這裡的時候，所有的 Bean 都載入、註冊完成了，但是都還沒有初始化
            // 具體的子類可以在這步的時候添加一些特殊的 BeanFactoryPostProcessor 的實現類或做點什麼事
            postProcessBeanFactory(beanFactory);

            // 調用 BeanFactoryPostProcessor 各個實現類的 postProcessBeanFactory(factory) 方法
            invokeBeanFactoryPostProcessors(beanFactory);

            // 註冊 BeanPostProcessor 的實現類，註意看和 BeanFactoryPostProcessor 的區別
            // 此介面兩個方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
            // 兩個方法分別在 Bean 初始化之前和初始化之後得到執行。註意，到這裡 Bean 還沒初始化
            registerBeanPostProcessors(beanFactory);

            // 初始化message source
            initMessageSource();

            // 初始化 event multicaster
            initApplicationEventMulticaster();

            // 刷新由子類實現的方法
            onRefresh();

            // 註冊事件監聽器，監聽器需要實現 ApplicationListener 介面。
            registerListeners();

            // 初始化所有的 singleton beans
            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.
            destroyBeans();

            // Reset 'active' flag.
            cancelRefresh(ex);

            // Propagate exception to caller.
            throw ex;
        }

        finally {
            // Reset common introspection caches in Spring's core, since we
            // might not ever need metadata for singleton beans anymore...
            resetCommonCaches();
        }
    }
}

refresh函數主要包含了以下幾個步驟:

1.構建BeanFactory,以便於產生所需的"演員"

2.註冊可能感興趣的事件

3.創建Bean實例對象

4.觸發被監聽的事件

創建BeanFactory的時序圖:

繼續看一看refresh()函數中調用的函數吧

AbstractApplicationContext.java

protected void prepareRefresh() {
    // 記錄啟動時間,將 active 屬性設置為 true，closed 屬性設置為 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();

    // 校驗 xml 配置文件
    getEnvironment().validateRequiredProperties();

    // Allow for the collection of early ApplicationEvents,
    // to be published once the multicaster is available...
    this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
}

AbstractApplicationContext.java

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    // 關閉舊的 BeanFactory (如果有)，創建新的 BeanFactory，載入 Bean 定義、註冊 Bean 等等
    refreshBeanFactory();
    // 返回剛剛創建的 BeanFactory
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (logger.isDebugEnabled()) {
        logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
    }
    return beanFactory;
}

AbstractRefreshableApplicationContext.java

@Override
protected final void refreshBeanFactory() throws BeansException {
    // 如果 ApplicationContext 中已經載入過 BeanFactory 了，銷毀所有 Bean，關閉 BeanFactory
    // 註意，應用中BeanFactory本來就是可以多個的，這裡可不是說應用全局是否有 BeanFactory，而是當前ApplicationContext是否有BeanFactory
    if (hasBeanFactory()) {
        destroyBeans();
        closeBeanFactory();
    }
    try {
        // 初始化一個 DefaultListableBeanFactory
        DefaultListableBeanFactory beanFactory = createBeanFactory();
        // 用於 BeanFactory 的序列化
        beanFactory.setSerializationId(getId());
        // 設置 BeanFactory 的兩個配置屬性：是否允許 Bean 覆蓋、是否允許迴圈引用
        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);
    }
}

此時已經獲得了BeanFactory

後面會陸續更新,暫時先整理到這裡...

對了,以上文章整理自

https://javadoop.com/post/spring-ioc

《深入分析Java Web技術內幕》

感謝兩位大神的文章及書籍　