Java ClientSession.createConsumer方法代码示例

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
/**
 * @throws ActiveMQException
 */
private void addBogusData(final int nmessages, final String queue) throws ActiveMQException {
   ClientSession session = sf.createSession(false, false);
   try {
      session.createQueue(queue, queue, true);
   } catch (Exception ignored) {
   }

   ClientProducer prod = session.createProducer(queue);
   for (int i = 0; i < nmessages; i++) {
      ClientMessage msg = session.createMessage(true);
      msg.getBodyBuffer().writeBytes(new byte[1024]);
      prod.send(msg);
   }
   session.commit();

   session.start();

   ClientConsumer cons = session.createConsumer(queue);
   Assert.assertNotNull(cons.receive(1000));
   session.rollback();
   session.close();
}
 

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

   ClientSessionFactory cf = createSessionFactory(locator);
   ClientSession session = cf.createSession(false, true, true);
   session.createQueue(addressA, queueA, false);
   ClientConsumer cc = session.createConsumer(queueA);
   session.start();
   session.close();
   try {
      cc.receive();
      Assert.fail("should throw exception");
   } catch (ActiveMQObjectClosedException oce) {
      //ok
   } catch (ActiveMQException e) {
      Assert.fail("Invalid Exception type:" + e.getType());
   }
   session.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testRouteToMultipleQueues() throws Exception {
   ClientSession sendSession = cf.createSession(false, true, true);
   sendSession.createQueue(addressA, queueA, false);
   sendSession.createQueue(addressA, queueB, false);
   sendSession.createQueue(addressA, queueC, false);
   int numMessages = 300;
   ClientProducer p = sendSession.createProducer(addressA);
   for (int i = 0; i < numMessages; i++) {
      p.send(sendSession.createMessage(false));
   }
   ClientSession session = cf.createSession(false, true, true);
   ClientConsumer c1 = session.createConsumer(queueA);
   ClientConsumer c2 = session.createConsumer(queueB);
   ClientConsumer c3 = session.createConsumer(queueC);
   session.start();
   for (int i = 0; i < numMessages; i++) {
      ClientMessage m = c1.receive(5000);
      Assert.assertNotNull(m);
      m.acknowledge();
      c2.receive(5000);
      Assert.assertNotNull(m);
      m.acknowledge();
      c3.receive(5000);
      Assert.assertNotNull(m);
      m.acknowledge();
   }
   Assert.assertNull(c1.receiveImmediate());
   Assert.assertNull(c2.receiveImmediate());
   Assert.assertNull(c3.receiveImmediate());
   sendSession.close();
   session.close();
}
 

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

   SimpleString sendAddress = new SimpleString("test.address");

   List<String> testAddresses = Arrays.asList("test.address", "test.#", "test.*");

   for (String consumeAddress : testAddresses) {

      // For each address, create 2 Queues with the same address, assert both queues receive message
      Queue q1 = server.createQueue(new SimpleString(consumeAddress), RoutingType.MULTICAST, new SimpleString(consumeAddress + ".1"), null, true, false);
      Queue q2 = server.createQueue(new SimpleString(consumeAddress), RoutingType.MULTICAST, new SimpleString(consumeAddress + ".2"), null, true, false);

      ClientSession session = sessionFactory.createSession();
      session.start();

      ClientConsumer consumer1 = session.createConsumer(q1.getName());
      ClientConsumer consumer2 = session.createConsumer(q2.getName());

      ClientProducer producer = session.createProducer(sendAddress);
      ClientMessage m = session.createMessage(ClientMessage.TEXT_TYPE, true);
      m.getBodyBuffer().writeString("TestMessage");

      producer.send(m);

      assertNotNull(consumer1.receive(2000));
      assertNotNull(consumer2.receive(2000));

      q1.deleteQueue();
      q2.deleteQueue();
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
@BMRules(
   rules = {@BMRule(
      name = "trace clientsessionimpl commit",
      targetClass = "org.apache.activemq.artemis.core.client.impl.ClientSessionImpl",
      targetMethod = "commit",
      targetLocation = "ENTRY",
      action = "org.apache.activemq.artemis.tests.extras.byteman.BMFailoverTest.serverToStop.getServer().stop(true)")})
public void testFailoverOnReceiveCommit() throws Exception {
   serverToStop = liveServer;
   locator = getServerLocator().setFailoverOnInitialConnection(true);
   createSessionFactory();
   ClientSession session = createSessionAndQueue();

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

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

   sendMessages(sendSession, producer, 10);

   ClientConsumer consumer = session.createConsumer(FailoverTestBase.ADDRESS);
   session.start();
   for (int i = 0; i < 10; i++) {
      ClientMessage m = consumer.receive(500);
      assertNotNull(m);
      m.acknowledge();
   }
   try {
      session.commit();
      fail("should have thrown an exception");
   } catch (ActiveMQTransactionOutcomeUnknownException e) {
      //pass
   } catch (ActiveMQTransactionRolledBackException e1) {
      //pass
   }
   Queue bindable = (Queue) backupServer.getServer().getPostOffice().getBinding(FailoverTestBase.ADDRESS).getBindable();
   assertEquals(10, getMessageCount(bindable));

}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
@BMRules(
   rules = {@BMRule(
      name = "interrupt",
      targetClass = "org.apache.activemq.artemis.core.protocol.core.impl.ActiveMQSessionContext",
      targetMethod = "xaEnd",
      targetLocation = "ENTRY",
      action = "org.apache.activemq.artemis.tests.extras.byteman.ActiveMQMessageHandlerTest.interrupt();")})
public void testSimpleMessageReceivedOnQueueTwoPhase() throws Exception {
   ActiveMQResourceAdapter qResourceAdapter = newResourceAdapter();
   resourceAdapter = qResourceAdapter;

   MyBootstrapContext ctx = new MyBootstrapContext();

   qResourceAdapter.setConnectorClassName(NETTY_CONNECTOR_FACTORY);
   qResourceAdapter.start(ctx);

   ActiveMQActivationSpec spec = new ActiveMQActivationSpec();
   spec.setMaxSession(1);
   spec.setCallTimeout(1000L);
   spec.setResourceAdapter(qResourceAdapter);
   spec.setUseJNDI(false);
   spec.setDestinationType("javax.jms.Queue");
   spec.setDestination(MDBQUEUE);

   CountDownLatch latch = new CountDownLatch(1);

   XADummyEndpoint endpoint = new XADummyEndpoint(latch, true);

   DummyMessageEndpointFactory endpointFactory = new DummyMessageEndpointFactory(endpoint, true);

   qResourceAdapter.endpointActivation(endpointFactory, spec);

   ClientSession session = locator.createSessionFactory().createSession();

   ClientProducer clientProducer = session.createProducer(MDBQUEUEPREFIXED);

   ClientMessage message = session.createMessage(true);

   message.getBodyBuffer().writeString("teststring");

   clientProducer.send(message);

   session.close();

   latch.await(5, TimeUnit.SECONDS);

   assertNotNull(endpoint.lastMessage);
   assertEquals(endpoint.lastMessage.getCoreMessage().getBodyBuffer().readString(), "teststring");

   qResourceAdapter.endpointDeactivation(endpointFactory, spec);

   qResourceAdapter.stop();

   Binding binding = server.getPostOffice().getBinding(SimpleString.toSimpleString(MDBQUEUEPREFIXED));
   assertEquals(1, getMessageCount(((Queue) binding.getBindable())));

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

   ClientSessionFactory factory = locator.createSessionFactory();
   session = factory.createSession(true, true);

   session.start();
   ClientConsumer consumer = session.createConsumer(MDBQUEUEPREFIXED);
   assertNotNull(consumer.receive(5000));
   session.close();
}
 

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

   Configuration config = createDefaultInVMConfig();

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

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

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

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

   server.start();

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

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

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

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

   ClientMessage message = session.createMessage(true);

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

   message.getBodyBuffer().writeBytes(body);

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

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

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

   validateExceptionOnSending(producer, message);

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

   ClientConsumer consumer = session.createConsumer(ADDRESS);

   session.start();

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

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

   producer.send(message);

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

   consumer = session.createConsumer(ADDRESS);

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

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
private void internalTest(int MAX_MESSAGES,
                          String MY_ADDRESS,
                          String MY_QUEUE,
                          ActiveMQServer server) throws Exception {
   ServerLocator locator = createInVMNonHALocator().setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setBlockOnAcknowledge(true);

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

   session.createQueue(MY_ADDRESS, MY_QUEUE, true);

   final ClientProducer producer = session.createProducer(MY_ADDRESS);

   final ClientMessage message = session.createMessage(false);
   message.getBodyBuffer().writeBytes(new byte[1024]);

   ExecutorService executor = Executors.newFixedThreadPool(1, ActiveMQThreadFactory.defaultThreadFactory());
   Callable<Object> sendMessageTask = new Callable<Object>() {
      @Override
      public Object call() throws ActiveMQException {
         producer.send(message);
         return null;
      }
   };

   int sendCount = 0;

   for (int i = 0; i < MAX_MESSAGES; i++) {
      Future<Object> future = executor.submit(sendMessageTask);
      try {
         future.get(3, TimeUnit.SECONDS);
         sendCount++;
      } catch (TimeoutException ex) {
         // message sending has been blocked
         break;
      } finally {
         future.cancel(true); // may or may not desire this
      }
   }

   executor.shutdown();
   session.close();

   session = factory.createSession(false, true, true);
   session.start();
   ClientConsumer consumer = session.createConsumer(MY_QUEUE);
   for (int i = 0; i < sendCount; i++) {
      ClientMessage msg = consumer.receive(250);
      if (msg == null)
         break;
      msg.acknowledge();
   }

   session.close();
   locator.close();
   server.stop();

   // Using the code only so the test doesn't fail just because someone edits the log text
   Assert.assertTrue("Expected to find AMQ222183", AssertionLoggerHandler.findText("AMQ222183", "myAddress"));
   Assert.assertTrue("Expected to find AMQ221046", AssertionLoggerHandler.findText("AMQ221046", "myAddress"));
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testListSessionsAsJSON() throws Exception {
   SimpleString queueName = new SimpleString(UUID.randomUUID().toString());
   server.addAddressInfo(new AddressInfo(queueName, RoutingType.ANYCAST));
   server.createQueue(queueName, RoutingType.ANYCAST, queueName, null, false, false);
   ActiveMQServerControl serverControl = createManagementControl();

   ServerLocator locator = createInVMNonHALocator();
   ClientSessionFactory factory = createSessionFactory(locator);
   ClientSession session1 = addClientSession(factory.createSession());
   Thread.sleep(5);
   ClientSession session2 = addClientSession(factory.createSession("myUser", "myPass", false, false, false, false, 0));
   session2.createConsumer(queueName);

   String jsonString = serverControl.listSessionsAsJSON(factory.getConnection().getID().toString());
   IntegrationTestLogger.LOGGER.info(jsonString);
   Assert.assertNotNull(jsonString);
   JsonArray array = JsonUtil.readJsonArray(jsonString);
   Assert.assertEquals(2, array.size());
   JsonObject first;
   JsonObject second;
   if (array.getJsonObject(0).getJsonNumber("creationTime").longValue() < array.getJsonObject(1).getJsonNumber("creationTime").longValue()) {
      first = array.getJsonObject(0);
      second = array.getJsonObject(1);
   } else {
      first = array.getJsonObject(1);
      second = array.getJsonObject(0);
   }

   Assert.assertTrue(first.getString("sessionID").length() > 0);
   Assert.assertEquals(((ClientSessionImpl) session1).getName(), first.getString("sessionID"));
   Assert.assertTrue(first.getString("principal").length() > 0);
   Assert.assertEquals("guest", first.getString("principal"));
   Assert.assertTrue(first.getJsonNumber("creationTime").longValue() > 0);
   Assert.assertEquals(0, first.getJsonNumber("consumerCount").longValue());

   Assert.assertTrue(second.getString("sessionID").length() > 0);
   Assert.assertEquals(((ClientSessionImpl) session2).getName(), second.getString("sessionID"));
   Assert.assertTrue(second.getString("principal").length() > 0);
   Assert.assertEquals("myUser", second.getString("principal"));
   Assert.assertTrue(second.getJsonNumber("creationTime").longValue() > 0);
   Assert.assertEquals(1, second.getJsonNumber("consumerCount").longValue());
}
 

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

   server.start();
   AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(dlaA).setMaxDeliveryAttempts(1);
   AddressSettings addressSettings2 = new AddressSettings().setDeadLetterAddress(dlaB).setMaxDeliveryAttempts(1);
   AddressSettings addressSettings3 = new AddressSettings().setDeadLetterAddress(dlaC).setMaxDeliveryAttempts(1);
   HierarchicalRepository<AddressSettings> repos = server.getAddressSettingsRepository();
   repos.addMatch(addressA2.toString(), addressSettings);
   repos.addMatch("add.*", addressSettings2);
   repos.addMatch("#", addressSettings3);
   ServerLocator locator = createInVMNonHALocator();
   ClientSessionFactory sf = createSessionFactory(locator);
   ClientSession session = sf.createSession(false, true, false);
   session.createQueue(addressA2, queueA, false);
   session.createQueue(addressB2, queueB, false);
   session.createQueue(addressC, queueC, false);
   session.createQueue(dlaA, dlqA, false);
   session.createQueue(dlaB, dlqB, false);
   session.createQueue(dlaC, dlqC, false);
   ClientSession sendSession = sf.createSession(false, true, true);
   ClientMessage cm = sendSession.createMessage(true);
   cm.getBodyBuffer().writeString("A");
   ClientMessage cm2 = sendSession.createMessage(true);
   cm2.getBodyBuffer().writeString("B");
   ClientMessage cm3 = sendSession.createMessage(true);
   cm3.getBodyBuffer().writeString("C");
   ClientProducer cp1 = sendSession.createProducer(addressA2);
   ClientProducer cp2 = sendSession.createProducer(addressB2);
   ClientProducer cp3 = sendSession.createProducer(addressC);
   cp1.send(cm);
   cp2.send(cm2);
   cp3.send(cm3);

   ClientConsumer dlqARec = session.createConsumer(dlqA);
   ClientConsumer dlqBrec = session.createConsumer(dlqB);
   ClientConsumer dlqCrec = session.createConsumer(dlqC);
   ClientConsumer cc1 = session.createConsumer(queueA);
   ClientConsumer cc2 = session.createConsumer(queueB);
   ClientConsumer cc3 = session.createConsumer(queueC);
   session.start();
   ClientMessage message = cc1.receive(5000);
   Assert.assertNotNull(message);
   message.acknowledge();
   message = cc2.receive(5000);
   Assert.assertNotNull(message);
   message.acknowledge();
   message = cc3.receive(5000);
   Assert.assertNotNull(message);
   message.acknowledge();
   session.rollback();
   cc1.close();
   cc2.close();
   cc3.close();
   message = dlqARec.receive(5000);
   Assert.assertNotNull(message);
   Assert.assertEquals("A", message.getBodyBuffer().readString());
   message = dlqBrec.receive(5000);
   Assert.assertNotNull(message);
   Assert.assertEquals("B", message.getBodyBuffer().readString());
   message = dlqCrec.receive(5000);
   Assert.assertNotNull(message);
   Assert.assertEquals("C", message.getBodyBuffer().readString());
   sendSession.close();
   session.close();

}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testBody2() throws Exception {
   final String QUEUE_NAME = "A1";
   server = createServer(true);
   server.start();
   ServerLocator locator = createInVMNonHALocator();
   ClientSessionFactory factory = locator.createSessionFactory();
   ClientSession session = factory.createSession(false, true, true);

   session.createQueue(QUEUE_NAME, RoutingType.MULTICAST, QUEUE_NAME, true);

   ClientProducer producer = session.createProducer(QUEUE_NAME);

   ClientMessage msg = session.createMessage(true);
   byte[] bodyTst = new byte[10];
   for (int i = 0; i < 10; i++) {
      bodyTst[i] = (byte) (i + 1);
   }
   msg.getBodyBuffer().writeBytes(bodyTst);
   assertEquals(bodyTst.length, msg.getBodySize());
   producer.send(msg);

   session.close();
   locator.close();
   server.stop();

   ByteArrayOutputStream xmlOutputStream = new ByteArrayOutputStream();
   XmlDataExporter xmlDataExporter = new XmlDataExporter();
   xmlDataExporter.process(xmlOutputStream, server.getConfiguration().getBindingsDirectory(), server.getConfiguration().getJournalDirectory(), server.getConfiguration().getPagingDirectory(), server.getConfiguration().getLargeMessagesDirectory());
   System.out.print(new String(xmlOutputStream.toByteArray()));

   clearDataRecreateServerDirs();
   server.start();
   checkForLongs();
   locator = createInVMNonHALocator();
   factory = locator.createSessionFactory();
   session = factory.createSession(false, false, true);
   ClientSession managementSession = factory.createSession(false, true, true);

   ByteArrayInputStream xmlInputStream = new ByteArrayInputStream(xmlOutputStream.toByteArray());
   XmlDataImporter xmlDataImporter = new XmlDataImporter();
   xmlDataImporter.validate(xmlInputStream);
   xmlInputStream.reset();
   xmlDataImporter.process(xmlInputStream, session, managementSession);
   ClientConsumer consumer = session.createConsumer(QUEUE_NAME);
   session.start();

   msg = consumer.receive(CONSUMER_TIMEOUT);
   assertNotNull(msg);
   assertEquals(msg.getBodySize(), bodyTst.length);
   byte[] bodyRead = new byte[bodyTst.length];
   msg.getBodyBuffer().readBytes(bodyRead);
   assertEqualsByteArrays(bodyTst, bodyRead);

   session.close();
   locator.close();
   server.stop();
}
 

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

   server2.getConfiguration().setJournalFileSize(10 * 1024 * 1024);
   server2.getConfiguration().setJournalMinFiles(10);
   server2.getConfiguration().setJournalCompactMinFiles(3);
   server2.getConfiguration().setJournalCompactPercentage(50);

   for (int i = 0; i < 10; i++) {
      server2.start();

      ServerLocator locator = createInVMNonHALocator().setMinLargeMessageSize(1024 * 1024).setBlockOnDurableSend(false);

      ClientSessionFactory sf = createSessionFactory(locator);

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

      try {
         session.createQueue("slow-queue", RoutingType.MULTICAST, "slow-queue");
      } catch (Exception ignored) {
      }

      session.start();
      ClientConsumer consumer = session.createConsumer("slow-queue");

      while (true) {
         System.out.println("Received message from previous");
         ClientMessage msg = consumer.receiveImmediate();
         if (msg == null) {
            break;
         }
         msg.acknowledge();
      }

      session.close();

      produceMessages(sf, 30000);

      server2.stop();
   }

}
 

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

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

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

   ClientProducer producer = session.createProducer(ADDRESS);

   ClientMessage message = session.createMessage(false);

   producer.send(message);

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

   session.start();

   ClientMessage received = consumer.receiveImmediate();

   assertNotNull(received);

   received.acknowledge();

   received = consumer.receive(1);

   assertNull(received);

   session.close();
}
 

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

   if (createQueue) {
      session.createQueue(FailoverTestBase.ADDRESS, FailoverTestBase.ADDRESS, null, false);
   }

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

   final int numMessages = 1000;

   for (int i = 0; i < numMessages; i++) {
      ClientMessage message = session.createMessage(ActiveMQTextMessage.TYPE, false, 0, System.currentTimeMillis(), (byte) 1);
      message.putIntProperty(new SimpleString("count"), i);
      message.getBodyBuffer().writeString("aardvarks");
      producer.send(message);
   }

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

   session.start();

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

      Assert.assertNotNull(message2);

      Assert.assertEquals("aardvarks", message2.getBodyBuffer().readString());

      Assert.assertEquals(i, message2.getObjectProperty(new SimpleString("count")));

      message2.acknowledge();
   }

   ClientMessage message3 = consumer.receiveImmediate();

   Assert.assertNull(message3);

   return session;
}
 

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

   ClientSession session1 = createSessionAndQueue();

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

   for (int i = 0; i < NUM_MESSAGES; i++) {
      // some are durable, some are not!
      producer.send(createMessage(session1, i, true));
   }

   session1.commit();

   ClientSession session2 = createSession(sf, true, false, false);

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

   session2.start();

   Xid xid = new XidImpl("uhuhuhu".getBytes(), 126512, "auhsduashd".getBytes());

   session2.start(xid, XAResource.TMNOFLAGS);

   crash(session2);

   receiveMessages(consumer);

   try {
      session2.end(xid, XAResource.TMSUCCESS);

      Assert.fail("Should throw exception");
   } catch (XAException e) {
   }

   // Since the end was not accepted, the messages should be redelivered
   receiveMessages(consumer);
}