Java ConsumerInfo.setSubscriptionName方法代码示例

import org.apache.activemq.command.ConsumerInfo; //导入方法依赖的package包/类
protected DemandSubscription createDemandSubscription(ConsumerInfo info) throws IOException {
    if (addToAlreadyInterestedConsumers(info)) {
        return null; // don't want this subscription added
    }
    //add our original id to ourselves
    info.addNetworkConsumerId(info.getConsumerId());

    if (info.isDurable()) {
        // set the subscriber name to something reproducible
        info.setSubscriptionName(getSubscriberName(info.getDestination()));
        // and override the consumerId with something unique so that it won't
        // be removed if the durable subscriber (at the other end) goes away
        info.setConsumerId(new ConsumerId(localSessionInfo.getSessionId(),
                           consumerIdGenerator.getNextSequenceId()));
    }
    info.setSelector(null);
    return doCreateDemandSubscription(info);
}
 

import org.apache.activemq.command.ConsumerInfo; //导入方法依赖的package包/类
@Override
public ObjectName createDurableSubscriber(String clientId, String subscriberName, String topicName,
                                          String selector) throws Exception {
    ConnectionContext context = new ConnectionContext();
    context.setBroker(safeGetBroker());
    context.setClientId(clientId);
    ConsumerInfo info = new ConsumerInfo();
    ConsumerId consumerId = new ConsumerId();
    consumerId.setConnectionId(clientId);
    consumerId.setSessionId(sessionIdCounter.incrementAndGet());
    consumerId.setValue(0);
    info.setConsumerId(consumerId);
    info.setDestination(new ActiveMQTopic(topicName));
    info.setSubscriptionName(subscriberName);
    info.setSelector(selector);
    Subscription subscription = safeGetBroker().addConsumer(context, info);
    safeGetBroker().removeConsumer(context, info);
    if (subscription != null) {
        return subscription.getObjectName();
    }
    return null;
}
 

import org.apache.activemq.command.ConsumerInfo; //导入方法依赖的package包/类
QoS onSubscribe(SUBSCRIBE command, Topic topic) throws MQTTProtocolException {
    ActiveMQDestination destination = new ActiveMQTopic(convertMQTTToActiveMQ(topic.name().toString()));

    ConsumerId id = new ConsumerId(sessionId, consumerIdGenerator.getNextSequenceId());
    ConsumerInfo consumerInfo = new ConsumerInfo(id);
    consumerInfo.setDestination(destination);
    consumerInfo.setPrefetchSize(getActiveMQSubscriptionPrefetch());
    consumerInfo.setDispatchAsync(true);
    if (!connect.cleanSession() && (connect.clientId() != null)) {
        //by default subscribers are persistent
        consumerInfo.setSubscriptionName(
            connect.clientId().toString() + topic.name().toString());
    }
    MQTTSubscription mqttSubscription = new MQTTSubscription(this, topic.qos(), consumerInfo);

    subscriptionsByConsumerId.put(id, mqttSubscription);
    mqttSubscriptionByTopic.put(topic.name(), mqttSubscription);

    sendToActiveMQ(consumerInfo, null);
    return topic.qos();
}
 

import org.apache.activemq.command.ConsumerInfo; //导入方法依赖的package包/类
/**
 * @throws IOException
 */
final void startBridge() throws IOException {
    connectionInfo = new ConnectionInfo();
    connectionInfo.setConnectionId(new ConnectionId(ID_GENERATOR.generateId()));
    connectionInfo.setClientId(clientId);
    localBroker.oneway(connectionInfo);
    remoteBroker.oneway(connectionInfo);

    sessionInfo = new SessionInfo(connectionInfo, 1);
    localBroker.oneway(sessionInfo);
    remoteBroker.oneway(sessionInfo);

    queueConsumerInfo = new ConsumerInfo(sessionInfo, 1);
    queueConsumerInfo.setDispatchAsync(dispatchAsync);
    queueConsumerInfo.setDestination(new ActiveMQQueue(destinationFilter));
    queueConsumerInfo.setPrefetchSize(prefetchSize);
    queueConsumerInfo.setPriority(ConsumerInfo.NETWORK_CONSUMER_PRIORITY);
    localBroker.oneway(queueConsumerInfo);

    producerInfo = new ProducerInfo(sessionInfo, 1);
    producerInfo.setResponseRequired(false);
    remoteBroker.oneway(producerInfo);

    if (connectionInfo.getClientId() != null) {
        topicConsumerInfo = new ConsumerInfo(sessionInfo, 2);
        topicConsumerInfo.setDispatchAsync(dispatchAsync);
        topicConsumerInfo.setSubscriptionName("topic-bridge");
        topicConsumerInfo.setRetroactive(true);
        topicConsumerInfo.setDestination(new ActiveMQTopic(destinationFilter));
        topicConsumerInfo.setPrefetchSize(prefetchSize);
        topicConsumerInfo.setPriority(ConsumerInfo.NETWORK_CONSUMER_PRIORITY);
        localBroker.oneway(topicConsumerInfo);
    }

    LOG.info("Network connection between {} and {} has been established.", localBroker, remoteBroker);
}
 

import org.apache.activemq.command.ConsumerInfo; //导入方法依赖的package包/类
public ConsumerInfo createInactiveConsumerInfo(SubscriptionInfo info) {
    ConsumerInfo rc = new ConsumerInfo();
    rc.setSelector(info.getSelector());
    rc.setSubscriptionName(info.getSubscriptionName());
    rc.setDestination(info.getSubscribedDestination());
    rc.setConsumerId(createConsumerId());
    return rc;
}
 

import org.apache.activemq.command.ConsumerInfo; //导入方法依赖的package包/类
public void testTopicConsumerOnlySeeMessagesAfterCreation() throws Exception {

      ActiveMQDestination destination = new ActiveMQTopic("TEST");

      // Setup a first connection
      StubConnection connection1 = createConnection();
      ConnectionInfo connectionInfo1 = createConnectionInfo();
      connectionInfo1.setClientId("A");
      SessionInfo sessionInfo1 = createSessionInfo(connectionInfo1);
      ProducerInfo producerInfo1 = createProducerInfo(sessionInfo1);
      connection1.send(connectionInfo1);
      connection1.send(sessionInfo1);
      connection1.send(producerInfo1);

      // Send the 1st message
      connection1.send(createMessage(producerInfo1, destination, deliveryMode));

      // Create the durable subscription.
      ConsumerInfo consumerInfo1 = createConsumerInfo(sessionInfo1, destination);
      if (durableConsumer) {
         consumerInfo1.setSubscriptionName("test");
      }
      consumerInfo1.setPrefetchSize(100);
      connection1.send(consumerInfo1);

      Message m = createMessage(producerInfo1, destination, deliveryMode);
      connection1.send(m);
      connection1.send(createMessage(producerInfo1, destination, deliveryMode));

      // Subscription should skip over the first message
      Message m2 = receiveMessage(connection1);
      assertNotNull(m2);
      assertEquals(m.getMessageId(), m2.getMessageId());
      m2 = receiveMessage(connection1);
      assertNotNull(m2);

      assertNoMessagesLeft(connection1);
   }
 

import org.apache.activemq.command.ConsumerInfo; //导入方法依赖的package包/类
@Override
protected void populateObject(Object object) throws Exception {
   super.populateObject(object);
   ConsumerInfo info = (ConsumerInfo) object;
   info.setConsumerId(createConsumerId("ConsumerId:1"));
   info.setBrowser(true);
   info.setDestination(createActiveMQDestination("Destination:2"));
   info.setPrefetchSize(1);
   info.setMaximumPendingMessageLimit(2);
   info.setDispatchAsync(false);
   info.setSelector("Selector:3");
   info.setSubscriptionName("SubcriptionName:4");
   info.setNoLocal(true);
   info.setExclusive(false);
   info.setRetroactive(true);
   info.setPriority((byte) 1);

   {
      BrokerId value[] = new BrokerId[2];
      for (int i = 0; i < 2; i++) {
         value[i] = createBrokerId("BrokerPath:5");
      }
      info.setBrokerPath(value);
   }
   info.setAdditionalPredicate(createBooleanExpression("AdditionalPredicate:6"));
   info.setNetworkSubscription(false);
   info.setOptimizedAcknowledge(true);
   info.setNoRangeAcks(false);

}
 

import org.apache.activemq.command.ConsumerInfo; //导入方法依赖的package包/类
@Override
protected void populateObject(Object object) throws Exception {
   super.populateObject(object);
   ConsumerInfo info = (ConsumerInfo) object;

   info.setConsumerId(createConsumerId("ConsumerId:1"));
   info.setBrowser(true);
   info.setDestination(createActiveMQDestination("Destination:2"));
   info.setPrefetchSize(1);
   info.setMaximumPendingMessageLimit(2);
   info.setDispatchAsync(false);
   info.setSelector("Selector:3");
   info.setSubscriptionName("SubscriptionName:4");
   info.setNoLocal(true);
   info.setExclusive(false);
   info.setRetroactive(true);
   info.setPriority((byte) 1);
   {
      BrokerId value[] = new BrokerId[2];
      for (int i = 0; i < 2; i++) {
         value[i] = createBrokerId("BrokerPath:5");
      }
      info.setBrokerPath(value);
   }
   info.setAdditionalPredicate(createBooleanExpression("AdditionalPredicate:6"));
   info.setNetworkSubscription(false);
   info.setOptimizedAcknowledge(true);
   info.setNoRangeAcks(false);
}
 

import org.apache.activemq.command.ConsumerInfo; //导入方法依赖的package包/类
/**
 * Un-marshal an object instance from the data input stream
 * 
 * @param o the object to un-marshal
 * @param dataIn the data input stream to build the object from
 * @throws IOException
 */
public void tightUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn, BooleanStream bs)
    throws IOException {
    super.tightUnmarshal(wireFormat, o, dataIn, bs);

    ConsumerInfo info = (ConsumerInfo)o;
    info.setConsumerId((org.apache.activemq.command.ConsumerId)tightUnmarsalCachedObject(wireFormat,
                                                                                         dataIn, bs));
    info.setBrowser(bs.readBoolean());
    info
        .setDestination((org.apache.activemq.command.ActiveMQDestination)tightUnmarsalCachedObject(
                                                                                                   wireFormat,
                                                                                                   dataIn,
                                                                                                   bs));
    info.setPrefetchSize(dataIn.readInt());
    info.setMaximumPendingMessageLimit(dataIn.readInt());
    info.setDispatchAsync(bs.readBoolean());
    info.setSelector(tightUnmarshalString(dataIn, bs));
    info.setSubscriptionName(tightUnmarshalString(dataIn, bs));
    info.setNoLocal(bs.readBoolean());
    info.setExclusive(bs.readBoolean());
    info.setRetroactive(bs.readBoolean());
    info.setPriority(dataIn.readByte());

    if (bs.readBoolean()) {
        short size = dataIn.readShort();
        org.apache.activemq.command.BrokerId value[] = new org.apache.activemq.command.BrokerId[size];
        for (int i = 0; i < size; i++) {
            value[i] = (org.apache.activemq.command.BrokerId)tightUnmarsalNestedObject(wireFormat,
                                                                                       dataIn, bs);
        }
        info.setBrokerPath(value);
    } else {
        info.setBrokerPath(null);
    }
    info
        .setAdditionalPredicate((org.apache.activemq.filter.BooleanExpression)tightUnmarsalNestedObject(
                                                                                                        wireFormat,
                                                                                                        dataIn,
                                                                                                        bs));
    info.setNetworkSubscription(bs.readBoolean());
    info.setOptimizedAcknowledge(bs.readBoolean());
    info.setNoRangeAcks(bs.readBoolean());

}
 

import org.apache.activemq.command.ConsumerInfo; //导入方法依赖的package包/类
/**
 * Un-marshal an object instance from the data input stream
 * 
 * @param o the object to un-marshal
 * @param dataIn the data input stream to build the object from
 * @throws IOException
 */
public void looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException {
    super.looseUnmarshal(wireFormat, o, dataIn);

    ConsumerInfo info = (ConsumerInfo)o;
    info.setConsumerId((org.apache.activemq.command.ConsumerId)looseUnmarsalCachedObject(wireFormat,
                                                                                         dataIn));
    info.setBrowser(dataIn.readBoolean());
    info
        .setDestination((org.apache.activemq.command.ActiveMQDestination)looseUnmarsalCachedObject(
                                                                                                   wireFormat,
                                                                                                   dataIn));
    info.setPrefetchSize(dataIn.readInt());
    info.setMaximumPendingMessageLimit(dataIn.readInt());
    info.setDispatchAsync(dataIn.readBoolean());
    info.setSelector(looseUnmarshalString(dataIn));
    info.setSubscriptionName(looseUnmarshalString(dataIn));
    info.setNoLocal(dataIn.readBoolean());
    info.setExclusive(dataIn.readBoolean());
    info.setRetroactive(dataIn.readBoolean());
    info.setPriority(dataIn.readByte());

    if (dataIn.readBoolean()) {
        short size = dataIn.readShort();
        org.apache.activemq.command.BrokerId value[] = new org.apache.activemq.command.BrokerId[size];
        for (int i = 0; i < size; i++) {
            value[i] = (org.apache.activemq.command.BrokerId)looseUnmarsalNestedObject(wireFormat, dataIn);
        }
        info.setBrokerPath(value);
    } else {
        info.setBrokerPath(null);
    }
    info
        .setAdditionalPredicate((org.apache.activemq.filter.BooleanExpression)looseUnmarsalNestedObject(
                                                                                                        wireFormat,
                                                                                                        dataIn));
    info.setNetworkSubscription(dataIn.readBoolean());
    info.setOptimizedAcknowledge(dataIn.readBoolean());
    info.setNoRangeAcks(dataIn.readBoolean());

}
 

import org.apache.activemq.command.ConsumerInfo; //导入方法依赖的package包/类
public void testTopicDurableConsumerHoldsPersistentMessageAfterRestart() throws Exception {

      ActiveMQDestination destination = new ActiveMQTopic("TEST");

      // Setup a first connection
      StubConnection connection1 = createConnection();
      ConnectionInfo connectionInfo1 = createConnectionInfo();
      connectionInfo1.setClientId("A");
      SessionInfo sessionInfo1 = createSessionInfo(connectionInfo1);
      ProducerInfo producerInfo1 = createProducerInfo(sessionInfo1);
      connection1.send(connectionInfo1);
      connection1.send(sessionInfo1);
      connection1.send(producerInfo1);

      // Create the durable subscription.
      ConsumerInfo consumerInfo1 = createConsumerInfo(sessionInfo1, destination);
      consumerInfo1.setSubscriptionName("test");
      consumerInfo1.setPrefetchSize(100);
      connection1.send(consumerInfo1);

      // Close the subscription.
      connection1.send(closeConsumerInfo(consumerInfo1));

      // Send the messages
      connection1.send(createMessage(producerInfo1, destination, DeliveryMode.PERSISTENT));
      connection1.send(createMessage(producerInfo1, destination, DeliveryMode.PERSISTENT));
      connection1.send(createMessage(producerInfo1, destination, DeliveryMode.PERSISTENT));
      connection1.send(createMessage(producerInfo1, destination, DeliveryMode.PERSISTENT));
      connection1.request(closeConnectionInfo(connectionInfo1));
      // Restart the broker.
      restartBroker();

      // Get a connection to the new broker.
      StubConnection connection2 = createConnection();
      ConnectionInfo connectionInfo2 = createConnectionInfo();
      connectionInfo2.setClientId("A");
      SessionInfo sessionInfo2 = createSessionInfo(connectionInfo2);
      connection2.send(connectionInfo2);
      connection2.send(sessionInfo2);

      // Re-open the subscription.
      ConsumerInfo consumerInfo2 = createConsumerInfo(sessionInfo2, destination);
      consumerInfo2.setSubscriptionName("test");
      consumerInfo2.setPrefetchSize(100);
      connection2.send(consumerInfo2);

      // The we should get the messages.
      for (int i = 0; i < 4; i++) {
         Message m2 = receiveMessage(connection2);
         assertNotNull("Did not get message " + i, m2);
      }
      assertNoMessagesLeft(connection2);
   }
 

import org.apache.activemq.command.ConsumerInfo; //导入方法依赖的package包/类
public void testTopicPersistentPreparedAcksNotLostOnRestart() throws Exception {
   ActiveMQDestination destination = new ActiveMQTopic("TryTopic");

   // Setup the producer and send the message.
   StubConnection connection = createConnection();
   ConnectionInfo connectionInfo = createConnectionInfo();
   connectionInfo.setClientId("durable");
   SessionInfo sessionInfo = createSessionInfo(connectionInfo);
   ProducerInfo producerInfo = createProducerInfo(sessionInfo);
   connection.send(connectionInfo);
   connection.send(sessionInfo);
   connection.send(producerInfo);

   // setup durable subs
   ConsumerInfo consumerInfo = createConsumerInfo(sessionInfo, destination);
   consumerInfo.setSubscriptionName("durable");
   connection.send(consumerInfo);

   final int numMessages = 4;
   for (int i = 0; i < numMessages; i++) {
      Message message = createMessage(producerInfo, destination);
      message.setPersistent(true);
      connection.send(message);
   }

   // Begin the transaction.
   XATransactionId txid = createXATransaction(sessionInfo);
   connection.send(createBeginTransaction(connectionInfo, txid));

   final int messageCount = expectedMessageCount(numMessages, destination);
   Message m = null;
   for (int i = 0; i < messageCount; i++) {
      m = receiveMessage(connection);
      assertNotNull("unexpected null on: " + i, m);
   }

   // one ack with last received, mimic a beforeEnd synchronization
   MessageAck ack = createAck(consumerInfo, m, messageCount, MessageAck.STANDARD_ACK_TYPE);
   ack.setTransactionId(txid);
   connection.send(ack);

   connection.request(createPrepareTransaction(connectionInfo, txid));

   // restart the broker.
   restartBroker();

   connection = createConnection();
   connectionInfo = createConnectionInfo();
   connectionInfo.setClientId("durable");
   connection.send(connectionInfo);

   // validate recovery
   TransactionInfo recoverInfo = new TransactionInfo(connectionInfo.getConnectionId(), null, TransactionInfo.RECOVER);
   DataArrayResponse dataArrayResponse = (DataArrayResponse) connection.request(recoverInfo);

   assertEquals("there is a prepared tx", 1, dataArrayResponse.getData().length);
   assertEquals("it matches", txid, dataArrayResponse.getData()[0]);

   sessionInfo = createSessionInfo(connectionInfo);
   connection.send(sessionInfo);
   consumerInfo = createConsumerInfo(sessionInfo, destination);
   consumerInfo.setSubscriptionName("durable");
   connection.send(consumerInfo);

   // no redelivery, exactly once semantics unless there is rollback
   m = receiveMessage(connection);
   assertNull(m);
   assertNoMessagesLeft(connection);

   connection.request(createCommitTransaction2Phase(connectionInfo, txid));

   // validate recovery complete
   dataArrayResponse = (DataArrayResponse) connection.request(recoverInfo);
   assertEquals("there are no prepared tx", 0, dataArrayResponse.getData().length);
}
 

import org.apache.activemq.command.ConsumerInfo; //导入方法依赖的package包/类
public void testTopicDurableSubscriptionCanBeRestored() throws Exception {

      ActiveMQDestination destination = new ActiveMQTopic("TEST");

      // Setup a first connection
      StubConnection connection1 = createConnection();
      ConnectionInfo connectionInfo1 = createConnectionInfo();
      connectionInfo1.setClientId("clientid1");
      SessionInfo sessionInfo1 = createSessionInfo(connectionInfo1);
      ProducerInfo producerInfo1 = createProducerInfo(sessionInfo1);
      connection1.send(connectionInfo1);
      connection1.send(sessionInfo1);
      connection1.send(producerInfo1);

      ConsumerInfo consumerInfo1 = createConsumerInfo(sessionInfo1, destination);
      consumerInfo1.setPrefetchSize(100);
      consumerInfo1.setSubscriptionName("test");
      connection1.send(consumerInfo1);

      // Send the messages
      connection1.send(createMessage(producerInfo1, destination, DeliveryMode.PERSISTENT));
      connection1.send(createMessage(producerInfo1, destination, DeliveryMode.PERSISTENT));
      connection1.send(createMessage(producerInfo1, destination, DeliveryMode.PERSISTENT));
      connection1.request(createMessage(producerInfo1, destination, DeliveryMode.PERSISTENT));

      // Get the messages
      Message m = null;
      for (int i = 0; i < 2; i++) {
         m = receiveMessage(connection1);
         assertNotNull(m);
      }
      // Ack the last message.
      connection1.send(createAck(consumerInfo1, m, 2, MessageAck.STANDARD_ACK_TYPE));
      // Close the connection.
      connection1.request(closeConnectionInfo(connectionInfo1));
      connection1.stop();

      // Setup a second connection
      StubConnection connection2 = createConnection();
      ConnectionInfo connectionInfo2 = createConnectionInfo();
      connectionInfo2.setClientId("clientid1");
      SessionInfo sessionInfo2 = createSessionInfo(connectionInfo2);
      ConsumerInfo consumerInfo2 = createConsumerInfo(sessionInfo2, destination);
      consumerInfo2.setPrefetchSize(100);
      consumerInfo2.setSubscriptionName("test");

      connection2.send(connectionInfo2);
      connection2.send(sessionInfo2);
      connection2.send(consumerInfo2);

      // Get the rest of the messages
      for (int i = 0; i < 2; i++) {
         Message m1 = receiveMessage(connection2);
         assertNotNull("m1 is null for index: " + i, m1);
      }
      assertNoMessagesLeft(connection2);
   }
 

import org.apache.activemq.command.ConsumerInfo; //导入方法依赖的package包/类
public void testTopicRetroactiveConsumerSeeMessagesBeforeCreation() throws Exception {

      ActiveMQDestination destination = new ActiveMQTopic("TEST");

      // Setup a first connection
      StubConnection connection1 = createConnection();
      ConnectionInfo connectionInfo1 = createConnectionInfo();
      connectionInfo1.setClientId("A");
      SessionInfo sessionInfo1 = createSessionInfo(connectionInfo1);
      ProducerInfo producerInfo1 = createProducerInfo(sessionInfo1);
      connection1.send(connectionInfo1);
      connection1.send(sessionInfo1);
      connection1.send(producerInfo1);

      // Send the messages
      Message m = createMessage(producerInfo1, destination, deliveryMode);
      connection1.send(m);

      // Create the durable subscription.
      ConsumerInfo consumerInfo1 = createConsumerInfo(sessionInfo1, destination);
      if (durableConsumer) {
         consumerInfo1.setSubscriptionName("test");
      }
      consumerInfo1.setPrefetchSize(100);
      consumerInfo1.setRetroactive(true);
      connection1.send(consumerInfo1);

      connection1.send(createMessage(producerInfo1, destination, deliveryMode));
      connection1.request(createMessage(producerInfo1, destination, deliveryMode));

      // the behavior is VERY dependent on the recovery policy used.
      // But the default broker settings try to make it as consistent as
      // possible

      // Subscription should see all messages sent.
      Message m2 = receiveMessage(connection1);
      assertNotNull(m2);
      assertEquals(m.getMessageId(), m2.getMessageId());
      for (int i = 0; i < 2; i++) {
         m2 = receiveMessage(connection1);
         assertNotNull(m2);
      }

      assertNoMessagesLeft(connection1);
   }