GVKun编程网logo

spring MVC ajax 总是 error（springmvc ajax请求）

15

这篇文章主要围绕springMVCajax总是error和springmvcajax请求展开，旨在为您提供一份详细的参考资料。我们将全面介绍springMVCajax总是error的优缺点，解答spr

这篇文章主要围绕spring MVC ajax 总是 error和springmvc ajax请求展开，旨在为您提供一份详细的参考资料。我们将全面介绍spring MVC ajax 总是 error的优缺点，解答springmvc ajax请求的相关问题，同时也会为您带来08-SpringMvc-Ajax、2.ajax+springmvc+json、Ajax SpringMVC 上传文件、Ajax 响应中文乱码 [SpringMVC 使用 @ResponseBody 处理 Ajax 请求]的实用方法。

本文目录一览：

spring MVC ajax 总是 error（springmvc ajax请求）

spring MVC ajax 总是 error（springmvc ajax请求）

在以 springMVC 为框架的项目中，ajax 请求总是返回 error。在 error 方法中输出的 msg 为

[Object object] ，而我的 dataType 为 json，怎么会返回对象呢？

在 controller 中我用了 @ResponseBody 注解，方法返回的类型为 Map，说明 ResponseBody 没有把 Map 转为 json。说明 spring-servlet.xml 配置文件没有配置注解转换 json 的配置。

打开 spring-servlet.xml 文件：

只有 <bean />

修改配置：

<bean >
        <property name="messageConverters">
            <list>
                <ref bean="stringHttpMessageConverter" />
                <ref bean="mappingJacksonHttpMessageConverter" />
            </list>
        </property>
    </bean>
    <bean id="stringHttpMessageConverter"/>

    <bean id="mappingJacksonHttpMessageConverter"/>

正确返回 json。

08-SpringMvc-Ajax

08-SpringMvc-Ajax

1、简介

  • AJAX = Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）。

  • AJAX 是一种在无需重新加载整个网页的情况下，能够更新部分网页的技术。

  • Ajax 不是一种新的编程语言，而是一种用于创建更好更快以及交互性更强的Web应用程序的技术。

  • 在 2005 年，Google 通过其 Google Suggest 使 AJAX 变得流行起来。Google Suggest能够自动帮你完成搜索单词。

  • Google Suggest 使用 AJAX 创造出动态性极强的 web 界面：当您在谷歌的搜索框输入关键字时，JavaScript 会把这些字符发送到服务器，然后服务器会返回一个搜索建议的列表。

  • 就和国内百度的搜索框一样!

  • 传统的网页(即不用ajax技术的网页)，想要更新内容或者提交一个表单，都需要重新加载整个网页。

  • 使用ajax技术的网页，通过在后台服务器进行少量的数据交换，就可以实现异步局部更新。

  • 使用Ajax，用户可以创建接近本地桌面应用的直接、高可用、更丰富、更动态的Web用户界面。

2、伪造Ajax

我们可以使用前端的一个标签来伪造一个ajax的样子。iframe标签

1、新建一个module ：sspringmvc-06-ajax ， 导入web支持！

2、编写一个 ajax-frame.html 使用 iframe 测试，感受下效果

<!DOCTYPE html>
<html>
<head lang="en">
   <Meta charset="UTF-8">
   <title>kuangshen</title>
</head>
<body>

<script type="text/javascript">
   window.onload = function(){
       var myDate = new Date();
       document.getElementById('currentTime').innerText =myDate.getTime();
  };

   function LoadPage(){
       var targetUrl =  document.getElementById('url').value;
       console.log(targetUrl);
       document.getElementById("iframePosition").src = targetUrl;
  }

</script>

<div>
   <p>请输入要加载的地址：<span id="currentTime"></span></p>
   <p>
       <input id="url" type="text" value="https://www.baidu.com/"/>
       <input type="button" value="提交" onclick="LoadPage()">
   </p>
</div>

<div>
   <h3>加载页面位置：</h3>
   <iframe id="iframePosition"></iframe>
</div>

</body>
</html>

3、使用IDEA开浏览器测试一下！

利用AJAX可以做：

  • 注册时，输入用户名自动检测用户是否已经存在。

  • 登陆时，提示用户名密码错误

  • 删除数据行时，将行ID发送到后台，后台在数据库中删除，数据库删除成功后，在页面DOM中将数据行也删除。

  • …等等

3、jQuery.ajax

纯JS原生实现Ajax我们不去讲解这里，直接使用jquery提供的，方便学习和使用，避免重复造轮子，有兴趣的同学可以去了解下JS原生XMLHttpRequest ！

Ajax的核心是XMLHttpRequest对象(XHR)。XHR为向服务器发送请求和解析服务器响应提供了接口。能够以异步方式从服务器获取新数据。

jQuery 提供多个与 AJAX 有关的方法。

通过 jQuery AJAX 方法，您能够使用 HTTP Get 和 HTTP Post 从远程服务器上请求文本、HTML、XML 或 JSON – 同时您能够把这些外部数据直接载入网页的被选元素中。

jQuery 不是生产者，而是大自然搬运工。

jQuery Ajax本质就是 XMLHttpRequest，对他进行了封装，方便调用！

jQuery.ajax(...)
      部分参数：
            url：请求地址 *(常用)
            type：请求方式，GET、POST（1.9.0之后用method） *(常用)
        headers：请求头
            data：要发送的数据  *(常用)
    contentType：即将发送信息至服务器的内容编码类型(默认: "application/x-www-form-urlencoded; charset=UTF-8")
          async：是否异步
        timeout：设置请求超时时间（毫秒）
      beforeSend：发送请求前执行的函数(全局)
        complete：完成之后执行的回调函数(全局)
        success：成功之后执行的回调函数(全局)  *(常用)
          error：失败之后执行的回调函数(全局)  *(常用)
        accepts：通过请求头发送给服务器，告诉服务器当前客户端可接受的数据类型
        dataType：将服务器端返回的数据转换成指定类型
          "xml": 将服务器端返回的内容转换成xml格式
          "text": 将服务器端返回的内容转换成普通文本格式
          "html": 将服务器端返回的内容转换成普通文本格式，在插入DOM中时，如果包含JavaScript标签，则会尝试去执行。
        "script": 尝试将返回值当作JavaScript去执行，然后再将服务器端返回的内容转换成普通文本格式
          "json": 将服务器端返回的内容转换成相应的JavaScript对象
        "jsonp": JSONP 格式使用 JSONP 形式调用函数时，如 "myurl?callback=?" jQuery 将自动替换 ? 为正确的函数名，以执行回调函数

我们来个简单的测试，使用最原始的HttpServletResponse处理 , .最简单 , 最通用

1、配置web.xml 和 springmvc的配置文件，复制上面案例的即可 【记得静态资源过滤和注解驱动配置上】

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <context:component-scan base-package="com.shule"/>
    <mvc:default-servlet-handler/>
    <mvc:annotation-driven/>
    <bean>
        <property name="prefix" value="/WEB-INF/jsp"/>
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

2、编写一个AjaxController

@Controller
public class AjaxController {

   @RequestMapping("/a1")
   public void ajax1(String name , HttpServletResponse response)throws IOException {
       if ("admin".equals(name)){
           response.getWriter().print("true");
      }else{
           response.getWriter().print("false");
      }
  }

}

3、导入jquery ， 可以使用在线的CDN ， 也可以下载导入

//cdn
<script src="https://code.jquery.com/jquery-3.1.1.min.js"></script>
//导入的
<script src="${pageContext.request.contextpath}/statics/js/jquery-3.1.1.min.js"></script>

4、编写index.jsp测试

<%--
  Created by IntelliJ IDEA.
  User: 22529
  Date: 2021/1/24
  Time: 17:11
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
    <script src="https://code.jquery.com/jquery-3.1.1.min.js"></script>
    <script>
      function a1() {
          $.post({
            url: "${pageContext.request.contextpath}/a1",
            data:{'name':$("#txtName").val()},
            success:function (data) {
              alert(data)
            }
          })
      }
    </script>
  </head>
  <body>
    <%--onblur：失去焦点触发事件--%>
    用户名:<input type="text" id="txtName" οnblur="a1()"/>
  </body>
</html>

5、启动tomcat测试！打开浏览器的控制台，当我们鼠标离开输入框的时候，可以看到发出了一个ajax的请求！是后台返回给我们的结果！测试成功！

4、SpringMvc实现

实体类user

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

   private String name;
   private int age;
   private String sex;

}

我们来获取一个集合对象，展示到前端页面

@RequestMapping("/a2")
public List<User> ajax2(){
    List<User> list = new ArrayList<User>();
    list.add(new User("余香1号",3,"男"));
    list.add(new User("余香2号",3,"男"));
    list.add(new User("余香3号",3,"男"));
    return list; //由于@RestController注解，将list转成json格式返回
}

前端页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
  <title>Title</title>
</head>
<body>
<input type="button" id="btn" value="获取数据"/>
<table width="80%" align="center">
  <tr>
    <td>姓名</td>
    <td>年龄</td>
    <td>性别</td>
  </tr>
  <tbody id="content">
  </tbody>
</table>

<script src="https://code.jquery.com/jquery-3.1.1.min.js"></script>
<script>

  $(function () {
    $("#btn").click(function () {
      $.post("${pageContext.request.contextpath}/a2",function (data) {
        console.log(data)
        var html="";
        for (let i = 0; i <data.length ; i++) {
          html+= "<tr>" +
                  "<td>" + data[i].name + "</td>" +
                  "<td>" + data[i].age + "</td>" +
                  "<td>" + data[i].sex + "</td>" +
                  "</tr>"
        }
        $("#content").html(html);
      });
    })
  })
</script>
</body>
</html>

成功实现了数据回显！可以体会一下Ajax的好处！

2.ajax+springmvc+json

2.ajax+springmvc+json

1、表单验证/字典/往url传值

<input type="text" id="txt1" onkeyup="showHint(this.value)" />

<span id="txtHint"></span>

xmlhttp.open("GET","/ajax/gethint.asp?q="+str,true);

document.getElementById("txtHint").innerHTML=xmlhttp.responseText;

http://www.w3school.com.cn/tiy/t.asp?f=ajax_suggest


2、ajax+springmvc+json 前端接收mvc传递来的json数据

<%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
  <head>
    <Meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>ajax for springMVC</title>
    <script type="text/javascript" src="js/jquery-1.8.3.min.js"></script>
    <script type="text/javascript">
      $(function() {
        $("#click").click(function() {
          $.ajax( {
            type : "GET",url : "ajax.do",data : "name=zhangsan&age=20",dataType: "text",success : function(msg) {
           //jquery解析json
            var obj = $.parseJSON(msg) 
            alert(obj.name); 
            alert(obj.age);
            $("#show").val(msg);
            }
          });
        });
      });
    </script>
  </head>
  <body>
    <input id="click" type="button" value="click to show person" />
    <input id="show" />
  </body>
</html>
       
    @RequestMapping(value = "ajax.do",method = RequestMethod.GET) 
    public void ajax(@modelattribute Person person,PrintWriter printWriter) { 
        String jsonString = JSON.toJSONString(person,SerializerFeature.PrettyFormat); 
        printWriter.write(jsonString); 
        printWriter.flush(); 
        printWriter.close(); 
    }


项目地址：http://download.csdn.net/detail/nickfover/8249075



3、ajax+springmvc+json ajax向springmvc传递json

<%@ page language="java" contentType="text/html; charset=UTF-8"  
    pageEncoding="UTF-8"%>  
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
<html>  
<head>  
<script type="text/javascript" src="js/jquery-1.8.3.min.js"></script>  
<Meta http-equiv="Content-Type" content="text/html; charset=UTF-8">  
<title>Insert title here</title>  
<script type="text/javascript">  
  
    $(document).ready(function(){  
        //传递字符串格式json对象到后台（一个json对象）  
        $("#resolveJsonObject").click(function(){  
            var userName =encodeURI($("#userName").attr("value"));  
            var age = encodeURI($("#age").attr("value"));  
              //向mvc传递json对象
            var user = {userName:userName,age:age};  
            var aMenu  = encodeURI(JSON.stringify(user));  
  
            $.ajax({  
                 url:"resolveJsonObject",data:"orderjson=" + aMenu,success:function(data){  
                      
                }  
            });  
        });  
          
        //传递json数组到后台  
        $("#resolveJsonArray").click(function(){  
            var userName =encodeURI($("#userName").attr("value"));  
            var age = encodeURI($("#age").attr("value"));  
              
            //数组开始  
            var user1 = {userName:userName,age:age};  
            var allMenu={  
                "menu":[ ]  
                };  
            allMenu.menu.push(user1);   
            var allMenu1 = encodeURI(JSON.stringify(allMenu));  
              
            $.ajax({  
                //json数组  
                 url:"resolveJsonArray",data:"orderjson=" + allMenu1,success:function(data){  
                      
                }  
            });  
        });  
          
        //接收后台的json在前台解析  
        $("#resolveJson").click(function(){  
              
        	 $.ajax({  
                 //解析从后台返回的json数据  
                 url:"resolveJson",type:"post",success:function(data){  
                	 var arr=eval(data); 
                     for(var m = 0;m<arr.length;m++){  
                         alert(arr[m].user.userName);  
                     }  
                 }  
             });  
        });  
    });  
  
</script>  
</head>  
<body>  
    <h1>json添加用户</h1>   
      
    姓名：<input id="userName" type="text" name="userName">  
    年龄:<input id="age" type="text" name="age"><br>  
    <input type="button" id="resolveJsonObject" value="json对象">  
    <input type="button" id="resolveJsonArray" value="json数组">  
    <input type="button" id="resolveJson" value="前端解析json字符串">  
    
</body>  
</html>  


package org.nick.web;

import java.io.IOException;
import java.io.PrintWriter;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

import org.nick.demo.Person;
import org.nick.demo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.modelattribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;


@Controller
public class BaseController {
	@RequestMapping("/link")
	public String fun3(){
		return "/link";
	}
	 @RequestMapping("toAjax.do") 
	    public String toAjax() { 
	        return "ajax"; 
	    } 
	       
    @RequestMapping(value = "ajax.do",SerializerFeature.PrettyFormat); 
        printWriter.write(jsonString); 
        printWriter.flush(); 
        printWriter.close(); 
    } 
    //接收前台传过来的字符串格式的json对象，在后台进行解析  
    @RequestMapping("/resolveJsonObject"    )  
    public void resolveJsonObject(HttpServletRequest request,HttpServletResponse response) throws IOException {  
        //解码  
        String str = URLDecoder.decode(request.getParameter("orderjson"),"UTF-8");  
        JSONObject jb=new JSONObject();   
        //将json格式的字符串转换为json对象，并取得该对象的“userName”属性值  
        String o=(String)jb.fromObject(str).get("userName");  
        System.out.println(o);  
    }   
      
     //传递json数组字符串  
    @RequestMapping("/resolveJsonArray" )  
    public void resolveJsonArray(HttpServletRequest request,HttpServletResponse response) throws IOException {  
        //解码，为了解决中文乱码  
        String str = URLDecoder.decode(request.getParameter("orderjson"),"UTF-8");  
        JSONObject jb=new JSONObject();  
        //将json格式的字符串转换为json数组对象  
        JSONArray array=(JSONArray)jb.fromObject(str).get("menu");  
        //取得json数组中的第一个对象  
        JSONObject o = (JSONObject) array.get(0);//获得第一个array结果  
        //取出json数组中第一个对象的“userName”属性值  
        String name=o.get("userName").toString();//获得属性值  
        System.out.println(name);  
    }   
      
    //通过该函数返回json格式的数据，在前台通过JQuery进行解析  
    @RequestMapping("/resolveJson"  )  
    public void resolveJson(HttpServletRequest request,HttpServletResponse response) throws IOException {  
          
        List m = (List) new  ArrayList();  
        JSONArray jsons = new JSONArray();  
        for(int i=0;i<10;i++){  
            User user = new User();  
            user.setUserName("name_" + i);  
            m.add(user);  
        }  
          
        for(int j=0;j<m.size();j++){  
            JSONObject jsonObject = new JSONObject();  
            jsonObject.put("user",m.get(j));  
            jsons.add(jsonObject);  
        }  
        //火狐浏览器要添加如下格式设置utf-8
        response.setContentType("text/html;charset=UTF-8");
        System.out.println(jsons.toString());
        response.getWriter().print(jsons.toString()) ;   
    }   
      
    @RequestMapping("/toJson"   )   
    public String toJson() {  
        return "/json";  
    }  
}

http://localhost:8080/springmvc/link

项目下载：http://download.csdn.net/detail/nickfover/8251017

Ajax SpringMVC 上传文件

Ajax SpringMVC 上传文件

jsp 文件

	<form id="uploadForm" method="post" name="fileinfo"
		enctype="multipart/form-data">
		<input type="file" id="image" name="image"> <input
			type="button"onclick="upload()" value="上传图片">
	</form>

Ajax写法 
	function upload() {
		var uploadResult = document.getElementById("upload-result");
		uploadResult.style.color = "green";
		uploadResult.innerHTML = "正在上传.....";
		var formData = new FormData($("uploadForm")[0]);
		formData.append('Content-Type','multipart/form-data');
		formData.append('image',$('input[type=file]')[0].files[0]);
		$.ajax({
			url : "${pageContext.request.contextpath}/api/v1/file",type : 'POST',data : formData,dataType : 'json',contentType : false,processData : false,cache : false,//防止缓存
			error : function(data) {
				alert("请求失败，网络异常")
				console.log(data);
			},success : function(data) {
				console.log(data);
				var code = data.status;
				if (code == 200) {
					uploadResult.style.color = "green";
					uploadResult.innerHTML = "上传成功";
					imgurl = data.data;
				} else {
					uploadResult.style.color = "red";
					uploadResult.innerHTML = "上传失败";
				}
			}

		});
	}


SpringMVC服务器端写法：

@RequestMapping(method = RequestMethod.POST)
	@ResponseBody
	public Object uploadFile(HttpServletRequest request) {
		CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver(
				request.getSession().getServletContext());
		// 先判断request中是否包涵multipart类型的数据，
		String fileUrl = "";
		if (multipartResolver.isMultipart(request)) {
			// 再将request中的数据转化成multipart类型的数据
			MultipartHttpServletRequest multiRequest = (MultipartHttpServletRequest) request;
			Iterator<String> iter = multiRequest.getFileNames();
			while (iter.hasNext()) {
				multipartfile file = multiRequest.getFile((String) iter.next());
				if (file != null) {
					try {
						GridFSInputFile inputFile = fileService.save(file.getInputStream(),file.getoriginalFilename());
						if (inputFile == null) {
							return StatusConfig.FileUploadError;
						} else {
							fileUrl = inputFile.getId().toString();
							System.out.println("fileUrll" + (fileUrl));
						}
					} catch (IllegalStateException | IOException e) {
						return StatusConfig.FileUploadError;
					}
				}
			}
			HashMap<String,Object> hashMap = new HashMap<String,Object>();
			fileUrl = this.getHttpFilePath() + fileUrl;
			hashMap.put(ConstantsKey.STATUS,200);
			hashMap.put(ConstantsKey.DATA,fileUrl);
			String json = ConvertUtils.as().toJson(hashMap);
			System.out.println("photourl:" + json);
			return json;
		} else {
			return StatusConfig.RequestTypeError;
		}
	}

Ajax 响应中文乱码 [SpringMVC 使用 @ResponseBody 处理 Ajax 请求]

Ajax 响应中文乱码 [SpringMVC 使用 @ResponseBody 处理 Ajax 请求]

Spring3.0 MVC @ResponseBody 的作用是把返回值直接写到 HTTP response body 里。

Spring 使用 AnnotationMethodHandlerAdapter 的 handleResponseBody 方法，AnnotationMethodHandlerAdapter 使用 request header 中 "Accept" 的值和 messageConverter 支持的 MediaType 进行匹配，然后会用 "Accept" 的第一个值写入 response 的 "Content-Type"。
一般的请求都是通过浏览器进行的，request header 中 "Accept" 的值由浏览器生成。

有人跟踪 @ResponseBody 的实现类发现其默认的编码是 iso-8859-1,

解决办法，在 spring mvc 的配置文件中手工配置 bean：
<!-- 启动 SpringMVC 的注解功能，完成请求和注解 POJO 的映射 -->
<bean>
<propertyname="messageConverters">
<list>
<bean>
<propertyname="supportedMediaTypes">
<list>
<value>text/html;charset=UTF-8</value>
</list>
</property>
</bean>
</list>
</property>
</bean>


这样通过配置 AnnotationMethodHandlerAdapter 类 messageConverters 属性来指定编码。
记住，需要把 bean 部分加入到 <context:component-scan base-package="com.zlscw.mvc" /> 前面，

这样就可以在 jquery 中直接调用而不出现乱码了。


------------------------------------------- 这篇文章说的很到位

近日用 Spring3 的 MVC 写东西，深感其之于 Webwork/Struts2 的便利，但是在通过 @ResponseBody 这个 annotation 输出一个 json 字符串的时候，发现页面上获得的 json 字符串中文字符出现了乱码的现象。通过 firefox 观察返回的字符串，中文部分全部变成了？？？？？？？的形式，初步判定是返回时，spring 处理 @ResponseBody 使用了错误的编码。

因为我在 web.xml 中已经配置了 Spring 的 CharacterEncodingFilter，并且强制将 request 和 response 的编码都指定为 utf-8，所以出现乱码的原因肯定是在 Spring 内部某处的逻辑了。

把 log4j 中关于 spring 的输出级别调为 debug，通过访问出问题的地址，发现 Spring 在处理 @ResponseBody 这个 annotation 的时候，org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter 使用了 org.springframework.http.converter.StringHttpMessageConverter 进行处理，于是打开了 Spring 的源码，看看这个类究竟做了哪些事情。

不看不要紧，一看吓一跳，里面竟然是这样定义其默认编码的：

1 publicstaticfinalCharset DEFAULT_CHARSET = Charset.forName("ISO-8859-1");

顿时心生 N 种不爽：堂堂 Spring，竟然还在其中用西欧字符集作为其默认编码，坑爹啊！（很多 spring 的类中，涉及编码的已经都是 utf-8 了，比如负责 JSON 视图的 MappingJacksonHttpMessageConverter，就是默认使用 UTF-8）。本来想直接修改 spring 的源码重新打包一个 jar 出来，后来看 spring 的 java doc 发现，其父类 org.springframework.http.converter.AbstractHttpMessageConverter 中的 getDefaultContentType 方法是可以重写的：

By default, this returns the first element of the supportedMediaTypes property, if any. Can be overridden in subclasses.

心想这下就简单了，你的 DEFAULT_CHARSET 不是 final 么？那我自己继承一个出来，按照我的需求定义为 utf-8 不就得了？代码如下：

01 publicclassUTF8StringHttpMessageConverter extendsStringHttpMessageConverter {
02
03 privatestaticfinalMediaType utf8 = newMediaType("text", "plain",
04 Charset.forName("UTF-8"));
05 privatebooleanwriteAcceptCharset = true;
06
07 @Override
08 protectedMediaType getDefaultContentType(String dumy) {
09 returnutf8;
10 }
11
12 protectedList<Charset> getAcceptedCharsets() {
13 returnArrays.asList(utf8.getCharSet());
14 }
15
16 protectedvoidwriteInternal(String s, HttpOutputMessage outputMessage)
17 throwsIOException {
18 if(this.writeAcceptCharset) {
19 outputMessage.getHeaders().setAcceptCharset(getAcceptedCharsets());
20 }
21 Charset charset = utf8.getCharSet();
22 FileCopyUtils.copy(s, newOutputStreamWriter(outputMessage.getBody(),
23 charset));
24 }
25
26 publicbooleanisWriteAcceptCharset() {
27 returnwriteAcceptCharset;
28 }
29
30 publicvoidsetWriteAcceptCharset(booleanwriteAcceptCharset) {
31 this.writeAcceptCharset = writeAcceptCharset;
32 }
33
34 }

然后，在 spring 的配置文件中添加如下 bean 声明，用自己写的类替换掉原有的 StringHttpMessageConverter：

1 <beanclass="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
2 <propertyname="messageConverters">
3 <list>
4 <beanid="utf8StringHttpMessageConverter"class="xxx.xxx.UTF8StringHttpMessageConverter"/>
5 </list>
6 </property>
7 </bean>

再看通过 @ResponseBody 返回的 json 字符串，终于中文都可以正常显示了。


------------------------------------------- 下面有一些解释

但我们一般会在标注 @ResponseBody 的方法上返回 String 或 byte [] 类型的结果，期望的 "Content-Type" 的值应为 "text/plain" 或 "application/octet-stream"。
这样导致了浏览器不能正确处理返回的内容。
实际上 Spring 在用 HttpMessageConverter 处理的过程中首先会判断 response header 中有没有写入 "Content-Type"，如果没有写入的话才会使用 request header 中 "Accept" 的第一个值。
但是由于 Spring 对 HttpServletResponse 进行了封装，实际上使用的是 ServletServerHttpResponse，这个类有一个对真正的 HttpServletResponse 的引用。
判断 response header 的过程中使用的是 ServletServerHttpResponse 的 getHeaders () 方法，但该方法并没有返回真正的 HttpServletResponse 中的 header。（这应该有问题吧？）
所以我们虽然可以在 Controller 的方法中加入对 HttpServletResponse 的引用，然后设置 "Content-Type" 的值，但是并不会起作用。
来处理 @ResponseBody，该类再使用一些 HttpMessageConverter 来具体处理信息。
Chrome 生成的值为 application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,**
所以最后写入 response 中 "Content-Type" 的值为 "application/xml" 或 "application/x-ms-application"。


------------------------------------------------- 其实这个注解完全可以不用，直接使用 response 往输出流里面写。

使用 jQuery ajax 调用的返回 json，中文乱码问题

Jquery ：

$.ajax({
url: ''/test/testAction.do?method=test'',
type: ''POST'',
dataType: ''json'',
timeout: 5000,
async: false,
error: function(){
alert ('' 获取数据失败！'');
},
success: function(json){
jsObject= eval_r(json);
}
});
return jsObject;


JSONArray json = JSONArray.fromObject (SysList);//SysList 是一个 List
// 设置 response 的 ContentType 解决中文乱码
response.setContentType("text/html;charset=UTF-8");
response.getWriter().print(json.toString());
return null;

今天关于spring MVC ajax 总是 error和springmvc ajax请求的介绍到此结束，谢谢您的阅读，有关08-SpringMvc-Ajax、2.ajax+springmvc+json、Ajax SpringMVC 上传文件、Ajax 响应中文乱码 [SpringMVC 使用 @ResponseBody 处理 Ajax 请求]等更多相关知识的信息可以在本站进行查询。

本文标签：

上一篇java访问oracle时服务名（java oracle url）

下一篇requireJS-build.js

相关文章