springBoot框架ApplicationFilterChain类中进入业务方法

水深无声 2022-09-04 02:46 87阅读 0赞

我们从tomcat 的 过滤器链类开始

1、ApplicationFilterChain

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70][]

2、点击  servlet.service(request, response);进入 HttpServlet类

public abstract class HttpServlet extends GenericServlet

@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);//继续点击
        }
    }

3、进入 FrameworkServlet，

public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware

@Override
    	protected void service(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    
    		HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
    		if (httpMethod == HttpMethod.PATCH || httpMethod == null) {
    			processRequest(request, response);//进入
    		}
    		else {
    			super.service(request, response);//进入
    		}
    	}

4、再次进入HttpServlet，

public abstract class HttpServlet extends GenericServlet

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);
            }
        }

5、点击 doPost 方法，再次进入FrameworkServlet

public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware

@Override
    	protected final void doPost(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    
    		processRequest(request, response);//点击进入
    	}

进入

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);
    		}
    	}

6、来到DispatcherServlet类，即子类实现

public class DispatcherServlet extends FrameworkServlet

@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.
    		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);
    		}
    
    		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);
    				}
    			}
    		}
    	}

点击  doDispatch(request, response);

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.
    				mappedHandler = getHandler(processedRequest);
    				if (mappedHandler == null) {
    					noHandlerFound(processedRequest, response);
    					return;
    				}
    
    				// Determine handler adapter for the current request.
    				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
    
    				// Process last-modified header, if supported by the handler.
    				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.
    				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());//点击进入
    
    				if (asyncManager.isConcurrentHandlingStarted()) {
    					return;
    				}
    
    				applyDefaultViewName(processedRequest, mv);
    				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);
    			}
    			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);
    				}
    			}
    		}
    	}

7、来到 AbstractHandlerMethodAdapter类

public abstract class AbstractHandlerMethodAdapter extends WebContentGenerator implements HandlerAdapter, Ordered

@Override
    	@Nullable
    	public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
    			throws Exception {
    
    		return handleInternal(request, response, (HandlerMethod) handler);//点击进入
    	}

8、来到

public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
          implements BeanFactoryAware, InitializingBean

@Override
    	protected ModelAndView handleInternal(HttpServletRequest request,
    			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
    
    		ModelAndView mav;
    		checkRequest(request);
    
    		// Execute invokeHandlerMethod in synchronized block if required.
    		if (this.synchronizeOnSession) {
    			HttpSession session = request.getSession(false);
    			if (session != null) {
    				Object mutex = WebUtils.getSessionMutex(session);
    				synchronized (mutex) {
    					mav = invokeHandlerMethod(request, response, handlerMethod);
    				}
    			}
    			else {
    				// No HttpSession available -> no mutex necessary
    				mav = invokeHandlerMethod(request, response, handlerMethod);
    			}
    		}
    		else {
    			// No synchronization on session demanded at all...
    			mav = invokeHandlerMethod(request, response, handlerMethod);//点击进入
    		}
    
    		if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
    			if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
    				applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
    			}
    			else {
    				prepareResponse(response);
    			}
    		}
    
    		return mav;
    	}

来到

@Nullable
    	protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
    			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
    
    		ServletWebRequest webRequest = new ServletWebRequest(request, response);
    		try {
    			WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
    			ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
    
    			ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
    			if (this.argumentResolvers != null) {
    				invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
    			}
    			if (this.returnValueHandlers != null) {
    				invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
    			}
    			invocableMethod.setDataBinderFactory(binderFactory);
    			invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
    
    			ModelAndViewContainer mavContainer = new ModelAndViewContainer();
    			mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
    			modelFactory.initModel(webRequest, mavContainer, invocableMethod);
    			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();
    				LogFormatUtils.traceDebug(logger, traceOn -> {
    					String formatted = LogFormatUtils.formatValue(result, !traceOn);
    					return "Resume with async result [" + formatted + "]";
    				});
    				invocableMethod = invocableMethod.wrapConcurrentResult(result);
    			}
    
    			invocableMethod.invokeAndHandle(webRequest, mavContainer);//点击进入
    			if (asyncManager.isConcurrentHandlingStarted()) {
    				return null;
    			}
    
    			return getModelAndView(mavContainer, modelFactory, webRequest);//核心代码
    		}
    		finally {
    			webRequest.requestCompleted();
    		}
    	}

9、点击

invocableMethod.invokeAndHandle(webRequest, mavContainer);来到

public class ServletInvocableHandlerMethod extends InvocableHandlerMethod

public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
    			Object... providedArgs) throws Exception {
    
    		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 {
    			this.returnValueHandlers.handleReturnValue(
    					returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
    		}
    		catch (Exception ex) {
    			if (logger.isTraceEnabled()) {
    				logger.trace(formatErrorForReturnValue(returnValue), ex);
    			}
    			throw ex;
    		}
    	}

10、点击

Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);

来到

public class InvocableHandlerMethod extends HandlerMethod

@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);//点击进入
    	}

来到

@Nullable
    	protected Object doInvoke(Object... args) throws Exception {
    		ReflectionUtils.makeAccessible(getBridgedMethod());
    		try {
    			return getBridgedMethod().invoke(getBean(), args);//点击进入
    		}
    		catch (IllegalArgumentException ex) {
    			assertTargetBean(getBridgedMethod(), getBean(), args);
    			String text = (ex.getMessage() != null ? ex.getMessage() : "Illegal argument");
    			throw new IllegalStateException(formatInvokeError(text, args), ex);
    		}
    		catch (InvocationTargetException ex) {
    			// Unwrap for HandlerExceptionResolvers ...
    			Throwable targetException = ex.getTargetException();
    			if (targetException instanceof RuntimeException) {
    				throw (RuntimeException) targetException;
    			}
    			else if (targetException instanceof Error) {
    				throw (Error) targetException;
    			}
    			else if (targetException instanceof Exception) {
    				throw (Exception) targetException;
    			}
    			else {
    				throw new IllegalStateException(formatInvokeError("Invocation failure", args), targetException);
    			}
    		}
    	}

11、点击

getBridgedMethod().invoke(getBean(), args);来到

public final class Method extends Executable

@CallerSensitive
        public Object invoke(Object obj, Object... args)
            throws IllegalAccessException, IllegalArgumentException,
               InvocationTargetException
        {
            if (!override) {
                if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                    Class<?> caller = Reflection.getCallerClass();
                    checkAccess(caller, clazz, obj, modifiers);
                }
            }
            MethodAccessor ma = methodAccessor;             // read volatile
            if (ma == null) {
                ma = acquireMethodAccessor();
            }
            return ma.invoke(obj, args);//点击
        }

12、来到

class DelegatingMethodAccessorImpl extends MethodAccessorImpl

public Object invoke(Object var1, Object[] var2) throws IllegalArgumentException, InvocationTargetException {
            return this.delegate.invoke(var1, var2);//点击进入
        }

13、来到Native类

class NativeMethodAccessorImpl extends MethodAccessorImpl

public Object invoke(Object var1, Object[] var2) throws IllegalArgumentException, InvocationTargetException {
            if (++this.numInvocations > ReflectionFactory.inflationThreshold() && !ReflectUtil.isVMAnonymousClass(this.method.getDeclaringClass())) {
                MethodAccessorImpl var3 = (MethodAccessorImpl)(new MethodAccessorGenerator()).generateMethod(this.method.getDeclaringClass(), this.method.getName(), this.method.getParameterTypes(), this.method.getReturnType(), this.method.getExceptionTypes(), this.method.getModifiers());
                this.parent.setDelegate(var3);
            }
    
            return invoke0(this.method, var1, var2);//请求后端服务的方法名和类名
        }

此处到了能够断点的最底层，然后就会进入后台接口。执行完后台接口，会返回相应的结果。

14、返回到

public class ServletInvocableHandlerMethod extends InvocableHandlerMethod

public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
    			Object... providedArgs) throws Exception {
    
    		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 {
    			this.returnValueHandlers.handleReturnValue(
    					returnValue, getReturnValueType(returnValue), mavContainer, webRequest);//核心返回代码，点击
    		}
    		catch (Exception ex) {
    			if (logger.isTraceEnabled()) {
    				logger.trace(formatErrorForReturnValue(returnValue), ex);
    			}
    			throw ex;
    		}
    	}

15、点击进入

public class HandlerMethodReturnValueHandlerComposite implements HandlerMethodReturnValueHandler

@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);//点击进入
    	}

16、点击进入

public class RequestResponseBodyMethodProcessor extends AbstractMessageConverterMethodProcessor

@Override
    	public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
    			ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
    			throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
    
    		mavContainer.setRequestHandled(true);
    		ServletServerHttpRequest inputMessage = createInputMessage(webRequest);
    		ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);
    
    		// Try even with null return value. ResponseBodyAdvice could get involved.
    		writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);
    	}

17、进入

public abstract class AbstractMessageConverterMethodProcessor extends AbstractMessageConverterMethodArgumentResolver
          implements HandlerMethodReturnValueHandler

protected <T> void writeWithMessageConverters(@Nullable T value, MethodParameter returnType,
    			ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage)
    			throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
    
    		Object body;
    		Class<?> valueType;
    		Type targetType;
    
    		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 (isResourceType(value, returnType)) {
    			outputMessage.getHeaders().set(HttpHeaders.ACCEPT_RANGES, "bytes");
    			if (value != null && inputMessage.getHeaders().getFirst(HttpHeaders.RANGE) != null &&
    					outputMessage.getServletResponse().getStatus() == 200) {
    				Resource resource = (Resource) value;
    				try {
    					List<HttpRange> httpRanges = inputMessage.getHeaders().getRange();
    					outputMessage.getServletResponse().setStatus(HttpStatus.PARTIAL_CONTENT.value());
    					body = HttpRange.toResourceRegions(httpRanges, resource);
    					valueType = body.getClass();
    					targetType = RESOURCE_REGION_LIST_TYPE;
    				}
    				catch (IllegalArgumentException ex) {
    					outputMessage.getHeaders().set(HttpHeaders.CONTENT_RANGE, "bytes */" + resource.contentLength());
    					outputMessage.getServletResponse().setStatus(HttpStatus.REQUESTED_RANGE_NOT_SATISFIABLE.value());
    				}
    			}
    		}
    
    		MediaType selectedMediaType = null;
    		MediaType contentType = outputMessage.getHeaders().getContentType();
    		if (contentType != null && contentType.isConcrete()) {
    			if (logger.isDebugEnabled()) {
    				logger.debug("Found 'Content-Type:" + contentType + "' in response");
    			}
    			selectedMediaType = contentType;
    		}
    		else {
    			HttpServletRequest request = inputMessage.getServletRequest();
    			List<MediaType> acceptableTypes = getAcceptableMediaTypes(request);
    			List<MediaType> producibleTypes = getProducibleMediaTypes(request, valueType, targetType);
    
    			if (body != null && producibleTypes.isEmpty()) {
    				throw new HttpMessageNotWritableException(
    						"No converter found for return value of type: " + valueType);
    			}
    			List<MediaType> mediaTypesToUse = new ArrayList<>();
    			for (MediaType requestedType : acceptableTypes) {
    				for (MediaType producibleType : producibleTypes) {
    					if (requestedType.isCompatibleWith(producibleType)) {
    						mediaTypesToUse.add(getMostSpecificMediaType(requestedType, producibleType));
    					}
    				}
    			}
    			if (mediaTypesToUse.isEmpty()) {
    				if (body != null) {
    					throw new HttpMediaTypeNotAcceptableException(producibleTypes);
    				}
    				if (logger.isDebugEnabled()) {
    					logger.debug("No match for " + acceptableTypes + ", supported: " + producibleTypes);
    				}
    				return;
    			}
    
    			MediaType.sortBySpecificityAndQuality(mediaTypesToUse);
    
    			for (MediaType mediaType : mediaTypesToUse) {
    				if (mediaType.isConcrete()) {
    					selectedMediaType = mediaType;
    					break;
    				}
    				else if (mediaType.isPresentIn(ALL_APPLICATION_MEDIA_TYPES)) {
    					selectedMediaType = MediaType.APPLICATION_OCTET_STREAM;
    					break;
    				}
    			}
    
    			if (logger.isDebugEnabled()) {
    				logger.debug("Using '" + selectedMediaType + "', given " +
    						acceptableTypes + " and supported " + producibleTypes);
    			}
    		}
    
    		if (selectedMediaType != null) {
    			selectedMediaType = selectedMediaType.removeQualityValue();
    			for (HttpMessageConverter<?> converter : this.messageConverters) {
    				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;
    				}
    			}
    		}
    
    		if (body != null) {
    			throw new HttpMediaTypeNotAcceptableException(this.allSupportedMediaTypes);
    		}
    	}

18、点击 genericConverter.write(body, targetType, selectedMediaType, outputMessage);

来到：

public class FastJsonHttpMessageConverter extends AbstractHttpMessageConverter<Object>//
            implements GenericHttpMessageConverter<Object>

public void write(Object o, Type type, MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
            super.write(o, contentType, outputMessage);// support StreamingHttpOutputMessage in spring4.0+
            //writeInternal(o, outputMessage);
        }

19、点击来到

public class FastJsonHttpMessageConverter extends AbstractHttpMessageConverter<Object>//
            implements GenericHttpMessageConverter<Object>

@Override
    	public final void write(final T t, @Nullable MediaType contentType, HttpOutputMessage outputMessage)
    			throws IOException, HttpMessageNotWritableException {
    
    		final HttpHeaders headers = outputMessage.getHeaders();
    		addDefaultHeaders(headers, t, contentType);
    
    		if (outputMessage instanceof StreamingHttpOutputMessage) {
    			StreamingHttpOutputMessage streamingOutputMessage = (StreamingHttpOutputMessage) outputMessage;
    			streamingOutputMessage.setBody(outputStream -> writeInternal(t, new HttpOutputMessage() {
    				@Override
    				public OutputStream getBody() {
    					return outputStream;
    				}
    				@Override
    				public HttpHeaders getHeaders() {
    					return headers;
    				}
    			}));
    		}
    		else {
    			writeInternal(t, outputMessage);
    			outputMessage.getBody().flush();//直接把返回值刷到客户端
    		}
    	}

到此，整个请求流程基本结束了。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70]: /images/20220829/464a0043e86b4824b2bd2bf6deb7cc00.png