How to use

acknowledge

method

in

javax.jms.TextMessage

verify(textMessage).acknowledge();

private void acknowledge(TextMessage textMessage) {
 try {
  textMessage.acknowledge();
 } catch (JMSException e) {
  logger.error(e.getMessage(), e);
 }
}

@Override
public <V> V receive(Class<V> target) throws JMSException, IOException {
  val received = receiveTextMessage();
  received.acknowledge();
  val jsonString = received.getText();
  val unserialize = unserialize(jsonString, target);
  return unserialize;
}

 Queue tempQueue = (Queue) ctx.lookup("tempQueue");
QueueSession queueLocalSession = 
 queueConn.createQueueSession(false,
   Session.CLIENT_ACKNOWLEDGE);  
QueueReceiver queueReceiver = queueLocalSession.createReceiver(tempQueue);
TextMessage localMessage = (TextMessage) queueReceiver.receive();

//send to remote queue
Queue remoteQueue = (Queue) ctx.lookup("remoteQueue");
QueueSender queueSender = queueRemoteSession.createSender(remoteQueue);
Message newMessage = queueRemoteSession.createTextMessage(
 localMessage.getText());
queueSender.send( newMessage);

//now acknowledge the message since we safely sent to remoteQueue
localMessage.acknowledge();

private int flushMessages(MessageConsumer consumer) throws JMSException {
 int received = 0;
 while (true) {
   TextMessage msg = (TextMessage) consumer.receiveNoWait();
   if (msg == null) {
    break;
   }
   msg.acknowledge();
   received++;
 }
 return received;
}

  @Override
  public void onMessage(Message m) {
   try {
     TextMessage tm = (TextMessage) m;
     assertEquals("" + counter.get(), tm.getText());
     counter.incrementAndGet();
     if (counter.get() == 2) {
      sendDone.await();
      connection.close();
      got2Done.countDown();
     }
     System.out.println("acking tm: " + tm.getText());
     tm.acknowledge();
   } catch (Throwable e) {
     System.out.println("ack failed!!");
     e.printStackTrace();
   }
  }
});

@Test
public void testClientACK() throws Exception {
 Queue queueSource = createQueue("Source");
 Queue queueTarget = createQueue("Dest");
 Connection connection = cf.createConnection();
 Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
 final MessageProducer producer = session.createProducer(queueSource);
 final TextMessage message = session.createTextMessage("message text");
 producer.send(message);
 connection.start();
 final MessageConsumer consumer = session.createConsumer(queueTarget);
 TextMessage receivedMessage = (TextMessage) consumer.receive(1000);
 Assert.assertNotNull(receivedMessage);
 receivedMessage.acknowledge();
 connection.close();
}

@Test
public void testSendEmpty() throws Exception {
 try (Connection connection = factory.createConnection()) {
   Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
   Queue queue = session.createQueue(queueName);
   System.out.println("Queue:" + queue);
   MessageProducer producer = session.createProducer(queue);
   MessageConsumer consumer = session.createConsumer(queue);
   producer.send(session.createTextMessage());
   Assert.assertNull(consumer.receive(100));
   connection.start();
   TextMessage message = (TextMessage) consumer.receive(5000);
   Assert.assertNotNull(message);
   message.acknowledge();
 }
}

@Test
public void testClientACK() throws Exception {
 try {
   Connection connection = factory.createConnection();
   Collection<Session> sessions = new LinkedList<>();
   Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
   Queue queue = session.createQueue(queueName);
   System.out.println("Queue:" + queue);
   MessageProducer producer = session.createProducer(queue);
   MessageConsumer consumer = session.createConsumer(queue);
   producer.send(session.createTextMessage("test"));
   Assert.assertNull(consumer.receive(100));
   connection.start();
   TextMessage message = (TextMessage) consumer.receive(5000);
   Assert.assertNotNull(message);
   message.acknowledge();
   connection.close();
   System.err.println("Done!!!");
 } catch (Throwable e) {
   e.printStackTrace();
 }
}

  @Test
  public void testClientAcknowledge() throws Exception {
   conn = createConnection();

   Session session = conn.createSession(false, Session.CLIENT_ACKNOWLEDGE);
   MessageProducer p = session.createProducer(queue1);
   p.send(session.createTextMessage("CLACK"));

   MessageConsumer cons = session.createConsumer(queue1);

   conn.start();

   TextMessage m = (TextMessage) cons.receive(1000);

   ProxyAssertSupport.assertEquals("CLACK", m.getText());

   // make sure the message is still in "delivering" state
   assertRemainingMessages(1);

   m.acknowledge();

   assertRemainingMessages(0);
  }
}

@Test
public void testTransactionalSimple() throws Exception {
 try (Connection connection = factory.createConnection()) {
   Session session = connection.createSession(true, Session.SESSION_TRANSACTED);
   Queue queue = session.createQueue(queueName);
   System.out.println("Queue:" + queue);
   MessageProducer producer = session.createProducer(queue);
   MessageConsumer consumer = session.createConsumer(queue);
   producer.send(session.createTextMessage("test"));
   session.commit();
   Assert.assertNull(consumer.receive(100));
   connection.start();
   TextMessage message = (TextMessage) consumer.receive(5000);
   Assert.assertEquals("test", message.getText());
   Assert.assertNotNull(message);
   message.acknowledge();
 }
}

  r1.acknowledge();
  r2.acknowledge();
  r3.acknowledge();
} finally {
  if (conn != null) {

  tm3.acknowledge();
} finally {
  if (conn != null) {

m.acknowledge();

@Test
public void testSimpleSendReceive() throws Exception {
 factory.setAlwaysSyncSend(true);
 flowControlConnection = (ActiveMQConnection) factory.createConnection();
 flowControlConnection.start();
 Session session = flowControlConnection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
 MessageConsumer consumer = session.createConsumer(queueA);
 // Test sending to Queue B it should not block.
 CountDownLatch pubishDoneToQeueuA = asyncSendTo(queueA, "Message 1");
 assertTrue(pubishDoneToQeueuA.await(2, TimeUnit.SECONDS));
 TextMessage msg = (TextMessage) consumer.receive();
 assertEquals("Message 1", msg.getText());
 msg.acknowledge();
 pubishDoneToQeueuA = asyncSendTo(queueA, "Message 2");
 assertTrue(pubishDoneToQeueuA.await(2, TimeUnit.SECONDS));
 msg = (TextMessage) consumer.receive();
 assertEquals("Message 2", msg.getText());
 msg.acknowledge();
 consumer.close();
}

  ProxyAssertSupport.assertEquals("hello3", rm4.getText());
  rm4.acknowledge();
} finally {
  if (conn != null) {

@Test
public void test2ndPublisherWithSyncSendConnectionThatIsBlocked() throws Exception {
 factory.setAlwaysSyncSend(true);
 flowControlConnection = (ActiveMQConnection) factory.createConnection();
 flowControlConnection.start();
 Session session = flowControlConnection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
 MessageConsumer consumer = session.createConsumer(queueB);
 // Test sending to Queue A
 // 1st send should not block. But the rest will.
 fillQueue(queueA);
 // Test sending to Queue B it should not block.
 CountDownLatch pubishDoneToQeueuB = asyncSendTo(queueB, "Message 1");
 assertTrue(pubishDoneToQeueuB.await(2, TimeUnit.SECONDS));
 TextMessage msg = (TextMessage) consumer.receive();
 assertEquals("Message 1", msg.getText());
 msg.acknowledge();
 pubishDoneToQeueuB = asyncSendTo(queueB, "Message 2");
 assertTrue(pubishDoneToQeueuB.await(2, TimeUnit.SECONDS));
 msg = (TextMessage) consumer.receive();
 assertEquals("Message 2", msg.getText());
 msg.acknowledge();
 consumer.close();
}

@Test
public void test2ndPublisherWithProducerWindowSendConnectionThatIsBlocked() throws Exception {
 factory.setProducerWindowSize(1024 * 64);
 flowControlConnection = (ActiveMQConnection) factory.createConnection();
 flowControlConnection.start();
 Session session = flowControlConnection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
 MessageConsumer consumer = session.createConsumer(queueB);
 // Test sending to Queue A
 // 1 few sends should not block until the producer window is used up.
 fillQueue(queueA);
 // Test sending to Queue B it should not block since the connection
 // should not be blocked.
 CountDownLatch pubishDoneToQeueuB = asyncSendTo(queueB, "Message 1");
 assertTrue(pubishDoneToQeueuB.await(2, TimeUnit.SECONDS));
 TextMessage msg = (TextMessage) consumer.receive();
 assertEquals("Message 1", msg.getText());
 msg.acknowledge();
 pubishDoneToQeueuB = asyncSendTo(queueB, "Message 2");
 assertTrue(pubishDoneToQeueuB.await(2, TimeUnit.SECONDS));
 msg = (TextMessage) consumer.receive();
 assertEquals("Message 2", msg.getText());
 msg.acknowledge();
 consumer.close();
}

tm.acknowledge();

m.acknowledge();
Assert.assertEquals("m" + i, m.getText());