Spring MVC 消息转换器

最新推荐文章于 2024-07-10 10:16:44 发布
最新推荐文章于 2024-07-10 10:16:44 发布
阅读量502 收藏 1
点赞数 1
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wq5350/article/details/107304291
版权

文章目录

组件

HttpMessageConverter

处理HTTP请求和响应的转换器。

public interface HttpMessageConverter<T> {
	// 对于该Media类型是否可读
	boolean canRead(Class<?> clazz, @Nullable MediaType mediaType);
	boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType);
	
	// 获得当前消息转换器支持的类型
	List<MediaType> getSupportedMediaTypes();
	// 读写转换，将request或response中的参数转换为对应类型
	T read(Class<? extends T> clazz, HttpInputMessage inputMessage)
			throws IOException, HttpMessageNotReadableException;

	void write(T t, @Nullable MediaType contentType, HttpOutputMessage outputMessage)
			throws IOException, HttpMessageNotWritableException;
}

AbstractHttpMessageConverter

HttpMessageConverter接口的基础实现

public abstract class AbstractHttpMessageConverter<T> implements HttpMessageConverter<T> {
	// 消息转换器支持的Content-Type
	private List<MediaType> supportedMediaTypes = Collections.emptyList();	
	// 默认编码
	private Charset defaultCharset;	
	public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType) {
		// 是否支持类型和content-type
		return supports(clazz) && canRead(mediaType);
	}
	// 开始read时转换
	public final T read(Class<? extends T> clazz, HttpInputMessage inputMessage)
			throws IOException, HttpMessageNotReadableException {
 
		return readInternal(clazz, inputMessage);
	}
}

MediaType

添加了对HTTP规范中定义的content-type的支持。

public class MediaType extends MimeType implements Serializable {
	public static final String ALL_VALUE = "*/*";
	public static final String APPLICATION_JSON_VALUE = "application/json";
}

RequestResponseBodyMethodProcessor

处理@RequestBody和@ResponseBody注解的参数转换和返回值转换器，根据MediaType来选择消息转换器处理。

// 支持方法POST PUT PATCH
public class RequestResponseBodyMethodProcessor extends AbstractMessageConverterMethodProcessor {
	// 持有的消息转换器
	protected final List<HttpMessageConverter<?>> messageConverters;
	// 支持的媒体类型
	protected final List<MediaType> allSupportedMediaTypes;
	// 事件通知
	private final RequestResponseBodyAdviceChain advice;
}

源码分析

以RequestResponseBodyMethodProcessor为例，分析参数解析和返回值解析过程

参数解析

  1. 调用resolveArgument方法，通过消息转换器来解析request中的参数，返回解析后的参数值，如果有校验也在这进行。
public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

	parameter = parameter.nestedIfOptional();
	// 通过消息转换器将request中数据转换为所需的java类型
	Object arg = readWithMessageConverters(webRequest, parameter, parameter.getNestedGenericParameterType());
	// 解析参数名
	String name = Conventions.getVariableNameForParameter(parameter);
	// 参数值校验
	if (binderFactory != null) {
		WebDataBinder binder = binderFactory.createBinder(webRequest, arg, name);
		if (arg != null) {
			validateIfApplicable(binder, parameter);
			if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
				throw new MethodArgumentNotValidException(parameter, binder.getBindingResult());
			}
		}
		// 将校验结果放入model中
		if (mavContainer != null) {
			mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
		}
	}
	// 返回适配Optional后的参数值
	return adaptArgumentIfNecessary(arg, parameter);
}
  1. 将request请求装配为ServletServerHttpRequest，调用readWithMessageConverters方法解析参数。
protected <T> Object readWithMessageConverters(NativeWebRequest webRequest, MethodParameter parameter,
			Type paramType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {
	// 获得httpRequest请求
	HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
	// 将Request请求装配为ServletServerHttpRequest
	ServletServerHttpRequest inputMessage = new ServletServerHttpRequest(servletRequest);
	// 真正解析方法
	Object arg = readWithMessageConverters(inputMessage, parameter, paramType);
	// 如果参数为null且必要则抛异常
	if (arg == null && checkRequired(parameter)) {
		throw new HttpMessageNotReadableException("Required request body is missing: " +
				parameter.getExecutable().toGenericString(), inputMessage);
	}
	return arg;
}
  1. 将请求体内容转换为java类型，首先获得请求的content-type(默认使用application/octet-stream)，遍历消息转换器找到支持当前content-type和参数类型的消息转换器来解析请求体
protected <T> Object readWithMessageConverters(HttpInputMessage inputMessage, MethodParameter parameter,
			Type targetType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {

	MediaType contentType;
	boolean noContentType = false;
	try {
		// 获得request的content-type
		contentType = inputMessage.getHeaders().getContentType();
	}
	···无效类型异常
	
	// 如果请求未传送content-type，则使用application/octet-stream
	if (contentType == null) {
		noContentType = true;
		contentType = MediaType.APPLICATION_OCTET_STREAM;
	}
	// 获得当前参数所在的类
	Class<?> contextClass = parameter.getContainingClass();
	// 参数类型
	Class<T> targetClass = (targetType instanceof Class ? (Class<T>) targetType : null);
	// 泛型的情况下参数类型为null，解析参数类型
	if (targetClass == null) {
		ResolvableType resolvableType = ResolvableType.forMethodParameter(parameter);
		targetClass = (Class<T>) resolvableType.resolve();
	}
	// 获得请求方法POST|GET
	HttpMethod httpMethod = (inputMessage instanceof HttpRequest ? ((HttpRequest) inputMessage).getMethod() : null);
	// 默认请求体内容
	Object body = NO_VALUE;

	EmptyBodyCheckingHttpInputMessage message;
	try {
		message = new EmptyBodyCheckingHttpInputMessage(inputMessage);
		// 遍历消息转换器
		for (HttpMessageConverter<?> converter : this.messageConverters) {
			// 消息转换器类型
			Class<HttpMessageConverter<?>> converterType = (Class<HttpMessageConverter<?>>) converter.getClass();
			// 获得支持泛型的消息转换器
			GenericHttpMessageConverter<?> genericConverter =
					(converter instanceof GenericHttpMessageConverter ? (GenericHttpMessageConverter<?>) converter : null);
			// 消息转换器支持content-type和参数类型(优先使用支持泛型)
			if (genericConverter != null ? genericConverter.canRead(targetType, contextClass, contentType) :
					(targetClass != null && converter.canRead(targetClass, contentType))) {
				// 请求体有内容
				if (message.hasBody()) {
					// 获得读取请求体前通知消息
					HttpInputMessage msgToUse =
							getAdvice().beforeBodyRead(message, parameter, targetType, converterType);
					// 请求体转换为对应的targetType类型
					body = (genericConverter != null ? genericConverter.read(targetType, contextClass, msgToUse) :
							((HttpMessageConverter<T>) converter).read(targetClass, msgToUse));
					// 读取请求体后通知
					body = getAdvice().afterBodyRead(body, msgToUse, parameter, targetType, converterType);
				}
				else {
					// 处理空请求体通知
					body = getAdvice().handleEmptyBody(null, message, parameter, targetType, converterType);
				}
				break;
			}
		}
	}
	···抛出io异常
	// 如果请求体为空
	if (body == NO_VALUE) {
		// 如果method为null 或 不支持请求method 或 请求体为空且noContentType为true  返回null，否则抛出异常
		if (httpMethod == null || !SUPPORTED_METHODS.contains(httpMethod) ||
				(noContentType && !message.hasBody())) {
			return null;
		}
		throw new HttpMediaTypeNotSupportedException(contentType, this.allSupportedMediaTypes);
	}
	
	···日志记录

	return body;
}

返回值解析

  1. 封装request和response，调用消息转换器处理返回值
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);

	// 调用消息转换器
	writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);
}
  1. 处理返回值，判断返回值是否为Resource类型，通过accept和消息转换器支持的content-type选择合适的content-type作为响应头，通过消息转换器解析返回值(outputStream.flush响应客户端)
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());
			}
		}
	}
	// 获得返回值类型，content-type
	MediaType selectedMediaType = null;
	MediaType contentType = outputMessage.getHeaders().getContentType();
	boolean isContentTypePreset = contentType != null && contentType.isConcrete();
	if (isContentTypePreset) {
		// 如果response中设置的返回值类型
		selectedMediaType = contentType;
	}
	else {
		// 未设置返回值
		HttpServletRequest request = inputMessage.getServletRequest();
		// 获得请求头的accept
		List<MediaType> acceptableTypes = getAcceptableMediaTypes(request);
		// 可返回类型
		List<MediaType> producibleTypes = getProducibleMediaTypes(request, valueType, targetType);
		// 如果返回值不为null且可提供content-type为空抛出异常
		if (body != null && producibleTypes.isEmpty()) {
			throw new HttpMessageNotWritableException(
					"No converter found for return value of type: " + valueType);
		}
		
		// 获得可用的content-type
		List<MediaType> mediaTypesToUse = new ArrayList<>();
		for (MediaType requestedType : acceptableTypes) {
			for (MediaType producibleType : producibleTypes) {
				if (requestedType.isCompatibleWith(producibleType)) {
					mediaTypesToUse.add(getMostSpecificMediaType(requestedType, producibleType));
				}
			}
		}
		// 可用类型为null处理
		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);
		// 选择合适的content-type
		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 (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 {
					···日志
				}
				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);
	}
}
King77777777777
关注
专栏目录
SpringMVC的@RequestParam和@RequestBody
brantykl的博客
02-18 758
1.在使用SpringMVC时通常需要接收参数.而接收参数通常有多种情况 　1)拼接在url上 　2)存在于请求体中(存在于请求头中暂不说明) 　3)参数的数据格式 　4)接收多个参数 　5)接收数组参数 　6)接收单个参数 　7)接收Bean 2.在使用vue的异步请求发送参数,参数类型默认application/json 　1)单个参数,存在于路径中,可直接使用@RequestParam获取 　2)单个参数,存在于请求体中. { param: "参数" } //@RequestBody 参数使用Ma
SpringMVC源码(六)-@RequestBody和@ResponseBody
weixin_34220963的博客
10-18 225
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring WebMVC 源码分析(2)-从注解@RequestBody开始
谈谈1974
11-16 1546
文章目录1. 注解@RequestBody 的作用2. Http 请求的参数处理流程3. 自定义协议的解析 1. 注解@RequestBody 的作用 2. Http 请求的参数处理流程 3. 自定义协议的解析 ...
【spring】@RequestBody注解学习
一个写了10年bug的程序员日常笔记。
05-18 2258
是 Spring Framework 中的一个注解，用于将 HTTP 请求的正文绑定到处理方法的参数上。这个注解通常用于处理 POST 或 PUT 请求，这些请求通常包含 JSON 或 XML 格式的数据。将 HTTP 请求的正文内容转换成指定的 Java 类型。required: 这是一个布尔类型的属性，默认值为true。当设置为true时，表示请求体必须存在且非空，否则Spring MVC会在处理请求时抛出异常（通常是如果设置为false。
SpringMVC中@RequestBody的应用
零度的博客专栏
05-30 8449
一个比较复杂的数据结构在前台组合起来后传递到后台，之前所有的前后台转换都是自己写的，比如js将json转为字符串的方法，后台接收json转成实体的方法。使用SpringMVC之后，可以使用@RequestBody注释接受参数，具体使用如下：        首先，@RequestBody需要接的参数是一个String化的json，这里直接使用JSON.stringify(json)这个方法来转
Spring MVC自定义日期类型转换器实例详解
10-20
Spring MVC框架本身已经提供了基本的类型转换支持，但在实际开发中，我们可能需要根据特定的格式需求来扩展或自定义类型转换器。 在本文中，我们将详细讲解如何在Spring MVC中自定义一个日期类型转换器，以满足特定...
第11章spring-mvc默认转换器
05-01
第11章spring-mvc默认转换器
深入理解Spring MVC的数据转换
08-29
ConversionService可以自动识别该转换器，并在Spring MVC进行参数转换时使用。 四、自定义转换器 在Spring MVC中，可以通过使用@InitBinder添加自定义的编辑器。例如，可以使用@InitBinder来注册自定义的日期编辑...
@RequestBody注解的使用及源码解析
最新发布
好记性不如烂笔头
07-10 1127
RequestBody 注解是我们进行JavaEE开发，最常见的几个注解之一，这篇博文我们以案例和源码相结合，帮助大家更好的了解 @RequestBody 注解@Data@Override'}';
spring 支持@RequestBody注解依赖包
09-26
spring 支持@RequestBody注解依赖包 、 spring 支持@RequestBody注解依赖包 spring 支持@RequestBody注解依赖包
Spring之RequestBody的使用
qq_35967283的博客
01-17 550
Spring之RequestBody的使用姿势小结 SpringMVC中处理请求参数有好几种不同的方式，如我们常见的下面几种 根据 HttpServletRequest 对象获取 根据 @PathVariable 注解获取url参数 根据 @RequestParam 注解获取请求参数 根据Bean的方式获取请求参数 根据 @ModelAttribute 注解获取请求参数 还有一种 @Request...
SpringMVC源码探索之RequestBody的工作原理
Ysh-uestc
09-18 324
https://blog.csdn.net/asahinokawa/article/details/86683631
基于springMVC的页面跳转、转发、重定向等
weixin_34117211的博客
06-10 265
2019独角兽企业重金招聘Python工程师标准>>> ...
@RequestParam @RequestBody @PathVariable 等参数绑定注解详解
weixin_42035472的博客
07-13 146
转自 https://blog.csdn.net/walkerJong/article/details/7946109 引言： 接上一篇文章，对@RequestMapping进行地址映射讲解之后，该篇主要讲解request 数据到handler method 参数数据的绑定所用到的注解和什么情形下使用； 简介： handler method 参数绑定常用的注解,我们根据他们处理的Request的不同内容部分分为四类：（主要讲解常用类型） A、处理requet uri 部分（这里指uri template.
Spring中的RequestBody注释
热门推荐
zenglintao的博客
05-29 1万+
@ requestbody 注释可用于处理 web 请求。 更具体地说，它用于将方法参数绑定到请求的主体，它的工作方式是 HttpMessageConverter 根据请求内容的类型转换请求的主体。 语法 <modifier> <return-type> <method-name> (@RequestBody <type> <name>) { } 以上语法的示例： public String congratulateEmployee(@Reque
Failed to meta-introspect annotation interface org.springframework.web.bind.annotation.RequestBody:
qq_37095305的博客
03-27 1923
Failed to meta-introspect annotation interface org.springframework.web.bind.annotation.RequestBody: java.lang.NullPointerException zookeeper +Dubbo 项目：后端一直出现空指针异常，前端页面用开发者工具查看是可以发送ajax请求传送数据的，到后端一直null，@Reference导dubbo包也没有错。 也不是zookeeper-dubbo的问题 最终，查看spr
Spring @RequestBody 的使用
zCowl
08-28 695
@RequestBody 注解出现在当前端以Json格式传递一个数据类型时，后台需要解析Json格式里的值这样一个场合。 页面传递Json格式的数据类型时，请求方式只能为Post而不是Get，一般简单的情况是传递一个对象Json，如： User对象，Json格式为 {"id":"1","username":"name","password":"pwd"}；而后台想要解析这样的数据就得这样： ...
Spring RequestBody 的使用
NBA_2011的专栏
09-27 660
Spring RequestBody使用Spring的RequestMapping 接收一个数组，本来有一种方式，是让 客户端 发送多个同样的参数，然后服务器端就可以接收到数组了服务器端： @RequestMapping(value="/add",method=RequestMethod.POST) @ResponseBody public String addAgency(String
webmvc消息转换器
03-27
WebMvc消息转换器是Spring框架中的一个组件，用于将请求和响应的消息转换为不同的格式，例如JSON、XML、二进制等。这些消息转换器可以自动地将传输的数据转换为目标格式，并将其转换为Java对象或从Java对象转换为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值