Update MessagingOperations hieararchy

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

@@ -23,8 +23,10 @@ import org.springframework.util.Assert;
  * @author Mark Fisher
  * @since 4.0
  */
-public abstract class AbstractDestinationResolvingMessagingTemplate<D> extends AbstractReceivingMessagingTemplate<D>
+public abstract class AbstractDestinationResolvingMessagingTemplate<D> extends AbstractMessagingTemplate<D>
-		implements ResolvableDestinationMessageReceivingOperations<D> {
+		implements DestinationResolvingMessageSendingOperations<D>,
+		DestinationResolvingMessageReceivingOperations<D>,
+		DestinationResolvingMessageRequestReplyOperations<D> {
 
 	private volatile DestinationResolver<D> destinationResolver;
 

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

@@ -0,0 +1,101 @@
+/*
+ * 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.core;
+
+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.MessageConverter;
+import org.springframework.util.Assert;
+
+
+/**
+ * @author Mark Fisher
+ * @since 4.0
+ */
+public abstract class AbstractMessageSendingTemplate<D> implements MessageSendingOperations<D> {
+
+	protected final Log logger = LogFactory.getLog(this.getClass());
+
+	private volatile D defaultDestination;
+
+	protected volatile MessageConverter converter = new DefaultMessageConverter();
+
+
+	public void setDefaultDestination(D defaultDestination) {
+		this.defaultDestination = defaultDestination;
+	}
+
+	/**
+	 * Set the {@link MessageConverter} that is to be used to convert
+	 * between Messages and objects for this template.
+	 * <p>The default is {@link DefaultMessageConverter}.
+	 */
+	public void setMessageConverter(MessageConverter messageConverter) {
+		Assert.notNull(messageConverter, "'messageConverter' must not be null");
+		this.converter = messageConverter;
+	}
+
+
+	@Override
+	public <P> void send(Message<P> message) {
+		this.send(getRequiredDefaultDestination(), message);
+	}
+
+	protected final D getRequiredDefaultDestination() {
+		Assert.state(this.defaultDestination != null,
+				"No 'defaultDestination' specified for MessagingTemplate. "
+				+ "Unable to invoke method without an explicit destination argument.");
+		return this.defaultDestination;
+	}
+
+	@Override
+	public <P> void send(D destination, Message<P> message) {
+		this.doSend(destination, message);
+	}
+
+	protected abstract void doSend(D destination, Message<?> message) ;
+
+
+	@Override
+	public <T> void convertAndSend(T message) {
+		this.convertAndSend(getRequiredDefaultDestination(), message);
+	}
+
+	@Override
+	public <T> void convertAndSend(D destination, T object) {
+		this.convertAndSend(destination, object, null);
+	}
+
+	@Override
+	public <T> void convertAndSend(T object, MessagePostProcessor postProcessor) {
+		this.convertAndSend(getRequiredDefaultDestination(), object, postProcessor);
+	}
+
+	@Override
+	public <T> void convertAndSend(D destination, T object, MessagePostProcessor postProcessor)
+			throws MessagingException {
+
+		Message<?> message = this.converter.toMessage(object);
+		if (postProcessor != null) {
+			message = postProcessor.postProcessMessage(message);
+		}
+		this.send(destination, message);
+	}
+
+}

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

@@ -15,87 +15,78 @@
  */
 package org.springframework.messaging.core;
 
-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.MessageConverter;
-import org.springframework.util.Assert;
 
 
 /**
  * @author Mark Fisher
  * @since 4.0
  */
-public abstract class AbstractMessagingTemplate<D> implements MessageSendingOperations<D> {
+public abstract class AbstractMessagingTemplate<D> extends AbstractMessageSendingTemplate<D>
-
+		implements MessageRequestReplyOperations<D>, MessageReceivingOperations<D> {
-	protected final Log logger = LogFactory.getLog(this.getClass());
-
-	private volatile D defaultDestination;
-
-	protected volatile MessageConverter converter = new DefaultMessageConverter();
 
 
-	public void setDefaultDestination(D defaultDestination) {
+	@Override
-		this.defaultDestination = defaultDestination;
+	public <P> Message<P> receive() {
+		return this.receive(getRequiredDefaultDestination());
 	}
 
-	/**
+	@Override
-	 * Set the {@link MessageConverter} that is to be used to convert
+	public <P> Message<P> receive(D destination) {
-	 * between Messages and objects for this template.
+		return this.doReceive(destination);
-	 * <p>The default is {@link DefaultMessageConverter}.
+	}
-	 */
+
-	public void setMessageConverter(MessageConverter messageConverter) {
+	protected abstract <P> Message<P> doReceive(D destination);
-		Assert.notNull(messageConverter, "'messageConverter' must not be null");
+
-		this.converter = messageConverter;
+
+	@Override
+	public Object receiveAndConvert() {
+		return this.receiveAndConvert(getRequiredDefaultDestination());
+	}
+
+	@Override
+	public Object receiveAndConvert(D destination) {
+		Message<Object> message = this.doReceive(destination);
+		return (message != null) ? this.converter.fromMessage(message) : null;
 	}
 
 
 	@Override
-	public <P> void send(Message<P> message) {
+	public Message<?> sendAndReceive(Message<?> requestMessage) {
-		this.send(getRequiredDefaultDestination(), message);
+		return this.sendAndReceive(getRequiredDefaultDestination(), requestMessage);
-	}
-
-	protected final D getRequiredDefaultDestination() {
-		Assert.state(this.defaultDestination != null,
-				"No 'defaultDestination' specified for MessagingTemplate. "
-				+ "Unable to invoke method without an explicit destination argument.");
-		return this.defaultDestination;
 	}
 
 	@Override
-	public <P> void send(D destination, Message<P> message) {
+	public Message<?> sendAndReceive(D destination, Message<?> requestMessage) {
-		this.doSend(destination, message);
+		return this.doSendAndReceive(destination, requestMessage);
 	}
 
-	protected abstract void doSend(D destination, Message<?> message) ;
+	protected abstract <S, R> Message<R> doSendAndReceive(D destination, Message<S> requestMessage);
 
 
 	@Override
-	public <T> void convertAndSend(T message) {
+	public Object convertSendAndReceive(Object request) {
-		this.convertAndSend(getRequiredDefaultDestination(), message);
+		return this.convertSendAndReceive(getRequiredDefaultDestination(), request);
 	}
 
 	@Override
-	public <T> void convertAndSend(D destination, T object) {
+	public Object convertSendAndReceive(D destination, Object request) {
-		this.convertAndSend(destination, object, null);
+		return this.convertSendAndReceive(destination, request, null);
 	}
 
 	@Override
-	public <T> void convertAndSend(T object, MessagePostProcessor postProcessor) {
+	public Object convertSendAndReceive(Object request, MessagePostProcessor postProcessor) {
-		this.convertAndSend(getRequiredDefaultDestination(), object, postProcessor);
+		return this.convertSendAndReceive(getRequiredDefaultDestination(), request, postProcessor);
 	}
 
 	@Override
-	public <T> void convertAndSend(D destination, T object, MessagePostProcessor postProcessor)
+	public Object convertSendAndReceive(D destination, Object request, MessagePostProcessor postProcessor) {
-			throws MessagingException {
+		Message<?> requestMessage = this.converter.toMessage(request);
-
-		Message<?> message = this.converter.toMessage(object);
 		if (postProcessor != null) {
-			message = postProcessor.postProcessMessage(message);
+			requestMessage = postProcessor.postProcessMessage(requestMessage);
 		}
-		this.send(destination, message);
+		Message<?> replyMessage = this.sendAndReceive(destination, requestMessage);
+		return this.converter.fromMessage(replyMessage);
 	}
 
 }

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

@@ -1,92 +0,0 @@
-/*
- * 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.core;
-
-import org.springframework.messaging.Message;
-
-
-/**
- * @author Mark Fisher
- * @since 4.0
- */
-public abstract class AbstractReceivingMessagingTemplate<D>
-		extends AbstractMessagingTemplate<D> implements MessageReceivingOperations<D> {
-
-
-	@Override
-	public <P> Message<P> receive() {
-		return this.receive(getRequiredDefaultDestination());
-	}
-
-	@Override
-	public <P> Message<P> receive(D destination) {
-		return this.doReceive(destination);
-	}
-
-	protected abstract <P> Message<P> doReceive(D destination);
-
-
-	@Override
-	public Object receiveAndConvert() {
-		return this.receiveAndConvert(getRequiredDefaultDestination());
-	}
-
-	@Override
-	public Object receiveAndConvert(D destination) {
-		Message<Object> message = this.doReceive(destination);
-		return (message != null) ? this.converter.fromMessage(message) : null;
-	}
-
-
-	@Override
-	public Message<?> sendAndReceive(Message<?> requestMessage) {
-		return this.sendAndReceive(getRequiredDefaultDestination(), requestMessage);
-	}
-
-	@Override
-	public Message<?> sendAndReceive(D destination, Message<?> requestMessage) {
-		return this.doSendAndReceive(destination, requestMessage);
-	}
-
-	protected abstract <S, R> Message<R> doSendAndReceive(D destination, Message<S> requestMessage);
-
-
-	@Override
-	public Object convertSendAndReceive(Object request) {
-		return this.convertSendAndReceive(getRequiredDefaultDestination(), request);
-	}
-
-	@Override
-	public Object convertSendAndReceive(D destination, Object request) {
-		return this.convertSendAndReceive(destination, request, null);
-	}
-
-	@Override
-	public Object convertSendAndReceive(Object request, MessagePostProcessor postProcessor) {
-		return this.convertSendAndReceive(getRequiredDefaultDestination(), request, postProcessor);
-	}
-
-	@Override
-	public Object convertSendAndReceive(D destination, Object request, MessagePostProcessor postProcessor) {
-		Message<?> requestMessage = this.converter.toMessage(request);
-		if (postProcessor != null) {
-			requestMessage = postProcessor.postProcessMessage(requestMessage);
-		}
-		Message<?> replyMessage = this.sendAndReceive(destination, requestMessage);
-		return this.converter.fromMessage(replyMessage);
-	}
-
-}

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

@@ -0,0 +1,32 @@
+/*
+ * 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.core;
+
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessagingException;
+
+
+/**
+ * @author Mark Fisher
+ * @since 4.0
+ */
+public interface DestinationResolvingMessageReceivingOperations<D> extends MessageReceivingOperations<D> {
+
+	<P> Message<P> receive(String destinationName) throws MessagingException;
+
+	Object receiveAndConvert(String destinationName) throws MessagingException;
+
+}

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

@@ -16,19 +16,13 @@
 package org.springframework.messaging.core;
 
 import org.springframework.messaging.Message;
-import org.springframework.messaging.MessagingException;
 
 
 /**
  * @author Mark Fisher
  * @since 4.0
  */
-public interface ResolvableDestinationMessageReceivingOperations<D>
+public interface DestinationResolvingMessageRequestReplyOperations<D> extends MessageRequestReplyOperations<D> {
-		extends MessageReceivingOperations<D>, ResolvableDestinationMessageSendingOperations<D> {
-
-	<P> Message<P> receive(String destinationName) throws MessagingException;
-
-	Object receiveAndConvert(String destinationName) throws MessagingException;
 
 	Message<?> sendAndReceive(String destinationName, Message<?> requestMessage);
 

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

@@ -23,7 +23,7 @@ import org.springframework.messaging.MessagingException;
  * @author Mark Fisher
  * @since 4.0
  */
-public interface ResolvableDestinationMessageSendingOperations<D> extends MessageSendingOperations<D> {
+public interface DestinationResolvingMessageSendingOperations<D> extends MessageSendingOperations<D> {
 
 	<P> void send(String destinationName, Message<P> message) throws MessagingException;
 

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

@@ -37,7 +37,7 @@ import org.springframework.util.Assert;
  * @author Mark Fisher
  * @since 4.0
  */
-public class DefaultMessagingTemplate extends AbstractDestinationResolvingMessagingTemplate<MessageChannel>
+public class GenericMessagingTemplate extends AbstractDestinationResolvingMessagingTemplate<MessageChannel>
 		implements BeanFactoryAware {
 
 	private volatile long sendTimeout = -1;

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

@@ -23,7 +23,7 @@ import org.springframework.messaging.MessagingException;
  * @author Mark Fisher
  * @since 4.0
  */
-public interface MessageReceivingOperations<D> extends MessageSendingOperations<D> {
+public interface MessageReceivingOperations<D> {
 
 	<P> Message<P> receive() throws MessagingException;
 
@@ -33,16 +33,4 @@ public interface MessageReceivingOperations<D> extends MessageSendingOperations<
 
 	Object receiveAndConvert(D destination) throws MessagingException;
 
-	Message<?> sendAndReceive(Message<?> requestMessage);
-
-	Message<?> sendAndReceive(D destination, Message<?> requestMessage);
-
-	Object convertSendAndReceive(Object request);
-
-	Object convertSendAndReceive(D destination, Object request);
-
-	Object convertSendAndReceive(Object request, MessagePostProcessor requestPostProcessor);
-
-	Object convertSendAndReceive(D destination, Object request, MessagePostProcessor requestPostProcessor);
-
 }

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

@@ -0,0 +1,39 @@
+/*
+ * 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.core;
+
+import org.springframework.messaging.Message;
+
+
+/**
+ * @author Mark Fisher
+ * @since 4.0
+ */
+public interface MessageRequestReplyOperations<D> {
+
+	Message<?> sendAndReceive(Message<?> requestMessage);
+
+	Message<?> sendAndReceive(D destination, Message<?> requestMessage);
+
+	Object convertSendAndReceive(Object request);
+
+	Object convertSendAndReceive(D destination, Object request);
+
+	Object convertSendAndReceive(Object request, MessagePostProcessor requestPostProcessor);
+
+	Object convertSendAndReceive(D destination, Object request, MessagePostProcessor requestPostProcessor);
+
+}

spring-websocket/src/main/java/org/springframework/web/messaging/support/WebMessagingTemplate.java

@@ -3,13 +3,13 @@ package org.springframework.web.messaging.support;
 import org.springframework.messaging.Message;
 import org.springframework.messaging.MessageChannel;
 import org.springframework.messaging.MessageDeliveryException;
-import org.springframework.messaging.core.AbstractMessagingTemplate;
+import org.springframework.messaging.core.AbstractMessageSendingTemplate;
 import org.springframework.messaging.support.MessageBuilder;
 import org.springframework.util.Assert;
 import org.springframework.web.messaging.MessageType;
 
 
-public class WebMessagingTemplate extends AbstractMessagingTemplate<String> {
+public class WebMessagingTemplate extends AbstractMessageSendingTemplate<String> {
 
 	private final MessageChannel outputChannel;