springmvc----源码分析之springmvc执行流程

点滴记载，点滴进步，愿自己更上一层楼。

经过前面几部分的分享，springmvc的基本用法大致讲完。接下来分析源码，看看到底它是怎么做的，为什么这样干就能执行，以及拦截器为什么在Handler执行以前执行，拦截器的执行流程为什么是先preHandle先顺序执行，其他的是倒叙执行。

都知道springmvc项目中web.xml有一项配置------配置前端控制器，DispatchServlet。

可见所有的请求，都会经他来转发到对应的Handler。

下面是总结的流程图，没有画图功底，凑合着看吧。

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

文字叙述

1 用户浏览器发起请求

2 前端控制器DispatcherServlet首先会去请求Handler(也就是Controller)，

怎么请求Handler----通过查找HandlerMapping(里面有xml或者注解方式配置的Handler映射信息信息)来匹配用户请求url对应的Handler，

将查找到的请求信息，放入到执行链HandlerExecutionChain中，然后在放入该url对应的拦截器信息。

然后将执行链HandlerExecutionChain返回给前端控制器DispatcherServlet

3 前端控制器DispatcherServlet通过请求到的handler，再请求处理器适配器HandlerAdapter去执行handler，

：：：执行之前需要先请求执行链中的拦截器的preHandle方法进行某些请求校验等。

4 处理器适配器执行handler后返回给前端控制器DispatcherServlet一个ModelAndView(里面放有视图信息，模型数据信息)

：：：执行拦截器的postHandle方法

5 前端控制器DispatcherServlet请求视图解析器解析视图，根据逻辑名(xxxx/xxxx/xxxx.jsp)解析成真正的视图view(jsp,ftl等)

6 视图解析器解析完成后，返回给前端控制器DispatcherServlet一个View

7 前端控制器DispatcherServlet进行视图渲染，将模型数据填充到request中

8 响应用户请求，展示jsp等视图信息。

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

看完上面的执行过程，其实过程也挺多的，但是里面除了handler，拦截器，jsp等需要程序员来做以外，其他的要不配置一下就行，要不就完全是框架的东西，不用程序员编写，但是了解下原理还是必要的。

下面开始源码解读部分。

既然web.xml中配置了DispatchServlet，所以入口一定在这个类里面，主要的需要看的方法是里面的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 err = null;
            Exception dispatchException = null;

            try {
                processedRequest = this.checkMultipart(request);
                multipartRequestParsed = processedRequest != request;
                mappedHandler = this.getHandler(processedRequest);
                if(mappedHandler == null || mappedHandler.getHandler() == null) {
                    this.noHandlerFound(processedRequest, response);
                    return;
                }

                HandlerAdapter ex = this.getHandlerAdapter(mappedHandler.getHandler());
                String method = request.getMethod();
                boolean isGet = "GET".equals(method);
                if(isGet || "HEAD".equals(method)) {
                    long lastModified = ex.getLastModified(request, mappedHandler.getHandler());
                    if(this.logger.isDebugEnabled()) {
                        this.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;
                }

                try {
                    err = ex.handle(processedRequest, response, mappedHandler.getHandler());
                } finally {
                    if(asyncManager.isConcurrentHandlingStarted()) {
                        return;
                    }

                }

                this.applyDefaultViewName(request, err);
                mappedHandler.applyPostHandle(processedRequest, response, err);
            } catch (Exception var27) {
                dispatchException = var27;
            }

            this.processDispatchResult(processedRequest, response, mappedHandler, err, dispatchException);
        } catch (Exception var28) {
            this.triggerAfterCompletion(processedRequest, response, mappedHandler, var28);
        } catch (Error var29) {
            this.triggerAfterCompletionWithError(processedRequest, response, mappedHandler, var29);
        } finally {
            if(asyncManager.isConcurrentHandlingStarted()) {
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                return;
            }

            if(multipartRequestParsed) {
                this.cleanupMultipart(processedRequest);
            }

        }

    }

其中

mappedHandler = this.getHandler(processedRequest);

对应的就是就是第二步：前端控制器请求handler，返回一个执行链，

具体是怎么处理的，来看

getHandler(processedRequest);源码。

    protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        Iterator var2 = this.handlerMappings.iterator();

        HandlerExecutionChain handler;
        do {
            if(!var2.hasNext()) {
                return null;
            }

            HandlerMapping hm = (HandlerMapping)var2.next();
            if(this.logger.isTraceEnabled()) {
                this.logger.trace("Testing handler map [" + hm + "] in DispatcherServlet with name \'" + this.getServletName() + "\'");
            }

            handler = hm.getHandler(request);
        } while(handler == null);

        return handler;
    }

代码中的 Iterator var2 = this.handlerMappings.iterator(); 中的handlerMappings是在你初次请求后，spring加载的配置的映射信息，
下面来看看 handlerMapping中的映射信息。

可以看出框中的部分，里面放置了所有的配置了@RequestMapping()的handler的映射信息

"{[/helloWorld],methods=[],params=[],headers=[],consumes=[],produces=[],custom=[]}" -> "public org.springframework.web.servlet.ModelAndView com.soft.controller.TestController.helloWorld(javax.servlet.http.HttpServletRequest)"

上面这个是copy出来的一条完整的信息，包含了handler mapping信息。

我现在的请求是 http://localhost:8080/helloWorld，
controller代码

package com.soft.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;

/**
 * Created by xuweiwei on 2017/8/19.
 */
@Controller
public class TestController {

    @RequestMapping(value = "/helloWorld")
    public ModelAndView helloWorld(HttpServletRequest request){
        String name = request.getParameter("name");
        System.out.println(name);
        ModelAndView modelAndView = new ModelAndView();
//        modelAndView.addObject("msg","hello world!!!!!!!");
        modelAndView.addObject("msg", name);
        modelAndView.setViewName("test/helloworld");
        return modelAndView;
    }
}

所以它请求到的一定是这个handler

可以看到框中的内容正是上面的controller。

注意到这块代码中还有一块儿逻辑处理，

handler = hm.getHandler(request);

下面来看看这块都干了些什么事情。

    public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        Object handler = this.getHandlerInternal(request);
        if(handler == null) {
            handler = this.getDefaultHandler();
        }

        if(handler == null) {
            return null;
        } else {
            if(handler instanceof String) {
                String handlerName = (String)handler;
                handler = this.getApplicationContext().getBean(handlerName);
            }

            return this.getHandlerExecutionChain(handler, request);
        }
    }

这里就是在寻找对应的handler，没找到返回为null， getHandler(processedRequest);中的循环继续执行，直到找到对应的handler为止，最后当找到对应的的handler以后会调用，his.getHandlerExecutionChain(handler, request);方法，来放置执行该handler需要放置的东西。

下面来看看，都放了什么东东。

    protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
        HandlerExecutionChain chain = handler instanceof HandlerExecutionChain?(HandlerExecutionChain)handler:new HandlerExecutionChain(handler);
        chain.addInterceptors(this.getAdaptedInterceptors());
        String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
        Iterator var5 = this.mappedInterceptors.iterator();

        while(var5.hasNext()) {
            MappedInterceptor mappedInterceptor = (MappedInterceptor)var5.next();
            if(mappedInterceptor.matches(lookupPath, this.pathMatcher)) {
                chain.addInterceptor(mappedInterceptor.getInterceptor());
            }
        }

        return chain;
    }

可以看到这里最要就是放了拦截器到执行链中去，到此第2部执行结束。返回给前端控制器一个执行链(HandlerExecutionChain),里面包含了handler信息，拦截器信息。

然后再回到前端控制器的doDispatch(HttpServletRequest request, HttpServletResponse response)代码中去。

执行完请求handler请求后，开始请求处理器处理器适配器HandlerAdapter对应代码部分。

HandlerAdapter ex = this.getHandlerAdapter(mappedHandler.getHandler());

    protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
        Iterator var2 = this.handlerAdapters.iterator();

        HandlerAdapter ha;
        do {
            if(!var2.hasNext()) {
                throw new ServletException("No adapter for handler [" + handler + "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
            }

            ha = (HandlerAdapter)var2.next();
            if(this.logger.isTraceEnabled()) {
                this.logger.trace("Testing handler adapter [" + ha + "]");
            }
        } while(!ha.supports(handler));

        return ha;
    }

代码也没什么，就是在找handler对应的适配器。然后返回给前端控制器，然后前端控制器，调用适配器的handle方法（也就是请求处理器适配器执行handler）。也就是下面这句代码。

err = ex.handle(processedRequest, response, mappedHandler.getHandler());
但是在请求执行handler之前还有一句代码比较重要。

 if(!mappedHandler.applyPreHandle(processedRequest, response)) {
                        return;
                    }

这个mappedHandler.applyPreHandle就是在做拦截器的拦截操作(prehandle方法)，如果返回为false直接return掉，不在继续执行下面的代码，这就是springmvc的拦截器的原理。这就是为什么可以拦截请求。去瞄瞄看都有什么东东。

    boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
        if(this.getInterceptors() != null) {
            for(int i = 0; i < this.getInterceptors().length; this.interceptorIndex = i++) {
                HandlerInterceptor interceptor = this.getInterceptors()[i];
                if(!interceptor.preHandle(request, response, this.handler)) {
                    this.triggerAfterCompletion(request, response, (Exception)null);
                    return false;
                }
            }
        }

        return true;
    }

可以看到这里是在循环着执行执行链中放入的需要执行的拦截器的preHandle方法（正叙执行）。如果碰到一个拦截器返回为false，则直接执行triggerAfterCompletion，

应该都还记得拦截器有三个方法，preHandle postHandle afterCompletion 然而，这个方法就执行，afterCompletion 。反正也没事再进去瞄瞄怎么执行。

    void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, Exception ex) throws Exception {
        if(this.getInterceptors() != null) {
            for(int i = this.interceptorIndex; i >= 0; --i) {
                HandlerInterceptor interceptor = this.getInterceptors()[i];

                try {
                    interceptor.afterCompletion(request, response, this.handler, ex);
                } catch (Throwable var7) {
                    logger.error("HandlerInterceptor.afterCompletion threw exception", var7);
                }
            }

        }
    }

可以看到确实在执行着拦截器的 afterCompletion 方法，但是这里面的循环不再是正叙，而是倒叙，这也就是为什么前一篇博客得出的结论，afterCompletion 为倒叙执行。

看到下面这张图的执行结果就恍然大悟了。

前端控制器执行handler之前，执行拦截器操作到此执行完毕。然后才是真正的执行handler。

接下来看下面这块代码

err = ex.handle(processedRequest, response, mappedHandler.getHandler());

看看它的源码，源码在 AbstractHandlerMethodAdapter.java中。

    public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return this.handleInternal(request, response, (HandlerMethod)handler);
    }

继续跟进，发现真正的源码在，RequestMappingHandlerAdapter.java的handleInternal方法里面

 protected final ModelAndView handleInternal(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
        if(this.getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
            this.checkAndPrepare(request, response, this.cacheSecondsForSessionAttributeHandlers, true);
        } else {
            this.checkAndPrepare(request, response, true);
        }

        if(this.synchronizeOnSession) {
            HttpSession session = request.getSession(false);
            if(session != null) {
                Object mutex = WebUtils.getSessionMutex(session);
                synchronized(mutex) {
                    return this.invokeHandleMethod(request, response, handlerMethod);
                }
            }
        }

        return this.invokeHandleMethod(request, response, handlerMethod);
    }

invokeHandleMethod看着很眼熟，java反射机制里面执行某个方法用的就是invoke。

跟进去看看

   private ModelAndView invokeHandleMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
        ServletWebRequest webRequest = new ServletWebRequest(request, response);
        WebDataBinderFactory binderFactory = this.getDataBinderFactory(handlerMethod);
        ModelFactory modelFactory = this.getModelFactory(handlerMethod, binderFactory);
        ServletInvocableHandlerMethod requestMappingMethod = this.createRequestMappingMethod(handlerMethod, binderFactory);
        ModelAndViewContainer mavContainer = new ModelAndViewContainer();
        mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
        modelFactory.initModel(webRequest, mavContainer, requestMappingMethod);
        mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);
        AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
        asyncWebRequest.setTimeout(this.asyncRequestTimeout);
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
        asyncManager.setTaskExecutor(this.taskExecutor);
        asyncManager.setAsyncWebRequest(asyncWebRequest);
        asyncManager.registerCallableInterceptors(this.callableInterceptors);
        asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);
        if(asyncManager.hasConcurrentResult()) {
            Object result = asyncManager.getConcurrentResult();
            mavContainer = (ModelAndViewContainer)asyncManager.getConcurrentResultContext()[0];
            asyncManager.clearConcurrentResult();
            if(this.logger.isDebugEnabled()) {
                this.logger.debug("Found concurrent result value [" + result + "]");
            }

            requestMappingMethod = requestMappingMethod.wrapConcurrentResult(result);
        }

        requestMappingMethod.invokeAndHandle(webRequest, mavContainer, new Object[0]);
        return asyncManager.isConcurrentHandlingStarted()?null:this.getModelAndView(mavContainer, modelFactory, webRequest);
    }

可以看到在执行之前做了一堆的事前准备工作。其他的可以不用理会，主要看
requestMappingMethod.invokeAndHandle(webRequest, mavContainer, new Object[0]);做了一些什么事情。

  public final void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
        Object returnValue = this.invokeForRequest(webRequest, mavContainer, providedArgs);
        this.setResponseStatus(webRequest);
        if(returnValue == null) {
            if(this.isRequestNotModified(webRequest) || this.hasResponseStatus() || mavContainer.isRequestHandled()) {
                mavContainer.setRequestHandled(true);
                return;
            }
        } else if(StringUtils.hasText(this.responseReason)) {
            mavContainer.setRequestHandled(true);
            return;
        }

        mavContainer.setRequestHandled(false);

        try {
            this.returnValueHandlers.handleReturnValue(returnValue, this.getReturnValueType(returnValue), mavContainer, webRequest);
        } catch (Exception var6) {
            if(this.logger.isTraceEnabled()) {
                this.logger.trace(this.getReturnValueHandlingErrorMessage("Error handling return value", returnValue), var6);
            }

            throw var6;
        }
    }

代码中大部分还是在校验，设值，只有invokeForRequest它在干着实事。再看看。它在 InvocableHandlerMethod.java 中

    public final Object invokeForRequest(NativeWebRequest request, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
        Object[] args = this.getMethodArgumentValues(request, mavContainer, providedArgs);
        if(this.logger.isTraceEnabled()) {
            StringBuilder returnValue = new StringBuilder("Invoking [");
            returnValue.append(this.getBeanType().getSimpleName()).append(".");
            returnValue.append(this.getMethod().getName()).append("] method with arguments ");
            returnValue.append(Arrays.asList(args));
            this.logger.trace(returnValue.toString());
        }

        Object returnValue1 = this.invoke(args);
        if(this.logger.isTraceEnabled()) {
            this.logger.trace("Method [" + this.getMethod().getName() + "] returned [" + returnValue1 + "]");
        }

        return returnValue1;
    }

终于找到了，Object[] args = this.getMethodArgumentValues(request, mavContainer, providedArgs);这句在给需要执行的handler的方法准备参数信息。然后

Object returnValue1 = this.invoke(args);来执行方法。

总算找到了，曲曲折折饶了一大弯。最后返回一个ModelAndView给前端控制器。

然后开始执行拦截器的postHandle 也就是这句---- mappedHandler.applyPostHandle(processedRequest, response, err);

源码

    void applyPostHandle(HttpServletRequest request, HttpServletResponse response, ModelAndView mv) throws Exception {
        if(this.getInterceptors() != null) {
            for(int i = this.getInterceptors().length - 1; i >= 0; --i) {
                HandlerInterceptor interceptor = this.getInterceptors()[i];
                interceptor.postHandle(request, response, this.handler, mv);
            }

        }
    }

看的出来跟 triggerAfterCompletion 的执行有相似之处，都是倒叙执行。

所以拦截器那篇博客的结论，所有的preHandle方法都为true的时候postHandle才执行，并且是倒叙执行。这就是原因，这就是原理。

最后前端控制器开始请求视图解析器解析视图，渲染视图等等

this.processDispatchResult(processedRequest, response, mappedHandler, err, dispatchException);

    private void processDispatchResult(HttpServletRequest request, HttpServletResponse response, HandlerExecutionChain mappedHandler, ModelAndView mv, Exception exception) throws Exception {
        boolean errorView = false;
        if(exception != null) {
            if(exception instanceof ModelAndViewDefiningException) {
                this.logger.debug("ModelAndViewDefiningException encountered", exception);
                mv = ((ModelAndViewDefiningException)exception).getModelAndView();
            } else {
                Object handler = mappedHandler != null?mappedHandler.getHandler():null;
                mv = this.processHandlerException(request, response, handler, exception);
                errorView = mv != null;
            }
        }

        if(mv != null && !mv.wasCleared()) {
            this.render(mv, request, response);
            if(errorView) {
                WebUtils.clearErrorRequestAttributes(request);
            }
        } else if(this.logger.isDebugEnabled()) {
            this.logger.debug("Null ModelAndView returned to DispatcherServlet with name \'" + this.getServletName() + "\': assuming HandlerAdapter completed request handling");
        }

        if(!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
            if(mappedHandler != null) {
                mappedHandler.triggerAfterCompletion(request, response, (Exception)null);
            }

        }
    }

这里的代码分三块，一块看看执行Handler结果有没有异常，有的话处理异常，注意这里可以自定义异常，来统一处理。

另一块就是说的请求视图解析器解析，渲染视图等操作。

最后又看到了眼熟的 triggerAfterCompletion 了，这里不在看它。

主要看 this.render(mv, request, response); 看它是怎么请求视图解析器，渲染视图的。

    protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
        Locale locale = this.localeResolver.resolveLocale(request);
        response.setLocale(locale);
        View view;
        if(mv.isReference()) {
            view = this.resolveViewName(mv.getViewName(), mv.getModelInternal(), locale, request);
            if(view == null) {
                throw new ServletException("Could not resolve view with name \'" + mv.getViewName() + "\' in servlet with name \'" + this.getServletName() + "\'");
            }
        } else {
            view = mv.getView();
            if(view == null) {
                throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a " + "View object in servlet with name \'" + this.getServletName() + "\'");
            }
        }

        if(this.logger.isDebugEnabled()) {
            this.logger.debug("Rendering view [" + view + "] in DispatcherServlet with name \'" + this.getServletName() + "\'");
        }

        try {
            view.render(mv.getModelInternal(), request, response);
        } catch (Exception var7) {
            if(this.logger.isDebugEnabled()) {
                this.logger.debug("Error rendering view [" + view + "] in DispatcherServlet with name \'" + this.getServletName() + "\'", var7);
            }

            throw var7;
        }
    }

这里面，前一个if else就是在请求视图解析器。可以看看resolveViewName方法是怎么通过解析器获得视图view的。

    protected View resolveViewName(String viewName, Map<String, Object> model, Locale locale, HttpServletRequest request) throws Exception {
        Iterator var5 = this.viewResolvers.iterator();

        View view;
        do {
            if(!var5.hasNext()) {
                return null;
            }

            ViewResolver viewResolver = (ViewResolver)var5.next();
            view = viewResolver.resolveViewName(viewName, locale);
        } while(view == null);

        return view;
    }

看看即可，不是设么高深的代码。

获取到view以后开始对视图进行渲染，也就是将模型中的数据填充到request中去，

进入到 AbstractView.java 中

    public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
        if(this.logger.isTraceEnabled()) {
            this.logger.trace("Rendering view with name \'" + this.beanName + "\' with model " + model + " and static attributes " + this.staticAttributes);
        }

        Map mergedModel = this.createMergedOutputModel(model, request, response);
        this.prepareResponse(request, response);
        this.renderMergedOutputModel(mergedModel, request, response);
    }

没什么好看的，继续跟踪，renderMergedOutputModel方法。

    protected abstract void renderMergedOutputModel(Map<String, Object> var1, HttpServletRequest var2, HttpServletResponse var3) throws Exception;

发现是个抽象方法，记得springmvc.xml中配置的视图解析器是 InternalResourceViewResolver 所以它对应的 View 是 InternalResourceView

所以会调到这个类里面的renderMergedOutpitModel方法中，上代码

   protected void renderMergedOutputModel(Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest requestToExpose = this.getRequestToExpose(request);
        this.exposeModelAsRequestAttributes(model, requestToExpose);
        this.exposeHelpers(requestToExpose);
        String dispatcherPath = this.prepareForRendering(requestToExpose, response);
        RequestDispatcher rd = this.getRequestDispatcher(requestToExpose, dispatcherPath);
        if(rd == null) {
            throw new ServletException("Could not get RequestDispatcher for [" + this.getUrl() + "]: Check that the corresponding file exists within your web application archive!");
        } else {
            if(this.useInclude(requestToExpose, response)) {
                response.setContentType(this.getContentType());
                if(this.logger.isDebugEnabled()) {
                    this.logger.debug("Including resource [" + this.getUrl() + "] in InternalResourceView \'" + this.getBeanName() + "\'");
                }

                rd.include(requestToExpose, response);
            } else {
                if(this.logger.isDebugEnabled()) {
                    this.logger.debug("Forwarding to resource [" + this.getUrl() + "] in InternalResourceView \'" + this.getBeanName() + "\'");
                }

                rd.forward(requestToExpose, response);
            }

        }
    }

先来看看里面的exposeModelAsRequestAttributes方法

    protected void exposeModelAsRequestAttributes(Map<String, Object> model, HttpServletRequest request) throws Exception {
        Iterator var3 = model.entrySet().iterator();

        while(var3.hasNext()) {
            Entry entry = (Entry)var3.next();
            String modelName = (String)entry.getKey();
            Object modelValue = entry.getValue();
            if(modelValue != null) {
                request.setAttribute(modelName, modelValue);
                if(this.logger.isDebugEnabled()) {
                    this.logger.debug("Added model object \'" + modelName + "\' of type [" + modelValue.getClass().getName() + "] to request in view with name \'" + this.getBeanName() + "\'");
                }
            } else {
                request.removeAttribute(modelName);
                if(this.logger.isDebugEnabled()) {
                    this.logger.debug("Removed model object \'" + modelName + "\' from request in view with name \'" + this.getBeanName() + "\'");
                }
            }
        }

    }

前面说的什么渲染视图，将模型中的数据填充到request中去，就是这里实现了，前面的ModelAndView中的模型数据都已经放入到这个传入的map中去了，然后什么报文头等等页面需要的，最后统一放入到request中去。

看完了 exposeModelAsRequestAttributes 再看接下来的代码，
this.exposeHelpers(requestToExpose);对应的是空代码块，不在说了。

String dispatcherPath = this.prepareForRendering(requestToExpose, response); // 得到view所在的路径 Dispatcher要跳转的路径
RequestDispatcher rd = this.getRequestDispatcher(requestToExpose, dispatcherPath); 得到一个Dispatcher

if(this.useInclude(requestToExpose, response)) {
                response.setContentType(this.getContentType());
                if(this.logger.isDebugEnabled()) {
                    this.logger.debug("Including resource [" + this.getUrl() + "] in InternalResourceView \'" + this.getBeanName() + "\'");
                }

                rd.include(requestToExpose, response);
            } else {
                if(this.logger.isDebugEnabled()) {
                    this.logger.debug("Forwarding to resource [" + this.getUrl() + "] in InternalResourceView \'" + this.getBeanName() + "\'");
                }

                rd.forward(requestToExpose, response);
            }

这里设置跳转的路径，这个include和forword的具体区别，请看

http://blog.csdn.net/huo2007201019/article/details/7584241

这里执行完毕后，就要执行拦截器的最后操作，以及一些final里面的内容。

流程方面的源码解析，完毕。

分析到最后一点的时候发现对servlet的知识忘了，以后要补补。

点击分享，点击进步，终会更上一层楼。

下节，springmvc的参数绑定源码解析。

springmvc----源码分析之springmvc执行流程

猜你喜欢