<mvc:annotation-driven>
<mvc:message-converters>
<bean class="com.showe.MyMessageConverter"/>
</mvc:message-converters>
</mvc:annotation-driven>
import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.PrettyPrinter;
import com.fasterxml.jackson.core.util.DefaultPrettyPrinter;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectWriter;
import com.google.common.collect.Lists;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.AbstractGenericHttpMessageConverter;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.util.StreamUtils;
import org.springframework.util.StringUtils;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Type;
import java.net.URLDecoder;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Map;
public class MyMessageConverter extends AbstractGenericHttpMessageConverter<Object> {
private Charset charset = Charset.forName("UTF-8");
protected ObjectMapper objectMapper;
private PrettyPrinter prettyPrinter = new DefaultPrettyPrinter();
public MyMessageConverter() {
this.objectMapper = Jackson2ObjectMapperBuilder.json().build();
this.setSupportedMediaTypes(Lists.newArrayList(MediaType.ALL, MediaType.APPLICATION_JSON, MediaType
.APPLICATION_JSON_UTF8, MediaType.APPLICATION_FORM_URLENCODED));
}
@Override
protected boolean supports(Class<?> clazz) {
return supportInternalAndHandle(clazz);
}
private boolean supportInternalAndHandle(Class<?> clazz) {
//这里的clazz是controller中的加有@RequestBody的入参,如果入参Dto类上有MyAnnotation注解,则支持转换
SecurityBody securityBody = AnnotationUtils.findAnnotation(clazz, MyAnnotation.class);
if (securityBody == null) {
return false;
}else{
return true;
}
}
/**
* Abstract template method that writes the actual body. Invoked from {@link #write}.
* @param t the object to write to the output message
* @param type the type of object to write (may be {@code null})
* @param outputMessage the HTTP output message to write to
* @throws IOException in case of I/O errors
* @throws HttpMessageNotWritableException in case of conversion errors
*/
@Override
protected void writeInternal(Object o, Type type, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
MediaType contentType = outputMessage.getHeaders().getContentType();
JsonEncoding jsonEncoding = getJsonEncoding(contentType);
JsonGenerator generator = objectMapper.getFactory().createGenerator(outputMessage.getBody(), jsonEncoding);
String outStr = objectMapper.writeValueAsString(o);
ObjectWriter writer = objectMapper.writer();
writer.with(prettyPrinter);
writer.writeValue(generator,outStr);
generator.flush();
}
private JsonEncoding getJsonEncoding(MediaType contentType) {
if(null != contentType && contentType.getCharset()!=null){
Charset charset = contentType.getCharset();
for (JsonEncoding jsonEncoding:JsonEncoding.values()){
if(charset.name().equals(jsonEncoding.name())){
return jsonEncoding;
}
}
}
return JsonEncoding.UTF8;
}
/**
* Abstract template method that reads the actual object. Invoked from {@link #read}.
* @param clazz the type of object to return
* @param inputMessage the HTTP input message to read from
* @return the converted object
* @throws IOException in case of I/O errors
* @throws HttpMessageNotReadableException in case of conversion errors
*/
@Override
protected Map<String,String> readInternal(Class<?> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
MediaType contentType = inputMessage.getHeaders().getContentType();
Charset charset = contentType.getCharset()!=null?contentType.getCharset():this.charset;
//String body = StreamUtils.copyToString(inputMessage.getBody(), charset);
String body = copyToString(inputMessage.getBody(),charset);
Map<String,String> inputMap = handleParameters(body);
return inputMap;
}
private Map<String,String> handleParameters(String body) throws UnsupportedEncodingException {
Map<String,String> reqMap = new HashMap<>();
String[] pairs = StringUtils.tokenizeToStringArray(body, "&");
for (String pair:pairs) {
int index = pair.indexOf("=");
if(-1 == index){
reqMap.put(URLDecoder.decode(pair, "UTF-8"), null);
}else {
String name = URLDecoder.decode(pair.substring(0,index),this.charset.name());
String value = URLDecoder.decode(pair.substring(index+1),this.charset.name());
reqMap.put(name,value);
}
}
return reqMap;
}
@Override
public Object read(Type type, Class<?> contextClass, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
return readInternal((Class) type, inputMessage);
}
private String copyToString(InputStream in,Charset charset) throws IOException {
if(null==in){
return "";
}
StringBuilder out = new StringBuilder();
char[] buffer = new char[1024];
InputStreamReader reader = new InputStreamReader(in);
int len = -1;
while ((len = reader.read(buffer)) != -1){
out.append(buffer,0,len);
}
return out.toString();
}
}
