Java ClientMessage.acknowledge方法代码示例

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
@Test
public void testConsumeFromDurableQueue() throws Exception {
   SimpleString queue = RandomUtil.randomSimpleString();
   SimpleString address = RandomUtil.randomSimpleString();

   session.createQueue(address, queue, true);

   ClientProducer producer = session.createProducer(address);
   producer.send(session.createMessage(false));

   session.start();
   ClientConsumer consumer = session.createConsumer(queue);
   ClientMessage message = consumer.receive(500);
   Assert.assertNotNull(message);
   message.acknowledge();

   consumer.close();
   session.deleteQueue(queue);
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
@Test
public void testRouteToSingleTemporaryQueue() throws Exception {
   ClientSession sendSession = cf.createSession(false, true, true);
   sendSession.createTemporaryQueue(addressA, queueA);
   int numMessages = 300;
   ClientProducer p = sendSession.createProducer(addressA);
   for (int i = 0; i < numMessages; i++) {
      p.send(sendSession.createMessage(false));
   }
   ClientSession session = cf.createSession(false, true, true);
   ClientConsumer c1 = session.createConsumer(queueA);
   session.start();
   for (int i = 0; i < numMessages; i++) {
      ClientMessage m = c1.receive(5000);
      Assert.assertNotNull(m);
      m.acknowledge();
   }
   Assert.assertNull(c1.receiveImmediate());
   sendSession.close();
   session.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
@Test
public void testExpireWithWildcardAddressSettings() throws Exception {
   SimpleString ea = new SimpleString("EA");
   SimpleString qName = new SimpleString("q1");
   SimpleString eq = new SimpleString("EA1");
   AddressSettings addressSettings = new AddressSettings().setExpiryAddress(ea);
   server.getAddressSettingsRepository().addMatch("*", addressSettings);
   clientSession.createQueue(ea, eq, null, false);
   clientSession.createQueue(qName, qName, null, false);

   ClientProducer producer = clientSession.createProducer(qName);
   ClientMessage clientMessage = createTextMessage(clientSession, "heyho!");
   clientMessage.setExpiration(System.currentTimeMillis());
   producer.send(clientMessage);

   clientSession.start();
   ClientConsumer clientConsumer = clientSession.createConsumer(qName);
   ClientMessage m = clientConsumer.receiveImmediate();
   Assert.assertNull(m);
   clientConsumer.close();

   clientConsumer = clientSession.createConsumer(eq);
   m = clientConsumer.receive(500);
   Assert.assertNotNull(m);
   Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
   m.acknowledge();
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
@Test
public void testConsumerAckImmediateCloseSession() throws Exception {

   ClientSessionFactory sf = createSessionFactory(locator);

   ClientSession session = sf.createSession(false, true, true, true);

   ClientProducer producer = session.createProducer(QUEUE);

   final int numMessages = 100;

   for (int i = 0; i < numMessages; i++) {
      ClientMessage message = createTextMessage(session, "m" + i);
      producer.send(message);
   }

   ClientConsumer consumer = session.createConsumer(QUEUE);
   session.start();
   for (int i = 0; i < numMessages; i++) {
      ClientMessage message2 = consumer.receive(1000);

      Assert.assertEquals("m" + i, message2.getBodyBuffer().readString());
      if (i < 50) {
         message2.acknowledge();
      }
   }
   // assert that all the messages are there and none have been acked
   Assert.assertEquals(0, ((Queue) server.getPostOffice().getBinding(QUEUE).getBindable()).getDeliveringCount());
   Assert.assertEquals(0, getMessageCount(((Queue) server.getPostOffice().getBinding(QUEUE).getBindable())));

   session.close();

   Assert.assertEquals(0, ((Queue) server.getPostOffice().getBinding(QUEUE).getBindable()).getDeliveringCount());
   Assert.assertEquals(0, getMessageCount(((Queue) server.getPostOffice().getBinding(QUEUE).getBindable())));
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
@Test
public void testMultipleMessagesPersistedCorrectly() throws Exception {
   ClientProducer producer = clientSession.createProducer(address);
   ClientConsumer consumer = clientSession.createConsumer(qName1);
   SimpleString rh = new SimpleString("SMID1");
   ClientMessage m1 = createTextMessage(clientSession, "m1");
   m1.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
   m1.setDurable(true);
   ClientMessage m2 = createTextMessage(clientSession, "m2");
   m2.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
   m2.setDurable(true);
   ClientMessage m3 = createTextMessage(clientSession, "m3");
   m3.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
   m3.setDurable(true);
   ClientMessage m4 = createTextMessage(clientSession, "m4");
   m4.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
   m4.setDurable(true);
   ClientMessage m5 = createTextMessage(clientSession, "m5");
   m5.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
   m5.setDurable(true);
   ClientMessage m6 = createTextMessage(clientSession, "m6");
   m6.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
   m6.setDurable(true);
   producer.send(m1);
   producer.send(m2);
   producer.send(m3);
   producer.send(m4);
   producer.send(m5);
   producer.send(m6);
   clientSession.start();
   ClientMessage m = consumer.receive(1000);
   Assert.assertNotNull(m);
   m.acknowledge();
   Assert.assertEquals(m.getBodyBuffer().readString(), "m6");
   m = consumer.receiveImmediate();
   Assert.assertNull(m);
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
private void checkUserSendAndReceive(final String genericQueueName,
                                     final ClientSession connection) throws Exception {
   connection.start();
   try {
      ClientProducer prod = connection.createProducer(genericQueueName);
      ClientConsumer con = connection.createConsumer(genericQueueName);
      ClientMessage m = connection.createMessage(false);
      prod.send(m);
      ClientMessage rec = con.receive(1000);
      Assert.assertNotNull(rec);
      rec.acknowledge();
   } finally {
      connection.stop();
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
@Override
public void onMessage(final ClientMessage request) {
   try {
      ClientMessage reply = session.createMessage(false);
      SimpleString replyTo = (SimpleString) request.getObjectProperty(ClientMessageImpl.REPLYTO_HEADER_NAME);
      long value = (Long) request.getObjectProperty(key);
      reply.putLongProperty(key, value);
      ClientProducer replyProducer = session.createProducer(replyTo);
      replyProducer.send(reply);
      request.acknowledge();
   } catch (ActiveMQException e) {
      e.printStackTrace();
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
private void doReceiveMessage(ClientMessage message) throws Exception {
   Assert.assertNotNull(message);
   message.acknowledge();
   Integer value = message.getIntProperty("i");
   AtomicInteger mapCount = new AtomicInteger(1);

   mapCount = mapCounter.putIfAbsent(value, mapCount);

   if (mapCount != null) {
      mapCount.incrementAndGet();
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
private void internalTest(final boolean isCommit) throws Exception {
   Configuration configuration = createDefaultInVMConfig().setJMXManagementEnabled(true);

   ActiveMQServer server = createServer(false, configuration);
   server.setMBeanServer(mbeanServer);
   server.start();
   Xid xid = newXID();

   ClientSessionFactory sf = createSessionFactory(locator);

   ClientSession session = sf.createSession(true, false, false);

   session.createQueue(ADDRESS, ADDRESS, true);

   session.start(xid, XAResource.TMNOFLAGS);

   ClientProducer producer = session.createProducer(ADDRESS);

   ClientMessage msg = session.createMessage(true);

   msg.getBodyBuffer().writeString(body);

   producer.send(msg);

   session.end(xid, XAResource.TMSUCCESS);

   session.prepare(xid);

   session.close();

   ActiveMQServerControl jmxServer = ManagementControlHelper.createActiveMQServerControl(mbeanServer);

   String[] preparedTransactions = jmxServer.listPreparedTransactions();

   Assert.assertEquals(1, preparedTransactions.length);

   System.out.println(preparedTransactions[0]);

   Assert.assertEquals(0, jmxServer.listHeuristicCommittedTransactions().length);
   Assert.assertEquals(0, jmxServer.listHeuristicRolledBackTransactions().length);

   if (isCommit) {
      jmxServer.commitPreparedTransaction(XidImpl.toBase64String(xid));
   } else {
      jmxServer.rollbackPreparedTransaction(XidImpl.toBase64String(xid));
   }

   Assert.assertEquals(0, jmxServer.listPreparedTransactions().length);
   if (isCommit) {
      Assert.assertEquals(1, jmxServer.listHeuristicCommittedTransactions().length);
      Assert.assertEquals(0, jmxServer.listHeuristicRolledBackTransactions().length);
   } else {
      Assert.assertEquals(0, jmxServer.listHeuristicCommittedTransactions().length);
      Assert.assertEquals(1, jmxServer.listHeuristicRolledBackTransactions().length);
   }

   if (isCommit) {
      Assert.assertEquals(1, getMessageCount(((Queue) server.getPostOffice().getBinding(ADDRESS).getBindable())));

      session = sf.createSession(false, false, false);

      session.start();
      ClientConsumer consumer = session.createConsumer(ADDRESS);
      msg = consumer.receive(1000);
      Assert.assertNotNull(msg);
      msg.acknowledge();
      Assert.assertEquals(body, msg.getBodyBuffer().readString());

      session.commit();
      session.close();
   }

   Assert.assertEquals(0, getMessageCount(((Queue) server.getPostOffice().getBinding(ADDRESS).getBindable())));
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
@Test
public void testExpireMessagesWithFilter() throws Exception {
   SimpleString key = new SimpleString("key");
   long matchingValue = RandomUtil.randomLong();
   long unmatchingValue = matchingValue + 1;

   SimpleString address = RandomUtil.randomSimpleString();
   SimpleString queue = RandomUtil.randomSimpleString();

   session.createQueue(address, queue, null, false);
   ClientProducer producer = session.createProducer(address);

   // send on queue
   ClientMessage matchingMessage = session.createMessage(false);
   matchingMessage.putLongProperty(key, matchingValue);
   producer.send(matchingMessage);
   ClientMessage unmatchingMessage = session.createMessage(false);
   unmatchingMessage.putLongProperty(key, unmatchingValue);
   producer.send(unmatchingMessage);

   QueueControl queueControl = createManagementControl(address, queue);
   Assert.assertEquals(2, getMessageCount(queueControl));

   int expiredMessagesCount = queueControl.expireMessages(key + " =" + matchingValue);
   Assert.assertEquals(1, expiredMessagesCount);
   Assert.assertEquals(1, getMessageCount(queueControl));

   // consume the unmatched message from queue
   ClientConsumer consumer = session.createConsumer(queue);
   ClientMessage m = consumer.receive(500);
   Assert.assertNotNull(m);
   Assert.assertEquals(unmatchingValue, m.getObjectProperty(key));

   m.acknowledge();

   // check there is no other message to consume:
   m = consumer.receiveImmediate();
   Assert.assertNull(m);

   consumer.close();
   session.deleteQueue(queue);
   session.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
private void internalTest(int MAX_MESSAGES,
                          String MY_ADDRESS,
                          String MY_QUEUE,
                          ActiveMQServer server) throws Exception {
   ServerLocator locator = createInVMNonHALocator().setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);

   ClientSessionFactory factory = createSessionFactory(locator);
   ClientSession session = factory.createSession(false, true, true);

   session.createQueue(MY_ADDRESS, MY_QUEUE, true);

   final ClientProducer producer = session.createProducer(MY_ADDRESS);

   final ClientMessage message = session.createMessage(false);
   message.getBodyBuffer().writeBytes(new byte[1024]);

   ExecutorService executor = Executors.newFixedThreadPool(1, ActiveMQThreadFactory.defaultThreadFactory());
   Callable<Object> sendMessageTask = new Callable<Object>() {
      @Override
      public Object call() throws ActiveMQException {
         producer.send(message);
         return null;
      }
   };

   int sendCount = 0;

   for (int i = 0; i < MAX_MESSAGES; i++) {
      Future<Object> future = executor.submit(sendMessageTask);
      try {
         future.get(3, TimeUnit.SECONDS);
         sendCount++;
      } catch (TimeoutException ex) {
         // message sending has been blocked
         break;
      } finally {
         future.cancel(true); // may or may not desire this
      }
   }

   executor.shutdown();
   session.close();

   session = factory.createSession(false, true, true);
   session.start();
   ClientConsumer consumer = session.createConsumer(MY_QUEUE);
   for (int i = 0; i < sendCount; i++) {
      ClientMessage msg = consumer.receive(250);
      if (msg == null)
         break;
      msg.acknowledge();
   }

   session.close();
   locator.close();
   server.stop();

   // Using the code only so the test doesn't fail just because someone edits the log text
   Assert.assertTrue("Expected to find AMQ222183", AssertionLoggerHandler.findText("AMQ222183", "myAddress"));
   Assert.assertTrue("Expected to find AMQ221046", AssertionLoggerHandler.findText("AMQ221046", "myAddress"));
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
/**
 * @param session
 * @param queueToRead
 * @param numberOfBytes
 * @throws ActiveMQException
 * @throws IOException
 */
protected void readMessage(final ClientSession session,
                           final SimpleString queueToRead,
                           final int numberOfBytes) throws ActiveMQException, IOException {
   session.start();

   ClientConsumer consumer = session.createConsumer(queueToRead);

   ClientMessage clientMessage = consumer.receive(5000);

   Assert.assertNotNull(clientMessage);

   clientMessage.acknowledge();

   session.commit();

   consumer.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
@Test
public void testSimpleConnectOnMultipleNodes() throws Exception {
   BridgeConfiguration bridgeConfiguration = new BridgeConfiguration();

   String ORIGINAL_QUEUE = "noCluster.originalQueue";
   String TARGET_QUEUE = "noCluster.targetQueue";

   bridgeConfiguration.setHA(true);
   List<String> connectors = new ArrayList<>();
   connectors.add("target-4");
   connectors.add("backup-4");
   bridgeConfiguration.setName("Bridge-for-test");
   bridgeConfiguration.setStaticConnectors(connectors);
   bridgeConfiguration.setQueueName(ORIGINAL_QUEUE);
   bridgeConfiguration.setForwardingAddress(TARGET_QUEUE);
   bridgeConfiguration.setRetryInterval(100);
   bridgeConfiguration.setConfirmationWindowSize(1);
   bridgeConfiguration.setReconnectAttempts(-1);
   servers[2].getConfiguration().getBridgeConfigurations().add(bridgeConfiguration);

   for (ActiveMQServer server : servers) {
      server.getConfiguration().getQueueConfigurations().add(new CoreQueueConfiguration().setAddress(ORIGINAL_QUEUE).setName(ORIGINAL_QUEUE));
      server.getConfiguration().getQueueConfigurations().add(new CoreQueueConfiguration().setAddress(TARGET_QUEUE).setName(TARGET_QUEUE));
   }

   startServers();

   // The server where the bridge source is configured at
   ServerLocator locator = createLocator(false, 2);

   ClientSessionFactory factory = addSessionFactory(locator.createSessionFactory());
   ClientSession session = addClientSession(factory.createSession(false, false));
   ClientProducer producer = addClientProducer(session.createProducer(ORIGINAL_QUEUE));

   for (int i = 0; i < 100; i++) {
      ClientMessage msg = session.createMessage(true);
      msg.putIntProperty("i", i);
      producer.send(msg);
   }
   session.commit();

   ServerLocator locatorConsumer = createLocator(false, 4);
   ClientSessionFactory factoryConsumer = addSessionFactory(locatorConsumer.createSessionFactory());
   ClientSession sessionConsumer = addClientSession(factoryConsumer.createSession(false, false));
   ClientConsumer consumer = sessionConsumer.createConsumer(TARGET_QUEUE);

   sessionConsumer.start();

   for (int i = 0; i < 100; i++) {
      ClientMessage message = consumer.receive(10000);
      assertNotNull(message);
      message.acknowledge();
   }

   sessionConsumer.commit();
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
@Test
public void testConsumeAfterRestart() throws Exception {
   ClientSession session = null;

   LargeMessageTestInterceptorIgnoreLastPacket.clearInterrupt();

   ActiveMQServer server = createServer(true, isNetty());
   server.start();

   QueueFactory original = server.getQueueFactory();

   locator.setBlockOnNonDurableSend(true).setBlockOnDurableSend(true);

   ClientSessionFactory sf = createSessionFactory(locator);

   session = sf.createSession(false, true, true);

   session.createQueue(ADDRESS, ADDRESS, true);

   ClientProducer producer = session.createProducer(ADDRESS);

   for (int i = 0; i < 10; i++) {
      Message clientFile = createLargeClientMessageStreaming(session, LARGE_MESSAGE_SIZE, true);

      producer.send(clientFile);
   }
   session.commit();

   session.close();
   sf.close();

   server.stop();
   server.start();

   sf = createSessionFactory(locator);

   session = sf.createSession(false, false);

   ClientConsumer cons = session.createConsumer(ADDRESS);

   session.start();

   for (int i = 0; i < 10; i++) {
      ClientMessage msg = cons.receive(5000);
      Assert.assertNotNull(msg);
      msg.saveToOutputStream(new java.io.OutputStream() {
         @Override
         public void write(int b) throws IOException {
         }
      });
      msg.acknowledge();
      session.commit();
   }

   ((ActiveMQServerImpl) server).replaceQueueFactory(original);
   server.fail(false);
   server.start();

   server.stop();

   validateNoFilesOnLargeDir();
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
@Test
public void testRouteToMultipleQueueWithFilters() throws Exception {
   ClientSession sendSession = cf.createSession(false, true, true);
   sendSession.createQueue(addressA, queueA, new SimpleString("foo = 'bar'"), false);
   sendSession.createQueue(addressA, queueB, new SimpleString("x = 1"), false);
   sendSession.createQueue(addressA, queueC, new SimpleString("b = false"), false);
   int numMessages = 300;
   ClientProducer p = sendSession.createProducer(addressA);
   for (int i = 0; i < numMessages; i++) {
      ClientMessage clientMessage = sendSession.createMessage(false);
      if (i % 3 == 0) {
         clientMessage.putStringProperty(new SimpleString("foo"), new SimpleString("bar"));
      } else if (i % 3 == 1) {
         clientMessage.putIntProperty(new SimpleString("x"), 1);
      } else {
         clientMessage.putBooleanProperty(new SimpleString("b"), false);
      }
      p.send(clientMessage);
   }
   ClientSession session = cf.createSession(false, true, true);
   ClientConsumer c1 = session.createConsumer(queueA);
   ClientConsumer c2 = session.createConsumer(queueB);
   ClientConsumer c3 = session.createConsumer(queueC);
   session.start();
   for (int i = 0; i < numMessages / 3; i++) {
      ClientMessage m = c1.receive(5000);
      Assert.assertNotNull(m);
      m.acknowledge();
      m = c2.receive(5000);
      Assert.assertNotNull(m);
      m.acknowledge();
      m = c3.receive(5000);
      Assert.assertNotNull(m);
      m.acknowledge();
   }
   Assert.assertNull(c1.receiveImmediate());
   Assert.assertNull(c2.receiveImmediate());
   Assert.assertNull(c3.receiveImmediate());
   sendSession.close();
   session.close();
}