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. */@Controllerpublic 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的参数绑定源码解析。