How to use

setJMSCorrelationID

method

in

javax.jms.TextMessage

@Test
public void processAndReply() throws JMSException {
  MessagingMessageListenerAdapter listener = createDefaultInstance(String.class);
  String body = "echo text";
  String correlationId = "link-1234";
  Destination replyDestination = new Destination() {};
  TextMessage reply = mock(TextMessage.class);
  QueueSender queueSender = mock(QueueSender.class);
  Session session = mock(Session.class);
  given(session.createTextMessage(body)).willReturn(reply);
  given(session.createProducer(replyDestination)).willReturn(queueSender);
  listener.setDefaultResponseDestination(replyDestination);
  StubTextMessage inputMessage = createSimpleJmsTextMessage(body);
  inputMessage.setJMSCorrelationID(correlationId);
  listener.onMessage(inputMessage, session);
  assertDefaultListenerMethodInvocation();
  verify(reply).setJMSCorrelationID(correlationId);
  verify(queueSender).send(reply);
  verify(queueSender).close();
}

@Test
public void testWithResponsiveMessageDelegateNoDefaultDestination_SendsReturnTextMessageWhenSessionSupplied() throws Exception {
  Queue destination = mock(Queue.class);
  TextMessage sentTextMessage = mock(TextMessage.class);
  // correlation ID is queried when response is being created...
  given(sentTextMessage.getJMSCorrelationID()).willReturn(null);
  given(sentTextMessage.getJMSMessageID()).willReturn(CORRELATION_ID);
  // Reply-To is queried when response is being created...
  given(sentTextMessage.getJMSReplyTo()).willReturn(destination);
  TextMessage responseTextMessage = mock(TextMessage.class);
  MessageProducer messageProducer = mock(MessageProducer.class);
  Session session = mock(Session.class);
  given(session.createTextMessage(RESPONSE_TEXT)).willReturn(responseTextMessage);
  given(session.createProducer(destination)).willReturn(messageProducer);
  ResponsiveMessageDelegate delegate = mock(ResponsiveMessageDelegate.class);
  given(delegate.handleMessage(sentTextMessage)).willReturn(RESPONSE_TEXT);
  MessageListenerAdapter adapter = new MessageListenerAdapter(delegate) {
    @Override
    protected Object extractMessage(Message message) {
      return message;
    }
  };
  adapter.onMessage(sentTextMessage, session);
  verify(responseTextMessage).setJMSCorrelationID(CORRELATION_ID);
  verify(messageProducer).send(responseTextMessage);
  verify(messageProducer).close();
  verify(delegate).handleMessage(sentTextMessage);
}

@Test
public void testWithResponsiveMessageDelegateWithDefaultDestination_SendsReturnTextMessageWhenSessionSupplied() throws Exception {
  Queue destination = mock(Queue.class);
  TextMessage sentTextMessage = mock(TextMessage.class);
  // correlation ID is queried when response is being created...
  given(sentTextMessage.getJMSCorrelationID()).willReturn(
      CORRELATION_ID);
  // Reply-To is queried when response is being created...
  given(sentTextMessage.getJMSReplyTo()).willReturn(null); // we want to fall back to the default...
  TextMessage responseTextMessage = mock(TextMessage.class);
  QueueSender queueSender = mock(QueueSender.class);
  Session session = mock(Session.class);
  given(session.createTextMessage(RESPONSE_TEXT)).willReturn(responseTextMessage);
  given(session.createProducer(destination)).willReturn(queueSender);
  ResponsiveMessageDelegate delegate = mock(ResponsiveMessageDelegate.class);
  given(delegate.handleMessage(sentTextMessage)).willReturn(RESPONSE_TEXT);
  MessageListenerAdapter adapter = new MessageListenerAdapter(delegate) {
    @Override
    protected Object extractMessage(Message message) {
      return message;
    }
  };
  adapter.setDefaultResponseDestination(destination);
  adapter.onMessage(sentTextMessage, session);
  verify(responseTextMessage).setJMSCorrelationID(CORRELATION_ID);
  verify(queueSender).send(responseTextMessage);
  verify(queueSender).close();
  verify(delegate).handleMessage(sentTextMessage);
}

verify(responseTextMessage).setJMSCorrelationID(CORRELATION_ID);
verify(messageProducer).close();
verify(delegate).handleMessage(sentTextMessage);

private void processAndReplyWithSendTo(MessagingMessageListenerAdapter listener,
    String replyDestinationName, boolean pubSubDomain,
    QosSettings replyQosSettings) throws JMSException {
  String body = "echo text";
  String correlationId = "link-1234";
  Destination replyDestination = new Destination() {};
  DestinationResolver destinationResolver = mock(DestinationResolver.class);
  TextMessage reply = mock(TextMessage.class);
  QueueSender queueSender = mock(QueueSender.class);
  Session session = mock(Session.class);
  given(destinationResolver.resolveDestinationName(session, replyDestinationName, pubSubDomain))
      .willReturn(replyDestination);
  given(session.createTextMessage(body)).willReturn(reply);
  given(session.createProducer(replyDestination)).willReturn(queueSender);
  listener.setDestinationResolver(destinationResolver);
  StubTextMessage inputMessage = createSimpleJmsTextMessage(body);
  inputMessage.setJMSCorrelationID(correlationId);
  listener.onMessage(inputMessage, session);
  verify(destinationResolver).resolveDestinationName(session, replyDestinationName, pubSubDomain);
  verify(reply).setJMSCorrelationID(correlationId);
  if (replyQosSettings != null) {
    verify(queueSender).send(reply, replyQosSettings.getDeliveryMode(),
        replyQosSettings.getPriority(), replyQosSettings.getTimeToLive());
  }
  else {
    verify(queueSender).send(reply);
  }
  verify(queueSender).close();
}

@Test
public void testWithResponsiveMessageDelegateNoDefaultDestinationAndNoReplyToDestination_SendsReturnTextMessageWhenSessionSupplied() throws Exception {
  final TextMessage sentTextMessage = mock(TextMessage.class);
  // correlation ID is queried when response is being created...
  given(sentTextMessage.getJMSCorrelationID()).willReturn(CORRELATION_ID);
  // Reply-To is queried when response is being created...
  given(sentTextMessage.getJMSReplyTo()).willReturn(null);
  TextMessage responseTextMessage = mock(TextMessage.class);
  final QueueSession session = mock(QueueSession.class);
  given(session.createTextMessage(RESPONSE_TEXT)).willReturn(responseTextMessage);
  ResponsiveMessageDelegate delegate = mock(ResponsiveMessageDelegate.class);
  given(delegate.handleMessage(sentTextMessage)).willReturn(RESPONSE_TEXT);
  final MessageListenerAdapter adapter = new MessageListenerAdapter(delegate) {
    @Override
    protected Object extractMessage(Message message) {
      return message;
    }
  };
  try {
    adapter.onMessage(sentTextMessage, session);
    fail("expected CouldNotSendReplyException with InvalidDestinationException");
  }
  catch (ReplyFailureException ex) {
    assertEquals(InvalidDestinationException.class, ex.getCause().getClass());
  }
  verify(responseTextMessage).setJMSCorrelationID(CORRELATION_ID);
  verify(delegate).handleMessage(sentTextMessage);
}

@Test
public void testWithResponsiveMessageDelegateWhenReturnTypeIsAJMSMessageAndNoMessageConverterIsSupplied() throws Exception {
  Queue destination = mock(Queue.class);
  final TextMessage sentTextMessage = mock(TextMessage.class);
  // correlation ID is queried when response is being created...
  given(sentTextMessage.getJMSCorrelationID()).willReturn(CORRELATION_ID);
  // Reply-To is queried when response is being created...
  given(sentTextMessage.getJMSReplyTo()).willReturn(destination);
  TextMessage responseMessage = mock(TextMessage.class);
  QueueSender queueSender = mock(QueueSender.class);
  Session session = mock(Session.class);
  given(session.createProducer(destination)).willReturn(queueSender);
  ResponsiveJmsTextMessageReturningMessageDelegate delegate = mock(ResponsiveJmsTextMessageReturningMessageDelegate.class);
  given(delegate.handleMessage(sentTextMessage)).willReturn(responseMessage);
  final MessageListenerAdapter adapter = new MessageListenerAdapter(delegate) {
    @Override
    protected Object extractMessage(Message message) {
      return message;
    }
  };
  adapter.setMessageConverter(null);
  adapter.onMessage(sentTextMessage, session);
  verify(responseMessage).setJMSCorrelationID(CORRELATION_ID);
  verify(queueSender).send(responseMessage);
  verify(queueSender).close();
}

  public void onMessage(javax.jms.Message request, Session session) throws JMSException {
    String text = "priority=" + request.getJMSPriority();
    TextMessage reply = session.createTextMessage(text);
    MessageProducer producer = session.createProducer(request.getJMSReplyTo());
    reply.setJMSCorrelationID(request.getJMSMessageID());
    producer.send(reply);
  }
}

@Test
public void messageCorrelationBasedOnRequestMessageIdNonOptimized() throws Exception {
  ActiveMqTestUtils.prepare();
  ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("producer-cached-consumers.xml", this.getClass());
  try {
    RequestReplyExchanger gateway = context.getBean("standardMessageIdCopyingConsumerWithoutOptimization", RequestReplyExchanger.class);
    CachingConnectionFactory connectionFactory = context.getBean(CachingConnectionFactory.class);
    final JmsTemplate jmsTemplate = new JmsTemplate(connectionFactory);
    final Destination requestDestination = context.getBean("siOutQueueNonOptimizedB", Destination.class);
    final Destination replyDestination = context.getBean("siInQueueNonOptimizedB", Destination.class);
    new Thread(() -> {
      final Message requestMessage = jmsTemplate.receive(requestDestination);
      jmsTemplate.send(replyDestination, (MessageCreator) session -> {
        TextMessage message = session.createTextMessage();
        message.setText("bar");
        message.setJMSCorrelationID(requestMessage.getJMSMessageID());
        return message;
      });
    }).start();
    org.springframework.messaging.Message<?> siReplyMessage = gateway.exchange(new GenericMessage<String>("foo"));
    assertEquals("bar", siReplyMessage.getPayload());
  }
  finally {
    context.close();
  }
}

@Test(expected = MessageTimeoutException.class)
public void messageCorrelationBasedOnRequestMessageIdOptimized() throws Exception {
  ActiveMqTestUtils.prepare();
  ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("producer-cached-consumers.xml", this.getClass());
  try {
    RequestReplyExchanger gateway = context.getBean("standardMessageIdCopyingConsumerWithOptimization", RequestReplyExchanger.class);
    CachingConnectionFactory connectionFactory = context.getBean(CachingConnectionFactory.class);
    final JmsTemplate jmsTemplate = new JmsTemplate(connectionFactory);
    final Destination requestDestination = context.getBean("siOutQueueOptimizedA", Destination.class);
    final Destination replyDestination = context.getBean("siInQueueOptimizedA", Destination.class);
    new Thread(() -> {
      final Message requestMessage = jmsTemplate.receive(requestDestination);
      jmsTemplate.send(replyDestination, (MessageCreator) session -> {
        TextMessage message = session.createTextMessage();
        message.setText("bar");
        message.setJMSCorrelationID(requestMessage.getJMSMessageID());
        return message;
      });
    }).start();
    gateway.exchange(new GenericMessage<String>("foo"));
  }
  finally {
    context.close();
  }
}

@Test(expected = MessageTimeoutException.class)
public void messageCorrelationBasedOnRequestCorrelationIdNonOptimized() throws Exception {
  ActiveMqTestUtils.prepare();
  ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("producer-cached-consumers.xml", this.getClass());
  try {
    RequestReplyExchanger gateway = context.getBean("correlationPropagatingConsumerWithoutOptimization", RequestReplyExchanger.class);
    CachingConnectionFactory connectionFactory = context.getBean(CachingConnectionFactory.class);
    final JmsTemplate jmsTemplate = new JmsTemplate(connectionFactory);
    final Destination requestDestination = context.getBean("siOutQueueNonOptimizedD", Destination.class);
    final Destination replyDestination = context.getBean("siInQueueNonOptimizedD", Destination.class);
    new Thread(() -> {
      final Message requestMessage = jmsTemplate.receive(requestDestination);
      jmsTemplate.send(replyDestination, (MessageCreator) session -> {
        TextMessage message = session.createTextMessage();
        message.setText("bar");
        message.setJMSCorrelationID(requestMessage.getJMSCorrelationID());
        return message;
      });
    }).start();
    gateway.exchange(new GenericMessage<String>("foo"));
  }
  finally {
    context.close();
  }
}

@Test
public void messageCorrelationBasedOnRequestCorrelationIdOptimized() throws Exception {
  ActiveMqTestUtils.prepare();
  ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("producer-cached-consumers.xml", this.getClass());
  try {
    RequestReplyExchanger gateway = context.getBean("correlationPropagatingConsumerWithOptimization", RequestReplyExchanger.class);
    CachingConnectionFactory connectionFactory = context.getBean(CachingConnectionFactory.class);
    final JmsTemplate jmsTemplate = new JmsTemplate(connectionFactory);
    final Destination requestDestination = context.getBean("siOutQueueOptimizedC", Destination.class);
    final Destination replyDestination = context.getBean("siInQueueOptimizedC", Destination.class);
    new Thread(() -> {
      final Message requestMessage = jmsTemplate.receive(requestDestination);
      jmsTemplate.send(replyDestination, (MessageCreator) session -> {
        TextMessage message = session.createTextMessage();
        message.setText("bar");
        message.setJMSCorrelationID(requestMessage.getJMSCorrelationID());
        return message;
      });
    }).start();
    org.springframework.messaging.Message<?> siReplyMessage = gateway.exchange(new GenericMessage<String>("foo"));
    assertEquals("bar", siReplyMessage.getPayload());
  }
  finally {
    context.close();
  }
}

TextMessage message = session.createTextMessage();
message.setText("bar");
message.setJMSCorrelationID(requestMessage.getJMSMessageID());
return message;

TextMessage replyMessage = session.createTextMessage();
replyMessage.setText(requestPayload);
replyMessage.setJMSCorrelationID(message.getJMSMessageID());
MessageProducer producer = session.createProducer(replyTo);
producer.send(replyMessage);

@Test
public void messageCorrelationBasedOnRequestCorrelationIdOptimized() throws Exception {
  ActiveMqTestUtils.prepare();
  AbstractApplicationContext context = new ClassPathXmlApplicationContext("producer-no-cached-consumers.xml", this.getClass());
  try {
    RequestReplyExchanger gateway = context.getBean("optimized", RequestReplyExchanger.class);
    ConnectionFactory connectionFactory = context.getBean(ConnectionFactory.class);
    final JmsTemplate jmsTemplate = new JmsTemplate(connectionFactory);
    final Destination requestDestination = context.getBean("siOutQueueA", Destination.class);
    final Destination replyDestination = context.getBean("siInQueueA", Destination.class);
    new Thread(() -> {
      final Message requestMessage = jmsTemplate.receive(requestDestination);
      jmsTemplate.send(replyDestination, (MessageCreator) session -> {
        TextMessage message = session.createTextMessage();
        message.setText("bar");
        message.setJMSCorrelationID(requestMessage.getJMSCorrelationID());
        return message;
      });
    }).start();
    org.springframework.messaging.Message<?> siReplyMessage = gateway.exchange(new GenericMessage<String>("foo"));
    assertEquals("bar", siReplyMessage.getPayload());
  }
  finally {
    context.close();
  }
}

@Test
public void messageCorrelationBasedOnRequestMessageIdNonOptimized() throws Exception {
  ActiveMqTestUtils.prepare();
  AbstractApplicationContext context = new ClassPathXmlApplicationContext("producer-no-cached-consumers.xml", this.getClass());
  try {
    RequestReplyExchanger gateway = context.getBean("nonoptimizedMessageId", RequestReplyExchanger.class);
    ConnectionFactory connectionFactory = context.getBean(ConnectionFactory.class);
    final JmsTemplate jmsTemplate = new JmsTemplate(connectionFactory);
    final Destination requestDestination = context.getBean("siOutQueueD", Destination.class);
    final Destination replyDestination = context.getBean("siInQueueD", Destination.class);
    new Thread(() -> {
      final Message requestMessage = jmsTemplate.receive(requestDestination);
      jmsTemplate.send(replyDestination, (MessageCreator) session -> {
        TextMessage message = session.createTextMessage();
        message.setText("bar");
        message.setJMSCorrelationID(requestMessage.getJMSMessageID());
        return message;
      });
    }).start();
    org.springframework.messaging.Message<?> siReplyMessage = gateway.exchange(new GenericMessage<String>("foo"));
    assertEquals("bar", siReplyMessage.getPayload());
  }
  finally {
    context.close();
  }
}

@Test(expected = MessageTimeoutException.class)
public void messageCorrelationBasedOnRequestMessageIdOptimized() throws Exception {
  ActiveMqTestUtils.prepare();
  AbstractApplicationContext context = new ClassPathXmlApplicationContext("producer-no-cached-consumers.xml", this.getClass());
  try {
    RequestReplyExchanger gateway = context.getBean("optimizedMessageId", RequestReplyExchanger.class);
    ConnectionFactory connectionFactory = context.getBean(ConnectionFactory.class);
    final JmsTemplate jmsTemplate = new JmsTemplate(connectionFactory);
    final Destination requestDestination = context.getBean("siOutQueueC", Destination.class);
    final Destination replyDestination = context.getBean("siInQueueC", Destination.class);
    new Thread(() -> {
      final Message requestMessage = jmsTemplate.receive(requestDestination);
      jmsTemplate.send(replyDestination, (MessageCreator) session -> {
        TextMessage message = session.createTextMessage();
        message.setText("bar");
        message.setJMSCorrelationID(requestMessage.getJMSMessageID());
        return message;
      });
    }).start();
    org.springframework.messaging.Message<?> siReplyMessage = gateway.exchange(new GenericMessage<String>("foo"));
    assertEquals("bar", siReplyMessage.getPayload());
  }
  finally {
    context.close();
  }
}

  @Test(expected = MessageTimeoutException.class)
  public void messageCorrelationBasedOnRequestCorrelationIdNonOptimized() throws Exception {
    ActiveMqTestUtils.prepare();
    AbstractApplicationContext context = new ClassPathXmlApplicationContext("producer-no-cached-consumers.xml", this.getClass());
    try {
      RequestReplyExchanger gateway = context.getBean("nonoptimized", RequestReplyExchanger.class);
      ConnectionFactory connectionFactory = context.getBean(ConnectionFactory.class);
      final JmsTemplate jmsTemplate = new JmsTemplate(connectionFactory);

      final Destination requestDestination = context.getBean("siOutQueueB", Destination.class);
      final Destination replyDestination = context.getBean("siInQueueB", Destination.class);
      new Thread(() -> {
        final Message requestMessage = jmsTemplate.receive(requestDestination);
        jmsTemplate.send(replyDestination, (MessageCreator) session -> {
          TextMessage message = session.createTextMessage();
          message.setText("bar");
          message.setJMSCorrelationID(requestMessage.getJMSCorrelationID());
          return message;
        });
      }).start();
      gateway.exchange(new GenericMessage<String>("foo"));
    }
    finally {
      context.close();
    }
  }
}

@Test
public void testWithReply() throws Exception {
  QueueChannel replies = new QueueChannel();
  this.gateway1.setOutputChannel(replies);
  this.gateway1.start();
  this.gateway1.handleMessage(MessageBuilder.withPayload("foo")
      .setHeader(JmsHeaders.CORRELATION_ID, "baz")// make sure it's restored in case we're from an upstream gw
      .build());
  JmsTemplate template = new JmsTemplate(this.ccf);
  template.setReceiveTimeout(10000);
  final Message received = template.receive("asyncTest1");
  assertNotNull(received);
  template.send(received.getJMSReplyTo(), (MessageCreator) session -> {
    TextMessage textMessage = session.createTextMessage("bar");
    textMessage.setJMSCorrelationID(received.getJMSCorrelationID());
    return textMessage;
  });
  org.springframework.messaging.Message<?> reply = replies.receive(10000);
  assertNotNull(reply);
  assertEquals("bar", reply.getPayload());
  assertEquals("baz", reply.getHeaders().get(JmsHeaders.CORRELATION_ID));
  this.gateway1.stop();
}

MessageCreator reply = session -> {
  TextMessage reply1 = session.createTextMessage("bar");
  reply1.setJMSCorrelationID(request.getJMSMessageID());
  return reply1;
};