一个请求到达controller的过程分析（MVC工作流程）

向右看齐 2024-03-24 08:28 64阅读 0赞

## 前言 ##

面试中问到，一个请求到达controller之前经过了什么，我们会想到前端页面发出请求的过程：DNS解析—三次握手—四次分手。这个回答是不照应的，人家问的一个请求到达controller之前经过了什么，今天拿着代码就简单分析一下（当然这里其实就是MVC工作的流程哈）。

项目：最基础的springboot项目，有个controller就行。

## 开始分析 ##

我们应该从哪里开始入手呢？我们都知道“前端控制器DispatcherServlet”，但是DispatcherServlet在代码里边是怎么体现出来的呢，我们也不知道。  
这样，我们先打个断点在controller里边，进行debugger一下，看看能看到什么。  
![在这里插入图片描述][993808ca14724aec9442fd93bdc44b79.png]  
可以看到有个DispatcherServlet，当然再往前看，可以看到HttpServlet，我们刚开始学习java web的时候，应该挺熟悉HttpServlet的，现在是不是和我一样的把这个东西忘的差不多了。。。

// HttpServlet.class
        @Override
        public void service(ServletRequest req, ServletResponse res)
            throws ServletException, IOException {
        
    
            HttpServletRequest  request;
            HttpServletResponse response;
    
            try {
        
                request = (HttpServletRequest) req;
                response = (HttpServletResponse) res;
            } catch (ClassCastException e) {
        
                throw new ServletException(lStrings.getString("http.non_http"));
            }
            service(request, response);
        }

可以明显的看到，这里是把ServletRequest和ServletResponse 给强转为 HttpServletRequest和HttpServletResponse对象，之后继续往下调用，会进入FrameworkServlet的service方法。

// FrameworkServlet.class
    @Override
    	protected void service(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
        
    
    		HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
    		//判断是否是PATCH请求
    		if (httpMethod == HttpMethod.PATCH || httpMethod == null) {
        
    			processRequest(request, response);
    		}
    		else {
        
    			super.service(request, response);
    		}
    	}

![在这里插入图片描述][26aeb75c66334a45835c83ec62ed99e9.png]  
我们从类的关系图上可以看到，FrameworkServlet是HttpServlet的子类，这里也算是验证了Spring是基于Servlet来进行处理请求的。  
显然我们的请求不是PATCH请求，所以走的是else判断，继续往下，进入到了HttpServlet.service方法。这个方法的主要作用是：接收标准的HTTP请求，并将他们分派到具体的doMethod方法中。

// HttpServlet.class
    protected void service(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        
    
            String method = req.getMethod();
    
            if (method.equals(METHOD_GET)) {
        
                long lastModified = getLastModified(req);
                if (lastModified == -1) {
        
                    // servlet doesn't support if-modified-since, no reason
                    // to go through further expensive logic
                    doGet(req, resp);
                } else {
        
                    long ifModifiedSince;
                    try {
        
                        ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                    } catch (IllegalArgumentException iae) {
        
                        // Invalid date header - proceed as if none was set
                        ifModifiedSince = -1;
                    }
                    if (ifModifiedSince < (lastModified / 1000 * 1000)) {
        
                        // 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 less
                        maybeSetLastModified(resp, lastModified);
                        doGet(req, resp);
                    } else {
        
                        resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                    }
                }
    
            } else if (method.equals(METHOD_HEAD)) {
        
                long lastModified = getLastModified(req);
                maybeSetLastModified(resp, lastModified);
                doHead(req, resp);
    
            } else if (method.equals(METHOD_POST)) {
        
                doPost(req, resp);
    
            } else if (method.equals(METHOD_PUT)) {
        
                doPut(req, resp);
    
            } else if (method.equals(METHOD_DELETE)) {
        
                doDelete(req, resp);
    
            } else if (method.equals(METHOD_OPTIONS)) {
        
                doOptions(req,resp);
    
            } else if (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 = new Object[1];
                errArgs[0] = method;
                errMsg = MessageFormat.format(errMsg, errArgs);
    
                resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
            }
        }

我们请求是get请求，所以这里进入的是doGet(req, resp);方法。  
这里是将GET请求委托给processRequest，当然，我们也是可以看到doPost、doPut、doDelete这几个方法里边的调用都是一样的，都是调用了processRequest(request, response);方法。

// FrameworkServlet.class
    	@Override
    	protected final void doGet(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
        
    
    		processRequest(request, response);
    	}

在这里，会进行一些国际化的设置等等，请求的处理是通过抽象的doService模板方法来执行的，最终会发布一个ServletRequestHandledEvent的事件。

// FrameworkServlet.class
    protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
        
    
    		long startTime = System.currentTimeMillis();
    		Throwable failureCause = null;
    		
    		// 国际化的设置
    		LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
    		LocaleContext localeContext = buildLocaleContext(request);
    
    		RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
    		ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);
    
    		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    		asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());
    
    		initContextHolders(request, localeContext, requestAttributes);
    
    		try {
        
    			// 具体方法的执行者
    			doService(request, response);
    		}
    		catch (ServletException | IOException ex) {
        
    			failureCause = ex;
    			throw ex;
    		}
    		catch (Throwable ex) {
        
    			failureCause = ex;
    			throw new NestedServletException("Request processing failed", ex);
    		}
    
    		finally {
        
    			resetContextHolders(request, previousLocaleContext, previousAttributes);
    			if (requestAttributes != null) {
        
    				requestAttributes.requestCompleted();
    			}
    			logResult(request, response, failureCause, asyncManager);
    			publishRequestHandledEvent(request, response, startTime, failureCause);
    		}
    	}

之后，我们进入doService方法，发现此方法是在DispatcherServlet之中，看到这里，我们终于知道了DispatcherServlet是在哪里了。

## DispatcherServlet的分析 ##

DispatcherServlet是MVC中的核心，我们好好看看它吧。  
在这个方法中，暴露出DispatcherServlet特定的请求属性，并委托doDispatch方法继续往下执行的。

//DispatcherServlet.class
    	@Override
    	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
        
    		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.
    		// 请求是include请求时，保存一份请求属性的快照，一边后续可以进行恢复
    		Map<String, Object> attributesSnapshot = null;
    		if (WebUtils.isIncludeRequest(request)) {
        
    			attributesSnapshot = new HashMap<>();
    			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));
    				}
    			}
    		}
    
    		// Make framework objects available to handlers and view objects.
    		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, new FlashMap());
    			request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
    		}
    
    		RequestPath previousRequestPath = null;
    		if (this.parseRequestPath) {
        
    			previousRequestPath = (RequestPath) request.getAttribute(ServletRequestPathUtils.PATH_ATTRIBUTE);
    			ServletRequestPathUtils.parseAndCache(request);
    		}
    
    		try {
        
    			//具体执行方法
    			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);
    				}
    			}
    			if (this.parseRequestPath) {
        
    				ServletRequestPathUtils.setParsedRequestPath(previousRequestPath, request);
    			}
    		}
    	}

进入到doDispatch方法中，  
此方法的主要作用：  
1、确定当前请求的HandlerExecutionChain（handler对象和拦截器）  
2、确定当前请求的handler adapter  
3、由handler adapter执行具体的handler，会进入我们的controller，返回一个ModelAndView对象  
4、在controller方法之前之后调用拦截器的方法preHandle、postHandle  
5、解析ModelAndView

//DispatcherServlet.class
    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 {
        
    				processedRequest = checkMultipart(request);
    				multipartRequestParsed = (processedRequest != request);
    
    				// Determine handler for the current request.
    				// 1、确定当前请求的HandlerExecutionChain（handler对象和拦截器）
    				mappedHandler = getHandler(processedRequest);
    				if (mappedHandler == null) {
        
    					noHandlerFound(processedRequest, response);
    					return;
    				}
    
    				// Determine handler adapter for the current request.				
    				// 2、确定当前请求的handler adapter
    				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
    
    				// Process last-modified header, if supported by the handler.
    				String method = request.getMethod();
    				boolean isGet = HttpMethod.GET.matches(method);
    				if (isGet || HttpMethod.HEAD.matches(method)) {
        
    					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
    					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
        
    						return;
    					}
    				}
    				
    				// 在controller方法调用之前进行调用拦截器preHandle方法
    				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
        
    					return;
    				}
    
    				// Actually invoke the handler.
    				// 3、由handler adapter执行具体的handler，会进入我们的controller
    				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    
    				if (asyncManager.isConcurrentHandlingStarted()) {
        
    					return;
    				}
    
    				applyDefaultViewName(processedRequest, mv);
    				// 在controller方法调用之后进行调用拦截器postHandle方法
    				mappedHandler.applyPostHandle(processedRequest, response, mv);
    			}
    			catch (Exception ex) {
        
    				dispatchException = ex;
    			}
    			catch (Throwable err) {
        
    				// As of 4.3, we're processing Errors thrown from handler methods as well,
    				// making them available for @ExceptionHandler methods and other scenarios.
    				dispatchException = new NestedServletException("Handler dispatch failed", err);
    			}
    			// 5、解析ModelAndView或着它产生的Exception
    			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    		}
    		catch (Exception ex) {
        
    			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
    		}
    		catch (Throwable err) {
        
    			triggerAfterCompletion(processedRequest, response, mappedHandler,
    					new NestedServletException("Handler processing failed", err));
    		}
    		finally {
        
    			if (asyncManager.isConcurrentHandlingStarted()) {
        
    				// Instead of postHandle and afterCompletion
    				if (mappedHandler != null) {
        
    					mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
    				}
    			}
    			else {
        
    				// Clean up any resources used by a multipart request.
    				if (multipartRequestParsed) {
        
    					cleanupMultipart(processedRequest);
    				}
    			}
    		}
    	}

在打了断点的情况下，可以明显看到getHandler方法返回了具体的handler对象和拦截器。  
![在这里插入图片描述][c0e89fbe4f2e4784917492d86a531ff6.png]  
我们进去getHandler方法，看一眼，发现是遍历了handlerMappings，在这里边得到具体的handler。  
![在这里插入图片描述][c699755b75a6413a964ace44c9899163.png]  
![在这里插入图片描述][232b4decfde24420a032dda1f2c5be53.png]  
可以看到一个handler叫RequestMappingHandlerMapping，它的属性mappingRegistry，里面有个属性registry，存放了我们所有的controller。RequestMappingHandlerMapping就是专门用来处理请求的。

那这里的handlerMappings是怎么来的呢，我们可以发现，它是在onRefresh方法中进行了初始化。  
而onRefresh的父方法是FrameworkServlet的onRefresh方法，它是一个Template方法，该方法可以被覆盖以添加servlet特定的刷新工作。在成功刷新上下文后调用。此实现为空。

//DispatcherServlet.class
    
    	/** List of HandlerMappings used by this servlet. */
    	@Nullable
    	private List<HandlerMapping> handlerMappings;
    
    	/** List of HandlerAdapters used by this servlet. */
    	@Nullable
    	private List<HandlerAdapter> handlerAdapters;
    	
    	@Override
    	protected void onRefresh(ApplicationContext context) {
        
    		initStrategies(context);
    	}
    
    	/**
    	 * Initialize the strategy objects that this servlet uses.
    	 * <p>May be overridden in subclasses in order to initialize further strategy objects.
    	 */
    	protected void initStrategies(ApplicationContext context) {
        
    		initMultipartResolver(context);
    		initLocaleResolver(context);
    		initThemeResolver(context);
    		initHandlerMappings(context);
    		initHandlerAdapters(context);
    		initHandlerExceptionResolvers(context);
    		initRequestToViewNameTranslator(context);
    		initViewResolvers(context);
    		initFlashMapManager(context);
    	}

这样我们得到了一个ModelAndView对象，我们进入handle方法，看一下里边做了什么。

// AbstractHandlerMethodAdapter.calss
    public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
    			throws Exception {
        
    
    		return handleInternal(request, response, (HandlerMethod) handler);
    	}
    
    protected ModelAndView handleInternal(HttpServletRequest request,
    			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
        
    	mav = invokeHandlerMethod(request, response, handlerMethod);
    }
    
    protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
    			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
        
    	// 1、执行具体handler方法（此时会进入到具体的controller中）
    	invocableMethod.invokeAndHandle(webRequest, mavContainer);
    	// 2、返回了ModelAndView对象
    	return getModelAndView(mavContainer, modelFactory, webRequest);
    	finally {
        
    			// 3、设置请求处理完成
    			webRequest.requestCompleted();
    		}
    }

我们可以发现，在invokeHandlerMethod的方法中，有2个主要的方法，  
1、执行具体handler方法（此时会进入到具体的controller中）  
2、返回了ModelAndView对象  
3、设置请求处理完成

我们进入invokeAndHandle方法，看一下具体是怎么执行的。  
1、通过反射调用具体的方法，得到返回值（此时会进入到具体的controller中）  
2、根据返回值，选择对应的转换器，write写入到输出消息中（会进入到writeWithMessageConverters方法中）

// ServletInvocableHandlerMethod.class
    public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
    			Object... providedArgs) throws Exception {
        
    		//这里会通过反射调用具体的方法，得到返回值（此时会进入到具体的controller中）
    		Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
    		setResponseStatus(webRequest);
    
    		if (returnValue == null) {
        
    			if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
        
    				disableContentCachingIfNecessary(webRequest);
    				mavContainer.setRequestHandled(true);
    				return;
    			}
    		}
    		else if (StringUtils.hasText(getResponseStatusReason())) {
        
    			mavContainer.setRequestHandled(true);
    			return;
    		}
    
    		mavContainer.setRequestHandled(false);
    		Assert.state(this.returnValueHandlers != null, "No return value handlers");
    		try {
        
    			//根据返回值，选择对应的转换器，write写入到输出消息中（会进入到writeWithMessageConverters方法中）
    			this.returnValueHandlers.handleReturnValue(
    					returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
    		}
    		catch (Exception ex) {
        
    			if (logger.isTraceEnabled()) {
        
    				logger.trace(formatErrorForReturnValue(returnValue), ex);
    			}
    			throw ex;
    		}
    	}

我们看下writeWithMessageConverters方法，  
这个方法的主要作用是：将给定的返回类型写入给定的输出消息。

当MediaType是application/json，转换器会采用MappingJackson2HttpMessageConverter，会调用Jackson进行序列化这个对象，然后采用流的方式输出。

// AbstractMessageConverterMethodProcessor.class
    protected <T> void writeWithMessageConverters(@Nullable T value, MethodParameter returnType,
    			ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage)
    			throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
        
    	//.......
    	//返回值是字符串，就进行toString
    	if (value instanceof CharSequence) {
        
    			body = value.toString();
    			valueType = String.class;
    			targetType = String.class;
    		}
    		else {
        
    			body = value;
    			valueType = getReturnValueType(body, returnType);
    			targetType = GenericTypeResolver.resolveType(getGenericType(returnType), returnType.getContainingClass());
    		}
    	
    	//.......
    	
    if (selectedMediaType != null) {
        
    			selectedMediaType = selectedMediaType.removeQualityValue();
    			// 遍历所有的转换器
    			// String类型的话，就使用StringHttpMessageConverter
    			for (HttpMessageConverter<?> converter : this.messageConverters) {
        
    				// 先进行canWrite的判断
    				GenericHttpMessageConverter genericConverter = (converter instanceof GenericHttpMessageConverter ?
    						(GenericHttpMessageConverter<?>) converter : null);
    				if (genericConverter != null ?
    						((GenericHttpMessageConverter) converter).canWrite(targetType, valueType, selectedMediaType) :
    						converter.canWrite(valueType, selectedMediaType)) {
        
    					body = getAdvice().beforeBodyWrite(body, returnType, selectedMediaType,
    							(Class<? extends HttpMessageConverter<?>>) converter.getClass(),
    							inputMessage, outputMessage);
    					if (body != null) {
        
    						Object theBody = body;
    						LogFormatUtils.traceDebug(logger, traceOn ->
    								"Writing [" + LogFormatUtils.formatValue(theBody, !traceOn) + "]");
    						addContentDispositionHeader(inputMessage, outputMessage);
    						if (genericConverter != null) {
        
    							genericConverter.write(body, targetType, selectedMediaType, outputMessage);
    						}
    						else {
        
    							// 写入输出消息
    							((HttpMessageConverter) converter).write(body, selectedMediaType, outputMessage);
    						}
    					}
    					else {
        
    						if (logger.isDebugEnabled()) {
        
    							logger.debug("Nothing to write: null body");
    						}
    					}
    					return;
    				}
    			}
    		}
    	//.......
    }

之后，我们看一下getModelAndView，是怎么返回ModelAndView的。  
根据ModelAndViewContainer 容器对象，new出来一个mav对象，进行返回。

// RequestMappingHandlerAdapter.class
    	@Nullable
    	private ModelAndView getModelAndView(ModelAndViewContainer mavContainer,
    			ModelFactory modelFactory, NativeWebRequest webRequest) throws Exception {
        
    
    		modelFactory.updateModel(webRequest, mavContainer);
    		// 请求是否在handler中得到完全处理
    		if (mavContainer.isRequestHandled()) {
        
    			return null;
    		}
    		ModelMap model = mavContainer.getModel();
    		ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, mavContainer.getStatus());
    		if (!mavContainer.isViewReference()) {
        
    			mav.setView((View) mavContainer.getView());
    		}
    		if (model instanceof RedirectAttributes) {
        
    			Map<String, ?> flashAttributes = ((RedirectAttributes) model).getFlashAttributes();
    			HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
    			if (request != null) {
        
    				RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
    			}
    		}
    		return mav;
    	}

我们看看它是怎么解析ModelAndView的，进入processDispatchResult方法。  
这里主要做了：  
1、有异常信息的话，处理mv的异常信息  
2、进行渲染视图的操作

//DispatcherServlet.class
    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方法，看一下是怎么进行渲染视图的。  
此方法的作用：  
1、渲染给定的ModelAndView。  
2、这是处理请求的最后阶段。这可能涉及到按名称解析视图。  
此方法做了两件事：  
1、 根据给定的视图名称解析为视图对象  
2、视图进行渲染，将页面变成输出流，进行输出

//DispatcherServlet.class
    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) {
        
    			// We need to resolve the view name.
    			// 根据给定的视图名称解析为视图对象
    			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;
    		}
    	}

进入resolveViewName方法，看下是怎么 将给定的视图名称解析为视图对象的。  
明显看到：遍历视图解析器viewResolvers ，解析器会根据视图名称得到视图对象。

//DispatcherServlet.class
    	@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;
    	}

有了视图对象之后，调用它的render方法，可以看到render方法的实现有好几个，我们随便进去两个看看，发现总体上就是将页面变成输出流，进行输出。  
![在这里插入图片描述][91fc7554641141d5b840d41a668a9b72.png]

//DefaultErrorViewResolver.class
    		@Override
    		public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response)
    				throws Exception {
        
    			response.setContentType(getContentType());
    			FileCopyUtils.copy(this.resource.getInputStream(), response.getOutputStream());
    		}

//ErrorMvcAutoConfiguration.class
    		@Override
    		public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response)
    				throws Exception {
        
    			if (response.isCommitted()) {
        
    				String message = getMessage(model);
    				logger.error(message);
    				return;
    			}
    			response.setContentType(TEXT_HTML_UTF8.toString());
    			StringBuilder builder = new StringBuilder();
    			Object timestamp = model.get("timestamp");
    			Object message = model.get("message");
    			Object trace = model.get("trace");
    			if (response.getContentType() == null) {
        
    				response.setContentType(getContentType());
    			}
    			builder.append("<html><body><h1>Whitelabel Error Page</h1>").append(
    					"<p>This application has no explicit mapping for /error, so you are seeing this as a fallback.</p>")
    					.append("<div id='created'>").append(timestamp).append("</div>")
    					.append("<div>There was an unexpected error (type=").append(htmlEscape(model.get("error")))
    					.append(", status=").append(htmlEscape(model.get("status"))).append(").</div>");
    			if (message != null) {
        
    				builder.append("<div>").append(htmlEscape(message)).append("</div>");
    			}
    			if (trace != null) {
        
    				builder.append("<div style='white-space:pre-wrap;'>").append(htmlEscape(trace)).append("</div>");
    			}
    			builder.append("</body></html>");
    			response.getWriter().append(builder.toString());
    		}

好了，分析结束了。  
有不对的地方还望多多指正！

## 总结 ##

这里贴上两个图吧

![在这里插入图片描述][19c44507cf8e497587d13c664e5f650c.png]  
![在这里插入图片描述][d28f91d771964b66a5f2e7feb60936bc.png]  
![在这里插入图片描述][fa5d98cf5c4041afa881cb7b52a51eb7.png]

参考：https://blog.csdn.net/qq\_28064009/article/details/117074402

[993808ca14724aec9442fd93bdc44b79.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/bb71fd951a294c0781cc8f1e3e1b9d40.png
[26aeb75c66334a45835c83ec62ed99e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/eba9cca02ffb4f658fa7ce314fee0003.png
[c0e89fbe4f2e4784917492d86a531ff6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/e50fd8f3617e48f3891244b3b8b35360.png
[c699755b75a6413a964ace44c9899163.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/7a80c24a7f944918998cae6c706dcc16.png
[232b4decfde24420a032dda1f2c5be53.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/ce88644b55264c88a3e14856acbb2f67.png
[91fc7554641141d5b840d41a668a9b72.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/616115ffd87244cbbf347a9c462fc7bc.png
[19c44507cf8e497587d13c664e5f650c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/01593c7dcc8e4698b3351633d9854959.png
[d28f91d771964b66a5f2e7feb60936bc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/899848de529540c0a71a2af6554d13a3.png
[fa5d98cf5c4041afa881cb7b52a51eb7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/6d3d826d810541af8a3cba93267e878d.png