Subpackage rearrangements within 4.1's jms-messaging alignment

Issue: SPR-10873

Author: jhoeller

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

@@ -48,7 +48,7 @@
  * 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 renamed to 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 renamed to 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 @@
  * @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 JmsMessagingTemplate(JmsTemplate jmsTemplate) {
 		this.jmsTemplate = jmsTemplate;
 	}
 
+
 	/**
 	 * Set the {@link JmsTemplate} to use.
 	 */
@@ -79,7 +79,6 @@ public void setJmsTemplate(JmsTemplate jmsTemplate) {
 	 * <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 void convertAndSend(String destinationName, Object payload) throws Messag
 	@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 <T> T receiveAndConvert(String destinationName, Class<T> targetClass) thr
 
 	@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 @@ protected Message<?> doConvert(javax.jms.Message message) {
 			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 @@ private static class MessagingMessageCreator implements MessageCreator {
 
 		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.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,21 +146,25 @@ protected MessageConverter getMessageConverter() {
 		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) {
 		Assert.notNull(headerMapper, "HeaderMapper must not be null");
 		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 void onMessage(Message message) {
 		}
 	}
 
-	/**
-	 * 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 @@ protected Object extractMessage(Message message)  {
 			}
 			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 @@ protected void handleResult(Object result, Message request, Session session) {
 				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 @@ protected Object extractPayload(Message message) throws JMSException {
 		}
 	}
 
+
 	/**
 	 * 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 MessageListenerAdapter() {
 	 * @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 @@
 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 void setHandlerMethod(InvocableHandlerMethod handlerMethod) {
 		this.handlerMethod = handlerMethod;
 	}
 
+
 	@Override
 	public void onMessage(javax.jms.Message jmsMessage, Session session) throws JMSException {
 		Message<?> message = toMessagingMessage(jmsMessage);
@@ -76,34 +77,34 @@ protected Message<?> toMessagingMessage(javax.jms.Message jmsMessage) {
 		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();
 	}