2. 程式人生 > >SPRING 啟動載入BEAN 的程式碼過程

SPRING 啟動載入BEAN 的程式碼過程

阿新 • • 發佈：2019-01-09

當Web應用啟動時，contextInitialized方法會執行載入根上下文（IOC容器）：

（1）spring的web專案啟動的時候會，啟動我們常用的監聽類。

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>WEB-INF/classes/spring-context.xml</param-value>
</context-param>
<!-- Spring監聽器 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>


（2）tomcat在載入web應用時候，會針對每個web.xml的監聽器進行建立，看org.apache.catalina.core.StandardContext.listenerStart()，

public boolean listenerStart() {
    if (log.isDebugEnabled())
        log.debug("Configuring application event listeners");


    String listeners[] = findApplicationListeners();
    Object results[] = new Object[listeners.length];
    boolean ok = true;
    for (int i = 0; i < results.length; i++) {
        if (getLogger().isDebugEnabled())
            getLogger().debug(" Configuring event listener class '" + listeners[i] + "'");
        try {
            String listener = listeners[i];
            results[i] = getInstanceManager().newInstance(listener);
        } catch (Throwable t) {
            t = ExceptionUtils.unwrapInvocationTargetException(t);
            ExceptionUtils.handleThrowable(t);
            getLogger().error(sm.getString("standardContext.applicationListener", listeners[i]), t);
            ok = false;
        }
    }
    if (!ok) {
        getLogger().error(sm.getString("standardContext.applicationSkipped"));
        return (false);
    }


    ArrayList<Object> eventListeners = new ArrayList<>();
    ArrayList<Object> lifecycleListeners = new ArrayList<>();
    for (int i = 0; i < results.length; i++) {
        if ((results[i] instanceof ServletContextAttributeListener)
                || (results[i] instanceof ServletRequestAttributeListener)
                || (results[i] instanceof ServletRequestListener)
                || (results[i] instanceof HttpSessionIdListener)
                || (results[i] instanceof HttpSessionAttributeListener)) {
            eventListeners.add(results[i]);
        }
        if ((results[i] instanceof ServletContextListener)
                || (results[i] instanceof HttpSessionListener)) {
            lifecycleListeners.add(results[i]);
        }
    }


    for (Object eventListener : getApplicationEventListeners()) {
        eventListeners.add(eventListener);
    }
    setApplicationEventListeners(eventListeners.toArray());
    
    for (Object lifecycleListener : getApplicationLifecycleListeners()) {
        lifecycleListeners.add(lifecycleListener);
        if (lifecycleListener instanceof ServletContextListener) {
            noPluggabilityListeners.add(lifecycleListener);
        }
    }
    setApplicationLifecycleListeners(lifecycleListeners.toArray());


    if (getLogger().isDebugEnabled())
        getLogger().debug("Sending application start events");


    getServletContext();
    context.setNewServletContextListenerAllowed(false);


    Object instances[] = getApplicationLifecycleListeners();
    if (instances == null || instances.length == 0) {
        return ok;
    }


   

ServletContextEvent event = new ServletContextEvent(getServletContext());
    ServletContextEvent tldEvent = null;
    if (noPluggabilityListeners.size() > 0) {
        noPluggabilityServletContext = new NoPluggabilityServletContext(getServletContext());
        tldEvent = new ServletContextEvent(noPluggabilityServletContext);
    }
    for (int i = 0; i < instances.length; i++) {
        if (!(instances[i] instanceof ServletContextListener))
            continue;
        ServletContextListener listener = (ServletContextListener) instances[i];
        try {
            fireContainerEvent("beforeContextInitialized", listener);
            if (noPluggabilityListeners.contains(listener)) {
                listener.contextInitialized(tldEvent);
            } else {
                listener.contextInitialized(event); 
            }

  fireContainerEvent("afterContextInitialized", listener);//註冊事件
        } catch (Throwable t) {
            ExceptionUtils.handleThrowable(t);
            fireContainerEvent("afterContextInitialized", listener);
            getLogger().error(sm.getString("standardContext.listenerStart", instances[i].getClass().getName()), t);
            ok = false;
        }
    }
    return (ok);
}

（3）具體的建立wepapplicationcontext的過程如下：

ContextLoaderListener.contextInitialized(ServletContextEvent event) 

 
->ContextLoader.initWebApplicationContext(ServletContext servletContext) 

 
->ContextLoader.createWebApplicationContext(ServletContext sc) - - - - - 如果web.xml裡沒指定型別，預設是XmlWebAppalication


->ContextLoader.configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc)  - - - - - -  配置和初始化 webApplicationContext


->ConfigurableWebApplicationContext.refresh() - - - - -  ConfigurableWebApplicationContext是介面


->AbstractApplicationContext.refresh() - - - - - 啟動 容器初始化


->AbstractApplicationContext.obtainFreshBeanFactory() - - - - -  建立BeanFactory，開始容器的初始化過程，比如BeanDefinition的載入


->AbstractRefreshableApplicationContext.refreshBeanFactory() - - - - - 在這裡建立了BeanFactory（DefaultListableBeanFactory）。然後開始loadBeanDefinitions，這是一個抽象方法，實際的載入是在XmlWebApplicationContext類裡。


->XmlWebApplicationContext.loadBeanDefinitions(DefaultListableBeanFactory beanFactory) - - - -建立一個XmlBeanDefinitionReader，並啟動bean定義資訊的載入。


->XmlWebApplicationContext.loadBeanDefinitions(XmlBeanDefinitionReader reader) - - - 根據配置檔案的locations，因為配置檔案是xml的，所以使用的是XmlBeanDefinitionReader 。具體的載入過程是委託給BeanDefinitionReader完成的
 
->AbstractBeanDefinitionReader.loadBeanDefinitionReader - - - 這是一個抽象類，實際的載入是在XmlBeanDefinitionReader中實現的，抽象類是根據bean定義的xml配置檔案的路徑，生成resource。然後XmlBeanDefinitionReader根據resource開始具體載入BeanDefinition


->XmlBeanDefinitionReader.loadBeanDefinitionReader(Resource resource)
 
->XmlBeanDefinitionReader.loadBeanDefinitions(EncodedResource encodedResource) - - - 在讀取器中，需要得到代表XML檔案的resource，這個resource物件封裝了對xml檔案的IO操作，所以讀取器可以在開啟IO流後得到XML的檔案物件。
 
->XmlBeanDefinitionReader.doLoadBeanDefinitions(InputSource inputSource, Resource resource) - - - -讀取器在這裡開啟IO流後得到XML的檔案Document物件（Document物件是通過XML解析器出來的，下面會再根據Spring Bean的規則再解析出BeanDefinition）。得到物件後就可以按照spring的Bean定義規則來對這個xml的檔案檔樹進行解析了
 
->XmlBeanDefinitionReader.registerBeanDefinitions(Document doc, Resource resource) - - -這個方法啟動對BeanDefinition的解析的詳細過程，這個解析會使用到Spring的Bean的配置規則。具體的過程是有BeanDefinitionDocumentReader來完成的。
->BeanDefinitionDocumentReader.registerBeanDefinitions(Document doc, XmlReaderContext readerContext)
 
->DefaultBeanDefinitionDocumentReader.registerBeanDefinitions(Document doc, XmlReaderContext readerContext) - - - - -DefaultBeanDefinitionDocumentReader 是BeanDefinitionDocumentReader的實現類，registerBeanDefinitions方法開始按照Spring Bean的規則解析Document物件
 
->DefaultBeanDefinitionDocumentReader.doRegisterBeanDefinitions(Element root) - - -解析過程是由BeanDefinitionParserDelegate物件來完成的。


->DefaultBeanDefinitionDocumentReader.parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) 
->DefaultBeanDefinitionDocumentReader.parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate)
->DefaultBeanDefinitionDocumentReader.processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate)
 - - - - 解析的結果是由BeanDefinitionHolder來持有的，這個BeanDefinitionHolder物件封裝了BeanDefinition，beanName，aliases等資訊，用它來完成向IOC容器註冊。


->BeanDefinitionParserDelegate.parseBeanDefinitionElement(Element ele) 
->BeanDefinitionParserDelegate.parseBeanDefinitionElement(Element ele, BeanDefinition containingBean)
->BeanDefinitionParserDelegate.parseBeanDefinitionElement(
               Element ele, String beanName, BeanDefinition containingBean) - - - 對xml配置檔案中的配置的Bean進行詳細解析，這裡只是讀取定義 的<bean>，並載入到BeanDefinition中去，這裡不涉及物件的例項化過程，物件的例項化實際上是再依賴注入時完成的。

相關推薦

SPRING 啟動載入BEAN 的程式碼過程

當Web應用啟動時，contextInitialized方法會執行載入根上下文（IOC容器）： （1）spring的web專案啟動的時候會，啟動我們常用的監聽類。 <context-param><param-name>contextConfi

Spring原始碼中容器載入Bean的過程

使用XmlBeanFactory容器來載入容器中Bean的過程 在Spring原始碼中XmlBeanFactory.java 可以有上面的XmlBeanFactory,java載入資原始檔可以看出，初始化XmlBeanFactory類的關鍵是this.reader.loadBeanDefi

spring 啟動載入過程

spring啟動component-scan類掃描載入過程—原始碼分析spring通過DispatcherServlet載入:系統配置:<servlet> <servlet-name>spring</servlet-name>

spring載入bean的過程

首先，我在這裡舉個demo，大致演示一下怎麼獲取配置檔案中的bean： 一個applicationContext.xml配置檔案，這個不可少； 一個bean，這裡我沒用介面，直接用一個普通的類做為Spring的bean； 一個Junit測試類； applicationCon

Spring-Boot 載入Bean的幾種方式

Spring從3.0之後，就逐步傾向於使用java code config方式來進行bean的配置，在spring-boot中，這種風格就更為明顯了。 在檢視spring-boot工程的時候，總想著探究一下spring-boot如何簡單的宣告一個starter、Enable××，就

spring 啟動載入資料，訪問資料庫

首先，說下應用場景。 專案中時常會用到spring專案啟動需要載入一些全域性資料，如訪問資料庫獲取一些基本公共資料，為此就需要在啟動載入時訪問資料，為此，專門研究了一下，發現現在網上能搜到的主要是implements InitializingBean, ServletCon

spring啟動載入程式的幾種方法

轉載自：http://blog.csdn.net/lovesomnus/article/details/50158761 關於在spring  容器初始化 bean 和銷燬前所做的操作定義方式有三種： [java] view plain copy p

spring管理載入bean錯誤；Injection of autowired dependencies failed;

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'itemController': Injection of autowired dependen

Spring啟動流程（二）之Spring載入Bean Definition的流程

繼上篇Spring啟動流程（一） prepareRefresh() prepareRefresh();//初始化配置和環境 obtainFreshBeanFactory() // Tell the subclass to refresh the internal bean fac

Spring原始碼閱讀——bean的載入過程解析

前言 在上一節中，我們已經瞭解過Spring對bean從XML中提取，並且以BeanDefinition型別解析註冊到Spring的DefaultListableBeanFactory中取了，那麼，接下來就應該來看下我們在Spring中獲取一個例項過程中，bean是如何載入成為我們需

spring啟動component-scan類掃描載入過程---原始碼分析

最近因為寫書的事情，一段時間沒有寫部落格了，有朋友最近問到了spring載入類的過程，尤其是基於annotation註解的載入過程，有些時候如果由於某些系統部署的問題，載入不到，很是不解！就針對這個問題，我這篇部落格說說spring啟動過程，用原始碼來說明，這部分內容也會在

Spring原始碼閱讀——Bean的載入和獲取過程

我們經常使用Spring，並且也都瞭解其大概原理。我想我們一定會對Spring原始碼的解讀有迫切的渴望。 我也如此。所以，我打算閱讀一下Spring的原始碼。再此之前，我也為此準備了很多。包括，去複習熟練java反射，理解常用的設計模式。當然，這些複習筆記也會在今後的複習中

spring 設定通過程式碼啟動載入配置檔案和設定啟動順序

通過這種方式載入可以使用maven模組化，拋開web.xml的束縛。 @Order(1) public class SpringConfigInitializer extends AbstractContextLoaderInitializer   implements

spring 解析xml載入bean的整個過程

第一步從spring的容器重新整理開始 org.springframework.context.support.AbstractApplicationContext#refresh ConfigurableListableBeanFactory b

spring啟動component-scan類掃描載入過程

有朋友最近問到了 spring 載入類的過程，尤其是基於 annotation 註解的載入過程，有些時候如果由於某些系統部署的問題，載入不到，很是不解！就針對這個問題，我這篇部落格說說spring啟動過程，用原始碼來說明，這部分內容也會在書中出現，只是表達方式會稍微有些區別，

Spring 啟動過程,bean到底是什麼時候通過反射生成例項的

Spring 啟動時最重要的方法refresh()， 1. 在obtainFreshBeanFactory();中建立所有物件的BeanDefinition 2. 在finishBeanFactoryInitialization(beanFactory);中

基於spring boot的Bean 的配置與載入過程

      好久沒寫部落格了，前幾天在專案中用到了在系統啟動時候用redis 載入資料，我就在思考，啟動的時候載入資料，那就應該是配置一個bean，至於spring的bean是單例模式，不在本次的討論範圍之內，我記得是spring啟動的例項化的bean都是單例的，只是單純的記

Web專案使用Spring框架伺服器啟動載入xml檔案的過程學習

個人在Tomcat簡單部署了一個web專案，console啟動日誌。 2015-9-13 20:36:39 org.apache.catalina.core.AprLifecycleListener init 資訊: The APR based Apache Tomcat

spring啟動加載過程源碼分析

fault prot instant 消息 成了 ner 設置 [] wire 我們知道啟動spring容器兩常見的兩種方式（其實都是加載spring容器的xml配置文件時啟動的）： 1.在應用程序下加載 ApplicationContext ctx = new Clas

Spring IOC 容器源碼分析 - 創建單例 bean 的過程

event version trac 方法 del lB ctu prepare 先來 1. 簡介 在上一篇文章中，我比較詳細的分析了獲取 bean 的方法，也就是getBean(String)的實現邏輯。對於已實例化好的單例 bean，getBean(String) 方法