SpringMVC源码解析之执行过程篇

最新推荐文章于 2020-10-29 12:10:21 发布

0xZzzz

最新推荐文章于 2020-10-29 12:10:21 发布

阅读量1.6k

点赞数 1

本文链接：https://blog.csdn.net/heroqiang/article/details/78760356

版权

Spring 同时被 2 个专栏收录

24 篇文章 14 订阅

订阅专栏

Spring源码解析

23 篇文章 25 订阅

订阅专栏

阅读须知

Spring源码版本：4.3.8
文章中使用/* */注释的方法会做深入分析

正文

承接上文，我们知道 HttpServlet 提供一些处理请求的方法，如 doGet、doPost、service等，在 DispatcherServlet 中的实现都调用了 processRequest 方法，我们来分析这个方法：
FrameworkServlet：

protected final void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    processRequest(request, response);
}
protected final void doPost(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    processRequest(request, response);
}

FrameworkServlet：

protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    // 记录请求处理开始时间
    long startTime = System.currentTimeMillis();
    Throwable failureCause = null;
    // 提取当前线程的 LocaleContext 
    LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
    // 构建国际化语言环境
    LocaleContext localeContext = buildLocaleContext(request);
    // 提取当前线程的 RequestAttributes 
    RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
    // 封装请求参数
    ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);
    // 构建异步请求管理器，异步请求是 Spring3.2 版本的新特性
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    // 注册 Callable 拦截器
    asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());
    // 保存到当前线程，保证当前线程的请求还能获取到
    initContextHolders(request, localeContext, requestAttributes);
    try {
    	/* 子类具体实现处理请求逻辑 */
        doService(request, response);
    }
    catch (ServletException ex) {
        failureCause = ex;
        throw ex;
    }
    catch (IOException ex) {
        failureCause = ex;
        throw ex;
    }
    catch (Throwable ex) {
        failureCause = ex;
        throw new NestedServletException("Request processing failed", ex);
    }
    finally {
        resetContextHolders(request, previousLocaleContext, previousAttributes);
        if (requestAttributes != null) {
            requestAttributes.requestCompleted();
        }
        if (logger.isDebugEnabled()) {
            if (failureCause != null) {
                this.logger.debug("Could not complete request", failureCause);
            }
            else {
                if (asyncManager.isConcurrentHandlingStarted()) {
                    logger.debug("Leaving response open for concurrent processing");
                }
                else {
                    this.logger.debug("Successfully completed request");
                }
            }
        }
        publishRequestHandledEvent(request, response, startTime, failureCause); // 发布事件通知
    }
}

这里提到了异步请求，这里给出Spring对异步请求介绍和应用示例的官方文档地址，大家可以进行查阅了解。
DispatcherServlet：

protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
    if (logger.isDebugEnabled()) {
        String resumed = WebAsyncUtils.getAsyncManager(request).hasConcurrentResult() ? " resumed" : "";
        logger.debug("DispatcherServlet with name '" + getServletName() + "'" + resumed +
                " processing " + request.getMethod() + " request for [" + getRequestUri(request) + "]");
    }
    // 保存请求属性的快照，以便于包含之后还能够恢复原始属性
    Map<String, Object> attributesSnapshot = null;
    if (WebUtils.isIncludeRequest(request)) {
        attributesSnapshot = new HashMap<String, Object>();
        Enumeration<?> attrNames = request.getAttributeNames();
        while (attrNames.hasMoreElements()) {
            String attrName = (String) attrNames.nextElement();
            if (this.cleanupAfterInclude || attrName.startsWith("org.springframework.web.servlet")) {
                attributesSnapshot.put(attrName, request.getAttribute(attrName));
            }
        }
    }
    // 为请求包含一些属性（将之前初始化好的一些策略对象放入请求属性中）
    request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
    request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
    request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
    request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());
    FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
    if (inputFlashMap != null) {
        request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
    }
    request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
    request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
    try {
    	/* 做转发 */
        doDispatch(request, response);
    }
    finally {
        if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
            if (attributesSnapshot != null) {
                // 根据之前保存的请求属性快照将请求属性恢复到原始状态
                restoreAttributesAfterInclude(request, attributesSnapshot);
            }
        }
    }
}

DispatcherServlet：

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 {
            /* 检查是否是 multipart 类型的请求，如果是，将请求对象转换为 MultipartHttpServletRequest 类型的请求 */
            processedRequest = checkMultipart(request);
            multipartRequestParsed = (processedRequest != request);
            /* 根据 request 找到对应的 handler */
            mappedHandler = getHandler(processedRequest);
            if (mappedHandler == null || mappedHandler.getHandler() == null) {
            	// 没有 handler 通过 response 对象返回错误信息
                noHandlerFound(processedRequest, response);
                return;
            }
            /* 根据 handler 找到对应的 HandlerAdapter */
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
            String method = request.getMethod();
            boolean isGet = "GET".equals(method);
            // 如果 handler 支持处理 last-modified 请求，则处理
            if (isGet || "HEAD".equals(method)) {
                long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                if (logger.isDebugEnabled()) {
                    logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                }
                if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                    return;
                }
            }
            /* 调用拦截器的 preHandle 方法 */
            if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                return;
            }
            /* 真正的请求处理 */
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
            if (asyncManager.isConcurrentHandlingStarted()) {
            	// 如果是异步请求，直接返回，不会应用普通的视图和普通的拦截器后处理方法
                return;
            }
            // 如果没有视图则应用默认的视图名称
            applyDefaultViewName(processedRequest, mv);
            /* 调用拦截器的 postHandle 方法 */
            mappedHandler.applyPostHandle(processedRequest, response, mv);
        }
        catch (Exception ex) {
            dispatchException = ex;
        }
        catch (Throwable err) {
            dispatchException = new NestedServletException("Handler dispatch failed", err);
        }
        /* 处理请求结果 */
        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    }
    catch (Exception ex) {
        // 拦截器 afterCompletion 方法的调用
        triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
    }
    catch (Throwable err) {
        // 拦截器 afterCompletion 方法的调用
        triggerAfterCompletion(processedRequest, response, mappedHandler,
                new NestedServletException("Handler processing failed", err));
    }
    finally {
        if (asyncManager.isConcurrentHandlingStarted()) {
            if (mappedHandler != null) {
                // 如果是异步请求，则调用 AsyncHandlerInterceptor 的 afterConcurrentHandlingStarted 代替普通拦截器的 postHandle 和 afterCompletion 方法
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
            }
        }
        else {
            if (multipartRequestParsed) {
            	// 清理一些 multipart 类型请求的资源
                cleanupMultipart(processedRequest);
            }
        }
    }
}

DispatcherServlet：

protected HttpServletRequest checkMultipart(HttpServletRequest request) throws MultipartException {
    if (this.multipartResolver != null && this.multipartResolver.isMultipart(request)) {
        if (WebUtils.getNativeRequest(request, MultipartHttpServletRequest.class) != null) {
            logger.debug("Request is already a MultipartHttpServletRequest - if not in a forward, " +
                    "this typically results from an additional MultipartFilter in web.xml");
        }
        else if (hasMultipartException(request) ) {
            logger.debug("Multipart resolution failed for current request before - " +
                    "skipping re-resolution for undisturbed error rendering");
        }
        else {
            try {
                return this.multipartResolver.resolveMultipart(request);
            }
            catch (MultipartException ex) {
                if (request.getAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE) != null) {
                    logger.debug("Multipart resolution failed for error dispatch", ex);
                }
                else {
                    throw ex;
                }
            }
        }
    }
    return request;
}

这里使用之前初始化的 multipartResolver 来判断和解析文件上传请求，这里需要注意的是，multipartResolver 没有默认的策略，所以如果我们的系统需要处理文件上传，就必须配置 multipartResolver，Spring 为我们提供了两种处理类，第一个 StandardServletMultipartResolver，是基于 Servlet3.0 API 来实现的，另一个 CommonsMultipartResolver 是基于 apache 的 commons-fileupload 包实现的，使用时需要引入相关 jar 包。
DispatcherServlet：

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    for (HandlerMapping hm : this.handlerMappings) {
        if (logger.isTraceEnabled()) {
            logger.trace(
                    "Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");
        }
        // 获取 handler 请求处理链
        HandlerExecutionChain handler = hm.getHandler(request);
        if (handler != null) {
            return handler;
        }
    }
    return null;
}

这里获取 handler 请求处理链会涉及到 SpringMVC 中一个重要的角色 HandlerMapping，关于 HandlerMapping 的源码解析详见SpringMVC源码解析之HandlerMapping。下面是根据 Handler 获取 HandlerAdapter 适配器：
DispatcherServlet：

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
    for (HandlerAdapter ha : this.handlerAdapters) {
        if (logger.isTraceEnabled()) {
            logger.trace("Testing handler adapter [" + ha + "]");
        }
        /* 判断当前 HandlerAdapter 是否支持当前 Handler */
        if (ha.supports(handler)) {
            return ha;
        }
    }
    throw new ServletException("No adapter for handler [" + handler +
            "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}

这里的 handlerAdapters 在上面初始化的过程中在用户不指定的情况下，Spring 会默认注册三个策略，分别为HttpRequestHandlerAdapter、SimpleControllerHandlerAdapter、AnnotationMethodHandlerAdapter，其中 HttpRequestHandlerAdapter 用来适配实现了 HttpRequestHandler 的 handler，SimpleControllerHandlerAdapter 用于适配继承了 AbstractController 和实现了 Controller 接口的 Controller，AnnotationMethodHandlerAdapter 在 Spring3.2 版本被注解了 @Deprecated，已经不推荐使用了，用 RequestMappingHandlerAdapter 代替，用于适配注解了 @Controller 和 @RequestMapping 的 Controller，这种也是我们最常用的方式，我们就以 RequestMappingHandlerAdapter 为例来进行分析：

public final boolean supports(Object handler) {
    return (handler instanceof HandlerMethod && supportsInternal((HandlerMethod) handler));
}

我们在分析注解方式的 handler 注册的过程时看到了，handler 被封装成了 HandlerMethod，所以这里会匹配注解方式注册的 handler。接下来是对 Last-Modified 缓存机制的支持，简单介绍一下 Last-Modified 缓存机制，在客户端第一次输入 URL 时，服务器端会返回内容和状态码200，表示请求成功，同时会添加一个 Last-Modified 响应头，表示该请求内容在服务器上的最后更新时间，客户端第二次请求相同的 URL 时，客户端会向服务器发送请求头 If-Modified-Since 询问服务器该时间之后当前请求内容是否有被修改过，如果内容没有变化，则自动返回 HTTP304 状态码，内容为空，这样就节省了网络带宽。下面是拦截器 preHandle 方法的调用：
HandlerExecutionChain：

boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HandlerInterceptor[] interceptors = getInterceptors();
    if (!ObjectUtils.isEmpty(interceptors)) {
        for (int i = 0; i < interceptors.length; i++) {
            HandlerInterceptor interceptor = interceptors[i];
            // 遍历拦截器调用 preHandle 方法
            if (!interceptor.preHandle(request, response, this.handler)) {
            	// 如果有没通过的，遍历拦截器调用 afterCompletion 方法
                triggerAfterCompletion(request, response, null);
                return false;
            }
            this.interceptorIndex = i;
        }
    }
    return true;
}

下面就是真正的请求处理阶段了，调用 HandlerAdapter 的 handle 方法，我们同样以 RequestMappingHandlerAdapter 来分析，首先看一下它的类层次结构：
这里写图片描述
我们发现它实现了 InitializingBean，所以分析一下 afterPropertiesSet 方法的实现：
RequestMappingHandlerAdapter：