MessageConversionException offers constructor without cause argument now, plus related polishing

Issue: SPR-11653
(cherry picked from commit 2888775)

Author: jhoeller

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 the original author or authors.
+ * Copyright 2002-2014 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.
@@ -28,6 +28,9 @@
 @SuppressWarnings("serial")
 public class MessageConversionException extends MessagingException {
 
+	public MessageConversionException(String description) {
+		super(description);
+	}
 
 	public MessageConversionException(String description, Throwable cause) {
 		super(description, cause);

spring-messaging/src/main/java/org/springframework/messaging/core/AbstractDestinationResolvingMessagingTemplate.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 the original author or authors.
+ * Copyright 2002-2014 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.
@@ -25,9 +25,9 @@
  * An extension of {@link AbstractMessagingTemplate} that adds operations for sending
  * messages to a resolvable destination name as defined by the following interfaces:
  * <ul>
- *     <li>{@link DestinationResolvingMessageSendingOperations}</li>
- *     <li>{@link DestinationResolvingMessageReceivingOperations}</li>
- *     <li>{@link DestinationResolvingMessageRequestReplyOperations}</li>
+ * <li>{@link DestinationResolvingMessageSendingOperations}</li>
+ * <li>{@link DestinationResolvingMessageReceivingOperations}</li>
+ * <li>{@link DestinationResolvingMessageRequestReplyOperations}</li>
  * </ul>
  *
  * @author Mark Fisher
@@ -65,36 +65,31 @@ public DestinationResolver<D> getDestinationResolver() {
 	@Override
 	public void send(String destinationName, Message<?> message) {
 		D destination = resolveDestination(destinationName);
-		this.doSend(destination, message);
+		doSend(destination, message);
 	}
 
 	protected final D resolveDestination(String destinationName) {
-		Assert.state(this.destinationResolver != null, "destinationResolver is required to resolve destination names");
+		Assert.state(this.destinationResolver != null, "DestinationResolver is required to resolve destination names");
 		return this.destinationResolver.resolveDestination(destinationName);
 	}
 
 	@Override
 	public <T> void convertAndSend(String destinationName, T payload) {
-		Map<String, Object> headers = null;
-		this.convertAndSend(destinationName, payload, headers);
+		convertAndSend(destinationName, payload, null, null);
 	}
 
 	@Override
 	public <T> void convertAndSend(String destinationName, T payload, Map<String, Object> headers) {
-		MessagePostProcessor postProcessor = null;
-		this.convertAndSend(destinationName, payload, headers, postProcessor);
+		convertAndSend(destinationName, payload, headers, null);
 	}
 
 	@Override
 	public <T> void convertAndSend(String destinationName, T payload, MessagePostProcessor postProcessor) {
-		Map<String, Object> headers = null;
-		this.convertAndSend(destinationName, payload, headers, postProcessor);
+		convertAndSend(destinationName, payload, null, postProcessor);
 	}
 
 	@Override
-	public <T> void convertAndSend(String destinationName, T payload, Map<String, Object> headers,
-			MessagePostProcessor postProcessor) {
-
+	public <T> void convertAndSend(String destinationName, T payload, Map<String, Object> headers, MessagePostProcessor postProcessor) {
 		D destination = resolveDestination(destinationName);
 		super.convertAndSend(destination, payload, headers, postProcessor);
 	}

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

@@ -20,6 +20,7 @@
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+
 import org.springframework.messaging.Message;
 import org.springframework.messaging.MessageHeaders;
 import org.springframework.messaging.MessagingException;
@@ -37,7 +38,7 @@
  */
 public abstract class AbstractMessageSendingTemplate<D> implements MessageSendingOperations<D> {
 
-	protected final Log logger = LogFactory.getLog(this.getClass());
+	protected final Log logger = LogFactory.getLog(getClass());
 
 	private volatile D defaultDestination;
 
@@ -80,79 +81,75 @@ public MessageConverter getMessageConverter() {
 
 	@Override
 	public void send(Message<?> message) {
-		this.send(getRequiredDefaultDestination(), message);
+		send(getRequiredDefaultDestination(), message);
 	}
 
 	protected final D getRequiredDefaultDestination() {
-		Assert.state(this.defaultDestination != null, "No 'defaultDestination' configured.");
+		Assert.state(this.defaultDestination != null, "No 'defaultDestination' configured");
 		return this.defaultDestination;
 	}
 
 	@Override
 	public void send(D destination, Message<?> message) {
-		this.doSend(destination, message);
+		doSend(destination, message);
 	}
 
 	protected abstract void doSend(D destination, Message<?> message);
 
 
 	@Override
 	public void convertAndSend(Object payload) throws MessagingException {
-		this.convertAndSend(getRequiredDefaultDestination(), payload);
+		convertAndSend(getRequiredDefaultDestination(), payload);
 	}
 
 	@Override
 	public void convertAndSend(D destination, Object payload) throws MessagingException {
-		this.convertAndSend(destination, payload, (Map<String, Object>) null);
+		convertAndSend(destination, payload, (Map<String, Object>) null);
 	}
 
 	@Override
 	public void convertAndSend(D destination, Object payload, Map<String, Object> headers) throws MessagingException {
-		MessagePostProcessor postProcessor = null;
-		this.convertAndSend(destination, payload, headers, postProcessor);
+		convertAndSend(destination, payload, headers, null);
 	}
 
 	@Override
 	public void convertAndSend(Object payload, MessagePostProcessor postProcessor) throws MessagingException {
-		this.convertAndSend(getRequiredDefaultDestination(), payload, postProcessor);
+		convertAndSend(getRequiredDefaultDestination(), payload, postProcessor);
 	}
 
 	@Override
 	public void convertAndSend(D destination, Object payload, MessagePostProcessor postProcessor)
 			throws MessagingException {
 
-		Map<String, Object> headers = null;
-		this.convertAndSend(destination, payload, headers, postProcessor);
+		convertAndSend(destination, payload, null, postProcessor);
 	}
 
 	@Override
 	public void convertAndSend(D destination, Object payload, Map<String, Object> headers,
 			MessagePostProcessor postProcessor) throws MessagingException {
 
-		headers = processHeadersToSend(headers);
-		MessageHeaders messageHeaders = (headers != null) ? new MessageHeaders(headers) : null;
-		Message<?> message = this.converter.toMessage(payload, messageHeaders);
+		Map<String, Object> headersToUse = processHeadersToSend(headers);
+		MessageHeaders messageHeaders = (headersToUse != null ? new MessageHeaders(headersToUse) : null);
 
+		Message<?> message = getMessageConverter().toMessage(payload, messageHeaders);
 		if (message == null) {
-			String payloadType = (payload != null) ? payload.getClass().getName() : null;
-			throw new MessageConversionException("Unable to convert payload type '"
-					+ payloadType + "', Content-Type=" + messageHeaders.get(MessageHeaders.CONTENT_TYPE)
-					+ ", converter=" + this.converter, null);
+			String payloadType = (payload != null ? payload.getClass().getName() : null);
+			Object contentType = (messageHeaders != null ? messageHeaders.get(MessageHeaders.CONTENT_TYPE) : null);
+			throw new MessageConversionException("Unable to convert payload with type='" + payloadType +
+					"', contentType='" + contentType + "', converter=[" + getMessageConverter() + "]");
 		}
-
 		if (postProcessor != null) {
 			message = postProcessor.postProcessMessage(message);
 		}
-		this.send(destination, message);
+		send(destination, message);
 	}
 
 	/**
-	 * Provides access to the map of headers before a send operation.
-	 * Implementations can modify the headers by returning a different map.
-	 * This implementation returns the map that was passed in (i.e. without any changes).
-	 *
-	 * @param headers the headers to send, possibly {@code null}
-	 * @return the actual headers to send
+	 * Provides access to the map of input headers before a send operation. Sub-classes
+	 * can modify the headers and then return the same or a different map.
+	 * <p>This default implementation in this class returns the input map.
+	 * @param headers the headers to send or {@code null}
+	 * @return the actual headers to send or {@code null}
 	 */
 	protected Map<String, Object> processHeadersToSend(Map<String, Object> headers) {
 		return headers;

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

@@ -37,26 +37,26 @@ public abstract class AbstractMessagingTemplate<D> extends AbstractMessageSendin
 
 	@Override
 	public Message<?> receive() {
-		return this.receive(getRequiredDefaultDestination());
+		return receive(getRequiredDefaultDestination());
 	}
 
 	@Override
 	public Message<?> receive(D destination) {
-		return this.doReceive(destination);
+		return doReceive(destination);
 	}
 
 	protected abstract Message<?> doReceive(D destination);
 
 
 	@Override
 	public <T> T receiveAndConvert(Class<T> targetClass) {
-		return this.receiveAndConvert(getRequiredDefaultDestination(), targetClass);
+		return receiveAndConvert(getRequiredDefaultDestination(), targetClass);
 	}
 
 	@SuppressWarnings("unchecked")
 	@Override
 	public <T> T receiveAndConvert(D destination, Class<T> targetClass) {
-		Message<?> message = this.doReceive(destination);
+		Message<?> message = doReceive(destination);
 		if (message != null) {
 			return (T) getMessageConverter().fromMessage(message, targetClass);
 		}
@@ -67,70 +67,63 @@ public <T> T receiveAndConvert(D destination, Class<T> targetClass) {
 
 	@Override
 	public Message<?> sendAndReceive(Message<?> requestMessage) {
-		return this.sendAndReceive(getRequiredDefaultDestination(), requestMessage);
+		return sendAndReceive(getRequiredDefaultDestination(), requestMessage);
 	}
 
 	@Override
 	public Message<?> sendAndReceive(D destination, Message<?> requestMessage) {
-		return this.doSendAndReceive(destination, requestMessage);
+		return doSendAndReceive(destination, requestMessage);
 	}
 
 	protected abstract Message<?> doSendAndReceive(D destination, Message<?> requestMessage);
 
 
 	@Override
 	public <T> T convertSendAndReceive(Object request, Class<T> targetClass) {
-		return this.convertSendAndReceive(getRequiredDefaultDestination(), request, targetClass);
+		return convertSendAndReceive(getRequiredDefaultDestination(), request, targetClass);
 	}
 
 	@Override
 	public <T> T convertSendAndReceive(D destination, Object request, Class<T> targetClass) {
-		Map<String, Object> headers = null;
-		return this.convertSendAndReceive(destination, request, headers, targetClass);
+		return convertSendAndReceive(destination, request, null, targetClass);
 	}
 
 	@Override
-	public <T> T convertSendAndReceive(D destination, Object request, Map<String, Object> headers,
-			Class<T> targetClass) {
-
-		MessagePostProcessor postProcessor = null;
-		return this.convertSendAndReceive(destination, request, headers, targetClass, postProcessor);
+	public <T> T convertSendAndReceive(D destination, Object request, Map<String, Object> headers, Class<T> targetClass) {
+		return convertSendAndReceive(destination, request, headers, targetClass, null);
 	}
 
 	@Override
 	public <T> T convertSendAndReceive(Object request, Class<T> targetClass, MessagePostProcessor postProcessor) {
-		return this.convertSendAndReceive(getRequiredDefaultDestination(), request, targetClass, postProcessor);
+		return convertSendAndReceive(getRequiredDefaultDestination(), request, targetClass, postProcessor);
 	}
 
 	@Override
-	public <T> T convertSendAndReceive(D destination, Object request, Class<T> targetClass,
-			MessagePostProcessor postProcessor) {
-
-		Map<String, Object> headers = null;
-		return this.convertSendAndReceive(destination, request, headers, targetClass, postProcessor);
+	public <T> T convertSendAndReceive(D destination, Object request, Class<T> targetClass, MessagePostProcessor postProcessor) {
+		return convertSendAndReceive(destination, request, null, targetClass, postProcessor);
 	}
 
 	@SuppressWarnings("unchecked")
 	@Override
 	public <T> T convertSendAndReceive(D destination, Object request, Map<String, Object> headers,
 			Class<T> targetClass, MessagePostProcessor postProcessor) {
 
-		MessageHeaders messageHeaders = (headers != null) ? new MessageHeaders(headers) : null;
+		MessageHeaders messageHeaders = (headers != null ? new MessageHeaders(headers) : null);
 		Message<?> requestMessage = getMessageConverter().toMessage(request, messageHeaders);
 
 		if (requestMessage == null) {
-			String payloadType = (request != null) ? request.getClass().getName() : null;
-			throw new MessageConversionException("Unable to convert payload type '"
-					+ payloadType + "', Content-Type=" + messageHeaders.get(MessageHeaders.CONTENT_TYPE)
-					+ ", converter=" + getMessageConverter(), null);
+			String payloadType = (request != null ? request.getClass().getName() : null);
+			Object contentType = (messageHeaders != null ? messageHeaders.get(MessageHeaders.CONTENT_TYPE) : null);
+			throw new MessageConversionException("Unable to convert payload with type '" + payloadType +
+					"', contentType='" + contentType + "', converter=[" + getMessageConverter() + "]");
 		}
 
 		if (postProcessor != null) {
 			requestMessage = postProcessor.postProcessMessage(requestMessage);
 		}
 
-		Message<?> replyMessage = this.sendAndReceive(destination, requestMessage);
-		return (replyMessage != null) ? (T) getMessageConverter().fromMessage(replyMessage, targetClass) : null;
+		Message<?> replyMessage = sendAndReceive(destination, requestMessage);
+		return (replyMessage != null ? (T) getMessageConverter().fromMessage(replyMessage, targetClass) : null);
 	}
 
 }