root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

Reuse JmsTemplate's MessageConverter in JmsMessagingTemplate 

This commit makes sure that any custom MessageConverter set in a
JmsTemplate used by a JmsMessagingTemplate is reused as the payload
converter of the message.

Issue: SPR-15965

(cherry picked from commit b275a06)
This commit is contained in:
Stephane Nicoll 2017-09-18 14:27:47 +02:00 committed by Juergen Hoeller
parent 5e904ddcaa
commit 35af7ff854
4 changed files with 231 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
spring-jms/src/main/java/org/springframework/jms/core/JmsMessagingTemplate.java
View File

@ -50,6 +50,8 @@ public class JmsMessagingTemplate extends AbstractMessagingTemplate<Destination>
private MessageConverter jmsMessageConverter = new MessagingMessageConverter(); private MessageConverter jmsMessageConverter = new MessagingMessageConverter();
private boolean converterSet;
private String defaultDestinationName; private String defaultDestinationName;
@ -126,6 +128,7 @@ public class JmsMessagingTemplate extends AbstractMessagingTemplate<Destination>
public void setJmsMessageConverter(MessageConverter jmsMessageConverter) { public void setJmsMessageConverter(MessageConverter jmsMessageConverter) {
Assert.notNull(jmsMessageConverter, "MessageConverter must not be null"); Assert.notNull(jmsMessageConverter, "MessageConverter must not be null");
this.jmsMessageConverter = jmsMessageConverter; this.jmsMessageConverter = jmsMessageConverter;
this.converterSet = true;
} }
/** /**
@ -155,7 +158,11 @@ public class JmsMessagingTemplate extends AbstractMessagingTemplate<Destination>
@Override @Override
public void afterPropertiesSet() { public void afterPropertiesSet() {
Assert.notNull(getJmsTemplate(), "Property 'connectionFactory' or 'jmsTemplate' is required"); Assert.notNull(this.jmsTemplate, "Property 'connectionFactory' or 'jmsTemplate' is required");
if (!this.converterSet && this.jmsTemplate.getMessageConverter() != null) {
((MessagingMessageConverter) this.jmsMessageConverter)
.setPayloadConverter(this.jmsTemplate.getMessageConverter());
}
} }

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

@ -54,6 +54,15 @@ public class MessagingMessageConverter implements MessageConverter, Initializing
this(new SimpleMessageConverter(), new SimpleJmsHeaderMapper()); this(new SimpleMessageConverter(), new SimpleJmsHeaderMapper());
} }
/**
* Create an instance with the specific payload converter.
* @param payloadConverter the payload converter to use
* @since 4.3.12
*/
public MessagingMessageConverter(MessageConverter payloadConverter) {
this(payloadConverter, new SimpleJmsHeaderMapper());
}
/** /**
* Create an instance with the specified payload converter and * Create an instance with the specified payload converter and
* header mapper. * header mapper.

387
spring-jms/src/test/java/org/springframework/jms/core/JmsMessagingTemplateTests.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2014 the original author or authors. * Copyright 2002-2017 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -36,13 +36,14 @@ import org.mockito.BDDMockito;
import org.mockito.Captor; import org.mockito.Captor;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.MockitoAnnotations; import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer; import org.mockito.stubbing.Answer;
import org.springframework.beans.DirectFieldAccessor;
import org.springframework.jms.InvalidDestinationException; import org.springframework.jms.InvalidDestinationException;
import org.springframework.jms.MessageNotReadableException; import org.springframework.jms.MessageNotReadableException;
import org.springframework.jms.StubTextMessage; import org.springframework.jms.StubTextMessage;
import org.springframework.jms.support.converter.MessageConverter; import org.springframework.jms.support.converter.MessageConverter;
import org.springframework.jms.support.converter.MessagingMessageConverter;
import org.springframework.jms.support.converter.SimpleMessageConverter; import org.springframework.jms.support.converter.SimpleMessageConverter;
import org.springframework.jms.support.destination.DestinationResolutionException; import org.springframework.jms.support.destination.DestinationResolutionException;
import org.springframework.messaging.Message; import org.springframework.messaging.Message;
@ -54,6 +55,8 @@ import static org.junit.Assert.*;
import static org.mockito.BDDMockito.*; import static org.mockito.BDDMockito.*;
/** /**
* Tests for {@link JmsMessagingTemplate}.
*
* @author Stephane Nicoll * @author Stephane Nicoll
*/ */
public class JmsMessagingTemplateTests { public class JmsMessagingTemplateTests {
@ -73,12 +76,53 @@ public class JmsMessagingTemplateTests {
@Before @Before
public void setup() { public void setup() {
MockitoAnnotations.initMocks(this); MockitoAnnotations.initMocks(this);
messagingTemplate = new JmsMessagingTemplate(jmsTemplate); this.messagingTemplate = new JmsMessagingTemplate(this.jmsTemplate);
} }
@Test @Test
public void validateJmsTemplate() { public void validateJmsTemplate() {
assertSame(this.jmsTemplate, messagingTemplate.getJmsTemplate()); assertSame(this.jmsTemplate, this.messagingTemplate.getJmsTemplate());
}
@Test
public void payloadConverterIsConsistentConstructor() {
MessageConverter messageConverter = mock(MessageConverter.class);
given(this.jmsTemplate.getMessageConverter()).willReturn(messageConverter);
JmsMessagingTemplate messagingTemplate = new JmsMessagingTemplate(this.jmsTemplate);
messagingTemplate.afterPropertiesSet();
assertPayloadConverter(messagingTemplate, messageConverter);
}
@Test
public void payloadConverterIsConsistentSetter() {
MessageConverter messageConverter = mock(MessageConverter.class);
given(this.jmsTemplate.getMessageConverter()).willReturn(messageConverter);
JmsMessagingTemplate messagingTemplate = new JmsMessagingTemplate();
messagingTemplate.setJmsTemplate(this.jmsTemplate);
messagingTemplate.afterPropertiesSet();
assertPayloadConverter(messagingTemplate, messageConverter);
}
@Test
public void customConverterAlwaysTakesPrecedence() {
MessageConverter messageConverter = mock(MessageConverter.class);
given(this.jmsTemplate.getMessageConverter()).willReturn(messageConverter);
MessageConverter customMessageConverter = mock(MessageConverter.class);
JmsMessagingTemplate messagingTemplate = new JmsMessagingTemplate();
messagingTemplate.setJmsMessageConverter(
new MessagingMessageConverter(customMessageConverter));
messagingTemplate.setJmsTemplate(this.jmsTemplate);
messagingTemplate.afterPropertiesSet();
assertPayloadConverter(messagingTemplate, customMessageConverter);
}
private void assertPayloadConverter(JmsMessagingTemplate messagingTemplate,
MessageConverter messageConverter) {
MessageConverter jmsMessageConverter = messagingTemplate.getJmsMessageConverter();
assertNotNull(jmsMessageConverter);
assertEquals(MessagingMessageConverter.class, jmsMessageConverter.getClass());
assertSame(messageConverter, new DirectFieldAccessor(jmsMessageConverter)
.getPropertyValue("payloadConverter"));
} }
@Test @Test
@ -86,110 +130,110 @@ public class JmsMessagingTemplateTests {
Destination destination = new Destination() {}; Destination destination = new Destination() {};
Message<String> message = createTextMessage(); Message<String> message = createTextMessage();
messagingTemplate.send(destination, message); this.messagingTemplate.send(destination, message);
verify(jmsTemplate).send(eq(destination), messageCreator.capture()); verify(this.jmsTemplate).send(eq(destination), this.messageCreator.capture());
assertTextMessage(messageCreator.getValue()); assertTextMessage(this.messageCreator.getValue());
} }
@Test @Test
public void sendName() { public void sendName() {
Message<String> message = createTextMessage(); Message<String> message = createTextMessage();
messagingTemplate.send("myQueue", message); this.messagingTemplate.send("myQueue", message);
verify(jmsTemplate).send(eq("myQueue"), messageCreator.capture()); verify(this.jmsTemplate).send(eq("myQueue"), this.messageCreator.capture());
assertTextMessage(messageCreator.getValue()); assertTextMessage(this.messageCreator.getValue());
} }
@Test @Test
public void sendDefaultDestination() { public void sendDefaultDestination() {
Destination destination = new Destination() {}; Destination destination = new Destination() {};
messagingTemplate.setDefaultDestination(destination); this.messagingTemplate.setDefaultDestination(destination);
Message<String> message = createTextMessage(); Message<String> message = createTextMessage();
messagingTemplate.send(message); this.messagingTemplate.send(message);
verify(jmsTemplate).send(eq(destination), messageCreator.capture()); verify(this.jmsTemplate).send(eq(destination), this.messageCreator.capture());
assertTextMessage(messageCreator.getValue()); assertTextMessage(this.messageCreator.getValue());
} }
@Test @Test
public void sendDefaultDestinationName() { public void sendDefaultDestinationName() {
messagingTemplate.setDefaultDestinationName("myQueue"); this.messagingTemplate.setDefaultDestinationName("myQueue");
Message<String> message = createTextMessage(); Message<String> message = createTextMessage();
messagingTemplate.send(message); this.messagingTemplate.send(message);
verify(jmsTemplate).send(eq("myQueue"), messageCreator.capture()); verify(this.jmsTemplate).send(eq("myQueue"), this.messageCreator.capture());
assertTextMessage(messageCreator.getValue()); assertTextMessage(this.messageCreator.getValue());
} }
@Test @Test
public void sendNoDefaultSet() { public void sendNoDefaultSet() {
Message<String> message = createTextMessage(); Message<String> message = createTextMessage();
thrown.expect(IllegalStateException.class); this.thrown.expect(IllegalStateException.class);
messagingTemplate.send(message); this.messagingTemplate.send(message);
} }
@Test @Test
public void sendPropertyInjection() { public void sendPropertyInjection() {
JmsMessagingTemplate t = new JmsMessagingTemplate(); JmsMessagingTemplate t = new JmsMessagingTemplate();
t.setJmsTemplate(jmsTemplate); t.setJmsTemplate(this.jmsTemplate);
t.setDefaultDestinationName("myQueue"); t.setDefaultDestinationName("myQueue");
t.afterPropertiesSet(); t.afterPropertiesSet();
Message<String> message = createTextMessage(); Message<String> message = createTextMessage();
t.send(message); t.send(message);
verify(jmsTemplate).send(eq("myQueue"), messageCreator.capture()); verify(this.jmsTemplate).send(eq("myQueue"), this.messageCreator.capture());
assertTextMessage(messageCreator.getValue()); assertTextMessage(this.messageCreator.getValue());
} }
@Test @Test
public void convertAndSendPayload() throws JMSException { public void convertAndSendPayload() throws JMSException {
Destination destination = new Destination() {}; Destination destination = new Destination() {};
messagingTemplate.convertAndSend(destination, "my Payload"); this.messagingTemplate.convertAndSend(destination, "my Payload");
verify(jmsTemplate).send(eq(destination), messageCreator.capture()); verify(this.jmsTemplate).send(eq(destination), this.messageCreator.capture());
TextMessage textMessage = createTextMessage(messageCreator.getValue()); TextMessage textMessage = createTextMessage(this.messageCreator.getValue());
assertEquals("my Payload", textMessage.getText()); assertEquals("my Payload", textMessage.getText());
} }
@Test @Test
public void convertAndSendPayloadName() throws JMSException { public void convertAndSendPayloadName() throws JMSException {
messagingTemplate.convertAndSend("myQueue", "my Payload"); this.messagingTemplate.convertAndSend("myQueue", "my Payload");
verify(jmsTemplate).send(eq("myQueue"), messageCreator.capture()); verify(this.jmsTemplate).send(eq("myQueue"), this.messageCreator.capture());
TextMessage textMessage = createTextMessage(messageCreator.getValue()); TextMessage textMessage = createTextMessage(this.messageCreator.getValue());
assertEquals("my Payload", textMessage.getText()); assertEquals("my Payload", textMessage.getText());
} }
@Test @Test
public void convertAndSendDefaultDestination() throws JMSException { public void convertAndSendDefaultDestination() throws JMSException {
Destination destination = new Destination() {}; Destination destination = new Destination() {};
messagingTemplate.setDefaultDestination(destination); this.messagingTemplate.setDefaultDestination(destination);
messagingTemplate.convertAndSend("my Payload"); this.messagingTemplate.convertAndSend("my Payload");
verify(jmsTemplate).send(eq(destination), messageCreator.capture()); verify(this.jmsTemplate).send(eq(destination), this.messageCreator.capture());
TextMessage textMessage = createTextMessage(messageCreator.getValue()); TextMessage textMessage = createTextMessage(this.messageCreator.getValue());
assertEquals("my Payload", textMessage.getText()); assertEquals("my Payload", textMessage.getText());
} }
@Test @Test
public void convertAndSendDefaultDestinationName() throws JMSException { public void convertAndSendDefaultDestinationName() throws JMSException {
messagingTemplate.setDefaultDestinationName("myQueue"); this.messagingTemplate.setDefaultDestinationName("myQueue");
messagingTemplate.convertAndSend("my Payload"); this.messagingTemplate.convertAndSend("my Payload");
verify(jmsTemplate).send(eq("myQueue"), messageCreator.capture()); verify(this.jmsTemplate).send(eq("myQueue"), this.messageCreator.capture());
TextMessage textMessage = createTextMessage(messageCreator.getValue()); TextMessage textMessage = createTextMessage(this.messageCreator.getValue());
assertEquals("my Payload", textMessage.getText()); assertEquals("my Payload", textMessage.getText());
} }
@Test @Test
public void convertAndSendNoDefaultSet() throws JMSException { public void convertAndSendNoDefaultSet() throws JMSException {
thrown.expect(IllegalStateException.class); this.thrown.expect(IllegalStateException.class);
messagingTemplate.convertAndSend("my Payload"); this.messagingTemplate.convertAndSend("my Payload");
} }
@Test @Test
public void convertAndSendCustomJmsMessageConverter() throws JMSException { public void convertAndSendCustomJmsMessageConverter() throws JMSException {
messagingTemplate.setJmsMessageConverter(new SimpleMessageConverter() { this.messagingTemplate.setJmsMessageConverter(new SimpleMessageConverter() {
@Override @Override
public javax.jms.Message toMessage(Object object, Session session) public javax.jms.Message toMessage(Object object, Session session)
throws JMSException, org.springframework.jms.support.converter.MessageConversionException { throws JMSException, org.springframework.jms.support.converter.MessageConversionException {
@ -197,155 +241,155 @@ public class JmsMessagingTemplateTests {
} }
}); });
messagingTemplate.convertAndSend("myQueue", "msg to convert"); this.messagingTemplate.convertAndSend("myQueue", "msg to convert");
verify(jmsTemplate).send(eq("myQueue"), messageCreator.capture()); verify(this.jmsTemplate).send(eq("myQueue"), this.messageCreator.capture());
thrown.expect(org.springframework.messaging.converter.MessageConversionException.class); this.thrown.expect(org.springframework.messaging.converter.MessageConversionException.class);
thrown.expectMessage(new StringContains("Test exception")); this.thrown.expectMessage(new StringContains("Test exception"));
messageCreator.getValue().createMessage(mock(Session.class)); this.messageCreator.getValue().createMessage(mock(Session.class));
} }
@Test @Test
public void convertAndSendPayloadAndHeaders() throws JMSException { public void convertAndSendPayloadAndHeaders() throws JMSException {
Destination destination = new Destination() {}; Destination destination = new Destination() {};
Map<String, Object> headers = new HashMap<String, Object>(); Map<String, Object> headers = new HashMap<>();
headers.put("foo", "bar"); headers.put("foo", "bar");
messagingTemplate.convertAndSend(destination, "Hello", headers); this.messagingTemplate.convertAndSend(destination, "Hello", headers);
verify(jmsTemplate).send(eq(destination), messageCreator.capture()); verify(this.jmsTemplate).send(eq(destination), this.messageCreator.capture());
assertTextMessage(messageCreator.getValue()); // see createTextMessage assertTextMessage(this.messageCreator.getValue()); // see createTextMessage
} }
@Test @Test
public void convertAndSendPayloadAndHeadersName() throws JMSException { public void convertAndSendPayloadAndHeadersName() throws JMSException {
Map<String, Object> headers = new HashMap<String, Object>(); Map<String, Object> headers = new HashMap<>();
headers.put("foo", "bar"); headers.put("foo", "bar");
messagingTemplate.convertAndSend("myQueue", "Hello", headers); this.messagingTemplate.convertAndSend("myQueue", "Hello", headers);
verify(jmsTemplate).send(eq("myQueue"), messageCreator.capture()); verify(this.jmsTemplate).send(eq("myQueue"), this.messageCreator.capture());
assertTextMessage(messageCreator.getValue()); // see createTextMessage assertTextMessage(this.messageCreator.getValue()); // see createTextMessage
} }
@Test @Test
public void receive() { public void receive() {
Destination destination = new Destination() {}; Destination destination = new Destination() {};
javax.jms.Message jmsMessage = createJmsTextMessage(); javax.jms.Message jmsMessage = createJmsTextMessage();
given(jmsTemplate.receive(destination)).willReturn(jmsMessage); given(this.jmsTemplate.receive(destination)).willReturn(jmsMessage);
Message<?> message = messagingTemplate.receive(destination); Message<?> message = this.messagingTemplate.receive(destination);
verify(jmsTemplate).receive(destination); verify(this.jmsTemplate).receive(destination);
assertTextMessage(message); assertTextMessage(message);
} }
@Test @Test
public void receiveName() { public void receiveName() {
javax.jms.Message jmsMessage = createJmsTextMessage(); javax.jms.Message jmsMessage = createJmsTextMessage();
given(jmsTemplate.receive("myQueue")).willReturn(jmsMessage); given(this.jmsTemplate.receive("myQueue")).willReturn(jmsMessage);
Message<?> message = messagingTemplate.receive("myQueue"); Message<?> message = this.messagingTemplate.receive("myQueue");
verify(jmsTemplate).receive("myQueue"); verify(this.jmsTemplate).receive("myQueue");
assertTextMessage(message); assertTextMessage(message);
} }
@Test @Test
public void receiveDefaultDestination() { public void receiveDefaultDestination() {
Destination destination = new Destination() {}; Destination destination = new Destination() {};
messagingTemplate.setDefaultDestination(destination); this.messagingTemplate.setDefaultDestination(destination);
javax.jms.Message jmsMessage = createJmsTextMessage(); javax.jms.Message jmsMessage = createJmsTextMessage();
given(jmsTemplate.receive(destination)).willReturn(jmsMessage); given(this.jmsTemplate.receive(destination)).willReturn(jmsMessage);
Message<?> message = messagingTemplate.receive(); Message<?> message = this.messagingTemplate.receive();
verify(jmsTemplate).receive(destination); verify(this.jmsTemplate).receive(destination);
assertTextMessage(message); assertTextMessage(message);
} }
@Test @Test
public void receiveDefaultDestinationName() { public void receiveDefaultDestinationName() {
messagingTemplate.setDefaultDestinationName("myQueue"); this.messagingTemplate.setDefaultDestinationName("myQueue");
javax.jms.Message jmsMessage = createJmsTextMessage(); javax.jms.Message jmsMessage = createJmsTextMessage();
given(jmsTemplate.receive("myQueue")).willReturn(jmsMessage); given(this.jmsTemplate.receive("myQueue")).willReturn(jmsMessage);
Message<?> message = messagingTemplate.receive(); Message<?> message = this.messagingTemplate.receive();
verify(jmsTemplate).receive("myQueue"); verify(this.jmsTemplate).receive("myQueue");
assertTextMessage(message); assertTextMessage(message);
} }
@Test @Test
public void receiveNoDefaultSet() { public void receiveNoDefaultSet() {
thrown.expect(IllegalStateException.class); this.thrown.expect(IllegalStateException.class);
messagingTemplate.receive(); this.messagingTemplate.receive();
} }
@Test @Test
public void receiveAndConvert() { public void receiveAndConvert() {
Destination destination = new Destination() {}; Destination destination = new Destination() {};
javax.jms.Message jmsMessage = createJmsTextMessage("my Payload"); javax.jms.Message jmsMessage = createJmsTextMessage("my Payload");
given(jmsTemplate.receive(destination)).willReturn(jmsMessage); given(this.jmsTemplate.receive(destination)).willReturn(jmsMessage);
String payload = messagingTemplate.receiveAndConvert(destination, String.class); String payload = this.messagingTemplate.receiveAndConvert(destination, String.class);
assertEquals("my Payload", payload); assertEquals("my Payload", payload);
verify(jmsTemplate).receive(destination); verify(this.jmsTemplate).receive(destination);
} }
@Test @Test
public void receiveAndConvertName() { public void receiveAndConvertName() {
javax.jms.Message jmsMessage = createJmsTextMessage("my Payload"); javax.jms.Message jmsMessage = createJmsTextMessage("my Payload");
given(jmsTemplate.receive("myQueue")).willReturn(jmsMessage); given(this.jmsTemplate.receive("myQueue")).willReturn(jmsMessage);
String payload = messagingTemplate.receiveAndConvert("myQueue", String.class); String payload = this.messagingTemplate.receiveAndConvert("myQueue", String.class);
assertEquals("my Payload", payload); assertEquals("my Payload", payload);
verify(jmsTemplate).receive("myQueue"); verify(this.jmsTemplate).receive("myQueue");
} }
@Test @Test
public void receiveAndConvertDefaultDestination() { public void receiveAndConvertDefaultDestination() {
Destination destination = new Destination() {}; Destination destination = new Destination() {};
messagingTemplate.setDefaultDestination(destination); this.messagingTemplate.setDefaultDestination(destination);
javax.jms.Message jmsMessage = createJmsTextMessage("my Payload"); javax.jms.Message jmsMessage = createJmsTextMessage("my Payload");
given(jmsTemplate.receive(destination)).willReturn(jmsMessage); given(this.jmsTemplate.receive(destination)).willReturn(jmsMessage);
String payload = messagingTemplate.receiveAndConvert(String.class); String payload = this.messagingTemplate.receiveAndConvert(String.class);
assertEquals("my Payload", payload); assertEquals("my Payload", payload);
verify(jmsTemplate).receive(destination); verify(this.jmsTemplate).receive(destination);
} }
@Test @Test
public void receiveAndConvertDefaultDestinationName() { public void receiveAndConvertDefaultDestinationName() {
messagingTemplate.setDefaultDestinationName("myQueue"); this.messagingTemplate.setDefaultDestinationName("myQueue");
javax.jms.Message jmsMessage = createJmsTextMessage("my Payload"); javax.jms.Message jmsMessage = createJmsTextMessage("my Payload");
given(jmsTemplate.receive("myQueue")).willReturn(jmsMessage); given(this.jmsTemplate.receive("myQueue")).willReturn(jmsMessage);
String payload = messagingTemplate.receiveAndConvert(String.class); String payload = this.messagingTemplate.receiveAndConvert(String.class);
assertEquals("my Payload", payload); assertEquals("my Payload", payload);
verify(jmsTemplate).receive("myQueue"); verify(this.jmsTemplate).receive("myQueue");
} }
@Test @Test
public void receiveAndConvertWithConversion() { public void receiveAndConvertWithConversion() {
javax.jms.Message jmsMessage = createJmsTextMessage("123"); javax.jms.Message jmsMessage = createJmsTextMessage("123");
given(jmsTemplate.receive("myQueue")).willReturn(jmsMessage); given(this.jmsTemplate.receive("myQueue")).willReturn(jmsMessage);
messagingTemplate.setMessageConverter(new GenericMessageConverter()); this.messagingTemplate.setMessageConverter(new GenericMessageConverter());
Integer payload = messagingTemplate.receiveAndConvert("myQueue", Integer.class); Integer payload = this.messagingTemplate.receiveAndConvert("myQueue", Integer.class);
assertEquals(Integer.valueOf(123), payload); assertEquals(Integer.valueOf(123), payload);
verify(jmsTemplate).receive("myQueue"); verify(this.jmsTemplate).receive("myQueue");
} }
@Test @Test
public void receiveAndConvertNoConverter() { public void receiveAndConvertNoConverter() {
javax.jms.Message jmsMessage = createJmsTextMessage("Hello"); javax.jms.Message jmsMessage = createJmsTextMessage("Hello");
given(jmsTemplate.receive("myQueue")).willReturn(jmsMessage); given(this.jmsTemplate.receive("myQueue")).willReturn(jmsMessage);
thrown.expect(org.springframework.messaging.converter.MessageConversionException.class); this.thrown.expect(org.springframework.messaging.converter.MessageConversionException.class);
messagingTemplate.receiveAndConvert("myQueue", Writer.class); this.messagingTemplate.receiveAndConvert("myQueue", Writer.class);
} }
@Test @Test
public void receiveAndConvertNoInput() { public void receiveAndConvertNoInput() {
given(jmsTemplate.receive("myQueue")).willReturn(null); given(this.jmsTemplate.receive("myQueue")).willReturn(null);
assertNull(messagingTemplate.receiveAndConvert("myQueue", String.class)); assertNull(this.messagingTemplate.receiveAndConvert("myQueue", String.class));
} }
@Test @Test
@ -353,10 +397,10 @@ public class JmsMessagingTemplateTests {
Destination destination = new Destination() {}; Destination destination = new Destination() {};
Message<String> request = createTextMessage(); Message<String> request = createTextMessage();
javax.jms.Message replyJmsMessage = createJmsTextMessage(); javax.jms.Message replyJmsMessage = createJmsTextMessage();
given(jmsTemplate.sendAndReceive(eq(destination), anyObject())).willReturn(replyJmsMessage); given(this.jmsTemplate.sendAndReceive(eq(destination), any())).willReturn(replyJmsMessage);
Message<?> actual = messagingTemplate.sendAndReceive(destination, request); Message<?> actual = this.messagingTemplate.sendAndReceive(destination, request);
verify(jmsTemplate, times(1)).sendAndReceive(eq(destination), anyObject()); verify(this.jmsTemplate, times(1)).sendAndReceive(eq(destination), any());
assertTextMessage(actual); assertTextMessage(actual);
} }
@ -364,35 +408,35 @@ public class JmsMessagingTemplateTests {
public void sendAndReceiveName() { public void sendAndReceiveName() {
Message<String> request = createTextMessage(); Message<String> request = createTextMessage();
javax.jms.Message replyJmsMessage = createJmsTextMessage(); javax.jms.Message replyJmsMessage = createJmsTextMessage();
given(jmsTemplate.sendAndReceive(eq("myQueue"), anyObject())).willReturn(replyJmsMessage); given(this.jmsTemplate.sendAndReceive(eq("myQueue"), any())).willReturn(replyJmsMessage);
Message<?> actual = messagingTemplate.sendAndReceive("myQueue", request); Message<?> actual = this.messagingTemplate.sendAndReceive("myQueue", request);
verify(jmsTemplate, times(1)).sendAndReceive(eq("myQueue"), anyObject()); verify(this.jmsTemplate, times(1)).sendAndReceive(eq("myQueue"), any());
assertTextMessage(actual); assertTextMessage(actual);
} }
@Test @Test
public void sendAndReceiveDefaultDestination() { public void sendAndReceiveDefaultDestination() {
Destination destination = new Destination() {}; Destination destination = new Destination() {};
messagingTemplate.setDefaultDestination(destination); this.messagingTemplate.setDefaultDestination(destination);
Message<String> request = createTextMessage(); Message<String> request = createTextMessage();
javax.jms.Message replyJmsMessage = createJmsTextMessage(); javax.jms.Message replyJmsMessage = createJmsTextMessage();
given(jmsTemplate.sendAndReceive(eq(destination), anyObject())).willReturn(replyJmsMessage); given(this.jmsTemplate.sendAndReceive(eq(destination), any())).willReturn(replyJmsMessage);
Message<?> actual = messagingTemplate.sendAndReceive(request); Message<?> actual = this.messagingTemplate.sendAndReceive(request);
verify(jmsTemplate, times(1)).sendAndReceive(eq(destination), anyObject()); verify(this.jmsTemplate, times(1)).sendAndReceive(eq(destination), any());
assertTextMessage(actual); assertTextMessage(actual);
} }
@Test @Test
public void sendAndReceiveDefaultDestinationName() { public void sendAndReceiveDefaultDestinationName() {
messagingTemplate.setDefaultDestinationName("myQueue"); this.messagingTemplate.setDefaultDestinationName("myQueue");
Message<String> request = createTextMessage(); Message<String> request = createTextMessage();
javax.jms.Message replyJmsMessage = createJmsTextMessage(); javax.jms.Message replyJmsMessage = createJmsTextMessage();
given(jmsTemplate.sendAndReceive(eq("myQueue"), anyObject())).willReturn(replyJmsMessage); given(this.jmsTemplate.sendAndReceive(eq("myQueue"), any())).willReturn(replyJmsMessage);
Message<?> actual = messagingTemplate.sendAndReceive(request); Message<?> actual = this.messagingTemplate.sendAndReceive(request);
verify(jmsTemplate, times(1)).sendAndReceive(eq("myQueue"), anyObject()); verify(this.jmsTemplate, times(1)).sendAndReceive(eq("myQueue"), any());
assertTextMessage(actual); assertTextMessage(actual);
} }
@ -400,58 +444,58 @@ public class JmsMessagingTemplateTests {
public void sendAndReceiveNoDefaultSet() { public void sendAndReceiveNoDefaultSet() {
Message<String> message = createTextMessage(); Message<String> message = createTextMessage();
thrown.expect(IllegalStateException.class); this.thrown.expect(IllegalStateException.class);
messagingTemplate.sendAndReceive(message); this.messagingTemplate.sendAndReceive(message);
} }
@Test @Test
public void convertSendAndReceivePayload() throws JMSException { public void convertSendAndReceivePayload() throws JMSException {
Destination destination = new Destination() {}; Destination destination = new Destination() {};
javax.jms.Message replyJmsMessage = createJmsTextMessage("My reply"); javax.jms.Message replyJmsMessage = createJmsTextMessage("My reply");
given(jmsTemplate.sendAndReceive(eq(destination), anyObject())).willReturn(replyJmsMessage); given(this.jmsTemplate.sendAndReceive(eq(destination), any())).willReturn(replyJmsMessage);
String reply = messagingTemplate.convertSendAndReceive(destination, "my Payload", String.class); String reply = this.messagingTemplate.convertSendAndReceive(destination, "my Payload", String.class);
verify(jmsTemplate, times(1)).sendAndReceive(eq(destination), anyObject()); verify(this.jmsTemplate, times(1)).sendAndReceive(eq(destination), any());
assertEquals("My reply", reply); assertEquals("My reply", reply);
} }
@Test @Test
public void convertSendAndReceivePayloadName() throws JMSException { public void convertSendAndReceivePayloadName() throws JMSException {
javax.jms.Message replyJmsMessage = createJmsTextMessage("My reply"); javax.jms.Message replyJmsMessage = createJmsTextMessage("My reply");
given(jmsTemplate.sendAndReceive(eq("myQueue"), anyObject())).willReturn(replyJmsMessage); given(this.jmsTemplate.sendAndReceive(eq("myQueue"), any())).willReturn(replyJmsMessage);
String reply = messagingTemplate.convertSendAndReceive("myQueue", "my Payload", String.class); String reply = this.messagingTemplate.convertSendAndReceive("myQueue", "my Payload", String.class);
verify(jmsTemplate, times(1)).sendAndReceive(eq("myQueue"), anyObject()); verify(this.jmsTemplate, times(1)).sendAndReceive(eq("myQueue"), any());
assertEquals("My reply", reply); assertEquals("My reply", reply);
} }
@Test @Test
public void convertSendAndReceiveDefaultDestination() throws JMSException { public void convertSendAndReceiveDefaultDestination() throws JMSException {
Destination destination = new Destination() {}; Destination destination = new Destination() {};
messagingTemplate.setDefaultDestination(destination); this.messagingTemplate.setDefaultDestination(destination);
javax.jms.Message replyJmsMessage = createJmsTextMessage("My reply"); javax.jms.Message replyJmsMessage = createJmsTextMessage("My reply");
given(jmsTemplate.sendAndReceive(eq(destination), anyObject())).willReturn(replyJmsMessage); given(this.jmsTemplate.sendAndReceive(eq(destination), any())).willReturn(replyJmsMessage);
String reply = messagingTemplate.convertSendAndReceive("my Payload", String.class); String reply = this.messagingTemplate.convertSendAndReceive("my Payload", String.class);
verify(jmsTemplate, times(1)).sendAndReceive(eq(destination), anyObject()); verify(this.jmsTemplate, times(1)).sendAndReceive(eq(destination), any());
assertEquals("My reply", reply); assertEquals("My reply", reply);
} }
@Test @Test
public void convertSendAndReceiveDefaultDestinationName() throws JMSException { public void convertSendAndReceiveDefaultDestinationName() throws JMSException {
messagingTemplate.setDefaultDestinationName("myQueue"); this.messagingTemplate.setDefaultDestinationName("myQueue");
javax.jms.Message replyJmsMessage = createJmsTextMessage("My reply"); javax.jms.Message replyJmsMessage = createJmsTextMessage("My reply");
given(jmsTemplate.sendAndReceive(eq("myQueue"), anyObject())).willReturn(replyJmsMessage); given(this.jmsTemplate.sendAndReceive(eq("myQueue"), any())).willReturn(replyJmsMessage);
String reply = messagingTemplate.convertSendAndReceive("my Payload", String.class); String reply = this.messagingTemplate.convertSendAndReceive("my Payload", String.class);
verify(jmsTemplate, times(1)).sendAndReceive(eq("myQueue"), anyObject()); verify(this.jmsTemplate, times(1)).sendAndReceive(eq("myQueue"), any());
assertEquals("My reply", reply); assertEquals("My reply", reply);
} }
@Test @Test
public void convertSendAndReceiveNoDefaultSet() throws JMSException { public void convertSendAndReceiveNoDefaultSet() throws JMSException {
thrown.expect(IllegalStateException.class); this.thrown.expect(IllegalStateException.class);
messagingTemplate.convertSendAndReceive("my Payload", String.class); this.messagingTemplate.convertSendAndReceive("my Payload", String.class);
} }
@Test @Test
@ -459,12 +503,12 @@ public class JmsMessagingTemplateTests {
Message<String> message = createTextMessage(); Message<String> message = createTextMessage();
MessageConverter messageConverter = mock(MessageConverter.class); MessageConverter messageConverter = mock(MessageConverter.class);
willThrow(org.springframework.jms.support.converter.MessageConversionException.class) willThrow(org.springframework.jms.support.converter.MessageConversionException.class)
.given(messageConverter).toMessage(eq(message), anyObject()); .given(messageConverter).toMessage(eq(message), any());
messagingTemplate.setJmsMessageConverter(messageConverter); this.messagingTemplate.setJmsMessageConverter(messageConverter);
invokeMessageCreator("myQueue"); invokeMessageCreator();
thrown.expect(org.springframework.messaging.converter.MessageConversionException.class); this.thrown.expect(org.springframework.messaging.converter.MessageConversionException.class);
messagingTemplate.send("myQueue", message); this.messagingTemplate.send("myQueue", message);
} }
@Test @Test
@ -473,89 +517,86 @@ public class JmsMessagingTemplateTests {
MessageConverter messageConverter = mock(MessageConverter.class); MessageConverter messageConverter = mock(MessageConverter.class);
willThrow(org.springframework.jms.support.converter.MessageConversionException.class) willThrow(org.springframework.jms.support.converter.MessageConversionException.class)
.given(messageConverter).fromMessage(message); .given(messageConverter).fromMessage(message);
messagingTemplate.setJmsMessageConverter(messageConverter); this.messagingTemplate.setJmsMessageConverter(messageConverter);
given(jmsTemplate.receive("myQueue")).willReturn(message); given(this.jmsTemplate.receive("myQueue")).willReturn(message);
thrown.expect(org.springframework.messaging.converter.MessageConversionException.class); this.thrown.expect(org.springframework.messaging.converter.MessageConversionException.class);
messagingTemplate.receive("myQueue"); this.messagingTemplate.receive("myQueue");
} }
@Test @Test
public void convertMessageNotReadableException() throws JMSException { public void convertMessageNotReadableException() throws JMSException {
willThrow(MessageNotReadableException.class).given(jmsTemplate).receive("myQueue"); willThrow(MessageNotReadableException.class).given(this.jmsTemplate).receive("myQueue");
thrown.expect(MessagingException.class); this.thrown.expect(MessagingException.class);
messagingTemplate.receive("myQueue"); this.messagingTemplate.receive("myQueue");
} }
@Test @Test
public void convertDestinationResolutionExceptionOnSend() { public void convertDestinationResolutionExceptionOnSend() {
Destination destination = new Destination() {}; Destination destination = new Destination() {};
willThrow(DestinationResolutionException.class).given(jmsTemplate).send(eq(destination), anyObject()); willThrow(DestinationResolutionException.class).given(this.jmsTemplate).send(eq(destination), any());
thrown.expect(org.springframework.messaging.core.DestinationResolutionException.class); this.thrown.expect(org.springframework.messaging.core.DestinationResolutionException.class);
messagingTemplate.send(destination, createTextMessage()); this.messagingTemplate.send(destination, createTextMessage());
} }
@Test @Test
public void convertDestinationResolutionExceptionOnReceive() { public void convertDestinationResolutionExceptionOnReceive() {
Destination destination = new Destination() {}; Destination destination = new Destination() {};
willThrow(DestinationResolutionException.class).given(jmsTemplate).receive(destination); willThrow(DestinationResolutionException.class).given(this.jmsTemplate).receive(destination);
thrown.expect(org.springframework.messaging.core.DestinationResolutionException.class); this.thrown.expect(org.springframework.messaging.core.DestinationResolutionException.class);
messagingTemplate.receive(destination); this.messagingTemplate.receive(destination);
} }
@Test @Test
public void convertMessageFormatException() throws JMSException { public void convertMessageFormatException() throws JMSException {
Message<String> message = createTextMessage(); Message<String> message = createTextMessage();
MessageConverter messageConverter = mock(MessageConverter.class); MessageConverter messageConverter = mock(MessageConverter.class);
willThrow(MessageFormatException.class).given(messageConverter).toMessage(eq(message), anyObject()); willThrow(MessageFormatException.class).given(messageConverter).toMessage(eq(message), any());
messagingTemplate.setJmsMessageConverter(messageConverter); this.messagingTemplate.setJmsMessageConverter(messageConverter);
invokeMessageCreator("myQueue"); invokeMessageCreator();
thrown.expect(org.springframework.messaging.converter.MessageConversionException.class); this.thrown.expect(org.springframework.messaging.converter.MessageConversionException.class);
messagingTemplate.send("myQueue", message); this.messagingTemplate.send("myQueue", message);
} }
@Test @Test
public void convertMessageNotWritableException() throws JMSException { public void convertMessageNotWritableException() throws JMSException {
Message<String> message = createTextMessage(); Message<String> message = createTextMessage();
MessageConverter messageConverter = mock(MessageConverter.class); MessageConverter messageConverter = mock(MessageConverter.class);
willThrow(MessageNotWriteableException.class).given(messageConverter).toMessage(eq(message), anyObject()); willThrow(MessageNotWriteableException.class).given(messageConverter).toMessage(eq(message), any());
messagingTemplate.setJmsMessageConverter(messageConverter); this.messagingTemplate.setJmsMessageConverter(messageConverter);
invokeMessageCreator("myQueue"); invokeMessageCreator();
thrown.expect(org.springframework.messaging.converter.MessageConversionException.class); this.thrown.expect(org.springframework.messaging.converter.MessageConversionException.class);
messagingTemplate.send("myQueue", message); this.messagingTemplate.send("myQueue", message);
} }
@Test @Test
public void convertInvalidDestinationExceptionOnSendAndReceiveWithName() { public void convertInvalidDestinationExceptionOnSendAndReceiveWithName() {
willThrow(InvalidDestinationException.class).given(jmsTemplate).sendAndReceive(eq("unknownQueue"), anyObject()); willThrow(InvalidDestinationException.class).given(this.jmsTemplate).sendAndReceive(eq("unknownQueue"), any());
thrown.expect(org.springframework.messaging.core.DestinationResolutionException.class); this.thrown.expect(org.springframework.messaging.core.DestinationResolutionException.class);
messagingTemplate.sendAndReceive("unknownQueue", createTextMessage()); this.messagingTemplate.sendAndReceive("unknownQueue", createTextMessage());
} }
@Test @Test
public void convertInvalidDestinationExceptionOnSendAndReceive() { public void convertInvalidDestinationExceptionOnSendAndReceive() {
Destination destination = new Destination() {}; Destination destination = new Destination() {};
willThrow(InvalidDestinationException.class).given(jmsTemplate).sendAndReceive(eq(destination), anyObject()); willThrow(InvalidDestinationException.class).given(this.jmsTemplate).sendAndReceive(eq(destination), any());
thrown.expect(org.springframework.messaging.core.DestinationResolutionException.class); this.thrown.expect(org.springframework.messaging.core.DestinationResolutionException.class);
messagingTemplate.sendAndReceive(destination, createTextMessage()); this.messagingTemplate.sendAndReceive(destination, createTextMessage());
} }
private void invokeMessageCreator(String destinationName) { private void invokeMessageCreator() {
willAnswer(new Answer<Object>() { willAnswer(invocation -> {
@Override MessageCreator messageCreator = (MessageCreator) invocation.getArguments()[1];
public Object answer(InvocationOnMock invocation) throws Throwable { messageCreator.createMessage(null);
MessageCreator messageCreator = (MessageCreator) invocation.getArguments()[1]; return null;
messageCreator.createMessage(null); }).given(this.jmsTemplate).send(eq("myQueue"), any());
return null;
}
}).given(jmsTemplate).send(eq("myQueue"), anyObject());
} }
@ -604,15 +645,11 @@ public class JmsMessagingTemplateTests {
protected TextMessage createTextMessage(MessageCreator creator) throws JMSException { protected TextMessage createTextMessage(MessageCreator creator) throws JMSException {
Session mock = mock(Session.class); Session mock = mock(Session.class);
given(mock.createTextMessage(BDDMockito.<String> any())).willAnswer( given(mock.createTextMessage(BDDMockito.any())).willAnswer(
new Answer<TextMessage>() { (Answer<TextMessage>) invocation ->
@Override new StubTextMessage((String) invocation.getArguments()[0]));
public TextMessage answer(InvocationOnMock invocation) throws Throwable {
return new StubTextMessage((String) invocation.getArguments()[0]);
}
});
javax.jms.Message message = creator.createMessage(mock); javax.jms.Message message = creator.createMessage(mock);
verify(mock).createTextMessage(BDDMockito.<String> any()); verify(mock).createTextMessage(BDDMockito.any());
return TextMessage.class.cast(message); return TextMessage.class.cast(message);
} }

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

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2015 the original author or authors. * Copyright 2002-2017 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -78,7 +78,7 @@ public abstract class AbstractMessageSendingTemplate<D> implements MessageSendin
* @param messageConverter the message converter to use * @param messageConverter the message converter to use
*/ */
public void setMessageConverter(MessageConverter messageConverter) { public void setMessageConverter(MessageConverter messageConverter) {
Assert.notNull(messageConverter, "'messageConverter' must not be null"); Assert.notNull(messageConverter, "MessageConverter must not be null");
this.converter = messageConverter; this.converter = messageConverter;
} }