摘要：前端控制器根據(jù)返回的視圖名，選擇相應(yīng)的視圖進行渲染，并將模型數(shù)據(jù)傳入到視圖中以便展示。前端控制器將響應(yīng)的結(jié)果返回給用戶。

將URL映射到Java類或者方法

封裝用戶提交的數(shù)據(jù)

處理請求，調(diào)用相關(guān)的業(yè)務(wù)層，并封裝響應(yīng)的數(shù)據(jù)

將要響應(yīng)的數(shù)據(jù)進行渲染

與spring無縫集成（IOC、AOP）

約定優(yōu)于配置

性能比Struts2好

設(shè)計中的角色或者職責(zé)劃分明確

Restful

JUnit測試

異常處理

本地化、國際化

數(shù)據(jù)驗證、類型轉(zhuǎn)化等

攔截器

使用的人和公司比較多

簡單、便捷、易學(xué)

springMVC基于請求驅(qū)動，所有設(shè)計都圍繞一個中央servlet展開，它負(fù)責(zé)將請求分發(fā)給各個處理器（頁面控制器、Controller），下圖展示了springMVC處理請求的流程，圖中的Front Controller（前端控制器）正是springMVC的DispatcherServlet;Controller稱為處理器或應(yīng)用控制器，由它來處理具體的請求，返回數(shù)據(jù)模型；View Template為具體視圖，用于展示數(shù)據(jù)，響應(yīng)請求.

用戶發(fā)送請求，被前端攔截器攔截，前端控制器根據(jù)請求的信息選擇相應(yīng)的頁面控制器，并將請求委托給此頁面控制器來處理。

頁面控制器接收到請求后，首先收集并綁定請求參數(shù)到一個命令對象（表單對象）中，并進行驗證轉(zhuǎn)換等操作，然后將命令對象委托給業(yè)務(wù)對象處理，最后返回一個modelAndView對象。

前端控制器根據(jù)返回的視圖名，選擇相應(yīng)的視圖進行渲染，并將模型數(shù)據(jù)傳入到視圖中以便展示。

前端控制器將響應(yīng)的結(jié)果返回給用戶。

至此，整個請求流程結(jié)束，當(dāng)然還有一些細(xì)節(jié)的問題，需要我們了解，比如：前端控制器如何選擇頁面控制器，前端控制器如果根據(jù)頁面控制器的返回選擇相應(yīng)的視圖進行渲染，等等。帶著這些問題，我們將springMVC處理請求的流程圖轉(zhuǎn)換為架構(gòu)圖討論一下。

先上一段代碼：

 /**
     * Process the actual dispatching to the handler.
     * 
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.
     * 
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
     */
    /**
     * 處理實際的請求分發(fā)到處理器.
     * 要獲得具體的Handler, 需要先使用servlet的HandlerMappings.
     * 要獲得HandlerAdpter, 需要先在servlet加載的各HandlerAdapter中查找, 找到第一個支持此Handler的Adapter.
     * 所有的HTTP方法都通過這個方法來處理的. 這個方法中, 由HandlerAdapter或Handler自己來決定哪些方法可以被調(diào)用.
     * @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 {
                // 檢查請求是否為multipart(文件上傳)
                processedRequest = checkMultipart(request);
                multipartRequestParsed = (processedRequest != request);

                // Determine handler for the current request.
                // 圖中2,3兩步, 通過HandlerMappsing映射, 獲取處理請求的Handler
                mappedHandler = getHandler(processedRequest);
                if (mappedHandler == null || mappedHandler.getHandler() == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }

                // Determine handler adapter for the current request.
                // 圖中步驟4, 將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()) {
                        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.
                // 圖中5,6,7步驟, 由HandlerAdapter調(diào)用真正的處理器處理請求, 并返回ModelAndView對象
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

                if (asyncManager.isConcurrentHandlingStarted()) {
                    return;
                }

                applyDefaultViewName(processedRequest, mv);

                // 后置攔截器
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            }
            catch (Exception ex) {
                dispatchException = ex;
            }
            // 圖中8,9,10,11步驟, 處理Handler的處理結(jié)果, 這個結(jié)果可能是一個ModelAndView對象, 還可能是一個異常
            // 第8,9步, 由viewResolver解析視圖
            // viewResolver.resolveViewName(viewName, locale)
            // 第10, 11步, 傳入Model, 并渲染視圖
            // view.render(mv.getModelInternal(), request, response);
            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
                if (mappedHandler != null) {
                    // 完成時攔截器
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            }
            else {
                // Clean up any resources used by a multipart request.
                if (multipartRequestParsed) {
                    cleanupMultipart(processedRequest);
                }
            }
        }
    }

步驟①, DispatcherServlet作為前端控制器, 統(tǒng)一的請求接收點, 控制全局的請求流程. 接收到用戶請求, 自己不做處理, 而是將請求委托給其他的處理器進行處理.

步驟②③, DispatcherServlet通過HandlerMapping(處理映射器), 將請求映射為一個HandlerExecutionChain對象, 其中包括了頁面控制器和對其配置的攔截器.

步驟④, DispatcherServlet通過獲得的Handler(處理器, 頁面控制器, Controller), 查找一個合適的HandlerAdapter(處理器適配器), 通過這個HandlerAdapter調(diào)用Handler實際處理請求的方法.

步驟⑤, 提取請求中的模型數(shù)據(jù), 調(diào)用Handler實際處理請求的方法. 在調(diào)用方法時, 填充參數(shù)過程中, spring會根據(jù)配置做一些工作, 如: 數(shù)據(jù)轉(zhuǎn)換, 數(shù)據(jù)格式化, 數(shù)據(jù)驗證等.

步驟⑥⑦, Handler執(zhí)行完成后, 將返回一個ModelAndView對象給DispatherServlet. ModelAndView對象中包含邏輯視圖名或邏輯視圖名和模型.

步驟⑧, 根據(jù)ModelAndView對象選擇一個合適的ViewResolver(視圖解析器).

步驟⑨, ViewResolver將ModelAndView中的邏輯視圖名解釋成View對象. ViewResolver也是接口, 同樣采用了策略模式, 這樣就很容易切換其他的視圖類型.

步驟⑩?, 渲染視圖時, 將Model數(shù)據(jù)傳入視圖中, 這里的Model數(shù)據(jù)是一個Map, 容易與各種視圖類型相結(jié)合.

步驟?, 最后, 由DispatcherServlet將最終的響應(yīng)結(jié)果返回給用戶.