Java ClientSession.commit方法代码示例

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的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.ClientSession; //导入方法依赖的package包/类
@Test
public void testMulticastQueues() throws Exception {
   server.createQueue(multicastAddress, RoutingType.MULTICAST, multicastQ1, null, true, false, -1, false, true);
   server.createQueue(multicastAddress, RoutingType.MULTICAST, multicastQ2, null, true, false, -1, false, true);
   server.createQueue(multicastAddress, RoutingType.MULTICAST, multicastQ3, null, true, false, -1, false, true);

   ClientSessionFactory cf = createSessionFactory(locator);
   ClientSession session = cf.createSession();
   session.start();

   //send 3 messages
   ClientProducer producer = session.createProducer(multicastAddress);
   sendMessages(session, producer, 1);

   ClientConsumer consumer1 = session.createConsumer(toFullQN(multicastAddress, multicastQ1));
   ClientConsumer consumer2 = session.createConsumer(toFullQN(multicastAddress, multicastQ2));
   ClientConsumer consumer3 = session.createConsumer(toFullQN(multicastAddress, multicastQ3));
   session.start();

   //each consumer receives one
   ClientMessage m = consumer1.receive(2000);
   assertNotNull(m);
   m.acknowledge();
   m = consumer2.receive(2000);
   assertNotNull(m);
   m.acknowledge();
   m = consumer3.receive(2000);
   assertNotNull(m);
   m.acknowledge();

   session.commit();
   //queues are empty now
   for (SimpleString q : new SimpleString[]{multicastQ1, multicastQ2, multicastQ3}) {
      QueueQueryResult query = server.queueQuery(toFullQN(multicastAddress, q));
      assertTrue(query.isExists());
      assertEquals(multicastAddress, query.getAddress());
      assertEquals(toFullQN(multicastAddress, q), query.getName());
      assertEquals(0, query.getMessageCount());
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
/**
 * @param numberOfMessages
 * @param session
 * @throws Exception
 */
private void sendMessages(int numberOfMessages, ClientSession session) throws Exception {
   ClientProducer producer = session.createProducer(inQueue);

   for (int i = 0; i < numberOfMessages; i++) {
      ActiveMQTextMessage txt = new ActiveMQTextMessage(session);
      txt.setIntProperty("msg", i);
      txt.setText("Message Number (" + i + ")");
      txt.doBeforeSend();
      producer.send(txt.getCoreMessage());
   }

   session.commit();
}
 

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

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

   sendMessages(session, producer, NUM_MESSAGES);
   producer.close();
   session.commit();
   SimpleString liveId = liveServer.getServer().getNodeID();
   crash(session);

   session.start();
   ClientConsumer consumer = addClientConsumer(session.createConsumer(FailoverTestBase.ADDRESS));
   receiveMessages(consumer);
   assertNoMoreMessages(consumer);
   consumer.close();
   session.commit();

   Assert.assertEquals("backup must be running with the same nodeID", liveId, backupServer.getServer().getNodeID());
   sf.close();

   backupServer.crash();
   Thread.sleep(100);
   Assert.assertFalse("backup is not running", backupServer.isStarted());

   Assert.assertFalse("must NOT be a backup", liveServer.getServer().getHAPolicy() instanceof BackupPolicy);
   adaptLiveConfigForReplicatedFailBack(liveServer);
   beforeRestart(liveServer);
   liveServer.start();
   Assert.assertTrue("live initialized...", liveServer.getServer().waitForActivation(15, TimeUnit.SECONDS));

   sf = (ClientSessionFactoryInternal) createSessionFactory(locator);

   ClientSession session2 = createSession(sf, false, false);
   session2.start();
   ClientConsumer consumer2 = session2.createConsumer(FailoverTestBase.ADDRESS);
   boolean replication = liveServer.getServer().getHAPolicy() instanceof ReplicatedPolicy;
   if (replication)
      receiveMessages(consumer2, 0, NUM_MESSAGES, true);
   assertNoMoreMessages(consumer2);
   session2.commit();
}
 

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

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

   sendMessages(session, producer, NUM_MESSAGES);
   producer.close();
   session.commit();

   backupServer.stop(); // Backup stops!
   backupServer.start();

   waitForRemoteBackupSynchronization(backupServer.getServer());

   session.start();
   ClientConsumer consumer = addClientConsumer(session.createConsumer(FailoverTestBase.ADDRESS));
   receiveMessages(consumer);
   assertNoMoreMessages(consumer);
   consumer.close();
   session.commit();

   session.start();
   producer = addClientProducer(session.createProducer(FailoverTestBase.ADDRESS));
   sendMessages(session, producer, NUM_MESSAGES);
   producer.close();
   session.commit();
   backupServer.stop(); // Backup stops!
   beforeRestart(backupServer);
   backupServer.start();
   waitForRemoteBackupSynchronization(backupServer.getServer());
   backupServer.stop(); // Backup stops!

   liveServer.stop();
   beforeRestart(liveServer);
   liveServer.start();
   liveServer.getServer().waitForActivation(10, TimeUnit.SECONDS);

   ClientSession session2 = createSession(sf, false, false);
   session2.start();
   ClientConsumer consumer2 = session2.createConsumer(FailoverTestBase.ADDRESS);
   receiveMessages(consumer2, 0, NUM_MESSAGES, true);
   assertNoMoreMessages(consumer2);
   session2.commit();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的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.ClientSession; //导入方法依赖的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.ClientSession; //导入方法依赖的package包/类
@Test
public void testFailMessagesDurable() 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 = 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 and test for an exception.
   // The address will actually fill up after 3 messages. Also, it takes 32 messages for the client's
   // credits to run out.
   for (int i = 0; i < 50; i++) {
      if (i > 2) {
         validateExceptionOnSending(producer, message);
      } else {
         producer.send(message);
      }
   }

   ClientConsumer consumer = session.createConsumer(ADDRESS);

   session.start();

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

   boolean exception = false;

   try {
      for (int i = 0; i < 1000; i++) {
         // this send will succeed on the server
         producer.send(message);
      }
   } catch (Exception e) {
      exception = true;
   }

   assertTrue("Expected to throw an exception", exception);
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
@BMRules(
   rules = {@BMRule(
      name = "record large message copy thread",
      targetClass = "org.apache.activemq.artemis.core.persistence.impl.journal.LargeServerMessageImpl",
      targetMethod = "copy(long)",
      targetLocation = "ENTRY",
      action = "org.apache.activemq.artemis.tests.extras.byteman.LargeMessageReplicationTest.copyThread()"), @BMRule(
      name = "record byte array in addBytes",
      targetClass = "org.apache.activemq.artemis.core.persistence.impl.journal.LargeServerMessageImpl",
      targetMethod = "addBytes(byte[])",
      targetLocation = "ENTRY",
      action = "org.apache.activemq.artemis.tests.extras.byteman.LargeMessageReplicationTest.addBytesIn($1)"), @BMRule(
      name = "record byte array used for reading large message",
      targetClass = "^org.apache.activemq.artemis.core.io.SequentialFile",
      isInterface = true,
      targetMethod = "read(java.nio.ByteBuffer)",
      targetLocation = "ENTRY",
      action = "org.apache.activemq.artemis.tests.extras.byteman.LargeMessageReplicationTest.originBuff($1)")})
//https://issues.apache.org/jira/browse/ARTEMIS-1220
public void testDivertCopyMessageBuffer() 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();

   ClientProducer producer = session.createProducer(DIVERT_ADDRESS);
   ClientMessage message = createLargeMessage(session, 3 * minLarge);
   producer.send(message);

   session.commit();

   ClientConsumer consumer = session.createConsumer(DIVERT_ADDRESS);
   ClientMessage receivedFromSourceQueue = consumer.receive(5000);
   assertNotNull(receivedFromSourceQueue);
   receivedFromSourceQueue.acknowledge();
   session.commit();

   crash(session);

   ClientConsumer consumer1 = session.createConsumer(DIVERT_FORWARD_ADDRESS);
   ClientMessage receivedFromTargetQueue = consumer1.receive(5000);
   assertNotNull(receivedFromTargetQueue);
   receivedFromTargetQueue.acknowledge();

   session.commit();

   checkBufferNotReused();
}
 

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

   startBackups(0, 1, 3, 4);
   startServers(0, 1, 3, 4);

   waitForTopology(servers[4], getNumberOfServers() - 1, getNumberOfServers() - 1);

   crashAndWaitForFailure(servers[4], createLocator(false, 4));
   waitForServerToStart(backupServers[4]);

   startBackups(2);
   startServers(2);

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

   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, 9);
   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.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包/类
@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包/类
@Test
public void testSendServerMessage() throws Exception {
   ActiveMQServer server = createServer(true);

   server.start();

   ServerLocator locator = createInVMNonHALocator();

   ClientSessionFactory sf = createSessionFactory(locator);

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

   try {
      LargeServerMessageImpl fileMessage = new LargeServerMessageImpl((JournalStorageManager) server.getStorageManager());

      fileMessage.setMessageID(1005);

      for (int i = 0; i < 2 * ActiveMQClient.DEFAULT_MIN_LARGE_MESSAGE_SIZE; i++) {
         fileMessage.addBytes(new byte[]{ActiveMQTestBase.getSamplebyte(i)});
      }
      // The server would be doing this
      fileMessage.putLongProperty(Message.HDR_LARGE_BODY_SIZE, 2 * ActiveMQClient.DEFAULT_MIN_LARGE_MESSAGE_SIZE);

      fileMessage.releaseResources();

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

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

      prod.send(fileMessage);

      fileMessage.deleteFile();

      session.commit();

      session.start();

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

      ClientMessage msg = cons.receive(5000);

      Assert.assertNotNull(msg);

      Assert.assertEquals(msg.getBodySize(), 2 * ActiveMQClient.DEFAULT_MIN_LARGE_MESSAGE_SIZE);

      for (int i = 0; i < 2 * ActiveMQClient.DEFAULT_MIN_LARGE_MESSAGE_SIZE; i++) {
         Assert.assertEquals(ActiveMQTestBase.getSamplebyte(i), msg.getBodyBuffer().readByte());
      }

      msg.acknowledge();

      session.commit();

   } finally {
      sf.close();
      locator.close();
      server.stop();
   }
}
 

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

   ClientSession session = null;

   LargeMessageTestInterceptorIgnoreLastPacket.disableInterrupt();
   ActiveMQServer server = createServer(true, isNetty());

   server.start();

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

   ClientSessionFactory sf = createSessionFactory(locator);

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

   session.createQueue(ADDRESS, ADDRESS, false);

   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();

   session = sf.createSession(false, false);

   ClientConsumer cons = session.createConsumer(ADDRESS);

   session.start();

   for (int h = 0; h < 5; h++) {
      for (int i = 0; i < 10; i++) {
         ClientMessage clientMessage = cons.receive(5000);
         Assert.assertNotNull(clientMessage);
         for (int countByte = 0; countByte < LARGE_MESSAGE_SIZE; countByte++) {
            Assert.assertEquals(ActiveMQTestBase.getSamplebyte(countByte), clientMessage.getBodyBuffer().readByte());
         }
         clientMessage.acknowledge();
      }
      session.rollback();
   }

   server.fail(false);
   server.start();

   server.stop();

   validateNoFilesOnLargeDir();
}
 

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

   LargeMessageTestInterceptorIgnoreLastPacket.disableInterrupt();

   server.start();

   locator.setBlockOnNonDurableSend(false).setBlockOnDurableSend(false).addIncomingInterceptor(new LargeMessageTestInterceptorIgnoreLastPacket());

   ClientSessionFactory sf = createSessionFactory(locator);

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

   session.createQueue(ADDRESS, ADDRESS, true);

   ClientProducer producer = session.createProducer(ADDRESS);

   Message clientFile = createLargeClientMessageStreaming(session, LARGE_MESSAGE_SIZE, true);

   producer.send(clientFile);

   session.commit();

   LargeMessageTestInterceptorIgnoreLastPacket.clearInterrupt();

   final AtomicInteger unexpectedErrors = new AtomicInteger(0);
   final AtomicInteger expectedErrors = new AtomicInteger(0);
   final ClientConsumer cons = session.createConsumer(ADDRESS);

   session.start();

   Thread t = new Thread() {
      @Override
      public void run() {
         try {
            System.out.println("Receiving message");
            ClientMessage msg = cons.receive(5000);
            if (msg == null) {
               System.err.println("Message not received");
               unexpectedErrors.incrementAndGet();
               return;
            }

            msg.checkCompletion();
         } catch (ActiveMQException e) {
            e.printStackTrace();
            expectedErrors.incrementAndGet();
         }
      }
   };

   t.start();

   LargeMessageTestInterceptorIgnoreLastPacket.awaitInterrupt();

   cons.close();

   t.join();

   Assert.assertEquals(0, unexpectedErrors.get());
   Assert.assertEquals(1, expectedErrors.get());

   session.close();

   server.stop();
}