2. 程式人生 > >spring之我見--Controller註冊到DispatchServlet請求處理（上）

spring之我見--Controller註冊到DispatchServlet請求處理（上）

阿新 • • 發佈：2018-11-09

對應上一章 《spring之我見–從spring的啟動到ioc容器的建立》

今天我們探討一下Springmvc的工作原理，Springmvc的核心是Controller請求部分，所以我們的探討從Controller被註冊開始，到Controller如何被請求的。

1.Controller註冊前的準備工作

1.1 refresh()

上一章我們知道IOC容器是在ContextLoaderListener（ServletContextListener的實現類）下初始化的，而初始化的重要步驟是在ConfigurableApplicationContext的refresh ()方法下完成的，根據下面的註釋，refresh 方法負責載入配置檔案，比如常見的spring配置檔案applicationContext.xml

/**
 *  載入或重新整理配置的持久表示，這可能是XML檔案、屬性檔案或關係資料庫模式。
 * Load or refresh the persistent representation of the configuration,
 * which might an XML file, properties file, or relational database schema.
 * <p>As this is a startup method, it should destroy already created singletons
 * if it fails, to
 
 avoid dangling resources. In other words, after invocation
 * of that method, either all or no singletons at all should be instantiated.
 * @throws BeansException if the bean factory could not be initialized
 * @throws IllegalStateException if already initialized and multiple refresh
 * attempts are not
 
 supported
 */
void refresh() throws BeansException, IllegalStateException;

這是refresh()具體實現，做了很多事，我們具體進obtainFreshBeanFactory()方法。

@Override
    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) {
                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();
            }
        }
    }

當走到refreshBeanFactory()方法，我們看到loadBeanDefinitions()方法，官方解釋為 將bean定義載入到給定的bean工廠中，通常是通過委託給一個或多個bean定義閱讀器。話句話說 這裡就是生成BeanDefinition元資料的地方，BeanFactory不直接儲存例項，而是元資料，根據需要用反射等手段將BeanDefinition轉換成例項，我們的Controller當然也需要先轉換成元資料，

protected final void refreshBeanFactory() throws BeansException {
        if (hasBeanFactory()) {
            destroyBeans();
            closeBeanFactory();
        }
        try {
            DefaultListableBeanFactory beanFactory = createBeanFactory();
            beanFactory.setSerializationId(getId());
            customizeBeanFactory(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);
        }
    }

spring的呼叫棧比較深，我這裡只是挑重要的地方解釋，最主要還是自己debug走一遍。
當走到loadBeanDefinitions(XmlBeanDefinitionReader reader)方法（這跟上一個loadBeanDefinitions方法不是一樣，是過載方法），我們發現它開始讀配置檔案，這個configLocations陣列就一個String物件：“/WEB-INF/applicationContext.xml” .

    protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException {
        String[] configLocations = getConfigLocations();
        if (configLocations != null) {
            for (String configLocation : configLocations) {
                reader.loadBeanDefinitions(configLocation);
            }
        }
    }

而我們的applicationContext.xml檔案就寫了兩句，為了註冊一個controller。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- @Controller 掃描 -->
    <context:component-scan base-package="controller" />

    <!-- 註解驅動: 作用:替我們自動配置最新版的註解的處理器對映器和處理器介面卡 -->
    <mvc:annotation-driven />

</beans>

順便我也把controller貼出來吧。

package controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;

/**
 * @author panqian
 * @Description:
 * @date 2018/1/26
 */
@RestController
@RequestMapping("controller")
public class TestController {

    @GetMapping("test")
    public void test(HttpServletRequest request) {
        System.out.println("");
    }
}

有人問為什麼系統知道“/WEB-INF/applicationContext.xml” 這個路徑，一開始我也納悶，但是既然能debug，我們就能知道程式執行的堆疊鏈，所以我在setConfigLocation打一個斷點，根據堆疊鏈往前找，直接就可以找到答案。
這裡寫圖片描述

sc就是ServletContext，還記得上一章我們在web.xml寫的一個啟動的InitParameter？路徑就是從這裡取的。

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml</param-value>
    </context-param>
public static final String CONFIG_LOCATION_PARAM = "contextConfigLocation";
String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
if (configLocationParam != null) {
    wac.setConfigLocation(configLocationParam);
}

1.2XmlBeanDefinitionReader負責配置檔案解析

讓我們繼續往下看，剛剛拿到了檔案路徑，那我們的解析就交給了XmlBeanDefinitionReader負責，這裡面涉及解析節點，提取資訊，又是很深的呼叫棧，主要介紹一下MvcNamespaceHandler ，它針對不同的配置提供多種解析器，比如annotation-driven就用AnnotationDrivenBeanDefinitionParser。

package org.springframework.web.servlet.config;

import org.springframework.beans.factory.xml.NamespaceHandler;
import org.springframework.beans.factory.xml.NamespaceHandlerSupport;

/**
 * {@link NamespaceHandler} for Spring MVC configuration namespace.
 *
 * @author Keith Donald
 * @author Jeremy Grelle
 * @author Sebastien Deleuze
 * @since 3.0
 */
public class MvcNamespaceHandler extends NamespaceHandlerSupport {

    @Override
    public void init() {
        registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
        registerBeanDefinitionParser("default-servlet-handler", new DefaultServletHandlerBeanDefinitionParser());
        registerBeanDefinitionParser("interceptors", new InterceptorsBeanDefinitionParser());
        registerBeanDefinitionParser("resources", new ResourcesBeanDefinitionParser());
        registerBeanDefinitionParser("view-controller", new ViewControllerBeanDefinitionParser());
        registerBeanDefinitionParser("redirect-view-controller", new ViewControllerBeanDefinitionParser());
        registerBeanDefinitionParser("status-controller", new ViewControllerBeanDefinitionParser());
        registerBeanDefinitionParser("view-resolvers", new ViewResolversBeanDefinitionParser());
        registerBeanDefinitionParser("tiles-configurer", new TilesConfigurerBeanDefinitionParser());
        registerBeanDefinitionParser("freemarker-configurer", new FreeMarkerConfigurerBeanDefinitionParser());
        registerBeanDefinitionParser("velocity-configurer", new VelocityConfigurerBeanDefinitionParser());
        registerBeanDefinitionParser("groovy-configurer", new GroovyMarkupConfigurerBeanDefinitionParser());
        registerBeanDefinitionParser("script-template-configurer", new ScriptTemplateConfigurerBeanDefinitionParser());
        registerBeanDefinitionParser("cors", new CorsBeanDefinitionParser());
    }

}

AnnotationDrivenBeanDefinitionParser又具體做了什麼事呢？看它的parse()方法，

    public BeanDefinition parse(Element element, ParserContext parserContext) {
        Object source = parserContext.extractSource(element);
        XmlReaderContext readerContext = parserContext.getReaderContext();

        CompositeComponentDefinition compDefinition = new CompositeComponentDefinition(element.getTagName(), source);
        parserContext.pushContainingComponent(compDefinition);

        RuntimeBeanReference contentNegotiationManager = getContentNegotiationManager(element, source, parserContext);
// 生成 RequestMappingHandlerMapping，用於處理@Controller和@RequestMapping註解的  
        RootBeanDefinition handlerMappingDef = new RootBeanDefinition(RequestMappingHandlerMapping.class);
        handlerMappingDef.setSource(source);
        handlerMappingDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        handlerMappingDef.getPropertyValues().add("order", 0);
        handlerMappingDef.getPropertyValues().add("contentNegotiationManager", contentNegotiationManager);

        if (element.hasAttribute("enable-matrix-variables")) {
            Boolean enableMatrixVariables = Boolean.valueOf(element.getAttribute("enable-matrix-variables"));
            handlerMappingDef.getPropertyValues().add("removeSemicolonContent", !enableMatrixVariables);
        }
        else if (element.hasAttribute("enableMatrixVariables")) {
            Boolean enableMatrixVariables = Boolean.valueOf(element.getAttribute("enableMatrixVariables"));
            handlerMappingDef.getPropertyValues().add("removeSemicolonContent", !enableMatrixVariables);
        }

        configurePathMatchingProperties(handlerMappingDef, element, parserContext);

// 將該BeanDefinition加入BeanFactory工廠（ApplicationContext）
        readerContext.getRegistry().registerBeanDefinition(HANDLER_MAPPING_BEAN_NAME , handlerMappingDef);

。。。。。。
    }

上面註冊的RequestMappingHandlerMapping 和RequestMappingHandlerAdapter是為後面controller註冊和使用準備的，只有配置了<mvc:annotation-driven /> 才會註冊這些元件。

說了<mvc:annotation-driven /> 是不是還有一個<context:component-scan base-package="controller" /> ？這個標籤也有自己的parse–ComponentScanBeanDefinitionParser，它的parse方法更加簡單。

basePackage 拿到引數是我配的 “controller”，所以scanner.doScan方法直接到該包下拿到了testController的beanDefinitions，隨後註冊到 ApplicationContext中。

@Override
    public BeanDefinition parse(Element element, ParserContext parserContext) {
        String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
        basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
        String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
                ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);

        // Actually scan for bean definitions and register them.
        ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
        Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
        registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

        return null;
    }

2.生火燒飯！ Controller註冊

通過前面的分析，我們已經有了用於 Controller註冊的RequestMappingHandlerMapping，TestController也被註冊進了IOC容器中，萬事俱備，我們重新返回refresh()方法中，剛剛都是走的obtainFreshBeanFactory();而接下來的finishBeanFactoryInitialization()很重要，首先這個方法用於例項化所有(非懶載入)單例物件。 然後RequestMappingHandlerMapping是單例的，非懶載入的，所以RequestMappingHandlerMapping也會在這個方法裡處理，再加上 RequestMappingHandlerMapping的afterPropertiesSet方法是具體註冊Controller的地方，所以我們需要重點跟蹤finishBeanFactoryInitialization()的程式碼。

這是我根據的doGetBean()的部分程式碼,當輪到RequestMappingHandlerMapping開始建立例項時，會走複寫的getObject()方法。

    protected <T> T doGetBean(
            final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
            throws BeansException {
// Create bean instance.
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                        @Override
                        public Object getObject() throws BeansException {
                            try {
                                return createBean(beanName, mbd, args);
                            }
                            catch (BeansException ex) {
                                // Explicitly remove instance from singleton cache: It might have been put there
                                // eagerly by the creation process, to allow for circular reference resolution.
                                // Also remove any beans that received a temporary reference to the bean.
                                destroySingleton(beanName);
                                throw ex;
                            }
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }

}

繼續往裡走，populateBean是在封裝例項欄位值，繼續進initializeBean方法

// Initialize the bean instance.
        Object exposedObject = bean;
        try {
            populateBean(beanName, mbd, instanceWrapper);
            if (exposedObject != null) {
                exposedObject = initializeBean(beanName, exposedObject, mbd);
            }
        }

重點關注invokeInitMethods方法，這個方法給例項機會去 做一些初始化操作，而這個機會就是複寫afterPropertiesSet()方法。

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
。。。。
try {
            invokeInitMethods(beanName, wrappedBean, mbd);
        }
        catch (Throwable ex) {
            throw new BeanCreationException(
                    (mbd != null ? mbd.getResourceDescription() : null),
                    beanName, "Invocation of init method failed", ex);
        }
。。。。
}

invokeInitMethods方法會呼叫afterPropertiesSet(),那RequestMappingHandlerMapping怎麼複寫了這個方法呢？

((InitializingBean) bean).afterPropertiesSet();
@Override
    public void afterPropertiesSet() {
        this.config = new RequestMappingInfo.BuilderConfiguration();
        this.config.setUrlPathHelper(getUrlPathHelper());
        this.config.setPathMatcher(getPathMatcher());
        this.config.setSuffixPatternMatch(this.useSuffixPatternMatch);
        this.config.setTrailingSlashMatch(this.useTrailingSlashMatch);
        this.config.setRegisteredSuffixPatternMatch(this.useRegisteredSuffixPatternMatch);
        this.config.setContentNegotiationManager(getContentNegotiationManager());

        super.afterPropertiesSet();
    }
@Override
    public void afterPropertiesSet() {
        initHandlerMethods();
    }

這裡真相大白，它會先通過isHandler(beanType)判斷是不是有@Controller或@RequestMapping註釋，是的話進入detectHandlerMethods(),最後將對映寫入mappingRegistry，這是一個MappingRegistry型別，所有的前端對映都會記錄在這裡，也就達到了註冊controller的目的。

    /**
     * Scan beans in the ApplicationContext, detect and register handler methods.
     * @see #isHandler(Class)
     * @see #getMappingForMethod(Method, Class)
     * @see #handlerMethodsInitialized(Map)
     */
    protected void initHandlerMethods() {
        if (logger.isDebugEnabled()) {
            logger.debug("Looking for request mappings in application context: " + getApplicationContext());
        }
        String[] beanNames = (this.detectHandlerMethodsInAncestorContexts ?
                BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :
                getApplicationContext().getBeanNamesForType(Object.class));

        for (String beanName : beanNames) {
            if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
                Class<?> beanType = null;
                try {
                    beanType = getApplicationContext().getType(beanName);
                }
                catch (Throwable ex) {
                    // An unresolvable bean type, probably from a lazy bean - let's ignore it.
                    if (logger.isDebugEnabled()) {
                        logger.debug("Could not resolve target class for bean with name '" + beanName + "'", ex);
                    }
                }
                if (beanType != null && isHandler(beanType)) {
                    detectHandlerMethods(beanName);
                }
            }
        }
        handlerMethodsInitialized(getHandlerMethods());
    }

3.參考文獻

https://www.cnblogs.com/kindevil-zx/p/6603154.html
http://blog.csdn.net/lovesomnus/article/details/49801593

相關推薦

spring之我見--Controller註冊到DispatchServlet請求處理（上）

對應上一章 《spring之我見–從spring的啟動到ioc容器的建立》 今天我們探討一下Springmvc的工作原理，Springmvc的核心是Controller請求部分，所以我們的探討從Controller被註冊開始，到Controller如何被請求的。 1.Contro

spring之我見--Controller註冊到DispatchServlet請求處理（下）

1 DispatcherServlet請求分發 1.1 DispatcherServlet的初始化 在web.xml檔案裡，跟ContextLoaderListener形影不離的應該就是DispatcherServlet了，它一般做如下定義： <servlet>

程世東老師TensorFlow實戰——個性化推薦，程式碼學習筆記之資料匯入&資料預處理（上）

程式碼來自於知乎:https://zhuanlan.zhihu.com/p/32078473 /程式碼地址https://github.com/chengstone/movie_recommender/blob/master/movie_recommender.ipynb 下一篇有一些資料的

Spring Cloud 探索 | 服務註冊與發現 Eureka（上）

先在這裡宣告一下：這一系列的文章都是自己查詢網上資料學習而來，不可避免有些內容從其他地方copy過來，如有侵犯請聯絡我刪除，謝謝！（引用部分都會添加註腳） 本系列文章的寫作環境為：Spring Boot 2.0.7.RELEASE、Spring Cloud Fi

python web py入門-4-請求處理（上）

       這篇我們來介紹一下請求處理過程。其實，在前面python中requests做介面自動化的系列講過請求和響應。伺服器需要對客戶端傳送的請求，進行解析和處理。我們在前面文章介紹的URL對映，

【opencv入門之七】形態學圖像處理（一）：膨脹、腐蝕

tar struct show 函數 使用 運算 腐蝕和膨脹 依賴 版本 參考網站： http://blog.csdn.net/poem_qianmo/article/details/23710721 1、形態學（morphology）概述 　　數學形態學（Mathem

spring boot 1.5.4 統一異常處理（九）

springboot springboot1.5.4 springboot整合springdatajpa springboot集成jdbctemplate springboot異常處理 上一篇：springboot 1.5.4 配置文件詳解（八） 1 Spring Boot統一異

UI“三重天”之selenium--常用API和問題處理（三）

Selenium常用API： 前面兩篇示例程式碼中用到了一些selenium的API方法，例如定位元素的八種方法、訪問url、等待、操作瀏覽器、獲取title、點選、清理等等。 有關於selenium的常用API在園子中有寫的非常詳細的文章。先貼大佬文章地址：https://www.cnblogs.com

selenium之 時間日期控件的處理（轉）

ive input php same inpu find ttr gin uil 我們不去搞時間日期空間，我們把它當成一個普通的input框處理就好了！ 但是，很多此類型input框都是禁止手動輸入的，怎麽辦？ 很簡單，用js把禁止輸入的readonly屬性幹掉就好了。 來

selenium之 時間日期控制元件的處理（轉）

我們不去搞時間日期空間，我們把它當成一個普通的input框處理就好了！ 但是，很多此型別input框都是禁止手動輸入的，怎麼辦？ 很簡單，用js把禁止輸入的readonly屬性幹掉就好了。 來吧，看一下示例： 示例網址：http://www.sucaijiayuan.com/api/demo.php?

程世東老師TensorFlow實戰——個性化推薦，程式碼學習筆記之資料匯入&資料預處理（下）

這篇主要是進行程式碼中的一些數值視覺化，幫助理解 程式碼來自於知乎:https://zhuanlan.zhihu.com/p/32078473 /程式碼地址https://github.com/chengstone/movie_recommender/blob/master/movie_re

《Java從小白到大牛》之第14章 異常處理（上）

《Java從小白到大牛》紙質版已經上架了！！！ 很多事件並非總是按照人們自己設計意願順利發展的，而是有能夠出現這樣那樣的異常情況。例如：你計劃週末郊遊，你的計劃會安排滿滿的，你計劃可能是這樣的：從家裡出發→到達目的→游泳→燒烤→回家。但天有不測風雲，當前你準備

Spring AOP 自定義註解檢查請求頭（示例）

程式碼傳送門 需求 一個 Controller 可以處理 HTTP 請求 @RestController public class DemoController { @GetMapping("/hello") public String hel

Spring Cloud 探索 | 服務註冊與發現 Eureka（下）

接上文 …… 注意：以下是針對Eureka Client進行配置，如果需要對Eureka Server進行配置會有明顯的說明。 4 Spring Cloud Eureka Client 配置過程 4.1 pom.xml 新增依賴 新增Eureka Client依賴：

【OpenCV入門教程之十一】 形態學影象處理（二）：開運算、閉運算、形態學梯度、頂帽、黑帽合輯

上篇文章中，我們重點了解了腐蝕和膨脹這兩種最基本的形態學操作，而運用這兩個基本操作，我們可以實現更高階的形態學變換。所以，本文的主角是OpenCV中的morphologyEx函式，它利用基本的膨脹和腐蝕技術，來執行更加高階的形態學變換，如開閉運算、形態學梯度、“頂帽”、“黑帽

java網路程式設計之Netty流資料的傳輸處理（五）

Netty流資料的傳輸處理 Socket Buffer的缺陷       對於例如TCP/IP這種基於流的傳輸協議實現，接收到的資料會被儲存在socket的接受緩衝區內。不幸的是，這種基於流的傳輸緩衝區並不是一個包佇列，而是一個位元組佇列。這意味著，即使

【Spring】使用Spring和AMQP發送接收消息（上）

com load 設定 支持 消息發送 結果 alt 來看 接下來 講AMQP之前，先講下傳統的JMS的消息模型，JMS中主要有三個參與者：消息的生產者、消費者、傳遞消息的通道（隊列或者主題），兩種消息模型如下：通道是隊列： 通道是隊列： 通道是主題： 在JMS中，雖然

Netty事件監聽和處理（上）

事件處理 多路復用 linu 自定義事件 性能 cdn 處理請求 fancybox 客戶 陪產假結束了，今天又開始正常上班了，正好趕上米粉節活動，又要忙上一陣了，米粉節活動時間為4.03 - 4.10，有不少優惠，感興趣的可以關註mi.com或小米商城app。 今天

JavaSE之面向物件程式設計—類與物件（上）

1.面向物件程式設計簡介： [點一下就可以看到這個內容喲] (https://blog.csdn.net/ZhuiZhuDream5/article/details/83831961) 2.類與物件的定義與使用： [帶你進一步走進java] (https://blog.csdn.net/Zh

JavaSE之面向物件程式設計—類與物件（上）—— 5

首先我們來認識一下static關鍵字表示什麼：static關鍵字表示靜態的意思，更加通俗的解釋就是static修飾屬性或者方法它表示類的屬性或者方法，而前面所學的都表示物件的熟悉感或者方法。下面我們將從兩個方面來介紹static關鍵字。 一、static屬性 static屬性也叫類屬性，對於