Java ClientSession.QueueQuery方法代码示例

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Path("/{queue-name}")
public synchronized QueueResource findQueue(@PathParam("queue-name") String name) throws Exception {
   QueueResource queue = queues.get(name);
   if (queue == null) {
      String queueName = name;
      ClientSession session = manager.getSessionFactory().createSession(false, false, false);
      try {
         ClientSession.QueueQuery query = session.queueQuery(new SimpleString(queueName));
         if (!query.isExists()) {
            throw new WebApplicationException(Response.status(404).type("text/plain").entity("Queue '" + name + "' does not exist").build());
         }
         DestinationSettings queueSettings = manager.getDefaultSettings();
         boolean defaultDurable = queueSettings.isDurableSend() || query.isDurable();

         queue = createQueueResource(queueName, defaultDurable, queueSettings.getConsumerSessionTimeoutSeconds(), queueSettings.isDuplicatesAllowed());
      } finally {
         try {
            session.close();
         } catch (ActiveMQException e) {
         }
      }
   }
   return queue;
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
public void deploy(QueueDeployment queueDeployment) throws Exception {
   if (!started) {
      throw new Exception("You must start() this class instance before deploying");
   }
   String queueName = queueDeployment.getName();
   try (ClientSession session = sessionFactory.createSession(false, false, false)) {
      ClientSession.AddressQuery query = session.addressQuery(SimpleString.toSimpleString(queueName));
      if (!query.isExists()) {
         session.createAddress(SimpleString.toSimpleString(queueName), RoutingType.ANYCAST, true);
         session.createQueue(SimpleString.toSimpleString(queueName), RoutingType.ANYCAST, SimpleString.toSimpleString(queueName), queueDeployment.isDurableSend());
      } else {
         ClientSession.QueueQuery qquery = session.queueQuery(SimpleString.toSimpleString(queueName));
         if (!qquery.isExists()) {
            session.createQueue(SimpleString.toSimpleString(queueName), RoutingType.ANYCAST, SimpleString.toSimpleString(queueName), queueDeployment.isDurableSend());
         }
      }
   }

   destination.createQueueResource(queueName, queueDeployment.isDurableSend(), queueDeployment.getConsumerSessionTimeoutSeconds(), queueDeployment.isDuplicatesAllowed());

}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
public void testDuplicate() throws Exception {
   ActiveMQDestination queue = (ActiveMQDestination) session.createQueue("TEST,TEST");
   for (int i = 0; i < data.length; i++) {
      Message message = createMessage(i);
      configureMessage(message);
      if (verbose) {
         LOG.info("About to send a message: " + message + " with text: " + data[i]);
      }
      producer.send(queue, message);
   }

   Thread.sleep(200); // wait for messages to be queue;

   try (ServerLocator locator = ServerLocatorImpl.newLocator("tcp://localhost:61616");
        ClientSessionFactory factory = locator.createSessionFactory();
        ClientSession session = factory.createSession()) {
      ClientSession.QueueQuery query = session.queueQuery(new SimpleString("TEST"));
      assertNotNull(query);
      assertEquals(data.length, query.getMessageCount());
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@POST
@Consumes("application/activemq.jms.queue+xml")
public Response createJmsQueue(@Context UriInfo uriInfo, Document document) {
   ActiveMQRestLogger.LOGGER.debug("Handling POST request for \"" + uriInfo.getPath() + "\"");

   try {
      JMSQueueConfiguration queue = FileJMSConfiguration.parseQueueConfiguration(document.getDocumentElement());
      ActiveMQQueue activeMQQueue = ActiveMQDestination.createQueue(queue.getName());
      String queueName = activeMQQueue.getAddress();
      ClientSession session = manager.getSessionFactory().createSession(false, false, false);
      try {

         ClientSession.QueueQuery query = session.queueQuery(new SimpleString(queueName));
         if (!query.isExists()) {
            if (queue.getSelector() != null) {
               session.createQueue(queueName, queueName, queue.getSelector(), queue.isDurable());
            } else {
               session.createQueue(queueName, queueName, queue.isDurable());
            }

         } else {
            throw new WebApplicationException(Response.status(412).type("text/plain").entity("Queue already exists.").build());
         }
      } finally {
         try {
            session.close();
         } catch (Exception ignored) {
         }
      }
      URI uri = uriInfo.getRequestUriBuilder().path(queueName).build();
      return Response.created(uri).build();
   } catch (Exception e) {
      if (e instanceof WebApplicationException)
         throw (WebApplicationException) e;
      throw new WebApplicationException(e, Response.serverError().type("text/plain").entity("Failed to create queue.").build());
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
private void bindQueue() throws Exception {
   String queueName = "";
   String address = "";
   String filter = "";
   String routingType = "";

   for (int i = 0; i < reader.getAttributeCount(); i++) {
      String attributeName = reader.getAttributeLocalName(i);
      switch (attributeName) {
         case XmlDataConstants.QUEUE_BINDING_ADDRESS:
            address = reader.getAttributeValue(i);
            break;
         case XmlDataConstants.QUEUE_BINDING_NAME:
            queueName = reader.getAttributeValue(i);
            break;
         case XmlDataConstants.QUEUE_BINDING_FILTER_STRING:
            filter = reader.getAttributeValue(i);
            break;
         case XmlDataConstants.QUEUE_BINDING_ROUTING_TYPE:
            routingType = reader.getAttributeValue(i);
            break;
      }
   }

   ClientSession.QueueQuery queueQuery = session.queueQuery(new SimpleString(queueName));

   if (!queueQuery.isExists()) {
      session.createQueue(address, RoutingType.valueOf(routingType), queueName, filter, true);
      if (logger.isDebugEnabled()) {
         logger.debug("Binding queue(name=" + queueName + ", address=" + address + ", filter=" + filter + ")");
      }
   } else {
      if (logger.isDebugEnabled()) {
         logger.debug("Binding " + queueName + " already exists so won't re-bind.");
      }
   }

   addressMap.put(queueName, address);
}
 

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

   session.createQueue("addressName1", RoutingType.MULTICAST, "queueName1", true);
   session.createQueue("addressName1", RoutingType.MULTICAST, "queueName2", "bob", true);

   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 = createSessionFactory(locator);
   session = factory.createSession(false, true, true);

   ByteArrayInputStream xmlInputStream = new ByteArrayInputStream(xmlOutputStream.toByteArray());
   XmlDataImporter xmlDataImporter = new XmlDataImporter();
   xmlDataImporter.validate(xmlInputStream);
   xmlInputStream.reset();
   xmlDataImporter.process(xmlInputStream, session);

   ClientSession.QueueQuery queueQuery = session.queueQuery(new SimpleString("queueName1"));

   assertEquals("addressName1", queueQuery.getAddress().toString());
   assertNull(queueQuery.getFilterString());

   queueQuery = session.queueQuery(new SimpleString("queueName2"));

   assertEquals("addressName1", queueQuery.getAddress().toString());
   assertEquals("bob", queueQuery.getFilterString().toString());
   assertEquals(true, queueQuery.isDurable());
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
private boolean checkQueueFromInternalAddress(String queue) throws JMSException, ActiveMQException {
   try (Connection coreConn = coreCf.createConnection()) {
      ActiveMQSession session = (ActiveMQSession) coreConn.createSession();
      ClientSession coreSession = session.getCoreSession();
      ClientSession.QueueQuery query = coreSession.queueQuery(new SimpleString(queue));
      assertTrue("Queue doesn't exist: " + queue, query.isExists());
      SimpleString qAddr = query.getAddress();
      return qAddr.toString().startsWith(AdvisorySupport.ADVISORY_TOPIC_PREFIX);
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Override
public ClientSession.QueueQuery queueQuery(final SimpleString queueName) throws ActiveMQException {
   SessionQueueQueryMessage request = new SessionQueueQueryMessage(queueName);
   SessionQueueQueryResponseMessage response = (SessionQueueQueryResponseMessage) getSessionChannel().sendBlocking(request, PacketImpl.SESS_QUEUEQUERY_RESP);

   return response.toQueueQuery();
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Test
public void testFailure() throws Exception {
   try {
      String testName = "testFailure";
      startup();
      deployTopic(testName);

      ClientRequest request = new ClientRequest(generateURL("/topics/" + testName));

      ClientResponse<?> response = request.head();
      response.releaseConnection();
      Assert.assertEquals(200, response.getStatus());
      Link sender = MessageTestBase.getLinkByTitle(manager.getQueueManager().getLinkStrategy(), response, "create");
      System.out.println("create: " + sender);
      Link pushSubscriptions = MessageTestBase.getLinkByTitle(manager.getQueueManager().getLinkStrategy(), response, "push-subscriptions");
      System.out.println("push subscriptions: " + pushSubscriptions);

      PushTopicRegistration reg = new PushTopicRegistration();
      reg.setDurable(true);
      XmlLink target = new XmlLink();
      target.setHref("http://localhost:3333/error");
      target.setRelationship("uri");
      reg.setTarget(target);
      reg.setDisableOnFailure(true);
      reg.setMaxRetries(3);
      reg.setRetryWaitMillis(10);
      response = pushSubscriptions.request().body("application/xml", reg).post();
      Assert.assertEquals(201, response.getStatus());
      Link pushSubscription = response.getLocationLink();
      response.releaseConnection();

      ClientResponse<?> res = sender.request().body("text/plain", Integer.toString(1)).post();
      res.releaseConnection();
      Assert.assertEquals(201, res.getStatus());

      Thread.sleep(5000);

      response = pushSubscription.request().get();
      PushTopicRegistration reg2 = response.getEntity(PushTopicRegistration.class);
      response.releaseConnection();
      Assert.assertEquals(reg.isDurable(), reg2.isDurable());
      Assert.assertEquals(reg.getTarget().getHref(), reg2.getTarget().getHref());
      Assert.assertFalse(reg2.isEnabled());
      response.releaseConnection();

      String destination = reg2.getDestination();
      ClientSession session = manager.getQueueManager().getSessionFactory().createSession(false, false, false);
      ClientSession.QueueQuery query = session.queueQuery(new SimpleString(destination));
      Assert.assertFalse(query.isExists());

      manager.getQueueManager().getPushStore().removeAll();
   } finally {
      shutdown();
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Override
public ClientSession.QueueQuery getQueueInfo() {
   return null;
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
public ClientSession.QueueQuery toQueueQuery() {
   return new QueueQueryImpl(isDurable(), isTemporary(), getConsumerCount(), getMessageCount(), getFilterString(), getAddress(), getName(), isExists());
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Override
public ClientSession.QueueQuery toQueueQuery() {
   return new QueueQueryImpl(isDurable(), isTemporary(), getConsumerCount(), getMessageCount(), getFilterString(), getAddress(), getName(), isExists(), isAutoCreateQueues());
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Override
public ClientSession.QueueQuery toQueueQuery() {
   return new QueueQueryImpl(isDurable(), isTemporary(), getConsumerCount(), getMessageCount(), getFilterString(), getAddress(), getName(), isExists(), isAutoCreateQueues(), getMaxConsumers(), isAutoCreated(), isPurgeOnNoConsumers(), getRoutingType());
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
public ClientConsumerImpl(final ClientSessionInternal session,
                          final ConsumerContext consumerContext,
                          final SimpleString queueName,
                          final SimpleString filterString,
                          final boolean browseOnly,
                          final int clientWindowSize,
                          final int ackBatchSize,
                          final TokenBucketLimiter rateLimiter,
                          final Executor executor,
                          final Executor flowControlExecutor,
                          final SessionContext sessionContext,
                          final ClientSession.QueueQuery queueInfo,
                          final ClassLoader contextClassLoader) {
   this.consumerContext = consumerContext;

   this.queueName = queueName;

   this.filterString = filterString;

   this.browseOnly = browseOnly;

   this.sessionContext = sessionContext;

   this.session = session;

   this.rateLimiter = rateLimiter;

   sessionExecutor = executor;

   this.clientWindowSize = clientWindowSize;

   this.ackBatchSize = ackBatchSize;

   this.queueInfo = queueInfo;

   this.contextClassLoader = contextClassLoader;

   this.flowControlExecutor = flowControlExecutor;

   if (logger.isTraceEnabled()) {
      logger.trace(this + ":: being created at", new Exception("trace"));
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientSession; //导入方法依赖的package包/类
@Override
public ClientSession.QueueQuery getQueueInfo() {
   return queueInfo;
}