SpringBoot请求返回值处理与内容协商——源码学习

最新推荐文章于 2022-11-01 21:02:36 发布
最新推荐文章于 2022-11-01 21:02:36 发布
阅读量411 收藏 2
点赞数
分类专栏： SpringBoot学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44347271/article/details/120844094
版权

该文SpringBoot版本：2.3.4
SpringBoot的web场景中，底层依然使用的是SpringMVC，框架会根据请求url找到它对应的handler，然后再找到该handler的handlerAdapter，handlerAdapter先回处理handler（controller.method()）的形参，然后执行该方法，并返回方法的返回值，对应源码ServletInvocableHandlerMethod.invokeAndHandle()中的第一行，但这个返回结果并不能直接返回，而是需要进行进一步的处理，

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 {
		//处理返回值，将结果保存在mavContainer中
			this.returnValueHandlers.handleReturnValue(
					returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
		}
		catch (Exception ex) {
			if (logger.isTraceEnabled()) {
				logger.trace(formatErrorForReturnValue(returnValue), ex);
			}
			throw ex;
		}
	}

该方法中关键的一步就是this.returnValueHandlers.handleReturnValue(returnValue, getReturnValueType(returnValue), mavContainer,，invokeAndHandle方法没有返回值，它最后将处理的返回值保存在传入方法的一个mavContainer对象中传递出去。

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

handleReturnValue方法也还是那个老套路，先遍历选择容器中现有的可以处理该返回值的处理器，然后再使用该返回值处理器处理。
在这里插入图片描述
内置的returnValueHandlers有14中，也表示了框架能够处理的14中返回值。
举例来说，被@RespondBody标注的方法的返回值则是被RequestResponseBodyMethodProcessor，我们可以从它的判断方法中得出。

@Override
	public boolean supportsReturnType(MethodParameter returnType) {
		return (AnnotatedElementUtils.hasAnnotation(returnType.getContainingClass(), ResponseBody.class) ||
				returnType.hasMethodAnnotation(ResponseBody.class));
	}

在获得需要的returnValueHandler后，则是开始真正的处理返回值，一路向下可以追踪到writeWithMessageConverters中，这也是内容协商的代码所在！

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();
		boolean isContentTypePreset = contentType != null && contentType.isConcrete();
		if (isContentTypePreset) {
			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);
			}
			//双重for循环来得到两边都支持的内容类型
			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);
			}
		}
		//下面则是使用MessageConverter具体的处理内容
		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) {
			Set<MediaType> producibleMediaTypes =
					(Set<MediaType>) inputMessage.getServletRequest()
							.getAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);

			if (isContentTypePreset || !CollectionUtils.isEmpty(producibleMediaTypes)) {
				throw new HttpMessageNotWritableException(
						"No converter for [" + valueType + "] with preset Content-Type '" + contentType + "'");
			}
			throw new HttpMediaTypeNotAcceptableException(this.allSupportedMediaTypes);
		}
	}

获取浏览器想要的返回值类型List<MediaType> acceptableTypes = getAcceptableMediaTypes(request);是由内容协商管理器执行的。

private List<MediaType> getAcceptableMediaTypes(HttpServletRequest request)
			throws HttpMediaTypeNotAcceptableException {

		return this.contentNegotiationManager.resolveMediaTypes(new ServletWebRequest(request));
	}

该方法遍历现有的内容协商策略，

@Override
	public List<MediaType> resolveMediaTypes(NativeWebRequest request) throws HttpMediaTypeNotAcceptableException {
		for (ContentNegotiationStrategy strategy : this.strategies) {
			List<MediaType> mediaTypes = strategy.resolveMediaTypes(request);
			if (mediaTypes.equals(MEDIA_TYPE_ALL_LIST)) {
				continue;
			}
			return mediaTypes;
		}
		return MEDIA_TYPE_ALL_LIST;
	}

默认的内容协商策略是在请求头中获取浏览器支持的数据类型，其实也就是request header中的accept字段的值。
在这里插入图片描述
我们可以利用在配置中设置

spring:
    contentnegotiation:
      favor-parameter: true  #开启请求参数内容协商模式

来开启浏览器请求内容协商功能，请求带上format=XX参数就可以参与内容协商

发请求： 
http://localhost:8080/test/person?format=json
http://localhost:8080/test/person?format=xml

对于服务器支持的内容类型，类似的，用List<MediaType> producibleTypes = getProducibleMediaTypes(request, valueType, targetType);获得服务器支持的内容类型，这又是咋操作的呢？

protected List<MediaType> getProducibleMediaTypes(
			HttpServletRequest request, Class<?> valueClass, @Nullable Type targetType) {

		Set<MediaType> mediaTypes =
				(Set<MediaType>) request.getAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);
		if (!CollectionUtils.isEmpty(mediaTypes)) {
			return new ArrayList<>(mediaTypes);
		}
		else if (!this.allSupportedMediaTypes.isEmpty()) {
			List<MediaType> result = new ArrayList<>();
			//遍历所有的MessageConverter，将他们可以处理的内容类型都找到
			for (HttpMessageConverter<?> converter : this.messageConverters) {
				if (converter instanceof GenericHttpMessageConverter && targetType != null) {
					if (((GenericHttpMessageConverter<?>) converter).canWrite(targetType, valueClass, null)) {
					//可以处理的内容类型汇总
						result.addAll(converter.getSupportedMediaTypes());
					}
				}
				else if (converter.canWrite(valueClass, null)) {
					result.addAll(converter.getSupportedMediaTypes());
				}
			}
			return result;
		}
		else {
			return Collections.singletonList(MediaType.ALL);
		}
	}

在这里插入图片描述
MessageConverter也反应了服务器能处理的返回值类型有哪些。
MappingJackson2HttpMessageConverter 是我们常用的，它把对象转为JSON（利用底层的jackson的objectMapper转换的）。
当然，这里的MessageConverter也可以来自定义，这样就可以返回满足我们业务需求定制的数据协议的数据。
SpringBoot预留的接口。

 @Bean
    public WebMvcConfigurer webMvcConfigurer(){
        return new WebMvcConfigurer() {

            @Override
            public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {

            }
        }
    }

实现HttpMessageConverter接口，然后在WebMVC中配置。
以上处理请求返回值的过程可以总结一下：

1.返回值处理器判断是否支持这种类型返回值 supportsReturnType
2. 返回值处理器调用handleReturnValue 进行处理
3. RequestResponseBodyMethodProcessor 可以处理返回值标了@ResponseBody 注解的。
利用 MessageConverters 进行处理将数据写为json
■ 3.1、内容协商（浏览器默认会以请求头的方式告诉服务器他能接受什么样的内容类型）
■ 3.2、服务器最终根据自己自身的能力，决定服务器能生产出什么样内容类型的数据，
■ 3.3、SpringMVC会挨个遍历所有容器底层的 HttpMessageConverter ，看谁能处理？
● 3.3.1、得到MappingJackson2HttpMessageConverter可以将对象写为json
● 3.3.2、利用MappingJackson2HttpMessageConverter将对象转为json再写出去。

现在，我们可以以自定义的方式让浏览器告诉服务器支持什么样的内容（ContentNegotiationStrategy接口），也可以定制我们自己的数据协议，让服务器返回（HttpMessageConverter接口）

天师吴彦祖
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
包装SpringBoot Controller返回值
01-08
包装SpringBoot Controller返回值示例代码。 建议用idea导入。
spring boot内容协商（源码向）
qq_39344641的博客
03-30 190
前言 内容协商是发送请求（前端）和服务器（后端）之间确定数据以何种方式传输的。比如后台有一个User类型的数据需要响应到浏览器，那么浏览器显示的是什么格式的数据就是内容协商决定的。 spring boot版本2.4.3 1. 创建一个controller，写一个响应数据的请求 2. 浏览器访问 默认返回json数据 3. 源码分析 为了看效果，我们在配置文件中添加 spring.mvc.contentnegotiation.favor-parameter=true 开启后，就能在浏览器中指定参数了，默
SpringBoot中的内容协商器图解
08-28
本文通过图文解说加代码的形式给大家介绍了SpringBoot中的内容协商器知识，需要的朋友参考下吧
springboot2——6 响应处理
yangpei的博客
09-20 355
尚硅谷springboot2响应处理学习记录
springBoot多种请求参数解析器参数和返回值处理器
qq_36709608的博客
03-16 392
请求中： HandlerMapping中找到能处理请求的Handler（Controller层的方法） 为当前Handler 找一个适配器 HandlerAdapter； 使用的RequestMappingHandlerAdapter 适配器执行目标方法并确定方法参数的每一个值 参数解析器：（类似使用注解@PathVariable） RequestParamMethodArgumentResolver(getBeanFactory(), false) Request...
Springboot请求处理源码分析（含源代码详细注释）
04-19
SpringBoot是一个基于Spring框架的高度模块化和...以上就是SpringBoot请求处理的源码分析，涉及的主要组件和它们的角色。理解这些组件的工作原理有助于开发者深入理解SpringBoot的请求处理流程，提高开发和调试的效率。
[springboot源码探索]返回值处理.md
最新发布
04-28
[springboot源码探索]返回值处理
ajax请求后台接口数据与返回值处理js的实例讲解
01-19
type: post, //请求方式是post data:{type:1, //这是你要传给后台的data值 t:c4552111 }, dataType: json, //数据类型是json型 success: function (data) { //成功时返回的data值，注意这个data是后台返回的值...
springboot中用fastjson处理返回值为null的属性值
10-15
本文将详细讲解如何在Spring Boot中使用Fastjson来处理返回值为`null`的属性值。 首先，我们需要配置FastjsonHttpMessageConverter，这是Spring MVC用来将Java对象转换成JSON格式并发送给客户端的组件。在`...
Spring Boot 学习笔记：请求参数解析与返回数据处理
崔显龙的博客
11-24 1714
在刚刚使用 Spring 的时候，经常会有些疑问：（1）Spring 是如何帮我们把请求数据自动解析绑定到 Controller 方法入参？（2）Spring 是如何将 Controller 返回结果处理成 Response 返回给调用方的？（3）@RequestBody、@ResponseBody是干什么用的？（4）HttpMessageConverter、Converter有什么关系和区别？
【springboot】HTTPMessageConvertor源码分析原理
m0_56249083的博客
11-01 604
承接上一篇文章，还是按照之前的顺序来debug，先进入invokeAndHandle执行方法，可以看到this.returnValueHandlers是所有可以匹配的返回值处理器，通过supportsReturnType方法判断是否支持该类型的返回值后匹配到了目标的ReturnValueHandler，就可以执行它的handleReturnValue方法，也就是上篇文章中文末提到的处理返回值的方法handleReturnValue()，进入最内层的handleReturnValue方法。
HTTP断点续传（分块传输）
weixin_33832340的博客
11-21 4544
简述 断点续传：指的是在上传/下载时，将任务（一个文件或压缩包）人为的划分为几个部分，每一个部分采用一个线程进行上传/下载，如果碰到网络故障，可以从已经上传/下载的部分开始继续上传/下载未完成的部分，而没有必要从头开始上传/下载。可以节省时间，提高速度。 简述 断点续传的用途 Range Content-Range 增强...
【SpringMVC（十五）】HttpRange 分片下载 断点续传
u010900754的专栏
04-05 2681
基于http协议实现断点续传。 请求部分，需要在请求头里加入Range头，表示本次请求的byte数组的开始和结束位置。 https://tools.ietf.org/html/rfc7233#section-3.1 格式为：Bytes=开始-结束。如果不填表示0或者最后。 对于要支持断点续传的服务器，需要处理这个请求头，如果发现有Range头部，需要对响应特殊处理。 body：返回Ran...
http断点续传原理：http头 Range、Content-Range
lianghongge的专栏
02-10 2841
转自：http://www.liqwei.com/network/protocol/2011/886.shtml http断点续传原理：http头 Range、Content-Range 所谓断点续传，也就是要从文件已经下载的地方开始继续下载。在以前版本的 HTTP 协议是不支持断点的，HTTP/1.1 开始就支持了。一般断点下载时才用到 Range 和 Con
【十一】springboot整合异步调用并获取返回值
weixin_56995925的博客
09-18 9438
springboot整合异步调用并获取返回值
springboot 记录http请求和返回信息
qq_28017061的博客
08-29 1340
首先导入pom包： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </de...
Springboot-内容协商
qq_42250642的博客
04-23 876
Springboot-内容协商 内容协商 根据客户端接收能力不同，返回不同媒体类型的数据。 1、引入xml依赖 <dependency> <groupId>com.fasterxml.jackson.dataformat</groupId> <artifactId>jackson-dataformat-xml</artifactId> </dependency> 2、postman分别测试返回json和xml 只需要
springboot入门之controller的两种返回值（返回页面，返回数据）
热门推荐
1号帅比的博客
10-08 3万+
在web项目中，controller的返回值一般有两种，一种是返回对应的页面（例如html页面，jsp页面），一种是返回数据（例如json格式的数据）。 1.使用@Controller注解，返回对应的页面 @Controller public class UserController { @Resource private IUserService userService;...
springboot统一返回值
10-17
在Spring Boot中，可以通过自定义一个统一的返回值对象来实现统一返回值。具体实现方式如下： 1. 定义一个统一的返回值对象，例如： ```java public class Result<T> { private int code; private String ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值