JMS
Administrative tools allow you to bind
destinations and connection factories into a JNDI namespace. A JMS client can
then use resource injection to access the administered objects in the namespace
and then establish a logical connection to the same objects through the JMS
provider.
Point to point messaging
·
Each message has only
one consumer.
·
A sender and a receiver
of a message have no timing dependencies. The receiver can fetch the message
whether or not it was running when the client sent the message.
·
The receiver
acknowledges the successful processing of a message.
Use PTP messaging when every message you send must be processed
successfully by one consumer.
Publish/subscribe messaging
·
Each message can have
multiple consumers.
·
Publishers and
subscribers have a timing dependency. A client that subscribes to a topic can
consume only messages published after the client has created a subscription,
and the subscriber must continue to be active in order for it to consume
messages.
The JMS API relaxes this timing dependency to
some extent by allowing subscribers to create durable
subscriptions, which receive messages sent while the subscribers are not
active.
Use pub/sub messaging when each message can
be processed by any number of consumers (or none).
Messages could be consumed – synchronously (blocking w/
timeout) or asynchronously (provider calls onMessage() of listener).
The basic building blocks of a JMS application are:
·
Administered objects: connection factories and
destinations
·
Connections
·
Sessions
·
Message producers
·
Message consumers
·
Messages
An EJB Client – message producer.
|
import
helloworld.beans.SingletonHelloWorldBeanRemote;
import helloworld.vo.GreetingRequest; import javax.jms.Connection; import javax.jms.ConnectionFactory; import javax.jms.Destination; import javax.jms.JMSException; import javax.jms.Message; import javax.jms.MessageProducer; import javax.jms.Session; import javax.jms.TextMessage; import javax.naming.Context; import javax.naming.InitialContext; import javax.naming.NamingException; /** * The message producer. * @author rwatsh */ public class MessageProducerApp { private static Message createJMSMessageForjmsHelloWorldQueue(Session session, Object messageData) throws JMSException { // TODO create and populate message to send TextMessage tm = session.createTextMessage(); tm.setText(messageData.toString()); return tm; } private static void sendJMSMessageToHelloWorldQueue(Object messageData) throws NamingException, JMSException { Context c = new InitialContext(); ConnectionFactory cf = (ConnectionFactory) c.lookup("jms/HelloWorldQueueFactory"); Connection conn = null; Session s = null; try { conn = cf.createConnection(); s = conn.createSession(false, s.AUTO_ACKNOWLEDGE); Destination destination = (Destination) c.lookup("jms/HelloWorldQueue"); MessageProducer mp = s.createProducer(destination); mp.send(createJMSMessageForjmsHelloWorldQueue(s, messageData)); } finally { if (s != null) { try { s.close(); } catch (JMSException e) { System.err.println("Cannot close session - " + e); } } if (conn != null) { conn.close(); } } } private static SingletonHelloWorldBeanRemote lookupSingletonHelloWorldBeanRemote() { try { Context c = new InitialContext(); return (SingletonHelloWorldBeanRemote) c.lookup("java:global/EJB31/EJB31-ejb/SingletonHelloWorldBean"); } catch (NamingException ne) { ne.printStackTrace(); throw new RuntimeException(ne); } } public static void main(String[] args) { SingletonHelloWorldBeanRemote hwr = lookupSingletonHelloWorldBeanRemote(); GreetingRequest result = hwr.sayHello(); String resultStr = result.toString(); try { sendJMSMessageToHelloWorldQueue(resultStr); System.out.println("MessageProducerApp.main: sent message - " + resultStr); } catch (Exception ex) { System.err.println("MessageProducerApp.main: failed to send message - " + ex); } } } |
MDB message receiver:
|
import helloworld.vo.GreetingRequest;
import java.util.logging.Level; import java.util.logging.Logger; import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; import javax.ejb.ActivationConfigProperty; import javax.ejb.MessageDriven; import javax.jms.JMSException; import javax.jms.Message; import javax.jms.MessageListener; import javax.jms.ObjectMessage; import javax.jms.TextMessage; /** * MDB that consumes the message. * @author rwatsh */ @MessageDriven(mappedName = "jms/HelloWorldQueue", activationConfig = { @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"), @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue") }) public class HelloWorldMDB implements MessageListener { public HelloWorldMDB() { } @PostConstruct private void postConstruct() { System.out.println("HelloWorldMDB: @PostConstruct"); } @Override public void onMessage(Message message) { if (message instanceof TextMessage) { try { TextMessage textMessage = (TextMessage) message; String messageValue = textMessage.getText(); System.out.println("HelloWorldMDB.onMessage: received text message - " + messageValue); } catch (JMSException ex) { Logger.getLogger(HelloWorldMDB.class.getName()).log(Level.SEVERE, null, ex); } } else if (message instanceof ObjectMessage) { try { ObjectMessage objMessage = (ObjectMessage) message; Object contents = objMessage.getObject(); if (contents instanceof GreetingRequest) { String messageValue = contents.toString(); System.out.println("HelloWorldMDB.onMessage: received object message - " + messageValue); } } catch (JMSException ex) { } } else { //do nothing } } @PreDestroy private void destroy() { System.out.println("HelloWorldMDB: @PreDestroy"); } } |
No comments:
Post a Comment