/** * Listen to a message from JMS from a given destination by name. * * @param destinationName destinationName * @param messageListener messageListener */ public void listenTextMessagesWithDestination( final String destinationName, final Consumer<String> messageListener) { final MessageConsumer consumer = getConsumer(destinationName); try { consumer.setMessageListener( message -> { try { messageListener.accept(((TextMessage) message).getText()); if (acknowledgeMode == Session.CLIENT_ACKNOWLEDGE) { message.acknowledge(); } } catch (JMSException e) { throw new IllegalStateException( "Unable to register get text from message in listener " + destinationName, e); } catch (Exception ex) { throw new IllegalStateException("Unable handle JMS Consumer " + destinationName, ex); } }); } catch (JMSException e) { throw new IllegalStateException("Unable to register message listener " + destinationName, e); } }
public static void main(String[] args) { try { // Gets the JgetTopicName()NDI context Context jndiContext = new InitialContext(); // Looks up the administered objects ConnectionFactory connectionFactory = (ConnectionFactory) jndiContext.lookup("jms/javaee6/ConnectionFactory"); Queue queue = (Queue) jndiContext.lookup("jms/javaee6/Queue"); // Creates the needed artifacts to connect to the queue Connection connection = connectionFactory.createConnection(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); MessageConsumer consumer = session.createConsumer(queue); connection.start(); // Loops to receive the messages System.out.println("\nInfinite loop. Waiting for a message..."); while (true) { TextMessage message = (TextMessage) consumer.receive(); System.out.println("Message received: " + message.getText()); } } catch (Exception e) { e.printStackTrace(); } }
public static void main(String[] args) throws JMSException { AsyncSimpleConsumer asyncConsumer = new AsyncSimpleConsumer(); ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url); Connection connection = connectionFactory.createConnection(); connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Destination destination = session.createQueue(subject); MessageConsumer consumer = session.createConsumer(destination); consumer.setMessageListener(asyncConsumer); connection.setExceptionListener(asyncConsumer); try { while (true) { if (AsyncSimpleConsumer.catchExit) { break; } Thread.sleep(1000); } } catch (InterruptedException e) { System.out.println("Sleep interrupted"); } connection.close(); }
public static void main(String[] args) throws JMSException { // Getting JMS connection from the server ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url); Connection connection = connectionFactory.createConnection(); connection.start(); // Creating session for seding messages Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); // Getting the queue 'JMSBEGINQUEUE' Destination destination = session.createQueue(subject); // MessageConsumer is used for receiving (consuming) messages MessageConsumer consumer = session.createConsumer(destination); // Here we receive the message. // By default this call is blocking, which means it will wait // for a message to arrive on the queue. Message message = consumer.receive(); // There are many types of Message and TextMessage // is just one of them. Producer sent us a TextMessage // so we must cast to it to get access to its .getText() // method. if (message instanceof TextMessage) { TextMessage textMessage = (TextMessage) message; System.out.println("Received message '" + textMessage.getText() + "'"); } connection.close(); }
public static void main(String[] args) { try { Context ctx = new InitialContext(); ConnectionFactory factory = (ConnectionFactory) ctx.lookup("ConnectionFactory"); Queue queue = (Queue) ctx.lookup("inbound"); Connection con = factory.createConnection(); final Session session = con.createSession(false, Session.AUTO_ACKNOWLEDGE); final MessageConsumer consumer = session.createConsumer(queue); consumer.setMessageListener( new MessageListener() { @Override public void onMessage(Message message) { final String type; try { type = message.getStringProperty("type"); if (type != null && type.equals("xml")) { System.out.println(((TextMessage) message).getText()); } } catch (JMSException e) { e.printStackTrace(); } } }); con.start(); } catch (Exception e) { e.printStackTrace(); } }
/** * Receive a message from destination with timeout. * * @param destinationName destinationName * @param timeout timeout * @return message */ public String receiveTextMessageFromDestinationWithTimeout( final String destinationName, final int timeout) { if (!this.isConnected()) { throw new JmsNotConnectedException("Not connected"); } MessageConsumer consumer = getConsumer(destinationName); TextMessage message; try { if (timeout == 0) { message = (TextMessage) consumer.receiveNoWait(); } else { message = (TextMessage) consumer.receive(timeout); } if (message != null) { if (acknowledgeMode == Session.CLIENT_ACKNOWLEDGE) { message.acknowledge(); } return message.getText(); } else { return null; } } catch (JMSException e) { throw new IllegalStateException("Unable to receive message from " + destinationName, e); } }
public static void main(String args[]) { Connection connection = null; try { // JNDI lookup of JMS Connection Factory and JMS Destination Context context = new InitialContext(); ConnectionFactory factory = (ConnectionFactory) context.lookup(CONNECTION_FACTORY_NAME); Destination destination = (Destination) context.lookup(DESTINATION_NAME); connection = factory.createConnection(); connection.start(); Session session = connection.createSession(NON_TRANSACTED, Session.AUTO_ACKNOWLEDGE); MessageConsumer consumer = session.createConsumer(destination); LOG.info( "Start consuming messages from " + destination.toString() + " with " + MESSAGE_TIMEOUT_MILLISECONDS + "ms timeout"); // Synchronous message consumer int i = 1; while (true) { Message message = consumer.receive(MESSAGE_TIMEOUT_MILLISECONDS); if (message != null) { if (message instanceof TextMessage) { String text = ((TextMessage) message).getText(); LOG.info("Got " + (i++) + ". message: " + text); } } else { break; } } consumer.close(); session.close(); } catch (Throwable t) { LOG.error("Error receiving message", t); } finally { // Cleanup code // In general, you should always close producers, consumers, // sessions, and connections in reverse order of creation. // For this simple example, a JMS connection.close will // clean up all other resources. if (connection != null) { try { connection.close(); } catch (JMSException e) { LOG.error("Error closing connection", e); } } } }
public static void main(String[] args) { String url = BROKER_URL; if (args.length > 0) { url = args[0].trim(); } System.out.println( "\nWaiting to receive messages... will timeout after " + TIMEOUT / 1000 + "s"); ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("admin", "password", url); Connection connection = null; try { connection = connectionFactory.createConnection(); connection.start(); Session session = connection.createSession(NON_TRANSACTED, Session.AUTO_ACKNOWLEDGE); Queue destination = session.createQueue("test-queue?consumer.exclusive=true"); MessageConsumer consumer = session.createConsumer(destination); int i = 0; while (true) { Message message = consumer.receive(TIMEOUT); if (message != null) { if (message instanceof TextMessage) { String text = ((TextMessage) message).getText(); System.out.println("Got " + i++ + ". message: " + text); } } else { break; } } consumer.close(); session.close(); } catch (Exception e) { System.out.println("Caught exception!"); } finally { if (connection != null) { try { connection.close(); } catch (JMSException e) { System.out.println("Could not close an open connection..."); } } } }
public static void main(String[] args) throws JMSException { String user = env("ACTIVEMQ_USER", ""); String password = env("ACTIVEMQ_PASSWORD", ""); String host = env("ACTIVEMQ_HOST", "localhost"); int port = Integer.parseInt(env("ACTIVEMQ_PORT", "61616")); String destination = arg(args, 0, "foo.bar"); ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("tcp://" + host + ":" + port); Connection connection = factory.createConnection(user, password); connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Destination dest = new ActiveMQQueue(destination); MessageConsumer consumer = session.createConsumer(dest); long start = System.currentTimeMillis(); long count = 1; System.out.println("Waiting for messages..."); while (true) { Message msg = consumer.receive(); if (msg instanceof TextMessage) { String body = ((TextMessage) msg).getText(); if ("THE.END".equals(body)) { long diff = System.currentTimeMillis() - start; System.out.println( String.format("Received %d in %.2f seconds", count, (1.0 * diff / 1000.0))); break; } else { if (count != msg.getIntProperty("id")) { System.out.println("mismatch: " + count + "!=" + msg.getIntProperty("id")); } count = msg.getIntProperty("id"); if (count == 0) { start = System.currentTimeMillis(); } if (count % 1000 == 0) { System.out.println(String.format("Received %d messages.", count)); } count++; } } else { System.out.println("Unexpected message type: " + msg.getClass()); } } connection.close(); }
/** * Receives a command from a queue synchronously. If this queue also has listeners, then commands * will be distributed across all consumers. * * @param queueName name of queue * @param timeout timeout in milliseconds. If a command is not received during a timeout, this * methods returns null. * @return command if found. If command not found, this method will block till a command is * present in queue or a timeout expires. */ public Command receiveCommand(String queueName, long timeout) { Session session = null; try { session = consumerConnection.createSession(); Queue queue = (Queue) jmsServer.lookup("/queue/" + queueName); MessageConsumer consumer = session.createConsumer(queue); return message2Command((TextMessage) consumer.receive(timeout)); } catch (Exception e) { throw new HornetNestException("Could not get command", e); } finally { try { if (session != null) session.close(); } catch (Throwable e) { } } }
public DigitalLibraryServer() { try { Properties properties = new Properties(); properties.put(Context.INITIAL_CONTEXT_FACTORY, "org.jnp.interfaces.NamingContextFactory"); properties.put(Context.URL_PKG_PREFIXES, "org.jnp.interfaces"); properties.put(Context.PROVIDER_URL, "localhost"); InitialContext jndi = new InitialContext(properties); ConnectionFactory conFactory = (ConnectionFactory) jndi.lookup("XAConnectionFactory"); connection = conFactory.createConnection(); session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); try { counterTopic = (Topic) jndi.lookup("counterTopic"); } catch (NamingException NE1) { System.out.println("NamingException: " + NE1 + " : Continuing anyway..."); } if (null == counterTopic) { counterTopic = session.createTopic("counterTopic"); jndi.bind("counterTopic", counterTopic); } consumer = session.createConsumer(counterTopic); consumer.setMessageListener(this); System.out.println("Server started waiting for client requests"); connection.start(); } catch (NamingException NE) { System.out.println("Naming Exception: " + NE); } catch (JMSException JMSE) { System.out.println("JMS Exception: " + JMSE); JMSE.printStackTrace(); } }
@Test public void testReceiveMessageTimeout() throws JMSException { JmsMessageReceiver receiver = new JmsMessageReceiver(); receiver.setConnectionFactory(connectionFactory); receiver.setDestination(destination); reset(jmsTemplate, connectionFactory, destination, connection, session, messageConsumer); expect(connectionFactory.createConnection()).andReturn(connection).once(); expect(connection.createSession(anyBoolean(), anyInt())).andReturn(session).once(); expect(session.getTransacted()).andReturn(false).once(); expect(session.getAcknowledgeMode()).andReturn(Session.AUTO_ACKNOWLEDGE).once(); expect(session.createConsumer(destination, null)).andReturn(messageConsumer).once(); expect(messageConsumer.receive(5000L)).andReturn(null).once(); connection.start(); expectLastCall().once(); replay(jmsTemplate, connectionFactory, destination, connection, session, messageConsumer); try { receiver.receive(); } catch (ActionTimeoutException e) { Assert.assertTrue( e.getMessage().startsWith("Action timed out while receiving JMS message on")); return; } Assert.fail( "Missing " + CitrusRuntimeException.class + " because of receiveing message timeout"); }
/** * Stellt die Nachricht an alle Consumer zu. * * @param consumers die Message-Consumer. * @param msg */ private void deliver(Message msg) { if (pool.isTerminating() || pool.isTerminated()) { Logger.warn("shutdown in progress, no more messages accepted"); return; // wir nehmen keine Nachrichten mehr entgegen. } // BUGZILLA 1413 Wir koennen leider doch nicht auf einer Kopie der Liste arbeiten, weil // diese waehrend der Zustellung erweitert werden kann. Z.bsp. der "AutoRegisterMessageConsumer" // erhaelt die SYSTEM_STARTED-Message und registriert daraufhin neue Consumer. Unter anderem // den DeployMessageConsumer aus jameica.webadmin, der ebenfalls auf die SYSTEM_STARTED-Message // lauscht. Logger.debug("deliver message " + msg.toString()); MessageConsumer consumer = null; for (int i = 0; i < this.consumers.size(); ++i) { consumer = this.consumers.get(i); Class[] expected = consumer.getExpectedMessageTypes(); boolean send = expected == null; if (expected != null) { for (int j = 0; j < expected.length; ++j) { if (expected[j].isInstance(msg)) { send = true; break; } } } try { if (send) consumer.handleMessage(msg); } catch (ApplicationException ae) { Application.getMessagingFactory() .sendSyncMessage(new StatusBarMessage(ae.getMessage(), StatusBarMessage.TYPE_ERROR)); } catch (OperationCanceledException oce) { Logger.debug("consumer " + consumer.getClass().getName() + " cancelled message " + msg); } catch (Throwable t) { Logger.error( "consumer " + consumer.getClass().getName() + " produced an error (" + t.getClass().getName() + ": " + t + ") while consuming message " + msg); Logger.write(Level.INFO, "error while processing message", t); } } }
private void consume() { try { consumer = session.createConsumer(queue); message = consumer.receive(); } catch (JMSException e) { e.printStackTrace(); } }
@Override public void stop() { try { messageConsumer.close(); connection.stop(); } catch (JMSException e) { e.printStackTrace(); } }
public void run() { try { // Create a ConnectionFactory String conStr = "tcp://localhost:61616"; ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(conStr); System.out.println("Connecting..."); // Create a Connection Connection connection = connectionFactory.createConnection(); connection.start(); connection.setExceptionListener(this); // Create a Session Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); // Create the destination (Topic or Queue) Destination destination = session.createTopic("TEST.FOO"); // Create a MessageConsumer from the Session to the Topic or // Queue MessageConsumer consumer = session.createConsumer(destination); while (true) { // Wait for a message Message message = consumer.receive(1000); if (message instanceof TextMessage) { TextMessage textMessage = (TextMessage) message; String text = textMessage.getText(); System.out.println("Received: " + text); } else { System.out.println("Received: " + message); } } } catch (Exception e) { System.out.println("Caught: " + e); e.printStackTrace(); } }
public Value receive(Env env, @Optional("1") long timeout) throws JMSException { Message message = _consumer.receive(timeout); if (message == null) return BooleanValue.FALSE; if (message instanceof ObjectMessage) { Object object = ((ObjectMessage) message).getObject(); return env.wrapJava(object); } else if (message instanceof TextMessage) { return env.createString(((TextMessage) message).getText()); } else if (message instanceof StreamMessage) { Object object = ((StreamMessage) message).readObject(); return env.wrapJava(object); } else if (message instanceof BytesMessage) { BytesMessage bytesMessage = (BytesMessage) message; int length = (int) bytesMessage.getBodyLength(); StringValue bb = env.createBinaryBuilder(length); TempBuffer tempBuffer = TempBuffer.allocate(); int sublen; while (true) { sublen = bytesMessage.readBytes(tempBuffer.getBuffer()); if (sublen > 0) bb.append(tempBuffer.getBuffer(), 0, sublen); else break; } TempBuffer.free(tempBuffer); return bb; } else if (message instanceof MapMessage) { MapMessage mapMessage = (MapMessage) message; Enumeration mapNames = mapMessage.getMapNames(); ArrayValue array = new ArrayValueImpl(); while (mapNames.hasMoreElements()) { String name = mapNames.nextElement().toString(); Object object = mapMessage.getObject(name); array.put(env.createString(name), env.wrapJava(object)); } return array; } else { return BooleanValue.FALSE; } }
/** * @see * de.willuhn.jameica.messaging.MessagingQueue#unRegisterMessageConsumer(de.willuhn.jameica.messaging.MessageConsumer) */ public void unRegisterMessageConsumer(MessageConsumer consumer) { if (consumer == null) return; if (this.consumers.size() == 0) { Logger.debug("queue contains no consumers, skip unregistering"); return; } Logger.debug( "queue " + this.name + ": unregistering message consumer " + consumer.getClass().getName()); this.consumers.remove(consumer); }
private void setupMessageQueueConsumer() { ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(messageBrokerUrl); Connection connection; try { connection = connectionFactory.createConnection(); connection.start(); this.session = connection.createSession(this.transacted, ackMode); Destination adminQueue = this.session.createQueue(messageQueueName); // Setup a message producer to respond to messages from clients, we will get the destination // to send to from the JMSReplyTo header field from a Message this.replyProducer = this.session.createProducer(null); this.replyProducer.setDeliveryMode(DeliveryMode.NON_PERSISTENT); // Set up a consumer to consume messages off of the admin queue MessageConsumer consumer = this.session.createConsumer(adminQueue); consumer.setMessageListener(this); } catch (JMSException e) { // Handle the exception appropriately } }
@Override public void start() { try { connection = connectionFactory.createConnection(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); messageConsumer = session.createConsumer(schedulerQueue); messageConsumer.setMessageListener(this); connection.start(); } catch (JMSException e) { e.printStackTrace(); } }
public static void main(String[] args) throws Exception { stopMQService(); ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(); Connection connection = connectionFactory.createConnection(); connection.start(); final Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE); Destination destination = session.createQueue("my-queue"); MessageConsumer consumer = session.createConsumer(destination); /* * //listener 方式 consumer.setMessageListener(new MessageListener() { * * public void onMessage(Message msg) { MapMessage message = * (MapMessage) msg; //TODO something.... System.out.println("收到消息:" + * new Date(message.getLong("count"))); session.commit(); } * * }); Thread.sleep(30000); */ int i = 0; int num = 0; while (i < 3) { num++; MapMessage message = (MapMessage) consumer.receive(); session.commit(); // TODO something.... // System.out.println("收到消息:" + new Date(message.getLong("count"))); System.out.println("2收到第" + num + "条消息:" + message.getString("count")); // System.out.println("收到第"+num+"条消息:" + message.getString("mes")); } session.close(); connection.close(); }
/** @param args the command line arguments */ public static void main(String[] args) throws NamingException, JMSException, InterruptedException { BasicConfigurator.resetConfiguration(); BasicConfigurator.configure(); try { Properties props = new Properties(); props.setProperty( Context.INITIAL_CONTEXT_FACTORY, "org.apache.activemq.jndi.ActiveMQInitialContextFactory"); props.setProperty(Context.PROVIDER_URL, "tcp://miniserver.local:61616"); Context context = new InitialContext(props); ConnectionFactory connectionFactory = (ConnectionFactory) context.lookup("ConnectionFactory"); FileSystemListener myListener = new FileSystemListener(); Destination destination = (Destination) context.lookup("dynamicTopics/eXistdb"); LOG.info("Destination=" + destination); Connection connection = connectionFactory.createConnection(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); MessageConsumer messageConsumer = session.createConsumer(destination); messageConsumer.setMessageListener(myListener); connection.start(); LOG.info("Receiver is ready"); } catch (Throwable t) { LOG.error(t.getMessage(), t); } }
@Override public T take() throws FalconException { try { TextMessage textMessage = (TextMessage) consumer.receive(); T event = new RerunEventFactory<T>() .getRerunEvent(textMessage.getStringProperty("TYPE"), textMessage.getText()); LOG.debug("Dequeued Message: {}", event.toString()); return event; } catch (Exception e) { LOG.error("Error getting the message from ActiveMQ", e); throw new FalconException("Error getting the message from ActiveMQ: ", e); } }
/** * @see * de.willuhn.jameica.messaging.MessagingQueue#registerMessageConsumer(de.willuhn.jameica.messaging.MessageConsumer) */ public void registerMessageConsumer(MessageConsumer consumer) { if (consumer == null) return; Logger.debug( "queue " + this.name + ": registering message consumer " + consumer.getClass().getName()); this.consumers.add(consumer); // Wir haben mindestens eine zwischengespeicherte Message und wenigstens einen Consumer - wir // koennen die Queue jetzt leeren int size = this.queue.size(); if (size > 0) { Logger.info("delivering " + size + " queued messages to queue: " + this.name); this.queue.drainTo(messages); } }
@Test public void testWithMessageSelectorAndCustomTimeout() throws JMSException { JmsMessageReceiver receiver = new JmsMessageReceiver(); receiver.setConnectionFactory(connectionFactory); receiver.setDestination(destination); receiver.setReceiveTimeout(10000L); Map<String, Object> controlHeaders = new HashMap<String, Object>(); final Message<String> controlMessage = MessageBuilder.withPayload("<TestRequest><Message>Hello World!</Message></TestRequest>") .copyHeaders(controlHeaders) .build(); Map<String, String> headers = new HashMap<String, String>(); reset(jmsTemplate, connectionFactory, destination, connection, session, messageConsumer); expect(connectionFactory.createConnection()).andReturn(connection).once(); expect(connection.createSession(anyBoolean(), anyInt())).andReturn(session).once(); expect(session.getTransacted()).andReturn(false).once(); expect(session.getAcknowledgeMode()).andReturn(Session.AUTO_ACKNOWLEDGE).once(); expect(session.createConsumer(destination, "Operation = 'sayHello'")) .andReturn(messageConsumer) .once(); connection.start(); expectLastCall().once(); expect(messageConsumer.receive(10000L)) .andReturn( new TextMessageImpl( "<TestRequest><Message>Hello World!</Message></TestRequest>", headers)) .once(); replay(jmsTemplate, connectionFactory, destination, connection, session, messageConsumer); Message<?> receivedMessage = receiver.receiveSelected("Operation = 'sayHello'"); Assert.assertEquals(receivedMessage.getPayload(), controlMessage.getPayload()); verify(jmsTemplate, connectionFactory, destination, connection, session, messageConsumer); }
public static void main(String[] args) { _logger.info("Starting..."); final String host; final int port; final String username; final String password; final String virtualPath; final int numExpectedMessages; if (args.length == 0) { host = "localhost"; port = 5672; username = "******"; password = "******"; virtualPath = "/test"; numExpectedMessages = 100; } else if (args.length == 6) { host = args[0]; port = Integer.parseInt(args[1]); username = args[2]; password = args[3]; virtualPath = args[4]; numExpectedMessages = Integer.parseInt(args[5]); } else { System.out.println("Usage: host port username password virtual-path expectedMessageCount"); System.exit(1); throw new RuntimeException("cannot be reached"); } try { InetAddress address = InetAddress.getLocalHost(); AMQConnection con = new AMQConnection(host, port, username, password, address.getHostName(), virtualPath); final AMQSession session = (AMQSession) con.createSession(false, Session.AUTO_ACKNOWLEDGE); final int expectedMessageCount = numExpectedMessages; MessageConsumer consumer = session.createConsumer( new AMQTopic(session.getDefaultTopicExchangeName(), new AMQShortString("large")), 100, true, false, null); consumer.setMessageListener( new MessageListener() { private int _messageCount; private long _startTime = 0; public void onMessage(Message message) { validateMessage(message); if (_messageCount++ == 0) { _startTime = System.currentTimeMillis(); } if (_logger.isInfoEnabled()) { _logger.info("Got message '" + message + "'"); } if (_messageCount == expectedMessageCount) { long totalTime = System.currentTimeMillis() - _startTime; _logger.error( "Total time to receive " + _messageCount + " messages was " + totalTime + "ms. Rate is " + (_messageCount / (totalTime / 1000.0))); } } private void validateMessage(Message message) { if (!(message instanceof BytesMessage)) { _logger.error( "Message is not of correct type - should be BytesMessage and is " + message.getClass()); } BytesMessage bm = (BytesMessage) message; final int expectedSize = 1024 * 187; // 187k try { if (bm.getBodyLength() != expectedSize) { _logger.error( "Message is not correct length - should be " + expectedSize + " and is " + bm.getBodyLength()); } } catch (JMSException e) { _logger.error("Failed to validate message: " + e, e); } try { byte[] data = new byte[(int) bm.getBodyLength()]; bm.readBytes(data); for (int i = 0; i < data.length; i++) { if (data[i] != (byte) (i % 25)) { _logger.error( "byte " + i + " of message is wrong - should be " + i % 25 + " but is " + data[i]); } } _logger.info("***** Validated message successfully"); } catch (JMSException e) { _logger.error("Failed to validate message: " + e, e); } } }); con.start(); } catch (Throwable t) { System.err.println("Fatal error: " + t); t.printStackTrace(); } System.out.println("Waiting..."); }
public static void main(String... args) throws Exception { ConnectionFactory connectionFactory = null; Connection connection = null; Session session = null; MessageProducer producer = null; MessageConsumer consumer = null; Destination destination = null; TextMessage message = null; Context context = null; try { // Set up the context for the JNDI lookup final Properties env = new Properties(); env.put(Context.INITIAL_CONTEXT_FACTORY, INITIAL_CONTEXT_FACTORY); env.put(Context.PROVIDER_URL, System.getProperty(Context.PROVIDER_URL, PROVIDER_URL)); env.put(Context.SECURITY_PRINCIPAL, System.getProperty("username", DEFAULT_USERNAME)); env.put(Context.SECURITY_CREDENTIALS, System.getProperty("password", DEFAULT_PASSWORD)); context = new InitialContext(env); // Perform the JNDI lookups String connectionFactoryString = System.getProperty("connection.factory", DEFAULT_CONNECTION_FACTORY); log.info("Attempting to acquire connection factory \"" + connectionFactoryString + "\""); connectionFactory = (ConnectionFactory) context.lookup(connectionFactoryString); log.info("Found connection factory \"" + connectionFactoryString + "\" in JNDI"); String destinationString = System.getProperty("destination", DEFAULT_DESTINATION); log.info("Attempting to acquire destination \"" + destinationString + "\""); destination = (Destination) context.lookup(destinationString); log.info("Found destination \"" + destinationString + "\" in JNDI"); // Create the JMS connection, session, producer, and consumer connection = connectionFactory.createConnection( System.getProperty("username", DEFAULT_USERNAME), System.getProperty("password", DEFAULT_PASSWORD)); session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); producer = session.createProducer(destination); consumer = session.createConsumer(destination); connection.start(); int count = Integer.parseInt(System.getProperty("message.count", DEFAULT_MESSAGE_COUNT)); String content = System.getProperty("message.content", DEFAULT_MESSAGE); log.info("Sending " + count + " messages with content: " + content); // Send the specified number of messages for (int i = 0; i < count; i++) { message = session.createTextMessage(content); producer.send(message); } // Then receive the same number of messages that were sent for (int i = 0; i < count; i++) { message = (TextMessage) consumer.receive(5000); log.info("Received message with content " + message.getText()); } } catch (Exception exception) { log.severe(exception.getMessage()); throw exception; } finally { if (context != null) { context.close(); } // closing the connection takes care of the session, producer, and consumer if (connection != null) { connection.close(); } } }
@Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=UTF-8"); PrintWriter out = response.getWriter(); out.println("<html><head></head><body>"); try { // Gather necessary JMS resources Context ctx = new InitialContext(); ConnectionFactory cf = (ConnectionFactory) ctx.lookup("jms/myConnectionFactory"); Connection con = cf.createConnection(); con.start(); // don't forget to start the connection QueueSession session = (QueueSession) con.createSession(false, Session.AUTO_ACKNOWLEDGE); // The PITsnapshot Queue is used for responses from the Players to this serverlet Queue q = (Queue) ctx.lookup("jms/PITsnapshot"); MessageConsumer reader = session.createConsumer(q); /* * Throw out old PITsnapshot messages that may have been left from past * snapshots that did not complete (because of some error). */ ObjectMessage m = null; while ((m = (ObjectMessage) reader.receiveNoWait()) != null) { System.out.println("Found an orphaned PITsnapshot message"); } // Initialize the snapshot my sending a marker to a Player sendInitSnapshot(); /* * Receive the snapshot messages from all Players. * Each snapshot is a HahsMap. Put them into an array of HashMaps * */ HashMap state[] = new HashMap[numPlayers + 1]; int stateResponses = 0; int failures = 0; while (stateResponses < numPlayers) { if ((m = (ObjectMessage) reader.receive(1000)) == null) { if (++failures > 10) { System.out.println("Not all players reported, giving up after " + stateResponses); break; } continue; } state[stateResponses++] = (HashMap) m.getObject(); } /* * For each commodity, sum the number of them reported from * each Player. Store these into a two dimensional table * that will then be used to generate the report back to the user. */ String commodity[] = {"rice", "gold", "oil"}; int total[][] = new int[numPlayers][commodity.length]; for (int c = 0; c < commodity.length; c++) { for (int p = 0; p < stateResponses; p++) { try { Integer ccount = (Integer) state[p].get(commodity[c]); if (ccount == null) { total[p][c] = 0; } else { total[p][c] = (Integer) ccount.intValue(); } } catch (Exception e) { System.out.println("Servlet threw exception " + e); } } } /* * Now turn the table of commodities, and the state from each Player * into a response to the user. */ for (int c = 0; c < commodity.length; c++) { int ctotal = 0; out.print("<h2>Commodity: " + commodity[c] + "</h2>"); out.print("<table border='1'><tr><th>Player</th><th>Quantity</th></tr>"); for (int p = 0; p < stateResponses; p++) { out.print("<tr><td>" + p + "</td><td>" + total[p][c] + "</td></tr>"); ctotal += total[p][c]; } out.print("<tr><td><b>Total</b></td><td>" + ctotal + "</td></tr>"); out.print("</table></br></br>"); } // Close the connection con.close(); out.println("</BODY></HTML>"); } catch (Exception e) { System.out.println("Servlet threw exception " + e); } finally { out.println("</body></html>"); out.close(); } }
public static void main(String[] args) { Connection connection = null; try { Context context = new InitialContext(); ConnectionFactory factory = (ConnectionFactory) context.lookup(CONNECTION_FACTORY_NAME); Destination destination = (Destination) context.lookup(DESTINATION_NAME); Destination controlDestination = (Destination) context.lookup(CONTROL_DESTINATION_NAME); connection = factory.createConnection(); // create a session for the control producer Session session = connection.createSession(NON_TRANSACTED, Session.AUTO_ACKNOWLEDGE); MessageProducer controlProducer = session.createProducer(controlDestination); MessageConsumer consumer = session.createConsumer(destination); consumer.setMessageListener(new JmsMessageListener(session, controlProducer)); // Must have a separate session or connection for the sync MessageConsumer // per JMS spec you cannot have sync and async message consumers on the same // session Session controlSession = connection.createSession(NON_TRANSACTED, Session.AUTO_ACKNOWLEDGE); MessageConsumer controlConsumer = controlSession.createConsumer(controlDestination); // calling start after the listeners have been registered connection.start(); LOG.info("Start control message consumer"); int i = 1; while (true) { // sync receive for message consumer Message message = controlConsumer.receive(MESSAGE_TIMEOUT_MILLISECONDS); if (message != null) { if (message instanceof TextMessage) { TextMessage textMessage = (TextMessage) message; String text = textMessage.getText(); LOG.info("Got " + (i++) + ". message: " + text); if (text.startsWith("SHUTDOWN")) { break; } } } } controlConsumer.close(); controlSession.close(); consumer.close(); controlProducer.close(); session.close(); } catch (Exception e) { LOG.error(e); } finally { // got to clean up the connections and other resources! if (connection != null) { try { connection.close(); } catch (JMSException e) { LOG.error(e); } } } }
@Override public int run() throws Exception { // Default values of command line arguments String host = DEFAULT_HOST; int port = DEFAULT_PORT; String user = DEFAULT_USER; String pass = DEFAULT_PASS; String destination = DEFAULT_DESTINATION; String file = ""; // No default -- if not given, don't read/write file int sleep = 0; boolean showpercent = false; int batchSize = 0; int length = 500; // Length of message generated internally String properties = ""; String format = "short"; String durable = null; int n = 1; // n is the number of messages to process, or a specific // message number, depending on content String url = ""; // No default -- if not given, don't use it String[] nonSwitchArgs = cl.getArgs(); if (nonSwitchArgs.length > 0) n = Integer.parseInt(nonSwitchArgs[0]); String _destination = cl.getOptionValue("destination"); if (_destination != null) destination = _destination; String _host = cl.getOptionValue("host"); if (_host != null) host = _host; String _port = cl.getOptionValue("port"); if (_port != null) port = Integer.parseInt(_port); String _file = cl.getOptionValue("file"); if (_file != null) file = _file; String _user = cl.getOptionValue("user"); if (_user != null) user = _user; String _pass = cl.getOptionValue("password"); if (_pass != null) pass = _pass; String _url = cl.getOptionValue("url"); if (_url != null) url = _url; String _sleep = cl.getOptionValue("sleep"); if (_sleep != null) sleep = Integer.parseInt(_sleep); if (cl.hasOption("percent")) showpercent = true; String _batchSize = cl.getOptionValue("batch"); if (_batchSize != null) batchSize = Integer.parseInt(_batchSize); String _L = cl.getOptionValue("length"); if (_L != null) length = Integer.parseInt(_L); String _properties = cl.getOptionValue("properties"); if (_properties != null) properties = _properties; String _durable = cl.getOptionValue("durable"); if (_durable != null) durable = _durable; boolean batch = false; if (batchSize != 0) batch = true; String _format = cl.getOptionValue("format"); if (_format != null) format = _format; ActiveMQConnectionFactory factory = getFactory(host, port, url); Connection connection = factory.createConnection(user, pass); if (durable != null) connection.setClientID(durable); connection.start(); Session session = connection.createSession(batch, Session.AUTO_ACKNOWLEDGE); Topic topic = session.createTopic(destination); MessageConsumer consumer = null; if (durable != null) consumer = session.createDurableSubscriber(topic, "amqutil"); else consumer = session.createConsumer(topic); int oldpercent = 0; for (int i = 0; i < n; i++) { javax.jms.Message message = consumer.receive(); if (batch) if ((i + 1) % batchSize == 0) session.commit(); if (sleep != 0) Thread.sleep(sleep); JMSUtil.outputMessage(format, message, file); if (showpercent) { int percent = i * 100 / n; if (percent != oldpercent) System.out.println("" + percent + "%"); oldpercent = percent; } } if (batch) session.commit(); connection.close(); return 0; }