springmvc的详细的执行流程分析

当页面请求一发送，以前在servlet时是request接收请求，但是到了springmvc，就是前端控制器DispatcherServlet接收，为什么呢？看看DispatcherServlet的继承树，如下

可以看到DispatcherServlet实际上是HttpServlet的子类，那么也就说的通啦
那请求收到DispatcherServlet是怎么处理的呢？
在HttpServletBean中没有看到对请求方式的处理

在看看它的子类FrameworkServlet的方法，发现有了对各种请求方式的处理

看看是怎么处理的，发现都是一样的调用了processRequest(request, response)方法

进入processRequest方法一探究竟

发现最终是交给了DispatcherServlet的doService(request, response)方法处理

以为到此结束了，发现然并卵，哈哈

最终跑到了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 {
            try {
                ModelAndView mv = null;
                Object dispatchException = null;

                try {
                	//检查是否是文件上传
                    processedRequest = this.checkMultipart(request);
                    multipartRequestParsed = processedRequest != request;
                    //通过处理器处理请求找到匹配的处理器，也就是controller
                    mappedHandler = this.getHandler(processedRequest);
                    //找不到，报异常
                    if (mappedHandler == null) {
                        this.noHandlerFound(processedRequest, response);
                        return;
                    }
					//根据处理器得到匹配的处理器适配器
                    HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
                    String method = request.getMethod();
                    boolean isGet = "GET".equals(method);
                    if (isGet || "HEAD".equals(method)) {
                        long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                        if ((new ServletWebRequest(request, response)).checkNotModified(lastModified) && isGet) {
                            return;
                        }
                    }

                    if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                        return;
                    }
					//适配器处理请求
                    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                    if (asyncManager.isConcurrentHandlingStarted()) {
                        return;
                    }
					//应用默认的视图名
                    this.applyDefaultViewName(processedRequest, mv);
                    //后置处理器进行处理
                    mappedHandler.applyPostHandle(processedRequest, response, mv);
                } catch (Exception var20) {
                    dispatchException = var20;
                } catch (Throwable var21) {
                    dispatchException = new NestedServletException("Handler dispatch failed", var21);
                }
				//处理结果，进行视图渲染
                this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
            } catch (Exception var22) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, var22);
            } catch (Throwable var23) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler processing failed", var23));
            }

        } finally {
            if (asyncManager.isConcurrentHandlingStarted()) {
                if (mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            } else if (multipartRequestParsed) {
                this.cleanupMultipart(processedRequest);
            }
        }
    }

一个请求发过来，需要处理器映射器去找到对应的处理器，也可以说是控制器；又因为一个类型的控制器对应一个类型的适配器，而控制器找到与之匹配的适配器需要处理器适配器去映射，找到了适配器之后，就去执行业务逻辑。

处理器映射器有3个，如下

而处理器适配器有4个，如下

下面是总体的流程图