Map<String, String> headers = event.getHeaders(); @SuppressWarnings("rawtypes") Enumeration propertyNames = message.getPropertyNames(); while (propertyNames.hasMoreElements()) { String name = propertyNames.nextElement().toString(); String value = message.getStringProperty(name); headers.put(name, value); long length = bytesMessage.getBodyLength(); if (length > 0L) { if (length > Integer.MAX_VALUE) { int count = bytesMessage.readBytes(body); if (count != length) { throw new JMSException("Unable to read full message. " + String text = textMessage.getText(); if (text != null) { event.setBody(text.getBytes(charset)); Object object = objectMessage.getObject(); if (object != null) { ByteArrayOutputStream bos = new ByteArrayOutputStream();
/** This method called by {@link AppenderSkeleton#doAppend} method to do most of the real appending work. */ public void append(LoggingEvent event) { if(!checkEntryConditions()) { return; } try { ObjectMessage msg = topicSession.createObjectMessage(); if(locationInfo) { event.getLocationInformation(); } msg.setObject(event); topicPublisher.publish(msg); } catch(JMSException e) { errorHandler.error("Could not publish message in JMSAppender ["+name+"].", e, ErrorCode.GENERIC_FAILURE); } catch(RuntimeException e) { errorHandler.error("Could not publish message in JMSAppender ["+name+"].", e, ErrorCode.GENERIC_FAILURE); } }
connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Destination destination = session.createQueue(site); MessageProducer producer = session.createProducer(destination); ObjectMessage message = session.createObjectMessage(job); producer.send(message); logger.info("Sent message '{}'", ((CollectionJob) message.getObject()).toString()); connection.close(); } catch (Exception e) { logger.error("Exception during Job Publishing, sorry '{}'", e.getMessage());
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Queue queue = session.createQueue(queueName); MessageProducer producer = session.createProducer(queue); producer.setDeliveryMode(DeliveryMode.PERSISTENT); TextMessage textMessage = session.createTextMessage(); textMessage.setText(testString); TextMessage receivedMessage = sendAndReceive(textMessage, producer, consumer); String receivedText = receivedMessage.getText(); assertEquals(testString, receivedText); ObjectMessage objMessage = session.createObjectMessage(); objMessage.setObject(testString); ObjectMessage receivedObjMessage = sendAndReceive(objMessage, producer, consumer); String receivedObj = (String) receivedObjMessage.getObject(); assertEquals(testString, receivedObj); BytesMessage byteMessage = session.createBytesMessage(); byte[] bytes = testString.getBytes(); byteMessage.writeBytes(bytes); long receivedBodylength = receivedByteMessage.getBodyLength(); receivedByteMessage.readBytes(receivedBytes);
theConn.start(); Session sessSend = theConn.createSession(false, Session.AUTO_ACKNOWLEDGE); MessageProducer theProducer = sessSend.createProducer(queue1); theProducer.setDeliveryMode(DeliveryMode.PERSISTENT); Message m = sessSend.createMessage(); m.setStringProperty("p1", "aardvark"); ObjectMessage om = sessSend.createObjectMessage(); om.setObject("aardvark"); StreamMessage sm = sessSend.createStreamMessage(); TextMessage tm = sessSend.createTextMessage("aardvark"); theProducer.send(tm); theConn.close(); ProxyAssertSupport.assertEquals("aardvark", m2.getStringProperty("p1")); ProxyAssertSupport.assertEquals("aardvark", bm2.readUTF()); ProxyAssertSupport.assertEquals("aardvark", mm2.getString("s1")); ProxyAssertSupport.assertEquals("aardvark", (String) om2.getObject());
@Test public void testManagedOutboundJMSSetHeaderFromCamelRoute() throws Exception { String payload = "onMessageCamel"; Session session = _hqMixIn.createJMSSession(); try { MessageProducer producer = session.createProducer(HornetQMixIn.getJMSQueue(INPUT_TX_QUEUE)); TextMessage inMsg = session.createTextMessage(); inMsg.setText(payload); producer.send(inMsg); producer.close(); session.close(); session = _hqMixIn.createJMSSession(); MessageConsumer consumer = session.createConsumer(HornetQMixIn.getJMSQueue(OUTPUT_QUEUE)); javax.jms.Message msg = consumer.receive(3000); consumer.close(); Assert.assertNotNull(msg); Assert.assertTrue(msg instanceof ObjectMessage); Assert.assertEquals(payload, ObjectMessage.class.cast(msg).getObject().toString()); Assert.assertEquals("jmscorrelation-onMessageCamel", msg.getJMSCorrelationID()); } finally { session.close(); } }
private void send(Destination destination, Serializable message, String propertyName, String propertValue, boolean transacted) { Connection connection = null; try { if (transacted) { connection = xaConnectionFactory.createConnection(); } else { connection = connectionFactory.createConnection(); } Session session = connection.createSession(transacted, Session.AUTO_ACKNOWLEDGE); MessageProducer messageProducer = session.createProducer(destination); connection.start(); ObjectMessage objectMessage = session.createObjectMessage(message); if (propertyName != null) { objectMessage.setStringProperty(propertyName, propertValue); } messageProducer.send(objectMessage); } catch (JMSException e) { throw new MessageDeliveryException("Failed to queue push message for further processing", e); } finally { if (connection != null) { try { connection.close(); } catch (JMSException e) { logger.error("Failed to close JMS connection: ", e); } } } } }
private void sendObjectMessage(String qname, Serializable obj) throws Exception { ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("vm://0"); Connection connection = factory.createConnection(); try { Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Queue q = session.createQueue(qname); MessageProducer producer = session.createProducer(q); ObjectMessage objMessage = session.createObjectMessage(); objMessage.setObject(obj); producer.send(objMessage); } finally { connection.close(); } }
@Test public void testSendReceiveMessage() throws Exception { Connection conn = createConnection(); Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE); MessageProducer prod = sess.createProducer(queue1); // Make persistent to make sure message gets serialized prod.setDeliveryMode(DeliveryMode.PERSISTENT); MessageConsumer cons = sess.createConsumer(queue1); TestMessage tm = new TestMessage(123, false); ObjectMessage om = sess.createObjectMessage(); om.setObject(tm); conn.start(); prod.send(om); ObjectMessage om2 = (ObjectMessage) cons.receive(1000); ProxyAssertSupport.assertNotNull(om2); TestMessage tm2 = (TestMessage) om2.getObject(); ProxyAssertSupport.assertEquals(123, tm2.getID()); conn.close(); }
@Test(timeout = 30000) public void testDurableConsumerLarge() throws Exception { String durableClientId = getTopicName() + "-ClientId"; Connection connection = createConnection(durableClientId); try { Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Topic topic = session.createTopic(getTopicName()); final MessageConsumer consumer1 = session.createDurableSubscriber(topic, "DurbaleSub1"); final MessageConsumer consumer2 = session.createDurableSubscriber(topic, "DurbaleSub2"); MessageProducer producer = session.createProducer(topic); producer.setDeliveryMode(DeliveryMode.PERSISTENT); connection.start(); ObjectMessage objMessage = session.createObjectMessage(); BigObject bigObject = new BigObject(ActiveMQClient.DEFAULT_MIN_LARGE_MESSAGE_SIZE); objMessage.setObject(bigObject); producer.send(objMessage); ObjectMessage msg1 = (ObjectMessage)consumer1.receive(5000); Assert.assertNotNull(msg1); assertTrue("Should be an instance of TextMessage", msg1 instanceof ObjectMessage); ObjectMessage msg2 = (ObjectMessage)consumer2.receive(5000); assertNotNull("Should have received a message by now.", msg2); assertTrue("Should be an instance of TextMessage", msg2 instanceof ObjectMessage); } finally { connection.close(); } }
private static Serializable extractBody(Message message) { try { if (message instanceof TextMessage) return ((TextMessage) message).getText(); if (message instanceof ObjectMessage) return ((ObjectMessage) message).getObject(); if (message instanceof MapMessage) { LinkedHashMap<String, Object> map = new LinkedHashMap<String, Object>(); Enumeration<String> names = ((MapMessage) message).getMapNames(); while (names.hasMoreElements()) { String key = names.nextElement(); map.put(key, ((MapMessage) message).getObject(key)); } return map; } if (message instanceof BytesMessage) { BytesMessage bm = (BytesMessage) message; ByteArrayOutputStream baos = new ByteArrayOutputStream(); byte[] buffer = new byte[8096]; int c; while ((c = bm.readBytes(buffer)) != -1) baos.write(buffer, 0, c); return baos.toByteArray(); } } catch (JMSException e) { throw new JMSClientException(e); } throw new JMSClientException("Unsupported message type: " + message.getClass().getName() + " (" + message + ")"); }
/** * emits an JMS message to a queue, <b>inside a JTA transaction</b> * * @param payload the message body * @param ctx to send the message inside the ctx transaction * @param queueName * @throws Exception */ public static void emitJMSMessage(final Serializable payload, final EJBContext ignored, final String queueName, final long delayMillis, final long deliveriesCounter) throws Exception { InitialContext ctx = new InitialContext(); ConnectionFactory cf = (ConnectionFactory) ctx.lookup("jms/QueueConnectionFactory"); Queue queue = (Queue) ctx.lookup(queueName); Connection conn = cf.createConnection(); Session sess = conn.createSession(true, Session.AUTO_ACKNOWLEDGE); MessageProducer mp = sess.createProducer(queue); ObjectMessage msg = sess.createObjectMessage(); if (delayMillis > 0) { msg.setLongProperty("scheduleDate", System.currentTimeMillis() + delayMillis); } msg.setLongProperty("deliveriesCounter", deliveriesCounter); msg.setObject(payload); mp.send(msg); sess.close(); conn.close(); }
private void testObjectMessageUsingCustomType(Connection producerConnection, Connection consumerConnection) throws Throwable { long time = System.currentTimeMillis(); Session session = producerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE); Queue queue = session.createQueue(getQueueName()); MessageProducer producer = session.createProducer(queue); for (int i = 0; i < NUM_MESSAGES; i++) { System.out.println("Sending " + i); ObjectMessage message = session.createObjectMessage(new AnythingSerializable(i)); producer.send(message); } Session sessionConsumer = consumerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE); Queue consumerQueue = sessionConsumer.createQueue(getQueueName()); final MessageConsumer consumer = sessionConsumer.createConsumer(consumerQueue); for (int i = 0; i < NUM_MESSAGES; i++) { ObjectMessage msg = (ObjectMessage) consumer.receive(5000); Assert.assertNotNull("Could not receive message count=" + i + " on consumer", msg); AnythingSerializable someSerialThing = (AnythingSerializable) msg.getObject(); Assert.assertEquals(i, someSerialThing.getCount()); } long taken = (System.currentTimeMillis() - time) / 1000; System.out.println("taken = " + taken); }
public void internalTestResend(final ArrayList<Message> msgs, final Session sess) throws Exception { MessageProducer prod = sess.createProducer(queue); prod.send(msg); sess.commit(); MessageConsumer cons = sess.createConsumer(queue); Assert.assertNotNull(msg); prod.send(msg); BytesMessage copiedBytes = (BytesMessage) copiedMessage; for (int i = 0; i < copiedBytes.getBodyLength(); i++) { Assert.assertEquals(ActiveMQTestBase.getSamplebyte(i), copiedBytes.readByte()); if (originalMap.getString("str") != null) { Assert.assertEquals(originalMap.getString("str"), copiedMap.getString("str")); if (originalMap.getObject("long") != null) { Assert.assertNotSame(((ObjectMessage) originalMessage).getObject(), ((ObjectMessage) copiedMessage).getObject()); Assert.assertEquals(((ObjectMessage) originalMessage).getObject(), ((ObjectMessage) copiedMessage).getObject()); } else if (copiedMessage instanceof TextMessage) { Assert.assertEquals(((TextMessage) originalMessage).getText(), ((TextMessage) copiedMessage).getText());
private void jmsSendMessage(Serializable value, String destName, boolean isQueue) throws JMSException { ConnectionFactory factory = new ActiveMQJMSConnectionFactory("tcp://localhost:61616"); String jmsDest; if (isQueue) { jmsDest = QUEUE_QUALIFIED_PREFIX + destName; } else { jmsDest = TOPIC_QUALIFIED_PREFIX + destName; } Destination destination = ActiveMQDestination.fromPrefixedName(jmsDest); Connection conn = factory.createConnection(); try { Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE); MessageProducer producer = session.createProducer(destination); ObjectMessage message = session.createObjectMessage(); message.setStringProperty(HttpHeaderProperty.CONTENT_TYPE, "application/xml"); message.setObject(value); producer.send(message); } finally { conn.close(); } } }
public Object fromMessage(Message message) throws JMSException { if (message instanceof TextMessage) { return ((TextMessage)message).getText(); } else if (message instanceof BytesMessage) { BytesMessage message1 = (BytesMessage)message; byte[] bytes = new byte[(int)message1.getBodyLength()]; message1.readBytes(bytes); return bytes; } else if (message instanceof ObjectMessage) { return ((ObjectMessage)message).getObject(); } else if (message instanceof StreamMessage) { StreamMessage streamMessage = (StreamMessage)message; return streamMessage.readObject(); } else { return new byte[]{}; } }
message = _session.createMapMessage(); byte []bytes = ((BinaryValue) entry.getValue()).toBytes(); ((MapMessage) message).setBytes(entry.getKey().toString(), bytes); } else { ((MapMessage) message).setString(entry.getKey().toString(), entry.getValue().toString()); message = _session.createBytesMessage(); ((BytesMessage) message).writeBytes(bytes); } else if (value.isLongConvertible()) { message = _session.createStreamMessage(); message = _session.createTextMessage(); ((ObjectMessage) message).setObject((Serializable) value.toJavaObject()); } else { return false; message.setJMSReplyTo(replyTo._destination); _producer.send(message);
try { sb.append("=== JMS Message === ").append(msg.getClass().getSimpleName()).append(" ===\n"); sb.append("Message ID : ").append(msg.getJMSMessageID()).append('\n'); sb.append("Reply : ").append(msg.getJMSReplyTo()).append('\n'); if (msg.getJMSExpiration() != 0) sb.append("Expiration : ").append(msg.getJMSExpiration()).append(" (").append(msg.getJMSExpiration() - msg.getJMSTimestamp()).append(")\n"); sb.append("Correlation ID: ").append(msg.getJMSCorrelationID()).append('\n'); sb.append("Map:\n"); MapMessage m = (MapMessage)msg; for (@SuppressWarnings("unchecked")Enumeration<String> e = m.getMapNames();e.hasMoreElements();) { String key = e.nextElement(); Object val = ((MapMessage) msg).getObject(key); if (key.contains("assword")) val = "[***]"; sb.append(" ").append(key).append('=').append(MString.toString(val)).append('\n'); sb.append("Text: ").append( ((TextMessage)msg).getText()).append('\n'); } else if (msg instanceof BytesMessage) { sb.append("Size: " + ((BytesMessage)msg).getBodyLength() ); } else if (msg instanceof ObjectMessage) { sb.append("Object: ").append( ((ObjectMessage)msg).getObject() ).append('\n');
private void sendObjectMessages(int nMsgs, ConnectionFactory factory) throws Exception { try (Connection connection = factory.createConnection()) { Session session = connection.createSession(); Queue queue = session.createQueue(testQueueName); MessageProducer producer = session.createProducer(queue); ObjectMessage msg = session.createObjectMessage(); StringBuilder builder = new StringBuilder(); for (int i = 0; i < PAYLOAD; ++i) { builder.append("A"); } msg.setObject(builder.toString()); for (int i = 0; i < nMsgs; ++i) { msg.setIntProperty("i", (Integer) i); producer.send(msg); } } }
@Test public void testObjectMessage() throws Exception { // Receive a message with the JMS API connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); destination = createDestination(session, destinationType); MessageConsumer consumer = session.createConsumer(destination); MessageProducer producer = session.createProducer(destination); // send the message. { ObjectMessage message = session.createObjectMessage(); message.setObject("Hi"); producer.send(message); } // Check the message { ObjectMessage message = (ObjectMessage) consumer.receive(1000); assertNotNull(message); assertEquals("Hi", message.getObject()); } assertNull(consumer.receiveNoWait()); }