Spring MVC 后端获取前端提交的json格式字符串并直接转换成control方法对应的参数对象

场景：

在web应用开发中，spring mvc凭借出现的性能和良好的可扩展性，导致使用日渐增多，成为事实标准，在日常的开发过程中，有一个很常见的场景：即前端通过ajax提交方式，提交参数为一个json对象的字符串，采用application/json的类型，在后端control中利用@RequestBody将json字符串直接转换成对应的Java对象，如：

var dataStr = '[{"id":1476,"name":"test"}]';
    $.ajax({
                url : '${request.contextPath}/test/jsonParam.json',
                data : dataStr,
                type : "POST",
                async : false,
                contentType : "application/json;charset=utf-8", //设置请求头信息
                success : function(data) {
                    console.log(data);
                    //alert(data);
                }
            });

在control，我们想直接在处理的方法中获取json字符串对应的对象，如：

@RequestMapping(value = "/jsonParam")
    public JSONObject handleJsonParam(WebRequest request, ModelMap model,@RequestBody User user) {
        System.out.println(user.getName());
        JSONObject jsonObject = JSONObject.parseObject("{"status":"ok"}");
        return jsonObject;
    }

在handleJsonParam中，我们希望一进入此方法，参数user对象就已经初始化，而且其对应的id,names属性已经分别被赋值为1476和test，减少json字符串与对象间的反系列化工作，提升开发人员的效率。

场景分析：

我们知道，spring mvc在根据requestmapping找对对应的control方法处理前，会根据请求参数及请求类型做一些数据转换，数据格式化及数据校验等工作，因此我们的解决思路就是在数据转换过程中，将前台请求传过来的json字符串转换成对应的对象，然后将此对象绑定到control方法的参数中。

解决方式：

方式一：最简单的方式，spring mvc为我们提供了一个MappingJackson2HttpMessageConverter类，用于帮助从json字符串转成java的对象，我们只需要在requestmappinghandleradpter中进行配置即可：

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
		<property name="messageConverters">
			<list>
				<ref bean="mappingJacksonHttpMessageConverter" />
			</list>
		</property>
	</bean>
	<bean id="mappingJacksonHttpMessageConverter"
		class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
		<property name="supportedMediaTypes">
			<list>
				<value>text/html;charset=UTF-8</value>
				<value>application/json;charset=utf-8</value>
			</list>
		</property>
	</bean>

此方式需要依赖以下三个包：jackson-core(2.4.0),jackson-databind(2.4.0),jackson-annotations(2.4.0)

 方式二：

 方式一对所有的json请求都会做如此转换，有时候我们只需要对具体的json字符串做转换或者我们希望控制转换的细节，可以自己创建一个类继承AbstractHttpMessageConverter并实现GenericHttpMessageConverter接口，通过重写canRead，support方法来控制可发序列化的对象类型，并重写read方法实现最终的转换。先看配置文件：

    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="com.web.converter.JsonRequestMessageConverter">
                <property name="supportedMediaTypes">
                    <list>
                        <value>application/json;charset=utf-8</value>
                    </list>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

此处我用的是mvc:annotation-driven配置方式，该标签简化了spring的配置，内部会注册默认的DefaultAnnotationHandlerMapping及AnnotationMethodHandlerAdapter示例，与方式一的配置效果类似。其中JsonRequestMessageConverter类如下：

import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Type;
import java.nio.charset.Charset;
import java.util.concurrent.atomic.AtomicReference;

import javax.servlet.http.HttpServletRequest;

import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.AbstractHttpMessageConverter;
import org.springframework.http.converter.GenericHttpMessageConverter;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.util.StringUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * 
 * @Description:json请求是对json格式的参数直接进行映射为对应的对象，control中可直接得到对应的对象
 * @Create time: 2015年9月21日下午3:47:55
 *
 */
public class JsonRequestMessageConverter extends AbstractHttpMessageConverter<Object> implements GenericHttpMessageConverter<Object> {
	private final static Charset UTF8 = Charset.forName("UTF-8");
	private final static String JSONP_FUNC_NAME = "callback";
	
	private Charset charset = UTF8;
	private String jsonpFuncName = JSONP_FUNC_NAME;
	private ObjectMapper objectMapper;
	
	public JsonRequestMessageConverter() {
		super(new MediaType("application", "json", UTF8), new MediaType("application", "*+json", UTF8));
		objectMapper = Jackson2ObjectMapperBuilder.json().build();
	}

	public void setJsonpFuncName(String jsonpFuncName) {
		this.jsonpFuncName = jsonpFuncName;
	}

	public void setCharset(Charset charset) {
		this.charset = charset;
	}

	private HttpServletRequest getRequest() {
		return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
	}

	private boolean requestJsonp(HttpServletRequest request) {
		return request.getRequestURI().endsWith(".jsonp");
	}

	private String getJsonpFunc(HttpServletRequest request) {
		String func = request.getParameter(jsonpFuncName);
		return StringUtils.isEmpty(func) ? "null" : func;
	}

	/**
	 * 判断前台请求提交的数据是否可以用此convert读
	 * type为control中标记为RequestBody的参数类型
	 * contextClass为对应请求的control类
	 * mediaType为自持的请求类型，如json、text等
	 * 
	 */
	@Override
	public boolean canRead(Type type, Class<?> contextClass, MediaType mediaType) {
		JavaType javaType = getJavaType(type, contextClass);
		AtomicReference<Throwable> causeRef = new AtomicReference<Throwable>();
		if (this.objectMapper.canDeserialize(javaType, causeRef) && canRead(mediaType)) {
			return true;
		}
		Throwable cause = causeRef.get();
		if (cause != null) {
			String msg = "Failed to evaluate deserialization for type " + javaType;
			if (logger.isDebugEnabled()) {
				logger.warn(msg, cause);
			}
			else {
				logger.warn(msg + ": " + cause);
			}
		}
		return false;
	}
	
	
	private JavaType getJavaType(Type type, Class<?> contextClass) {
		return this.objectMapper.getTypeFactory().constructType(type, contextClass);
	}
    
	/**
	 * 
	 * @Description:泛型读，将从前台传过来的json请求串映射为具体的参数对象
	 * @param type
	 * @param contextClass
	 * @param inputMessage
	 * @return
	 * @throws IOException
	 * @throws HttpMessageNotReadableException
	 * @see org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodArgumentResolver.readWithMessageConverters(HttpInputMessage, MethodParameter, Type)
	 * @see org.springframework.http.converter.GenericHttpMessageConverter#read(java.lang.reflect.Type, java.lang.Class, org.springframework.http.HttpInputMessage)
	 * @update1: 
	 *
	 */
	@Override
	public Object read(Type type, Class<?> contextClass, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
		try {
			return this.objectMapper.readValue(inputMessage.getBody(), this.getJavaType(type, contextClass));
		}
		catch (IOException ex) {
			throw new HttpMessageNotReadableException("Could not read JSON: " + ex.getMessage(), ex);
		}
	}
	
	/**
	 * 
	 * @Description:如果泛型读canRead方法返回false，则会调用AbstractHttpMessageConverter中的read方法，此方法会调用readInternal转普通jsonObject
	 * @param clazz
	 * @param inputMessage
	 * @return
	 * @throws IOException
	 * @throws HttpMessageNotReadableException
	 * @see org.springframework.http.converter.AbstractHttpMessageConverter#readInternal(java.lang.Class, org.springframework.http.HttpInputMessage)
	 * @update1: 
	 *
	 */
	@Override
	protected Object readInternal(Class<? extends Object> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
		try {
			return this.objectMapper.readValue(inputMessage.getBody(), this.getJavaType(clazz, null));
		}
		catch (IOException ex) {
			throw new HttpMessageNotReadableException("Could not read JSON: " + ex.getMessage(), ex);
		}
	}
	
	
	/**
	 * 
	 * @Description:定义此convert支持输出的对象类型，即control端返回的类型，此处支持json格式的字符串及JSONObject/JsonArray对象
	 * @param clazz
	 * @return
	 * @see org.springframework.http.converter.AbstractHttpMessageConverter#supports(java.lang.Class)
	 * @update1:
	 *
	 */
	@Override
	protected boolean supports(Class<?> clazz) {
		// 只处理control返回的String/JSONObject/JsonArray对象
		return String.class.isAssignableFrom(clazz) || JSON.class.isAssignableFrom(clazz);
	}
	
	/**
	 * 
	 * @Description:定义此convert可以输出的条件为json格式的字符串及JSONObject/JsonArray对象,且为json请求类型
	 * @param clazz
	 * @param mediaType
	 * @return
	 * @see org.springframework.http.converter.AbstractHttpMessageConverter#canWrite(java.lang.Class, org.springframework.http.MediaType)
	 * @update1:
	 *
	 */
	@Override
	public boolean canWrite(Class<?> clazz, MediaType mediaType) {
		return this.supports(clazz) && canWrite(mediaType);
    }
	

	/**
	 * 
	 * @Description:
	 * @param t
	 * @param outputMessage
	 * @throws IOException
	 * @throws HttpMessageNotWritableException
	 * @see	org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodProcessor.writeWithMessageConverters(T, MethodParameter, ServletServerHttpRequest, ServletServerHttpResponse)
	 * @see org.springframework.http.converter.AbstractHttpMessageConverter#writeInternal(java.lang.Object, org.springframework.http.HttpOutputMessage)
	 * @update1:
	 *
	 */
	@Override
	protected void writeInternal(Object t, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
		// 进来的t值只能是字符串或JSONObject/JsonArray格式
		OutputStream out = outputMessage.getBody();
		HttpServletRequest request = getRequest();
		StringBuilder buffer = new StringBuilder();
		boolean requestJsonp = requestJsonp(request);
		if (requestJsonp) {
			buffer.append(getJsonpFunc(request)).append('(');
		}
		buffer.append(resolveJsonString(t));
		if (requestJsonp) {
			buffer.append(");");
		}
		System.out.println("jsonvonvert:"+buffer);
		byte[] bytes = buffer.toString().getBytes(charset);
		out.write(bytes);
		out.flush();
	}
	
	private String resolveJsonString(Object t) throws HttpMessageNotWritableException{
		if(t instanceof JSON){
			return ((JSON)t).toJSONString();
		}else if(t instanceof String){
			return (String)t;
		}
		throw new HttpMessageNotReadableException("Not Json Object");
	}

}

　 

 方式三：

通过@InitBinder标签指定json字符串到具体Java对象类型间转换的处理类，这种方式需要了解类细节，不建议使用。

可能出现的问题：

有可能会出现如下两个问题：

问题1：control端能得到JsonObject，但是无法泛型到具体的对象，如上面的配置中如果是得到一个List<User>，那么从control方法的参数看到的list内部不是User对象，而是JsonObject；

问题2：有时输入或输出的json数据时会出现乱码。

问题原因：

从前端请求到后端处理，requestMappingHandlerAdapter需要通过requestMapping找到对应的方法，并在方法处理前对参数进行解析，如下图：

在resolverArgument方法体里，会做如下处理：

通过readWithMessageConverters将传过来的json串通过配置的convert类转成具体的对象，如json字符串到jsonObject，在通过binder对象将得到的对象转成泛型，如jsonObject到User对象，因此如果出现问题1，即没有转换成User对象，说明binder处理出现问题，如果出现问题2，说明得到解析得到arg对象时出现了问题，而解析此对象时根据预先配置的convert对象的，说明在转换过程中从request读取数据流出现了问题。

解决方式：

问题一解决：自己的转换类一定要实现实现GenericHttpMessageConverter接口，并在read方法中处理将json字符串到User对象的转换；

问题二解决：每一个converter都需要明确指定支持的MediaType，如：

public JsonRequestMessageConverter() {
        super(new MediaType("application", "json", UTF8), new MediaType("application", "*+json", UTF8));
        objectMapper = Jackson2ObjectMapperBuilder.json().build();
    }

convert默认的字符集的iso-8859,因此如果出现了乱码，需要在配置文件中明确指定字符编码，如：

<bean class="com.letv.shop.demoWeb.web.converter.JsonRequestMessageConverter">
                <property name="supportedMediaTypes">
                    <list>
                        <value>application/json;charset=utf-8</value>
                    </list>
                </property>
            </bean>

还有一点需要注意的是：对于上面的配置，如果是通过js发起ajax请求，需要加一行配置：

 <value>application/javascript;charset=UTF-8</value> 

特别是在IE下，因为IE下默认的js请求不会带charset，因此解析用的是默认的iso-8859,需要明确指定编码，如utf-8.

 

spring mvc具有精巧的设计，如果出现了问题，可以通过源码不断的调试进来，细致耐心，则问题自然就可以搞定了。