/** Sends a request and waits for a reply. The temporary queue is used for * the {@code JMSReplyTo} destination, and only one reply per request * is expected. * * @param message the message to send * * @return the reply message * * @exception JMSException if the JMS provider fails to complete the * request due to some internal error. */ public Message request(Message message) throws JMSException { message.setJMSReplyTo(tempQueue); sender.send(message); return (receiver.receive()); }
@Override @Nullable public Queue getQueue() throws JMSException { return (this.target instanceof QueueReceiver ? ((QueueReceiver) this.target).getQueue() : null); }
receiverConnection.stop(); if (receiver!=null) receiver.close(); receiver = receiverSession.createReceiver(receiverQueue, "weight <> 2500"); receiverConnection.start(); TextMessage dummyMessage = senderSession.createTextMessage(); dummyMessage.setLongProperty("weight", 2500); dummyMessage.setText("testEquals:1"); sender.send(dummyMessage); TextMessage message = senderSession.createTextMessage(); message.setLongProperty("weight", 1000); message.setText("testEquals:2"); sender.send(message); TextMessage msg = (TextMessage) receiver.receive(TestConfig.TIMEOUT); assertEquals("testEquals:2", msg.getText());
/** * Test that it is valid to use message objects created or received via the [closed] session with the * exception of a received message <code>acknowledge()</code> method. */ public void testUseMessage() { try { TextMessage message = senderSession.createTextMessage(); message.setText("testUseMessage"); sender.send(message); TextMessage m = (TextMessage) receiver.receive(TestConfig.TIMEOUT); receiverSession.close(); assertEquals("testUseMessage", m.getText()); } catch (Exception e) { fail("�4.4.1 It is valid to continue to use message objects created or received via " + "the [closed] session.\n"); } }
qSession = qConn.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); qSender = qSession.createSender(queue); qReceiver = qSession.createReceiver(queue); qReceiver.setMessageListener(this); qConn.start(); TextMessage msg = qSession.createTextMessage(str); qSender.send(msg); if (message instanceof TextMessage) { TextMessage textMessage = (TextMessage)message; System.out.println("Text Message Received: "+textMessage.getText()); } else { System.out.println(message.getJMSType()+" Message Received"); if (qSender != null) qSender.close(); if (qReceiver != null) qReceiver.close(); if (qSession != null) qSession.close(); if (qConn != null) qConn.close();
senderSession = senderConnection.createQueueSession(true, 0); sender = senderSession.createSender(senderQueue); assertEquals(true, senderSession.getTransacted()); TextMessage message = senderSession.createTextMessage(); message.setText("testCommitTransactedSession"); sender.send(message); TextMessage m = (TextMessage) receiver.receiveNoWait(); senderSession.commit(); m = (TextMessage) receiver.receive(TestConfig.TIMEOUT); assertTrue(m != null); assertEquals("testCommitTransactedSession", m.getText());
conn.start(); session = conn.createQueueSession(false, QueueSession.AUTO_ACKNOWLEDGE); QueueReceiver recv = session.createReceiver(queue); recv.setMessageListener(new MessageListener() { QueueSender sender = session.createSender(queue); for (int i = 0; i < 10; i++) { String s = "Test" + i; stdout.println("----> Sending: " + s); TextMessage msg = session.createTextMessage(s); sender.send(msg); conn.stop(); } catch (Exception ignore) {
QueueSession qs = qc.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); QueueReceiver qreceiver = qs.createReceiver(queue1, "targetMessage = TRUE"); qc.start(); TextMessage m = qs.createTextMessage(); m.setText("one"); m.setBooleanProperty("targetMessage", false); QueueSender qsender = qs.createSender(queue1); qsender.send(m); m.setText("two"); m.setBooleanProperty("targetMessage", true); qsender.send(m); TextMessage rm = (TextMessage) qreceiver.receive(1000); ProxyAssertSupport.assertEquals("two", rm.getText()); } finally { if (qc != null) { qc.close();
try { senderConnection.stop(); receiverConnection.stop(); tempQueue = receiverSession.createTemporaryQueue(); sender = senderSession.createSender(null); tempReceiver = receiverSession.createReceiver(tempQueue); receiverConnection.start(); senderConnection.start(); TextMessage message = senderSession.createTextMessage(); message.setText("testTemporaryQueue"); sender.send(tempQueue, message); Message m = tempReceiver.receive(TestConfig.TIMEOUT); Assert.assertTrue(m instanceof TextMessage); TextMessage msg = (TextMessage) m; Assert.assertEquals("testTemporaryQueue", msg.getText()); } catch (JMSException e) { fail(e);
/** * Test that if the JMS ReplyTo header field has been set as a <code>TemporaryQueue</code>, * it will be rightly get also as a <code>TemporaryQueue</code> * (and not only as a <code>Queue</code>). */ public void testJMSReplyTo_2() { try { TemporaryQueue tempQueue = senderSession.createTemporaryQueue(); Message message = senderSession.createMessage(); message.setJMSReplyTo(tempQueue); sender.send(message); Message msg = receiver.receive(TestConfig.TIMEOUT); Destination dest = msg.getJMSReplyTo(); assertTrue("JMS ReplyTo header field should be a TemporaryQueue", dest instanceof TemporaryQueue); Queue replyTo = (Queue) dest; assertEquals("JMS ReplyTo header field should be equals to the temporary queue", replyTo.getQueueName(), tempQueue.getQueueName()); } catch (JMSException e) { fail(e); } }
/** * Test that the JMSX property <code>JMSXGroupID</code> works */ public void testJMSXGroupID_1() { try { String groupID = "testSupportsJMSXGroupID_1:group"; TextMessage message = senderSession.createTextMessage(); message.setStringProperty("JMSXGroupID", groupID); message.setText("testSupportsJMSXGroupID_1"); sender.send(message); Message m = receiver.receive(TestConfig.TIMEOUT); assertTrue(m instanceof TextMessage); TextMessage msg = (TextMessage) m; assertEquals(groupID, msg.getStringProperty("JMSXGroupID")); assertEquals("testSupportsJMSXGroupID_1", msg.getText()); } catch (JMSException e) { fail(e); } }
/** * Test that the JMS property <code>JMSDeliveryMode</code> is treated as having the values <code>'PERSISTENT'</code> * or <code>'NON_PERSISTENT'</code> when used in a message selector (chapter 3.8.1.3). */ @Test public void testJMSDeliveryModeInSelector() throws Exception { if (receiver != null) { receiver.close(); } receiver = receiverSession.createReceiver(receiverQueue, "JMSDeliveryMode = 'PERSISTENT'"); TextMessage dummyMessage = senderSession.createTextMessage(); dummyMessage.setText("testJMSDeliveryModeInSelector:1"); // send a dummy message in *non persistent* mode sender.send(dummyMessage, DeliveryMode.NON_PERSISTENT, sender.getPriority(), sender.getTimeToLive()); TextMessage message = senderSession.createTextMessage(); message.setText("testJMSDeliveryModeInSelector:2"); // send a message in *persistent* sender.send(message, DeliveryMode.PERSISTENT, sender.getPriority(), sender.getTimeToLive()); TextMessage msg = (TextMessage) receiver.receive(TestConfig.TIMEOUT); Assert.assertTrue("No message was received", msg != null); // only the message sent in persistent mode should be received. Assert.assertEquals(DeliveryMode.PERSISTENT, msg.getJMSDeliveryMode()); Assert.assertEquals("testJMSDeliveryModeInSelector:2", msg.getText()); }
/** * Test that the <code>JMSMessageID</code> header field value is * ignored when the message is sent. */ public void testJMSMessageID_1() { try { Message message = senderSession.createMessage(); message.setJMSMessageID("ID:foo"); sender.send(message); assertTrue("3.4.3 When a message is sent this value is ignored.\n", message.getJMSMessageID() != "ID:foo"); receiver.receive(TestConfig.TIMEOUT); } catch (JMSException e) { fail(e); } }
public void start() throws Exception { InitialContext ctx = new InitialContext(); QueueConnectionFactory qcf = (QueueConnectionFactory)ctx.lookup("java:/ConnectionFactory"); conn = qcf.createQueueConnection(); conn.start(); queue = (Queue)ctx.lookup("queue/test"); session = conn.createQueueSession(false, QueueSession.AUTO_ACKNOWLEDGE); // Set the async listener QueueReceiver recv = session.createReceiver(queue); recv.setMessageListener(new ExampeMessageListener()); }
Queue tempQueue = (Queue) ctx.lookup("tempQueue"); QueueSession queueLocalSession = queueConn.createQueueSession(false, Session.CLIENT_ACKNOWLEDGE); QueueReceiver queueReceiver = queueLocalSession.createReceiver(tempQueue); TextMessage localMessage = (TextMessage) queueReceiver.receive(); //send to remote queue Queue remoteQueue = (Queue) ctx.lookup("remoteQueue"); QueueSender queueSender = queueRemoteSession.createSender(remoteQueue); Message newMessage = queueRemoteSession.createTextMessage( localMessage.getText()); queueSender.send( newMessage); //now acknowledge the message since we safely sent to remoteQueue localMessage.acknowledge();
@Test public void testQueueRequestor() throws Exception { QueueConnection conn1 = null, conn2 = null; try { Queue queue1 = createQueue(true, "myQueue"); conn1 = (QueueConnection) cf.createConnection(); QueueSession sess1 = conn1.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); QueueRequestor requestor = new QueueRequestor(sess1, queue1); conn1.start(); // And the responder conn2 = (QueueConnection) cf.createConnection(); QueueSession sess2 = conn2.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); TestMessageListener listener = new TestMessageListener(sess2); QueueReceiver receiver = sess2.createReceiver(queue1); receiver.setMessageListener(listener); conn2.start(); Message m1 = sess1.createMessage(); log.trace("Sending request message"); TextMessage m2 = (TextMessage) requestor.request(m1); assertNotNull(m2); assertEquals("This is the response", m2.getText()); requestor.close(); } finally { conn1.close(); conn2.close(); } }
/** * Test that invoking the <code>acknowledge()</code> method of a received message * from a closed connection's session must throw an <code>IllegalStateException</code>. */ @Test public void testAcknowledge() { try { receiverConnection.stop(); receiverSession = receiverConnection.createQueueSession(false, Session.CLIENT_ACKNOWLEDGE); receiver.close(); // Before assigning a new receiver, we need to close the old one... // Not closing it could cause load balancing between receivers. // Not having this close might be valid for JORAM or JBossMQ, but it's not valid for ActiveMQ Artemis (and still legal) receiver = receiverSession.createReceiver(receiverQueue); receiverConnection.start(); Message message = senderSession.createMessage(); sender.send(message); Message m = receiver.receive(TestConfig.TIMEOUT); receiverConnection.close(); m.acknowledge(); Assert.fail("sec. 4.3.5 Invoking the acknowledge method of a received message from a closed " + "connection's session must throw a [javax.jms.]IllegalStateException.\n"); } catch (javax.jms.IllegalStateException e) { } catch (JMSException e) { Assert.fail("sec. 4.3.5 Invoking the acknowledge method of a received message from a closed " + "connection's session must throw a [javax.jms.]IllegalStateException, not a " + e); } catch (java.lang.IllegalStateException e) { Assert.fail("sec. 4.3.5 Invoking the acknowledge method of a received message from a closed " + "connection's session must throw an [javax.jms.]IllegalStateException " + "[not a java.lang.IllegalStateException]"); } }
public Message request(Message message) throws JMSException { message.setJMSReplyTo(replyQueue); message.setJMSDeliveryMode(DeliveryMode.NON_PERSISTENT); requestSender.send(message); return replyReceiver.receive(); }
/** * Test that invoking the <code>acknowledge()</code> method of a received message * from a closed session must throw an <code>IllegalStateException</code>. */ @Test public void testAcknowledge() { try { if (receiverSession != null) { receiverSession.close(); } receiverSession = receiverConnection.createQueueSession(false, Session.CLIENT_ACKNOWLEDGE); receiver = receiverSession.createReceiver(receiverQueue); Message message = senderSession.createMessage(); sender.send(message); Message m = receiver.receive(TestConfig.TIMEOUT); receiverSession.close(); m.acknowledge(); Assert.fail("sec. 4.4.1 Invoking the acknowledge method of a received message from a closed " + " session must throw an [javax.jms.]IllegalStateException.\n"); } catch (javax.jms.IllegalStateException e) { } catch (JMSException e) { Assert.fail("Should raise a javax.jms.IllegalStateException, not a " + e); } catch (java.lang.IllegalStateException e) { Assert.fail("sec. 4.4.1 Invoking the acknowledge method of a received message from a closed " + "session must throw an [javax.jms.]IllegalStateException, " + "[not a java.lang.IllegalStateException]"); } }
public Message request(Message message) throws JMSException { TemporaryQueue tempQueue = _session.createTemporaryQueue(); try { message.setJMSReplyTo(tempQueue); _sender.send(message); QueueReceiver receiver = _session.createReceiver(tempQueue); try { return receiver.receive(); } finally { receiver.close(); } } finally { tempQueue.delete(); } }