Java ClientMessage.putIntProperty方法代码示例

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
public List<String> sendMessageBatch(int batchSize,
                                     ClientSession session,
                                     SimpleString queueAddr) throws ActiveMQException {
   List<String> messageIds = new ArrayList<>();
   ClientProducer producer = session.createProducer(queueAddr);
   for (int i = 0; i < batchSize; i++) {
      ClientMessage message = session.createMessage(true);
      message.getBodyBuffer().writeBytes(new byte[1024]);
      String id = UUID.randomUUID().toString();
      message.putStringProperty("id", id);
      message.putIntProperty("seq", i); // this is to make the print-data easier to debug
      messageIds.add(id);
      producer.send(message);
   }
   session.commit();

   return messageIds;
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
@Test
public void testListScheduledMessagesAsJSON() throws Exception {
   long delay = 2000;
   SimpleString address = RandomUtil.randomSimpleString();
   SimpleString queue = RandomUtil.randomSimpleString();
   int intValue = RandomUtil.randomInt();
   session.createQueue(address, queue, null, false);

   QueueControl queueControl = createManagementControl(address, queue);

   ClientProducer producer = session.createProducer(address);
   ClientMessage message = session.createMessage(false);
   message.putLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME, System.currentTimeMillis() + delay);
   message.putIntProperty(new SimpleString("key"), intValue);
   producer.send(message);
   // unscheduled message
   producer.send(session.createMessage(false));

   String jsonString = queueControl.listScheduledMessagesAsJSON();
   Assert.assertNotNull(jsonString);
   JsonArray array = JsonUtil.readJsonArray(jsonString);
   Assert.assertEquals(1, array.size());
   int i = Integer.parseInt(array.getJsonObject(0).get("key").toString().replaceAll("\"", ""));
   Assert.assertEquals(intValue, i);

   Thread.sleep(delay + 500);

   jsonString = queueControl.listScheduledMessagesAsJSON();
   Assert.assertNotNull(jsonString);
   array = JsonUtil.readJsonArray(jsonString);
   Assert.assertEquals(0, array.size());

   consumeMessages(2, session, queue);

   session.deleteQueue(queue);
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
@Test
public void testListMessagesAsJSONWithNullFilter() throws Exception {
   SimpleString address = RandomUtil.randomSimpleString();
   SimpleString queue = RandomUtil.randomSimpleString();
   int intValue = RandomUtil.randomInt();
   session.createQueue(address, queue, null, false);

   QueueControl queueControl = createManagementControl(address, queue);

   ClientProducer producer = session.createProducer(address);
   ClientMessage message = session.createMessage(false);
   message.putIntProperty(new SimpleString("key"), intValue);
   producer.send(message);

   String jsonString = queueControl.listMessagesAsJSON(null);
   Assert.assertNotNull(jsonString);
   JsonArray array = JsonUtil.readJsonArray(jsonString);
   Assert.assertEquals(1, array.size());

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

   consumeMessages(1, session, queue);

   jsonString = queueControl.listMessagesAsJSON(null);
   Assert.assertNotNull(jsonString);
   array = JsonUtil.readJsonArray(jsonString);
   Assert.assertEquals(0, array.size());

   session.deleteQueue(queue);
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
@Override
public void run() {
   try {
      if (shareConnectionFactory) {
         session = sharedSf.createSession(false, false);
      } else {
         locator = createInVMNonHALocator();
         sf = createSessionFactory(locator);
         session = sf.createSession(false, false);
      }

      ClientProducer prod = session.createProducer(MultipleConsumersPageStressTest.ADDRESS);

      int count = 0;

      while (enabled()) {
         int numberOfMessages = getNumberOfMessages();

         for (int i = 0; i < numberOfMessages; i++) {
            ClientMessage msg = session.createMessage(true);
            msg.putStringProperty("Test", "This is a simple test");
            msg.putIntProperty("count", count++);
            prod.send(msg);
         }

         messagesAvailable.addAndGet(numberOfMessages);
         session.commit();
      }
   } catch (Throwable e) {
      exceptionHappened(e);
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
protected void sendInRange(final int node,
                           final String address,
                           final int msgStart,
                           final int msgEnd,
                           final boolean durable,
                           final SimpleString key,
                           final SimpleString val) throws Exception {
   ClientSessionFactory sf = sfs[node];

   if (sf == null) {
      throw new IllegalArgumentException("No sf at " + node);
   }

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

   try {
      ClientProducer producer = session.createProducer(address);

      for (int i = msgStart; i < msgEnd; i++) {
         ClientMessage message = session.createMessage(durable);

         if (isLargeMessage()) {
            message.setBodyInputStream(createFakeLargeStream(getLargeMessageSize()));
         }

         message.putStringProperty(key, val);
         message.putIntProperty(ClusterTestBase.COUNT_PROP, i);

         producer.send(message);
      }
   } finally {
      session.close();
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
@Test
public void testSendPacketsWithFailure() throws Exception {
   final int nMsg = 100;
   final int stop = 37;
   setupServer(true, TestInterceptor.class.getName());

   manager = liveServer.getReplicationManager();
   waitForComponent(manager);
   ClientSessionFactory sf = createSessionFactory(locator);
   final ClientSession session = sf.createSession();
   final ClientSession session2 = sf.createSession();
   session.createQueue(ADDRESS, ADDRESS, null, true);

   final ClientProducer producer = session.createProducer(ADDRESS);

   session.start();
   session2.start();
   try {
      final ClientConsumer consumer = session2.createConsumer(ADDRESS);
      for (int i = 0; i < nMsg; i++) {

         ClientMessage message = session.createMessage(true);
         setBody(i, message);
         message.putIntProperty("counter", i);
         producer.send(message);
         if (i == stop) {
            // Now we start intercepting the communication with the backup
            TestInterceptor.value.set(false);
         }
         ClientMessage msgRcvd = consumer.receive(1000);
         Assert.assertNotNull("Message should exist!", msgRcvd);
         assertMessageBody(i, msgRcvd);
         Assert.assertEquals(i, msgRcvd.getIntProperty("counter").intValue());
         msgRcvd.acknowledge();
      }
   } finally {
      TestInterceptor.value.set(false);
      if (!session.isClosed())
         session.close();
      if (!session2.isClosed())
         session2.close();
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
@Test
public void testListDeliveringMessages() throws Exception {
   SimpleString address = RandomUtil.randomSimpleString();
   SimpleString queue = RandomUtil.randomSimpleString();
   int intValue = RandomUtil.randomInt();
   session.createQueue(address, queue, null, false);

   Queue srvqueue = server.locateQueue(queue);

   QueueControl queueControl = createManagementControl(address, queue);

   ClientProducer producer = session.createProducer(address);
   ClientMessage message = session.createMessage(false);
   message.putIntProperty(new SimpleString("key"), intValue);
   producer.send(message);
   producer.send(session.createMessage(false));

   ClientConsumer consumer = session.createConsumer(queue);
   session.start();
   ClientMessage msgRec = consumer.receive(5000);
   assertNotNull(msgRec);
   assertEquals(msgRec.getIntProperty("key").intValue(), intValue);

   ClientSessionFactory sf2 = createSessionFactory(locator);
   ClientSession session2 = sf2.createSession(false, true, false);
   ClientConsumer consumer2 = session2.createConsumer(queue);
   session2.start();
   ClientMessage msgRec2 = consumer2.receive(5000);
   assertNotNull(msgRec2);

   assertEquals(2, srvqueue.getDeliveringCount());
   assertEquals(2, srvqueue.getConsumerCount());

   System.out.println(queueControl.listDeliveringMessagesAsJSON());

   Map<String, Map<String, Object>[]> deliveringMap = queueControl.listDeliveringMessages();
   assertEquals(2, deliveringMap.size());

   consumer.close();
   consumer2.close();

   session.deleteQueue(queue);
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
/**
 * @param useManagement true = it will use a management operation to make the connection failure, false through ping
 * @throws Exception
 */
private void internalTestOrphanedConsumers(boolean useManagement) throws Exception {
   final int NUMBER_OF_MESSAGES = 2;
   server = createServer(true, true);
   server.start();
   staticServer = server;

   // We are not interested on consumer-window-size on this test
   // We want that every message is delivered
   // as we asserting for number of consumers available and round-robin on delivery
   locator.setConsumerWindowSize(-1).setBlockOnNonDurableSend(false).setBlockOnDurableSend(false).setBlockOnAcknowledge(true).setConnectionTTL(1000).setClientFailureCheckPeriod(100).setReconnectAttempts(0);

   ClientSessionFactoryImpl sf = (ClientSessionFactoryImpl) createSessionFactory(locator);

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

   session.createQueue("queue", "queue1", true);
   session.createQueue("queue", "queue2", true);

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

   ClientConsumer consumer = session.createConsumer("queue1");
   ClientConsumer consumer2 = session.createConsumer("queue2");

   Queue queue1 = server.locateQueue(new SimpleString("queue1"));

   Queue queue2 = server.locateQueue(new SimpleString("queue2"));

   session.start();

   if (!useManagement) {
      sf.stopPingingAfterOne();

      for (long timeout = System.currentTimeMillis() + 6000; timeout > System.currentTimeMillis() && server.getConnectionCount() != 0; ) {
         Thread.sleep(100);
      }

      // an extra second to avoid races of something closing the session while we are asserting it
      Thread.sleep(1000);
   } else {
      server.getActiveMQServerControl().closeConnectionsForAddress("127.0.0.1");
   }

   if (verification != null) {
      throw verification;
   }

   assertEquals(0, queue1.getConsumerCount());
   assertEquals(0, queue2.getConsumerCount());

   setConditionActive(false);

   locator = internalCreateNonHALocator(true).setBlockOnNonDurableSend(false).setBlockOnDurableSend(false).setBlockOnAcknowledge(true).setReconnectAttempts(0).setConsumerWindowSize(-1);

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

   session.start();

   prod = session.createProducer("queue");

   for (int i = 0; i < NUMBER_OF_MESSAGES; i++) {
      ClientMessage message = session.createMessage(true);
      message.putIntProperty("i", i);
      prod.send(message);
   }

   consumer = session.createConsumer("queue1");
   consumer2 = session.createConsumer("queue2");

   for (int i = 0; i < NUMBER_OF_MESSAGES; i++) {
      assertNotNull(consumer.receive(5000));
      assertNotNull(consumer2.receive(5000));
   }

   session.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的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.ClientMessage; //导入方法依赖的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.ClientMessage; //导入方法依赖的package包/类
@Test
public void testOverflowCredits() throws Exception {
   final long retryInterval = 500;

   final double retryMultiplier = 1d;

   final int reconnectAttempts = 1;

   locator.setRetryInterval(retryInterval).setRetryIntervalMultiplier(retryMultiplier).setReconnectAttempts(reconnectAttempts).setConfirmationWindowSize(1024 * 1024).setProducerWindowSize(1000);

   final AtomicInteger count = new AtomicInteger(0);

   Interceptor intercept = new Interceptor() {

      @Override
      public boolean intercept(Packet packet, RemotingConnection connection) throws ActiveMQException {
         System.out.println("Intercept..." + packet.getClass().getName());

         if (packet instanceof SessionProducerCreditsMessage) {
            SessionProducerCreditsMessage credit = (SessionProducerCreditsMessage) packet;

            System.out.println("Credits: " + credit.getCredits());
            if (count.incrementAndGet() == 2) {
               System.out.println("Failing");
               connection.fail(new ActiveMQException(ActiveMQExceptionType.UNSUPPORTED_PACKET, "bye"));
               return false;
            }
         }
         return true;
      }
   };

   locator.addIncomingInterceptor(intercept);

   ClientSessionFactoryInternal sf = (ClientSessionFactoryInternal) createSessionFactory(locator);

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

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

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

   final int numMessages = 10;

   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().writeBytes(new byte[5000]);
      producer.send(message);
   }

   session.close();

   sf.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientMessage; //导入方法依赖的package包/类
@Test
public void testFailoverAndReconnectImmediately() throws Exception {
   NodeManager nodeManager = new InVMNodeManager(false);
   server0 = createActiveMQServer(0, server0Params, isNetty(), nodeManager);
   server2 = createBackupActiveMQServer(2, server2Params, isNetty(), 0, nodeManager);

   TransportConfiguration server0tc = new TransportConfiguration(getConnector(), server0Params, "server0tc");
   TransportConfiguration server2tc = new TransportConfiguration(getConnector(), server2Params, "server2tc");

   connectors.put(server2tc.getName(), server2tc);

   server0.getConfiguration().setConnectorConfigurations(connectors);
   server1.getConfiguration().setConnectorConfigurations(connectors);

   reconnectAttempts = 1;

   BridgeConfiguration bridgeConfiguration = createBridgeConfig();

   List<BridgeConfiguration> bridgeConfigs = new ArrayList<>();
   bridgeConfigs.add(bridgeConfiguration);
   server0.getConfiguration().setBridgeConfigurations(bridgeConfigs);

   CoreQueueConfiguration queueConfig0 = new CoreQueueConfiguration().setAddress(testAddress).setName(queueName);
   List<CoreQueueConfiguration> queueConfigs0 = new ArrayList<>();
   queueConfigs0.add(queueConfig0);
   server0.getConfiguration().setQueueConfigurations(queueConfigs0);

   CoreQueueConfiguration queueConfig1 = new CoreQueueConfiguration().setAddress(forwardAddress).setName(queueName);
   List<CoreQueueConfiguration> queueConfigs1 = new ArrayList<>();
   queueConfigs1.add(queueConfig1);
   server1.getConfiguration().setQueueConfigurations(queueConfigs1);
   server2.getConfiguration().setQueueConfigurations(queueConfigs1);

   startServers();

   BridgeReconnectTest.log.info("** failing connection");
   // Now we will simulate a failure of the bridge connection between server0 and server1
   server0.fail(true);

   waitForServerStart(server2);

   locator = addServerLocator(ActiveMQClient.createServerLocatorWithoutHA(server0tc, server2tc));

   ClientSessionFactory csf0 = addSessionFactory(locator.createSessionFactory(server2tc));

   session0 = csf0.createSession(false, true, true);

   ClientProducer prod0 = session0.createProducer(testAddress);

   ClientSessionFactory csf2 = addSessionFactory(locator.createSessionFactory(server2tc));

   session2 = csf2.createSession(false, true, true);

   ClientConsumer cons2 = session2.createConsumer(queueName);

   session2.start();

   final int numMessages = NUM_MESSAGES;

   SimpleString propKey = new SimpleString("propkey");

   for (int i = 0; i < numMessages; i++) {
      ClientMessage message = session0.createMessage(true);
      message.putIntProperty(propKey, i);

      prod0.send(message);
   }

   for (int i = 0; i < numMessages; i++) {
      ClientMessage r1 = cons2.receive(1500);
      assertNotNull(r1);
      assertEquals(i, r1.getObjectProperty(propKey));
   }
   closeServers();

   assertNoMoreConnections();
}
 

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

   AddressSettings as = new AddressSettings().setAddressFullMessagePolicy(AddressFullMessagePolicy.PAGE).setPageSizeBytes(10000).setMaxSizeBytes(20000);

   getServer(0).getAddressSettingsRepository().addMatch("queues.*", as);
   getServer(1).getAddressSettingsRepository().addMatch("queues.*", as);
   getServer(2).getAddressSettingsRepository().addMatch("queues.*", as);

   startServers(0);

   startServers(1);

   waitForTopology(getServer(0), 2);
   waitForTopology(getServer(1), 2);

   setupSessionFactory(0, isNetty());

   setupSessionFactory(1, isNetty());

   createQueue(0, "queues.testaddress", "queue0", null, true);

   createQueue(1, "queues.testaddress", "queue0", null, true);

   waitForBindings(1, "queues.testaddress", 1, 0, true);

   waitForBindings(0, "queues.testaddress", 1, 0, false);

   getServer(0).getPagingManager().getPageStore(new SimpleString("queues.testaddress")).startPaging();

   ClientSession session0 = sfs[0].createSession(true, true, 0);
   ClientProducer producer0 = session0.createProducer("queues.testaddress");

   ClientConsumer consumer0 = session0.createConsumer("queue0");
   session0.start();

   ClientSession session1 = sfs[1].createSession(true, true, 0);
   ClientConsumer consumer1 = session1.createConsumer("queue0");
   session1.start();

   for (int i = 0; i < 10; i++) {
      ClientMessage msg = session0.createMessage(true);
      msg.putIntProperty("i", i);
      // send two identical messages so they are routed on the cluster
      producer0.send(msg);
      producer0.send(msg);

      msg = consumer0.receive(5000);
      Assert.assertNotNull(msg);
      Assert.assertEquals(i, msg.getIntProperty("i").intValue());
      // msg.acknowledge(); // -- do not ack message on consumer0, to make sure the messages will be paged

      msg = consumer1.receive(5000);
      Assert.assertNotNull(msg);
      Assert.assertEquals(i, msg.getIntProperty("i").intValue());
      msg.acknowledge();
   }

   session0.close();
   session1.close();
}
 

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

   startServers();

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

   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, 4);
   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.ClientMessage; //导入方法依赖的package包/类
private ClientSession sendAndConsume(final ClientSessionFactory sf, final boolean createQueue) throws Exception {
   ClientSession session = sf.createSession(false, true, true);

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

   ClientProducer producer = session.createProducer(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(ADDRESS);

   session.start();

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

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

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

      message2.acknowledge();
   }

   ClientMessage message3 = consumer.receiveImmediate();

   consumer.close();

   assertNull(message3);

   return session;
}