目录
全过程略写图
- 用户发送请求，经过前端控制器Dispacherservlet（Controller的核心）将url交给处理器映射器HandlerMapping处理
- 处理器映射器HandlerMapping处理url，返回HandlerExecutionChain（可能包含拦截器，一定包含自定义的Controller(handler)）
- 前端控制器将Controller交给处理器适配器HandlerAdapter处理，处理完成后，返回MV对象（ModelAndView）
- 前端控制器将MV交给视图解析器处理ViewResolver，处理的过程：将MV拆分成Model和view两个对象，并且将model渲染到view视图上，并且将view返回给前端控制器。
- 最后，前端控制器将视图响应给用户
二、SpringMVC处理请求源码分析
2.1全过程详解图
2.2执行过程：
第一步：发起请求到前端控制器(DispatcherServlet)
第二步：前端控制器请求HandlerMapping查找 Handler可以根据xml配置、注解进行查找
第三步：处理器映射器HandlerMapping向前端控制器返回Handler
第四步：前端控制器调用处理器适配器去执行Handler
第五步：处理器适配器去执行Handler
第六步：Handler执行完成给适配器返回ModelAndView
第七步：处理器适配器向前端控制器返回ModelAndView ModelAndView是springmvc框架的一个 底层对象，包括 Model和view
第八步：前端控制器请求视图解析器去进行视图解析根据逻辑视图名解析成真正的视图(jsp)
第九步：视图解析器向前端控制器返回View
第十步：前端控制器进行视图渲染视图渲染将模型数据(在ModelAndView对象中)填充到request域
第十一步：前端控制器向用户响应结果
2.3源码解析
首先我们大家都知道SpringMvc是通过DispatcherServlet这个类和web.xml配置中的拦截来接管Tomcat中的请求的。所有想看所有关于控制器(打了Controller注解)的细节基本都是在DispatcherServlet这个类中，下面我们就来看看DispatcherServlet中的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 mv = null;
Exception dispatchException = null;
try {
//可以看出springMVC最先初始化的是文件上传组件
processedRequest = checkMultipart(request);
multipartRequestParsed = (processedRequest != request);
//为request请求找到对应的处理器
(源码在下一个三级标题)
mappedHandler = getHandler(processedRequest);
//非空判断
if (mappedHandler == null) {
noHandlerFound(processedRequest, response);
return;
}
//
很明显这是为了拿到处理器适配器了
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
//
获取Method，并且在下面代码就开始和Method比较了
String method = request.getMethod();
boolean isGet = "GET".equals(method);
if (isGet || "HEAD".equals(method)) {
long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
return;
}
}
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
// Actually invoke the handler.
真正执行处理器适配的方法，返回ModelAndView对象了
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
//是否需要解析view name ，渲染时需要。
applyDefaultViewName(processedRequest, mv);
//执行处理器的postHandler方法
mappedHandler.applyPostHandle(processedRequest, response, mv);
}
//下一步的方法就是拿着ModelAndView去render(渲染)了，至此程序跑完，页面也出来了(这一步也有视图解析器工作流程)
//将map和model参数保存在request中是在internResourceView的exposeModelRequestAttribute
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
}
按照主流程进行，它执行到源码中的mappedHandler = getHandler(processedRequest);这句代码，我们进入getHandler方法。
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
//此时会拿到所有的处理器映射器进行匹配
if (this.handlerMappings != null) {
for (HandlerMapping mapping : this.handlerMappings) {
//通过处理器映射器去找到对应的处理器(三级标题为getHandler)
HandlerExecutionChain handler = mapping.getHandler(request);
if (handler != null) {
return handler;
}
}
}
return null;
}
这个方法首先会使用一个for循环，遍历所有的handlerMapping。他会调用每个HandlerMapping的getHandler方法进行映射，如果某个HandlerMapping映射成功了就会直接返回（可以使用@Order注解配置优先级），不会再接着映射了，返回一个处理器映射器链（为什么会是链，因为可能会有拦截器需要执行），如果没有配置HandlerMapping，就会直接返回null。
处理器映射器：
接下来会执行HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());去找到合适的HandlerAdapter
protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
if (this.handlerAdapters != null) {
for (HandlerAdapter adapter : this.handlerAdapters) {
if (adapter.supports(handler)) {
return adapter;
}
}
}
throw new ServletException("No adapter for handler [" + handler +
"]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}
首先它会遍历所有的HandlerAdapter，然后调用supports方法判断当前的HandlerAdapter是否支持。它会根据前面handlerMapping返回的Handler的具体类去调用不同的supports的实现方法，来判断。具体的作用就是根据不同的Handler去选择最合适的HandlerAdapter。
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
// 返回false就不进行后续处理了
return;
}
这个就是调用了applyPreHandle方法，我们进入该方法。
boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
for (int i = 0; i < this.interceptorList.size(); i++) {
HandlerInterceptor interceptor = this.interceptorList.get(i);
if (!interceptor.preHandle(request, response, this.handler)) {
triggerAfterCompletion(request, response, null);
return false;
}
this.interceptorIndex = i;
}
return true;
}
上述代码调用了前置拦截器preHandler方法
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
上述代码执行了最合适的HandlerAdapter的handle方法
@Override
@Nullable
public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
return handleInternal(request, response, (HandlerMethod) handler);
}
@Override
protected ModelAndView handleInternal(HttpServletRequest request,
HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
ModelAndView mav;
// 检查当前请求的method是否为支持的method(默认Null,可通过继承AbstractController设置supportedMethods)
// 检查当前请求是否必须session (默认false,可通过继承AbstractController设置requireSession)
checkRequest(request);
/**
* 判断当前是否需要支持在同一个session中只能线性地处理请求
* 因为锁是通过 synchronized 是 JVM 进程级，所以在分布式环境下，
* 无法达到同步相同 Session 的功能。默认情况下，synchronizeOnSession 为 false
*/
if (this.synchronizeOnSession) {
// 获取当前请求的session对象
HttpSession session = request.getSession(false);
if (session != null) {
// 为当前session生成一个唯一的可以用于锁定的key
Object mutex = WebUtils.getSessionMutex(session);
synchronized (mutex) {
// 对HandlerMethod进行参数等的适配处理，并调用目标handler
mav = invokeHandlerMethod(request, response, handlerMethod);
}
}
else {
// 如果当前不存在session，则直接对HandlerMethod进行适配
mav = invokeHandlerMethod(request, response, handlerMethod);
}
}
else {
// *如果当前不需要对session进行同步处理，则直接对HandlerMethod进行适配
mav = invokeHandlerMethod(request, response, handlerMethod);
}
//判断当前请求头中是否包含Cache-Control请求头，如果不包含，则对当前response进行处理
if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
// 如果当前SessionAttribute中存在配置的attributes，则为其设置过期时间。
// 这里SessionAttribute主要是通过@SessionAttribute注解生成的
if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
}
else {
// 如果当前不存在SessionAttributes，则判断当前是否存在Cache-Control设置，
// 如果存在，则按照该设置进行response处理，如果不存在，则设置response中的
// Cache的过期时间为-1，即立即失效
prepareResponse(response);
}
}
return mav;
}
然后执行invokeHandlerMethod方法。
@Nullable
protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
// 把我们的请求req resp包装成 ServletWebRequest
ServletWebRequest webRequest = new ServletWebRequest(request, response);
try {
// 获取容器中全局配置的InitBinder和当前HandlerMethod所对应的Controller中
// 配置的InitBinder，用于进行参数的绑定
WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
// 获取容器中全局配置的ModelAttribute和当前HandlerMethod所对应的Controller 中配置的ModelAttribute，
// 这些配置的方法将会在目标方法调用之前进行调用
ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
// 封装handlerMethod，会在调用前解析参数、调用后对返回值进行处理
ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
if (this.argumentResolvers != null) {
// 让invocableMethod拥有参数解析能力
invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
}
if (this.returnValueHandlers != null) {
// 让invocableMethod拥有返回值处理能力
invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
}
// 让invocableMethod拥有InitBinder解析能力
invocableMethod.setDataBinderFactory(binderFactory);
// 设置ParameterNameDiscoverer，该对象将按照一定的规则获取当前参数的名称
invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
// ModelAndView处理容器
ModelAndViewContainer mavContainer = new ModelAndViewContainer();
// 将request的Attribute复制一份到ModelMap
mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
// *调用我们标注了@ModelAttribute的方法,主要是为我们的目标方法预加载
modelFactory.initModel(webRequest, mavContainer, invocableMethod);
// 重定向的时候，忽略model中的数据 默认false
mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);
// 获取当前的AsyncWebRequest，这里AsyncWebRequest的主要作用是用于判断目标
// handler的返回值是否为WebAsyncTask或DeferredResult，如果是这两种中的一种，
// 则说明当前请求的处理应该是异步的。所谓的异步，指的是当前请求会将Controller中
// 封装的业务逻辑放到一个线程池中进行调用，待该调用有返回结果之后再返回到response中。
// 这种处理的优点在于用于请求分发的线程能够解放出来，从而处理更多的请求,提高吞吐。
// 只有待目标任务完成之后才会回来将该异步任务的结果返回。
AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
asyncWebRequest.setTimeout(this.asyncRequestTimeout);
// 封装异步任务的线程池、request、interceptors到WebAsyncManager中
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();
LogFormatUtils.traceDebug(logger, traceOn -> {
String formatted = LogFormatUtils.formatValue(result, !traceOn);
return "Resume with async result [" + formatted + "]";
});
invocableMethod = invocableMethod.wrapConcurrentResult(result);
}
// *对请求参数进行处理，调用目标HandlerMethod，并且将返回值封装为一个ModelAndView对象
invocableMethod.invokeAndHandle(webRequest, mavContainer);
if (asyncManager.isConcurrentHandlingStarted()) {
return null;
}
// 对封装的ModelAndView进行处理，主要是判断当前请求是否进行了重定向，如果进行了重定向，
// 还会判断是否需要将FlashAttributes封装到新的请求中
return getModelAndView(mavContainer, modelFactory, webRequest);
}
finally {
webRequest.requestCompleted();
}
}
后执行invocableMethod.invokeAndHandle(webRequest, mavContainer)方法
public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
Object... providedArgs) throws Exception {
/*真正的调用我们的目标对象 很重要 很重要*/
Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
// 设置相关的返回状态
setResponseStatus(webRequest);
// 如果请求处理完成，则设置requestHandled属性
if (returnValue == null) {
if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
disableContentCachingIfNecessary(webRequest);
mavContainer.setRequestHandled(true);
return;
}
}
// 如果请求失败，但是有错误原因，那么也会设置requestHandled属性
else if (StringUtils.hasText(getResponseStatusReason())) {
mavContainer.setRequestHandled(true);
return;
}
mavContainer.setRequestHandled(false);
Assert.state(this.returnValueHandlers != null, "No return value handlers");
try {
// 遍历当前容器中所有ReturnValueHandler，判断哪种handler支持当前返回值的处理，
// 如果支持，则使用该handler处理该返回值
this.returnValueHandlers.handleReturnValue(
returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
}
catch (Exception ex) {
if (logger.isTraceEnabled()) {
logger.trace(formatErrorForReturnValue(returnValue), ex);
}
throw ex;
}
}
然后执行invokeForRequest执行我们真正的Controller中方法
@Nullable
public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
Object... providedArgs) throws Exception {
//*获取我们目标方法入参的值
Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
if (logger.isTraceEnabled()) {
logger.trace("Arguments: " + Arrays.toString(args));
}
//真的的调用我们的目标方法
return doInvoke(args);
}
这里同样用的是反射，这里就是解析我们的参数，然后调用目标方法。继续回到invokeAndHandle方法，拿到了执行的返回值后，我们会对返回值结果进行解析。
this.returnValueHandlers.handleReturnValue(
returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
调用了handleReturnValue进行返回值解析
@Override
public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
if (handler == null) {
throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());
}
handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
}
@Nullable
private HandlerMethodReturnValueHandler selectHandler(@Nullable Object value, MethodParameter returnType) {
boolean isAsyncValue = isAsyncReturnValue(value, returnType);
for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) {
if (isAsyncValue && !(handler instanceof AsyncHandlerMethodReturnValueHandler)) {
continue;
}
if (handler.supportsReturnType(returnType)) {
return handler;
}
}
return null;
}
HandlerMethodReturnValueHandler方法会根据你的返回值类型是String或者ModelAndView来选择合适的返回值解析器，然后在handleReturnValue方法中调用返回值解析器的handleReturnValue方法对返回值进行解析。回到handleInternal返回上面代码的处理结果最后会被封装为一个ModelAndView对象，返回到handleInternal方法中（如果返回值是Json这个mva对象就是null，就没有后续处理了）。继续回到doDispatch方法。继续执行下面代码：
applyDefaultViewName(processedRequest, mv);
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
上面代码就是真正的开始渲染视图了
private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
@Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
@Nullable Exception exception) throws Exception {
boolean errorView = false;
// 异常视图（处理抛出异常的视图）
if (exception != null) {
if (exception instanceof ModelAndViewDefiningException) {
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);
}
}
// Did the handler return a view to render?
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 forward
return;
}
if (mappedHandler != null) {
// Exception (if any) is already handled.. 拦截器：AfterCompletion
mappedHandler.triggerAfterCompletion(request, response, null);
}
}
当没有出现异常的时候会调用，就调用render方法去解析、渲染视图。
protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
// 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) {
// 调用resolveViewName方法去解析视图名称
view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
if (view == null) {
throw new ServletException("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) {
throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a " +
"View object in servlet with name '" + getServletName() + "'");
}
}
// Delegate to the View object for rendering.
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 (Exception ex) {
if (logger.isDebugEnabled()) {
logger.debug("Error rendering view [" + view + "]", ex);
}
throw ex;
}
}
上面代码首先会解析视图的名称（我们知道ModelAndView中的视图名称可能只是一个具体的jsp的文件名，但实际要解析成有前缀和后缀的详细文件名称），调用的代码是view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
@Nullable
protected View resolveViewName(String viewName, @Nullable Map<String, Object> model,
Locale locale, HttpServletRequest request) throws Exception {
if (this.viewResolvers != null) {
for (ViewResolver viewResolver : this.viewResolvers) {
View view = viewResolver.resolveViewName(viewName, locale);
if (view != null) {
return view;
}
}
}
return null;
}
@Override
public void render(@Nullable Map<String, ?> model, HttpServletRequest request,
HttpServletResponse response) throws Exception {
if (logger.isDebugEnabled()) {
logger.debug("View " + formatViewName() +
", model " + (model != null ? model : Collections.emptyMap()) +
(this.staticAttributes.isEmpty() ? "" : ", static attributes " + this.staticAttributes));
}
Map<String, Object> mergedModel = createMergedOutputModel(model, request, response);
prepareResponse(request, response);
// 这里
renderMergedOutputModel(mergedModel, getRequestToExpose(request), response);
然后执行renderMergedOutputModel(mergedModel, getRequestToExpose(request), response)这句代码：
@Override
protected void renderMergedOutputModel(
Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
// Expose the model object as request attributes. 将model设置到request的attribute中.
exposeModelAsRequestAttributes(model, request);
// Expose helpers as request attributes, if any. 设置国际化资源
exposeHelpers(request);
// Determine the path for the request dispatcher. 防止死循环请求
String dispatcherPath = prepareForRendering(request, response);
// Obtain a RequestDispatcher for the target resource (typically a JSP).
// 通过request拿到RequestDispatcher request.getRequestDispacther("/test.jsp")
RequestDispatcher rd = getRequestDispatcher(request, dispatcherPath);
if (rd == null) {
throw new ServletException("Could not get RequestDispatcher for [" + getUrl() +
"]: Check that the corresponding file exists within your web application archive!");
}
// If already included or response already committed, perform include, else forward.
if (useInclude(request, response)) {
response.setContentType(getContentType());
if (logger.isDebugEnabled()) {
logger.debug("Including [" + getUrl() + "]");
}
rd.include(request, response);
}
else {
// Note: The forwarded resource is supposed to determine the content type itself.
if (logger.isDebugEnabled()) {
logger.debug("Forwarding to [" + getUrl() + "]");
} // RequestDispatcher.forward直接转发，就这么简单粗暴
rd.forward(request, response);
}
}
执行的是这句代码exposeModelAsRequestAttributes(model, request);。
protected void exposeModelAsRequestAttributes(Map<String, Object> model,
HttpServletRequest request) throws Exception {
// 将model解析到request的attribute中
model.forEach((name, value) -> {
if (value != null) {
request.setAttribute(name, value);
}
else {
request.removeAttribute(name);
}
});
}
上面代码就是讲model解析到request的attribute属性中。回到renderMergedOutputModel方法。然后就是设置一些国际化资源，然后执行RequestDispatcher rd = getRequestDispatcher(request, dispatcherPath);拿到RequestDispatcher对象。最后调用rd.forward(request, response);进行请求转发。回到processDispatchResult方法，最后执行最后的拦截器afterCompletion方法。
if (mappedHandler != null) {
// Exception (if any) is already handled.. 拦截器：AfterCompletion
mappedHandler.triggerAfterCompletion(request, response, null);
}
以上SpringMVC的大致流程。
三、总结
总的来说，Spring MVC 的请求处理流程是一个经典的 MVC 模式的实现，通过各个组件的配合，实现了请求的接收、处理、响应的完整流程，为开发者提供了一种简单、灵活且可扩展的方式来构建 Web 应用程序。熟悉这些流程和组件对于理解 Spring MVC 的工作原理和实现机制非常重要，有助于更加高效地开发和调试应用程序。
1994
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
