【小家Spring】Spring MVC容器的web九大组件之---HandlerAdapter源码详解---HttpMessageConverter 消息转换器详解

<mvc:annotation-driven>
    <mvc:message-converters>
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <property name="supportedMediaTypes">
                <list>
                    <value>text/plain;charset=UTF-8</value>
                    <value>text/html;charset=UTF-8</value>
                </list>
             </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

public interface HttpMessage {
	// Return the headers of this message
	HttpHeaders getHeaders();
}

public interface HttpInputMessage extends HttpMessage {
	InputStream getBody() throws IOException;
}
public interface HttpOutputMessage extends HttpMessage {
	OutputStream getBody() throws IOException;
}

public interface HttpRequest extends HttpMessage {
	@Nullable
	default HttpMethod getMethod() {
		// 可议根据String类型的值  返回一个枚举
		return HttpMethod.resolve(getMethodValue());
	}
	String getMethodValue();
	// 可以从请求消息里  拿到URL
	URI getURI();
}

// @since 3.0  Spring3.0后推出的   是个泛型接口
// 策略接口，指定可以从HTTP请求和响应转换为HTTP请求和响应的转换器
public interface HttpMessageConverter<T> {

	// 指定转换器可以读取的对象类型，即转换器可将请求信息转换为clazz类型的对象
	// 同时支持指定的MIME类型(text/html、application/json等)
	boolean canRead(Class<?> clazz, @Nullable MediaType mediaType);
	// 指定转换器可以将clazz类型的对象写到响应流当中，响应流支持的媒体类型在mediaType中定义
	boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType);
	// 返回当前转换器支持的媒体类型~~
	List<MediaType> getSupportedMediaTypes();

	// 将请求信息转换为T类型的对象 流对象为：HttpInputMessage
	T read(Class<? extends T> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException;
	// 将T类型的对象写到响应流当中，同事指定响应的媒体类型为contentType 输出流为：HttpOutputMessage 
	void write(T t, @Nullable MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException;
}

// @since 3.0
public class FormHttpMessageConverter implements HttpMessageConverter<MultiValueMap<String, ?>> {

	// 默认UTF-8编码  MediaType为：application/x-www-form-urlencoded
	public static final Charset DEFAULT_CHARSET = StandardCharsets.UTF_8;
	private static final MediaType DEFAULT_FORM_DATA_MEDIA_TYPE = new MediaType(MediaType.APPLICATION_FORM_URLENCODED, DEFAULT_CHARSET);
	
	// 缓存下它所支持的MediaType们
	private List<MediaType> supportedMediaTypes = new ArrayList<>();
	// 用于二进制内容的消息转换器们~~~ 毕竟此转换器还支持`multipart/form-data`这种  可以进行文件下载~~~~~
	private List<HttpMessageConverter<?>> partConverters = new ArrayList<>();

	private Charset charset = DEFAULT_CHARSET;
	@Nullable
	private Charset multipartCharset;

	// 唯一的一个构造函数~
	public FormHttpMessageConverter() {
		// 默认支持处理两种MediaType：application/x-www-form-urlencoded和multipart/form-data
		this.supportedMediaTypes.add(MediaType.APPLICATION_FORM_URLENCODED);
		this.supportedMediaTypes.add(MediaType.MULTIPART_FORM_DATA);

		StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter();
		stringHttpMessageConverter.setWriteAcceptCharset(false);  // see SPR-7316

		// === 它自己不仅是个转换器，还内置了这三个转换器 至于他们具体处理那种消息，请看下面 都有详细说明 ==
		// 注意：这些消息转换器都是去支持part的，支持文件下载
		this.partConverters.add(new ByteArrayHttpMessageConverter());
		this.partConverters.add(stringHttpMessageConverter);
		this.partConverters.add(new ResourceHttpMessageConverter());

		// 这是为partConverters设置默认的编码~~~
		applyDefaultCharset();
	}
	// 省略属性额get/set方法
	
	// 从这可以发现，只有Handler的入参类型是是MultiValueMap它才会去处理~~~~
	@Override
	public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType) {
		if (!MultiValueMap.class.isAssignableFrom(clazz)) {
			return false;
		}
		// 若没指定MedieType  会认为是可读的~
		if (mediaType == null) {
			return true;
		}
		// 显然，只有我们Supported的MediaType才会是true（当然multipart/form-data例外，此处是不可读的）
		for (MediaType supportedMediaType : getSupportedMediaTypes()) {
			// We can't read multipart....
			if (!supportedMediaType.equals(MediaType.MULTIPART_FORM_DATA) && supportedMediaType.includes(mediaType)) {
				return true;
			}
		}
		return false;
	}

	// 注意和canRead的区别，有点对着干的意思~~~
	@Override
	public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType) {
		if (!MultiValueMap.class.isAssignableFrom(clazz)) {
			return false;
		}
		// 如果是ALL 说明支持所有的类型  那就恒返回true  当然null也是的
		if (mediaType == null || MediaType.ALL.equals(mediaType)) {
			return true;
		}
		for (MediaType supportedMediaType : getSupportedMediaTypes()) {
			// isCompatibleWith是否是兼容的
			if (supportedMediaType.isCompatibleWith(mediaType)) {
				return true;
			}
		}
		return false;
	}

	// 把输入信息读进来，成为一个 MultiValueMap<String, String>
	// 注意：此处发现class这个变量并没有使用~
	@Override
	public MultiValueMap<String, String> read(@Nullable Class<? extends MultiValueMap<String, ?>> clazz,
			HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {

		// 拿到请求的ContentType请求头~~~~
		MediaType contentType = inputMessage.getHeaders().getContentType();
		// 这里面 编码放在contentType里面  若没有指定  走默认的编码
		// 类似这种形式就是我们自己指定了编码：application/json;charset=UTF-8
		Charset charset = (contentType != null && contentType.getCharset() != null ? contentType.getCharset() : this.charset);
		
		// 把body的内容读成字符串~
		String body = StreamUtils.copyToString(inputMessage.getBody(), charset);
		// 用"&"分隔   因为此处body一般都是hello=world&fang=shi这样传进来的
		String[] pairs = StringUtils.tokenizeToStringArray(body, "&");
		MultiValueMap<String, String> result = new LinkedMultiValueMap<>(pairs.length);

		// 这个就不说了，就是把键值对保存在map里面。注意：此处为何用多值Map呢？因为一个key可能是会有多个value的
		for (String pair : pairs) {
			int idx = pair.indexOf('=');
			if (idx == -1) {
				result.add(URLDecoder.decode(pair, charset.name()), null);
			}
			else {
				String name = URLDecoder.decode(pair.substring(0, idx), charset.name());
				String value = URLDecoder.decode(pair.substring(idx + 1), charset.name());
				result.add(name, value);
			}
		}
		return result;
	}

}

public abstract class AbstractHttpMessageConverter<T> implements HttpMessageConverter<T> {

	// 它主要内部维护了这两个属性，可议构造器赋值，也可以set方法赋值~~
	private List<MediaType> supportedMediaTypes = Collections.emptyList();
	@Nullable
	private Charset defaultCharset;

	// supports是个抽象方法，交给子类自己去决定自己支持的转换类型~~~~
	// 而canRead(mediaType)表示MediaType也得在我支持的范畴了才行（入参MediaType若没有指定，就返回true的）
	@Override
	public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType) {
		return supports(clazz) && canRead(mediaType);
	}

	// 原理基本同上，supports和上面是同一个抽象方法  所以我们发现并不能入参处理Map，出餐处理List等等
	@Override
	public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType) {
		return supports(clazz) && canWrite(mediaType);
	}


	// 这是Spring的惯用套路:readInternal  虽然什么都没做，但我觉得还是挺有意义的。Spring后期也非常的好扩展了~~~~
	@Override
	public final T read(Class<? extends T> clazz, HttpInputMessage inputMessage)
			throws IOException, HttpMessageNotReadableException {
		return readInternal(clazz, inputMessage);
	}


	// 整体上就write方法做了一些事~~
	@Override
	public final void write(final T t, @Nullable MediaType contentType, HttpOutputMessage outputMessage)
			throws IOException, HttpMessageNotWritableException {

		final HttpHeaders headers = outputMessage.getHeaders();
		// 设置一个headers.setContentType 和 headers.setContentLength
		addDefaultHeaders(headers, t, contentType);

		if (outputMessage instanceof StreamingHttpOutputMessage) {
			StreamingHttpOutputMessage streamingOutputMessage = (StreamingHttpOutputMessage) outputMessage;
			// StreamingHttpOutputMessage增加的setBody()方法，关于它下面会给一个使用案例~~~~
			streamingOutputMessage.setBody(outputStream -> writeInternal(t, new HttpOutputMessage() {
				// 注意此处复写：返回的是outputStream ，它也是靠我们的writeInternal对它进行写入的~~~~
				@Override
				public OutputStream getBody() {
					return outputStream;
				}
				@Override
				public HttpHeaders getHeaders() {
					return headers;
				}
			}));
		}
		// 最后它执行了flush，这也就是为何我们自己一般不需要flush的原因
		else {
			writeInternal(t, outputMessage);
			outputMessage.getBody().flush();
		}
	}
	
	// 三个抽象方法
	protected abstract boolean supports(Class<?> clazz);
	protected abstract T readInternal(Class<? extends T> clazz, HttpInputMessage inputMessage)
			throws IOException, HttpMessageNotReadableException;
	protected abstract void writeInternal(T t, HttpOutputMessage outputMessage)
			throws IOException, HttpMessageNotWritableException;
			
}

// @since 4.0
public interface StreamingHttpOutputMessage extends HttpOutputMessage {

	// 设置一个流的正文，提供回调
	void setBody(Body body);
	
	// 定义可直接写入@link outputstream的主体的协定。
	// 通过回调机制间接的访问HttpClient库很有作用
	@FunctionalInterface
	interface Body {
		// 把当前的这个body写进给定的OutputStream
		void writeTo(OutputStream outputStream) throws IOException;
	}

}

public class ResourceHttpMessageConverter extends AbstractHttpMessageConverter<Resource> {
	// 是否支持读取流信息
	private final boolean supportsReadStreaming;
	// 默认支持所有的MediaType~~~~~   但是它有个类型匹配，所以值匹配入参/返回类型是Resource类型的
	public ResourceHttpMessageConverter() {
		super(MediaType.ALL);
		this.supportsReadStreaming = true;
	}
	@Override
	protected boolean supports(Class<?> clazz) {
		return Resource.class.isAssignableFrom(clazz);
	}

	// 直观感受：读的时候也只支持InputStreamResource和ByteArrayResource这两种resource的直接封装
	@Override
	protected Resource readInternal(Class<? extends Resource> clazz, HttpInputMessage inputMessage)
			throws IOException, HttpMessageNotReadableException {

		if (this.supportsReadStreaming && InputStreamResource.class == clazz) {
			return new InputStreamResource(inputMessage.getBody()) {
				@Override
				public String getFilename() {
					return inputMessage.getHeaders().getContentDisposition().getFilename();
				}
			};
		}
		// 若入参类型是Resource接口，也是当作ByteArrayResource处理的
		else if (Resource.class == clazz || ByteArrayResource.class.isAssignableFrom(clazz)) {
			// 把inputSteeam转换为byte[]数组~~~~~~
			byte[] body = StreamUtils.copyToByteArray(inputMessage.getBody());
			return new ByteArrayResource(body) {
				@Override
				@Nullable
				public String getFilename() {
					return inputMessage.getHeaders().getContentDisposition().getFilename();
				}
			};
		}
		else {
			throw new HttpMessageNotReadableException("Unsupported resource class: " + clazz, inputMessage);
		}
	}

	@Override
	protected void writeInternal(Resource resource, HttpOutputMessage outputMessage)
			throws IOException, HttpMessageNotWritableException {
		writeContent(resource, outputMessage);
	}
	
	// 写也非常的简单，就是把resource这个资源的内容写到body里面去，此处使用的StreamUtils.copy这个工具方法，专门处理流
	// 看到此处我们自己并不需要flush，但是需要自己关闭流
	protected void writeContent(Resource resource, HttpOutputMessage outputMessage)
			throws IOException, HttpMessageNotWritableException {
		try {
			InputStream in = resource.getInputStream();
			try {
				StreamUtils.copy(in, outputMessage.getBody());
			}
			catch (NullPointerException ex) {
				// ignore, see SPR-13620
			}
			finally {
				try {
					in.close();
				}
				catch (Throwable ex) {
					// ignore, see SPR-12999
				}
			}
		}
		catch (FileNotFoundException ex) {
			// ignore, see SPR-12999
		}
	}
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>测试FormHttpMessageConverter</title>
</head>
<body>
<!-- 表单的enctype一定要标注成multipart形式，否则是拿不到二进制流的 -->
<form action="http://localhost:8080/demo_war_war/upload" method="post" enctype="multipart/form-data">
    用户名 <input type="text" name="userName">
    头像 <input type="file" name="touxiang">
    <input type="submit">
</form>
</body>
</html>

    // 模拟使用Resource进行文件的上传~~~
    @ResponseBody
    @RequestMapping(value = "/upload", method = RequestMethod.POST)
    public String upload(@RequestBody Resource resource) { //此处不能用接口Resource resource
        dumpStream(resource);
        return "success";
    }

    // 模拟写文件的操作（此处写到控制台）
    private static void dumpStream(Resource resource) {
        InputStream is = null;
        try {
            //1.获取文件资源
            is = resource.getInputStream();
            //2.读取资源
            byte[] descBytes = new byte[is.available()];
            is.read(descBytes);
            System.out.println(new String(descBytes, StandardCharsets.UTF_8));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //3.关闭资源
                is.close();
            } catch (IOException e) {
            }
        }
    }

public class ObjectToStringHttpMessageConverter extends AbstractHttpMessageConverter<Object> {
	
	// 我们只需要自定定义这个转换器   让它实现String到Obj之间的互相转换~~~
	private final ConversionService conversionService;
	private final StringHttpMessageConverter stringHttpMessageConverter;
	... // 下面省略
	// 读的时候先用stringHttpMessageConverter读成String，再用转换器转为Object对象
	// 写的时候先用转换器转成String，再用stringHttpMessageConverter写进返回的body里
}

// @since 4.1  课件它被Spring选中的时间还是比较晚的
public class GsonHttpMessageConverter extends AbstractJsonHttpMessageConverter {
	private Gson gson;
	public GsonHttpMessageConverter() {
		this.gson = new Gson();
	}
	// @since 5.0  调用者可以自己指定一个Gson对象了
	public GsonHttpMessageConverter(Gson gson) {
		Assert.notNull(gson, "A Gson instance is required");
		this.gson = gson;
	}	

	// 因为肯定是文本，所以这里使用Reader 没有啥问题
	// 父类默认用UTF-8把inputStream转为了更友好的Reader
	@Override
	protected Object readInternal(Type resolvedType, Reader reader) throws Exception {
		return getGson().fromJson(reader, resolvedType);
	}

	@Override
	protected void writeInternal(Object o, @Nullable Type type, Writer writer) throws Exception {
		// 如果带泛型  这里也是特别的处理了兼容处理~~~~
		if (type instanceof ParameterizedType) {
			getGson().toJson(o, type, writer);
		} else {
			getGson().toJson(o, writer);
		}
	}

	// 父类定义了它支持的MediaType类型~
	public AbstractJsonHttpMessageConverter() {
		super(MediaType.APPLICATION_JSON, new MediaType("application", "*+json"));
		setDefaultCharset(DEFAULT_CHARSET);
	}
}

// @since 3.1.2  出来可谓最早。正统太子
public class MappingJackson2HttpMessageConverter extends AbstractJackson2HttpMessageConverter {
	
	// 该属性在父类定义~~~
	protected ObjectMapper objectMapper;
	@Nullable
	private String jsonPrefix;

	// 支持指定的MediaType类型~~
	public MappingJackson2HttpMessageConverter(ObjectMapper objectMapper) {
		super(objectMapper, MediaType.APPLICATION_JSON, new MediaType("application", "*+json"));
	}

	// 所有的读、写都在父类AbstractJackson2HttpMessageConverter里统一实现的，稍微有点复杂性
}

// @since 3.0  出生非常早
public class StringHttpMessageConverter extends AbstractHttpMessageConverter<String> {
	// 这就是为何你return中文的时候会乱码的原因（若你不设置它的编码的话~）
	public static final Charset DEFAULT_CHARSET = StandardCharsets.ISO_8859_1;
	@Nullable
	private volatile List<Charset> availableCharsets;
	// 标识是否输出 Response Headers:Accept-Charset(默认true表示输出)
	private boolean writeAcceptCharset = true;

	public StringHttpMessageConverter() {
		this(DEFAULT_CHARSET);
	}
	public StringHttpMessageConverter(Charset defaultCharset) {
		super(defaultCharset, MediaType.TEXT_PLAIN, MediaType.ALL);
	}

	//Indicates whether the {@code Accept-Charset} should be written to any outgoing request.
	// Default is {@code true}.
	public void setWriteAcceptCharset(boolean writeAcceptCharset) {
		this.writeAcceptCharset = writeAcceptCharset;
	}

	// 只处理String类型~
	@Override
	public boolean supports(Class<?> clazz) {
		return String.class == clazz;
	}

	@Override
	protected String readInternal(Class<? extends String> clazz, HttpInputMessage inputMessage) throws IOException {
		// 哪编码的原则为：
		// 1、contentType自己指定了编码就以指定的为准
		// 2、没指定，但是类型是`application/json`，统一按照UTF_8处理
		// 3、否则使用默认编码：getDefaultCharset  ISO_8859_1
		Charset charset = getContentTypeCharset(inputMessage.getHeaders().getContentType());
		// 按照此编码，转换为字符串~~~
		return StreamUtils.copyToString(inputMessage.getBody(), charset);
	}


	// 显然，ContentLength和编码也是有关的~~~
	@Override
	protected Long getContentLength(String str, @Nullable MediaType contentType) {
		Charset charset = getContentTypeCharset(contentType);
		return (long) str.getBytes(charset).length;
	}


	@Override
	protected void writeInternal(String str, HttpOutputMessage outputMessage) throws IOException {
		// 默认会给请求设置一个接收的编码格式~~~（若用户不指定，是所有的编码都支持的）
		if (this.writeAcceptCharset) {
			outputMessage.getHeaders().setAcceptCharset(getAcceptedCharsets());
		}
		
		// 根据编码把字符串写进去~
		Charset charset = getContentTypeCharset(outputMessage.getHeaders().getContentType());
		StreamUtils.copy(str, charset, outputMessage.getBody());
	}
	...
}

	// 因为它支持MediaType.TEXT_PLAIN, MediaType.ALL所有类型，所以你的contentType无所谓~~~ 它都能够处理
    @ResponseBody
    @RequestMapping(value = "/test", method = RequestMethod.POST)
    public String upload(@RequestBody String body) {
        return "Hello World";
    }

    @ResponseBody
    @RequestMapping(value = "/test")
    public String test() {
        return "{\"status\":0,\"errmsg\":null,\"data\":{\"query\":\"酒店查询\",\"num\":65544,\"url\":\"www.test.com\"}}";
    }

public interface GenericHttpMessageConverter<T> extends HttpMessageConverter<T> {
	//This method should perform the same checks than {@link HttpMessageConverter#canRead(Class, MediaType)} with additional ones related to the generic type.
	// 它的效果同父接口的canRead，但是它是加了一个泛型类型~~~来加以更加详细的判断
	boolean canRead(Type type, @Nullable Class<?> contextClass, @Nullable MediaType mediaType);
	// 一样也是加了泛型类型
	T read(Type type, @Nullable Class<?> contextClass, HttpInputMessage inputMessage)
			throws IOException, HttpMessageNotReadableException;

	//@since 4.2
	boolean canWrite(@Nullable Type type, Class<?> clazz, @Nullable MediaType mediaType);
	// @since 4.2
	void write(T t, @Nullable Type type, @Nullable MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException;
}

// Fastjson for Spring MVC Converter. Compatible Spring MVC version 3.2+
// @since 1.2.10
public class FastJsonHttpMessageConverter extends AbstractHttpMessageConverter<Object>
        implements GenericHttpMessageConverter<Object> {

    public FastJsonHttpMessageConverter() {
        super(MediaType.ALL);
    }

	// 永远返回true，表示它想支持所有的类型，所有的MediaType，现在这算一个小Bug
    @Override
    protected boolean supports(Class<?> clazz) {
        return true;
    }

	// 它竟然对泛型Type都没有任何的实现，这也是一个小bug
	// 包括读写的时候  对泛型类型都没有做很好的处理~~~
    public boolean canRead(Type type, Class<?> contextClass, MediaType mediaType) {
        return super.canRead(contextClass, mediaType);
    }
    public boolean canWrite(Type type, Class<?> clazz, MediaType mediaType) {
        return super.canWrite(clazz, mediaType);
    }

	// 这是处理读的方法，主要依赖于JSON.parseObject这个方法解析成一个object
    private Object readType(Type type, HttpInputMessage inputMessage) {

        try {
            InputStream in = inputMessage.getBody();
            return JSON.parseObject(in,
                    fastJsonConfig.getCharset(),
                    type,
                    fastJsonConfig.getParserConfig(),
                    fastJsonConfig.getParseProcess(),
                    JSON.DEFAULT_PARSER_FEATURE,
                    fastJsonConfig.getFeatures());
        } catch (JSONException ex) {
            throw new HttpMessageNotReadableException("JSON parse error: " + ex.getMessage(), ex);
        } catch (IOException ex) {
            throw new HttpMessageNotReadableException("I/O error while reading input message", ex);
        }
    }
}

// 这个类很简单，就是对Resource的一个包装  所以它和`application/octet-stream`也是有关的
// @since 4.3
public class ResourceRegion {
	private final Resource resource;
	private final long position;
	private final long count;
	...
}

public class PropertiesHttpMessageConverter extends AbstractHttpMessageConverter<User> {


    // 用于仅仅只处理我自己自定义的指定的MediaType
    private static final MediaType DEFAULT_MEDIATYPE = MediaType.valueOf("application/properties");


    public PropertiesHttpMessageConverter() {
        super(DEFAULT_MEDIATYPE);
        setDefaultCharset(StandardCharsets.UTF_8);
    }

    // 要求入参、返回值必须是User类型我才处理
    @Override
    protected boolean supports(Class<?> clazz) {
        return clazz.isAssignableFrom(User.class);
    }

    @Override
    protected User readInternal(Class<? extends User> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
        InputStream is = inputMessage.getBody();
        Properties props = new Properties();
        props.load(is);

        // user的三个属性
        String id = props.getProperty("id");
        String name = props.getProperty("name");
        String age = props.getProperty("age");
        return new User(Integer.valueOf(id), name, Integer.valueOf(age));
    }

    @Override
    protected void writeInternal(User user, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
        OutputStream os = outputMessage.getBody();
        Properties properties = new Properties();

        // 属性判空此处我就不做了~~~
        properties.setProperty("id", user.getId().toString());
        properties.setProperty("name", user.getName());
        properties.setProperty("age", user.getAge().toString());
        properties.store(os, "user comments");
    }
}

@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcConfigurerAdapter {

    @Override
    public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
        // 因为此转换器职责已经足够单一，所以放在首位是木有问题的~
        converters.add(0, new PropertiesHttpMessageConverter());
        // 若放在末尾，将可能不会生效~~~~（比如如果Fastjson转换器 处理所有的类型的话，所以放在首位最为保险）
        //converters.add(0, new PropertiesHttpMessageConverter());
    }
}

    @ResponseBody
    @RequestMapping(value = "/test/properties", method = RequestMethod.POST)
    public User upload(@RequestBody User user) {
        System.out.println(user);
        return user;
    }

    @Override
    public boolean canWrite(Class<?> clazz, MediaType mediaType) {
        return (AnnotationUtils.findAnnotation(clazz, XmlRootElement.class) != null && canWrite(mediaType));
    }