SpringMVC到底是如何处理请求的?
很多人会用 SpringMVC,但对它的处理请求的方式并不清楚,当我们学习一个知识的时候,了解它会让我们更好地使用它,下面我们来看看 SpringMVC 是如何处理请求的。
先上图:
Spring MVC 框架也是一个基于请求驱动的 Web 框架,并且使用了前端控制器模式(是用来提供一个集中的请求处理机制,所有的请求都将由一个单一的处理程序处理来进行设计,再根据请求映射规则分发给相应的页面控制器(动作/处理器)进行处理。首先让我们整体看一下 Spring MVC 处理请求的流程:
首先用户发送请求,请求被 SpringMVC前端控制器(DispatherServlet)捕获;
前端控制器(DispatherServlet)对请求 URL 解析获取请求 URI,根据 URI,调用 HandlerMapping;
前端控制器(DispatherServlet)获得返回的 HandlerExecutionChain(包括 Handler 对象以及 Handler 对象对应的拦截器);
DispatcherServlet 根据获得的 HandlerExecutionChain,选择一个合适的 HandlerAdapter。(附注:如果成功获得 HandlerAdapter 后,此时将开始执行拦截器的 preHandler(…) 方法);
HandlerAdapter 根据请求的 Handler 适配并执行对应的 Handler;HandlerAdapter 提取 Request 中的模型数据,填充 Handler 入参,开始执行 Handler(Controller)。 在填充 Handler 的入参过程中,根据配置,Spring 将做一些额外的工作:
HttpMessageConveter:将请求消息(如 Json、xml 等数据)转换成一个对象,将对象转换为指定的响应信息;
数据转换:对请求消息进行数据转换。如 String 转换成 Integer、Double 等;
数据格式化:如将字符串转换成格式化数字或格式化日期等;
数据验证: 验证数据的有效性(长度、格式等),验证结果存储到 BindingResult 或 Error 中);
Handler 执行完毕,返回一个 ModelAndView (即模型和视图)给 HandlerAdaptor;
HandlerAdaptor 适配器将执行结果 ModelAndView 返回给前端控制器;
前端控制器接收到 ModelAndView 后,请求对应的视图解析器;
视图解析器解析 ModelAndView 后返回对应 View;
渲染视图并返回渲染后的视图给前端控制器;
最终前端控制器将渲染后的页面响应给用户或客户端。
对于 SpringMVC 项目所有的请求入口(静态资源除外)这里都是从 web.xml 文件配置的前端控制器 DispatcherServlet 开始:
<!-- servlet请求分发器 --><servlet><servlet-name>springMvc</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:servlet-context.xml</param-value></init-param><!-- 表示启动容器时初始化该Servlet --><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>springMvc</servlet-name><!-- 这是拦截请求, /代表拦截所有请求,拦截所有.do请求 --><url-pattern>/</url-pattern></servlet-mapping>
DispatcherServlet UML继承关系图如下:
这里关注蓝线部分继承结构:DispatcherServlet–>FrameworkServlet–>HttpServletBean–>HttpServlet–>GenericServlet–>Servlet,对于请求核心时序图如下:
对于 web 请求的处理,大家都知道是通过继承 HttpServlet 重写其 service 方法,这里打开 DispatcherServlet 源码发现这里并没有看到我们要找的 service 方法,此时到父类 FrameworkServlet 查找如下:可以看到父类重写 HttpServlet service 方法。
/**
* Override the parent class implementation in order to intercept PATCH requests.
*/@Overrideprotectedvoidservice(HttpServletRequest request,HttpServletResponse response)throwsServletException,IOException{HttpMethod httpMethod=HttpMethod.resolve(request.getMethod());if(httpMethod==HttpMethod.PATCH||httpMethod==null){processRequest(request,response);}else{super.service(request,response);}}
从源码分析来看当请求方法为 patch 请求或者为 null 时执行 processRequest0 方法,其他情况则调用父类 service 方法,大家都知道 SpringMVC 请求大多请求是 get|post 请求为主,此时继续向上查看 FrameworkServlet 父类 HttpServletBean(抽象类继承 HttpServlet 并未重写 service 方法,所以向上继续寻找)–> HttpServlet service 方法:
@Overridepublicvoidservice(ServletRequest req,ServletResponse res)throwsServletException,IOException{HttpServletRequest request;HttpServletResponse response;if(!(reqinstanceofHttpServletRequest&&resinstanceofHttpServletResponse)){thrownewServletException("non-HTTP request or response");}request=(HttpServletRequest)req;response=(HttpServletResponse)res;service(request,response);}}protectedvoidservice(HttpServletRequest req,HttpServletResponse resp)throwsServletException,IOException{String method=req.getMethod();if(method.equals(METHOD_GET)){longlastModified=getLastModified(req);if(lastModified==-1){// servlet doesn't support if-modified-since, no reason// to go through further expensive logicdoGet(req,resp);}else{longifModifiedSince=req.getDateHeader(HEADER_IFMODSINCE);if(ifModifiedSince<lastModified){// If the servlet mod time is later, call doGet()// Round down to the nearest second for a proper compare// A ifModifiedSince of -1 will always be lessmaybeSetLastModified(resp,lastModified);doGet(req,resp);}else{resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);}}}elseif(method.equals(METHOD_HEAD)){longlastModified=getLastModified(req);maybeSetLastModified(resp,lastModified);doHead(req,resp);}elseif(method.equals(METHOD_POST)){doPost(req,resp);}elseif(method.equals(METHOD_PUT)){doPut(req,resp);}elseif(method.equals(METHOD_DELETE)){doDelete(req,resp);}elseif(method.equals(METHOD_OPTIONS)){doOptions(req,resp);}elseif(method.equals(METHOD_TRACE)){doTrace(req,resp);}else{//// Note that this means NO servlet supports whatever// method was requested, anywhere on this server.//String errMsg=lStrings.getString("http.method_not_implemented");Object[]errArgs=newObject[1];errArgs[0]=method;errMsg=MessageFormat.format(errMsg,errArgs);resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED,errMsg);}}
可以看到 HttpServlet service 进行了重载,根据不同的请求类型然后调用不同处理方法,这里以 get 请求为例,当请求方法为 get 请求时在重载 service 方法中调用 doGet 方法进行处理,这里需要特别注意的是:HttpServlet 存在 doGet 方法实现,然而在继承的子类中也存在 doGet 方法实现,到底调用哪个方法?很明显调用子类的 doGet 方法(面向对象多态思想!!!)从继承 UML 关系图上看,最外层子类实现 doGet 方法的为 FrameworkServlet :
FrameworkServlet#doGet&processRequest
@OverrideprotectedfinalvoiddoGet(HttpServletRequest request,HttpServletResponse response)throwsServletException,IOException{processRequest(request,response);}protectedfinalvoidprocessRequest(HttpServletRequest request,HttpServletResponse response)throwsServletException,IOException{// 系统计时开始时间longstartTime=System.currentTimeMillis();Throwable failureCause=null;// 国际化LocaleContext previousLocaleContext=LocaleContextHolder.getLocaleContext();LocaleContext localeContext=buildLocaleContext(request);//构建ServletRequestAttributes对象RequestAttributes previousAttributes=RequestContextHolder.getRequestAttributes();ServletRequestAttributes requestAttributes=buildRequestAttributes(request,response,previousAttributes);//异步管理WebAsyncManager asyncManager=WebAsyncUtils.getAsyncManager(request);asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(),newRequestBindingInterceptor());//初始化ContextHoldersinitContextHolders(request,localeContext,requestAttributes);try{doService(request,response);}catch(ServletException|IOException ex){failureCause=ex;throwex;}catch(Throwableex){failureCause=ex;thrownewNestedServletException("Request processing failed",ex);}finally{//恢复原来的LocaleContext和ServiceRequestAttributes到LocaleContextHolder和RequestContextHolder,避免影响Servlet以外的处理,如FilterresetContextHolders(request,previousLocaleContext,previousAttributes);if(requestAttributes!=null){requestAttributes.requestCompleted();}logResult(request,response,failureCause,asyncManager);//发布ServletRequestHandlerEvent消息,这个请求是否执行成功都会发布消息的publishRequestHandledEvent(request,response,startTime,failureCause);}}// initContextHolders(request, localeContext, requestAttributes);privatevoidinitContextHolders(HttpServletRequest request,@NullableLocaleContext localeContext,@NullableRequestAttributes requestAttributes){if(localeContext!=null){LocaleContextHolder.setLocaleContext(localeContext,this.threadContextInheritable);}if(requestAttributes!=null){RequestContextHolder.setRequestAttributes(requestAttributes,this.threadContextInheritable);}}
该方法大概做了这几件事:国际化的设置,创建 ServletRequestAttributes 对象,初始化上下文 holders (即将 Request 对象放入到线程上下文中,如后续想要在方法中获取 request、response对象此时可以通过调用 LocaleContextHolder 对应方法即可),然后调用 doService 方法。对于 doService 方法,FrameworkServlet 类并未提供实现,该方法由 DispatcherServlet 子类实现:
DispatcherServlet 里面执行处理的入口方法是 doService,由于这个类继承于 FrameworkServlet 类,重写了 doService() 方法:
@OverrideprotectedvoiddoService(HttpServletRequest request,HttpServletResponse response)throwsException{logRequest(request);// Keep a snapshot of the request attributes in case of an include,// to be able to restore the original attributes after the include.Map<String,Object>attributesSnapshot=null;if(WebUtils.isIncludeRequest(request)){attributesSnapshot=newHashMap<>();Enumeration<?>attrNames=request.getAttributeNames();while(attrNames.hasMoreElements()){String attrName=(String)attrNames.nextElement();if(this.cleanupAfterInclude||attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)){attributesSnapshot.put(attrName,request.getAttribute(attrName));}}}//Spring上下文request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE,getWebApplicationContext());//国际化解析器request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE,this.localeResolver);//主题解析器request.setAttribute(THEME_RESOLVER_ATTRIBUTE,this.themeResolver);//主题request.setAttribute(THEME_SOURCE_ATTRIBUTE,getThemeSource());//重定向的数据 if(this.flashMapManager!=null){FlashMap inputFlashMap=this.flashMapManager.retrieveAndUpdate(request,response);if(inputFlashMap!=null){request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE,Collections.unmodifiableMap(inputFlashMap));}request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE,newFlashMap());request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE,this.flashMapManager);}try{//request设置完相关的属性做真正的请求处理doDispatch(request,response);}finally{if(!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()){// Restore the original attribute snapshot, in case of an include.if(attributesSnapshot!=null){restoreAttributesAfterInclude(request,attributesSnapshot);}}}}
整个方法看下来处理的操作有:处理 include 标签的请求,将上下文放到 request 的属性中,将国际化解析器放到 request 的属性中,将主题解析器放到 request 属性中,将主题放到 request 的属性中,处理重定向的请求数据最后调用 doDispatch 这个核心的方法对请求进行处理:
该方法是在 doService 方法中调用的,从底层设计了整个请求的处理流程:
根据 request 找到 Handler
根据 Handler 找到对应的 HandlerAdapter
用 HandlerAdapter 处理 Handler
调用 processDispatchResult 方法处理上面之后的结果(包含View渲染并输出给用户)
protectedvoiddoDispatch(HttpServletRequest request,HttpServletResponse response)throwsException{HttpServletRequest processedRequest=request;HandlerExecutionChain mappedHandler=null;booleanmultipartRequestParsed=false;WebAsyncManager asyncManager=WebAsyncUtils.getAsyncManager(request);try{ModelAndView mv=null;Exception dispatchException=null;try{// 校验是否为上传请求 是上传请求执行解析 否则返回requestprocessedRequest=checkMultipart(request);multipartRequestParsed=(processedRequest!=request);// 根据访问的Handler 返回指定对应的HandlerExecutionChain对象 这里从HandlerMapping 集合中查找 HandlerExecutionChain 对象包含Handler与拦截器HandlerInterceptor列表mappedHandler=getHandler(processedRequest);if(mappedHandler==null){noHandlerFound(processedRequest,response);return;}// 根据得到的Handler 获取对应的HandlerAdaptor对象HandlerAdapter ha=getHandlerAdapter(mappedHandler.getHandler());// 处理GET、HEAD请求的Last-ModifiedString method=request.getMethod();booleanisGet="GET".equals(method);if(isGet||"HEAD".equals(method)){longlastModified=ha.getLastModified(request,mappedHandler.getHandler());//当数据没有更改时,就直接返回上次的数据,提高效率if(newServletWebRequest(request,response).checkNotModified(lastModified)&&isGet){return;}}//执行Interceptor的preHandle if(!mappedHandler.applyPreHandle(processedRequest,response)){return;}// 执行Handler 返回ModelAndViewmv=ha.handle(processedRequest,response,mappedHandler.getHandler());//如果需要异步处理,直接返回if(asyncManager.isConcurrentHandlingStarted()){return;}//当view为空时,根据request设置默认view,如Handler返回值为voidapplyDefaultViewName(processedRequest,mv);//执行相应Interceptor的postHandle mappedHandler.applyPostHandle(processedRequest,response,mv);}catch(Exceptionex){dispatchException=ex;}catch(Throwableerr){// As of 4.3, we're processing Errors thrown from handler methods as well,// making them available for @ExceptionHandler methods and other scenarios.dispatchException=newNestedServletException("Handler dispatch failed",err);}//处理返回结果,包括处理异常、渲染页面,发出完成通知触发Interceptor的afterCompletionprocessDispatchResult(processedRequest,response,mappedHandler,mv,dispatchException);}catch(Exceptionex){triggerAfterCompletion(processedRequest,response,mappedHandler,ex);}catch(Throwableerr){triggerAfterCompletion(processedRequest,response,mappedHandler,newNestedServletException("Handler processing failed",err));}finally{if(asyncManager.isConcurrentHandlingStarted()){// Instead of postHandle and afterCompletionif(mappedHandler!=null){mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest,response);}}else{// Clean up any resources used by a multipart request.if(multipartRequestParsed){cleanupMultipart(processedRequest);}}}}
doDispatcher 首先检查是不是上传请求,如果是则将 request 转换为 MultipartHttpServletRequest,并将 multipartRequestParsed 标志设置为 true;
通过 getHandler 获取 Handler 处理器链 HandlerExecutionChain;
处理GET、HEAD请求的 Last-Modified,这里主要判断 Last-Modified 值是否被修改来处理决定是否采用缓存数据;
接下来依次调用相应的 Interceptor 的 preHandle,执行拦截器拦截操作;
拦截器 preHandle 方法执行后,此时开始通过 HandlerAdapter 适配对应的 Handler 执行(这里才是真正要执行的 Controller 方法), Handler 处理完请求后,如果需要异步处理则直接返回,如果不需要异步处理,当 view 为空时,设置默认 view,然后执行相应的 Interceptor 的postHandle。
Handler:处理器,他直接对应着 MVC 中的 C,也就是 Controller 层,它的具体表现形式有很多,可以是类,也可以是方法(通常以方法居多),因为它的定义是 Object,我们在方法中标注的 @RequestMapping 的所有方法都可以看成一个 Handler,只要可以实际处理请求的都可以看成 Handler。
HandlerMapping:用来查找 Handler,在 SpringMVC 中会处理很多请求,每一个请求都需要一个 Handler 来处理,具体接受到请求后需要哪一个 Handler 来处理,此时通过 HandlerMapping 来实现查找。
HandlerAdapter:适配器,不同的 Handler 需要找到不同 HandlerAdapter 来调用 Handler。就如工厂里需要使用工具,工人(HandlerAdapter)使用工具(Handler)完成工作,而 HandlerMapping 用于根据需要完成的工作来找到相应的工具。
DispatcherServlet#processDispatchResult
processDispatchResult 方法主要用来处理前面返回的结果,其中包括处理异常、渲染页面、触发 Interceptor 的 afterCompletion 方法三部分内容,处理的异常是在处理请求 doDispatch 方法的过程中产生。
privatevoidprocessDispatchResult(HttpServletRequest request,HttpServletResponse response,@NullableHandlerExecutionChain mappedHandler,@NullableModelAndView mv,@NullableException exception)throwsException{booleanerrorView=false;// 如果请求过程中有异常抛出则处理异常if(exception!=null){if(exceptioninstanceofModelAndViewDefiningException){logger.debug("ModelAndViewDefiningException encountered",exception);mv=((ModelAndViewDefiningException)exception).getModelAndView();}else{Object handler=(mappedHandler!=null?mappedHandler.getHandler():null);mv=processHandlerException(request,response,handler,exception);errorView=(mv!=null);}}//执行页面渲染操作if(mv!=null&&!mv.wasCleared()){render(mv,request,response);if(errorView){WebUtils.clearErrorRequestAttributes(request);}}else{if(logger.isTraceEnabled()){logger.trace("No view rendering, null ModelAndView returned.");}}if(WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()){// Concurrent handling started during a forwardreturn;}// Handler请求处理完,触发Interceptor的afterCompletionif(mappedHandler!=null){// Exception (if any) is already handled..mappedHandler.triggerAfterCompletion(request,response,null);}}
render 视图渲染:
protectedvoidrender(ModelAndView mv,HttpServletRequest request,HttpServletResponse response)throwsException{// Determine locale for request and apply it to the response.Locale locale=(this.localeResolver!=null?this.localeResolver.resolveLocale(request):request.getLocale());response.setLocale(locale);View view;String viewName=mv.getViewName();if(viewName!=null){// We need to resolve the view name.view=resolveViewName(viewName,mv.getModelInternal(),locale,request);if(view==null){thrownewServletException("Could not resolve view with name '"+mv.getViewName()+"' in servlet with name '"+getServletName()+"'");}}else{// No need to lookup: the ModelAndView object contains the actual View object.view=mv.getView();if(view==null){thrownewServletException("ModelAndView ["+mv+"] neither contains a view name nor a "+"View object in servlet with name '"+getServletName()+"'");}}if(logger.isTraceEnabled()){logger.trace("Rendering view ["+view+"] ");}try{if(mv.getStatus()!=null){response.setStatus(mv.getStatus().value());}// 渲染页面处理view.render(mv.getModelInternal(),request,response);}catch(Exceptionex){if(logger.isDebugEnabled()){logger.debug("Error rendering view ["+view+"]",ex);}throwex;}}
今天我们来了解了一下 SpringMVC 框架中 MVC 核心思想,SpringMVC 内部请求流程分析以及源码级别代码解读,让大家真正能够从底层级别理解整个框架执行原貌,最后以一张图来总结今天的源码分析执行流程。
模型-视图-控制器(MVC)是一个众所周知的以设计界面应用程序为基础的设计思想。它主要通过分离模型、视图及控制器在应用程序中的角色将业务逻辑从界面中解耦。通常,模型负责封装应用程序数据在视图层展示。视图仅仅只是展示这些数据,不包含任何业务逻辑。控制器负责接收来自用户的请求,并调用后台服务(service或者dao)来处理业务逻辑。处理后,后台业务层可能会返回了一些数据在视图层展示。控制器收集这些数据及准备模型在视图层展示。MVC模式的核心思想是将业务逻辑从界面中分离出来,允许它们单独改变而不会相互影响。
view + “]”, ex);
}
throw ex;
}
}
今天我们来了解了一下 SpringMVC 框架中 MVC 核心思想,SpringMVC 内部请求流程分析以及源码级别代码解读,让大家真正能够从底层级别理解整个框架执行原貌,最后以一张图来总结今天的源码分析执行流程。
[外链图片转存中...(img-MAtKmB3j-1607396371044)]
## 扩展~MVC
模型-视图-控制器(MVC)是一个众所周知的以设计界面应用程序为基础的设计思想。它主要通过分离模型、视图及控制器在应用程序中的角色将业务逻辑从界面中解耦。通常,模型负责封装应用程序数据在视图层展示。视图仅仅只是展示这些数据,不包含任何业务逻辑。控制器负责接收来自用户的请求,并调用后台服务(service或者dao)来处理业务逻辑。处理后,后台业务层可能会返回了一些数据在视图层展示。控制器收集这些数据及准备模型在视图层展示。MVC模式的核心思想是将业务逻辑从界面中分离出来,允许它们单独改变而不会相互影响。
[外链图片转存中...(img-2j1sGTJI-1607396371047)]