Spring MVC（5）HttpMessageConvert

最新推荐文章于 2023-11-06 08:43:04 发布
最新推荐文章于 2023-11-06 08:43:04 发布
阅读量543 收藏 2
点赞数
分类专栏： Spring MVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38060977/article/details/102768943
版权

目录

一 介绍

HttpMessageConveter 是用来处理request 和response 里的数据的。Spring 为我们内置了大量的HttpMessageConverter，例如， MappingJackson2HttpMessageConverter 、StringHttpMessageConverter 等。主要是为了配合@RequestBody和@ResponsetBody。

是 Spring3.0 新添加的一个接 口，负责1：将请求信息转换为一个对象（类型为 T），2：将对象（ 类型为 T）输出为响应信息

  1. Boolean canRead(Class<?> clazz,MediaType mediaType): 指定转换器 可以读取的对象类型，即转换器是否可将请求信息转换为 clazz 类型的对 象，同时指定支持 MIME 类型(text/html,applaiction/json等) – Boolean
  2. canWrite(Class<?> clazz,MediaType mediaType):指定转换器 是否可将 clazz 类型的对象写到响应流中，响应流支持的媒体类型 在MediaType 中定义。 – LIst getSupportMediaTypes()：该转换器支持的媒体类 型。
  3. T read(Class<? extends T> clazz,HttpInputMessage inputMessage)： 将请求信息流转换为 T 类型的对象。
  4. void write(T t,MediaType contnetType,HttpOutputMessgae outputMessage):将T类型的对象写到响应流中，同时指定相应的媒体类 型为 contentType。

二 实践

实现自定义HttpMessageConvert

这个类得作用是将前端通过表单（如x-www-form-urlencoded）提交得key-value的数据；我们后台可以通过@ResponseBody来获取。
这里的key是固定的，query或-model.
比如用户提交了xx?query={'name':"xw","age":"12"},我们后台可以处理这样的请求。

转换class类型或者ParameterizedType类型

package net.zjsos.core.common.web.config;

import java.io.IOException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.ArrayList;
import java.util.List;

import org.springframework.core.ResolvableType;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.GenericHttpMessageConverter;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.web.context.request.ServletWebRequest;

import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.type.TypeFactory;

import net.zjsos.core.common.base.util.SessionUtils;
import net.zjsos.core.common.util.Jackson;
import net.zjsos.core.common.util.StringUtils;

public class FormHttpMessageConvertor implements GenericHttpMessageConverter<Object> {
	

	private List<MediaType> list = new ArrayList<>();
	
	{
		//在程序初始化时spring mvc 会查询所有消息转换支持的MediaType，如果其他的消息转换器已经有了下面MediaType，可以不写
		list.add(MediaType.APPLICATION_FORM_URLENCODED);
		list.add(MediaType.APPLICATION_JSON);
		
	}
	

	@Override
	public List<MediaType> getSupportedMediaTypes() {
		return list;
	}


	@Override
	public void write(Object t, MediaType contentType, HttpOutputMessage outputMessage)
			throws IOException, HttpMessageNotWritableException {
		
	}

	@Override
	public boolean canRead(Type type, Class contextClass, MediaType mediaType) {
//		if(!(type instanceof Class)) {//泛型不是class
//			return false;
//		}
		if(!(type instanceof ParameterizedType || type instanceof Class)) {//非class类型或者ParameterizedType类型
			return false;
		}
		ServletWebRequest request = SessionUtils.getServletWebRequest();
		String content = request.getParameter("_model");
		if(!StringUtils.empty(content))
			return true;
		content = request.getParameter("query");
		if(!StringUtils.empty(content))
			return true;

		return false;
	}

	@Override
	public Object read(Type type, Class contextClass, HttpInputMessage inputMessage)
			throws IOException, HttpMessageNotReadableException {
		ServletWebRequest request = SessionUtils.getServletWebRequest();
		String content = request.getParameter("_model");
		
		if(!StringUtils.empty(content)) {
//			return Json.fromJson(content, type);
			JavaType javaType = getJavaType(type,contextClass);
			return Jackson.toObject(content, javaType);
		}
		content = request.getParameter("query");
		if(!StringUtils.empty(content)) {
//			return Json.fromJson(content, type);
			JavaType javaType = getJavaType(type,contextClass);
			return Jackson.toObject(content, javaType);
		}
		return null;
	}

	@Override
	public boolean canWrite(Type type, Class clazz, MediaType mediaType) {
		return false;
	}

	@Override
	public void write(Object t, Type type, MediaType contentType, HttpOutputMessage outputMessage)
			throws IOException, HttpMessageNotWritableException {
		
	}


	@Override
	public boolean canRead(Class clazz, MediaType mediaType) {
		return false;
	}


	@Override
	public boolean canWrite(Class clazz, MediaType mediaType) {
		return false;
	}


	@Override
	public Object read(Class clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
		return null;
	}

	
	protected JavaType getJavaType(Type type, Class<?> contextClass) {
		TypeFactory typeFactory = Jackson.getTypeFactory();
		if (contextClass != null) {
			ResolvableType resolvedType = ResolvableType.forType(type);
			if (type instanceof TypeVariable) {
				ResolvableType resolvedTypeVariable = resolveVariable(
						(TypeVariable<?>) type, ResolvableType.forClass(contextClass));
				if (resolvedTypeVariable != ResolvableType.NONE) {
					return typeFactory.constructType(resolvedTypeVariable.resolve());
				}
			}
			else if (type instanceof ParameterizedType && resolvedType.hasUnresolvableGenerics()) {
				ParameterizedType parameterizedType = (ParameterizedType) type;
				Class<?>[] generics = new Class<?>[parameterizedType.getActualTypeArguments().length];
				Type[] typeArguments = parameterizedType.getActualTypeArguments();
				for (int i = 0; i < typeArguments.length; i++) {
					Type typeArgument = typeArguments[i];
					if (typeArgument instanceof TypeVariable) {
						ResolvableType resolvedTypeArgument = resolveVariable(
								(TypeVariable<?>) typeArgument, ResolvableType.forClass(contextClass));
						if (resolvedTypeArgument != ResolvableType.NONE) {
							generics[i] = resolvedTypeArgument.resolve();
						}
						else {
							generics[i] = ResolvableType.forType(typeArgument).resolve();
						}
					}
					else {
						generics[i] = ResolvableType.forType(typeArgument).resolve();
					}
				}
				return typeFactory.constructType(ResolvableType.
						forClassWithGenerics(resolvedType.getRawClass(), generics).getType());
			}
		}
		return typeFactory.constructType(type);
	}
	
	private ResolvableType resolveVariable(TypeVariable<?> typeVariable, ResolvableType contextType) {
		ResolvableType resolvedType;
		if (contextType.hasGenerics()) {
			resolvedType = ResolvableType.forType(typeVariable, contextType);
			if (resolvedType.resolve() != null) {
				return resolvedType;
			}
		}

		ResolvableType superType = contextType.getSuperType();
		if (superType != ResolvableType.NONE) {
			resolvedType = resolveVariable(typeVariable, superType);
			if (resolvedType.resolve() != null) {
				return resolvedType;
			}
		}
		for (ResolvableType ifc : contextType.getInterfaces()) {
			resolvedType = resolveVariable(typeVariable, ifc);
			if (resolvedType.resolve() != null) {
				return resolvedType;
			}
		}
		return ResolvableType.NONE;
	}
}

转换TypeVariable

/**
 * 该转换器应该放在FormHttpMessageConvertor后面，不然ParameterizedType类型的参数会序列化失败
 * 
 * @author zyc
 *
 */
public class TypeVariableConverter implements HttpMessageConverter<Object> {

	private List<MediaType> list = new ArrayList<>();
	{
		// 在程序初始化时spring mvc 会查询所有消息转换支持的MediaType，如果其他的消息转换器已经有了下面MediaType，可以不写
		list.add(MediaType.APPLICATION_FORM_URLENCODED);
		list.add(MediaType.APPLICATION_JSON);
	}

	// 经过FormHttpMessageConvertor筛选后，仍然返回true的参数的targettype肯定不是class类型
	@Override
	public boolean canRead(Class<?> clazz, MediaType mediaType) {
		ServletWebRequest request = SessionUtils.getServletWebRequest();
		String content = request.getParameter("_model");
		if (!StringUtils.empty(content))
			return true;
		content = request.getParameter("query");
		if (!StringUtils.empty(content))
			return true;

		return false;
	}

	@Override
	public boolean canWrite(Class<?> clazz, MediaType mediaType) {
		return false;
	}

	@Override
	public List<MediaType> getSupportedMediaTypes() {
		return list;
	}

	@Override
	public Object read(Class<? extends Object> clazz, HttpInputMessage inputMessage)
			throws IOException, HttpMessageNotReadableException {
		ServletWebRequest request = SessionUtils.getServletWebRequest();
		String content = request.getParameter("_model");

		if (!StringUtils.empty(content)) {
			return Json.fromJson(content, clazz);
		}
		content = request.getParameter("query");
		if (!StringUtils.empty(content)) {
			return Json.fromJson(content, clazz);
		}
		return null;
	}

	@Override
	public void write(Object t, MediaType contentType, HttpOutputMessage outputMessage)
			throws IOException, HttpMessageNotWritableException {

	}

}

配置

@Configuration
@EnableWebMvc
@ComponentScan("com.example.spring.framework.converter")
public class MyMvcConfig extends WebMvcConfigurerAdapter {
...
      /**
     * 配置自定义的HttpMessageConverter 的Bean ，在Spring MVC 里注册HttpMessageConverter有两个方法：
     * 1、configureMessageConverters ：重载会覆盖掉Spring MVC 默认注册的多个HttpMessageConverter
     * 2、extendMessageConverters ：仅添加一个自定义的HttpMessageConverter ，不覆盖默认注册的HttpMessageConverter
     * 在这里重写extendMessageConverters
     */
    @Override
    public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {

        converters.add(converter());

    }

三 RequestBodyAdvice

上面两个HttpMesageConvert在请求的content-type不支持的情况下，需要一个统一处理；转换失败后的统一处理，只需要重写handleEmptyBody.不影响其他正常的@RequestBody注解使用

package net.zjsos.core.common.web.advice;

import java.io.IOException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;

import org.springframework.core.MethodParameter;
import org.springframework.core.ResolvableType;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.context.request.ServletWebRequest;
import org.springframework.web.servlet.mvc.method.annotation.RequestBodyAdvice;

import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.type.TypeFactory;

import net.zjsos.core.common.base.util.SessionUtils;
import net.zjsos.core.common.util.Jackson;
import net.zjsos.core.common.util.StringUtils;
import net.zjsos.core.common.web.config.FormHttpMessageConvertor;
import net.zjsos.core.common.web.config.TypeVariableConverter;

@ControllerAdvice
public class NullBodyAdvice implements RequestBodyAdvice{

	@Override
	public boolean supports(MethodParameter methodParameter, Type targetType,
			Class<? extends HttpMessageConverter<?>> converterType) {
		if(FormHttpMessageConvertor.class == converterType || TypeVariableConverter.class == converterType)
			return true;
		return false;
	}


	@Override
	public Object handleEmptyBody(Object body, HttpInputMessage inputMessage, MethodParameter parameter,
			Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
		try {
			ServletWebRequest request = SessionUtils.getServletWebRequest();
			
			Class<?> contextClass = (parameter != null ? parameter.getContainingClass() : null);
			JavaType javatype = getJavaType(targetType,contextClass);
			
			String content = request.getParameter("_model");
			if(!StringUtils.empty(content)) {
				return Jackson.toObject(content, javatype);
			}
			content = request.getParameter("query");
			if(!StringUtils.empty(content)) {
				return Jackson.toObject(content, javatype);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	@Override
	public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType,
			Class<? extends HttpMessageConverter<?>> converterType) throws IOException {
		// TODO 原样返回
		return inputMessage;
	}

	@Override
	public Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType,
			Class<? extends HttpMessageConverter<?>> converterType) {
		// TODO 不修改原值
		return body;
	}
	
	protected JavaType getJavaType(Type type, Class<?> contextClass) {
		TypeFactory typeFactory = Jackson.getTypeFactory();
		if (contextClass != null) {
			ResolvableType resolvedType = ResolvableType.forType(type);
			if (type instanceof TypeVariable) {
				ResolvableType resolvedTypeVariable = resolveVariable(
						(TypeVariable<?>) type, ResolvableType.forClass(contextClass));
				if (resolvedTypeVariable != ResolvableType.NONE) {
					return typeFactory.constructType(resolvedTypeVariable.resolve());
				}
			}
			else if (type instanceof ParameterizedType && resolvedType.hasUnresolvableGenerics()) {
				ParameterizedType parameterizedType = (ParameterizedType) type;
				Class<?>[] generics = new Class<?>[parameterizedType.getActualTypeArguments().length];
				Type[] typeArguments = parameterizedType.getActualTypeArguments();
				for (int i = 0; i < typeArguments.length; i++) {
					Type typeArgument = typeArguments[i];
					if (typeArgument instanceof TypeVariable) {
						ResolvableType resolvedTypeArgument = resolveVariable(
								(TypeVariable<?>) typeArgument, ResolvableType.forClass(contextClass));
						if (resolvedTypeArgument != ResolvableType.NONE) {
							generics[i] = resolvedTypeArgument.resolve();
						}
						else {
							generics[i] = ResolvableType.forType(typeArgument).resolve();
						}
					}
					else {
						generics[i] = ResolvableType.forType(typeArgument).resolve();
					}
				}
				return typeFactory.constructType(ResolvableType.
						forClassWithGenerics(resolvedType.getRawClass(), generics).getType());
			}
		}
		return typeFactory.constructType(type);
	}
	
	private ResolvableType resolveVariable(TypeVariable<?> typeVariable, ResolvableType contextType) {
		ResolvableType resolvedType;
		if (contextType.hasGenerics()) {
			resolvedType = ResolvableType.forType(typeVariable, contextType);
			if (resolvedType.resolve() != null) {
				return resolvedType;
			}
		}

		ResolvableType superType = contextType.getSuperType();
		if (superType != ResolvableType.NONE) {
			resolvedType = resolveVariable(typeVariable, superType);
			if (resolvedType.resolve() != null) {
				return resolvedType;
			}
		}
		for (ResolvableType ifc : contextType.getInterfaces()) {
			resolvedType = resolveVariable(typeVariable, ifc);
			if (resolvedType.resolve() != null) {
				return resolvedType;
			}
		}
		return ResolvableType.NONE;
	}

}

参考

  1. https://blog.csdn.net/DERRANTCM/article/details/77104957
ycCoding
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringMvc---MessageConverter
wowo
11-24 1988
SpringMvc---MessageConverter HttpMessageConverter，报文信息转换器，将请求报文转换为Java对象，或将Java对象转换为响应报文 HttpMessageConverter提供了两个注解和两个类型：@RequestBody，@ResponseBody，RequestEntity， ResponseEntity 使用这些注解就能把控制器返回值直接显示在页面上，而不是被解析为视图。 1、@RequestBody 这个注解在参数上使用 @RequestB
SpringMVC系列-5 消息转换器
Sheng_Q的博客
10-22 968
SpringMVC系列的第五篇介绍消息转换器，本文讨论的消息转换指代调用Controller接口后，对结果进行转换处理的过程。 内容包括介绍自定义消息转换器、SpringMVC常见的消息转换器、Spring消息转换器工作原理等三部分。
SpringMVC消息转换器HttpMessageConverter
哈
05-24 1829
Http数据转换的原理 当一个HTTP请求到达时是一个InputStream，通过HttpMessageConverter转换为java对象，从而进行参数接收。 当对一个HTTP请求进行响应时，我们首先输出的是一个java对象，然后由HttpMessageConverter转换为OutputStream输出。 当我们在Spring Boot应用中集成了jackson的类库之后，如下的一些HttpMessageConverter将会被加载： 实现类 功能说明 StringHttpMessag
spring升级处理MappingJackson2HttpMessageConverter
lishuzhen5678的博客
10-29 1743
将一套公司的N年前的老代码，原始到直接是jar放入lib搭建的项目。首先第一步把项目改成maven版本，然后再从spring3.1 升级到 spring5，直接跳过4...
Spring——HttpMessageConverter
chenxingxingxing的博客
04-21 1277
文章目录HttpMessageConverter简介1、@RequestBody2、RequestEntity3、@ResponseBody（1）响应普通类型（2）响应json对象4、ResponseEntity（1）文件的下载（3）文件上传 HttpMessageConverter简介 Http:http协议；Message：消息；Converter:转换器，合起来就是报文消息转换器，它可以将请求报文转化为java对象，也可以将java对象转换为响应报文信息。HttpMessageConverter有两个
SpringMVC-StringHttpMessageConverter简介
热门推荐
晚晴小筑
09-06 2万+
旨在通过分析StringHttpMessageConverter 来初步认识消息转换器HttpMessageConverter 的处理流程。分析完StringHttpMessageConverter 便可以窥视SpringMVC的庐山真面目了。/** * HttpMessageConverter 的实现类：完成请求报文到字符串和字符串到响应报文的转换 * 默认情况下，此转换器支持所有媒体类型(*
spring mvc demo
最新发布
06-23
Spring MVC 是一个基于Java的轻量级Web应用框架，它为构建MVC（Model-View-Controller）架构的Web应用程序提供了强大的支持。Spring MVC通过解耦业务逻辑、数据模型和用户界面，使得开发者可以更专注于应用程序的...
Spring MVC 学习记录总结1
08-03
5. 使用Spring MVC的步骤 - 创建Maven项目，并在pom.xml中添加Spring Web MVC的依赖。 - 配置web.xml，定义DispatcherServlet。 - 编写Controller，实现请求处理逻辑。 - 配置视图解析器，如JSP或Thymeleaf。 -...
Spring MVC 4.2.3
07-29
5. **数据绑定和验证**：Spring MVC提供强大的数据绑定功能，将HTTP请求参数自动映射到处理方法的参数，并支持JSR-303/JSR-349 Bean Validation标准进行数据验证。 6. **异常处理**：通过定义全局异常处理器，可以...
spring mvc项目后端源码
05-28
Spring MVC 是一个基于 Java 的轻量级 Web 开发框架，它是 Spring 框架的一部分，专为构建可维护、高性能的 Web 应用程序而设计。这个“spring mvc项目后端源码”包含了实现此类应用程序的核心组件和配置。下面我们...
详解 SpringMVC 的 HttpMessageConverter
莫等闲 白了少年头 空悲切
11-06 5859
HttpMessageConverter是Spring Framework中的一个接口，用于处理HTTP请求和响应的消息转换。在Spring MVC中，HttpMessageConverter主要用于将HTTP请求的输入内容转换为指定的Java对象，以及将Java对象转换为HTTP响应的输出内容。它负责处理请求和响应的数据格式转换，例如将请求的JSON或XML数据转换为Java对象，并将Java对象转换为JSON或XML格式的响应数据。
SpringMVC的HttpMessageConverter(消息转换器)
five-five
02-07 4618
首先说说我在阅读Spring官方文档遇到的三个不明确的地方， Type Conversion（ 类型转换）、Content Type（内容类型） 、Message Converters（消息转换器） TypeConversion（类型转换器） 首先看看spring的官网怎么解释这个的： By default, formatters for various number and date types are installed, along with support for customization vi
SpringMVC源码剖析（五)-消息转换器HttpMessageConverter
weixin_33686714的博客
10-28 552
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring中HttpMessageConverter的工作原理
JAVA上尉
03-26 1232
在SpringMvc中，想要一个Http接口返回Json格式的数据，只需要在Controller类中做如下定义：@GetMapping("/{id}") public ...
【Spring】HttpMessageConverter的作用及替换
weknow
02-07 1171
相信使用过Spring的开发人员都用过@RequestBody、@ResponseBody注解，可以直接将输入解析成Json、将输出解析成Json，但HTTP 请求和响应是基于文本的，意味着浏览器和服务器通过交换原始文本进行通信，而这里其实就是HttpMessageConverter发挥着作用。   HttpMessageConverter Http请求响应报文其实都是字符串，当
三、SpringMVC报文信息
weixin_46203713的博客
10-11 228
三、SpringMVC报文信息 1、HttpMessageConverter HttpMessageConverter，报文信息转换器，将请求报文转换为java对象，或将java对象转换为响应报文 HttpMessageConverter提供了两个注解和两个类型: @RequestBody RequestEntity @ResponseBody ResponseEntity 2、@RequestBody @RequestBody可以获取请求体，需要在控制器方法设置一个形参，使用@Request
解决低版本spring中StringHttpMessageConverter中文乱码问题
机智W_en的博客
06-28 1619
项目架构比较老旧，spirng用的3.0.2，在使用@ResponseBody String做返回值的接口时，若客户端不做处理，Content-Type默认为text/plain;charset=ISO-8859-1，导致的问题是中文会显示乱码，变成???问号。 查阅资料发现有以下几种解决方案： 在@RequestMapping里面加入produces = "text/html;charset=UTF-8" @RequestMapping(value = "/getAllTask", metho.
SpringMVC使用stringHttpMessageConverter
weixin_43992119的博客
08-22 738
SpringMVC使用stringHttpMessageConverter场景演示解决方法 场景演示 当使用@ReponseBody注解的时候，我们知道返回值会被转换成 Json格式.然而里面的中文可能会被转换成乱码，如下面代码中的’测试错误’可能就被转换成‘？？？？？’。显然这对我们的开发很有影响的，这时候超级英雄spring出现了 @Controller public class tipica...
SpringMVC中StringHttpMessageConverter乱码处理
屋里郎
09-29 1万+
很多人都碰到过，SpringMVC使用 @ResponseBody 注解，返加字符串不做任何处理时，有可能会出现乱码问题。 这是由于 StringHttpMessageConverter 类中，默认采用的字符集是 ISO-8859-1。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值