org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod#invokeAndHandle(webRequest,mavContainer,Object... providedArgs){ // 执行目标方法,详见执行目标方法InvocableHandlerMethod#invokeForRequest原理(最终参数解析,执行目标方法) Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs); // 设置响应状态 setResponseStatus(webRequest);{ // 设置状态码 HttpStatus status = getResponseStatus(); if (status == null) { return; } // 设置响应头信息 HttpServletResponse response = webRequest.getResponse(); if (response != null) { String reason = getResponseStatusReason(); // 有错误信息,设置错误信息和状态码 if (StringUtils.hasText(reason)) { response.sendError(status.value(), reason); } // 没有错误信息,设置状态码 else { response.setStatus(status.value()); } } // 保存请求状态,被RedirectView用到 webRequest.getRequest().setAttribute(View.RESPONSE_STATUS_ATTRIBUTE, status); } // 执行目标方法返回结果不为null 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);{ // 获取返回值处理器 HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);{ // 是否是异步的返回结果 boolean isAsyncValue = isAsyncReturnValue(value, returnType);{ // 遍历所有的返回值处理器 for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) { // 如果是AsyncHandlerMethodReturnValueHandler这个类型并且isAsyncReturnValue返回true,就符合条件 // 表示可以处理这个异步结果的handler if (handler instanceof AsyncHandlerMethodReturnValueHandler && ((AsyncHandlerMethodReturnValueHandler) handler).isAsyncReturnValue(value, returnType)) { return true; } } return false; } // 遍历所有的返回值处理器 for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) { // 有两种情况,异步AsyncHandlerMethodReturnValueHandler处理isAsyncValue异步的结果 // 普通HandlerMethodReturnValueHandler处理普通结果 // 这样做就是避免没必要的判断,例如普通HandlerMethodReturnValueHandler去执行supportsReturnType为异步结果的逻辑,肯定是不符合条件的 // AsyncHandlerMethodReturnValueHandler去执行普通返回结果的supportsReturnType,没有不要 if (isAsyncValue && !(handler instanceof AsyncHandlerMethodReturnValueHandler)) { continue; } // 执行当前Handler是否可以处理这个返回值 if (handler.supportsReturnType(returnType){ return ModelAndView.class.isAssignableFrom(returnType.getParameterType()); // 类中或者方法中是否有@ResponseBody注解 return (AnnotatedElementUtils.hasAnnotation(returnType.getContainingClass(), ResponseBody.class) || returnType.hasMethodAnnotation(ResponseBody.class)); }) { return handler; } } return null; } // 到了这里如果没有找到合适的Handler,表示当前返回值无法进行处理,直接报错 if (handler == null) { throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName()); } // 找到了Handler,使用handler处理返回值 这个只讲处理@ResponseBody的处理器RequestResponseBodyMethodProcessor handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);{ // 请求处理完成 mavContainer.setRequestHandled(true); // 创建InputMessage,可以获取Body为InputStream ServletServerHttpRequest inputMessage = createInputMessage(webRequest);{ HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class); return new ServletServerHttpRequest(servletRequest); } // 创建输出的对象,也是可以获取Body为OutputStream ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);{ HttpServletResponse response = webRequest.getNativeResponse(HttpServletResponse.class); return new ServletServerHttpResponse(response); } // 使用消息转换器,写入OutputStream(ServletServerHttpRequest) writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);{ // 实现了RequestResponseBodyAdvice的执行链,在创建当前参数解析器的时候就已经将 // 在RequestMappingHandlerAdapter初始化的时候,给参数解析器设置的 // this.requestResponseBodyAdvice就是在RequestMappingHandlerAdapter初始化的时候,执行initControllerAdviceCache();方法 // 从@ControllerAdvice中,实现了requestResponseBodyAdvice的类缓存下来了 // resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice)); RequestResponseBodyAdviceChain advice = this.advice; // 找到对应的媒体类型,使用消息转换器写消息 // 遍历所有的消息转换器 for (HttpMessageConverter<?> converter : this.messageConverters) { // 判断转换器是否是GenericHttpMessageConverter这种类型 GenericHttpMessageConverter genericConverter = (converter instanceof GenericHttpMessageConverter ? (GenericHttpMessageConverter<?>) converter : null); // 判断这个GenericHttpMessageConverter是否可以写入这条消息 if (genericConverter != null ? ((GenericHttpMessageConverter) converter).canWrite(targetType, valueType, selectedMediaType){ // 判断当前媒体类型是否支持 if (!canWrite(mediaType)) { return false; } // 找到对应的ObjectMapper进行序列化 ObjectMapper objectMapper = selectObjectMapper(clazz, mediaType); if (objectMapper == null) { return false; } // 判断ObjectMapper是否可以对当前类型进行序列化 AtomicReference<Throwable> causeRef = new AtomicReference<>(); if (objectMapper.canSerialize(clazz, causeRef)) { return true; } return false; } : converter.canWrite(valueType, selectedMediaType)) { // 调用过ResponseBodyAdvice的beforeBodyWrite方法 // 在写入响应体之前最后对响应值做处理 body = advice.beforeBodyWrite(body, returnType, selectedMediaType,(Class<? extends HttpMessageConverter<?>>) converter.getClass(),inputMessage, outputMessage);{ return processBody(body, returnType, contentType, converterType, request, response);{ // 找到符合条件的ResponseBodyAdvice类 for (ResponseBodyAdvice<?> advice : getMatchingAdvice(returnType, ResponseBodyAdvice.class)) { // 判断ResponseBodyAdvice是否支持处理当前这个返回值 if (advice.supports(returnType, converterType)) { // 如果可以处理,就将处理后的结果进行返回 // 我们可以在这个对结果进行统一格式化处理 body = ((ResponseBodyAdvice<T>) advice).beforeBodyWrite((T) body, returnType,contentType, converterType, request, response); } } } } if (body != null) { Object theBody = body; // 添加响应头要暴露的信息 addContentDispositionHeader(inputMessage, outputMessage); // 真正写入OutputStream,根据不同类型调用不同类型的write方法 if (genericConverter != null) { genericConverter.write(body, targetType, selectedMediaType, outputMessage);{ // 添加响应头 final HttpHeaders headers = outputMessage.getHeaders(); addDefaultHeaders(headers, t, contentType); // 判断响应的结果是不是就是OutputStream信息,如果是,直接返回数据流信息 if (outputMessage instanceof StreamingHttpOutputMessage) { StreamingHttpOutputMessage streamingOutputMessage = (StreamingHttpOutputMessage) outputMessage; streamingOutputMessage.setBody(outputStream -> writeInternal(t, type, new HttpOutputMessage() { @Override public OutputStream getBody() { return outputStream; } @Override public HttpHeaders getHeaders() { return headers; } })); }else{ // 不是响应Stream信息,写入消息 writeInternal(t, type, outputMessage);{ // 获取媒体类型,json编码,响应对象类型 MediaType contentType = outputMessage.getHeaders().getContentType(); JsonEncoding encoding = getJsonEncoding(contentType); Class<?> clazz = (object instanceof MappingJacksonValue ?((MappingJacksonValue) object).getValue().getClass() : object.getClass()); // 获取ObjectMapper,写入数据 ObjectMapper objectMapper = selectObjectMapper(clazz, contentType); ObjectWriter objectWriter = (serializationView != null ? objectMapper.writerWithView(serializationView) : objectMapper.writer()); objectWriter.writeValue(generator, value); writeSuffix(generator, object); generator.flush(); } // 刷新OutputStream outputMessage.getBody().flush(); } } } else { ((HttpMessageConverter) converter).write(body, selectedMediaType, outputMessage); } } return; } } } } } } catch (Exception ex) { throw ex; } }