PayloadArgumentResolver supports JsonView as well (through AbstractMessageConverter revision)

AbstractMessageConverter provides overloaded methods with a conversion hint, MappingJackson2MessageConverter takes that hint into account, and SimpMessagingTemplate transformes such a hint in the given headers map into an explicit argument invocation argument.

Issue: SPR-13265

Author: jhoeller

spring-messaging/src/main/java/org/springframework/messaging/converter/AbstractMessageConverter.java

@@ -24,7 +24,6 @@
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
-import org.springframework.core.MethodParameter;
 import org.springframework.messaging.Message;
 import org.springframework.messaging.MessageHeaders;
 import org.springframework.messaging.support.MessageBuilder;
@@ -40,20 +39,11 @@
  *
  * @author Rossen Stoyanchev
  * @author Sebastien Deleuze
+ * @author Juergen Hoeller
  * @since 4.0
  */
 public abstract class AbstractMessageConverter implements MessageConverter {
 
-	/**
-	 * Name of the header that can be set to provide further information
-	 * ({@link MethodParameter} instance) about the origin of the payload (for
-	 * {@link #toMessage(Object, MessageHeaders)}) or about the target of the payload
-	 * ({@link #fromMessage(Message, Class)}).
-	 * @since 4.2
-	 */
-	public static final String METHOD_PARAMETER_HINT_HEADER = "methodParameterHint";
-
-
 	protected final Log logger = LogFactory.getLog(getClass());
 
 	private final List<MimeType> supportedMimeTypes;
@@ -174,10 +164,27 @@ protected MimeType getDefaultContentType(Object payload) {
 
 	@Override
 	public final Object fromMessage(Message<?> message, Class<?> targetClass) {
+		return fromMessage(message, targetClass, null);
+	}
+
+	/**
+	 * A variant of {@link #fromMessage(Message, Class)} which takes an extra
+	 * conversion context as an argument, allowing to take e.g. annotations
+	 * on a payload parameter into account.
+	 * @param message the input message
+	 * @param targetClass the target class for the conversion
+	 * @param conversionHint an extra object passed to the {@link MessageConverter},
+	 * e.g. the associated {@code MethodParameter} (may be {@code null}}
+	 * @return the result of the conversion, or {@code null} if the converter cannot
+	 * perform the conversion
+	 * @since 4.2
+	 * @see #fromMessage(Message, Class)
+	 */
+	public final Object fromMessage(Message<?> message, Class<?> targetClass, Object conversionHint) {
 		if (!canConvertFrom(message, targetClass)) {
 			return null;
 		}
-		return convertFromInternal(message, targetClass);
+		return convertFromInternal(message, targetClass, conversionHint);
 	}
 
 	protected boolean canConvertFrom(Message<?> message, Class<?> targetClass) {
@@ -186,13 +193,33 @@ protected boolean canConvertFrom(Message<?> message, Class<?> targetClass) {
 
 	@Override
 	public final Message<?> toMessage(Object payload, MessageHeaders headers) {
+		return toMessage(payload, headers, null);
+	}
+
+	/**
+	 * A variant of {@link #toMessage(Object, MessageHeaders)} which takes an extra
+	 * conversion context as an argument, allowing to take e.g. annotations
+	 * on a return type into account.
+	 * @param payload the Object to convert
+	 * @param headers optional headers for the message (may be {@code null})
+	 * @param conversionHint an extra object passed to the {@link MessageConverter},
+	 * e.g. the associated {@code MethodParameter} (may be {@code null}}
+	 * @return the new message, or {@code null} if the converter does not support the
+	 * Object type or the target media type
+	 * @since 4.2
+	 * @see #toMessage(Object, MessageHeaders)
+	 */
+	public final Message<?> toMessage(Object payload, MessageHeaders headers, Object conversionHint) {
 		if (!canConvertTo(payload, headers)) {
 			return null;
 		}
 
-		payload = convertToInternal(payload, headers);
-		MimeType mimeType = getDefaultContentType(payload);
+		payload = convertToInternal(payload, headers, conversionHint);
+		if (payload == null) {
+			return null;
+		}
 
+		MimeType mimeType = getDefaultContentType(payload);
 		if (headers != null) {
 			MessageHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(headers, MessageHeaderAccessor.class);
 			if (accessor != null && accessor.isMutable()) {
@@ -244,13 +271,52 @@ protected MimeType getMimeType(MessageHeaders headers) {
 
 	/**
 	 * Convert the message payload from serialized form to an Object.
+	 * @param message the input message
+	 * @param targetClass the target class for the conversion
+	 * @param conversionHint an extra object passed to the {@link MessageConverter},
+	 * e.g. the associated {@code MethodParameter} (may be {@code null}}
+	 * @return the result of the conversion, or {@code null} if the converter cannot
+	 * perform the conversion
+	 * @since 4.2
 	 */
-	public abstract Object convertFromInternal(Message<?> message, Class<?> targetClass);
+	@SuppressWarnings("deprecation")
+	protected Object convertFromInternal(Message<?> message, Class<?> targetClass, Object conversionHint) {
+		return convertFromInternal(message, targetClass);
+	}
 
+	/**
+	 * Convert the payload object to serialized form.
+	 * @param payload the Object to convert
+	 * @param headers optional headers for the message (may be {@code null})
+	 * @param conversionHint an extra object passed to the {@link MessageConverter},
+	 * e.g. the associated {@code MethodParameter} (may be {@code null}}
+	 * @return the resulting payload for the message, or {@code null} if the converter
+	 * cannot perform the conversion
+	 * @since 4.2
+	 */
+	@SuppressWarnings("deprecation")
+	protected Object convertToInternal(Object payload, MessageHeaders headers, Object conversionHint) {
+		return convertToInternal(payload, headers);
+	}
+
+	/**
+	 * Convert the message payload from serialized form to an Object.
+	 * @deprecated as of Spring 4.2, in favor of {@link #convertFromInternal(Message, Class, Object)}
+	 * (which is also protected instead of public)
+	 */
+	@Deprecated
+	public Object convertFromInternal(Message<?> message, Class<?> targetClass) {
+		return null;
+	}
 
 	/**
 	 * Convert the payload object to serialized form.
+	 * @deprecated as of Spring 4.2, in favor of {@link #convertFromInternal(Message, Class, Object)}
+	 * (which is also protected instead of public)
 	 */
-	public abstract Object convertToInternal(Object payload, MessageHeaders headers);
+	@Deprecated
+	public Object convertToInternal(Object payload, MessageHeaders headers) {
+		return null;
+	}
 
 }

spring-messaging/src/main/java/org/springframework/messaging/converter/ByteArrayMessageConverter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 the original author or authors.
+ * Copyright 2002-2015 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -29,24 +29,23 @@
  */
 public class ByteArrayMessageConverter extends AbstractMessageConverter {
 
-
 	public ByteArrayMessageConverter() {
 		super(MimeTypeUtils.APPLICATION_OCTET_STREAM);
 	}
 
 
 	@Override
 	protected boolean supports(Class<?> clazz) {
-		return byte[].class == clazz;
+		return (byte[].class == clazz);
 	}
 
 	@Override
-	public Object convertFromInternal(Message<?> message, Class<?> targetClass) {
+	protected Object convertFromInternal(Message<?> message, Class<?> targetClass, Object conversionHint) {
 		return message.getPayload();
 	}
 
 	@Override
-	public Object convertToInternal(Object payload, MessageHeaders headers) {
+	protected Object convertToInternal(Object payload, MessageHeaders headers, Object conversionHint) {
 		return payload;
 	}
 

spring-messaging/src/main/java/org/springframework/messaging/converter/MappingJackson2MessageConverter.java

@@ -195,15 +195,28 @@ protected boolean supports(Class<?> clazz) {
 	}
 
 	@Override
-	public Object convertFromInternal(Message<?> message, Class<?> targetClass) {
+	@SuppressWarnings("deprecation")
+	protected Object convertFromInternal(Message<?> message, Class<?> targetClass, Object conversionHint) {
 		JavaType javaType = this.objectMapper.constructType(targetClass);
 		Object payload = message.getPayload();
+		Class<?> view = getSerializationView(conversionHint);
+		// Note: in the view case, calling withType instead of forType for compatibility with Jackson <2.5
 		try {
 			if (payload instanceof byte[]) {
-				return this.objectMapper.readValue((byte[]) payload, javaType);
+				if (view != null) {
+					return this.objectMapper.readerWithView(view).withType(javaType).readValue((byte[]) payload);
+				}
+				else {
+					return this.objectMapper.readValue((byte[]) payload, javaType);
+				}
 			}
 			else {
-				return this.objectMapper.readValue((String) payload, javaType);
+				if (view != null) {
+					return this.objectMapper.readerWithView(view).withType(javaType).readValue(payload.toString());
+				}
+				else {
+					return this.objectMapper.readValue(payload.toString(), javaType);
+				}
 			}
 		}
 		catch (IOException ex) {
@@ -212,15 +225,15 @@ public Object convertFromInternal(Message<?> message, Class<?> targetClass) {
 	}
 
 	@Override
-	public Object convertToInternal(Object payload, MessageHeaders headers) {
+	protected Object convertToInternal(Object payload, MessageHeaders headers, Object conversionHint) {
 		try {
-			Class<?> serializationView = getSerializationView(headers);
+			Class<?> view = getSerializationView(conversionHint);
 			if (byte[].class == getSerializedPayloadClass()) {
 				ByteArrayOutputStream out = new ByteArrayOutputStream(1024);
 				JsonEncoding encoding = getJsonEncoding(getMimeType(headers));
 				JsonGenerator generator = this.objectMapper.getFactory().createGenerator(out, encoding);
-				if (serializationView != null) {
-					this.objectMapper.writerWithView(serializationView).writeValue(generator, payload);
+				if (view != null) {
+					this.objectMapper.writerWithView(view).writeValue(generator, payload);
 				}
 				else {
 					this.objectMapper.writeValue(generator, payload);
@@ -229,8 +242,8 @@ public Object convertToInternal(Object payload, MessageHeaders headers) {
 			}
 			else {
 				Writer writer = new StringWriter();
-				if (serializationView != null) {
-					this.objectMapper.writerWithView(serializationView).writeValue(writer, payload);
+				if (view != null) {
+					this.objectMapper.writerWithView(view).writeValue(writer, payload);
 				}
 				else {
 					this.objectMapper.writeValue(writer, payload);
@@ -244,20 +257,40 @@ public Object convertToInternal(Object payload, MessageHeaders headers) {
 		return payload;
 	}
 
-	private Class<?> getSerializationView(MessageHeaders headers) {
-		MethodParameter returnType = (headers != null ?
-				(MethodParameter) headers.get(METHOD_PARAMETER_HINT_HEADER) : null);
-		if (returnType == null) {
-			return null;
+	/**
+	 * Determine a Jackson serialization view based on the given conversion hint.
+	 * @param conversionHint the conversion hint Object as passed into the
+	 * converter for the current conversion attempt
+	 * @return the serialization view class, or {@code null} if none
+	 */
+	protected Class<?> getSerializationView(Object conversionHint) {
+		if (conversionHint instanceof MethodParameter) {
+			MethodParameter methodParam = (MethodParameter) conversionHint;
+			JsonView annotation = methodParam.getParameterAnnotation(JsonView.class);
+			if (annotation == null) {
+				annotation = methodParam.getMethodAnnotation(JsonView.class);
+				if (annotation == null) {
+					return null;
+				}
+			}
+			return extractViewClass(annotation, conversionHint);
+		}
+		else if (conversionHint instanceof JsonView) {
+			return extractViewClass((JsonView) conversionHint, conversionHint);
 		}
-		JsonView annotation = returnType.getMethodAnnotation(JsonView.class);
-		if (annotation == null) {
+		else if (conversionHint instanceof Class) {
+			return (Class) conversionHint;
+		}
+		else {
 			return null;
 		}
+	}
+
+	private Class<?> extractViewClass(JsonView annotation, Object conversionHint) {
 		Class<?>[] classes = annotation.value();
 		if (classes.length != 1) {
 			throw new IllegalArgumentException(
-					"@JsonView only supported for handler methods with exactly 1 class argument: " + returnType);
+					"@JsonView only supported for handler methods with exactly 1 class argument: " + conversionHint);
 		}
 		return classes[0];
 	}

spring-messaging/src/main/java/org/springframework/messaging/converter/MarshallingMessageConverter.java

@@ -134,7 +134,7 @@ protected boolean supports(Class<?> clazz) {
 	}
 
 	@Override
-	public Object convertFromInternal(Message<?> message, Class<?> targetClass) {
+	protected Object convertFromInternal(Message<?> message, Class<?> targetClass, Object conversionHint) {
 		Assert.notNull(this.unmarshaller, "Property 'unmarshaller' is required");
 		try {
 			Source source = getSource(message.getPayload());
@@ -159,7 +159,7 @@ private Source getSource(Object payload) {
 	}
 
 	@Override
-	public Object convertToInternal(Object payload, MessageHeaders headers) {
+	protected Object convertToInternal(Object payload, MessageHeaders headers, Object conversionHint) {
 		Assert.notNull(this.marshaller, "Property 'marshaller' is required");
 		try {
 			if (byte[].class == getSerializedPayloadClass()) {

spring-messaging/src/main/java/org/springframework/messaging/converter/StringMessageConverter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 the original author or authors.
+ * Copyright 2002-2015 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -46,18 +46,18 @@ public StringMessageConverter(Charset defaultCharset) {
 
 	@Override
 	protected boolean supports(Class<?> clazz) {
-		return String.class == clazz;
+		return (String.class == clazz);
 	}
 
 	@Override
-	public Object convertFromInternal(Message<?> message, Class<?> targetClass) {
+	protected Object convertFromInternal(Message<?> message, Class<?> targetClass, Object conversionHint) {
 		Charset charset = getContentTypeCharset(getMimeType(message.getHeaders()));
 		Object payload = message.getPayload();
-		return (payload instanceof String) ? payload : new String((byte[]) payload, charset);
+		return (payload instanceof String ? payload : new String((byte[]) payload, charset));
 	}
 
 	@Override
-	public Object convertToInternal(Object payload, MessageHeaders headers) {
+	protected Object convertToInternal(Object payload, MessageHeaders headers, Object conversionHint) {
 		if (byte[].class == getSerializedPayloadClass()) {
 			Charset charset = getContentTypeCharset(getMimeType(headers));
 			payload = ((String) payload).getBytes(charset);