Spring MVC的工做原理，咱们来看看其源码实现

时间 2019-11-07

原文原文链接

前言

　　开心一刻html

　　　　晚上陪老丈人吃饭，忽然手机响了，我手贱按了免提……哥们：快出来喝酒！哥几个都在呢！我：今天不行，我如今陪老丈人吃饭呢。哥们：那你抓紧喝，我三杯白酒，把我岳父放倒了才出来的，你也快点。看着我老丈人的脸，我不知道该怎么回了……git

猪同样的队友web

遗留问题

　　在关于利用maven搭建ssm的博客，咱们一块儿来探讨下问的最多的问题中，我遗留了一个问题：Spring mvc是什么时候、何地、如何将Model中的属性绑定到哪一个做用域，这里的做用域指的是Servlet的四大做用域；不了解问题背景的能够回过头去看看个人上篇博文。spring

　　明确的解答我会放到最后，在解答问题以前，我先和你们一块儿来捋一捋Spring mvc的工做原理。废话很少说，开始咱们神秘的探险之旅！tomcat

应用示例

　　在讲工做原理以前，咱们先看一个简单的spring mvc（ssm）示例，以及实现的效果mvc

　　工程代码地址：ssm-web　app

　　工程结构与效果如上所示，咱们不作过多的探究，咱们打起精神往下看本篇的重点jsp

工做原理

　　准备 - 资源的加载与初始化

　　　　一、DispatcherServlet 静态初始化async

　　　　　　DispatcherServlet中有以下静态块maven

static {
        // Load default strategy implementations from properties file.
        // This is currently strictly internal and not meant to be customized
        // by application developers.
        try {
            ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
            defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
        }
        catch (IOException ex) {
            throw new IllegalStateException("Could not load 'DispatcherServlet.properties': " + ex.getMessage());
        }
    }

　　　　　　这里会将DispatcherServlet.properties中的内容读取到DispatcherServlet的属性：private static final Properties defaultStrategies中，DispatcherServlet.properties内容以下

# Default implementation classes for DispatcherServlet's strategy interfaces.
# Used as fallback when no matching beans are found in the DispatcherServlet context.
# Not meant to be customized by application developers.

org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver

org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
    org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping

org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
    org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
    org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter

org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver,\
    org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
    org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver

org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

View Code

　　　　　　指定了DispatcherServlet策略接口的默认实现，后续DispatcherServlet初始化策略的时候会用到

　　　　二、interceptor定义的加载

　　　　　　spring启动过程当中会调用InterceptorsBeanDefinitionParser的parse方法来解析出咱们自定义的interceptor定义，封装成MappedInterceptor类型的bean定义，并放到spring容器中；咱们能够简单的认为spring容器中已经存在了咱们自定义的interceptor的bean定义

　　　　三、DispatcherServlet初始化策略：initStrategies

　　　　　　DispatcherServlet的继承图以下

　　　　　　DispatcherServlet是一个Servlet，tomcat启动过程当中会调用其init方法，一串的调用后，会调用DispatcherServlet的initStrategies方法

protected void initStrategies(ApplicationContext context) {
    initMultipartResolver(context);
    initLocaleResolver(context);
    initThemeResolver(context);
    initHandlerMappings(context);
    initHandlerAdapters(context);
    initHandlerExceptionResolvers(context);
    initRequestToViewNameTranslator(context);
    initViewResolvers(context);
    initFlashMapManager(context);
}

　　　　　　实例化步骤1中的默认实现，并填充到DispatcherServlet各个属性值中

　　　　四、DefaultAnnotationHandlerMapping的拦截器初始化

　　　　　　DispatcherServlet.properties种指定了两个默认的HandlerMapping：BeanNameUrlHandlerMapping、DefaultAnnotationHandlerMapping，这二者的类继承图以下（咱们暂时只关注DefaultAnnotationHandlerMapping）

　　　　　　DefaultAnnotationHandlerMapping间接实现了ApplicationContextAware，那么在DefaultAnnotationHandlerMapping实例初始化过程当中，会调用setApplicationContext(ApplicationContext applicationContext)方法，一串调用后，会来到AbstractUrlHandlerMapping的initApplicationContext()

@Override
protected void initApplicationContext() throws BeansException {
    extendInterceptors(this.interceptors);
    detectMappedInterceptors(this.mappedInterceptors);
    initInterceptors();
}

　　　　　　初始化了DefaultAnnotationHandlerMapping的拦截器：interceptor

　　　　咱们来看下具体的初始化过程，看看上面的顺序是否只是我我的的臆想？

　　　　能够看到，初始化顺序就是咱们上面说的，不是我我的的意淫；此时的DefaultAnnotationHandlerMapping中有咱们自定义的MyInterceptor。初始化过程咱们须要关注的就是上述这些，下面咱们一块儿看看具体请求的过程

　　请求的处理

　　　　请求从servlet的service开始，一路到DispatcherServlet的doDispatch，以下图

　　　　doDispatch

/**
 * Process the actual dispatching to the handler. 将请求分发到具体的handler，也就是咱们的controller
 * <p>The handler will be obtained by applying the servlet's HandlerMappings in order.
 * The HandlerAdapter will be obtained by querying the servlet's installed HandlerAdapters
 * to find the first that supports the handler class.
 * <p>All HTTP methods are handled by this method. It's up to HandlerAdapters or handlers
 * themselves to decide which methods are acceptable.
 * @param request current HTTP request
 * @param response current HTTP response
 * @throws Exception in case of any kind of processing failure
 */
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpServletRequest processedRequest = request;
    HandlerExecutionChain mappedHandler = null;
    boolean multipartRequestParsed = false;

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

    try {
        ModelAndView mv = null;
        Exception dispatchException = null;

        try {
            processedRequest = checkMultipart(request);
            multipartRequestParsed = processedRequest != request;

            // Determine handler for the current request. 决定哪一个handler来处理当前的请求
            // mappedHandler是由handler和interceptor集合组成的一个执行链，有点相似FilterChain
            mappedHandler = getHandler(processedRequest);
            if (mappedHandler == null || mappedHandler.getHandler() == null) {
                noHandlerFound(processedRequest, response);
                return;
            }

            // Determine handler adapter for the current request. 决定哪一个adapter来处理当前的请求
            // handlerMapping是找出适配的handler，而真正回调handler的是adapter
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

            // Process last-modified header, if supported by the handler.
            String method = request.getMethod();
            boolean isGet = "GET".equals(method);
            if (isGet || "HEAD".equals(method)) {
                long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                if (logger.isDebugEnabled()) {
                    String requestUri = urlPathHelper.getRequestUri(request);
                    logger.debug("Last-Modified value for [" + requestUri + "] is: " + lastModified);
                }
                if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                    return;
                }
            }

            // handler的前置处理，也就是调用适配当前url的interceptor的preHandler方法
            if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                return;
            }

            try {
                // Actually invoke the handler. 真正调用handler
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
            }
            finally {
                if (asyncManager.isConcurrentHandlingStarted()) {
                    return;
                }
            }

            applyDefaultViewName(request, mv);
            // handler的后置处理，也就是调用适配当前url的interceptor的postHandler方法
            mappedHandler.applyPostHandle(processedRequest, response, mv);
        }
        catch (Exception ex) {
            dispatchException = ex;
        }
        // 处理handler返回的结果，会调用适配当前url的interceptor的afterCompletion方法
        // 这里会将响应结果返回给请求者
        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    }
    catch (Exception ex) {
        triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
    }
    catch (Error err) {
        triggerAfterCompletionWithError(processedRequest, response, mappedHandler, err);
    }
    finally {
        if (asyncManager.isConcurrentHandlingStarted()) {
            // Instead of postHandle and afterCompletion
            mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
            return;
        }
        // Clean up any resources used by a multipart request.
        if (multipartRequestParsed) {
            cleanupMultipart(processedRequest);
        }
    }
}

View Code

　　　　　　handlerMapping具体如何找到匹配当前url的handler（通常而言就是咱们的controller）、handlerAdapter具体如何回调真正的handler，有兴趣的能够自行去跟下，我就不跟了。咱们具体看下processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException); 这个与咱们最初的疑问有关

　　　　processDispatchResult

　　　　　　能够看到model中的persons会被设置到request的attributes中，而后转发请求到show_person.jsp，转发过程当中request做用域的变量仍然有效，因此show_person.jsp中的jstl标签和el表达式可以取到persons变量，最后将show_person.jsp中的内容填充好以后的静态内容返回给请求者；至此就完成了一次请求的响应

问题解答

　　回到咱们开篇的疑问：Spring mvc是什么时候、何地、如何将Model中的属性绑定到哪一个做用域？想必你们已经知道答案了

　　Controller中的model、ModelMap的注入由spring mvc完成，这个不是请求传入的参数，用于绑定变量到Servlet做用域；默认状况下，在DispatcherServlet调用了真正的handler以后，将结果返回给请求者的过程当中，将model、modelMap中的变量设置到了request的attributes中，转发的过程当中，request中的变量仍然有效，因此show_person.jsp中能取到persons这个变量，自此疑问获得解答

总结

　　一、Spring MVC工做原理图

　　　　图是用的别人的，具体是谁的我也不记得了（捂脸）

　　二、DefaultAnnotationHandlerMapping在spring3.2中被废弃，替换成了RequestMappingHandlerMapping