org.springframework.jms.support.converter.MessageConverter Java Examples

/**
 * Build a JMS message to be sent as response based on the given result object.
 * @param session the JMS Session to operate on
 * @param result the content of the message, as returned from the listener method
 * @return the JMS {@code Message} (never {@code null})
 * @throws JMSException if thrown by JMS API methods
 * @see #setMessageConverter
 */
protected Message buildMessage(Session session, Object result) throws JMSException {
	Object content = preProcessResponse(result instanceof JmsResponse
			? ((JmsResponse<?>) result).getResponse() : result);

	MessageConverter converter = getMessageConverter();
	if (converter != null) {
		if (content instanceof org.springframework.messaging.Message) {
			return this.messagingMessageConverter.toMessage(content, session);
		}
		else {
			return converter.toMessage(content, session);
		}
	}

	if (!(content instanceof Message)) {
		throw new MessageConversionException(
				"No MessageConverter specified - cannot handle message [" + content + "]");
	}
	return (Message) content;
}
 

/**
 * Build a JMS message to be sent as response based on the given result object.
 * @param session the JMS Session to operate on
 * @param result the content of the message, as returned from the listener method
 * @return the JMS {@code Message} (never {@code null})
 * @throws JMSException if thrown by JMS API methods
 * @see #setMessageConverter
 */
protected Message buildMessage(Session session, Object result) throws JMSException {
	Object content = (result instanceof JmsResponse ? ((JmsResponse<?>) result).getResponse() : result);
	if (content instanceof org.springframework.messaging.Message) {
		return this.messagingMessageConverter.toMessage(content, session);
	}

	MessageConverter converter = getMessageConverter();
	if (converter != null) {
		return converter.toMessage(content, session);
	}

	if (!(content instanceof Message)) {
		throw new MessageConversionException(
				"No MessageConverter specified - cannot handle message [" + content + "]");
	}
	return (Message) content;
}
 

@Test
public void setExtraCollaborators() {
	MessageConverter messageConverter = mock(MessageConverter.class);
	DestinationResolver destinationResolver = mock(DestinationResolver.class);
	this.container.setMessageConverter(messageConverter);
	this.container.setDestinationResolver(destinationResolver);

	MessagingMessageListenerAdapter listener = createInstance(this.factory,
			getListenerMethod("resolveObjectPayload", MyBean.class), container);
	DirectFieldAccessor accessor = new DirectFieldAccessor(listener);
	assertSame(messageConverter, accessor.getPropertyValue("messageConverter"));
	assertSame(destinationResolver, accessor.getPropertyValue("destinationResolver"));
}
 

@Override
protected Message createMessageForPayload(Object payload, Session session, @Nullable Object conversionHint)
		throws JMSException {

	MessageConverter converter = getMessageConverter();
	if (converter == null) {
		throw new IllegalStateException("No message converter, cannot handle '" + payload + "'");
	}
	if (converter instanceof SmartMessageConverter) {
		return ((SmartMessageConverter) converter).toMessage(payload, session, conversionHint);

	}
	return converter.toMessage(payload, session);
}
 

@Override
protected MessagingMessageListenerAdapter createMessageListener(MessageListenerContainer container) {
	Assert.state(this.messageHandlerMethodFactory != null,
			"Could not create message listener - MessageHandlerMethodFactory not set");
	MessagingMessageListenerAdapter messageListener = createMessageListenerInstance();
	Object bean = getBean();
	Method method = getMethod();
	Assert.state(bean != null && method != null, "No bean+method set on endpoint");
	InvocableHandlerMethod invocableHandlerMethod =
			this.messageHandlerMethodFactory.createInvocableHandlerMethod(bean, method);
	messageListener.setHandlerMethod(invocableHandlerMethod);
	String responseDestination = getDefaultResponseDestination();
	if (StringUtils.hasText(responseDestination)) {
		if (container.isReplyPubSubDomain()) {
			messageListener.setDefaultResponseTopicName(responseDestination);
		}
		else {
			messageListener.setDefaultResponseQueueName(responseDestination);
		}
	}
	QosSettings responseQosSettings = container.getReplyQosSettings();
	if (responseQosSettings != null) {
		messageListener.setResponseQosSettings(responseQosSettings);
	}
	MessageConverter messageConverter = container.getMessageConverter();
	if (messageConverter != null) {
		messageListener.setMessageConverter(messageConverter);
	}
	DestinationResolver destinationResolver = container.getDestinationResolver();
	if (destinationResolver != null) {
		messageListener.setDestinationResolver(destinationResolver);
	}
	return messageListener;
}
 

@Bean // Serialize message content to json using TextMessage
public MessageConverter jacksonJmsMessageConverter() {
	MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter();
	converter.setTargetType(MessageType.BYTES);
	converter.setTypeIdPropertyName("_type");
	return converter;
}
 

@Bean 
public MessageConverter jacksonJmsMessageConverter(ObjectMapper aObjectMapper) {
  MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter();
  converter.setObjectMapper(aObjectMapper);
  converter.setTargetType(MessageType.TEXT);
  converter.setTypeIdPropertyName("_type");
  return converter;
}
 

/**
 * Extract the message body from the given JMS message.
 * @param message the JMS {@code Message}
 * @return the content of the message, to be passed into the listener method
 * as an argument
 * @throws MessageConversionException if the message could not be extracted
 */
protected Object extractMessage(Message message)  {
	try {
		MessageConverter converter = getMessageConverter();
		if (converter != null) {
			return converter.fromMessage(message);
		}
		return message;
	}
	catch (JMSException ex) {
		throw new MessageConversionException("Could not convert JMS message", ex);
	}
}
 

@Test
public void incomingMessageUsesMessageConverter() throws JMSException {
	javax.jms.Message jmsMessage = mock(javax.jms.Message.class);
	Session session = mock(Session.class);
	MessageConverter messageConverter = mock(MessageConverter.class);
	given(messageConverter.fromMessage(jmsMessage)).willReturn("FooBar");
	MessagingMessageListenerAdapter listener = getSimpleInstance("simple", Message.class);
	listener.setMessageConverter(messageConverter);
	listener.onMessage(jmsMessage, session);
	verify(messageConverter, times(1)).fromMessage(jmsMessage);
	assertEquals(1, sample.simples.size());
	assertEquals("FooBar", sample.simples.get(0).getPayload());
}
 

@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 convertMessageConversionExceptionOnSend() throws JMSException {
	Message<String> message = createTextMessage();
	MessageConverter messageConverter = mock(MessageConverter.class);
	willThrow(org.springframework.jms.support.converter.MessageConversionException.class)
			.given(messageConverter).toMessage(eq(message), any());
	this.messagingTemplate.setJmsMessageConverter(messageConverter);
	invokeMessageCreator();

	assertThatExceptionOfType(org.springframework.messaging.converter.MessageConversionException.class).isThrownBy(() ->
			this.messagingTemplate.send("myQueue", message));
}
 

@Test
public void convertMessageConversionExceptionOnReceive() throws JMSException {
	javax.jms.Message message = createJmsTextMessage();
	MessageConverter messageConverter = mock(MessageConverter.class);
	willThrow(org.springframework.jms.support.converter.MessageConversionException.class)
			.given(messageConverter).fromMessage(message);
	this.messagingTemplate.setJmsMessageConverter(messageConverter);
	given(this.jmsTemplate.receive("myQueue")).willReturn(message);

	assertThatExceptionOfType(org.springframework.messaging.converter.MessageConversionException.class).isThrownBy(() ->
			this.messagingTemplate.receive("myQueue"));
}
 

@Test
public void convertMessageFormatException() throws JMSException {
	Message<String> message = createTextMessage();
	MessageConverter messageConverter = mock(MessageConverter.class);
	willThrow(MessageFormatException.class).given(messageConverter).toMessage(eq(message), any());
	this.messagingTemplate.setJmsMessageConverter(messageConverter);
	invokeMessageCreator();

	assertThatExceptionOfType(org.springframework.messaging.converter.MessageConversionException.class).isThrownBy(() ->
			this.messagingTemplate.send("myQueue", message));
}
 

@Override
protected Message createMessageForPayload(Object payload, Session session) throws JMSException {
	MessageConverter converter = getMessageConverter();
	if (converter != null) {
		return converter.toMessage(payload, session);
	}
	throw new IllegalStateException("No message converter - cannot handle [" + payload + "]");
}
 

@Bean // Serialize message content to json using TextMessage
public MessageConverter jacksonJmsMessageConverter() {
    final MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter();
    converter.setTargetType(MessageType.TEXT);
    converter.setTypeIdPropertyName("_type");
    return converter;
}
 

/**
 * Extract the message body from the given JMS message.
 * @param message the JMS {@code Message}
 * @return the content of the message, to be passed into the listener method
 * as an argument
 * @throws MessageConversionException if the message could not be extracted
 */
protected Object extractMessage(Message message)  {
	try {
		MessageConverter converter = getMessageConverter();
		if (converter != null) {
			return converter.fromMessage(message);
		}
		return message;
	}
	catch (JMSException ex) {
		throw new MessageConversionException("Could not convert JMS message", ex);
	}
}
 

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
public void convertMessageNotWritableException() throws JMSException {
	Message<String> message = createTextMessage();
	MessageConverter messageConverter = mock(MessageConverter.class);
	willThrow(MessageNotWriteableException.class).given(messageConverter).toMessage(eq(message), any());
	this.messagingTemplate.setJmsMessageConverter(messageConverter);
	invokeMessageCreator();

	this.thrown.expect(org.springframework.messaging.converter.MessageConversionException.class);
	this.messagingTemplate.send("myQueue", message);
}
 

@Bean
public MessageConverter jacksonJmsMessageConverter() {
	MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter();

	converter.setTargetType(MessageType.TEXT);
	converter.setTypeIdPropertyName("_type");

	return converter;
}
 

@Bean
public MessageConverter jacksonJmsMessageConverter() {
	final MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter();
	converter.setTargetType(MessageType.TEXT);
	converter.setTypeIdPropertyName("_type");
	return converter;
}
 

@Test
public void convertMessageConversionExceptionOnReceive() throws JMSException {
	javax.jms.Message message = createJmsTextMessage();
	MessageConverter messageConverter = mock(MessageConverter.class);
	willThrow(org.springframework.jms.support.converter.MessageConversionException.class)
			.given(messageConverter).fromMessage(message);
	this.messagingTemplate.setJmsMessageConverter(messageConverter);
	given(this.jmsTemplate.receive("myQueue")).willReturn(message);

	this.thrown.expect(org.springframework.messaging.converter.MessageConversionException.class);
	this.messagingTemplate.receive("myQueue");
}
 

@Test
public void convertMessageConversionExceptionOnSend() throws JMSException {
	Message<String> message = createTextMessage();
	MessageConverter messageConverter = mock(MessageConverter.class);
	willThrow(org.springframework.jms.support.converter.MessageConversionException.class)
			.given(messageConverter).toMessage(eq(message), any());
	this.messagingTemplate.setJmsMessageConverter(messageConverter);
	invokeMessageCreator();

	this.thrown.expect(org.springframework.messaging.converter.MessageConversionException.class);
	this.messagingTemplate.send("myQueue", message);
}
 

@Test
public void convertMessageNotWritableException() throws JMSException {
	Message<String> message = createTextMessage();
	MessageConverter messageConverter = mock(MessageConverter.class);
	willThrow(MessageNotWriteableException.class).given(messageConverter).toMessage(eq(message), anyObject());
	messagingTemplate.setJmsMessageConverter(messageConverter);
	invokeMessageCreator("myQueue");

	thrown.expect(org.springframework.messaging.converter.MessageConversionException.class);
	messagingTemplate.send("myQueue", message);
}
 

@Override
protected MessagingMessageListenerAdapter createMessageListener(MessageListenerContainer container) {
	Assert.state(this.messageHandlerMethodFactory != null,
			"Could not create message listener - MessageHandlerMethodFactory not set");
	MessagingMessageListenerAdapter messageListener = createMessageListenerInstance();
	InvocableHandlerMethod invocableHandlerMethod =
			this.messageHandlerMethodFactory.createInvocableHandlerMethod(getBean(), getMethod());
	messageListener.setHandlerMethod(invocableHandlerMethod);
	String responseDestination = getDefaultResponseDestination();
	if (StringUtils.hasText(responseDestination)) {
		if (container.isReplyPubSubDomain()) {
			messageListener.setDefaultResponseTopicName(responseDestination);
		}
		else {
			messageListener.setDefaultResponseQueueName(responseDestination);
		}
	}
	MessageConverter messageConverter = container.getMessageConverter();
	if (messageConverter != null) {
		messageListener.setMessageConverter(messageConverter);
	}
	DestinationResolver destinationResolver = container.getDestinationResolver();
	if (destinationResolver != null) {
		messageListener.setDestinationResolver(destinationResolver);
	}
	return messageListener;
}
 

@Override
protected MessagingMessageListenerAdapter createMessageListener(MessageListenerContainer container) {
	Assert.state(this.messageHandlerMethodFactory != null,
			"Could not create message listener - MessageHandlerMethodFactory not set");
	MessagingMessageListenerAdapter messageListener = createMessageListenerInstance();
	InvocableHandlerMethod invocableHandlerMethod =
			this.messageHandlerMethodFactory.createInvocableHandlerMethod(getBean(), getMethod());
	messageListener.setHandlerMethod(invocableHandlerMethod);
	String responseDestination = getDefaultResponseDestination();
	if (StringUtils.hasText(responseDestination)) {
		if (container.isReplyPubSubDomain()) {
			messageListener.setDefaultResponseTopicName(responseDestination);
		}
		else {
			messageListener.setDefaultResponseQueueName(responseDestination);
		}
	}
	QosSettings responseQosSettings = container.getReplyQosSettings();
	if (responseQosSettings != null) {
		messageListener.setResponseQosSettings(responseQosSettings);
	}
	MessageConverter messageConverter = container.getMessageConverter();
	if (messageConverter != null) {
		messageListener.setMessageConverter(messageConverter);
	}
	DestinationResolver destinationResolver = container.getDestinationResolver();
	if (destinationResolver != null) {
		messageListener.setDestinationResolver(destinationResolver);
	}
	return messageListener;
}
 

@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 payloadConversionLazilyInvoked() throws JMSException {
	javax.jms.Message jmsMessage = mock(javax.jms.Message.class);
	MessageConverter messageConverter = mock(MessageConverter.class);
	given(messageConverter.fromMessage(jmsMessage)).willReturn("FooBar");
	MessagingMessageListenerAdapter listener = getSimpleInstance("simple", Message.class);
	listener.setMessageConverter(messageConverter);
	Message<?> message = listener.toMessagingMessage(jmsMessage);
	verify(messageConverter, never()).fromMessage(jmsMessage);
	assertEquals("FooBar", message.getPayload());
	verify(messageConverter, times(1)).fromMessage(jmsMessage);
}
 

@Test
public void incomingMessageUsesMessageConverter() throws JMSException {
	javax.jms.Message jmsMessage = mock(javax.jms.Message.class);
	Session session = mock(Session.class);
	MessageConverter messageConverter = mock(MessageConverter.class);
	given(messageConverter.fromMessage(jmsMessage)).willReturn("FooBar");
	MessagingMessageListenerAdapter listener = getSimpleInstance("simple", Message.class);
	listener.setMessageConverter(messageConverter);
	listener.onMessage(jmsMessage, session);
	verify(messageConverter, times(1)).fromMessage(jmsMessage);
	assertEquals(1, sample.simples.size());
	assertEquals("FooBar", sample.simples.get(0).getPayload());
}
 

@Test
public void setExtraCollaborators() {
	MessageConverter messageConverter = mock(MessageConverter.class);
	DestinationResolver destinationResolver = mock(DestinationResolver.class);
	this.container.setMessageConverter(messageConverter);
	this.container.setDestinationResolver(destinationResolver);

	MessagingMessageListenerAdapter listener = createInstance(this.factory,
			getListenerMethod("resolveObjectPayload", MyBean.class), this.container);
	DirectFieldAccessor accessor = new DirectFieldAccessor(listener);
	assertSame(messageConverter, accessor.getPropertyValue("messageConverter"));
	assertSame(destinationResolver, accessor.getPropertyValue("destinationResolver"));
}