Java ClientSession.start方法代码示例

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
private static ClientSession startSession(
        ClientSessionFactory csf,
        FunctionE<ClientSessionFactory, ClientSession> createSession)
            throws ActiveMQException {
    boolean created = false;
    try {
        ClientSession session = createSession.apply(csf);
        session.start();
        created = true;

        return session;
    } finally {
        if (!created) {    // (1)
            csf.close();
        }
    }
}
 

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

   ServerLocator locator = createInVMNonHALocator();
   ClientSessionFactory cf = createSessionFactory(locator);
   ClientSession sendSession = cf.createSession(false, true, true);
   ClientSession session = cf.createSession(false, false, false);
   sendSession.createQueue(addressA, queueA, false);
   ClientProducer cp = sendSession.createProducer(addressA);
   ClientConsumer cc = session.createConsumer(queueA);
   int numMessages = 100;
   for (int i = 0; i < numMessages; i++) {
      cp.send(sendSession.createMessage(false));
   }
   session.start();
   for (int i = 0; i < numMessages; i++) {
      ClientMessage cm = cc.receive(5000);
      Assert.assertNotNull(cm);
      cm.acknowledge();
   }
   Queue q = (Queue) server.getPostOffice().getBinding(queueA).getBindable();
   Assert.assertEquals(numMessages, q.getDeliveringCount());
   session.commit();
   Assert.assertEquals(0, q.getDeliveringCount());
   session.close();
   sendSession.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testConsumerAckImmediateAckIgnored() 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();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testAsyncConsumerAckLastMessageOnly() throws Exception {
   ActiveMQServer server = createServer(false);
   server.start();
   ServerLocator locator = createInVMNonHALocator().setBlockOnAcknowledge(true).setAckBatchSize(0);
   ClientSessionFactory cf = createSessionFactory(locator);
   ClientSession sendSession = cf.createSession(false, true, true);
   final ClientSession session = cf.createSession(false, true, true);
   sendSession.createQueue(addressA, queueA, false);
   ClientProducer cp = sendSession.createProducer(addressA);
   ClientConsumer cc = session.createConsumer(queueA);
   int numMessages = 100;
   for (int i = 0; i < numMessages; i++) {
      cp.send(sendSession.createMessage(false));
   }
   final CountDownLatch latch = new CountDownLatch(numMessages);
   session.start();
   cc.setMessageHandler(new MessageHandler() {
      @Override
      public void onMessage(final ClientMessage message) {
         if (latch.getCount() == 1) {
            try {
               message.acknowledge();
            } catch (ActiveMQException e) {
               try {
                  session.close();
               } catch (ActiveMQException e1) {
                  e1.printStackTrace();
               }
            }
         }
         latch.countDown();
      }
   });
   Assert.assertTrue(latch.await(5, TimeUnit.SECONDS));
   Queue q = (Queue) server.getPostOffice().getBinding(queueA).getBindable();
   Assert.assertEquals(0, q.getDeliveringCount());
   sendSession.close();
   session.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testCONSUMER_CLOSED() throws Exception {
   ClientSessionFactory sf = createSessionFactory(locator);
   ClientSession mySession = sf.createSession("myUser", "myPassword", false, true, true, locator.isPreAcknowledge(), locator.getAckBatchSize());

   mySession.start();

   SimpleString queue = RandomUtil.randomSimpleString();
   SimpleString address = RandomUtil.randomSimpleString();
   boolean durable = RandomUtil.randomBoolean();

   mySession.createQueue(address, queue, durable);
   ClientConsumer consumer = mySession.createConsumer(queue);
   SimpleString sessionName = SimpleString.toSimpleString(((ClientSessionInternal) mySession).getName());

   NotificationTest.flush(notifConsumer);

   consumer.close();

   ClientMessage[] notifications = NotificationTest.consumeMessages(1, notifConsumer);
   Assert.assertEquals(CONSUMER_CLOSED.toString(), notifications[0].getObjectProperty(ManagementHelper.HDR_NOTIFICATION_TYPE).toString());
   Assert.assertEquals(queue.toString(), notifications[0].getObjectProperty(ManagementHelper.HDR_ROUTING_NAME).toString());
   Assert.assertEquals(address.toString(), notifications[0].getObjectProperty(ManagementHelper.HDR_ADDRESS).toString());
   Assert.assertEquals(0, notifications[0].getObjectProperty(ManagementHelper.HDR_CONSUMER_COUNT));
   Assert.assertEquals(SimpleString.toSimpleString("myUser"), notifications[0].getSimpleStringProperty(ManagementHelper.HDR_USER));
   Assert.assertEquals(SimpleString.toSimpleString("invm:0"), notifications[0].getSimpleStringProperty(ManagementHelper.HDR_REMOTE_ADDRESS));
   Assert.assertEquals(sessionName, notifications[0].getSimpleStringProperty(ManagementHelper.HDR_SESSION_NAME));

   session.deleteQueue(queue);
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
/**
 * LargeMessages are passed from the client to the server in chunks. Here we test the backup
 * starting the data synchronization with the live in the middle of a multiple chunks large
 * message upload from the client to the live server.
 *
 * @throws Exception
 */
@Test
public void testBackupStartsWhenLiveIsReceivingLargeMessage() throws Exception {
   final ClientSession session = addClientSession(sessionFactory.createSession(true, true));
   session.createQueue(FailoverTestBase.ADDRESS, FailoverTestBase.ADDRESS, null, true);
   final ClientProducer producer = session.createProducer(FailoverTestBase.ADDRESS);
   final ClientMessage message = session.createMessage(true);
   final int largeMessageSize = 1000 * MIN_LARGE_MESSAGE;
   message.setBodyInputStream(ActiveMQTestBase.createFakeLargeStream(largeMessageSize));

   final AtomicBoolean caughtException = new AtomicBoolean(false);
   final CountDownLatch latch = new CountDownLatch(1);
   final CountDownLatch latch2 = new CountDownLatch(1);

   Runnable r = new Runnable() {
      @Override
      public void run() {
         try {
            latch.countDown();
            producer.send(message);
            sendMessages(session, producer, 20);
            session.commit();
         } catch (ActiveMQException e) {
            e.printStackTrace();
            caughtException.set(true);
         } finally {
            latch2.countDown();
         }
      }
   };
   Executors.defaultThreadFactory().newThread(r).start();
   waitForLatch(latch);
   startBackupFinishSyncing();
   ActiveMQTestBase.waitForLatch(latch2);
   crash(session);
   assertFalse("no exceptions while sending message", caughtException.get());

   session.start();
   ClientConsumer consumer = session.createConsumer(FailoverTestBase.ADDRESS);
   ClientMessage msg = consumer.receive(2000);
   ActiveMQBuffer buffer = msg.getBodyBuffer();

   for (int j = 0; j < largeMessageSize; j++) {
      Assert.assertTrue("large msg , expecting " + largeMessageSize + " bytes, got " + j, buffer.readable());
      Assert.assertEquals("equal at " + j, ActiveMQTestBase.getSamplebyte(j), buffer.readByte());
   }
   receiveMessages(consumer, 0, 20, true);
   assertNull("there should be no more messages!", consumer.receiveImmediate());
   consumer.close();
   session.commit();
}
 

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包/类
private void doForgetHeuristicCompletedTxAndRestart(final boolean heuristicCommit) throws Exception {
   Configuration configuration = createDefaultInVMConfig().setJMXManagementEnabled(true);

   ActiveMQServer server = createServer(true, 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().writeBytes(new byte[123]);

   producer.send(msg);

   session.end(xid, XAResource.TMSUCCESS);

   session.prepare(xid);

   ActiveMQServerControl jmxServer = ManagementControlHelper.createActiveMQServerControl(mbeanServer);

   String[] preparedTransactions = jmxServer.listPreparedTransactions();

   Assert.assertEquals(1, preparedTransactions.length);
   System.out.println(preparedTransactions[0]);

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

   preparedTransactions = jmxServer.listPreparedTransactions();
   Assert.assertEquals(0, preparedTransactions.length);

   session.forget(xid);

   session.close();

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

   server.stop();

   server.start();
   // we need to recreate the sf
   sf = createSessionFactory(locator);
   session = sf.createSession(true, false, false);
   Xid[] recoveredXids = session.recover(XAResource.TMSTARTRSCAN);
   Assert.assertEquals(0, recoveredXids.length);
   jmxServer = ManagementControlHelper.createActiveMQServerControl(mbeanServer);
   if (heuristicCommit) {
      Assert.assertEquals(0, jmxServer.listHeuristicCommittedTransactions().length);
   } else {
      Assert.assertEquals(0, jmxServer.listHeuristicRolledBackTransactions().length);
   }

   session.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testInterceptUsernameOnConsumer() throws Exception {
   ActiveMQJAASSecurityManager securityManager = (ActiveMQJAASSecurityManager) server.getSecurityManager();
   securityManager.getConfiguration().addUser("dumb", "dumber");
   securityManager.getConfiguration().addUser("an", "other");

   server.getRemotingService().addIncomingInterceptor(new InterceptUserOnCreateConsumer());

   locator.setBlockOnDurableSend(true);
   ClientSessionFactory sf = createSessionFactory(locator);

   ClientSession session = sf.createSession("dumb", "dumber", false, false, false, false, 0);

   ClientSession sessionAnotherUser = sf.createSession("an", "other", false, false, false, false, 0);

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

   ClientProducer prod = session.createProducer(QUEUE);

   ClientProducer prodAnother = sessionAnotherUser.createProducer(QUEUE);

   ClientMessage msg = session.createMessage(true);
   prod.send(msg);
   session.commit();

   prodAnother.send(msg);
   sessionAnotherUser.commit();

   ClientConsumer consumer = session.createConsumer(QUEUE);
   ClientConsumer consumerAnother = sessionAnotherUser.createConsumer(QUEUE);

   session.start();
   sessionAnotherUser.start();

   msg = consumer.receive(1000);
   assertNotNull(msg);
   assertEquals("dumb", msg.getStringProperty("userName"));
   msg.acknowledge();
   assertNull(consumer.receiveImmediate());

   msg = consumerAnother.receive(1000);
   assertNotNull(msg);
   assertEquals("an", msg.getStringProperty("userName"));
   msg.acknowledge();
   assertNull(consumerAnother.receiveImmediate());

   session.close();
   sessionAnotherUser.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的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.ClientSession; //导入方法依赖的package包/类
private void doConsumerReceiveImmediateWithNoMessages(final boolean browser) throws Exception {
   locator.setBlockOnNonDurableSend(true).setBlockOnAcknowledge(true).setAckBatchSize(0);

   sf = createSessionFactory(locator);

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

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

   ClientConsumer consumer = session.createConsumer(QUEUE, null, browser);
   session.start();

   ClientMessage message = consumer.receiveImmediate();
   Assert.assertNull(message);

   session.close();
}
 

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

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

   ClientProducer producer = addClientProducer(session.createProducer(QUEUE));

   final int numMessages = 5;

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

   assertPaging();

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

   Thread.sleep(3000);

   for (int i = 0; i < numMessages; i++) {
      assertNotNull(consumer.receive(500));
   }
}
 

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

   ClientSessionFactory sf = createSessionFactory(locator);

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

   AddressSettings addressSettings = new AddressSettings();
   addressSettings.setSlowConsumerCheckPeriod(2);
   addressSettings.setSlowConsumerThreshold(10);
   addressSettings.setSlowConsumerPolicy(SlowConsumerPolicy.NOTIFY);
   if (!isPaging) {
      addressSettings.setAddressFullMessagePolicy(AddressFullMessagePolicy.BLOCK);
      addressSettings.setMaxSizeBytes(-1);
   }

   server.getAddressSettingsRepository().removeMatch(QUEUE.toString());
   server.getAddressSettingsRepository().addMatch(QUEUE.toString(), addressSettings);

   assertPaging();

   ClientProducer producer = addClientProducer(session.createProducer(QUEUE));

   final int numMessages = 25;

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

   SimpleString notifQueue = RandomUtil.randomSimpleString();

   session.createQueue(ActiveMQDefaultConfiguration.getDefaultManagementNotificationAddress(), notifQueue, null, false);

   ClientConsumer notifConsumer = session.createConsumer(notifQueue.toString(), ManagementHelper.HDR_NOTIFICATION_TYPE + "='" + CoreNotificationType.CONSUMER_SLOW + "'");

   final CountDownLatch notifLatch = new CountDownLatch(1);

   notifConsumer.setMessageHandler(new MessageHandler() {
      @Override
      public void onMessage(ClientMessage message) {
         assertEquals(CoreNotificationType.CONSUMER_SLOW.toString(), message.getObjectProperty(ManagementHelper.HDR_NOTIFICATION_TYPE).toString());
         assertEquals(QUEUE.toString(), message.getObjectProperty(ManagementHelper.HDR_ADDRESS).toString());
         assertEquals(Integer.valueOf(1), message.getIntProperty(ManagementHelper.HDR_CONSUMER_COUNT));
         if (isNetty) {
            assertTrue(message.getSimpleStringProperty(ManagementHelper.HDR_REMOTE_ADDRESS).toString().startsWith("/127.0.0.1"));
         } else {
            assertEquals(SimpleString.toSimpleString("invm:0"), message.getSimpleStringProperty(ManagementHelper.HDR_REMOTE_ADDRESS));
         }
         assertNotNull(message.getSimpleStringProperty(ManagementHelper.HDR_CONNECTION_NAME));
         assertNotNull(message.getSimpleStringProperty(ManagementHelper.HDR_CONSUMER_NAME));
         assertNotNull(message.getSimpleStringProperty(ManagementHelper.HDR_SESSION_NAME));
         try {
            message.acknowledge();
         } catch (ActiveMQException e) {
            e.printStackTrace();
         }
         notifLatch.countDown();
      }
   });

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

   assertTrue(notifLatch.await(15, TimeUnit.SECONDS));
}
 

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

   ServerLocator locator = null;

   server.getConfiguration().setJournalSyncNonTransactional(false);
   server.getConfiguration().setJournalBufferTimeout_AIO(15000);

   server.start();

   System.out.println("sync = " + server.getConfiguration().isJournalSyncNonTransactional());
   locator = createInVMNonHALocator().setBlockOnDurableSend(true);
   factory = createSessionFactory(locator);

   session = factory.createSession();

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

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

   ClientMessage message = session.createMessage(true);

   prod.send(message);

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

   session.start();

   ClientMessage msg = consumer.receive(5000);

   Assert.assertNotNull(msg);

   msg.acknowledge();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test(timeout = 120000)
public void testNonTransacted() 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);

   crash(session);

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

   session.start();

   receiveDurableMessages(consumer);

   session.close();

   sf.close();

   Assert.assertEquals(0, sf.numSessions());

   Assert.assertEquals(0, sf.numConnections());
}