Java ClientSession.createProducer方法代码示例

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testRollbackWithSend() throws Exception {
   cf = createSessionFactory(locator);
   ClientSession clientSession = cf.createSession(false, false, true);
   clientSession.createQueue(queueName, queueName, false);
   ClientProducer cp = clientSession.createProducer(queueName);
   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(0, getMessageCount(q));
   clientSession.rollback();
   cp.send(clientSession.createMessage(false));
   cp.send(clientSession.createMessage(false));
   clientSession.commit();
   Assert.assertEquals(2, getMessageCount(q));
   clientSession.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testPurgeOnNoConsumersFalse() 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, false, true);
   assertNotNull(server.locateQueue(queueName));
   ClientSession session = sessionFactory.createSession();
   ClientProducer producer = session.createProducer(address);
   producer.send(session.createMessage(true));
   session.createConsumer(queueName).close();
   assertNotNull(server.locateQueue(queueName));
   assertEquals(1, server.locateQueue(queueName).getMessageCount());
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testReceiveImmediate() throws Exception {
   // forces perfect round robin
   locator.setConsumerWindowSize(0);
   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, RoutingType.ANYCAST, queueA, false);
   ClientConsumer cc = session.createConsumer(queueA);
   ClientConsumer cc2 = session.createConsumer(queueA);
   session.start();
   cp.send(sendSession.createMessage(false));
   cp.send(sendSession.createMessage(false));
   cp.send(sendSession.createMessage(false));
   sendSession.commit();

   final Queue queue = server.locateQueue(queueA);

   Wait.waitFor(() -> queue.getMessageCount() == 3, 500, 100);

   Assert.assertNotNull(cc2.receiveImmediate());
   Assert.assertNotNull(cc.receiveImmediate());
   if (cc.receiveImmediate() == null) {
      Assert.assertNotNull(cc2.receiveImmediate());
   }
   session.close();
   sendSession.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
protected void addPooled() throws ActiveMQException {
   ClientSession session = sessionFactory.createSession();
   ClientProducer producer = session.createProducer(destination);
   session.start();
   pool.add(new Pooled(session, producer));
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testStopStartMultipleConsumers() throws Exception {
   locator.setConsumerWindowSize(getMessageEncodeSize(QUEUE) * 33);
   ClientSessionFactory sf = createSessionFactory(locator);

   final 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);
      message.putIntProperty(new SimpleString("i"), i);
      producer.send(message);
   }

   ClientConsumer consumer = session.createConsumer(QUEUE);
   ClientConsumer consumer2 = session.createConsumer(QUEUE);
   ClientConsumer consumer3 = session.createConsumer(QUEUE);

   session.start();

   ClientMessage cm = consumer.receive(5000);
   Assert.assertNotNull(cm);
   cm.acknowledge();
   cm = consumer2.receive(5000);
   Assert.assertNotNull(cm);
   cm.acknowledge();
   cm = consumer3.receive(5000);
   Assert.assertNotNull(cm);
   cm.acknowledge();

   session.stop();
   cm = consumer.receiveImmediate();
   Assert.assertNull(cm);
   cm = consumer2.receiveImmediate();
   Assert.assertNull(cm);
   cm = consumer3.receiveImmediate();
   Assert.assertNull(cm);

   session.start();
   cm = consumer.receive(5000);
   Assert.assertNotNull(cm);
   cm = consumer2.receive(5000);
   Assert.assertNotNull(cm);
   cm = consumer3.receive(5000);
   Assert.assertNotNull(cm);
   session.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testCreateAndDestroyBridge() throws Exception {
   String name = RandomUtil.randomString();
   String sourceAddress = RandomUtil.randomString();
   String sourceQueue = RandomUtil.randomString();
   String targetAddress = RandomUtil.randomString();
   String targetQueue = RandomUtil.randomString();

   ActiveMQServerControl serverControl = createManagementControl();

   checkNoResource(ObjectNameBuilder.DEFAULT.getBridgeObjectName(name));
   assertEquals(0, serverControl.getBridgeNames().length);

   ServerLocator locator = createInVMNonHALocator();
   ClientSessionFactory csf = createSessionFactory(locator);
   ClientSession session = csf.createSession();

   session.createQueue(sourceAddress, RoutingType.ANYCAST, sourceQueue);
   session.createQueue(targetAddress, RoutingType.ANYCAST, targetQueue);

   serverControl.createBridge(name, sourceQueue, targetAddress, null, // forwardingAddress
                              null, // filterString
                              ActiveMQClient.DEFAULT_RETRY_INTERVAL, ActiveMQClient.DEFAULT_RETRY_INTERVAL_MULTIPLIER, ActiveMQClient.INITIAL_CONNECT_ATTEMPTS, ActiveMQClient.DEFAULT_RECONNECT_ATTEMPTS, false, // duplicateDetection
                              1, // confirmationWindowSize
                              -1, // producerWindowSize
                              ActiveMQClient.DEFAULT_CLIENT_FAILURE_CHECK_PERIOD, connectorConfig.getName(), // liveConnector
                              false, false, null, null);

   checkResource(ObjectNameBuilder.DEFAULT.getBridgeObjectName(name));
   String[] bridgeNames = serverControl.getBridgeNames();
   assertEquals(1, bridgeNames.length);
   assertEquals(name, bridgeNames[0]);

   BridgeControl bridgeControl = ManagementControlHelper.createBridgeControl(name, mbeanServer);
   assertEquals(name, bridgeControl.getName());
   assertTrue(bridgeControl.isStarted());

   // check that a message sent to the sourceAddress is put in the tagetQueue
   ClientProducer producer = session.createProducer(sourceAddress);
   ClientMessage message = session.createMessage(false);
   String text = RandomUtil.randomString();
   message.putStringProperty("prop", text);
   producer.send(message);

   session.start();

   ClientConsumer targetConsumer = session.createConsumer(targetQueue);
   message = targetConsumer.receive(5000);
   assertNotNull(message);
   assertEquals(text, message.getStringProperty("prop"));

   ClientConsumer sourceConsumer = session.createConsumer(sourceQueue);
   assertNull(sourceConsumer.receiveImmediate());

   serverControl.destroyBridge(name);

   checkNoResource(ObjectNameBuilder.DEFAULT.getBridgeObjectName(name));
   assertEquals(0, serverControl.getBridgeNames().length);

   // check that a message is no longer diverted
   message = session.createMessage(false);
   String text2 = RandomUtil.randomString();
   message.putStringProperty("prop", text2);
   producer.send(message);

   assertNull(targetConsumer.receiveImmediate());
   message = sourceConsumer.receive(5000);
   assertNotNull(message);
   assertEquals(text2, message.getStringProperty("prop"));

   sourceConsumer.close();
   targetConsumer.close();

   session.deleteQueue(sourceQueue);
   session.deleteQueue(targetQueue);

   session.close();

   locator.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testSendRegularAfterCompression() throws Exception {
   ActiveMQServer server = createServer(true, isNetty());
   server.start();

   ClientSessionFactory sf = createSessionFactory(locator);

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

   session.createTemporaryQueue(ADDRESS, ADDRESS);

   ClientProducer producer = session.createProducer(ADDRESS);

   int minLargeSize = locator.getMinLargeMessageSize();

   TestLargeMessageInputStream input = new TestLargeMessageInputStream(minLargeSize);
   adjustLargeCompression(true, input, 1024);

   int num = 1;
   for (int i = 0; i < num; i++) {
      ClientMessage clientFile = session.createMessage(true);
      clientFile.setBodyInputStream(input.clone());

      producer.send(clientFile);
   }

   session.start();

   //no file should be in the dir as we send it as regular
   validateNoFilesOnLargeDir();

   ClientConsumer consumer = session.createConsumer(ADDRESS);
   for (int j = 0; j < num; j++) {
      ClientMessage msg1 = consumer.receive(1000);
      Assert.assertNotNull(msg1);

      for (int i = 0; i < input.getSize(); i++) {
         byte b = msg1.getBodyBuffer().readByte();
         Assert.assertEquals("incorrect char ", input.getChar(i), b);
      }
      msg1.acknowledge();
   }

   session.commit();
   consumer.close();

   session.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
protected void testDedeliveryMessageOnPersistent(final boolean strictUpdate) throws Exception {
   setUp(strictUpdate);
   ClientSession session = factory.createSession(false, false, false);

   RedeliveryConsumerTest.log.info("created");

   ClientProducer prod = session.createProducer(ADDRESS);
   prod.send(createTextMessage(session, "Hello"));
   session.commit();
   session.close();

   session = factory.createSession(false, false, false);
   session.start();
   ClientConsumer consumer = session.createConsumer(ADDRESS);

   ClientMessage msg = consumer.receive(1000);
   Assert.assertEquals(1, msg.getDeliveryCount());
   session.stop();

   // if strictUpdate == true, this will simulate a crash, where the server is stopped without closing/rolling back
   // the session, but the delivery count still persisted, so the final delivery count is 2 too.
   if (!strictUpdate) {
      // If non Strict, at least rollback/cancel should still update the delivery-counts
      session.rollback(true);

      session.close();
   }

   server.stop();

   // once the server is stopped, we close the session
   // to clean up its client resources
   session.close();

   server.start();

   factory = createSessionFactory(locator);

   session = factory.createSession(false, true, false);
   session.start();
   consumer = session.createConsumer(ADDRESS);
   msg = consumer.receive(1000);
   Assert.assertNotNull(msg);
   Assert.assertEquals(strictUpdate ? 2 : 2, msg.getDeliveryCount());
   session.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testHangOnDelivery() throws Exception {
   queue = server.createQueue(QUEUE, RoutingType.ANYCAST, QUEUE, null, true, false);
   try {

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

      ServerLocator consumerLocator = createInVMNonHALocator();
      ClientSessionFactory factoryConsumer = consumerLocator.createSessionFactory();
      ClientSession sessionConsumer = factoryConsumer.createSession();

      ClientProducer producer = sessionProducer.createProducer(QUEUE);

      ClientConsumer consumer = sessionConsumer.createConsumer(QUEUE);

      producer.send(sessionProducer.createMessage(true));

      blockConsumers();

      sessionProducer.commit();

      sessionConsumer.start();

      awaitBlocking();

      // this shouldn't lock
      producer.send(sessionProducer.createMessage(true));
      sessionProducer.commit();

      // These three operations should finish without the test hanging
      queue.getMessagesAdded();
      queue.getMessageCount();

      releaseConsumers();

      // a rollback to make sure everything will be reset on the deliveries
      // and that both consumers will receive each a message
      // this is to guarantee the server will have both consumers regsitered
      sessionConsumer.rollback();

      // a flush to guarantee any pending task is finished on flushing out delivery and pending msgs
      queue.flushExecutor();
      Wait.waitFor(() -> getMessageCount(queue) == 2);
      Wait.assertEquals(2, queue::getMessageCount);
      Wait.assertEquals(2, queue::getMessagesAdded);

      ClientMessage msg = consumer.receive(5000);
      Assert.assertNotNull(msg);
      msg.acknowledge();

      msg = consumer.receive(5000);
      Assert.assertNotNull(msg);
      msg.acknowledge();

      sessionProducer.commit();
      sessionConsumer.commit();

      sessionProducer.close();
      sessionConsumer.close();
   } finally {
      releaseConsumers();
   }
}
 

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

   ClientSession session = sf.createSession(false, true, true);
   session.createQueue(ClientCrashTest.QUEUE, ClientCrashTest.QUEUE, null, false);

   // spawn a JVM that creates a Core client, which sends a message
   // It has to be spawned after the queue was created.
   // if the client is too fast you race the send before the queue was created, missing a message
   Process p = SpawnedVMSupport.spawnVM(CrashClient.class.getName());

   ClientConsumer consumer = session.createConsumer(ClientCrashTest.QUEUE);
   ClientProducer producer = session.createProducer(ClientCrashTest.QUEUE);

   session.start();

   // receive a message from the queue
   Message messageFromClient = consumer.receive(5000);
   assertNotNull("no message received", messageFromClient);
   assertEquals(ClientCrashTest.MESSAGE_TEXT_FROM_CLIENT, messageFromClient.getBodyBuffer().readString());

   assertActiveConnections(1 + 1); // One local and one from the other vm
   assertActiveSession(1 + 1);

   ClientMessage message = session.createMessage(ActiveMQTextMessage.TYPE, false, 0, System.currentTimeMillis(), (byte) 1);
   message.getBodyBuffer().writeString(ClientCrashTest.MESSAGE_TEXT_FROM_SERVER);
   producer.send(message);

   ClientCrashTest.log.debug("waiting for the client VM to crash ...");
   p.waitFor();

   assertEquals(9, p.exitValue());

   System.out.println("VM Exited");

   long timeout = ClientCrashTest.CONNECTION_TTL + ClientCrashTest.PING_PERIOD + 10000;

   assertActiveConnections(1, timeout);
   assertActiveSession(1, timeout);

   session.close();

   // the crash must have been detected and the resources cleaned up
   assertActiveConnections(1);
   assertActiveSession(0);
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testReceiveImmediateWithZeroWindow2() throws Exception {
   ActiveMQServer server = createServer(true);
   try (ServerLocator locator = createInVMNonHALocator()) {
      server.start();

      locator.setConsumerWindowSize(0);

      ClientSessionFactory sf = createSessionFactory(locator);
      ClientSession session = sf.createSession(false, false, false);
      session.createQueue("testReceive", "testReceive", true);
      session.close();

      ClientSession sessionProd = sf.createSession(false, false);
      ClientMessage msg = sessionProd.createMessage(true);
      msg.putStringProperty("hello", "world");
      ClientProducer prod = sessionProd.createProducer("testReceive");

      prod.send(msg);
      sessionProd.commit();

      ClientSession session1 = sf.createSession();
      ClientConsumer consumer = session1.createConsumer("testReceive");
      session1.start();

      Thread.sleep(1000);
      ClientMessage message = null;
      message = consumer.receiveImmediate();
      // message = consumer.receive(1000); // the test will pass if used receive(1000) instead of receiveImmediate
      Assert.assertNotNull(message);
      message.acknowledge();

      prod.send(msg);
      sessionProd.commit();

      message = consumer.receive(10000);
      Assert.assertNotNull(message);
      message.acknowledge();

      session.close();
      session1.close();
      sessionProd.close();
   }
}
 

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

      // then we create a client as normal
      ClientSessionFactory sessionFactory = createSessionFactory(locator);
      ClientSession session = sessionFactory.createSession(false, true, false);
      session.createQueue(atestq, atestq, null, true);
      ClientProducer producer = session.createProducer(atestq);
      ClientMessage message = session.createMessage(ActiveMQTextMessage.TYPE, false, 0, System.currentTimeMillis(), (byte) 1);
      message.getBodyBuffer().writeString("testINVMCoreClient");
      message.setDurable(true);
      long time = System.currentTimeMillis();
      time += 10000;
      message.putLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME, time);
      producer.send(message);

      ScheduledMessageTest.log.info("Recover is " + recover);
      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 message2 = consumer.receive(11000);
      Assert.assertTrue(System.currentTimeMillis() >= time);
      Assert.assertEquals("testINVMCoreClient", message2.getBodyBuffer().readString());

      message2.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.ClientSession; //导入方法依赖的package包/类
@Test
public void testHugeStreamingSpacesCompressed() throws Exception {
   final long messageSize = 1024L * 1024L;

   System.out.println("Message size = " + messageSize);

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

   server.start();

   // big enough to hold the whole message compressed on a single message (about 1M on our tests)
   locator.setMinLargeMessageSize(100 * 1024 * 1024);

   ClientSessionFactory sf = createSessionFactory(locator);

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

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

   ClientProducer producer = session.createProducer(ADDRESS);

   ClientMessage clientMessage = session.createMessage(true);

   clientMessage.setBodyInputStream(new InputStream() {
      private long count;

      private boolean closed = false;

      @Override
      public void close() throws IOException {
         super.close();
         closed = true;
      }

      @Override
      public int read() throws IOException {
         if (closed) {
            throw new IOException("Stream was closed");
         }

         if (count++ < messageSize) {
            return ' ';
         } else {
            return -1;
         }
      }
   });

   producer.send(clientMessage);

   session.commit();

   // this is to make sure the message was sent as a regular message (not taking a file on server)
   validateNoFilesOnLargeDir();

   session.start();

   ClientConsumer consumer = session.createConsumer(ADDRESS);
   ClientMessage msg1 = consumer.receive(1000);
   Assert.assertNotNull(msg1);

   final AtomicLong numberOfSpaces = new AtomicLong();

   msg1.saveToOutputStream(new OutputStream() {
      @Override
      public void write(int content) {
         if (content == ' ') {
            numberOfSpaces.incrementAndGet();
         }
      }
   });

   assertEquals(messageSize, numberOfSpaces.get());

   msg1.acknowledge();

   session.commit();

   session.close();
}
 

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

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

   session.createQueue(FailoverTestBase.ADDRESS, RoutingType.MULTICAST, FailoverTestBase.ADDRESS, null, true);

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

   sendMessagesSomeDurable(session, producer);

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

   session.start();

   // Receive MSGs but don't ack!
   for (int i = 0; i < NUM_MESSAGES; i++) {
      ClientMessage message = consumer.receive(1000);

      Assert.assertNotNull(message);

      assertMessageBody(i, message);

      Assert.assertEquals(i, message.getIntProperty("counter").intValue());
   }

   crash(session);

   // Should get the same ones after failover since we didn't ack

   receiveDurableMessages(consumer);
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
protected void doTestN(final ClientSessionFactory sf, final int threadNum) throws Exception {
   ClientSession sessCreate = sf.createSession(false, true, true);

   sessCreate.createQueue(MultiThreadRandomReattachTestBase.ADDRESS, new SimpleString(threadNum + MultiThreadRandomReattachTestBase.ADDRESS.toString()), (SimpleString) null, false);

   ClientSession sess = sf.createSession(false, true, true);
   sess.addMetaData("data", RandomUtil.randomString());

   sess.stop();

   sess.start();

   sess.stop();

   ClientConsumer consumer = sess.createConsumer(new SimpleString(threadNum + MultiThreadRandomReattachTestBase.ADDRESS.toString()));

   ClientProducer producer = sess.createProducer(MultiThreadRandomReattachTestBase.ADDRESS);

   ClientMessage message = sess.createMessage(ActiveMQTextMessage.TYPE, false, 0, System.currentTimeMillis(), (byte) 1);
   producer.send(message);

   sess.start();

   ClientMessage message2 = consumer.receive(MultiThreadRandomReattachTestBase.RECEIVE_TIMEOUT);

   Assert.assertNotNull(message2);

   message2.acknowledge();

   sess.stop();

   sess.start();

   sess.close();

   sessCreate.deleteQueue(new SimpleString(threadNum + MultiThreadRandomReattachTestBase.ADDRESS.toString()));

   sessCreate.close();
}