Refine search
/** * Actually receive a message from the given consumer. * @param consumer the JMS MessageConsumer to receive with * @param timeout the receive timeout (a negative value indicates * a no-wait receive; 0 indicates an indefinite wait attempt) * @return the JMS Message received, or {@code null} if none * @throws JMSException if thrown by JMS API methods * @since 4.3 * @see #RECEIVE_TIMEOUT_NO_WAIT * @see #RECEIVE_TIMEOUT_INDEFINITE_WAIT */ @Nullable protected Message receiveFromConsumer(MessageConsumer consumer, long timeout) throws JMSException { if (timeout > 0) { return consumer.receive(timeout); } else if (timeout < 0) { return consumer.receiveNoWait(); } else { return consumer.receive(); } }
public List<Message> receive(Queue queue) throws Exception { List<Message> messages = new ArrayList<Message>(); Connection qconnetion = factory.createConnection(); Session qsession = qconnetion.createSession(true, QueueSession.AUTO_ACKNOWLEDGE); MessageConsumer consumer = qsession.createConsumer(queue); qconnetion.start(); Message m = null; while ((m = consumer.receiveNoWait()) != null) { messages.add(m); } consumer.close(); qsession.close(); qconnetion.close(); return messages; } }
given(localSession.createConsumer(replyDestination)).willReturn(messageConsumer); given(messageConsumer.receiveNoWait()).willReturn(reply); given(messageConsumer.receive()).willReturn(reply); given(messageConsumer.receive(timeout)).willReturn(reply);
given(this.session.createConsumer(this.queue, messageSelector ? selectorString : null)).willReturn(messageConsumer); given(messageConsumer.receiveNoWait()).willReturn(textMessage); given(messageConsumer.receive()).willReturn(textMessage); given(messageConsumer.receive(timeout)).willReturn(textMessage);
@Override public Message readMessageFromRetryQueueByJmsId(String jmsId) throws QueueingException { Connection connection = null; Session session = null; MessageConsumer messageConsumer = null; Message message = null; try { connection = getConnectionFactory().createConnection(); session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); connection.start(); messageConsumer = session.createConsumer(getRetryQueue(), "JMSMessageID='"+jmsId+"'"); message = messageConsumer.receiveNoWait(); } catch (JMSException e) { throw new QueueingException("Failed to read message from MessageConsumer."); } finally { try { connection.close(); } catch (Exception e) {} } return message; }
while (consumer.receiveNoWait() != null) { TextMessage message = (TextMessage)consumer.receive(1000); assertEquals(outbound[0].getText(), message.getText()); message = (TextMessage)consumer.receive(1000); assertEquals(outbound[1].getText(), message.getText()); commitTx();
try (Session session = connection.createSession(true, Session.SESSION_TRANSACTED)) { Queue queue = session.createQueue(queueName); try (MessageConsumer consumer = session.createConsumer(queue, selector)) { Message message = null; while (first || message != null) { if (first) { message = consumer.receive(2000); } else { message = consumer.receiveNoWait();
final ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url); final javax.jms.Connection connection = connectionFactory.createConnection(); connection.setClientID("12345"); connection.start(); final Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); final Topic temporaryTopic = session.createTemporaryTopic(); final MessageConsumer consumer1 = session.createConsumer(temporaryTopic); final MessageProducer producer = session.createProducer(temporaryTopic); producer.send(session.createTextMessage("Testmessage")); final TextMessage message = (TextMessage)consumer1.receiveNoWait(); Assert.assertNotNull(message); Assert.assertEquals("testing", message.getText());
while (consumer.receive(1000) != null) { Message message = consumer.receive(1000); assertEquals(outbound[0], message); message = consumer.receive(1000); assertNotNull(message); assertEquals(outbound[1], message); assertEquals(outbound[1], message); assertNull(consumer.receiveNoWait()); commitTx();
try (Session session = connection.createSession(true, Session.SESSION_TRANSACTED)) { Queue queue = session.createQueue(queueName); try (MessageConsumer consumer = session.createConsumer(queue)) { try (MessageProducer producer = session.createProducer(queue)) { if (first) { message = consumer.receive(2000); } else { message = consumer.receiveNoWait();
private void doCleanupQueue( final Session session, final Destination destination ) throws JMSException { try { MessageConsumer consumer = session.createConsumer(destination); Message message = null; do { message = consumer.receiveNoWait(); if (message != null) { message.acknowledge(); } } while (message != null); } finally { releaseSession(false); } }
message = consumer.receive(timeout); } else { message = consumer.receiveNoWait();
public void internalTestPreACK(final int sessionType) throws Exception { conn = cf.createConnection(); Session sess = conn.createSession(false, sessionType); MessageProducer prod = sess.createProducer(queue); TextMessage msg1 = sess.createTextMessage("hello"); prod.send(msg1); conn.start(); MessageConsumer cons = sess.createConsumer(queue); TextMessage msg2 = (TextMessage) cons.receive(1000); assertNotNull(msg2); assertEquals(msg1.getText(), msg2.getText()); conn.close(); conn = cf.createConnection(); conn.start(); sess = conn.createSession(false, Session.CLIENT_ACKNOWLEDGE); cons = sess.createConsumer(queue); msg2 = (TextMessage) cons.receiveNoWait(); assertNull("ConnectionFactory is on PreACK mode, the message shouldn't be received", msg2); }
@Test public void test() throws Exception { final ConnectionFactory connectionFactory = new ActiveMQConnectionFactory( "vm://localhost?broker.persistent=false"); final Connection connection = connectionFactory.createConnection(); connection.start(); final Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); final Queue queue = session.createTemporaryQueue(); { final MessageProducer producer = session.createProducer(queue); final TextMessage message = session.createTextMessage("testing"); producer.send(message); } { final MessageConsumer consumer = session.createConsumer(queue); final TextMessage message = (TextMessage) consumer.receiveNoWait(); Assert.assertNotNull(message); Assert.assertEquals("testing", message.getText()); } }
/** * Actually receive a message from the given consumer. * @param consumer the JMS MessageConsumer to receive with * @param timeout the receive timeout * @return the JMS Message received, or {@code null} if none * @throws JMSException if thrown by JMS API methods */ private Message doReceive(MessageConsumer consumer, long timeout) throws JMSException { if (timeout == RECEIVE_TIMEOUT_NO_WAIT) { return consumer.receiveNoWait(); } else if (timeout > 0) { return consumer.receive(timeout); } else { return consumer.receive(); } }
public static void consumeMessages(final int expected, final Destination dest) throws JMSException { Connection connection = JMSUtil.createConnection(InVMConnectorFactory.class.getName()); try { Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); MessageConsumer consumer = session.createConsumer(dest); connection.start(); Message m = null; for (int i = 0; i < expected; i++) { m = consumer.receive(500); Assert.assertNotNull("expected to received " + expected + " messages, got only " + (i + 1), m); } m = consumer.receiveNoWait(); Assert.assertNull("received one more message than expected (" + expected + ")", m); } finally { if (connection != null) { connection.close(); } } }
String url = "tcp://localhost:61616"; BrokerService broker = new BrokerService(); broker.addConnector(url); broker.start(); ConnectionFactory cf = new ActiveMQConnectionFactory(url); Connection conn = cf.createConnection(); Session s = conn.createSession(true, Session.AUTO_ACKNOWLEDGE); ActiveMQQueue q = new ActiveMQQueue("test"); MessageProducer p = s.createProducer(q); p.send(s.createTextMessage("!!!!"), DeliveryMode.NON_PERSISTENT, 0, 1000); // ttl = 1s Thread.sleep(2000); MessageConsumer c = s.createConsumer(q); System.out.println("Received: " + c.receiveNoWait()); System.exit(1);
/** * Receive a message with the given timeout * * @param timeout the amount of time to wait for a message in milliseconds * * @return the message receivied or null in the event of a timeout * * @throws JMSException in the event of a JMS error */ public Message receiveMessage(long timeout) throws JMSException { Message message = null; if (timeout > 0) { message = consumer.receive(timeout); } else if (timeout == 0) { message = consumer.receiveNoWait(); } else { message = consumer.receive(); } return message; } }
@Test public void testRollback() throws Exception { try (Connection connection = factory.createConnection()) { Session session = connection.createSession(true, Session.SESSION_TRANSACTED); Queue queue = session.createQueue(queueName); System.out.println("Queue:" + queue); MessageProducer producer = session.createProducer(queue); MessageConsumer consumer = session.createConsumer(queue); producer.send(session.createTextMessage("test")); producer.send(session.createTextMessage("test2")); connection.start(); Assert.assertNull(consumer.receiveNoWait()); session.rollback(); producer.send(session.createTextMessage("test2")); Assert.assertNull(consumer.receiveNoWait()); session.commit(); TextMessage msg = (TextMessage) consumer.receive(1000); Assert.assertNotNull(msg); Assert.assertEquals("test2", msg.getText()); } }
public Message receiveNoWait(Destination dest) { Session session = null; MessageConsumer consumer = null; try { session = getSession(); consumer = session.createConsumer(dest); return consumer.receiveNoWait(); } catch (JMSException e) { throw new RuntimeException(e); } finally { try { if (consumer != null) consumer.close(); } catch (JMSException e) { log.log(Level.FINE, e.toString(), e); } freeSession(session); } }