经过前面几部分的分享,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里面的内容。
流程方面的源码解析,完毕。