Update MessageConverter and reactor dependencies

spring-context/src/main/java/org/springframework/messaging/channel/ReactorMessageChannel.java

@@ -26,10 +26,10 @@ import org.springframework.messaging.MessageHandler;
 import org.springframework.messaging.SubscribableChannel;
 
 import reactor.core.Reactor;
-import reactor.fn.Consumer;
-import reactor.fn.Event;
-import reactor.fn.registry.Registration;
-import reactor.fn.selector.ObjectSelector;
+import reactor.event.Event;
+import reactor.event.registry.Registration;
+import reactor.event.selector.ObjectSelector;
+import reactor.function.Consumer;
 
 
 /**

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

@@ -0,0 +1,116 @@
+/*
+ * 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.converter;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.lang.reflect.Type;
+import java.util.Map;
+
+import org.springframework.messaging.Message;
+import org.springframework.messaging.support.MessageBuilder;
+import org.springframework.util.Assert;
+
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+
+/**
+ * @author Rossen Stoyanchev
+ * @sicne 4.0
+ */
+public class MappingJackson2MessageConverter implements MessageConverter<Object> {
+
+	private ObjectMapper objectMapper = new ObjectMapper();
+
+	private Type defaultObjectType = Map.class;
+
+	private Class<?> defaultMessagePayloadClass = byte[].class;
+
+
+	/**
+	 * Set the default target Object class to convert to in
+	 * {@link #fromMessage(Message, Class)}.
+	 */
+	public void setDefaultObjectClass(Type defaultObjectType) {
+		Assert.notNull(defaultObjectType, "defaultObjectType is required");
+		this.defaultObjectType = defaultObjectType;
+	}
+
+	/**
+	 * Set the type of Message payload to convert to in {@link #toMessage(Object)}.
+	 * @param payloadClass either byte[] or String
+	 */
+	public void setDefaultTargetPayloadClass(Class<?> payloadClass) {
+		Assert.isTrue(byte[].class.equals(payloadClass) || String.class.equals(payloadClass),
+				"Payload class must be byte[] or String: " + payloadClass);
+		this.defaultMessagePayloadClass = payloadClass;
+	}
+
+	@Override
+	public Object fromMessage(Message<?> message, Type objectType) {
+
+		JavaType javaType = (objectType != null) ?
+				this.objectMapper.constructType(objectType) :
+					this.objectMapper.constructType(this.defaultObjectType);
+
+		Object payload = message.getPayload();
+		try {
+			if (payload instanceof byte[]) {
+				return this.objectMapper.readValue((byte[]) payload, javaType);
+			}
+			else if (payload instanceof String) {
+				return this.objectMapper.readValue((String) payload, javaType);
+			}
+			else {
+				throw new IllegalArgumentException("Unexpected message payload type: " + payload);
+			}
+		}
+		catch (IOException ex) {
+			throw new MessageConversionException("Could not read JSON: " + ex.getMessage(), ex);
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public <P> Message<P> toMessage(Object object) {
+		P payload;
+		try {
+			if (byte[].class.equals(this.defaultMessagePayloadClass)) {
+				ByteArrayOutputStream out = new ByteArrayOutputStream();
+				this.objectMapper.writeValue(out, object);
+				payload = (P) out.toByteArray();
+			}
+			else if (String.class.equals(this.defaultMessagePayloadClass)) {
+				Writer writer = new StringWriter();
+				this.objectMapper.writeValue(writer, object);
+				payload = (P) writer.toString();
+			}
+			else {
+				// Should never happen..
+				throw new IllegalStateException("Unexpected payload class: " + defaultMessagePayloadClass);
+			}
+		}
+		catch (IOException ex) {
+			throw new MessageConversionException("Could not write JSON: " + ex.getMessage(), ex);
+		}
+		return MessageBuilder.withPayload(payload).build();
+	}
+
+}

spring-context/src/main/java/org/springframework/messaging/converter/MessageConversionException.java

@@ -0,0 +1,37 @@
+/*
+ * 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.converter;
+
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessagingException;
+
+/**
+ * @author Mark Fisher
+ * @since 4.0
+ */
+@SuppressWarnings("serial")
+public class MessageConversionException extends MessagingException {
+
+	public MessageConversionException(String description, Throwable cause) {
+		super(description, cause);
+	}
+
+	public MessageConversionException(Message<?> failedMessage, String description, Throwable cause) {
+		super(failedMessage, description, cause);
+	}
+
+}

spring-context/src/main/java/org/springframework/messaging/converter/MessageConverter.java

@@ -16,6 +16,8 @@
 
 package org.springframework.messaging.converter;
 
+import java.lang.reflect.Type;
+
 import org.springframework.messaging.Message;
 
 
@@ -23,10 +25,10 @@ import org.springframework.messaging.Message;
  * @author Mark Fisher
  * @since 4.0
  */
-public interface MessageConverter {
+public interface MessageConverter<T> {
 
-	<T> Message<?> toMessage(T object);
+	<P> Message<P> toMessage(T object);
 
-	<T> T fromMessage(Message<?> message);
+	T fromMessage(Message<?> message, Type targetClass);
 
 }

spring-context/src/main/java/org/springframework/messaging/converter/SimplePayloadMessageConverter.java

@@ -15,6 +15,8 @@
  */
 package org.springframework.messaging.converter;
 
+import java.lang.reflect.Type;
+
 import org.springframework.messaging.Message;
 import org.springframework.messaging.support.MessageBuilder;
 
@@ -23,19 +25,16 @@ import org.springframework.messaging.support.MessageBuilder;
  * @author Mark Fisher
  * @since 4.0
  */
-public class DefaultMessageConverter implements MessageConverter {
+public class SimplePayloadMessageConverter implements MessageConverter<Object> {
 
 	@Override
-	public <T> Message<?> toMessage(T object) {
-		System.out.println("converting " + object + " to message");
+	public Message<Object> toMessage(Object object) {
 		return MessageBuilder.withPayload(object).build();
 	}
 
 	@Override
-	@SuppressWarnings("unchecked")
-	public <T> T fromMessage(Message<?> message) {
-		System.out.println("converting " + message + " to object");
-		return (T) message.getPayload();
+	public Object fromMessage(Message<?> message, Type targetClass) {
+		return message.getPayload();
 	}
 
 }

spring-context/src/main/java/org/springframework/messaging/core/AbstractMessageSendingTemplate.java

@@ -19,7 +19,7 @@ import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.springframework.messaging.Message;
 import org.springframework.messaging.MessagingException;
-import org.springframework.messaging.converter.DefaultMessageConverter;
+import org.springframework.messaging.converter.SimplePayloadMessageConverter;
 import org.springframework.messaging.converter.MessageConverter;
 import org.springframework.util.Assert;
 
@@ -34,7 +34,7 @@ public abstract class AbstractMessageSendingTemplate<D> implements MessageSendin
 
 	private volatile D defaultDestination;
 
-	protected volatile MessageConverter converter = new DefaultMessageConverter();
+	protected volatile MessageConverter converter = new SimplePayloadMessageConverter();
 
 
 	public void setDefaultDestination(D defaultDestination) {
@@ -44,7 +44,7 @@ public abstract class AbstractMessageSendingTemplate<D> implements MessageSendin
 	/**
 	 * Set the {@link MessageConverter} that is to be used to convert
 	 * between Messages and objects for this template.
-	 * <p>The default is {@link DefaultMessageConverter}.
+	 * <p>The default is {@link SimplePayloadMessageConverter}.
 	 */
 	public void setMessageConverter(MessageConverter messageConverter) {
 		Assert.notNull(messageConverter, "'messageConverter' must not be null");

spring-context/src/main/java/org/springframework/messaging/core/AbstractMessagingTemplate.java

@@ -46,8 +46,8 @@ public abstract class AbstractMessagingTemplate<D> extends AbstractMessageSendin
 
 	@Override
 	public Object receiveAndConvert(D destination) {
-		Message<Object> message = this.doReceive(destination);
-		return (message != null) ? this.converter.fromMessage(message) : null;
+		Message<?> message = this.doReceive(destination);
+		return (message != null) ? this.converter.fromMessage(message, null) : null;
 	}
 
 
@@ -86,7 +86,7 @@ public abstract class AbstractMessagingTemplate<D> extends AbstractMessageSendin
 			requestMessage = postProcessor.postProcessMessage(requestMessage);
 		}
 		Message<?> replyMessage = this.sendAndReceive(destination, requestMessage);
-		return this.converter.fromMessage(replyMessage);
+		return this.converter.fromMessage(replyMessage, null);
 	}
 
 }