享读SpringMVC源码0--从Tomcat到SpringMVC-阿里云开发者社区

1.回顾

SpringMVC的核心是DispatcherServlet. 而DispatcherServlet的本质还是一个Servlet 。

说到Servlet 就得讲讲web服务器Tomcat。

文接Tomcat原理系列之三：请求链上的那些类与 Tomcat原理系列之七：详解socket如何封装成request(下)

2.请求从Tomcat到SpringMVC

请求通过Socket 开启应用之旅，在Tomcat原理系列之三：请求链上的那些类中讲过，请求来到Tomcat的最后一个valve,StandardWrapperValve时。执行其invoke方法

StandardWrapperValve

请求来到StandardWrapperValve#invoke方法

final class StandardWrapperValve
    extends ValveBase {
    public final void invoke(Request request, Response response)
        throws IOException, ServletException {
        // 1.Allocate a servlet instance to process this request
        //分配一个servet 去处理请求
        servlet = wrapper.allocate();
        // 2.Create the filter chain for this request 
        //封装servlet, 为当前请求创建一个过滤器链
        ApplicationFilterChain filterChain =
                        ApplicationFilterFactory.createFilterChain(request, wrapper, servlet);
        //3.执行过滤器链的doFilter方法，（链式执行各种Filter ，末端执行servlet's service() method）
        filterChain.doFilter(request.getRequest(),
                                            response.getResponse());
        }
}

ApplicationFilterChain

之后来到 ApplicationFilterChain#doFilter方法

public final class ApplicationFilterChain implements FilterChain {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response)
            throws IOException, ServletException {
        internalDoFilter(request,response);//调用内部internalDoFilter方法
            }
     private void internalDoFilter(ServletRequest request,
                                      ServletResponse response)
            throws IOException, ServletException {
             // Call the next filter if there is one
             // 4.链式调用每个Filter的doFilter方法
             if (pos < n) {
                  filter.doFilter(request, response, this);
             }
             //5.调用servlet的service方法
             servlet.service(request, response);
            }
}

在Filter的末端，开始准备进入Servlet执行方法。

HttpServlet

我们来看看DispatcherServlet 的继承图

从图中我们可以看出，DispatcherServlet 通过几层父类间接实现Servlet。

ApplicationFilterChain中调用servlet.service(request, response);传递的参数是(ServletRequest request, ServletResponse response)。所以执行的是HttpServlet 中的service方法.可以看出此方法的目的是将ServletRequest，ServletResponse 转换为我们熟悉的HttpServletRequest ，HttpServletResponse

public abstract class HttpServlet extends GenericServlet {
 //6.执行HttpServlet.service()方法，做req,res 的强制转换
 public void service(ServletRequest req, ServletResponse res){
    HttpServletRequest  request;
    HttpServletResponse response;
    try {
        //转为 HttpServletRequest，HttpServletResponse
         request = (HttpServletRequest) req;
         response = (HttpServletResponse) res;
    } catch (ClassCastException e) {
                throw new ServletException("non-HTTP request or response");
    }
    service(request, response);
    }
 //8.执行HttpServlet.service此时的参数已经是HttpServletRequest，HttpServletResponse
 //并根据请求方法类型。调用不同的处理方法。子类FrameworkServlet 类中重写了一些方法，所以转去执行子类的doGet方法
 protected void service(HttpServletRequest req, HttpServletResponse resp)
         throws ServletException, IOException {
      if (method.equals(METHOD_GET)) {
        doGet(req, resp);   
      }
    }
 }

FrameworkServlet

public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
 //7.兼容PATCH方法，非PATCH方法最终还是交给HttpServlet.service()
 protected void service(HttpServletRequest request, HttpServletResponse response)
             throws ServletException, IOException {
         HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
         if (httpMethod == HttpMethod.PATCH || httpMethod == null) {
             processRequest(request, response);
         }
         else {
             super.service(request, response);
         }
 }
//9.get代理方法，转到processRequset去处理
 protected final void doGet(HttpServletRequest request, HttpServletResponse response)
             throws ServletException, IOException {
         processRequest(request, response);
     }
//10.模板方法，请求的处理交给子类的doService方法去处理
 protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
             throws ServletException, IOException {
        doService(request, response);
     }
}

DispatcherServlet

最终请求来到了DispatcherServlet的doService方法，开始DispatcherServlet的工作内容

//最终来到了DispatcherServlet
public class DispatcherServlet extends FrameworkServlet {
    //11.做请求分发前的准备工作，主要是设置一些请求的相关属性
    protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
        doDispatch(request, response);
    }
    //12 开启请求的分发。
    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //开启DispatcherServlet的分发功能
    }
}

最终请求到了DispatcherServlet的doDispatch开启DispatcherServlet 请求分发处理功能。

3.DispatcherServlet的工作原理

请求到达doDispatch 方法后，DispatcherServlet对其做了什么呢？这就引出了DispatcherServlet的工作原理这个话题。

处理流程

借用网上张图：

请求来到DispatcherServlet
DispatcherServlet根据请求信息，从HandlerMapping 找能处理当前请求的Handler并封装成一个HandlerExecutionChain
根据解析到的Handler ，获取一个适配器。
HandlerAdapter会根据Handler来调用真正的处理器开处理请求，列如我们写的controller类中的业务方法
处理器处理完业务后，会返回一个ModelAndView对象，Model是返回的数据对象，View是个逻辑上的View
ViewResolver会根据逻辑View查找实际的View。
视图渲染完成后，DispatcherServlet返回。

这些流程反映在代码中，就是doDispatch 方法内的相关调用了.

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);
                // 获取能处理当前请求的Handler 链
                mappedHandler = getHandler(processedRequest);
                if (mappedHandler == null || mappedHandler.getHandler() == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }
                // 获取能处理当前请求的的handler的适配器
                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;
                }
                //适配器handle方法处理请求。
                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) {
                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);
                }
            }
        }
    }

4.总结

我们可以看出，DispatcherServlet采用了“中心化”的思想。请求统一过DispatcherServlet，这样的好处就是统一管理。DispatcherServlet就有点路由的意思了。

本文衔接Tomcat原理系列之七：详解socket如何封装成request(下) 终于粗略的过了一遍，请求如何从socket经Tomcat到达DispatcherServlet，变成我们常用的HttpServletRequest 。对于web 的工作原理有了更深的理解

享读SpringMVC源码0--从Tomcat到SpringMVC