SpringMVC中controller中方法返回类型为ResponseEntity<String>乱码的问题

最新推荐文章于 2025-02-27 07:57:23 发布
转载 最新推荐文章于 2025-02-27 07:57:23 发布 · 1.3w 阅读 · 5

本文探讨了Spring MVC中使用ResponseEntity作为返回类型时的工作原理，重点介绍了如何配置StringHttpMessageConverter来避免乱码问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

返回类型为ResponseEntity<T>

代表我们返回的数据是一个对象，在springMVC中，请求数据到对象和对象到响应数据的转换是通过消息转换器来完成的。

HttpMessageConverter是消息转换器的顶层接口，所有的消息转换器都必须实现这个接口

[java]  view plain  copy
  1. package org.springframework.http.converter;  
  2.   
  3. import java.io.IOException;  
  4. import java.util.List;  
  5.   
  6. import org.springframework.http.HttpInputMessage;  
  7. import org.springframework.http.HttpOutputMessage;  
  8. import org.springframework.http.MediaType;  
  9.   
  10. public interface HttpMessageConverter<T> {  
  11.   
  12.     boolean canRead(Class<?> clazz, MediaType mediaType);  
  13.   
  14.     boolean canWrite(Class<?> clazz, MediaType mediaType);  
  15.   
  16.     List<MediaType> getSupportedMediaTypes();  
  17.   
  18.     T read(Class<? extends T> clazz, HttpInputMessage inputMessage)  
  19.             throws IOException, HttpMessageNotReadableException;  
  20.   
  21.     void write(T t, MediaType contentType, HttpOutputMessage outputMessage)  
  22.             throws IOException, HttpMessageNotWritableException;  
  23.   
  24. }  



我们可以看到针对不同的类型，实现了具体消息转换器


--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

下面先来说说<mvc:annotation-driven></mvc:annotation-driven>，通过这个线索一直下去，找到问题的根源。

通常我们在springMVC配置文件中会配置<mvc:annotation-driven></mvc:annotation-driven>注解驱动，它对应的类是AnnotationDrivenBeanDefinitionParser


在 spring-webmvc.jar包下我们可以找到AnnotationDrivenBeanDefinitionParser类


分析getMessageConverters()方法后发现执行流程如下：

1.它首先会去配置中查找<mvc:annotation-driven>父标签中是否含有<mvc:message-converters>子标签，如果有则把<mvc:message-converters>下的所有自定义消息转化器封装在message-converter对象中

2.然后判断message-converter是否为空。如果不为空，则把message-converter中封装的的所有自定义消息转换器添加到managedList集合中。

3.a)如果<mvc:annotation-driven>的属性register-defaults为真，还会加载默认列出的消息转换器，并加入到managedList集合里。b)如果为假，则只会加载我们自定义的。tips:通常我们都会是它为真，或不配置这个属性，不配置，他默认为真。

[java]  view plain  copy
  1. class AnnotationDrivenBeanDefinitionParser implements BeanDefinitionParser {  
  2.     …  
  3.         private ManagedList<?> getMessageConverters(Element element, Object source, ParserContext parserContext) {  
  4.         Element convertersElement = DomUtils.getChildElementByTagName(element, "message-converters");  
  5.         ManagedList<? super Object> messageConverters = new ManagedList<Object>();  
  6.         if (convertersElement != null) {  
  7.             messageConverters.setSource(source);  
  8.             for (Element beanElement : DomUtils.getChildElementsByTagName(convertersElement, "bean", "ref")) {  
  9.                 Object object = parserContext.getDelegate().parsePropertySubElement(beanElement, null);  
  10.                 messageConverters.add(object);  
  11.             }  
  12.         }  
  13.   
  14.         if (convertersElement == null || Boolean.valueOf(convertersElement.getAttribute("register-defaults"))) {  
  15.             messageConverters.setSource(source);  
  16.             messageConverters.add(createConverterDefinition(ByteArrayHttpMessageConverter.class, source));  
  17.   
  18.             RootBeanDefinition stringConverterDef = createConverterDefinition(StringHttpMessageConverter.class, source);  
  19.             stringConverterDef.getPropertyValues().add("writeAcceptCharset", false);  
  20.             messageConverters.add(stringConverterDef);  
  21.   
  22.             messageConverters.add(createConverterDefinition(ResourceHttpMessageConverter.class, source));  
  23.             messageConverters.add(createConverterDefinition(SourceHttpMessageConverter.class, source));  
  24.             messageConverters.add(createConverterDefinition(AllEncompassingFormHttpMessageConverter.class, source));  
  25.   
  26.             if (romePresent) {  
  27.                 messageConverters.add(createConverterDefinition(AtomFeedHttpMessageConverter.class, source));  
  28.                 messageConverters.add(createConverterDefinition(RssChannelHttpMessageConverter.class, source));  
  29.             }  
  30.   
  31.             if (jackson2XmlPresent) {  
  32.                 RootBeanDefinition jacksonConverterDef = createConverterDefinition(MappingJackson2XmlHttpMessageConverter.class, source);  
  33.                 GenericBeanDefinition jacksonFactoryDef = createObjectMapperFactoryDefinition(source);  
  34.                 jacksonFactoryDef.getPropertyValues().add("createXmlMapper", true);  
  35.                 jacksonConverterDef.getConstructorArgumentValues().addIndexedArgumentValue(0, jacksonFactoryDef);  
  36.                 messageConverters.add(jacksonConverterDef);  
  37.             }  
  38.             else if (jaxb2Present) {  
  39.                 messageConverters.add(createConverterDefinition(Jaxb2RootElementHttpMessageConverter.class, source));  
  40.             }  
  41.   
  42.             if (jackson2Present) {  
  43.                 RootBeanDefinition jacksonConverterDef = createConverterDefinition(MappingJackson2HttpMessageConverter.class, source);  
  44.                 GenericBeanDefinition jacksonFactoryDef = createObjectMapperFactoryDefinition(source);  
  45.                 jacksonConverterDef.getConstructorArgumentValues().addIndexedArgumentValue(0, jacksonFactoryDef);  
  46.                 messageConverters.add(jacksonConverterDef);  
  47.             }  
  48.             else if (gsonPresent) {  
  49.                 messageConverters.add(createConverterDefinition(GsonHttpMessageConverter.class, source));  
  50.             }  
  51.         }  
  52.         return messageConverters;  
  53.     }  
  54. }  

 从其中我们可以找到添加StringHttpMessageConverter转换器的代码段


和之前输出JSON用到的MappingJackson2HttpMessageConverter转换器，这也可以看处springMVC对JSON的支持为什么要加入jackson的依赖。




我这里为什么要单独挑出这两个转换器，是为了说明他们的区别和调用时机的,和进一步引出问题。

         a)之前如果我们要把对象以JSON格式输出，可以给controller的方法加@ResponseBody注解,到后来我们依照resultful的思想来做项目时，函数的返回值不会再是POJO，而是ResponseEntity<T>，有了它我们向往前台输出对象对应的JSON就不再需要再添加@ResponseBody注解了

         b)在SpringMVC中是怎么把我们的对象转换为JSON输出的呢，这里依旧要提到spring mvc的消息转换器,是它完成了这个转换过程。

         c)但是函数值为ResponseEntity<T>并不是所有的对象都会再后来转换为json，比如String,它会调用对应的StringHttpMessageConverter的消息转换器，而不是MappingJackson2HttpMessageConverter转换器。所以如果返回值类型为ResponseEntity<String> ，要输出json需要我们自己把json数据写到string里，spring是不会帮我们转换的。


接下来我们看StringHttpMessageConverter.class类 org.springframework.http.converter.StringHttpMessageConverter

[java]  view plain  copy
  1. public class StringHttpMessageConverter extends AbstractHttpMessageConverter<String> {  
  2.       
  3. public static final Charset DEFAULT_CHARSET = Charset.forName("ISO-8859-1");  
  4.     private final Charset defaultCharset;  
  5.     …  
  6. public StringHttpMessageConverter() {  
  7.         this(DEFAULT_CHARSET);  
  8.     }  
  9.   
  10.     public StringHttpMessageConverter(Charset defaultCharset) {  
  11.         super(new MediaType("text", "plain", defaultCharset), MediaType.ALL);  
  12.         this.defaultCharset = defaultCharset;  
  13.         this.availableCharsets = new ArrayList<Charset>(Charset.availableCharsets().values());  
  14.     }  
  15.     …  
  16. }  
  17.       

发现它的默认转换编码是iso-8859-1，前台解码一般用utf-8，编解码不一致导致乱码，但我们发现这给类的构造方法预留了一个参数让我自己指定编码，这里我们看到了一丝希望哈哈。

解决办法：

我们只要在spring-mvc.xml配置文件中自己为这个消息转换器配置utf-8编码就ok了

[html]  view plain  copy
  1. <mvc:annotation-driven>  
  2.         <!-- 自定义消息转换器 -->  
  3.         <mvc:message-converters register-defaults="true">  
  4.             <!-- 自定义消息转换器，设置编码为utf-8，防止responseEntity<String>转换成json对象输出乱码 -->  
  5.             <bean class="org.springframework.http.converter.StringHttpMessageConverter">  
  6.                 <constructor-arg index="0" value="utf-8"></constructor-arg>  
  7.             </bean>   
  8.         </mvc:message-converters>  
  9. </mvc:annotation-driven>  

RestTemplate 请求响应数据出现乱码问题，RestTemplate 如何解压缩 gzip 数据
是谢添啊
03-29 2524
原理：当 RestTemplate 接收到经过 Gzip 压缩的响应时，底层的 HTTP 客户端库会自动解压缩这个响应，然后将解压缩后的内容传递给 RestTemplate 进行处理。在最后呢，我结合着浏览器可以正常响应数据而 RestTemplate 不可以，出现了乱码，以及我观察到响应头的一个字段。但遗憾的是，还是没有用。然后再想的是默认注入的 RestTemplate 是不是内置的字符编码有问题。因此，我猜测是字符编码的问题，于是我需要重新设置一下默认的字符编码。就对数据进行了解压缩。
Spring Boot 乱码解决全攻略：从根源定位到实战修复
最新发布
qq_20294455的博客
06-30 1133
SpringBoot乱码问题解决方案 摘要：SpringBoot开发中常见的乱码问题源于字符编码不一致，主要涉及项目配置、Web容器、数据库和前端页面四个环节。本文提供系统解决方案：1)在application.properties中配置Tomcat和SpringMVC的UTF-8编码；2)创建字符编码过滤器统一处理请求响应；3)确保数据库(如MySQL)使用utf8mb4编码；4)前端页面声明UTF-8字符集。通过全局编码配置、过滤器处理、数据库设置和前端调整四步方案，配合控制台输出、页面显示和接口测试等
springboot responseentity＜string＞乱码问题
chaoyueyou的博客
08-06 2304
乱码： <200,{"result":"[{\"field\":\"name\",\"objectName\":\"driver\",\"defaultMessage\":\"名称不能为空！\"},{\"field\":\"address\",\"objectName\":\"driver\",\"defaultMessage\":\"系统id不能为空！\"},{\"field\":\"authcode\",\"objectName\":\"dr
关于controller返回String页面乱码问题
冷芝士鸭的学习笔记
09-24 970
https://blog.youkuaiyun.com/jiahao1186/article/details/91980316 在Springboot中根本不需要做什么，主要返回值是一个对象，传递给浏览器后，都会将这个对象转换成json字符串，key对应对象字段名称，value对应字段值 1、概念 注解 @ResponseBody，使用在控制层（controller）的方法上。 2、作用 作用：将方法的返回值，以特定的格式写入到response的body区域，进而将数据返回给客户端。 当方法上面没有写ResponseB
ResponseEntity＜String＞ resultMap = restTemplate.getForEntity
weixin_44945027的博客
02-10 592
使用restTemplate的get方法获取返回值中的头部信息的 cookie，吧cookie拿来放到头部作为参数再次请求另一个接口，就是先登录获取返回的cookie 吧cookie作为参数调用另一个接口。。。。。
解决springboot Controller直接返回String类型带来的乱码
热门推荐
wcy1900353090的博客
03-15 1万+
在学习springboot的路上遇到的一个小坑，就是controller在响应时如果直接返回String类型,得到的将是一串???的乱码 下面是解决办法，就是配置请求个响应的编码格式 首先在 application.yaml 内设置 请求的编码格式 # Tomcat specifics tomcat: uri-encoding: UTF-8 然后设置response响...
SpringMVC学习总结（七）@RequestBody/RequestEntity/@ResponseBody/SpringMVC处理Json和Ajax/ResponseEntity/文件上传和下载
ZaynFox的博客
09-06 1363
HttpMessageConverter，报文信息转换器，将请求报文转换为Java对象，或将Java对象转换为响应报文 HttpMessageConverter提供了两个注解和两个类型：@RequestBody，@ResponseBody，RequestEntity，ResponseEntity 一、获取请求信息 （一）@RequestBody @RequestBody可以获取请求体，需要在控制器方法设置一个形参，使用@RequestBody进行标识，当前请求的请求体就会为当前注解所标识的形参赋值。 案例：
SpringMvc后台接收json数据中文乱码问题详解
10-16
4. **在Controller中处理乱码**：虽然前面的配置应该能解决问题，但为了保险起见，你也可以在Controller方法中手动处理请求参数的编码，如示例代码所示，将接收到的ISO-8859-1编码的字符串转换为UTF-8： ```java ...
解决SpringMvc后台接收json数据中文乱码问题的几种方法
10-18
本文将深入探讨两种解决SpringMvc后台接收JSON数据中文乱码问题的方法。 1. **使用Ajax传输数据** 当前端通过Ajax使用JSON格式向SpringMvc后台发送数据时，可能出现中文乱码。这通常是因为服务器默认的字符编码不...
springMVC解决中文乱码
07-28
解决 SpringMVC 中的中文乱码问题可以通过多种方法来实现，包括在 web.xml 文件中配置字符编码、使用注解配置字符编码、使用 CharacterEncodingFilter 或者自定义 Filter 等。这些方法都可以有效地解决中文乱码问题...
SpringMVC请求/响应乱码问题解决方案解析
08-25
name> <param-value>utf-8</param-value> </init-param> </filter> <filter-mapping> <filter-name>CharacterEncodingFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> 本文对SpringMVC请求/...
Java ResponseEntity
alallalalal的博客
11-28 1257
Java ResponseEntity对象
深入理解Spring MVC Controller返回String类型导致中文乱码的问题。
starjuly的专栏
05-28 493
代码 在Controller层写下如下的测试代码： @GetMapping public String test() { return "这是一个中文句子"; } 调试 在return返回后，使用调试模式，知道代码会进入到AbstractMessageConverterMethodProcessor类的writeWithMessageConverters方法： org.springframework.web.servlet.mvc.method.annotati
controller返回string类型和bean的序列化、乱码
04-21 1809
@Bean public HttpMessageConverter<String> responseBodyConverter() { return new StringHttpMessageConverter(StandardCharsets.UTF_8); } @Bean public ObjectMapper getObjectMapper() { ...
在Spring开发Restful API中使用ResponseEntity返回内容
yuxzlucy的博客
02-27 2122
在 Spring 框架中，ResponseEntity 是一个非常强大且常用的类，用于表示 HTTP 响应的完整内容，包括状态码、响应头和响应体。它通常用于 RESTful API 的控制器中，能够灵活地控制返回给客户端的响应细节。
2021-07-16项目中如何处理接收到的参数（ResponseEntity＜String＞）
qq_43117978的博客
07-16 1705
https://www.cnblogs.com/chushujin/p/11371450.html
responseEntity如何加响应头
m0_62932368的博客
03-21 2331
responseEntity如何加响应头
Java ResponseEntity的用法和介绍
m0_64974617的博客
09-30 2063
是Spring框架中的一个类，它继承自HttpEntity，代表了整个HTTP响应（包括状态码、头信息和响应体）。为你提供了更大的灵活性来控制REST API的响应。你可以使用返回自定义的HTTP状态码。// 假设资源不存在if (!还允许你自定义HTTP头部信息是Spring框架中一个非常实用的工具，它为你提供了对HTTP响应细粒度的控制。通过使用，你可以灵活地定制HTTP响应的状态码、头信息和响应体，从而构建出更强大和健壮的REST API。掌握。
1异常(throw、throws关键字、try...catch、Throwable类、finally代码块)
weixin_52308754的博客
12-22 278
声明异常throws 捕获异常try…catch package Text1; import java.io.IOException; public class Demo12 { public static void main(String[] args) { try { readFile("d:\\a.tx"); } catch (IOException e) { System.out.println("传...
springmvc中文乱码问题
09-02
### 回答1： 在SpringMVC中，中文乱码问题通常是由于字符集编码不一致所导致的。一般有以下几种解决方法： 1. 在web.xml文件中添加过滤器解决乱码问题： ``` <filter> <filter-name>encodingFilter</filter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> <init-param> <param-name>encoding</param-name> <param-value>UTF-8</param-value> </init-param> <init-param> <param-name>forceEncoding</param-name> <param-value>true</param-value> </init-param> </filter> <filter-mapping> <filter-name>encodingFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> ``` 2. 在SpringMVC的配置文件中添加字符集编码过滤器： ``` <mvc:annotation-driven> <mvc:message-converters register-defaults="true"> <bean class="org.springframework.http.converter.StringHttpMessageConverter"> <constructor-arg value="UTF-8"/> <property name="supportedMediaTypes"> <list> <value>text/plain;charset=UTF-8</value> <value>text/html;charset=UTF-8</value> <value>application/json;charset=UTF-8</value> </list> </property> </bean> </mvc:message-converters> </mvc:annotation-driven> ``` 3. 在控制器方法上添加字符集编码注解： ``` @RequestMapping(value = "/test", produces = "text/plain;charset=UTF-8") @ResponseBody public String test() { //do something } ``` 以上三种方法都可以解决SpringMVC中的中文乱码问题，可以根据自己的实际情况选择适合自己的方法。 ### 回答2： Spring MVC中文乱码问题通常是由于数据的编码与解码不一致造成的。解决办法可以通过以下几种方式： 1. 在web.xml中配置字符集过滤器（CharacterEncodingFilter）来统一设定请求和响应的编码。可以将编码设置为UTF-8，例如： ```xml <filter> <filter-name>characterEncodingFilter</filter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> <init-param> <param-name>encoding</param-name> <param-value>UTF-8</param-value> </init-param> </filter> <filter-mapping> <filter-name>characterEncodingFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> ``` 2. 在@RequestMapping注解中设置produces属性，指定响应的编码，例如： ```java @RequestMapping(value = "/example", produces = "text/html; charset=UTF-8") ``` 3. 在方法参数上添加@RequestParam注解，指定请求参数的编码，例如： ```java @RequestMapping("/example") public String example(@RequestParam(value = "param", required = false) String param, Model model) { // 使用param参数 return "example"; } ``` 4. 使用@ResponseBody注解返回JSON格式数据时，在@RequestMapping注解上添加produces属性，指定返回的媒体类型和编码，例如： ```java @ResponseBody @RequestMapping(value = "/api/example", produces = "application/json; charset=UTF-8") public Map<String, Object> example() { // 返回JSON格式数据 return resultMap; } ``` 通过以上方式，可以有效解决Spring MVC中文乱码问题，确保数据的传输和显示正常。 ### 回答3： 在Spring MVC框架中，出现中文乱码问题的主要原因是字符编码设置不正确。为了解决这个问题，我们可以采取以下几种方法： 1. 在web.xml文件中配置字符编码过滤器(Filter)，将请求和响应的字符编码设置为UTF-8。示例如下： ```xml <filter> <filter-name>encodingFilter</filter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> <init-param> <param-name>encoding</param-name> <param-value>UTF-8</param-value> </init-param> <init-param> <param-name>forceEncoding</param-name> <param-value>true</param-value> </init-param> </filter> <filter-mapping> <filter-name>encodingFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> ``` 2. 在Spring MVC的配置文件中，配置视图解析器(ViewResolver)时，指定使用UTF-8编码。示例如下： ```xml <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/WEB-INF/views/" /> <property name="suffix" value=".jsp" /> <property name="contentType" value="text/html;charset=UTF-8" /> </bean> ``` 3. 在Controller方法中使用`@RequestMapping`注解的`produces`属性，设置响应的Content-Type为"application/json;charset=UTF-8"，确保响应的中文乱码问题被正确处理。示例如下： ```java @RequestMapping(value = "/example", produces = "application/json;charset=UTF-8") @ResponseBody public String example() { // 处理逻辑 } ``` 通过以上几种方法的组合使用，我们可以有效解决Spring MVC中文乱码问题，确保正确显示和处理中文字符。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值