Java ClientProducer.send方法代码示例

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

   session.createQueue(address, queue, null, false);

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

   ClientProducer producer = session.createProducer(address);
   producer.send(session.createMessage(false));
   Assert.assertEquals(1, getMessageCount(queueControl));

   consumeMessages(1, session, queue);

   Assert.assertEquals(0, getMessageCount(queueControl));

   session.deleteQueue(queue);
}
 

import org.apache.activemq.artemis.api.core.client.ClientProducer; //导入方法依赖的package包/类
private void checkUserReceiveNoSend(final String queue,
                                    final ClientSession connection,
                                    final ClientSession sendingConn) throws Exception {
   connection.start();
   try {
      ClientProducer prod = connection.createProducer(queue);
      ClientMessage m = connection.createMessage(false);
      try {
         prod.send(m);
         Assert.fail("should throw exception");
      } catch (ActiveMQException e) {
         // pass
      }

      prod = sendingConn.createProducer(queue);
      prod.send(m);
      ClientConsumer con = connection.createConsumer(queue);
      ClientMessage rec = con.receive(1000);
      Assert.assertNotNull(rec);
      rec.acknowledge();
   } finally {
      connection.stop();
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientProducer; //导入方法依赖的package包/类
@Test
public void testSendToDLAWhenNoRoute() throws Exception {
   SimpleString dla = new SimpleString("DLA");
   SimpleString address = new SimpleString("empty_address");
   AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(dla).setSendToDLAOnNoRoute(true);
   server.getAddressSettingsRepository().addMatch(address.toString(), addressSettings);
   SimpleString dlq = new SimpleString("DLQ1");
   clientSession.createQueue(dla, dlq, null, false);
   ClientProducer producer = clientSession.createProducer(address);
   producer.send(createTextMessage(clientSession, "heyho!"));
   clientSession.start();
   ClientConsumer clientConsumer = clientSession.createConsumer(dlq);
   ClientMessage m = clientConsumer.receive(500);
   m.acknowledge();
   Assert.assertNotNull(m);
   Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
}
 

import org.apache.activemq.artemis.api.core.client.ClientProducer; //导入方法依赖的package包/类
@Test
public void testSendWithCommit() throws Exception {
   ActiveMQServer server = createServer(false);
   server.start();
   ClientSessionFactory cf = createSessionFactory(locator);
   ClientSession session = cf.createSession(false, false, false);
   session.createQueue(addressA, queueA, false);
   ClientProducer cp = session.createProducer(addressA);
   int numMessages = 100;
   for (int i = 0; i < numMessages; i++) {
      cp.send(session.createMessage(false));
   }
   Queue q = (Queue) server.getPostOffice().getBinding(queueA).getBindable();
   Assert.assertEquals(0, getMessageCount(q));
   session.commit();
   Assert.assertEquals(getMessageCount(q), numMessages);
   // now send some more
   for (int i = 0; i < numMessages; i++) {
      cp.send(session.createMessage(false));
   }
   Assert.assertEquals(numMessages, getMessageCount(q));
   session.commit();
   Assert.assertEquals(numMessages * 2, getMessageCount(q));
   session.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientProducer; //导入方法依赖的package包/类
@Test
public void testReceiveWithListeners() throws Exception {
   SimpleString dla = new SimpleString("DLA");
   SimpleString qName = new SimpleString("q1");
   AddressSettings addressSettings = new AddressSettings().setMaxDeliveryAttempts(2).setDeadLetterAddress(dla);
   server.getAddressSettingsRepository().addMatch(qName.toString(), addressSettings);
   SimpleString dlq = new SimpleString("DLQ1");
   clientSession.createQueue(dla, dlq, null, false);
   clientSession.createQueue(qName, qName, null, false);
   ClientProducer producer = clientSession.createProducer(qName);
   producer.send(createTextMessage(clientSession, "heyho!"));
   ClientConsumer clientConsumer = clientSession.createConsumer(qName);
   final CountDownLatch latch = new CountDownLatch(2);
   TestHandler handler = new TestHandler(latch, clientSession);
   clientConsumer.setMessageHandler(handler);
   clientSession.start();
   assertTrue(latch.await(5, TimeUnit.SECONDS));
   assertEquals(handler.count, 2);
   clientConsumer = clientSession.createConsumer(dlq);
   Message m = clientConsumer.receive(5000);
   Assert.assertNotNull(m);
   Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
}
 

import org.apache.activemq.artemis.api.core.client.ClientProducer; //导入方法依赖的package包/类
@Test
public void testNonDurableMessageOnDurableQueue() throws Exception {
   boolean durable = true;

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

   session.createQueue(address, queue, durable);

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

   restart();

   session.start();
   ClientConsumer consumer = session.createConsumer(queue);
   Assert.assertNull(consumer.receiveImmediate());

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

import org.apache.activemq.artemis.api.core.client.ClientProducer; //导入方法依赖的package包/类
@Test
public void testNonDurableMessageOnNonDurableQueue() throws Exception {
   boolean durable = true;

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

   session.createQueue(address, queue, !durable);

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

   restart();

   session.start();
   try {
      session.createConsumer(queue);
   } catch (ActiveMQNonExistentQueueException neqe) {
      //ok
   } catch (ActiveMQException e) {
      fail("Invalid Exception type:" + e.getType());
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientProducer; //导入方法依赖的package包/类
private void doTestBasicGroupingMultipleProducers() throws Exception {
   ClientProducer clientProducer = clientSession.createProducer(qName);
   ClientProducer clientProducer2 = clientSession.createProducer(qName);
   ClientProducer clientProducer3 = clientSession.createProducer(qName);
   ClientConsumer consumer = clientSession.createConsumer(qName);
   ClientConsumer consumer2 = clientSession.createConsumer(qName);
   clientSession.start();

   int numMessages = 100;
   for (int i = 0; i < numMessages; i++) {
      ClientMessage message = createTextMessage(clientSession, "m" + i);
      clientProducer.send(message);
      clientProducer2.send(message);
      clientProducer3.send(message);
   }
   CountDownLatch latch = new CountDownLatch(numMessages * 3);
   DummyMessageHandler dummyMessageHandler = new DummyMessageHandler(latch, true);
   consumer.setMessageHandler(dummyMessageHandler);
   DummyMessageHandler dummyMessageHandler2 = new DummyMessageHandler(latch, true);
   consumer2.setMessageHandler(dummyMessageHandler2);
   Assert.assertTrue(latch.await(10, TimeUnit.SECONDS));
   Assert.assertEquals(300, dummyMessageHandler.list.size());
   Assert.assertEquals(0, dummyMessageHandler2.list.size());
   consumer.close();
   consumer2.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientProducer; //导入方法依赖的package包/类
@Test
public void testBasicReceive() throws Exception {
   ClientSessionFactory cf = createSessionFactory(locator);
   ClientSession sendSession = cf.createSession(false, true, true);
   ClientProducer cp = sendSession.createProducer(addressA);
   ClientSession session = cf.createSession(false, true, true);
   session.createQueue(addressA, queueA, false);
   ClientConsumer cc = session.createConsumer(queueA);
   session.start();
   cp.send(sendSession.createMessage(false));
   Assert.assertNotNull(cc.receive());
   session.close();
   sendSession.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientProducer; //导入方法依赖的package包/类
@Test
public void testOneWaySSLWithGoodServerProtocol() throws Exception {
   createCustomSslServer(null, "TLSv1");
   String text = RandomUtil.randomString();

   tc.getParams().put(TransportConstants.SSL_ENABLED_PROP_NAME, true);
   tc.getParams().put(TransportConstants.TRUSTSTORE_PROVIDER_PROP_NAME, storeType);
   tc.getParams().put(TransportConstants.TRUSTSTORE_PATH_PROP_NAME, CLIENT_SIDE_TRUSTSTORE);
   tc.getParams().put(TransportConstants.TRUSTSTORE_PASSWORD_PROP_NAME, PASSWORD);

   ServerLocator locator = addServerLocator(ActiveMQClient.createServerLocatorWithoutHA(tc));
   ClientSessionFactory sf = null;
   try {
      sf = createSessionFactory(locator);
      Assert.assertTrue(true);
   } catch (ActiveMQNotConnectedException e) {
      Assert.fail();
   }

   ClientSession session = sf.createSession(false, true, true);
   session.createQueue(CoreClientOverOneWaySSLTest.QUEUE, CoreClientOverOneWaySSLTest.QUEUE, false);
   ClientProducer producer = session.createProducer(CoreClientOverOneWaySSLTest.QUEUE);

   ClientMessage message = createTextMessage(session, text);
   producer.send(message);

   ClientConsumer consumer = session.createConsumer(CoreClientOverOneWaySSLTest.QUEUE);
   session.start();

   Message m = consumer.receive(1000);
   Assert.assertNotNull(m);
   Assert.assertEquals(text, m.getBodyBuffer().readString());
}
 

import org.apache.activemq.artemis.api.core.client.ClientProducer; //导入方法依赖的package包/类
@Test
public void testBasicWildcardRouting() throws Exception {
   SimpleString addressAB = new SimpleString("a/b");
   SimpleString addressAC = new SimpleString("a/c");
   SimpleString address = new SimpleString("a/*");
   SimpleString queueName1 = new SimpleString("Q1");
   SimpleString queueName2 = new SimpleString("Q2");
   SimpleString queueName = new SimpleString("Q");
   clientSession.createQueue(addressAB, queueName1, null, false);
   clientSession.createQueue(addressAC, queueName2, null, false);
   clientSession.createQueue(address, queueName, 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);
}
 

import org.apache.activemq.artemis.api.core.client.ClientProducer; //导入方法依赖的package包/类
@Test
public void testPurgeOnNoConsumersTrue() throws Exception {
   SimpleString address = new SimpleString("test.address");
   SimpleString queueName = SimpleString.toSimpleString(UUID.randomUUID().toString());
   server.createQueue(address, RoutingType.ANYCAST, queueName, null, null, true, false, false, false, false, 1, true, true);
   Queue queue = server.locateQueue(queueName);
   assertNotNull(queue);
   ClientSession session = sessionFactory.createSession();
   ClientProducer producer = session.createProducer(address);

   // there are no consumers so no messages should be routed to the queue
   producer.send(session.createMessage(true));
   assertEquals(0, queue.getMessageCount());

   ClientConsumer consumer = session.createConsumer(queueName);
   // there is a consumer now so the message should be routed
   producer.send(session.createMessage(true));
   Wait.assertEquals(1, queue::getMessageCount);


   consumer.close();
   // the last consumer was closed so the queue should exist but be purged
   assertNotNull(server.locateQueue(queueName));
   assertEquals(0, queue.getMessageCount());

   // there are no consumers so no messages should be routed to the queue
   producer.send(session.createMessage(true));
   assertEquals(0, queue.getMessageCount());
}
 

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

   session.createQueue(address, queue, true);

   session.close();

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

   sf = createSessionFactory(locator);

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

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

   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.ClientProducer; //导入方法依赖的package包/类
private long scaleDownSNF(final SimpleString address,
                          final Set<Queue> queues,
                          final ClientProducer producer) throws Exception {
   long messageCount = 0;

   final String propertyEnd;

   // If this SNF is towards our targetNodeId
   boolean queueOnTarget = address.toString().endsWith(targetNodeId);

   if (queueOnTarget) {
      propertyEnd = targetNodeId;
   } else {
      propertyEnd = address.toString().substring(address.toString().lastIndexOf("."));
   }

   Transaction tx = new TransactionImpl(storageManager);

   for (Queue queue : queues) {
      // using auto-closeable
      try (LinkedListIterator<MessageReference> messagesIterator = queue.browserIterator()) {
         // loop through every message of this queue
         while (messagesIterator.hasNext()) {
            MessageReference messageRef = messagesIterator.next();
            Message message = messageRef.getMessage().copy();

            /* Here we are taking messages out of a store-and-forward queue and sending them to the corresponding
             * address on the scale-down target server.  However, we have to take the existing _AMQ_ROUTE_TOsf.*
             * property and put its value into the _AMQ_ROUTE_TO property so the message is routed properly.
             */

            byte[] oldRouteToIDs = null;

            List<SimpleString> propertiesToRemove = new ArrayList<>();
            message.removeProperty(Message.HDR_ROUTE_TO_IDS.toString());
            for (SimpleString propName : message.getPropertyNames()) {
               if (propName.startsWith(Message.HDR_ROUTE_TO_IDS)) {
                  if (propName.toString().endsWith(propertyEnd)) {
                     oldRouteToIDs = message.getBytesProperty(propName.toString());
                  }
                  propertiesToRemove.add(propName);
               }
            }

            // TODO: what if oldRouteToIDs == null ??

            for (SimpleString propertyToRemove : propertiesToRemove) {
               message.removeProperty(propertyToRemove.toString());
            }

            if (queueOnTarget) {
               message.putBytesProperty(Message.HDR_ROUTE_TO_IDS.toString(), oldRouteToIDs);
            } else {
               message.putBytesProperty(Message.HDR_SCALEDOWN_TO_IDS.toString(), oldRouteToIDs);
            }

            logger.debug("Scaling down message " + message + " from " + address + " to " + message.getAddress() + " on node " + targetNodeId);

            producer.send(message.getAddress(), message);

            messageCount++;

            messagesIterator.remove();

            ackMessageOnQueue(tx, queue, messageRef);
         }
      } catch (NoSuchElementException ignored) {
         // this could happen through paging browsing
      }
   }

   tx.commit();

   return messageCount;
}
 

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

   session1.createQueue(address, queue, null, true);

   QueueControl queueControl = createManagementControl(address, queue);

   int num = 1000;

   SimpleString key = new SimpleString("key");
   long matchingValue = RandomUtil.randomLong();
   long unmatchingValue = matchingValue + 1;
   String filter = key + " =" + matchingValue;

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

   ClientProducer producer = session1.createProducer(address);
   for (int i = 0; i < num; i++) {
      ClientMessage message = session1.createMessage(true);
      if (i % 2 == 0) {
         message.putLongProperty(key, matchingValue);
      } else {
         message.putLongProperty(key, unmatchingValue);
      }
      producer.send(message);
   }

   String jsonString = queueControl.listMessagesAsJSON(filter);
   Assert.assertNotNull(jsonString);
   JsonArray array = JsonUtil.readJsonArray(jsonString);
   Assert.assertEquals(num / 2, array.size());

   long l = Long.parseLong(array.getJsonObject(0).get("key").toString().replaceAll("\"", ""));
   Assert.assertEquals(matchingValue, l);

   long n = queueControl.countMessages(filter);
   assertEquals(num / 2, n);

   //drain out messages
   ReceiverThread receiver = new ReceiverThread(queue, num, 1);
   receiver.start();
   receiver.join();
}