Java ClientSession.createMessage方法代码示例

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的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.ClientSession; //导入方法依赖的package包/类
@Test
public void testTotalMessageCount() throws Exception {
   String random1 = RandomUtil.randomString();
   String random2 = RandomUtil.randomString();

   ActiveMQServerControl serverControl = createManagementControl();

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

   session.createQueue(random1, RoutingType.ANYCAST, random1);
   session.createQueue(random2, RoutingType.ANYCAST, random2);

   ClientProducer producer1 = session.createProducer(random1);
   ClientProducer producer2 = session.createProducer(random2);
   ClientMessage message = session.createMessage(true);
   producer1.send(message);
   producer2.send(message);

   session.commit();

   // flush executors on queues so we can get precise number of messages
   Queue queue1 = server.locateQueue(SimpleString.toSimpleString(random1));
   queue1.flushExecutor();
   Queue queue2 = server.locateQueue(SimpleString.toSimpleString(random1));
   queue2.flushExecutor();

   assertEquals(2, serverControl.getTotalMessageCount());

   session.deleteQueue(random1);
   session.deleteQueue(random2);

   session.close();

   locator.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
/**
 * @param numberOfMessages
 * @param numberOfBytes
 * @param delayDelivery
 * @param session
 * @param producer
 * @throws Exception
 * @throws IOException
 * @throws ActiveMQException
 */
private void sendMessages(final int numberOfMessages,
                          final long numberOfBytes,
                          final long delayDelivery,
                          final ClientSession session,
                          final ClientProducer producer) throws Exception {
   LargeMessageTestBase.log.debug("NumberOfBytes = " + numberOfBytes);
   for (int i = 0; i < numberOfMessages; i++) {
      ClientMessage message = session.createMessage(true);

      // If the test is using more than 1M, we will only use the Streaming, as it require too much memory from the
      // test
      if (numberOfBytes > 1024 * 1024 || i % 2 == 0) {
         LargeMessageTestBase.log.debug("Sending message (stream)" + i);
         message.setBodyInputStream(ActiveMQTestBase.createFakeLargeStream(numberOfBytes));
      } else {
         LargeMessageTestBase.log.debug("Sending message (array)" + i);
         byte[] bytes = new byte[(int) numberOfBytes];
         for (int j = 0; j < bytes.length; j++) {
            bytes[j] = ActiveMQTestBase.getSamplebyte(j);
         }
         message.getBodyBuffer().writeBytes(bytes);
      }
      message.putIntProperty(new SimpleString("counter-message"), i);
      if (delayDelivery > 0) {
         long time = System.currentTimeMillis();
         message.putLongProperty(new SimpleString("original-time"), time);
         message.putLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME, time + delayDelivery);

         producer.send(message);
      } else {
         producer.send(message);
      }
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
protected void doSendManagementMessage(final String user,
                                       final String password,
                                       final boolean expectSuccess) throws Exception {
   ServerLocator locator = createInVMNonHALocator();
   ClientSessionFactory sf = locator.createSessionFactory();
   try {
      ClientSession session = null;
      if (user == null) {
         session = sf.createSession(false, true, true);
      } else {
         session = sf.createSession(user, password, false, true, true, false, 1);
      }

      session.start();

      ClientRequestor requestor = new ClientRequestor(session, ActiveMQDefaultConfiguration.getDefaultManagementAddress());

      ClientMessage mngmntMessage = session.createMessage(false);
      ManagementHelper.putAttribute(mngmntMessage, ResourceNames.BROKER, "started");
      ClientMessage reply = requestor.request(mngmntMessage, 500);
      if (expectSuccess) {
         Assert.assertNotNull(reply);
         Assert.assertTrue((Boolean) ManagementHelper.getResult(reply));
      } else {
         Assert.assertNull(reply);
      }

      requestor.close();
   } catch (Exception e) {
      if (expectSuccess) {
         Assert.fail("got unexpected exception " + e.getClass() + ": " + e.getMessage());
         e.printStackTrace();
      }
   } finally {
      sf.close();
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testSubscribeWithAutoAckAndHyphenatedSelector() throws Exception {
   conn.connect(defUser, defPass);
   subscribe(conn, null, Stomp.Headers.Subscribe.AckModeValues.AUTO, null, "hyphenated_props:foo-bar = 'zzz'");

   ServerLocator serverLocator = addServerLocator(ActiveMQClient.createServerLocator("vm://0"));
   ClientSessionFactory clientSessionFactory = serverLocator.createSessionFactory();
   ClientSession clientSession = clientSessionFactory.createSession(true, true);
   ClientProducer producer = clientSession.createProducer(getQueuePrefix() + getQueueName());

   ClientMessage ignoredMessage = clientSession.createMessage(false);
   ignoredMessage.putStringProperty("foo-bar", "1234");
   ignoredMessage.getBodyBuffer().writeNullableSimpleString(SimpleString.toSimpleString("Ignored message"));

   ClientMessage realMessage = clientSession.createMessage(false);
   realMessage.putStringProperty("foo-bar", "zzz");
   realMessage.getBodyBuffer().writeNullableSimpleString(SimpleString.toSimpleString("Real message"));

   producer.send(ignoredMessage);
   producer.send(realMessage);


   ClientStompFrame frame = conn.receiveFrame(10000);
   Assert.assertEquals(Stomp.Responses.MESSAGE, frame.getCommand());
   Assert.assertTrue("Should have received the real message but got: " + frame, frame.getBody().equals("Real message"));

   conn.disconnect();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
public void sendMessages(String queueName, int num) throws ActiveMQException {
   ClientSession session = sessionFactory.createSession();
   ClientProducer producer = session.createProducer(queueName);
   for (int i = 0; i < num; i++) {
      ClientMessage m = session.createMessage(true);
      m.putStringProperty("bridge-message", "hello " + index);
      index++;
      producer.send(m);
   }
   session.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
/**
 * @param session
 * @param producer
 * @throws Exception
 */
private void sendMessage(ClientSession session, ClientProducer producer, String color, String msg) throws Exception {
   ClientMessage anyMessage = session.createMessage(true);
   anyMessage.putStringProperty("color", color);
   anyMessage.putStringProperty("value", msg);
   producer.send(anyMessage);
   session.commit();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
private ClientMessage createDurableMessage(final ClientSession session, final String body) {
   ClientMessage message = session.createMessage(ActiveMQTextMessage.TYPE, true, 0, System.currentTimeMillis(), (byte) 1);
   message.getBodyBuffer().writeString(body);
   return message;
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test(timeout = 120000)
public void testTimeoutOnFailover() throws Exception {
   locator.setCallTimeout(1000).setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setAckBatchSize(0).setReconnectAttempts(300).setRetryInterval(100);

   if (nodeManager instanceof InVMNodeManager) {
      ((InVMNodeManager) nodeManager).failoverPause = 500L;
   }

   ClientSessionFactoryInternal sf1 = (ClientSessionFactoryInternal) createSessionFactory(locator);

   final ClientSession session = createSession(sf1, true, true);

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

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

   final CountDownLatch latch = new CountDownLatch(10);
   final CountDownLatch latchFailed = new CountDownLatch(1);

   Runnable r = new Runnable() {
      @Override
      public void run() {
         for (int i = 0; i < 500; i++) {
            ClientMessage message = session.createMessage(true);
            message.putIntProperty("counter", i);
            try {
               System.out.println("Sent " + i);
               producer.send(message);
               if (i < 10) {
                  latch.countDown();
                  if (latch.getCount() == 0) {
                     latchFailed.await(10, TimeUnit.SECONDS);
                  }
               }
            } catch (Exception e) {
               // this is our retry
               try {
                  if (!producer.isClosed())
                     producer.send(message);
               } catch (ActiveMQException e1) {
                  e1.printStackTrace();
               }
            }
         }
      }
   };
   Thread t = new Thread(r);
   t.start();
   Assert.assertTrue("latch released", latch.await(10, TimeUnit.SECONDS));
   crash(session);
   latchFailed.countDown();
   t.join(30000);
   if (t.isAlive()) {
      t.interrupt();
      Assert.fail("Thread still alive");
   }
   Assert.assertTrue(backupServer.getServer().waitForActivation(5, TimeUnit.SECONDS));
   ClientConsumer consumer = session.createConsumer(FailoverTestBase.ADDRESS);
   session.start();
   for (int i = 0; i < 500; i++) {
      ClientMessage m = consumer.receive(1000);
      Assert.assertNotNull("message #=" + i, m);
      // assertEquals(i, m.getIntProperty("counter").intValue());
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testHugeStreamingSpacesCompressed() throws Exception {
   final long messageSize = 1024L * 1024L;

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

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

   server.start();

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

   ClientSessionFactory sf = createSessionFactory(locator);

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

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

   ClientProducer producer = session.createProducer(ADDRESS);

   ClientMessage clientMessage = session.createMessage(true);

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

      private boolean closed = false;

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

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

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

   producer.send(clientMessage);

   session.commit();

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

   session.start();

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

   final AtomicLong numberOfSpaces = new AtomicLong();

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

   assertEquals(messageSize, numberOfSpaces.get());

   msg1.acknowledge();

   session.commit();

   session.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
public void doTestStressSend(final boolean netty) throws Exception {
   ActiveMQServer server = createServer(false, netty);
   server.start();
   ServerLocator locator = createNonHALocator(netty);
   ClientSessionFactory sf = createSessionFactory(locator);

   ClientSession session = null;

   final int batchSize = 2000;

   final int numberOfMessages = 100000;

   try {
      server.start();

      session = sf.createSession(false, false);

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

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

      ClientMessage message = session.createMessage(false);

      message.getBodyBuffer().writeBytes(new byte[1024]);

      for (int i = 0; i < numberOfMessages; i++) {
         producer.send(message);
         if (i % batchSize == 0) {
            System.out.println("Sent " + i);
            session.commit();
         }
      }

      session.commit();

      session.close();

      session = sf.createSession(false, false);

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

      session.start();

      for (int i = 0; i < numberOfMessages; i++) {
         ClientMessage msg = consumer.receive(5000);
         Assert.assertNotNull(msg);
         msg.acknowledge();

         if (i % batchSize == 0) {
            System.out.println("Consumed " + i);
            session.commit();
         }
      }

      session.commit();
   } finally {
      if (session != null) {
         try {
            sf.close();
            session.close();
         } catch (Exception e) {
            e.printStackTrace();
         }
      }
      locator.close();
      server.stop();
   }

}
 

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包/类
private ClientMessage createMessage(final ClientSession session, final int i) {
   ClientMessage message = session.createMessage(false);

   message.putIntProperty(propKey, i);

   return message;
}
 

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

      AddressInfo addressInfo = new AddressInfo(new SimpleString(consumeAddress));
      addressInfo.addRoutingType(RoutingType.ANYCAST);

      server.addOrUpdateAddressInfo(addressInfo);
      Queue q1 = server.createQueue(new SimpleString(consumeAddress), RoutingType.ANYCAST, new SimpleString(consumeAddress + ".1"), null, true, false, Queue.MAX_CONSUMERS_UNLIMITED, false, true);
      Queue q2 = server.createQueue(new SimpleString(consumeAddress), RoutingType.ANYCAST, new SimpleString(consumeAddress + ".2"), null, true, false, Queue.MAX_CONSUMERS_UNLIMITED, false, true);

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

      int count = 0;
      count = (consumer1.receive(1000) == null) ? count : count + 1;
      count = (consumer2.receive(1000) == null) ? count : count + 1;
      assertEquals(1, count);

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

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test(timeout = 120000)
public void testBackupServerNotRemoved() throws Exception {
   // HORNETQ-720 Disabling test for replicating backups.
   if (!(backupServer.getServer().getHAPolicy() instanceof SharedStoreSlavePolicy)) {
      return;
   }
   locator.setFailoverOnInitialConnection(true);
   createSessionFactory();

   ClientSession session = sendAndConsume(sf, true);
   CountDownSessionFailureListener listener = new CountDownSessionFailureListener(session);

   session.addFailureListener(listener);

   backupServer.stop();

   liveServer.crash();

   // To reload security or other settings that are read during startup
   beforeRestart(backupServer);

   backupServer.start();

   Assert.assertTrue("session failure listener", listener.getLatch().await(5, TimeUnit.SECONDS));

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

   ClientMessage message = session.createMessage(true);

   setBody(0, message);

   producer.send(message);
}