SpringMVC之源码分析--请求过程

zxhaaa 发布于2019-08-16 11:14 / 1185人阅读

摘要：概述根据规范，当用户请求到达应用时，由的方法进行处理，对于而言，处理用户请求的入口为，通过其父类的拦截处理。最后创建了群方便大家交流，可扫描加入，同时也可加我，共同学习共同进步，谢谢

概述

根据Servlet规范，当用户请求到达应用时，由Servlet的service()方法进行处理，对于Spring MVC而言，处理用户请求的入口为DispatcherServlet，通过其父类FrameworkServlet的service()拦截处理。

FrameworkServlet

用户请求的入口方法为service(request,response)，源码如下：

</>复制代码 
/**
 * Override the parent class implementation in order to intercept PATCH requests.
 */
@Override
protected void service(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
    // Spring3.0增加了PATCH方法拦截处理
    if (httpMethod == HttpMethod.PATCH || httpMethod == null) {
        processRequest(request, response);
    } else { // GET, HEAD, POST, PUT, DELETE, OPTIONS, TRACE
        super.service(request, response);
    }
}

该方法重写了HttpServlet的service()方法，并增加了PATCH请求的拦截处理，其他诸如GET、POST、PUT等请求则调用父类的service方法，HttpServlet类的service()方法就是根据请求类型进行不同的路由处理，如为GET请求，则路由至doGet()方法处理，以此类推，此处省略源码。

假如用户请求为GET，则路由到子类（FrameworkServlet）的doGet()方法进行处理，doGet()源码如下：

</>复制代码 
@Override
protected final void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    processRequest(request, response);
}

其实，所有类型的请求最终都由processRequest()方法进行处理，processRequest方法源码如下：

</>复制代码 
protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    long startTime = System.currentTimeMillis();
    Throwable failureCause = null;
    // 
    LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
    // 构建请求(request)的LocalContext上下文，提供基本的作为当前地区的主要语言环境
    LocaleContext localeContext = buildLocaleContext(request);
    RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
    // 构建请求(request)的ServletRequestAttributes对象，保存本次请求的request和response
    ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);
    // 异步请求处理的管理核心类
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());
    // 绑定request context上线到当前线程
    initContextHolders(request, localeContext, requestAttributes);
    try {
        // 模板方法，调用子类（DispatcherServlet）的doService方法进行处理
        doService(request, response);
    }
    catch (ServletException | IOException ex) {
        failureCause = ex;
        throw ex;
    }
    catch (Throwable ex) {
        failureCause = ex;
        throw new NestedServletException("Request processing failed", ex);
    }
    finally {
        // 接触请求线程与LocalContext和RequestAttributes的绑定
        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");
                }
            }
        }
        // 发布ApplicationEvent事件，可由ApplicationListener进行监听
        // 继承ApplicationListener接口，实现onApplicationEvent()接口，并注册到spring容器，即可捕获该事件
        publishRequestHandledEvent(request, response, startTime, failureCause);
    }
}

DispatcherServlet

</>复制代码 
@Override
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) + "]");
    }
    // 如果是include请求，保存request attribute快照数据，并在finally中进行还原
    Map attributesSnapshot = null;
    if (WebUtils.isIncludeRequest(request)) {
        attributesSnapshot = new HashMap<>();
        Enumeration attrNames = request.getAttributeNames();
        while (attrNames.hasMoreElements()) {
            String attrName = (String) attrNames.nextElement();
            if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
                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());
    if (this.flashMapManager != null) {
        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()) {
            // Restore the original attribute snapshot, in case of an include.
            if (attributesSnapshot != null) {
                restoreAttributesAfterInclude(request, attributesSnapshot);
            }
        }
    }
}
// 请求处理关键方法
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.
            mappedHandler = getHandler(processedRequest);
            if (mappedHandler == null) {
                noHandlerFound(processedRequest, response);
                return;
            }
            // Determine handler adapter for the current request.
            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()) {
                    logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                }
                if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                    return;
                }
            }
            if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                return;
            }
            // Actually invoke the handler.
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
            if (asyncManager.isConcurrentHandlingStarted()) {
                return;
            }
            applyDefaultViewName(processedRequest, mv);
            mappedHandler.applyPostHandle(processedRequest, response, mv);
        }
        catch (Exception ex) {
            dispatchException = ex;
        }
        catch (Throwable err) {
            // As of 4.3, we"re processing Errors thrown from handler methods as well,
            // making them available for @ExceptionHandler methods and other scenarios.
            dispatchException = new NestedServletException("Handler dispatch failed", err);
        }
        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    }
    catch (Exception ex) {
        triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
    }
    catch (Throwable err) {
        triggerAfterCompletion(processedRequest, response, mappedHandler,
                new NestedServletException("Handler processing failed", err));
    }
    finally {
        if (asyncManager.isConcurrentHandlingStarted()) {
            // Instead of postHandle and afterCompletion
            if (mappedHandler != null) {
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
            }
        }
        else {
            // Clean up any resources used by a multipart request.
            if (multipartRequestParsed) {
                cleanupMultipart(processedRequest);
            }
        }
    }
}

doDispatch()是Spring MVC中重要的方法，用户处理用户请求，其主要经过过程如下：

获取当前请求的Handler

获取当前请求的Handler Adapter

执行preHandle方法

执行Handle方法，即Controller中的方法

执行postHandle方法

处理返回结果

总结

本文简要概述了Spring MVC处理用户请求过程中所涉及的主要方法，对请求处理的流程做了概述，后续将对内部细节进行分析，以加深理解。

最后创建了qq群方便大家交流，可扫描加入，同时也可加我qq：276420284，共同学习、共同进步，谢谢！

GPU云服务器云服务器源码中文说明之大数据之数据挖掘分析数据分析分析过程过程数据分析

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/71103.html

SpringMVC之源码分析--HandlerAdapter（二）

摘要：概述本章我们主要分析处理组件的处理流程以及其接口源码。概括来说，使用组件分为两步，首先是注册组件，其次是处理用户请求，以下针对这两个过程进行详细的分析。本系列文章是基于。接下来的几章将分析提供的适配策略，希望本节对大家能有帮助，谢谢。概述本章我们主要分析Spring处理HandlerAdapter组件的处理流程以及其接口源码。概括来说，Spring使用HandlerAdapter组...

Eastboat 2019-08-15 17:58 评论0 收藏0
SpringMVC之源码分析--HandlerMapping（六）

摘要：概述上一节我们分析了的初始化过程，即创建并注册，本章我们分析下的请求处理过程，即查找。本系列文章是基于。最后创建了群方便大家交流，可扫描加入，同时也可加我，共同学习共同进步，谢谢概述上一节我们分析了RequestMappingHandlerMapping的初始化过程，即创建并注册HandlerMehtod，本章我们分析下RequestMappingHandlerMapping的请求...

BDEEFE 2019-08-15 17:54 评论0 收藏0
SpringMVC之源码分析--LocaleResolver和ThemeResolver应用

摘要：需求根据客户端环境，界面显示不同的国旗图案。选择的技术方案可利用提供的国际化和主题定制来解决。注意此时返回的中没有国际化及主题相关的信息。修改请求参数的值为荷兰，即后再发起请求，结果如下与预期一致，测试通过。概述以上分析了Spring MVC的LocaleResolver和ThemeResolver两个策略解析器，在实际项目中很少使用，尤其是ThemeResolver，花精力去分析...

qpal 2019-08-15 17:43 评论0 收藏0
SpringMVC之源码分析--HandlerMapping（三）

摘要：与类图对比，类继承自抽象类，其又继承自抽象类，再往上继承关系与一致。创建初始化上一章我们分析了的创建初始化过程，的创建初始化过程与一样，方法的入口在抽象类中的方法。至此，代码编写完毕。概述本节我们继续分析HandlerMapping另一个实现类BeanNameUrlHandlerMapping，从类的名字可知，该类会根据请求的url与spring容器中定义的bean的name属性值...

fsmStudy 2019-08-15 17:49 评论0 收藏0
SpringMVC之源码分析--HandlerMapping（五）

摘要：概述通过前三章的分析，我们简要分析了和，但对拦截器部分做详细的分析，拦截器的加载和初始化是三个相同的部分。概述通过前三章的分析，我们简要分析了SimpleUrlHandlerMapping、BeanNameUrlHandlerMapping和RequestMappingHandlerMapping，但对拦截器部分做详细的分析，拦截器的加载和初始化是三个HandlerMapping相...

nanchen2251 2019-08-15 17:54 评论0 收藏0