Java TopicSubscriber.receive方法代码示例

import javax.jms.TopicSubscriber; //导入方法依赖的package包/类
@Test(timeout = 60000)
public void testSendAndReceiveOnTopic() throws Exception {
   Connection connection = createConnection("myClientId");

   try {
      TopicSession session = (TopicSession) connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
      Topic topic = session.createTopic(getTopicName());
      TopicSubscriber consumer = session.createSubscriber(topic);
      TopicPublisher producer = session.createPublisher(topic);

      TextMessage message = session.createTextMessage("test-message");
      producer.send(message);

      producer.close();
      connection.start();

      message = (TextMessage) consumer.receive(1000);

      assertNotNull(message);
      assertNotNull(message.getText());
      assertEquals("test-message", message.getText());
   } finally {
      connection.close();
   }
}
 

import javax.jms.TopicSubscriber; //导入方法依赖的package包/类
private Message collectMessagesFromDurableSubscriptionForOneMinute() throws Exception {
   ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("vm://" + brokerName);
   TopicConnection connection = connectionFactory.createTopicConnection();

   connection.setClientID(clientID);
   TopicSession topicSession = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
   Topic topic = topicSession.createTopic(topicName);
   connection.start();
   TopicSubscriber subscriber = topicSession.createDurableSubscriber(topic, durableSubName);
   LOG.info("About to receive messages");
   Message message = subscriber.receive(120000);
   subscriber.close();
   connection.close();
   LOG.info("collectMessagesFromDurableSubscriptionForOneMinute done");

   return message;
}
 

import javax.jms.TopicSubscriber; //导入方法依赖的package包/类
/**
 * Topics shouldn't hold on to messages when the non-durable subscribers close
 */
@Test
public void testPersistentMessagesForTopicDropped2() throws Exception {
   TopicConnection topicConn = createTopicConnection();
   topicConn.start();
   TopicSession sess = topicConn.createTopicSession(true, 0);
   TopicPublisher pub = sess.createPublisher(ActiveMQServerTestCase.topic1);
   TopicSubscriber sub = sess.createSubscriber(ActiveMQServerTestCase.topic1);
   pub.setDeliveryMode(DeliveryMode.PERSISTENT);

   Message m = sess.createTextMessage("testing123");
   pub.publish(m);
   sess.commit();

   // receive but rollback
   TextMessage m2 = (TextMessage) sub.receive(3000);

   ProxyAssertSupport.assertNotNull(m2);
   ProxyAssertSupport.assertEquals("testing123", m2.getText());

   sess.rollback();

   topicConn.close();

   checkEmpty(ActiveMQServerTestCase.topic1);
}
 

import javax.jms.TopicSubscriber; //导入方法依赖的package包/类
public void testQueueReceiversAndTopicSubscriber() throws Exception
{
    Queue queue = new AMQAnyDestination("ADDR:my-queue; {create: always}");
    Topic topic = new AMQAnyDestination("ADDR:amq.topic/test");
    
    QueueSession qSession = ((AMQConnection)_connection).createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
    QueueReceiver receiver = qSession.createReceiver(queue);
    
    TopicSession tSession = ((AMQConnection)_connection).createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
    TopicSubscriber sub = tSession.createSubscriber(topic);
    
    Session ssn = _connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    MessageProducer prod1 = ssn.createProducer(ssn.createQueue("ADDR:my-queue"));
    prod1.send(ssn.createTextMessage("test1"));
    
    MessageProducer prod2 = ssn.createProducer(ssn.createTopic("ADDR:amq.topic/test"));
    prod2.send(ssn.createTextMessage("test2"));
    
    Message msg1 = receiver.receive();
    assertNotNull(msg1);
    assertEquals("test1",((TextMessage)msg1).getText());
    
    Message msg2 = sub.receive();
    assertNotNull(msg2);
    assertEquals("test2",((TextMessage)msg2).getText());  
}
 

import javax.jms.TopicSubscriber; //导入方法依赖的package包/类
@Parameters({ "broker-port"})
@Test
public void testSubscriberPublisher(String port) throws Exception {
    String topicName = "MyTopic1";
    int numberOfMessages = 100;

    InitialContext initialContext = ClientHelper
            .getInitialContextBuilder("admin", "admin", "localhost", port)
            .withTopic(topicName)
            .build();

    TopicConnectionFactory connectionFactory
            = (TopicConnectionFactory) initialContext.lookup(ClientHelper.CONNECTION_FACTORY);
    TopicConnection connection = connectionFactory.createTopicConnection();
    connection.start();

    // Initialize subscriber
    TopicSession subscriberSession = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
    Topic subscriberDestination = (Topic) initialContext.lookup(topicName);
    TopicSubscriber subscriber = subscriberSession.createSubscriber(subscriberDestination);

    // publish 100 messages
    TopicSession producerSession = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
    TopicPublisher producer = producerSession.createPublisher(subscriberDestination);

    for (int i = 0; i < numberOfMessages; i++) {
        producer.publish(producerSession.createTextMessage("Test message " + i));
    }

    producerSession.close();

    for (int i = 0; i < numberOfMessages; i++) {
        Message message = subscriber.receive(1000);
        Assert.assertNotNull(message, "Message #" + i + " was not received");
    }

    connection.close();
}
 

import javax.jms.TopicSubscriber; //导入方法依赖的package包/类
@Test(timeout = 60000)
public void testSendAndReceiveOnAutoCreatedTopic() throws Exception {
   Connection connection = createConnection("myClientId");
   String topicName = UUID.randomUUID().toString();
   SimpleString simpleTopicName = SimpleString.toSimpleString(topicName);

   try {
      TopicSession session = (TopicSession) connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
      Topic topic = session.createTopic(topicName);
      TopicPublisher producer = session.createPublisher(topic);

      TextMessage message = session.createTextMessage("test-message");
      // this will auto-create the address, but not the subscription queue
      producer.send(message);

      assertNotNull(server.getAddressInfo(simpleTopicName));
      assertEquals(RoutingType.MULTICAST, server.getAddressInfo(simpleTopicName).getRoutingType());
      assertTrue(server.getAddressInfo(simpleTopicName).isAutoCreated());
      assertTrue(server.getPostOffice().getBindingsForAddress(simpleTopicName).getBindings().isEmpty());

      // this will auto-create the subscription queue
      TopicSubscriber consumer = session.createSubscriber(topic);
      assertFalse(server.getPostOffice().getBindingsForAddress(simpleTopicName).getBindings().isEmpty());
      producer.send(message);

      producer.close();
      connection.start();

      message = (TextMessage) consumer.receive(1000);

      assertNotNull(message);
      assertNotNull(message.getText());
      assertEquals("test-message", message.getText());
      consumer.close();
      assertTrue(server.getPostOffice().getBindingsForAddress(simpleTopicName).getBindings().isEmpty());
   } finally {
      connection.close();
   }
}
 

import javax.jms.TopicSubscriber; //导入方法依赖的package包/类
@Test(timeout = 60000)
public void testSendWithMultipleReceiversOnTopic() throws Exception {
   Connection connection = createConnection();

   try {
      TopicSession session = (TopicSession) connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
      Topic topic = session.createTopic(getTopicName());
      TopicSubscriber consumer1 = session.createSubscriber(topic);
      TopicSubscriber consumer2 = session.createSubscriber(topic);
      TopicPublisher producer = session.createPublisher(topic);

      TextMessage message = session.createTextMessage("test-message");
      producer.send(message);

      producer.close();
      connection.start();

      message = (TextMessage) consumer1.receive(1000);

      assertNotNull(message);
      assertNotNull(message.getText());
      assertEquals("test-message", message.getText());

      message = (TextMessage) consumer2.receive(1000);

      assertNotNull(message);
      assertNotNull(message.getText());
      assertEquals("test-message", message.getText());
   } finally {
      connection.close();
   }
}
 

import javax.jms.TopicSubscriber; //导入方法依赖的package包/类
@Test(timeout = 60000)
public void testMultipleDurableConsumersSendAndReceive() throws Exception {
   Connection connection = createConnection("myClientId");

   try {
      TopicSession session = (TopicSession) connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
      Topic topic = session.createTopic(getTopicName());

      int numMessages = 100;
      TopicSubscriber sub1 = session.createDurableSubscriber(topic, "myPubId1");
      TopicSubscriber sub2 = session.createDurableSubscriber(topic, "myPubId2");
      TopicSubscriber sub3 = session.createDurableSubscriber(topic, "myPubId3");

      Session sendSession = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
      MessageProducer producer = sendSession.createProducer(topic);
      connection.start();
      for (int i = 0; i < numMessages; i++) {
         producer.send(sendSession.createTextMessage("message:" + i));
      }

      for (int i = 0; i < numMessages; i++) {
         TextMessage receive = (TextMessage) sub1.receive(5000);
         Assert.assertNotNull(receive);
         Assert.assertEquals(receive.getText(), "message:" + i);
         receive = (TextMessage) sub2.receive(5000);
         Assert.assertNotNull(receive);
         Assert.assertEquals(receive.getText(), "message:" + i);
         receive = (TextMessage) sub3.receive(5000);
         Assert.assertNotNull(receive);
         Assert.assertEquals(receive.getText(), "message:" + i);
      }
   } finally {
      connection.close();
   }
}
 

import javax.jms.TopicSubscriber; //导入方法依赖的package包/类
@org.junit.Test
public void testDurableSubRedeliveryFlagAfterRestartNotSupported() throws Exception {

   ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("failover:(" + broker.getTransportConnectors().get(0).getPublishableConnectString() + ")?jms.prefetchPolicy.all=0");
   connection = (ActiveMQConnection) connectionFactory.createConnection();
   connection.setClientID("id");
   connection.start();

   Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
   ActiveMQTopic destination = new ActiveMQTopic(queueName);

   TopicSubscriber durableSub = session.createDurableSubscriber(destination, "id");

   populateDestination(10, destination, connection);

   TextMessage msg = null;
   for (int i = 0; i < 5; i++) {
      msg = (TextMessage) durableSub.receive(20000);
      LOG.info("not redelivered? got: " + msg);
      assertNotNull("got the message", msg);
      assertEquals("first delivery", 1, msg.getLongProperty("JMSXDeliveryCount"));
      assertEquals("not a redelivery", false, msg.getJMSRedelivered());
   }
   durableSub.close();

   restartBroker();

   // make failover aware of the restarted auto assigned port
   connection.getTransport().narrow(FailoverTransport.class).add(true, broker.getTransportConnectors().get(0).getPublishableConnectString());

   durableSub = session.createDurableSubscriber(destination, "id");
   for (int i = 0; i < 10; i++) {
      msg = (TextMessage) durableSub.receive(4000);
      LOG.info("redelivered? got: " + msg);
      assertNotNull("got the message again", msg);
      assertEquals("no reDelivery flag", false, msg.getJMSRedelivered());
      msg.acknowledge();
   }
   connection.close();
}
 

import javax.jms.TopicSubscriber; //导入方法依赖的package包/类
public void testReactivateKeepaliveSubscription() throws Exception {

      Connection connection = createConnection();
      connection.setClientID("cliID");
      connection.start();
      Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
      TopicSubscriber subscriber = session.createDurableSubscriber((Topic) createDestination(), "subName");
      subscriber.close();
      connection.close();

      connection = createConnection();
      connection.start();
      session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
      MessageProducer producer = session.createProducer(createDestination());
      producer.send(session.createMessage());
      connection.close();

      connection = createConnection();
      connection.setClientID("cliID");
      connection.start();
      session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
      subscriber = session.createDurableSubscriber((Topic) createDestination(), "subName");
      Message message = subscriber.receive(1 * 1000);
      subscriber.close();
      connection.close();

      assertNotNull("Message not received.", message);
   }
 

import javax.jms.TopicSubscriber; //导入方法依赖的package包/类
/**
 * This tests the fix for QPID-1085
 * Creates a durable subscriber with an invalid selector, checks that the
 * exception is thrown correctly and that the subscription is not created. 
 * @throws Exception 
 */
public void testDurableWithInvalidSelector() throws Exception
{
	Connection conn = getConnection();
	conn.start();
	Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
	AMQTopic topic = new AMQTopic((AMQConnection) conn, "MyTestDurableWithInvalidSelectorTopic");
	MessageProducer producer = session.createProducer(topic);
	producer.send(session.createTextMessage("testDurableWithInvalidSelector1"));
	try 
	{
		TopicSubscriber deadSubscriber = session.createDurableSubscriber(topic, "testDurableWithInvalidSelectorSub",
													 		 "=TEST 'test", true);
		assertNull("Subscriber should not have been created", deadSubscriber);
	} 
	catch (JMSException e)
	{
		assertTrue("Wrong type of exception thrown", e instanceof InvalidSelectorException);
	}
	TopicSubscriber liveSubscriber = session.createDurableSubscriber(topic, "testDurableWithInvalidSelectorSub");
	assertNotNull("Subscriber should have been created", liveSubscriber);

	producer.send(session.createTextMessage("testDurableWithInvalidSelector2"));
	
	Message msg = liveSubscriber.receive(POSITIVE_RECEIVE_TIMEOUT);
	assertNotNull ("Message should have been received", msg);
	assertEquals ("testDurableWithInvalidSelector2", ((TextMessage) msg).getText());
	assertNull("Should not receive subsequent message", liveSubscriber.receive(200));
    liveSubscriber.close();
    session.unsubscribe("testDurableWithInvalidSelectorSub");
}
 

import javax.jms.TopicSubscriber; //导入方法依赖的package包/类
/**
 * This tests the fix for QPID-1085
 * Creates a durable subscriber with an invalid destination, checks that the
 * exception is thrown correctly and that the subscription is not created. 
 * @throws Exception 
 */
public void testDurableWithInvalidDestination() throws Exception
{
	Connection conn = getConnection();
	conn.start();
	Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
	AMQTopic topic = new AMQTopic((AMQConnection) conn, "testDurableWithInvalidDestinationTopic");
	try 
	{
		TopicSubscriber deadSubscriber = session.createDurableSubscriber(null, "testDurableWithInvalidDestinationsub");
		assertNull("Subscriber should not have been created", deadSubscriber);
	} 
	catch (InvalidDestinationException e)
	{
		// This was expected
	}
	MessageProducer producer = session.createProducer(topic);    	
	producer.send(session.createTextMessage("testDurableWithInvalidSelector1"));
	
	TopicSubscriber liveSubscriber = session.createDurableSubscriber(topic, "testDurableWithInvalidDestinationsub");
	assertNotNull("Subscriber should have been created", liveSubscriber);
	
	producer.send(session.createTextMessage("testDurableWithInvalidSelector2"));
	Message msg = liveSubscriber.receive(POSITIVE_RECEIVE_TIMEOUT);
	assertNotNull ("Message should have been received", msg);
	assertEquals ("testDurableWithInvalidSelector2", ((TextMessage) msg).getText());
	assertNull("Should not receive subsequent message", liveSubscriber.receive(200));

    session.unsubscribe("testDurableWithInvalidDestinationsub");
}
 

import javax.jms.TopicSubscriber; //导入方法依赖的package包/类
public void testUnsubscriptionAfterConnectionClose() throws Exception
{
    AMQConnection con1 = (AMQConnection) getClientConnection("guest", "guest", "clientid");
    AMQTopic topic = new AMQTopic(con1, "MyTopic3");

    TopicSession session1 = con1.createTopicSession(true, AMQSession.AUTO_ACKNOWLEDGE);
    TopicPublisher publisher = session1.createPublisher(topic);

    AMQConnection con2 = (AMQConnection) getClientConnection("guest", "guest", "clientid");
    TopicSession session2 = con2.createTopicSession(true, AMQSession.AUTO_ACKNOWLEDGE);
    TopicSubscriber sub = session2.createDurableSubscriber(topic, "subscription0");

    con2.start();

    publisher.publish(session1.createTextMessage("Hello"));
    session1.commit();
    TextMessage tm = (TextMessage) sub.receive(2000);
    session2.commit();
    assertNotNull(tm);
    con2.close();
    publisher.publish(session1.createTextMessage("Hello2"));
    session1.commit();
    con2 =  (AMQConnection) getClientConnection("guest", "guest", "clientid");
    session2 = con2.createTopicSession(true, AMQSession.NO_ACKNOWLEDGE);
    sub = session2.createDurableSubscriber(topic, "subscription0");
    con2.start();
    tm = (TextMessage) sub.receive(2000);
    session2.commit();
    assertNotNull(tm);
    assertEquals("Hello2", tm.getText());
    session2.unsubscribe("subscription0");
    con1.close();
    con2.close();
}
 

import javax.jms.TopicSubscriber; //导入方法依赖的package包/类
@Parameters({"broker-port", "admin-username", "admin-password", "broker-hostname"})
@Test
public void testPositiveJMSSelectorConsumerProducer(String port,
                                                    String adminUsername,
                                                    String adminPassword,
                                                    String brokerHostname) throws NamingException, JMSException {
    String queueName = "testPositiveJMSSelectorConsumerProducer";
    InitialContext initialContext = ClientHelper
            .getInitialContextBuilder(adminUsername, adminPassword, brokerHostname, port)
            .withTopic(queueName)
            .build();


    TopicConnectionFactory connectionFactory
            = (TopicConnectionFactory) initialContext.lookup(ClientHelper.CONNECTION_FACTORY);
    TopicConnection connection = connectionFactory.createTopicConnection();
    connection.start();

    TopicSession subscriberSession = connection.createTopicSession(false, TopicSession.AUTO_ACKNOWLEDGE);
    Topic topic = (Topic) initialContext.lookup(queueName);

    // Subscribe with a selector
    String propertyName = "MyProperty";
    String propertyValue = "propertyValue";
    String jmsPropertySelector = propertyName + " = '" + propertyValue + "'";
    TopicSubscriber consumer = subscriberSession.createSubscriber(topic, jmsPropertySelector, false);

    // publish messages with property
    TopicSession producerSession = connection.createTopicSession(false, TopicSession.AUTO_ACKNOWLEDGE);
    TopicPublisher producer = producerSession.createPublisher(topic);

    int numberOfMessages = 100;
    for (int i = 0; i < numberOfMessages; i++) {
        TextMessage textMessage = producerSession.createTextMessage("Test message " + i);
        textMessage.setStringProperty(propertyName, propertyValue);
        producer.send(textMessage);
    }

    // consume messages
    for (int i = 0; i < numberOfMessages; i++) {
        Message message = consumer.receive(1000);
        Assert.assertNotNull(message, "Message #" + i + " was not received");
    }

    producerSession.close();
    connection.close();
}
 

import javax.jms.TopicSubscriber; //导入方法依赖的package包/类
@Parameters({"broker-port", "admin-username", "admin-password", "broker-hostname"})
@Test
public void testNegativeJMSSelectorConsumerProducer(String port,
                                                    String adminUsername,
                                                    String adminPassword,
                                                    String brokerHostname) throws NamingException, JMSException {
    String queueName = "testNegativeJMSSelectorConsumerProducer";
    InitialContext initialContext = ClientHelper
            .getInitialContextBuilder(adminUsername, adminPassword, brokerHostname, port)
            .withTopic(queueName)
            .build();

    TopicConnectionFactory connectionFactory
            = (TopicConnectionFactory) initialContext.lookup(ClientHelper.CONNECTION_FACTORY);
    TopicConnection connection = connectionFactory.createTopicConnection();
    connection.start();

    TopicSession subscriberSession = connection.createTopicSession(false, TopicSession.AUTO_ACKNOWLEDGE);
    Topic topic = (Topic) initialContext.lookup(queueName);

    // Subscribe with a selector
    String propertyName = "MyProperty";
    String propertyValue = "propertyValue";
    String jmsPropertySelector = propertyName + " = '" + propertyValue + "'";
    TopicSubscriber consumer = subscriberSession.createSubscriber(topic, jmsPropertySelector, false);

    // publish messages with property
    TopicSession producerSession = connection.createTopicSession(false, TopicSession.AUTO_ACKNOWLEDGE);
    TopicPublisher producer = producerSession.createPublisher(topic);

    // Send messages with a different property value
    int numberOfMessages = 100;
    for (int i = 0; i < numberOfMessages; i++) {
        TextMessage textMessage = producerSession.createTextMessage("Test message " + i);
        textMessage.setStringProperty(propertyName, propertyValue + "-1");
        producer.send(textMessage);
    }

    // consume messages
    Message message = consumer.receive(100);
    Assert.assertNull(message, "Message received. Shouldn't receive any messages.");

    producerSession.close();
    connection.close();
}