Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update MessagingOperations hieararchy

Browse Source
This commit is contained in:
Rossen Stoyanchev
2013-07-05 10:59:04 -04:00
parent ef823721e5
commit 9dd7f6e5fb
11 changed files with 220 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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

101
spring-context/src/main/java/org/springframework/messaging/core/AbstractMessageSendingTemplate.java Normal file
View File

@@ -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);
}
}

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

@@ -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> {
protected final Log logger = LogFactory.getLog(this.getClass());
private volatile D defaultDestination;
protected volatile MessageConverter converter = new DefaultMessageConverter();
public abstract class AbstractMessagingTemplate<D> extends AbstractMessageSendingTemplate<D>
implements MessageRequestReplyOperations<D>, MessageReceivingOperations<D> {
public void setDefaultDestination(D defaultDestination) {
this.defaultDestination = defaultDestination;
@Override
public <P> Message<P> receive() {
return this.receive(getRequiredDefaultDestination());
}
/**
* 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> 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 <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;
public Message<?> sendAndReceive(Message<?> requestMessage) {
return this.sendAndReceive(getRequiredDefaultDestination(), requestMessage);
}
@Override
public <P> void send(D destination, Message<P> message) {
this.doSend(destination, message);
public Message<?> sendAndReceive(D destination, Message<?> requestMessage) {
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) {
this.convertAndSend(getRequiredDefaultDestination(), message);
public Object convertSendAndReceive(Object request) {
return this.convertSendAndReceive(getRequiredDefaultDestination(), request);
}
@Override
public <T> void convertAndSend(D destination, T object) {
this.convertAndSend(destination, object, null);
public Object convertSendAndReceive(D destination, Object request) {
return this.convertSendAndReceive(destination, request, null);
}
@Override
public <T> void convertAndSend(T object, MessagePostProcessor postProcessor) {
this.convertAndSend(getRequiredDefaultDestination(), object, postProcessor);
public Object convertSendAndReceive(Object request, MessagePostProcessor postProcessor) {
return this.convertSendAndReceive(getRequiredDefaultDestination(), request, postProcessor);
}
@Override
public <T> void convertAndSend(D destination, T object, MessagePostProcessor postProcessor)
throws MessagingException {
Message<?> message = this.converter.toMessage(object);
public Object convertSendAndReceive(D destination, Object request, MessagePostProcessor postProcessor) {
Message<?> requestMessage = this.converter.toMessage(request);
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);
}
}

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

@@ -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);
}
}

32
spring-context/src/main/java/org/springframework/messaging/core/DestinationResolvingMessageReceivingOperations.java Normal file
View File

@@ -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;
}

8
spring-context/src/main/java/org/springframework/messaging/core/ResolvableDestinationMessageReceivingOperations.java → spring-context/src/main/java/org/springframework/messaging/core/DestinationResolvingMessageRequestReplyOperations.java
View File

@@ -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>
extends MessageReceivingOperations<D>, ResolvableDestinationMessageSendingOperations<D> {
<P> Message<P> receive(String destinationName) throws MessagingException;
Object receiveAndConvert(String destinationName) throws MessagingException;
public interface DestinationResolvingMessageRequestReplyOperations<D> extends MessageRequestReplyOperations<D> {
Message<?> sendAndReceive(String destinationName, Message<?> requestMessage);

2
spring-context/src/main/java/org/springframework/messaging/core/ResolvableDestinationMessageSendingOperations.java → spring-context/src/main/java/org/springframework/messaging/core/DestinationResolvingMessageSendingOperations.java
View File

@@ -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;

2
spring-context/src/main/java/org/springframework/messaging/core/DefaultMessagingTemplate.java → spring-context/src/main/java/org/springframework/messaging/core/GenericMessagingTemplate.java
View File

@@ -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;

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

@@ -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);
}

39
spring-context/src/main/java/org/springframework/messaging/core/MessageRequestReplyOperations.java Normal file
View File

@@ -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);
}