Java ClientConsumer.receive方法代码示例

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
@Test
public void testRouteToSingleQueueWithFilter() throws Exception {
   ClientSession sendSession = cf.createSession(false, true, true);
   sendSession.createQueue(addressA, queueA, new SimpleString("foo = 'bar'"), false);
   int numMessages = 300;
   ClientProducer p = sendSession.createProducer(addressA);
   for (int i = 0; i < numMessages; i++) {
      ClientMessage clientMessage = sendSession.createMessage(false);
      clientMessage.putStringProperty(new SimpleString("foo"), new SimpleString("bar"));
      p.send(clientMessage);
   }
   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.ClientConsumer; //导入方法依赖的package包/类
@Test
public void testFirstMessageReceivedAndCancelled() throws Exception {
   ClientProducer producer = clientSession.createProducer(address);
   ClientConsumer consumer = clientSession.createConsumer(qName1);
   ClientMessage m1 = createTextMessage(clientSession, "m1");
   SimpleString rh = new SimpleString("SMID1");
   m1.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
   ClientMessage m2 = createTextMessage(clientSession, "m2");
   m2.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
   producer.send(m1);
   clientSession.start();
   ClientMessage m = consumer.receive(1000);
   Assert.assertNotNull(m);
   Assert.assertEquals(m.getBodyBuffer().readString(), "m1");
   producer.send(m2);
   consumer.close();
   consumer = clientSession.createConsumer(qName1);
   m = consumer.receive(1000);
   Assert.assertNotNull(m);
   Assert.assertEquals("m2", m.getBodyBuffer().readString());
   m.acknowledge();
   m = consumer.receiveImmediate();
   Assert.assertNull(m);
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
private void receiveAllMessages() throws Exception {
   final ClientSessionFactory sf = createSessionFactory(locator);
   ClientSession session = sf.createSession(null, null, false, true, true, false, 0);

   session.start();
   ClientConsumer consumer = session.createConsumer(ADDRESS);
   for (int i = 0; i < numMsgs; i++) {
      ClientMessage message = consumer.receive(2000);
      assertNotNull(message);
      message.acknowledge();
   }

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

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
@Test
public void testBasicWildcardRoutingQueuesDontExist2() throws Exception {
   SimpleString addressAB = new SimpleString("a.b");
   SimpleString addressAC = new SimpleString("a.c");
   SimpleString address = new SimpleString("a.*");
   SimpleString queueName = new SimpleString("Q");
   SimpleString queueName2 = new SimpleString("Q2");
   clientSession.createQueue(address, queueName, null, false);
   clientSession.createQueue(address, queueName2, null, false);
   ClientProducer producer = clientSession.createProducer(addressAB);
   ClientProducer producer2 = clientSession.createProducer(addressAC);
   ClientConsumer clientConsumer = clientSession.createConsumer(queueName);
   clientSession.start();
   producer.send(createTextMessage(clientSession, "m1"));
   producer2.send(createTextMessage(clientSession, "m2"));
   ClientMessage m = clientConsumer.receive(500);
   Assert.assertNotNull(m);
   Assert.assertEquals("m1", m.getBodyBuffer().readString());
   m.acknowledge();
   m = clientConsumer.receive(500);
   Assert.assertNotNull(m);
   Assert.assertEquals("m2", m.getBodyBuffer().readString());
   m.acknowledge();
   m = clientConsumer.receiveImmediate();
   Assert.assertNull(m);
   clientConsumer.close();
   clientSession.deleteQueue(queueName);

   Assert.assertEquals(1, server.getPostOffice().getBindingsForAddress(addressAB).getBindings().size());
   Assert.assertEquals(1, server.getPostOffice().getBindingsForAddress(addressAC).getBindings().size());
   Assert.assertEquals(1, server.getPostOffice().getBindingsForAddress(address).getBindings().size());

   clientSession.deleteQueue(queueName2);

   Assert.assertEquals(0, server.getPostOffice().getBindingsForAddress(addressAB).getBindings().size());
   Assert.assertEquals(0, server.getPostOffice().getBindingsForAddress(addressAC).getBindings().size());
   Assert.assertEquals(0, server.getPostOffice().getBindingsForAddress(address).getBindings().size());
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
@Test
public void testJAASSecurityManagerAuthenticationWithValidateUser() throws Exception {
   ActiveMQJAASSecurityManager securityManager = new ActiveMQJAASSecurityManager("PropertiesLogin");
   ActiveMQServer server = addServer(ActiveMQServers.newActiveMQServer(createDefaultInVMConfig().setSecurityEnabled(true), ManagementFactory.getPlatformMBeanServer(), securityManager, false));
   server.getConfiguration().setPopulateValidatedUser(true);
   server.start();
   Role role = new Role("programmers", true, true, true, true, true, true, true, true, true, true);
   Set<Role> roles = new HashSet<>();
   roles.add(role);
   server.getSecurityRepository().addMatch("#", roles);
   ClientSessionFactory cf = createSessionFactory(locator);

   try {
      ClientSession session = cf.createSession("first", "secret", false, true, true, false, 0);
      server.createQueue(SimpleString.toSimpleString("address"), RoutingType.ANYCAST, SimpleString.toSimpleString("queue"), null, true, false);
      ClientProducer producer = session.createProducer("address");
      producer.send(session.createMessage(true));
      session.commit();
      producer.close();
      ClientConsumer consumer = session.createConsumer("queue");
      session.start();
      ClientMessage message = consumer.receive(1000);
      assertNotNull(message);
      assertEquals("first", message.getValidatedUserID());
      session.close();
   } catch (ActiveMQException e) {
      e.printStackTrace();
      Assert.fail("should not throw exception");
   }
}
 

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

   ClientSessionFactory sf = createSessionFactory(locator);

   ClientSession session = sf.createSession(false, true, false, 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());
   }
   // 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();
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
@Test
public void testUniqueIDsWithDivert() throws Exception {
   Map<String, Object> params = new HashMap<>();
   params.put(TransportConstants.HOST_PROP_NAME, "localhost");
   TransportConfiguration tc = createTransportConfiguration(true, false, params);
   ServerLocator locator = addServerLocator(ActiveMQClient.createServerLocatorWithHA(tc)).setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true).setReconnectAttempts(-1);
   sf = createSessionFactoryAndWaitForTopology(locator, 2);
   int minLarge = locator.getMinLargeMessageSize();

   ClientSession session = sf.createSession(false, false);
   addClientSession(session);
   session.start();

   final int num = 100;
   ClientProducer producer = session.createProducer(DIVERT_ADDRESS);
   for (int i = 0; i < num; i++) {
      ClientMessage message = createLargeMessage(session, 2 * minLarge);
      producer.send(message);
   }
   session.commit();

   ClientConsumer consumer = session.createConsumer(DIVERT_ADDRESS);
   for (int i = 0;  i < num; i++) {
      ClientMessage receivedFromSourceQueue = consumer.receive(5000);
      assertNotNull(receivedFromSourceQueue);
      receivedFromSourceQueue.acknowledge();
   }
   session.commit();

   crash(session);

   ClientConsumer consumer1 = session.createConsumer(DIVERT_FORWARD_ADDRESS);
   for (int i = 0; i < num; i++) {
      ClientMessage receivedFromTargetQueue = consumer1.receive(5000);
      assertNotNull(receivedFromTargetQueue);
      receivedFromTargetQueue.acknowledge();
   }
   session.commit();
}
 

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

   Configuration config = createDefaultInVMConfig();

   HashMap<String, AddressSettings> settings = new HashMap<>();

   AddressSettings set = new AddressSettings();
   set.setAddressFullMessagePolicy(AddressFullMessagePolicy.FAIL);

   settings.put(PagingTest.ADDRESS.toString(), set);

   server = createServer(true, config, 1024, 5 * 1024, settings);

   server.start();

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

   sf = createSessionFactory(locator);
   ClientSession session = addClientSession(sf.createSession(true, true, 0));

   session.createQueue(PagingTest.ADDRESS, PagingTest.ADDRESS, null, true);

   ClientProducer producer = session.createProducer(PagingTest.ADDRESS);

   ClientMessage message = session.createMessage(true);

   int biggerMessageSize = 2048;
   byte[] body = new byte[biggerMessageSize];
   ByteBuffer bb = ByteBuffer.wrap(body);
   for (int j = 1; j <= biggerMessageSize; j++) {
      bb.put(getSamplebyte(j));
   }

   message.getBodyBuffer().writeBytes(body);

   // Send enough messages to fill up the address.
   producer.send(message);
   producer.send(message);
   producer.send(message);

   Queue q = (Queue) server.getPostOffice().getBinding(ADDRESS).getBindable();
   Wait.waitFor(() -> 3 == getMessageCount(q));
   Assert.assertEquals(3, getMessageCount(q));

   // send a message with a dup ID that should fail b/c the address is full
   SimpleString dupID1 = new SimpleString("abcdefg");
   message.putBytesProperty(Message.HDR_DUPLICATE_DETECTION_ID, dupID1.getData());
   message.putStringProperty("key", dupID1.toString());

   validateExceptionOnSending(producer, message);

   Assert.assertEquals(3, getMessageCount(q));

   ClientConsumer consumer = session.createConsumer(ADDRESS);

   session.start();

   // Receive a message...this should open space for another message
   ClientMessage msgReceived = consumer.receive(5000);
   assertNotNull(msgReceived);
   msgReceived.acknowledge();
   session.commit(); // to make sure it's on the server (roundtrip)
   consumer.close();

   Assert.assertEquals(2, getMessageCount(q));

   producer.send(message);

   Assert.assertEquals(3, getMessageCount(q));

   consumer = session.createConsumer(ADDRESS);

   for (int i = 0; i < 3; i++) {
      msgReceived = consumer.receive(5000);
      assertNotNull(msgReceived);
      msgReceived.acknowledge();
      session.commit();
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
private ClientMessage receiveMessage() throws Exception {
   final ClientSessionFactory sf = createSessionFactory(locator);
   ClientSession session = sf.createSession(null, null, false, true, true, false, 0);

   session.start();
   ClientConsumer consumer = session.createConsumer(ADDRESS);

   ClientMessage message = consumer.receive(1000);

   session.commit();

   if (message != null) {
      message.acknowledge();
   }

   consumer.close();

   session.close();

   return message;
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
public void testScheduledMessagesDeliveredCorrectly(final boolean recover) throws Exception {

      ClientSessionFactory sessionFactory = createSessionFactory(locator);
      ClientSession session = sessionFactory.createSession(false, true, false);
      session.createQueue(atestq, atestq, null, true);
      ClientProducer producer = session.createProducer(atestq);
      ClientMessage m1 = createDurableMessage(session, "m1");
      ClientMessage m2 = createDurableMessage(session, "m2");
      ClientMessage m3 = createDurableMessage(session, "m3");
      ClientMessage m4 = createDurableMessage(session, "m4");
      ClientMessage m5 = createDurableMessage(session, "m5");
      long time = System.currentTimeMillis();
      time += 10000;
      m1.putLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME, time);
      producer.send(m1);
      time += 1000;
      m2.putLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME, time);
      producer.send(m2);
      time += 1000;
      m3.putLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME, time);
      producer.send(m3);
      time += 1000;
      m4.putLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME, time);
      producer.send(m4);
      time += 1000;
      m5.putLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME, time);
      producer.send(m5);
      time -= 4000;
      if (recover) {
         producer.close();
         session.close();
         server.stop();
         server = null;
         server = createServer(true, configuration);
         server.start();

         sessionFactory = createSessionFactory(locator);

         session = sessionFactory.createSession(false, true, true);
      }

      ClientConsumer consumer = session.createConsumer(atestq);

      session.start();

      ClientMessage message = consumer.receive(11000);
      Assert.assertTrue(System.currentTimeMillis() >= time);
      Assert.assertEquals("m1", message.getBodyBuffer().readString());
      message.acknowledge();
      time += 1000;
      message = consumer.receive(1250);
      Assert.assertTrue(System.currentTimeMillis() >= time);
      Assert.assertEquals("m2", message.getBodyBuffer().readString());
      message.acknowledge();
      time += 1000;
      message = consumer.receive(1250);
      Assert.assertTrue(System.currentTimeMillis() >= time);
      Assert.assertEquals("m3", message.getBodyBuffer().readString());
      message.acknowledge();
      time += 1000;
      message = consumer.receive(1250);
      Assert.assertTrue(System.currentTimeMillis() >= time);
      Assert.assertEquals("m4", message.getBodyBuffer().readString());
      message.acknowledge();
      time += 1000;
      message = consumer.receive(1250);
      Assert.assertTrue(System.currentTimeMillis() >= time);
      Assert.assertEquals("m5", message.getBodyBuffer().readString());
      message.acknowledge();

      // Make sure no more messages
      consumer.close();
      consumer = session.createConsumer(atestq);
      Assert.assertNull(consumer.receiveImmediate());

      session.close();
   }
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
@Test
public void testSendPacketsWithFailure() throws Exception {
   final int nMsg = 100;
   final int stop = 37;
   setupServer(true, TestInterceptor.class.getName());

   manager = liveServer.getReplicationManager();
   waitForComponent(manager);
   ClientSessionFactory sf = createSessionFactory(locator);
   final ClientSession session = sf.createSession();
   final ClientSession session2 = sf.createSession();
   session.createQueue(ADDRESS, ADDRESS, null, true);

   final ClientProducer producer = session.createProducer(ADDRESS);

   session.start();
   session2.start();
   try {
      final ClientConsumer consumer = session2.createConsumer(ADDRESS);
      for (int i = 0; i < nMsg; i++) {

         ClientMessage message = session.createMessage(true);
         setBody(i, message);
         message.putIntProperty("counter", i);
         producer.send(message);
         if (i == stop) {
            // Now we start intercepting the communication with the backup
            TestInterceptor.value.set(false);
         }
         ClientMessage msgRcvd = consumer.receive(1000);
         Assert.assertNotNull("Message should exist!", msgRcvd);
         assertMessageBody(i, msgRcvd);
         Assert.assertEquals(i, msgRcvd.getIntProperty("counter").intValue());
         msgRcvd.acknowledge();
      }
   } finally {
      TestInterceptor.value.set(false);
      if (!session.isClosed())
         session.close();
      if (!session2.isClosed())
         session2.close();
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
@Test
public void testRollbackWithReceive() throws Exception {
   locator.setBlockOnNonDurableSend(true).setBlockOnDurableSend(true);
   cf = createSessionFactory(locator);
   ClientSession sendSession = cf.createSession(false, true, true);
   ClientProducer cp = sendSession.createProducer(queueName);
   ClientSession clientSession = cf.createSession(false, true, false);
   clientSession.createQueue(queueName, queueName, false);
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   Queue q = (Queue) server.getPostOffice().getBinding(new SimpleString(queueName)).getBindable();
   Assert.assertEquals(10, getMessageCount(q));
   ClientConsumer cc = clientSession.createConsumer(queueName);
   clientSession.start();
   ClientMessage m = cc.receive(5000);
   Assert.assertNotNull(m);
   m.acknowledge();
   m = cc.receive(5000);
   Assert.assertNotNull(m);
   m.acknowledge();
   m = cc.receive(5000);
   Assert.assertNotNull(m);
   m.acknowledge();
   m = cc.receive(5000);
   Assert.assertNotNull(m);
   m.acknowledge();
   m = cc.receive(5000);
   Assert.assertNotNull(m);
   m.acknowledge();
   m = cc.receive(5000);
   Assert.assertNotNull(m);
   m.acknowledge();
   m = cc.receive(5000);
   Assert.assertNotNull(m);
   m.acknowledge();
   m = cc.receive(5000);
   Assert.assertNotNull(m);
   m.acknowledge();
   m = cc.receive(5000);
   Assert.assertNotNull(m);
   m.acknowledge();
   m = cc.receive(5000);
   Assert.assertNotNull(m);
   m.acknowledge();
   clientSession.rollback();
   Wait.waitFor(() -> getMessageCount(q) == 10);
   Assert.assertEquals(10, getMessageCount(q));
   clientSession.close();
   sendSession.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
public void doTestStressSend(final boolean netty) throws Exception {
   ActiveMQServer server = createServer(false, netty);
   server.start();
   ServerLocator locator = createNonHALocator(netty);
   ClientSessionFactory sf = createSessionFactory(locator);

   ClientSession session = null;

   final int batchSize = 2000;

   final int numberOfMessages = 100000;

   try {
      server.start();

      session = sf.createSession(false, false);

      session.createQueue("address", RoutingType.MULTICAST, "queue");

      ClientProducer producer = session.createProducer("address");

      ClientMessage message = session.createMessage(false);

      message.getBodyBuffer().writeBytes(new byte[1024]);

      for (int i = 0; i < numberOfMessages; i++) {
         producer.send(message);
         if (i % batchSize == 0) {
            System.out.println("Sent " + i);
            session.commit();
         }
      }

      session.commit();

      session.close();

      session = sf.createSession(false, false);

      ClientConsumer consumer = session.createConsumer("queue");

      session.start();

      for (int i = 0; i < numberOfMessages; i++) {
         ClientMessage msg = consumer.receive(5000);
         Assert.assertNotNull(msg);
         msg.acknowledge();

         if (i % batchSize == 0) {
            System.out.println("Consumed " + i);
            session.commit();
         }
      }

      session.commit();
   } finally {
      if (session != null) {
         try {
            sf.close();
            session.close();
         } catch (Exception e) {
            e.printStackTrace();
         }
      }
      locator.close();
      server.stop();
   }

}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
@Test
public void testACKWithoutXID() throws Exception {
   // Since both resources have same RM, TM will probably use 1PC optimization

   ClientSessionFactory factory = createSessionFactory(locator);

   ClientSession session = addClientSession(factory.createSession(false, true, true));

   session.createQueue("Test", RoutingType.ANYCAST, "Test");

   ClientProducer prod = session.createProducer("Test");

   prod.send(session.createMessage(true));

   session.close();

   session = addClientSession(factory.createSession(true, false, false));

   session.start();

   ClientConsumer cons = session.createConsumer("Test");

   ClientMessage msg = cons.receive(5000);

   assertNotNull(msg);

   msg.acknowledge();

   session.close();

   session = addClientSession(factory.createSession(false, false, false));

   session.start();

   cons = session.createConsumer("Test");

   msg = cons.receiveImmediate();

   assertNull("Acknowledge went through invalid XA Session", msg);
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
@Test
public void testConsumerBrowserMessageAckDoesNothing() throws Exception {
   ClientSessionFactory sf = createSessionFactory(locator);

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

   session.createQueue(QUEUE, QUEUE, null, false);

   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, null, true);

   for (int i = 0; i < numMessages; i++) {
      ClientMessage message2 = consumer.receive(1000);

      message2.acknowledge();

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

   session.close();

}