2. 程式人生 > >Spring MVC原理之Spring應用上下文（IoC容器）在Web容器中的啟動分析

Spring MVC原理之Spring應用上下文（IoC容器）在Web容器中的啟動分析

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

Spring IoC是一個獨立的模組，它並不是直接在Web容器中發揮作用的。如果要在Web環境中使用IoC容器，需要Spring為IoC設計一個啟動過程，把IoC容器導人，並在Web容器中建立起來。具體說來，這個啟動過程是和Web容器的啟動過程整合在一起的。在這個過程中，一方面處理Web容器的啟動，另一方面通過設計特定的Web容器攔截器，將IoC容器載入到Web環境中來.並將其初始化。在這個過程建立完成以後， IoC容器才能正常工作，而SpringMVC是建立在IoC容器的基礎上的，這樣才能建立起MVC框架的執行機制，從而響應從Web容器傳遞的HTTP請求。

下面以Tomcat容器為例子進行分析。在Tomcat中，web.xml

是應用的部署描述檔案。在web.xm.中常常看到與Spring相關的部署描述如下：

    <!-- 載入spring容器 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring/applicationContext-*.xml</param-value>
    </context-param>
    <listener>
 

        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- springmvc的前端控制器 -->
    <servlet>
        <servlet-name>tt-manager</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class
 
>
        <!-- contextConfigLocation不是必須的， 如果不配置contextConfigLocation， springmvc的配置檔案預設在：WEB-INF/servlet的name+"-servlet.xml" -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring/springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>tt-manager</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

這裡看到的部署描述是Spring MVC與Tomcat的介面部分。在這個部署描述檔案中。首先定義了一個Servlet物件，它是Spring MVC的DispatcherServlet。這個DispatcherServlet是MVC中很重要的一個類，起著分發請求的作用。同時，在部署描述中，為這個DispatcherServlet定義了應的URL對映，這些URL對映為這個Servlet指定了需要處理的HTTP請求。

context-param引數的配裡用來指定Spring IoC容器讀取Bean定義的XML檔案的路徑，在這裡。這個配且檔案被定義為classpath:spring/applicationContext-*.xml下的檔案中，可以看到Spring應用的Bean配置。最後，作為Spring MVC的啟動類，Contex tLoaderListener被定義為一個監聽器，這個監聽器是與Web伺服器的生命週期相關聯的。由ContextLoaderListener監聽器負責完成IoC容器在Web環魂中的啟動工作.

IoC容器啟動的基本過程

IOC容器的啟動過程就是建立上下文的過程，該上下文是與SerVietContext相伴而生的，同時也是IoC容器在Web應用環境中的具體表現之一。由ConteztLoaderListener啟動的上下文為根上下文。在根上下文的基礎上.還有一個與Web MVC相關的上下文用來儲存控制器(DispatcherServlet)需要的MVC物件，作為根上下文的子上下文，構成一個層次化的上下文體系。

在Web容器中啟動Spring應用程式時.首先建立根上下文.然後建立這個上下文體系的，這個上下文體系的建立是由ContextLoder來完成的。具體如下圖：

在web.xml中，已經配了ContextLoaderListener，這個ConteztLoaderListener提Spring提供的類，是為在Web容器中建立IoC容器服務的。它實現了ServletContextListener介面。這個介面是在Servlet API中定義的，提供了與Servlet生命週期結合的回撥，比如contextlnitialized方法和contextDestroyed方法。
而在Web容器中，建立WebApplicationContext的過程，是在contextlnitialized的介面實現中完成的。具體的載入IoC容器的過程是由ContextLoaderListener交由ContextLoader來完成的，而ContextLoader本身就是ContextLoaderListener的基類.它們之間的類關係如下圖：

總之，ContextLoaderListener是SpringMVC的入口，通過父類ContextLoader來實現IoC容器的初始化，通過實現ServletContextListener介面，通過監聽來建立或銷燬WebApplicationContext（IoC容器）。

Web容器中的上下文設計

為了方便在Web環境中使用IoC容器，Spring為Web應用提供了上下文的擴充套件介面WebApplicationContext來滿足啟動過程的需要。

在這個類繼承關係中，可以從熟悉的XmlWebApplicationContext入手來了解它的介面實現.在介面設計中，最後是通過ApplicationContex介面與BeanFactory介面對接的，而對於具體的功能實現，很多都是封裝在其基類AbstractRefreshableWebApplicationContext中完成的。
WebApplicationContext和XmlWebApplicationContext中定義了很多常量，如下：

public interface WebApplicationContext extends ApplicationContext {
    //用於在ServletContext中存取 根上下文
    String ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE = WebApplicationContext.class.getName() + ".ROOT";
    String SCOPE_REQUEST = "request";
    String SCOPE_SESSION = "session";
    String SCOPE_APPLICATION = "application";
    String SERVLET_CONTEXT_BEAN_NAME = "servletContext";
    String CONTEXT_PARAMETERS_BEAN_NAME = "contextParameters";
    String CONTEXT_ATTRIBUTES_BEAN_NAME = "contextAttributes";

    @Nullable
    ServletContext getServletContext();   //可以取得Web容器的ServletContext
}
public class XmlWebApplicationContext extends AbstractRefreshableWebApplicationContext {
    //預設的Bean資訊路徑
    public static final String DEFAULT_CONFIG_LOCATION = "/WEB-INF/applicationContext.xml";
    //預設的配置檔案位裡在/WEB-INF/目錄下
    public static final String DEFAULT_CONFIG_LOCATION_PREFIX = "/WEB-INF/";
    //預設的配置檔案字尾名.xml檔案
    public static final String DEFAULT_CONFIG_LOCATION_SUFFIX = ".xml";

    public XmlWebApplicationContext() {
    }
    //refresh(）時啟動
    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
        beanDefinitionReader.setEnvironment(this.getEnvironment());
        beanDefinitionReader.setResourceLoader(this);
        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
        this.initBeanDefinitionReader(beanDefinitionReader);
        this.loadBeanDefinitions(beanDefinitionReader);
    }

    protected void initBeanDefinitionReader(XmlBeanDefinitionReader beanDefinitionReader) {
    }
    //這個初始化過程是由refreshBeanFactory方法來完成的.這裡只是負責載入BeanDefinition
    protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException {
        String[] configLocations = this.getConfigLocations();
        if (configLocations != null) {
            String[] var3 = configLocations;
            int var4 = configLocations.length;

            for(int var5 = 0; var5 < var4; ++var5) {
                String configLocation = var3[var5];
                reader.loadBeanDefinitions(configLocation);
            }
        }

    }

    //這裡是取得Resource位置的地方.使用了設定的預設配置位置!預設的配置位置是/WEB-INF/applicationContext.xml
    protected String[] getDefaultConfigLocations() {
        return this.getNamespace() != null ? new String[]{"/WEB-INF/" + this.getNamespace() + ".xml"} : new String[]{"/WEB-INF/applicationContext.xml"};
    }

}

從程式碼中可以看到，在XmlWebApplicationContext中，基本的上下文功能都已經通過類的繼承獲得，這裡需要處理的是，如何獲取Bean定義資訊，在這裡，就轉化為如何在Web容器環境如這裡指定的/WEB -INF/applicationContext.xml中獲得Bean定義資訊。這就解釋了為什麼我們開發的時候，web.xml檔案一般放在/WEB -INF/下。

ContextLoader的設計與實現

對於Spring承載的Web應用而言，可以指定在Web應用程式啟動時載人IoC容器(或者稱為WebAppl icationCon text)。這個功能是由ContextLoaderListener這樣的類來完成的，它是在Web容器中配置的監聽器。這個ContextLoaderListener通過使用ContextLoader來完成實際的WebApplicationContext，也就是IoC容器的初始化工作。這個ContextLoader就像Spring應用程式在Web容器中的啟動器。這個啟動過程是在Web容器中發生的，所以需要根據Web容器部署的要求來定義ContextLoader。

下面分析具體的根上下文的載入過程。在ContextLoaderListener中，實現的是ServletContextListener介面，這個接口裡的函式會結合Web容器的生命週期被呼叫。因為ServletContextListener是ServletContext的監聽者，如果ServletContext發生變化.會觸發出相應的事件，而監聽器一直在對這些事件進行監聽，如果接收到了監聽的事件，就會做出預先設計好的響應動作。

由於ServletContext的變化而觸發的監聽器的響應具體包括：在伺服器啟動時，ServletContext被建立。伺服器關閉時，ServletContext將被銷燬等。對應這些事件及Web容器狀態的變化，在監聽器中定義了對應的事件響應的回撥方法。比如在伺服器啟動時，ServletContextListener的contextlnitialized()方法被呼叫，伺服器將要關閉時，ServletContextListener的contextDestroyed()方法被呼叫。

public class ContextLoaderListener extends ContextLoader implements ServletContextListener {
    public ContextLoaderListener() {
    }

    public ContextLoaderListener(WebApplicationContext context) {
        super(context);
    }
    //在伺服器啟動時，ServletContext被建立
    public void contextInitialized(ServletContextEvent event) {
        this.initWebApplicationContext(event.getServletContext()); //具體的初始化工作交給ContextLoader來完成
    }
    //伺服器關閉時，ServletContext將被銷燬
    public void contextDestroyed(ServletContextEvent event) {
        this.closeWebApplicationContext(event.getServletContext());
        ContextCleanupListener.cleanupAttributes(event.getServletContext());
    }
}

看看ContextLoader中的建立方法：

public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
        //判斷是否已經有上下文存在，key就是之前WebApplicationContext定義的
        if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
            throw new IllegalStateException("Cannot initialize context because there is already a root application context present - check whether you have multiple ContextLoader* definitions in your web.xml!");
        } else {
            Log logger = LogFactory.getLog(ContextLoader.class);
            servletContext.log("Initializing Spring root WebApplicationContext");
            if (logger.isInfoEnabled()) {
                logger.info("Root WebApplicationContext: initialization started");
            }

            long startTime = System.currentTimeMillis();

            try {
                if (this.context == null) {
                    //建立根上下文
                    this.context = this.createWebApplicationContext(servletContext);
                }

                if (this.context instanceof ConfigurableWebApplicationContext) {
                    ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext)this.context;
                    if (!cwac.isActive()) {
                        if (cwac.getParent() == null) {
                            ApplicationContext parent = this.loadParentContext(servletContext);
                            //這裡載入根上下文的雙親上下文
                            cwac.setParent(parent);
                        }

                        this.configureAndRefreshWebApplicationContext(cwac, servletContext);
                    }
                }
                //將根上下文儲存到servletContext中，key是之前WebApplicationContext中定義的
                servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
                ClassLoader ccl = Thread.currentThread().getContextClassLoader();
                if (ccl == ContextLoader.class.getClassLoader()) {
                    currentContext = this.context;
                } else if (ccl != null) {
                    currentContextPerThread.put(ccl, this.context);
                }

                if (logger.isDebugEnabled()) {
                    logger.debug("Published root WebApplicationContext as ServletContext attribute with name [" + WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
                }

                if (logger.isInfoEnabled()) {
                    long elapsedTime = System.currentTimeMillis() - startTime;
                    logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");
                }

                return this.context;
            } catch (RuntimeException var8) {
                logger.error("Context initialization failed", var8);
                servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, var8);
                throw var8;
            } catch (Error var9) {
                logger.error("Context initialization failed", var9);
                servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, var9);
                throw var9;
            }
        }
    }

    //建立根上下文的方法
   protected WebApplicationContext createWebApplicationContext(ServletContext sc) {
       //這裡判斷使用什麼樣的類在Web容界中作為IoC容界
        Class<?> contextClass = this.determineContextClass(sc);
        if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
            throw new ApplicationContextException("Custom context class [" + contextClass.getName() + "] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]");
        } else {
        //直接例項化要產生的IOC容器
            return (ConfigurableWebApplicationContext)BeanUtils.instantiateClass(contextClass);
        }
    }

在初始化這個上下文以後，該上下文會被儲存到SevletContext中，這樣就建立了一個全域性的關於整個應用的上下文。同時，在啟動Spring MVC時.我們還會看到這個上下文被以後的DispatcherServlet在進行自己持有的上下文的初始化時，設定為DispatcherServlet自帶的上下文的雙親上下文。

相關推薦

Spring MVC原理之Spring應用上下文（IoC容器）在Web容器中的啟動分析

Spring IoC是一個獨立的模組，它並不是直接在Web容器中發揮作用的。如果要在Web環境中使用IoC容器，需要Spring為IoC設計一個啟動過程，把IoC容器導人，並在Web容器中建立起來。具體說來，這個啟動過程是和Web容器的啟動過程整合在一起的

Spring-MVC理解之一：應用上下文webApplicationContext

節點 lba filter lin title tin sed 找不到 默認 原文轉至 http://www.cnblogs.com/brolan... 一、先說ServletContext 　　javaee標準規定了，servlet容器需要在應用項目啟動時，給應

Spring MVC系列之模型繫結（SpringBoot）（七）

前言 上一節我們在SpringBoot中啟用了Spring MVC最終輸出了HelloWorld，本節我們來講講Spring MVC中的模型繫結，這個名稱來源於.NET或.NET Core，不知是否恰當，我們暫且這樣理解吧。 @RequestParam VS  @PathVariable &n

spring mvc 上傳檔案幫助類（留備用）

package com.service.impl; import com.entity.UploadInfo; import com.service.UploadHelp; import org.springframework.web.context.ContextLoader; import o

Spring之思維導圖（IOC篇）

轉載原文：https://mp.weixin.qq.com/s/TQvmt84imz77oTcH7KQ1rQ 寫過java的都知道：所有的物件都必須建立；或者說：使用物件之前必須先建立。而使用ioc之後，你就可以不再手動建立物件，而是從ioc容器中直接獲取物件。   就好像我們

Spring MVC 基於Method的對映規則（註解版）

在Restful風格的web開發中，根據不同的請求方法使用相應的控制器處理邏輯成為核心需求，下面就看看如何在Spring MVC中識別不同的請求方法。 請求方法 在Http中，請求的方法有很多種，最常見的就是GET、POST，他們的差異就不過多贅述了。由於Restful概念的興起，即使用Url的不同請求方

Spring MVC 基於URL的對映規則（註解版）

好幾天沒有跟進Spring MVC的學習了，之前看了點原始碼都忘的差不多了。這次就跟著之前的問題，繼續總結下Spring MVC中的小知識。 關於SpringMVC的小demo可以參考這裡！ url-pattern 如果看過前一篇入門的帖子，應該瞭解到sprin

JavaWeb（十二）---web.xml 中的listener、 filter、servlet 載入順序及其詳解

一、建立順序 　　1、web.xml檔案中的載入順序為：listener-filter-servlet 　　2、如果web.xml中配置了<context-param>，初始化順序： 　　　　　　context-param > Listener > Filter

Spring MVC原理介紹（工作流程）

Spring MVC工作流程圖   圖一   圖二    Spring工作流程描述       1. 使用者向伺服器傳送請求，請求被Spring 前端控制Servelt Dispa

第四十章：Spring MVC框架之執行原理12

第十章 SpringMVC執行原理 找到一篇寫的不錯的部落格，大家可以看看 第一節 幾個重要元件 1.HandlerMapping 代表請求地址到handler之間的對映。 2.HandlerExecutionChain handler的執行鏈物件，由handler物件和所有ha

Spring原始碼解讀之Spring MVC HandlerMapping元件（二）

一、HandlerMapping HandlerMapping作用是根據request找到相應的處理器Handler和Interceptors，並將Handler和Interceptors封裝成HandlerExecutionChain 物件返回。Handler

Spring MVC總結之工作原理詳解

目錄 1.MVC思想/模式 2.Spring MVC的前端控制器（DispatcherServlet） 3.業務控制器Handle 4.Spring MVC的請求流程： 1.MVC思想/模式 1.1 MVC思想將一個應用分為三個基本部分：Model(模型)、Vie

Spring學習筆記一： Bean工廠（BeanFactory ）與應用上下文（ApplicationContext）BeanFactory

bean工廠:最簡單的容器，提供了基礎的依賴注入支援。建立各種型別的Bean. 應用上下文(ApplicationContext):建立在bean工廠基礎之上，提供系統架構服務。 beans包提供了以程式設計的方式管理和操控bean的基本功能，而contex

Spring mvc請求處理流程詳解（一）之檢視解析

前言 　　Spring mvc框架相信很多人都很熟悉了，關於這方面的資料也是一搜一大把。但是感覺講的都不是很細緻，讓很多初學者都雲裡霧裡的。本人也是這樣，之前研究過，但是後面一段時間不用發現又忘記了。所以決定寫下來，以備後用。 　　本系列文基於spring-

【系統學習SpringBoot】再遇Spring Data JPA之JPA應用詳解（自定義查詢及複雜查詢）

在此，對Spring Data Jpa做詳細的筆記（使用層面的，原理層日後再說哈哈。） 一、Spring Data JPA設定建立方式： 建立方式一共分為四種： #配置資料庫，使用SpringJPA spring: datasource:

OSGI企業應用開發（十五）基於Spring、Mybatis、Spring MVC實現一個登入應用

前面文章中，我們已經完成了OSGI應用中Spring、Mybatis、Spring MVC的整合，本篇文章我們就在這個基礎上來完成一個簡單的登入應用，其中使用者名稱和密碼需要從資料庫中查詢。 前面文章中，我們已經搭建好的工作空間如下圖所示： 本篇文章中，

Spring MVC系列之JDBC Demo（SpringBoot）（七）

前言 前面我們瞭解了Spring MVC的基本使用，其實和.NET或.NET Core MVC無異，只是語法不同而已罷了，本節我們將和和資料庫打交道，從最基礎的JDBC講解起，文中若有錯誤之處，還望指正。 JDBC Demo 我們需要下載三個包：JDBC驅動包(mysql-connector-java)、sp

Spring原始碼解析之基礎應用（二）

方法注入 在spring容器中，大部分bean的作用域（scope）是單例（singleton）的，少部分bean的作用域是原型（prototype），如果一個bean的作用域是原型，我們A bean的作用域是原型，B bean中以@Autowired的方式注入A，那麼B在A中依舊是單例。我們可以讓B類實現A

Spring原始碼解析之基礎應用（三）

組合Java配置 在XML中，我們可以使用<import/>標籤，在一個XML檔案中引入另一個XML檔案，在Java類中，我們同樣可以在一個配置類中用@Import引入另一個配置類，被引入的配置類中的@Bean也會載入到spring容器。程式碼如下： @Configuration public

【Spring】Spring MVC原理及配置詳解

進行 return sub sca scrip uil 線程安全 松耦合 必須 1.Spring MVC概述： Spring MVC是Spring提供的一個強大而靈活的web框架。借助於註解，Spring MVC提供了幾乎是POJO的開發模式，使得控制器的開發和測試更加簡