Add support for MIME-based message conversion

The MessageConverter interface in spring-messaging is now explicitly
designed to support conversion of the payload of a Message<?> to and
from serialized form based on MIME type message header.
By default, the MessageHeaders.CONTENT_HEADER header is used but a
custom ContentTypeResolver can be configured to customize that.

Currently available are Jackson 2, String, and byte array converters.
A CompositeMessageConverter can be used to configure several
message converters in various places such as a messaging template.

spring-messaging/src/test/java/org/springframework/messaging/simp/annotation/support/SendToMethodReturnValueHandlerTests.java

@@ -76,11 +76,11 @@ public class SendToMethodReturnValueHandlerTests {
 
 		MockitoAnnotations.initMocks(this);
 
-		Message<String> message = MessageBuilder.withPayload(payloadContent).build();
-		when(this.messageConverter.toMessage(payloadContent)).thenReturn(message);
+		Message message = MessageBuilder.withPayload(payloadContent).build();
+		when(this.messageConverter.toMessage(payloadContent, null)).thenReturn(message);
 
 		SimpMessagingTemplate messagingTemplate = new SimpMessagingTemplate(this.messageChannel);
-		messagingTemplate.setConverter(this.messageConverter);
+		messagingTemplate.setMessageConverter(this.messageConverter);
 
 		this.handler = new SendToMethodReturnValueHandler(messagingTemplate, true);
 		this.handlerAnnotationNotRequired = new SendToMethodReturnValueHandler(messagingTemplate, false);

spring-messaging/src/test/java/org/springframework/messaging/simp/annotation/support/SubscriptionMethodReturnValueHandlerTests.java

@@ -72,11 +72,11 @@ public class SubscriptionMethodReturnValueHandlerTests {
 
 		MockitoAnnotations.initMocks(this);
 
-		Message<String> message = MessageBuilder.withPayload(payloadContent).build();
-		when(this.messageConverter.toMessage(payloadContent)).thenReturn(message);
+		Message message = MessageBuilder.withPayload(payloadContent).build();
+		when(this.messageConverter.toMessage(payloadContent, null)).thenReturn(message);
 
 		SimpMessagingTemplate messagingTemplate = new SimpMessagingTemplate(this.messageChannel);
-		messagingTemplate.setConverter(this.messageConverter);
+		messagingTemplate.setMessageConverter(this.messageConverter);
 
 		this.handler = new SubscriptionMethodReturnValueHandler(messagingTemplate);
 

spring-messaging/src/test/java/org/springframework/messaging/simp/config/WebSocketMessageBrokerConfigurationSupportTests.java

@@ -43,7 +43,10 @@ import org.springframework.messaging.simp.stomp.StompCommand;
 import org.springframework.messaging.simp.stomp.StompHeaderAccessor;
 import org.springframework.messaging.simp.stomp.StompTextMessageBuilder;
 import org.springframework.messaging.support.MessageBuilder;
+import org.springframework.messaging.support.converter.CompositeMessageConverter;
+import org.springframework.messaging.support.converter.DefaultContentTypeResolver;
 import org.springframework.stereotype.Controller;
+import org.springframework.util.MimeTypeUtils;
 import org.springframework.web.servlet.HandlerMapping;
 import org.springframework.web.servlet.handler.SimpleUrlHandlerMapping;
 import org.springframework.web.socket.TextMessage;
@@ -274,6 +277,15 @@ public class WebSocketMessageBrokerConfigurationSupportTests {
 		assertEquals("/foos1", headers.getDestination());
 	}
 
+	@Test
+	public void messageConverter() {
+		CompositeMessageConverter messageConverter = this.cxtStompBroker.getBean(
+				"simpMessageConverter", CompositeMessageConverter.class);
+
+		DefaultContentTypeResolver resolver = (DefaultContentTypeResolver) messageConverter.getContentTypeResolver();
+		assertEquals(MimeTypeUtils.APPLICATION_JSON, resolver.getDefaultMimeType());
+	}
+
 
 	@Controller
 	static class TestController {

spring-messaging/src/test/java/org/springframework/messaging/simp/stomp/StompHeaderAccessorTests.java

@@ -21,8 +21,12 @@ import java.util.Map;
 
 import org.junit.Test;
 import org.springframework.http.MediaType;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageHeaders;
 import org.springframework.messaging.simp.SimpMessageType;
+import org.springframework.messaging.support.MessageBuilder;
 import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MimeTypeUtils;
 import org.springframework.util.MultiValueMap;
 
 import static org.junit.Assert.*;
@@ -153,6 +157,18 @@ public class StompHeaderAccessorTests {
 		assertNotNull("message-id was not created", actual.get(StompHeaderAccessor.STOMP_MESSAGE_ID_HEADER).get(0));
 	}
 
+	@Test
+	public void toNativeHeadersContentType() {
+
+		Message<byte[]> message = MessageBuilder.withPayload(new byte[0])
+				.setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.APPLICATION_ATOM_XML).build();
+
+		StompHeaderAccessor headers = StompHeaderAccessor.wrap(message);
+		Map<String, List<String>> map = headers.toNativeHeaderMap();
+
+		assertEquals("application/atom+xml", map.get(StompHeaderAccessor.STOMP_CONTENT_TYPE_HEADER).get(0));
+	}
+
 	@Test
 	public void modifyCustomNativeHeader() {
 

spring-messaging/src/test/java/org/springframework/messaging/support/converter/AbstractMessageConverterTests.java

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2002-2013 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.messaging.support.converter;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageHeaders;
+import org.springframework.messaging.support.MessageBuilder;
+import org.springframework.util.MimeType;
+import org.springframework.util.MimeTypeUtils;
+
+import static org.junit.Assert.*;
+
+
+/**
+ * Test fixture for {@link AbstractMessageConverter}.
+ *
+ * @author Rossen Stoyanchev
+ */
+public class AbstractMessageConverterTests {
+
+	private TestMessageConverter converter;
+
+
+	@Before
+	public void setup() {
+		this.converter = new TestMessageConverter();
+		this.converter.setContentTypeResolver(new DefaultContentTypeResolver());
+	}
+
+	@Test
+	public void supportsTargetClass() {
+		Message<String> message = MessageBuilder.withPayload("ABC").build();
+
+		assertEquals("success-from", this.converter.fromMessage(message, String.class));
+		assertNull(this.converter.fromMessage(message, Integer.class));
+	}
+
+	@Test
+	public void supportsMimeType() {
+		Message<String> message = MessageBuilder.withPayload(
+				"ABC").setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN).build();
+
+		assertEquals("success-from", this.converter.fromMessage(message, String.class));
+	}
+
+	@Test
+	public void supportsMimeTypeNotSupported() {
+		Message<String> message = MessageBuilder.withPayload(
+				"ABC").setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.APPLICATION_JSON).build();
+
+		assertNull(this.converter.fromMessage(message, String.class));
+	}
+
+	@Test
+	public void supportsMimeTypeNotSpecified() {
+		Message<String> message = MessageBuilder.withPayload("ABC").build();
+		assertEquals("success-from", this.converter.fromMessage(message, String.class));
+	}
+
+	@Test
+	public void supportsMimeTypeNoneConfigured() {
+
+		Message<String> message = MessageBuilder.withPayload(
+				"ABC").setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.APPLICATION_JSON).build();
+
+		this.converter = new TestMessageConverter(Collections.<MimeType>emptyList());
+		this.converter.setContentTypeResolver(new DefaultContentTypeResolver());
+
+		assertEquals("success-from", this.converter.fromMessage(message, String.class));
+	}
+
+	@Test
+	public void toMessageHeadersCopied() {
+		Map<String, Object> map = new HashMap<String, Object>();
+		map.put("foo", "bar");
+		MessageHeaders headers = new MessageHeaders(map );
+		Message<?> message = this.converter.toMessage("ABC", headers);
+
+		assertEquals("bar", message.getHeaders().get("foo"));
+	}
+
+	@Test
+	public void toMessageContentTypeHeader() {
+		Message<?> message = this.converter.toMessage("ABC", null);
+		assertEquals(MimeTypeUtils.TEXT_PLAIN, message.getHeaders().get(MessageHeaders.CONTENT_TYPE));
+	}
+
+
+	private static class TestMessageConverter extends AbstractMessageConverter {
+
+		public TestMessageConverter() {
+			super(MimeTypeUtils.TEXT_PLAIN);
+		}
+
+		public TestMessageConverter(Collection<MimeType> supportedMimeTypes) {
+			super(supportedMimeTypes);
+		}
+
+		@Override
+		protected boolean supports(Class<?> clazz) {
+			return String.class.equals(clazz);
+		}
+
+		@Override
+		public Object convertFromInternal(Message<?> message, Class<?> targetClass) {
+			return "success-from";
+		}
+
+		@Override
+		public Object convertToInternal(Object payload, MessageHeaders headers) {
+			return "success-to";
+		}
+	}
+
+}

spring-messaging/src/test/java/org/springframework/messaging/support/converter/DefaultContentTypeResolverTests.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2002-2013 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.messaging.support.converter;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.messaging.MessageHeaders;
+import org.springframework.util.MimeTypeUtils;
+
+import static org.junit.Assert.*;
+
+
+/**
+ * Test fixture for {@link DefaultContentTypeResolver}.
+ *
+ * @author Rossen Stoyanchev
+ */
+public class DefaultContentTypeResolverTests {
+
+	private DefaultContentTypeResolver resolver;
+
+
+	@Before
+	public void setup() {
+		this.resolver = new DefaultContentTypeResolver();
+	}
+
+	@Test
+	public void resolve() {
+		Map<String, Object> map = new HashMap<String, Object>();
+		map.put(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.APPLICATION_JSON);
+		MessageHeaders headers = new MessageHeaders(map);
+
+		assertEquals(MimeTypeUtils.APPLICATION_JSON, this.resolver.resolve(headers));
+	}
+
+	@Test
+	public void resolveNoContentTypeHeader() {
+		MessageHeaders headers = new MessageHeaders(Collections.<String, Object>emptyMap());
+
+		assertNull(this.resolver.resolve(headers));
+	}
+
+	@Test
+	public void resolveFromDefaultMimeType() {
+		this.resolver.setDefaultMimeType(MimeTypeUtils.APPLICATION_JSON);
+		MessageHeaders headers = new MessageHeaders(Collections.<String, Object>emptyMap());
+
+		assertEquals(MimeTypeUtils.APPLICATION_JSON, this.resolver.resolve(headers));
+	}
+
+}

spring-messaging/src/test/java/org/springframework/messaging/support/converter/MappingJackson2MessageConverterTests.java

@@ -0,0 +1,215 @@
+/*
+ * Copyright 2002-2013 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.messaging.support.converter;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageHeaders;
+import org.springframework.messaging.support.MessageBuilder;
+import org.springframework.util.MimeType;
+
+import static org.junit.Assert.*;
+
+
+/**
+ * Test fixture for {@link MappingJackson2MessageConverter}.
+ *
+ * @author Rossen Stoyanchev
+ */
+public class MappingJackson2MessageConverterTests {
+
+	private static Charset UTF_8 = Charset.forName("UTF-8");
+
+	private MappingJackson2MessageConverter converter;
+
+
+	@Before
+	public void setup() {
+		this.converter = new MappingJackson2MessageConverter();
+		this.converter.setContentTypeResolver(new DefaultContentTypeResolver());
+	}
+
+	@Test
+	public void fromMessage() throws Exception {
+		String payload = "{\"bytes\":\"AQI=\",\"array\":[\"Foo\",\"Bar\"],"
+				+ "\"number\":42,\"string\":\"Foo\",\"bool\":true,\"fraction\":42.0}";
+		Message<?> message = MessageBuilder.withPayload(payload.getBytes(UTF_8)).build();
+		MyBean actual = (MyBean) this.converter.fromMessage(message, MyBean.class);
+
+		assertEquals("Foo", actual.getString());
+		assertEquals(42, actual.getNumber());
+		assertEquals(42F, actual.getFraction(), 0F);
+		assertArrayEquals(new String[]{"Foo", "Bar"}, actual.getArray());
+		assertTrue(actual.isBool());
+		assertArrayEquals(new byte[]{0x1, 0x2}, actual.getBytes());
+	}
+
+	@Test
+	public void fromMessageUntyped() throws Exception {
+		String payload = "{\"bytes\":\"AQI=\",\"array\":[\"Foo\",\"Bar\"],"
+				+ "\"number\":42,\"string\":\"Foo\",\"bool\":true,\"fraction\":42.0}";
+		Message<?> message = MessageBuilder.withPayload(payload.getBytes(UTF_8)).build();
+		@SuppressWarnings("unchecked")
+		HashMap<String, Object> actual = (HashMap<String, Object>) this.converter.fromMessage(message, HashMap.class);
+
+		assertEquals("Foo", actual.get("string"));
+		assertEquals(42, actual.get("number"));
+		assertEquals(42D, (Double) actual.get("fraction"), 0D);
+		assertEquals(Arrays.asList("Foo", "Bar"), actual.get("array"));
+		assertEquals(Boolean.TRUE, actual.get("bool"));
+		assertEquals("AQI=", actual.get("bytes"));
+	}
+
+	@Test(expected = MessageConversionException.class)
+	public void fromMessageInvalidJson() throws Exception {
+		String payload = "FooBar";
+		Message<?> message = MessageBuilder.withPayload(payload.getBytes(UTF_8)).build();
+		this.converter.fromMessage(message, MyBean.class);
+	}
+
+	@Test(expected = MessageConversionException.class)
+	public void fromMessageValidJsonWithUnknownProperty() throws IOException {
+		String payload = "{\"string\":\"string\",\"unknownProperty\":\"value\"}";
+		Message<?> message = MessageBuilder.withPayload(payload.getBytes(UTF_8)).build();
+		this.converter.fromMessage(message, MyBean.class);
+	}
+
+	@Test
+	public void toMessage() throws Exception {
+		MyBean payload = new MyBean();
+		payload.setString("Foo");
+		payload.setNumber(42);
+		payload.setFraction(42F);
+		payload.setArray(new String[]{"Foo", "Bar"});
+		payload.setBool(true);
+		payload.setBytes(new byte[]{0x1, 0x2});
+
+		Message<?> message = this.converter.toMessage(payload, null);
+		String actual = new String((byte[]) message.getPayload(), UTF_8);
+
+		assertTrue(actual.contains("\"string\":\"Foo\""));
+		assertTrue(actual.contains("\"number\":42"));
+		assertTrue(actual.contains("fraction\":42.0"));
+		assertTrue(actual.contains("\"array\":[\"Foo\",\"Bar\"]"));
+		assertTrue(actual.contains("\"bool\":true"));
+		assertTrue(actual.contains("\"bytes\":\"AQI=\""));
+		assertEquals("Invalid content-type", new MimeType("application", "json", UTF_8),
+				message.getHeaders().get(MessageHeaders.CONTENT_TYPE, MimeType.class));
+	}
+
+	@Test
+	public void toMessageUtf16() {
+		Charset utf16 = Charset.forName("UTF-16BE");
+		MimeType contentType = new MimeType("application", "json", utf16);
+		Map<String, Object> map = new HashMap<>();
+		map.put(MessageHeaders.CONTENT_TYPE, contentType);
+		MessageHeaders headers = new MessageHeaders(map);
+		String payload = "H\u00e9llo W\u00f6rld";
+		Message<?> message = this.converter.toMessage(payload, headers);
+
+		assertEquals("\"" + payload + "\"", new String((byte[]) message.getPayload(), utf16));
+		assertEquals(contentType, message.getHeaders().get(MessageHeaders.CONTENT_TYPE));
+	}
+
+	@Test
+	public void toMessageUtf16String() {
+		this.converter.setSerializedPayloadClass(String.class);
+
+		Charset utf16 = Charset.forName("UTF-16BE");
+		MimeType contentType = new MimeType("application", "json", utf16);
+		Map<String, Object> map = new HashMap<>();
+		map.put(MessageHeaders.CONTENT_TYPE, contentType);
+		MessageHeaders headers = new MessageHeaders(map);
+		String payload = "H\u00e9llo W\u00f6rld";
+		Message<?> message = this.converter.toMessage(payload, headers);
+
+		assertEquals("\"" + payload + "\"", message.getPayload());
+		assertEquals(contentType, message.getHeaders().get(MessageHeaders.CONTENT_TYPE));
+	}
+
+
+	public static class MyBean {
+
+		private String string;
+
+		private int number;
+
+		private float fraction;
+
+		private String[] array;
+
+		private boolean bool;
+
+		private byte[] bytes;
+
+		public byte[] getBytes() {
+			return bytes;
+		}
+
+		public void setBytes(byte[] bytes) {
+			this.bytes = bytes;
+		}
+
+		public boolean isBool() {
+			return bool;
+		}
+
+		public void setBool(boolean bool) {
+			this.bool = bool;
+		}
+
+		public String getString() {
+			return string;
+		}
+
+		public void setString(String string) {
+			this.string = string;
+		}
+
+		public int getNumber() {
+			return number;
+		}
+
+		public void setNumber(int number) {
+			this.number = number;
+		}
+
+		public float getFraction() {
+			return fraction;
+		}
+
+		public void setFraction(float fraction) {
+			this.fraction = fraction;
+		}
+
+		public String[] getArray() {
+			return array;
+		}
+
+		public void setArray(String[] array) {
+			this.array = array;
+		}
+	}
+
+}

spring-messaging/src/test/java/org/springframework/messaging/support/converter/StringMessageConverterTests.java

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2002-2013 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.messaging.support.converter;
+
+import java.nio.charset.Charset;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageHeaders;
+import org.springframework.messaging.support.MessageBuilder;
+import org.springframework.util.MimeType;
+import org.springframework.util.MimeTypeUtils;
+
+import static org.junit.Assert.*;
+
+
+/**
+ * Test fixture for {@link StringMessageConverter}.
+ *
+ * @author Rossen Stoyanchev
+ */
+public class StringMessageConverterTests {
+
+	private StringMessageConverter converter;
+
+
+	@Before
+	public void setUp() {
+		this.converter = new StringMessageConverter();
+		this.converter.setContentTypeResolver(new DefaultContentTypeResolver());
+	}
+
+
+	@Test
+	public void fromByteArrayMessage() {
+		Message<byte[]> message = MessageBuilder.withPayload(
+				"ABC".getBytes()).setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN).build();
+		assertEquals("ABC", this.converter.fromMessage(message, String.class));
+	}
+
+	@Test
+	public void fromStringMessage() {
+		Message<String> message = MessageBuilder.withPayload(
+				"ABC").setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN).build();
+		assertEquals("ABC", this.converter.fromMessage(message, String.class));
+	}
+
+	@Test
+	public void fromMessageNoContentTypeHeader() {
+		Message<byte[]> message = MessageBuilder.withPayload("ABC".getBytes()).build();
+		assertEquals("ABC", this.converter.fromMessage(message, String.class));
+	}
+
+	@Test
+	public void fromMessageCharset() {
+		Charset iso88591 = Charset.forName("ISO-8859-1");
+		String payload = "H\u00e9llo W\u00f6rld";
+		Message<byte[]> message = MessageBuilder.withPayload(payload.getBytes(iso88591))
+				.setHeader(MessageHeaders.CONTENT_TYPE, new MimeType("text", "plain", iso88591)).build();
+
+		assertEquals(payload, this.converter.fromMessage(message, String.class));
+	}
+
+	@Test
+	public void fromMessageDefaultCharset() {
+		Charset utf8 = Charset.forName("UTF-8");
+		String payload = "H\u00e9llo W\u00f6rld";
+		Message<byte[]> message = MessageBuilder.withPayload(payload.getBytes(utf8)).build();
+
+		assertEquals(payload, this.converter.fromMessage(message, String.class));
+	}
+
+	@Test
+	public void fromMessageTargetClassNotSupported() {
+		Message<byte[]> message = MessageBuilder.withPayload("ABC".getBytes()).build();
+		assertNull(this.converter.fromMessage(message, Integer.class));
+	}
+
+	@Test
+	public void fromMessageByteArray() {
+		Message<byte[]> message = MessageBuilder.withPayload(
+				"ABC".getBytes()).setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN).build();
+		assertEquals("ABC", this.converter.fromMessage(message, String.class));
+	}
+
+	@Test
+	public void toMessage() {
+		Map<String, Object> map = new HashMap<String, Object>();
+		map.put(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN);
+		MessageHeaders headers = new MessageHeaders(map);
+		Message<?> message = this.converter.toMessage("ABC", headers);
+
+		assertEquals("ABC", new String(((byte[]) message.getPayload())));
+	}
+
+}