2. 程式人生 > >簡述Spring容器與SpringMVC的容器的聯絡與區別

簡述Spring容器與SpringMVC的容器的聯絡與區別

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

摘要：

　　在spring整體框架的核心概念中，容器的核心思想是管理Bean的整個生命週期。但在一個專案中，Spring容器往往不止一個，最常見的場景就是在一個專案中引入Spring和SpringMVC這兩個框架，其本質就是兩個容器：Spring是根容器，SpringMVC是其子容器。關於這兩個容器的建立、聯絡及區別也正是本文所關注的問題。

一、引子

　　Spring和SpringMVC作為Bean管理容器和MVC層的預設框架，已被眾多web應用採用。但是在實際應用中，初級開發者常常會因對Spring和SpringMVC的配置失當導致一些奇怪的異常現象，比如Controller的方法無法攔截、Bean被多次載入等問題，這種情況發生的根本原因在於開發者對Spring容器和SpringMVC容器之間的關係瞭解不夠深入，這也正是本文要闡述的問題。

二、Spring容器、SpringMVC容器與ServletContext之間的關係

　　在Web容器中配置Spring時，你可能已經司空見慣於web.xml檔案中的以下配置程式碼，下面我們以該程式碼片段為基礎來了解Spring容器、SpringMVC容器與ServletContext之間的關係。要想理解這三者的關係，需要先熟悉Spring是怎樣在web容器中啟動起來的。Spring的啟動過程其實就是其Spring IOC容器的啟動過程。特別地，對於web程式而言，IOC容器啟動過程即是建立上下文的過程。

<web-app>

    ...

    <!-- 利用Spring提供的ContextLoaderListener監聽器去監聽ServletContext物件的建立，並初始化WebApplicationContext物件 -->
 

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!-- Context Configuration locations for Spring XML files(預設查詢/WEB-INF/applicationContext.xml) -->
    <context-param>
        <param-name
 
>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

    <!-- 配置Spring MVC的前端控制器：DispatchcerServlet -->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    ...

</web-app>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

1、Spring的啟動過程

　　(1). 對於一個web應用，其部署在web容器中，web容器提供其一個全域性的上下文環境，這個上下文就是ServletContext，其為後面的spring IoC容器提供宿主環境；

　　(2). 在web.xml中會提供有contextLoaderListener。在web容器啟動時，會觸發容器初始化事件，此時contextLoaderListener會監聽到這個事件，其contextInitialized方法會被呼叫。在這個方法中，spring會初始化一個啟動上下文，這個上下文被稱為根上下文，即WebApplicationContext。WebApplicationContext是一個介面類，確切的說，其實際的實現類是XmlWebApplicationContext，它就是spring的IoC容器，其對應的Bean定義的配置由web.xml中的<context-param>標籤指定。在這個IoC容器初始化完畢後，Spring以WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE為屬性Key，將其儲存到ServletContext中，便於獲取；

　　(3). ContextLoaderListener監聽器初始化完畢後，開始初始化web.xml中配置的Servlet，這個servlet可以配置多個，以最常見的DispatcherServlet為例，這個servlet實際上是一個標準的前端控制器，用以轉發、匹配、處理每個servlet請求。DispatcherServlet上下文在初始化的時候會建立自己的IoC上下文，用以持有spring mvc相關的bean。特別地，在建立DispatcherServlet自己的IoC上下文前，會利用WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE先從ServletContext中獲取之前的根上下文(即WebApplicationContext)作為自己上下文的parent上下文。有了這個parent上下文之後，再初始化自己持有的上下文。這個DispatcherServlet初始化自己上下文的工作在其initStrategies方法中可以看到，大概的工作就是初始化處理器對映、檢視解析等。這個servlet自己持有的上下文預設實現類也是mlWebApplicationContext。初始化完畢後，spring以與servlet的名字相關(此處不是簡單的以servlet名為Key，而是通過一些轉換，具體可自行檢視原始碼)的屬性為屬性Key，也將其存到ServletContext中，以便後續使用。這樣每個servlet就持有自己的上下文，即擁有自己獨立的bean空間，同時各個servlet共享相同的bean，即根上下文(第2步中初始化的上下文)定義的那些bean。

2、Spring容器與SpringMVC的容器聯絡與區別

　　ContextLoaderListener中建立Spring容器主要用於整個Web應用程式需要共享的一些元件，比如DAO、資料庫的ConnectionFactory等；而由DispatcherServlet建立的SpringMVC的容器主要用於和該Servlet相關的一些元件，比如Controller、ViewResovler等。它們之間的關係如下：

(1). 作用範圍

　　子容器(SpringMVC容器)可以訪問父容器(Spring容器)的Bean，父容器(Spring容器)不能訪問子容器(SpringMVC容器)的Bean。也就是說，當在SpringMVC容器中getBean時，如果在自己的容器中找不到對應的bean，則會去父容器中去找，這也解釋了為什麼由SpringMVC容器建立的Controller可以獲取到Spring容器建立的Service元件的原因。

(2). 具體實現

　　在Spring的具體實現上，子容器和父容器都是通過ServletContext的setAttribute方法放到ServletContext中的。但是，ContextLoaderListener會先於DispatcherServlet建立ApplicationContext，DispatcherServlet在建立ApplicationContext時會先找到由ContextLoaderListener所建立的ApplicationContext，再將後者的ApplicationContext作為引數傳給DispatcherServlet的ApplicationContext的setParent()方法。也就是說，子容器的建立依賴於父容器的建立，父容器先於子容器建立。在Spring原始碼中，你可以在FrameServlet.Java中找到如下程式碼：

wac.setParent(parent);
  • 1
  • 1

　　其中，wac即為由DisptcherServlet建立的ApplicationContext，而parent則為有ContextLoaderListener建立的ApplicationContext。此後，框架又會呼叫ServletContext的setAttribute()方法將wac加入到ServletContext中。

三、Spring容器和SpringMVC容器的配置

　　在Spring整體框架的核心概念中，容器是核心思想，就是用來管理Bean的整個生命週期的，而在一個專案中，容器不一定只有一個，Spring中可以包括多個容器，而且容器間有上下層關係，目前最常見的一種場景就是在一個專案中引入Spring和SpringMVC這兩個框架，其實就是兩個容器：Spring是根容器，SpringMVC是其子容器。在上文中，我們提到，SpringMVC容器可以訪問Spring容器中的Bean，Spring容器不能訪問SpringMVC容器的Bean。但是，若開發者對Spring容器和SpringMVC容器之間的關係瞭解不夠深入，常常會因配置失當而導致同時配置Spring和SpringMVC時出現一些奇怪的異常，比如Controller的方法無法攔截、Bean被多次載入等問題。

　　在實際工程中，一個專案中會包括很多配置，根據不同的業務模組來劃分，我們一般思路是各負其責，明確邊界，即：Spring根容器負責所有其他非controller的Bean的註冊，而SpringMVC只負責controller相關的Bean的註冊，下面我們演示這種配置方案。

(1). Spring容器配置

　　Spring根容器負責所有其他非controller的Bean的註冊：

    <!-- 啟用註解掃描，並定義元件查詢規則 ，除了@controller，掃描所有的Bean -->
    <context:component-scan base-package="cn.edu.tju.rico">
        <context:exclude-filter type="annotation"
            expression="org.springframework.stereotype.Controller" />
    </context:component-scan>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 1
  • 2
  • 3
  • 4
  • 5

(2). SpringMVC容器配置

　　SpringMVC只負責controller相關的Bean的註冊，其中@ControllerAdvice用於對控制器進行增強，常用於實現全域性的異常處理類：

    <!-- 啟用註解掃描，並定義元件查詢規則 ，mvc層只負責掃描@Controller、@ControllerAdvice -->
    <!-- base-package 如果多個，用“,”分隔 -->
    <context:component-scan base-package="cn.edu.tju.rico"
        use-default-filters="false">
        <!-- 掃描@Controller -->
        <context:include-filter type="annotation"
            expression="org.springframework.stereotype.Controller" />
        <!--控制器增強，使一個Contoller成為全域性的異常處理類，類中用@ExceptionHandler方法註解的方法可以處理所有Controller發生的異常 -->
        <context:include-filter type="annotation"
            expression="org.springframework.web.bind.annotation.ControllerAdvice" />
    </context:component-scan>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

　　在<context:component-scan>中可以新增use-default-filters，Spring配置中的use-default-filters用來指示是否自動掃描帶有@Component、@Repository、@Service和@Controller的類。預設為true，即預設掃描。如果想要過濾其中這四個註解中的一個，比如@Repository，可以新增<context:exclude-filter />子標籤，如下：

    <context:component-scan base-package="cn.edu.tju.rico" scoped-proxy="targetClass" use-default-filters="true">  
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/>  
</context:component-scan>
  • 1
  • 2
  • 3
  • 1
  • 2
  • 3

　　而<context:include-filter/>子標籤是用來新增掃描註解的：

<context:component-scan base-package="cn.edu.tju.rico" scoped-proxy="targetClass" use-default-filters="false">  
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Repository"/>  
</context:component-scan>
  • 1
  • 2
  • 3
  • 1
  • 2
  • 3

四、Spring容器和SpringMVC容器的配置失當帶來的問題

1、問題描述

　　在一個專案中，想使用Spring AOP在Controller中切入一些邏輯，但發現不能切入到Controller的中，但可以切入到Service中。最初的配置情形如下：

1). Spring的配置檔案application.xml包含了開啟AOP自動代理、Service掃描配置以及Aspect的自動掃描配置，如下所示：

<aop:aspectj-autoproxy/>
<context:component-scan base-package="cn.edu.tju.rico">
  • 1
  • 2
  • 1
  • 2

2). Spring MVC的配置檔案spring-mvc.xml主要內容是Controller層的自動掃描配置。

<context:component-scan base-package="cn.edu.tju.rico.controller" />
  • 1
  • 1

3). 增強程式碼為如下:

@Component
@Aspect
public class SecurityAspect {

    private static final String DEFAULT_TOKEN_NAME = "X-Token";

    private TokenManager tokenManager;

    @Resource(name = "tokenManager")
    public void setTokenManager(TokenManager tokenManager) {
        this.tokenManager = tokenManager;
    }

    @Around("@annotation(org.springframework.web.bind.annotation.RequestMapping)")
    public Object execute(ProceedingJoinPoint pjp) throws Throwable {
        // 從切點上獲取目標方法
        MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
        Method method = methodSignature.getMethod();
        // 若目標方法忽略了安全性檢查，則直接呼叫目標方法
        if (method.isAnnotationPresent(IgnoreSecurity.class)) {
            System.out
                    .println("method.isAnnotationPresent(IgnoreSecurity.class) : "
                            + method.isAnnotationPresent(IgnoreSecurity.class));
            return pjp.proceed();
        }
        // 從 request header 中獲取當前 token
        String token = WebContext.getRequest().getHeader(DEFAULT_TOKEN_NAME);
        // 檢查 token 有效性
        if (!tokenManager.checkToken(token)) {
            String message = String.format("token [%s] is invalid", token);
            throw new TokenException(message);
        }
        // 呼叫目標方法
        return pjp.proceed();
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

4). 需要被代理的Controller如下:

@RestController
@RequestMapping("/tokens")
public class TokenController {

    private UserService userService;
    private TokenManager tokenManager;

    public UserService getUserService() {
        return userService;
    }

    @Resource(name = "userService")
    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public TokenManager getTokenManager() {
        return tokenManager;
    }

    @Resource(name = "tokenManager")
    public void setTokenManager(TokenManager tokenManager) {
        this.tokenManager = tokenManager;
    }

    @RequestMapping(method = RequestMethod.POST)
    @IgnoreSecurity
    public Response login(@RequestParam("uname") String uname,
            @RequestParam("passwd") String passwd) {
        boolean flag = userService.login(uname, passwd);
        if (flag) {
            String token = tokenManager.createToken(uname);
            System.out.println("**** Token **** : " + token);
            return new Response().success("Login Success...");
        }
        return new Response().failure("Login Failure...");
    }

    @RequestMapping(method = RequestMethod.DELETE)
    @IgnoreSecurity
    public Response logout(@RequestParam("uname") String uname) {
        tokenManager.deleteToken(uname);
        return new Response().success("Logout Success...");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

　　在執行過程中，發現這樣配置並沒有起作用，AOP配置不生效，沒有生成TokenController的代理。

2、解決方案

　　由上一節可知，Spring容器先於SpringMVC容器進行建立，並且SpringMVC容器的建立依賴於Spring容器。在SpringMVC容器建立TokenController時，由於其沒有啟用AOP代理，並且父容器的配置與子容器配置的獨立性，導致SpringMVC容器沒有為TokenController生成代理，所以沒有生效。我們只需要在SpringMVC的配置檔案中新增Aspect的自動掃描配置即可：

<aop:aspectj-autoproxy/>
<context:component-scan base-package="com.hodc.sdk.controller" />
  • 1
  • 2
  • 1
  • 2

相關推薦

Spring 與 SpringMVC 容器父子關係引出的相應問題

1）關係說明 spring 與 springmvc 父子關係：spring (父容器)，springmvc (子容器) springmvc（子）--- 可呼叫 --> spring（父） 中的 bean，屬性值等 但 spring（父）-- 不

spring容器和springmvc容器，以及web容器的關系

初始化 pack font BE 識別 exti 定義 獲取spring gmv 　　說到spring和springmvc，其實有很多工作好多年的人也分不清他們有什麽區別，如果你問他項目裏用的什麽MVC技術，他會說我們用的spring和mybatis，或者spring和hi

spring容器和springmvc容器，以及web容器的關係

說到spring和springmvc，其實有很多工作好多年的人也分不清他們有什麼區別，如果你問他專案裡用的什麼MVC技術，他會說我們用的spring和mybatis，或者spring和hibernate。在潛意識裡會認為springmvc就是spring，之前我也是這麼認為的，哈哈。 　　雖然springMV

Web容器、Servlet容器、Spring容器、SpringMVC容器之間的關系

org 自動 har dwr cer times 配置信息 很多 一個 以下內容為個人理解，如有誤還請留言指出，不勝感激！ Web容器 web容器（web服務器）主要有：Apache、IIS、Tomcat、Jetty、JBoss、webLogic等，而Tomcat

Java Servlet 過濾器與 springmvc 攔截器的區別？

結果 dap ber 如果 exce 流程 @override clas 出錯 前言：在工作中，遇到需要記錄日誌的情況，不知道該選擇過濾器還是攔截器，故總結了一下。 servlet 過濾器 定義 　　java過濾器能夠對目標資源的請求和響應進行截取。過濾器的工作方式分為

hashCode與equals的聯絡與區別

一、equals方法的作用 1、預設情況（沒有覆蓋equals方法）下equals方法都是呼叫Object類的equals方法，而Object的equals方法主要用於判斷物件的記憶體地址引用是不是同一個地址（是不是同一個物件）。 2 、要是類中覆蓋了equals方法，那麼就要根據具

結構體與物件的聯絡與區別

結構體與物件的聯絡與區別 1.結構體是一種值型別，而類是引用型別。值型別用於儲存資料的值，引用型別用於儲存對實際資料的引用。 那麼結構體就是當成值來使用的，類則通過引用來對實際資料操作。   2.結構使用棧儲存（Stack Allocation），而類使用堆儲存（Heap Allocatio

hive與hbase的聯絡與區別

兩者分別是什麼？ Apache Hive是一個構建在Hadoop基礎設施之上的資料倉庫。通過Hive可以使用HQL語言查詢存放在HDFS上的資料。HQL是一種類SQL語言，這種語言最終被轉化為Map/Reduce. 雖然Hive提供了SQL查詢功能，但是

iOS --- UIView與CALayer的聯絡與區別

UIView是iOS系統中介面元素的基礎, 所有的介面元素都繼承自它, UIView本身完全是由CoreAnimation來實現. 真正的繪圖部分, 是由一個CALayer類來管理. UIView更像是一個CALayer的管理器, 所以訪問它的與繪圖和座標相關的

prototype與__proto__的聯絡與區別

寫在前面 這篇文章我的目的是試圖講清楚prototype與__proto__。很多人也許和我一樣，很困擾於這兩個東西究竟是幹啥的，網上的各種資料也是講的雲裡霧裡，傻傻分不清楚。今天我就來嘗試把它們說清楚。 JavaScript裡沒有類的概念 首先必須明

終於弄明白了include()與require()的聯絡與區別

----------------------------------　　1分多鐘，銀行卡里的3120元錢被人分4次從網上銀行取走，隨後又多次轉賬，讓你查詢不到這筆錢的去處……這些天來，市民向小姐一直在為自己網上銀行被盜一事煩心。在加入“網上工行受害者聯盟”後，她又發現該QQ群中與有著和自己同樣遭遇的人竟多達7

fseek函式與ftell函式聯絡與區別

fseek函式是 用來設定檔案的當前讀寫位置. 函式原型:   int fseek(FILE *fp,long offset,int origin); 函式功能:把fp的檔案讀寫位置指標移到指定的位置. fseek(fp,20,SEEK_SET); 意思是把fp檔案

淺談JS __proto__與prototype的聯絡與區別

學習JavaScript也有一段時日了，今天想談一下JS中一個比較重要的關鍵概念——原型（prototype） 什麼是原型？ W3School中是如此描述原型的： “Every JavaScript object has a prototype. Th

51微控制器PSW之CY與OV的聯絡與區別

1.先從計算機儲存的機制說起： 直接說有符號數，先說一個位元組的的補碼錶示範圍為-2^7~（2^7-1），即-128~127。 當X>0時，X[原碼]=[反碼]=[補碼]； 當X=0時，存在[＋0]和[-0]兩種表示形式，[＋0]原=0000 000，[＋0]反=00

http與socket的聯絡和區別

如題疑問也是我初學時糾結的問題。 嚴格意義上說，http和socket是兩個不同的概念，談不上什麼對比區別。 網路從上往下，可以分為五層：應用層、傳輸層、網路層、資料鏈路層、物理層。 （不同的識別法，

OAUTH、OPENID、SAML、CAS做統一認證與授權的聯絡與區別

首先，SSO和許可權控制是兩回事： 1、CAS系統解決單點登入問題，對身份認證的具體方法不做要求。 2、Oauth、openID、SAML是身份身份認證授權的規範和標準，是解決認證授權問題的。 OpenID與Oauth協議的區別，可以從其標準定義的核心應用場景來分

Struts2中Action與Servlet的聯絡與區別

Servlet處理客戶端請求的步驟： 1、Web客戶向Servlet容器（Tomcat）發出Http請求 2、Servlet容器分析客戶的請求資訊 3、Servlet容器建立一個HttpServletRequest物件，將客戶請求的資訊封裝到這個物件中 4、Servlet容

簡述Spring容器與SpringMVC的容器的聯絡與區別

摘要： 　　在spring整體框架的核心概念中，容器的核心思想是管理Bean的整個生命週期。但在一個專案中，Spring容器往往不止一個，最常見的場景就是在一個專案中引入Spring和SpringMVC這兩個框架，其本質就是兩個容器：Spring是根容器，SpringMVC是其子容器。關於這兩個容器的建立、

SpringMVC系列（十五）Spring MVC與Spring整合時實例被創建兩次的解決方案以及Spring 的 IOC 容器和 SpringMVC 的 IOC 容器的關系

問題 nbsp frame ota 展示 not als pri exc 一、Spring MVC與Spring整合時實例被創建兩次的解決方案 1.問題產生的原因 Spring MVC的配置文件和Spring的配置文件裏面都使用了掃描註解<context:compon

Spring與SpringMVC父子容器

如果使用SpringMVC則會在專案中出現父子容器。 如果使用Spring ContextLoaderListener載入並初始化的IOC------------父容器 如果使用SpringMVC DispathcherServlet載入並初始化的IOC--