Subpackage rearrangements within 4.1's jms-messaging alignment

Issue: SPR-10873

spring-jms/src/main/java/org/springframework/jms/annotation/JmsListener.java

@@ -48,7 +48,7 @@ import org.springframework.messaging.handler.annotation.MessageMapping;
  * arguments including the support of validation</li>
  * <li>{@link org.springframework.messaging.handler.annotation.Header @Header}-annotated method
  * arguments to extract a specific header value, including standard JMS headers defined by
- * {@link org.springframework.jms.support.converter.JmsHeaders JmsHeaders}</li>
+ * {@link org.springframework.jms.support.JmsHeaders JmsHeaders}</li>
  * <li>{@link org.springframework.messaging.handler.annotation.Headers @Headers}-annotated
  * argument that must also be assignable to {@link java.util.Map} for getting access to all
  * headers.</li>

spring-jms/src/main/java/org/springframework/jms/messaging/JmsMessageOperations.java → spring-jms/src/main/java/org/springframework/jms/core/JmsMessageOperations.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.jms.messaging;
+package org.springframework.jms.core;
 
 import java.util.Map;
 

spring-jms/src/main/java/org/springframework/jms/messaging/JmsMessagingTemplate.java → spring-jms/src/main/java/org/springframework/jms/core/JmsMessagingTemplate.java

@@ -14,21 +14,17 @@
  * limitations under the License.
  */
 
-package org.springframework.jms.messaging;
+package org.springframework.jms.core;
 
 import java.util.Map;
-
 import javax.jms.Destination;
 import javax.jms.JMSException;
 import javax.jms.Session;
 
 import org.springframework.beans.factory.InitializingBean;
-import org.springframework.jms.core.JmsTemplate;
-import org.springframework.jms.core.MessageCreator;
 import org.springframework.jms.support.converter.MessageConversionException;
 import org.springframework.jms.support.converter.MessageConverter;
 import org.springframework.jms.support.converter.MessagingMessageConverter;
-import org.springframework.jms.support.converter.SimpleJmsHeaderMapper;
 import org.springframework.jms.support.converter.SimpleMessageConverter;
 import org.springframework.messaging.Message;
 import org.springframework.messaging.MessagingException;
@@ -42,17 +38,20 @@ import org.springframework.util.Assert;
  * @author Stephane Nicoll
  * @since 4.1
  */
-public class JmsMessagingTemplate
-		extends AbstractMessageReceivingTemplate<Destination>
+public class JmsMessagingTemplate extends AbstractMessageReceivingTemplate<Destination>
 		implements JmsMessageOperations, InitializingBean {
 
 	private JmsTemplate jmsTemplate;
 
-	private MessageConverter jmsMessageConverter = new MessagingMessageConverter(
-			new SimpleMessageConverter(), new SimpleJmsHeaderMapper());
+	private MessageConverter jmsMessageConverter = new MessagingMessageConverter();
 
 	private String defaultDestinationName;
 
+
+	/**
+	 * Constructor for use with bean properties.
+	 * Requires {@link #setJmsTemplate} to be called.
+	 */
 	public JmsMessagingTemplate() {
 	}
 
@@ -64,6 +63,7 @@ public class JmsMessagingTemplate
 		this.jmsTemplate = jmsTemplate;
 	}
 
+
 	/**
 	 * Set the {@link JmsTemplate} to use.
 	 */
@@ -79,7 +79,6 @@ public class JmsMessagingTemplate
 	 * <p>Consider configuring a {@link MessagingMessageConverter} with a different
 	 * {@link MessagingMessageConverter#setPayloadConverter(MessageConverter) payload converter}
 	 * for more advanced scenario.
-	 *
 	 * @see org.springframework.jms.support.converter.MessagingMessageConverter
 	 */
 	public void setJmsMessageConverter(MessageConverter jmsMessageConverter) {
@@ -150,18 +149,21 @@ public class JmsMessagingTemplate
 	@Override
 	public void convertAndSend(String destinationName, Object payload, Map<String, Object> headers)
 			throws MessagingException {
+
 		convertAndSend(destinationName, payload, headers, null);
 	}
 
 	@Override
 	public void convertAndSend(String destinationName, Object payload, MessagePostProcessor postProcessor)
 			throws MessagingException {
+
 		convertAndSend(destinationName, payload, null, postProcessor);
 	}
 
 	@Override
 	public void convertAndSend(String destinationName, Object payload, Map<String, Object> headers,
 			MessagePostProcessor postProcessor) throws MessagingException {
+
 		Message<?> message = doConvert(payload, headers, postProcessor);
 		send(destinationName, message);
 	}
@@ -206,31 +208,29 @@ public class JmsMessagingTemplate
 
 	@Override
 	protected void doSend(Destination destination, Message<?> message) {
-		jmsTemplate.send(destination, new MessagingMessageCreator(message, this.jmsMessageConverter));
+		this.jmsTemplate.send(destination, new MessagingMessageCreator(message, this.jmsMessageConverter));
 	}
 
 	protected void doSend(String destinationName, Message<?> message) {
-		jmsTemplate.send(destinationName, new MessagingMessageCreator(message, this.jmsMessageConverter));
+		this.jmsTemplate.send(destinationName, new MessagingMessageCreator(message, this.jmsMessageConverter));
 	}
 
 	@Override
 	protected Message<?> doReceive(Destination destination) {
-		javax.jms.Message jmsMessage = jmsTemplate.receive(destination);
+		javax.jms.Message jmsMessage = this.jmsTemplate.receive(destination);
 		return doConvert(jmsMessage);
 	}
 
 	protected Message<?> doReceive(String destinationName) {
-		javax.jms.Message jmsMessage = jmsTemplate.receive(destinationName);
+		javax.jms.Message jmsMessage = this.jmsTemplate.receive(destinationName);
 		return doConvert(jmsMessage);
 	}
 
 	protected String getRequiredDefaultDestinationName() {
 		String name = getDefaultDestinationName();
 		if (name == null) {
-			throw new IllegalStateException(
-					"No 'defaultDestination' or 'defaultDestinationName' specified. " +
-							"Check configuration of JmsMessagingTemplate."
-			);
+			throw new IllegalStateException("No 'defaultDestination' or 'defaultDestinationName' specified. " +
+					"Check configuration of JmsMessagingTemplate.");
 		}
 		return name;
 	}
@@ -240,10 +240,10 @@ public class JmsMessagingTemplate
 			return null;
 		}
 		try {
-			return (Message<?>) jmsMessageConverter.fromMessage(message);
+			return (Message<?>) this.jmsMessageConverter.fromMessage(message);
 		}
-		catch (JMSException e) {
-			throw new MessageConversionException("Could not convert '" + message + "'", e);
+		catch (JMSException ex) {
+			throw new MessageConversionException("Could not convert '" + message + "'", ex);
 		}
 	}
 
@@ -254,14 +254,14 @@ public class JmsMessagingTemplate
 
 		private final MessageConverter messageConverter;
 
-		private MessagingMessageCreator(Message<?> message, MessageConverter messageConverter) {
+		public MessagingMessageCreator(Message<?> message, MessageConverter messageConverter) {
 			this.message = message;
 			this.messageConverter = messageConverter;
 		}
 
 		@Override
 		public javax.jms.Message createMessage(Session session) throws JMSException {
-			return messageConverter.toMessage(message, session);
+			return this.messageConverter.toMessage(this.message, session);
 		}
 	}
 

spring-jms/src/main/java/org/springframework/jms/listener/adapter/AbstractAdaptableMessageListener.java

@@ -28,12 +28,12 @@ import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
 import org.springframework.jms.listener.SessionAwareMessageListener;
+import org.springframework.jms.support.JmsHeaderMapper;
 import org.springframework.jms.support.JmsUtils;
-import org.springframework.jms.support.converter.JmsHeaderMapper;
+import org.springframework.jms.support.SimpleJmsHeaderMapper;
 import org.springframework.jms.support.converter.MessageConversionException;
 import org.springframework.jms.support.converter.MessageConverter;
 import org.springframework.jms.support.converter.MessagingMessageConverter;
-import org.springframework.jms.support.converter.SimpleJmsHeaderMapper;
 import org.springframework.jms.support.converter.SimpleMessageConverter;
 import org.springframework.jms.support.destination.DestinationResolver;
 import org.springframework.jms.support.destination.DynamicDestinationResolver;
@@ -59,18 +59,11 @@ public abstract class AbstractAdaptableMessageListener
 
 	private DestinationResolver destinationResolver = new DynamicDestinationResolver();
 
-	private MessageConverter messageConverter;
+	private MessageConverter messageConverter = new SimpleMessageConverter();
 
-	private MessagingMessageConverterAdapter messagingMessageConverter = new MessagingMessageConverterAdapter();
+	private final MessagingMessageConverterAdapter messagingMessageConverter = new MessagingMessageConverterAdapter();
 
 
-	/**
-	 * Create a new instance with default settings.
-	 */
-	protected AbstractAdaptableMessageListener() {
-		initDefaultStrategies();
-	}
-
 	/**
 	 * Set the default destination to send response messages to. This will be applied
 	 * in case of a request message that does not carry a "JMSReplyTo" field.
@@ -153,14 +146,9 @@ public abstract class AbstractAdaptableMessageListener
 		return this.messageConverter;
 	}
 
-	protected MessageConverter getMessagingMessageConverter() {
-		return this.messagingMessageConverter;
-	}
-
 	/**
-	 * Set the {@link JmsHeaderMapper} implementation to use to map the
-	 * standard JMS headers. By default {@link SimpleJmsHeaderMapper} is
-	 * used
+	 * Set the {@link JmsHeaderMapper} implementation to use to map the standard
+	 * JMS headers. By default, a {@link SimpleJmsHeaderMapper} is used.
 	 * @see SimpleJmsHeaderMapper
 	 */
 	public void setHeaderMapper(JmsHeaderMapper headerMapper) {
@@ -168,6 +156,15 @@ public abstract class AbstractAdaptableMessageListener
 		this.messagingMessageConverter.setHeaderMapper(headerMapper);
 	}
 
+	/**
+	 * Return the{@link MessagingMessageConverter} for this listener,
+	 * being able to convert {@link org.springframework.messaging.Message}.
+	 */
+	protected final MessagingMessageConverter getMessagingMessageConverter() {
+		return this.messagingMessageConverter;
+	}
+
+
 	/**
 	 * Standard JMS {@link MessageListener} entry point.
 	 * <p>Delegates the message to the target listener method, with appropriate
@@ -191,15 +188,6 @@ public abstract class AbstractAdaptableMessageListener
 		}
 	}
 
-	/**
-	 * Initialize the default implementations for the adapter's strategies.
-	 * @see #setMessageConverter
-	 * @see org.springframework.jms.support.converter.SimpleMessageConverter
-	 */
-	protected void initDefaultStrategies() {
-		setMessageConverter(new SimpleMessageConverter());
-	}
-
 	/**
 	 * Handle the given exception that arose during listener execution.
 	 * The default implementation logs the exception at error level.
@@ -228,8 +216,8 @@ public abstract class AbstractAdaptableMessageListener
 			}
 			return message;
 		}
-		catch (JMSException e) {
-			throw new MessageConversionException("Could not unmarshal message", e);
+		catch (JMSException ex) {
+			throw new MessageConversionException("Could not unmarshal message", ex);
 		}
 	}
 
@@ -257,8 +245,8 @@ public abstract class AbstractAdaptableMessageListener
 				Destination destination = getResponseDestination(request, response, session);
 				sendResponse(session, destination, response);
 			}
-			catch (Exception e) {
-				throw new ReplyFailureException("Failed to send reply with payload '" + result + "'", e);
+			catch (Exception ex) {
+				throw new ReplyFailureException("Failed to send reply with payload '" + result + "'", ex);
 			}
 		}
 		else {
@@ -410,6 +398,7 @@ public abstract class AbstractAdaptableMessageListener
 		}
 	}
 
+
 	/**
 	 * Internal class combining a destination name
 	 * and its target destination type (queue or topic).

spring-jms/src/main/java/org/springframework/jms/listener/adapter/MessageListenerAdapter.java

@@ -17,7 +17,6 @@
 package org.springframework.jms.listener.adapter;
 
 import java.lang.reflect.InvocationTargetException;
-
 import javax.jms.JMSException;
 import javax.jms.Message;
 import javax.jms.MessageListener;
@@ -137,7 +136,6 @@ public class MessageListenerAdapter extends AbstractAdaptableMessageListener
 	 * Create a new {@link MessageListenerAdapter} with default settings.
 	 */
 	public MessageListenerAdapter() {
-		initDefaultStrategies();
 		this.delegate = this;
 	}
 
@@ -146,7 +144,6 @@ public class MessageListenerAdapter extends AbstractAdaptableMessageListener
 	 * @param delegate the delegate object
 	 */
 	public MessageListenerAdapter(Object delegate) {
-		initDefaultStrategies();
 		setDelegate(delegate);
 	}
 

spring-jms/src/main/java/org/springframework/jms/listener/adapter/MessagingMessageListenerAdapter.java

@@ -19,7 +19,7 @@ package org.springframework.jms.listener.adapter;
 import javax.jms.JMSException;
 import javax.jms.Session;
 
-import org.springframework.jms.support.converter.JmsHeaderMapper;
+import org.springframework.jms.support.JmsHeaderMapper;
 import org.springframework.jms.support.converter.MessageConversionException;
 import org.springframework.messaging.Message;
 import org.springframework.messaging.MessagingException;
@@ -56,6 +56,7 @@ public class MessagingMessageListenerAdapter extends AbstractAdaptableMessageLis
 		this.handlerMethod = handlerMethod;
 	}
 
+
 	@Override
 	public void onMessage(javax.jms.Message jmsMessage, Session session) throws JMSException {
 		Message<?> message = toMessagingMessage(jmsMessage);
@@ -76,34 +77,34 @@ public class MessagingMessageListenerAdapter extends AbstractAdaptableMessageLis
 		try {
 			return (Message<?>) getMessagingMessageConverter().fromMessage(jmsMessage);
 		}
-		catch (JMSException e) {
-			throw new MessageConversionException("Could not unmarshal message", e);
+		catch (JMSException ex) {
+			throw new MessageConversionException("Could not unmarshal message", ex);
 		}
 	}
 
 	/**
-	 * Invoke the handler, wrapping any exception to a {@link ListenerExecutionFailedException} with
-	 * a dedicated error message.
+	 * Invoke the handler, wrapping any exception to a {@link ListenerExecutionFailedException}
+	 * with a dedicated error message.
 	 */
 	private Object invokeHandler(javax.jms.Message jmsMessage, Session session, Message<?> message) {
 		try {
-			return handlerMethod.invoke(message, jmsMessage, session);
+			return this.handlerMethod.invoke(message, jmsMessage, session);
 		}
-		catch (MessagingException e) {
+		catch (MessagingException ex) {
 			throw new ListenerExecutionFailedException(createMessagingErrorMessage("Listener method could not " +
-					"be invoked with the incoming message"), e);
+					"be invoked with the incoming message"), ex);
 		}
-		catch (Exception e) {
-			throw new ListenerExecutionFailedException("Listener method '"
-					+ handlerMethod.getMethod().toGenericString() + "' threw exception", e);
+		catch (Exception ex) {
+			throw new ListenerExecutionFailedException("Listener method '" +
+					this.handlerMethod.getMethod().toGenericString() + "' threw exception", ex);
 		}
 	}
 
 	private String createMessagingErrorMessage(String description) {
 		StringBuilder sb = new StringBuilder(description).append("\n")
 				.append("Endpoint handler details:\n")
-				.append("Method [").append(handlerMethod.getMethod()).append("]\n")
-				.append("Bean [").append(handlerMethod.getBean()).append("]\n");
+				.append("Method [").append(this.handlerMethod.getMethod()).append("]\n")
+				.append("Bean [").append(this.handlerMethod.getBean()).append("]\n");
 		return sb.toString();
 	}
 

spring-jms/src/main/java/org/springframework/jms/messaging/package-info.java

-/*
- * 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.
- * 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.
- */
-
-/**
- * JMS integration for Spring's messaging module.
- */
-package org.springframework.jms.messaging;
\ No newline at end of file

spring-jms/src/main/java/org/springframework/jms/support/converter/JmsHeaderMapper.java → spring-jms/src/main/java/org/springframework/jms/support/JmsHeaderMapper.java

@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-package org.springframework.jms.support.converter;
+package org.springframework.jms.support;
 
 import javax.jms.Message;
 
-import org.springframework.messaging.mapping.HeaderMapper;
+import org.springframework.messaging.support.HeaderMapper;
 
 /**
  * Strategy interface for mapping messaging Message headers to an outbound

spring-jms/src/main/java/org/springframework/jms/support/converter/JmsHeaders.java → spring-jms/src/main/java/org/springframework/jms/support/JmsHeaders.java

@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-package org.springframework.jms.support.converter;
+package org.springframework.jms.support;
 
 /**
- * Pre-defined names and prefixes to be used for setting and/or retrieving JMS
- * attributes from/to integration Message Headers.
+ * Pre-defined names and prefixes to be used for setting and/or retrieving
+ * JMS attributes from/to generic message headers.
  *
  * @author Mark Fisher
  * @author Stephane Nicoll
@@ -43,7 +43,7 @@ public interface JmsHeaders {
 
 	/**
 	 * Name of the destination (topic or queue) of the message.
-	 * <p>Read only value.
+	 * <p>Read-only value.
 	 * @see javax.jms.Message#getJMSDestination()
 	 * @see javax.jms.Destination
 	 * @see javax.jms.Queue
@@ -53,7 +53,7 @@ public interface JmsHeaders {
 
 	/**
 	 * Distribution mode.
-	 * <p>Read only value.
+	 * <p>Read-only value.
 	 * @see javax.jms.Message#getJMSDeliveryMode()
 	 * @see javax.jms.DeliveryMode
 	 */
@@ -61,21 +61,21 @@ public interface JmsHeaders {
 
 	/**
 	 * Message expiration date and time.
-	 * <p>Read only value.
+	 * <p>Read-only value.
 	 * @see javax.jms.Message#getJMSExpiration()
 	 */
 	public static final String EXPIRATION = PREFIX + "expiration";
 
 	/**
 	 * Unique Identifier for a message.
-	 * <p>Read only value.
+	 * <p>Read-only value.
 	 * @see javax.jms.Message#getJMSMessageID()
 	 */
 	public static final String MESSAGE_ID = PREFIX + "messageId";
 
 	/**
 	 * The message priority level.
-	 * <p>Read only value.
+	 * <p>Read-only value.
 	 * @see javax.jms.Message#getJMSPriority()
 	 */
 	public static final String PRIORITY = PREFIX + "priority";
@@ -90,7 +90,7 @@ public interface JmsHeaders {
 	/**
 	 * Specify if the message was resent. This occurs when a message
 	 * consumer fails to acknowledge the message reception.
-	 * <p>Read only value.
+	 * <p>Read-only value.
 	 * @see javax.jms.Message#getJMSRedelivered()
 	 */
 	public static final String REDELIVERED = PREFIX + "redelivered";
@@ -104,7 +104,7 @@ public interface JmsHeaders {
 
 	/**
 	 * Date and time of the message sending operation.
-	 * <p>Read only value.
+	 * <p>Read-only value.
 	 * @see javax.jms.Message#getJMSTimestamp()
 	 */
 	public static final String TIMESTAMP = PREFIX + "timestamp";

spring-jms/src/main/java/org/springframework/jms/support/JmsMessageHeaderAccessor.java

@@ -18,10 +18,8 @@ package org.springframework.jms.support;
 
 import java.util.List;
 import java.util.Map;
-
 import javax.jms.Destination;
 
-import org.springframework.jms.support.converter.JmsHeaders;
 import org.springframework.messaging.Message;
 import org.springframework.messaging.support.NativeMessageHeaderAccessor;
 
@@ -43,14 +41,6 @@ public class JmsMessageHeaderAccessor extends NativeMessageHeaderAccessor {
 	}
 
 
-	/**
-	 * Create {@link JmsMessageHeaderAccessor} from the headers of an existing message.
-	 */
-	public static JmsMessageHeaderAccessor wrap(Message<?> message) {
-		return new JmsMessageHeaderAccessor(message);
-	}
-
-
 	/**
 	 * Return the {@link JmsHeaders#CORRELATION_ID correlationId}.
 	 * @see JmsHeaders#CORRELATION_ID
@@ -131,4 +121,14 @@ public class JmsMessageHeaderAccessor extends NativeMessageHeaderAccessor {
 		return (Long) getHeader(JmsHeaders.TIMESTAMP);
 	}
 
+
+	// Static factory method
+
+	/**
+	 * Create a {@link JmsMessageHeaderAccessor} from the headers of an existing message.
+	 */
+	public static JmsMessageHeaderAccessor wrap(Message<?> message) {
+		return new JmsMessageHeaderAccessor(message);
+	}
+
 }

spring-jms/src/main/java/org/springframework/jms/support/converter/SimpleJmsHeaderMapper.java → spring-jms/src/main/java/org/springframework/jms/support/SimpleJmsHeaderMapper.java

@@ -14,15 +14,14 @@
  * limitations under the License.
  */
 
-package org.springframework.jms.support.converter;
+package org.springframework.jms.support;
 
 import java.util.Arrays;
 import java.util.Enumeration;
 import java.util.HashMap;
-import java.util.List;
+import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
-
 import javax.jms.Destination;
 import javax.jms.JMSException;
 
@@ -34,16 +33,16 @@ import org.springframework.util.StringUtils;
 
 /**
  * Simple implementation of {@link JmsHeaderMapper}.
- * <p>
- * This implementation copies JMS API headers (e.g. JMSReplyTo) to and from
+ *
+ * <p>This implementation copies JMS API headers (e.g. JMSReplyTo) to and from
  * {@link org.springframework.messaging.Message Messages}. Any user-defined
  * properties will also be copied from a JMS Message to a Message, and any
  * other headers on a Message (beyond the JMS API headers) will likewise
  * be copied to a JMS Message. Those other headers will be copied to the
  * general properties of a JMS Message whereas the JMS API headers are passed
  * to the appropriate setter methods (e.g. setJMSReplyTo).
- * <p>
- * Constants for the JMS API headers are defined in {@link JmsHeaders}.
+ *
+ * <p>Constants for the JMS API headers are defined in {@link JmsHeaders}.
  * Note that most of the JMS headers are read-only: the JMSDestination,
  * JMSDeliveryMode, JMSExpiration, JMSMessageID, JMSPriority, JMSRedelivered
  * and JMSTimestamp flags are only copied <em>from</em> a JMS Message. Those
@@ -51,51 +50,47 @@ import org.springframework.util.StringUtils;
  * JMS Message.
  *
  * @author Mark Fisher
- * @author Gary Russel
+ * @author Gary Russell
  * @since 4.1
  */
 public class SimpleJmsHeaderMapper implements JmsHeaderMapper {
 
-	private static List<Class<?>> SUPPORTED_PROPERTY_TYPES = Arrays.asList(new Class<?>[] {
-			Boolean.class, Byte.class, Double.class, Float.class, Integer.class, Long.class, Short.class, String.class});
+	private static Set<Class<?>> SUPPORTED_PROPERTY_TYPES = new HashSet<Class<?>>(Arrays.asList(new Class<?>[] {
+			Boolean.class, Byte.class, Double.class, Float.class, Integer.class, Long.class, Short.class, String.class}));
 
 
-	private final Log logger = LogFactory.getLog(this.getClass());
+	private final Log logger = LogFactory.getLog(getClass());
 
-	private volatile String inboundPrefix = "";
+	private String inboundPrefix = "";
+
+	private String outboundPrefix = "";
 
-	private volatile String outboundPrefix = "";
 
 	/**
 	 * Specify a prefix to be appended to the message header name for any
 	 * JMS property that is being mapped into the MessageHeaders. The
 	 * default is an empty string (no prefix).
-	 * <p>
-	 * This does not affect the JMS properties covered by the specification/API,
+	 * <p>This does not affect the JMS properties covered by the specification/API,
 	 * such as JMSCorrelationID, etc. The header names used for mapping such
-	 * properties are all defined in our {@link JmsHeaders}.
-	 *
-	 * @param inboundPrefix The inbound prefix.
+	 * properties are all defined in our {@link org.springframework.jms.support.JmsHeaders}.
 	 */
 	public void setInboundPrefix(String inboundPrefix) {
-		this.inboundPrefix = (inboundPrefix != null) ? inboundPrefix : "";
+		this.inboundPrefix = (inboundPrefix != null ? inboundPrefix : "");
 	}
 
 	/**
 	 * Specify a prefix to be appended to the JMS property name for any
 	 * message header that is being mapped into the JMS Message. The
 	 * default is an empty string (no prefix).
-	 * <p>
-	 * This does not affect the JMS properties covered by the specification/API,
+	 * <p>This does not affect the JMS properties covered by the specification/API,
 	 * such as JMSCorrelationID, etc. The header names used for mapping such
-	 * properties are all defined in our {@link JmsHeaders}.
-	 *
-	 * @param outboundPrefix The outbound prefix.
+	 * properties are all defined in our {@link org.springframework.jms.support.JmsHeaders}.
 	 */
 	public void setOutboundPrefix(String outboundPrefix) {
-		this.outboundPrefix = (outboundPrefix != null) ? outboundPrefix : "";
+		this.outboundPrefix = (outboundPrefix != null ? outboundPrefix : "");
 	}
 
+
 	@Override
 	public void fromHeaders(MessageHeaders headers, javax.jms.Message jmsMessage) {
 		try {
@@ -152,15 +147,15 @@ public class SimpleJmsHeaderMapper implements JmsHeaderMapper {
 				}
 			}
 		}
-		catch (Exception e) {
+		catch (Exception ex) {
 			if (logger.isWarnEnabled()) {
-				logger.warn("error occurred while mapping from MessageHeaders to JMS properties", e);
+				logger.warn("error occurred while mapping from MessageHeaders to JMS properties", ex);
 			}
 		}
 	}
 
 	@Override
-	public Map<String, Object> toHeaders(javax.jms.Message jmsMessage) {
+	public MessageHeaders toHeaders(javax.jms.Message jmsMessage) {
 		Map<String, Object> headers = new HashMap<String, Object>();
 		try {
 			try {
@@ -169,8 +164,8 @@ public class SimpleJmsHeaderMapper implements JmsHeaderMapper {
 					headers.put(JmsHeaders.CORRELATION_ID, correlationId);
 				}
 			}
-			catch (Exception e) {
-				logger.info("failed to read JMSCorrelationID property, skipping", e);
+			catch (Exception ex) {
+				logger.info("failed to read JMSCorrelationID property, skipping", ex);
 			}
 			try {
 				Destination destination = jmsMessage.getJMSDestination();
@@ -178,22 +173,22 @@ public class SimpleJmsHeaderMapper implements JmsHeaderMapper {
 					headers.put(JmsHeaders.DESTINATION, destination);
 				}
 			}
-			catch (Exception e) {
-				logger.info("failed to read JMSDestination property, skipping", e);
+			catch (Exception ex) {
+				logger.info("failed to read JMSDestination property, skipping", ex);
 			}
 			try {
 				int deliveryMode = jmsMessage.getJMSDeliveryMode();
 				headers.put(JmsHeaders.DELIVERY_MODE, deliveryMode);
 			}
-			catch (Exception e) {
-				logger.info("failed to read JMSDeliveryMode property, skipping", e);
+			catch (Exception ex) {
+				logger.info("failed to read JMSDeliveryMode property, skipping", ex);
 			}
 			try {
 				long expiration = jmsMessage.getJMSExpiration();
 				headers.put(JmsHeaders.EXPIRATION, expiration);
 			}
-			catch (Exception e) {
-				logger.info("failed to read JMSExpiration property, skipping", e);
+			catch (Exception ex) {
+				logger.info("failed to read JMSExpiration property, skipping", ex);
 			}
 			try {
 				String messageId = jmsMessage.getJMSMessageID();
@@ -201,14 +196,14 @@ public class SimpleJmsHeaderMapper implements JmsHeaderMapper {
 					headers.put(JmsHeaders.MESSAGE_ID, messageId);
 				}
 			}
-			catch (Exception e) {
-				logger.info("failed to read JMSMessageID property, skipping", e);
+			catch (Exception ex) {
+				logger.info("failed to read JMSMessageID property, skipping", ex);
 			}
 			try {
 				headers.put(JmsHeaders.PRIORITY, jmsMessage.getJMSPriority());
 			}
-			catch (Exception e) {
-				logger.info("failed to read JMSPriority property, skipping", e);
+			catch (Exception ex) {
+				logger.info("failed to read JMSPriority property, skipping", ex);
 			}
 			try {
 				Destination replyTo = jmsMessage.getJMSReplyTo();
@@ -216,14 +211,14 @@ public class SimpleJmsHeaderMapper implements JmsHeaderMapper {
 					headers.put(JmsHeaders.REPLY_TO, replyTo);
 				}
 			}
-			catch (Exception e) {
-				logger.info("failed to read JMSReplyTo property, skipping", e);
+			catch (Exception ex) {
+				logger.info("failed to read JMSReplyTo property, skipping", ex);
 			}
 			try {
 				headers.put(JmsHeaders.REDELIVERED, jmsMessage.getJMSRedelivered());
 			}
-			catch (Exception e) {
-				logger.info("failed to read JMSRedelivered property, skipping", e);
+			catch (Exception ex) {
+				logger.info("failed to read JMSRedelivered property, skipping", ex);
 			}
 			try {
 				String type = jmsMessage.getJMSType();
@@ -231,14 +226,14 @@ public class SimpleJmsHeaderMapper implements JmsHeaderMapper {
 					headers.put(JmsHeaders.TYPE, type);
 				}
 			}
-			catch (Exception e) {
-				logger.info("failed to read JMSType property, skipping", e);
+			catch (Exception ex) {
+				logger.info("failed to read JMSType property, skipping", ex);
 			}
 			try {
 				headers.put(JmsHeaders.TIMESTAMP, jmsMessage.getJMSTimestamp());
 			}
-			catch (Exception e) {
-				logger.info("failed to read JMSTimestamp property, skipping", e);
+			catch (Exception ex) {
+				logger.info("failed to read JMSTimestamp property, skipping", ex);
 			}
 
 
@@ -250,21 +245,21 @@ public class SimpleJmsHeaderMapper implements JmsHeaderMapper {
 						String headerName = this.toHeaderName(propertyName);
 						headers.put(headerName, jmsMessage.getObjectProperty(propertyName));
 					}
-					catch (Exception e) {
+					catch (Exception ex) {
 						if (logger.isWarnEnabled()) {
-							logger.warn("error occurred while mapping JMS property '"
-									+ propertyName + "' to Message header", e);
+							logger.warn("Error occurred while mapping JMS property '" + propertyName +
+									"' to Message header", ex);
 						}
 					}
 				}
 			}
 		}
-		catch (JMSException e) {
+		catch (JMSException ex) {
 			if (logger.isWarnEnabled()) {
-				logger.warn("error occurred while mapping from JMS properties to MessageHeaders", e);
+				logger.warn("Error occurred while mapping from JMS properties to MessageHeaders", ex);
 			}
 		}
-		return headers;
+		return new MessageHeaders(headers);
 	}
 
 	/**

spring-jms/src/main/java/org/springframework/jms/support/converter/MessagingMessageConverter.java

@@ -17,19 +17,20 @@
 package org.springframework.jms.support.converter;
 
 import java.util.Map;
-
 import javax.jms.JMSException;
 import javax.jms.Session;
 
 import org.springframework.beans.factory.InitializingBean;
+import org.springframework.jms.support.JmsHeaderMapper;
+import org.springframework.jms.support.SimpleJmsHeaderMapper;
 import org.springframework.messaging.Message;
 import org.springframework.messaging.support.MessageBuilder;
 import org.springframework.util.Assert;
 
 /**
- * Convert a {@link Message} from the messaging abstraction to
- * and from a {@link javax.jms.Message} using an underlying
- * {@link MessageConverter} for the payload and a {@link JmsHeaderMapper}
+ * Convert a {@link Message} from the messaging abstraction to and from a
+ * {@link javax.jms.Message} using an underlying {@link MessageConverter}
+ * for the payload and a {@link org.springframework.jms.support.JmsHeaderMapper}
  * to map the JMS headers to and from standard message headers.
  *
  * @author Stephane Nicoll
@@ -41,10 +42,11 @@ public class MessagingMessageConverter implements MessageConverter, Initializing
 
 	private JmsHeaderMapper headerMapper;
 
+
 	/**
 	 * Create an instance with a default payload converter.
 	 * @see org.springframework.jms.support.converter.SimpleMessageConverter
-	 * @see org.springframework.jms.support.converter.SimpleJmsHeaderMapper
+	 * @see org.springframework.jms.support.SimpleJmsHeaderMapper
 	 */
 	public MessagingMessageConverter() {
 		this(new SimpleMessageConverter(), new SimpleJmsHeaderMapper());
@@ -61,6 +63,7 @@ public class MessagingMessageConverter implements MessageConverter, Initializing
 		this.headerMapper = headerMapper;
 	}
 
+
 	/**
 	 * Set the {@link MessageConverter} to use to convert the payload.
 	 */
@@ -82,13 +85,13 @@ public class MessagingMessageConverter implements MessageConverter, Initializing
 		Assert.notNull(this.headerMapper, "Property 'headerMapper' is required");
 	}
 
+
 	@Override
 	public javax.jms.Message toMessage(Object object, Session session) throws JMSException, MessageConversionException {
 		if (!(object instanceof Message)) {
-			throw new IllegalArgumentException("Could not convert [" + object + "] only ["
-					+ Message.class.getName() + "] is handled by this converter");
+			throw new IllegalArgumentException("Could not convert [" + object + "] - only [" +
+					Message.class.getName() + "] is handled by this converter");
 		}
-
 		Message<?> input = (Message<?>) object;
 		javax.jms.Message reply = this.payloadConverter.toMessage(input.getPayload(), session);
 		this.headerMapper.fromHeaders(input.getHeaders(), reply);
@@ -110,7 +113,7 @@ public class MessagingMessageConverter implements MessageConverter, Initializing
 	}
 
 	/**
-	 * Extract the payload of the specified {@link javax.jms.Message}
+	 * Extract the payload of the specified {@link javax.jms.Message}.
 	 */
 	protected Object extractPayload(javax.jms.Message message) throws JMSException {
 		return this.payloadConverter.fromMessage(message);

spring-jms/src/test/java/org/springframework/jms/config/MethodJmsListenerEndpointTests.java

@@ -50,7 +50,7 @@ import org.springframework.jms.listener.adapter.ReplyFailureException;
 import org.springframework.jms.listener.adapter.ListenerExecutionFailedException;
 import org.springframework.jms.listener.adapter.MessagingMessageListenerAdapter;
 import org.springframework.jms.support.JmsMessageHeaderAccessor;
-import org.springframework.jms.support.converter.JmsHeaders;
+import org.springframework.jms.support.JmsHeaders;
 import org.springframework.jms.support.destination.DestinationResolver;
 import org.springframework.messaging.Message;
 import org.springframework.messaging.MessageHeaders;

spring-jms/src/test/java/org/springframework/jms/messaging/JmsMessagingTemplateTests.java → spring-jms/src/test/java/org/springframework/jms/core/JmsMessagingTemplateTests.java

@@ -14,12 +14,11 @@
  * limitations under the License.
  */
 
-package org.springframework.jms.messaging;
+package org.springframework.jms.core;
 
 import java.io.Writer;
 import java.util.HashMap;
 import java.util.Map;
-
 import javax.jms.Destination;
 import javax.jms.JMSException;
 import javax.jms.Session;
@@ -36,10 +35,8 @@ import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
-import org.springframework.core.convert.support.DefaultConversionService;
+
 import org.springframework.jms.StubTextMessage;
-import org.springframework.jms.core.JmsTemplate;
-import org.springframework.jms.core.MessageCreator;
 import org.springframework.jms.support.converter.MessageConversionException;
 import org.springframework.jms.support.converter.SimpleMessageConverter;
 import org.springframework.messaging.Message;
@@ -317,7 +314,7 @@ public class JmsMessagingTemplateTests {
 		javax.jms.Message jmsMessage = createJmsTextMessage("123");
 		given(jmsTemplate.receive("myQueue")).willReturn(jmsMessage);
 
-		messagingTemplate.setMessageConverter(new GenericMessageConverter(new DefaultConversionService()));
+		messagingTemplate.setMessageConverter(new GenericMessageConverter());
 
 		Integer payload = messagingTemplate.receiveAndConvert("myQueue", Integer.class);
 		assertEquals(Integer.valueOf(123), payload);

spring-jms/src/test/java/org/springframework/jms/support/JmsMessageHeaderAccessorTests.java

@@ -26,7 +26,6 @@ import javax.jms.JMSException;
 import org.junit.Test;
 
 import org.springframework.jms.StubTextMessage;
-import org.springframework.jms.support.converter.SimpleJmsHeaderMapper;
 import org.springframework.messaging.Message;
 import org.springframework.messaging.support.MessageBuilder;
 

spring-jms/src/test/java/org/springframework/jms/support/converter/SimpleJmsHeaderMapperTests.java → spring-jms/src/test/java/org/springframework/jms/support/SimpleJmsHeaderMapperTests.java

@@ -14,13 +14,10 @@
  * limitations under the License.
  */
 
-package org.springframework.jms.support.converter;
-
-import static org.junit.Assert.*;
+package org.springframework.jms.support;
 
 import java.util.Date;
 import java.util.Map;
-
 import javax.jms.DeliveryMode;
 import javax.jms.Destination;
 import javax.jms.JMSException;
@@ -32,6 +29,8 @@ import org.springframework.messaging.Message;
 import org.springframework.messaging.MessageHeaders;
 import org.springframework.messaging.support.MessageBuilder;
 
+import static org.junit.Assert.*;
+
 /**
  *
  * @author Mark Fisher
@@ -42,6 +41,7 @@ public class SimpleJmsHeaderMapperTests {
 
 	private final SimpleJmsHeaderMapper mapper = new SimpleJmsHeaderMapper();
 
+
 	// Outbound mapping
 
 	@Test
@@ -559,4 +559,5 @@ public class SimpleJmsHeaderMapperTests {
 	private MessageBuilder<String> initBuilder() {
 		return MessageBuilder.withPayload("test");
 	}
+
 }

spring-messaging/src/main/java/org/springframework/messaging/mapping/package-info.java

-/*
- * 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.
- * 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.
- */
-
-/**
- * Provides classes related to mapping to/from message headers.
- */
-package org.springframework.messaging.mapping;
\ No newline at end of file

spring-messaging/src/main/java/org/springframework/messaging/mapping/HeaderMapper.java → spring-messaging/src/main/java/org/springframework/messaging/support/HeaderMapper.java

@@ -14,9 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.messaging.mapping;
-
-import java.util.Map;
+package org.springframework.messaging.support;
 
 import org.springframework.messaging.MessageHeaders;
 
@@ -26,12 +24,23 @@ import org.springframework.messaging.MessageHeaders;
  * has a concept of headers or properties (HTTP, JMS, AMQP, etc).
  *
  * @author Mark Fisher
- * @param <T> type of the instance to and from which headers will be mapped.
+ * @since 4.1
+ * @param <T> type of the instance to and from which headers will be mapped
  */
 public interface HeaderMapper<T> {
 
+	/**
+	 * Map from the given {@link MessageHeaders} to the specified target message.
+	 * @param headers the abstracted MessageHeaders
+	 * @param target the native target message
+	 */
 	void fromHeaders(MessageHeaders headers, T target);
 
-	Map<String, Object> toHeaders(T source);
+	/**
+	 * Map from the given target message to abstracted {@link MessageHeaders}.
+	 * @param source the native target message
+	 * @return the abstracted MessageHeaders
+	 */
+	MessageHeaders toHeaders(T source);
 
 }