Its is an asynchronous communication between software components/applications
Sender sends to/receives the messages from messaging client. hence NO need to know about the other side of the communicator - who is receiving/sending.
It enables loosely coupled distributed communication
Ensures 100% reliability - Message is delivered to the client[acknowledgement] only once [accuracy]
Platform independent interface for Existing - Message Oriented Middleware System [MOM] like MQSeries from IBM.
It can be implemented through -EJB - Message driven beans, web components , application clients ....Or infact through simple POJOs.
Supports Distributed Transactions and allows concurrent consumption of messages as per EJB 3.0 specification
Through Java EE Connector Architecture [Resource Adapters - rsadapter], multiple JMS providers can be integrated with single Java EE application server.
Architecture:
A JMS application is composed of the following parts.
■ A JMS provider is a messaging system that implements the JMS interfaces and provides
administrative and control features. An implementation of the Java EE platform includes a
JMS provider.
■ JMS clients are the programs or components, written in the Java programming language,
that produce and consume messages. Any Java EE application component can act as a JMS
client.
■ Messages are the objects that communicate information between JMS clients.
■ Administered objects are preconfigured JMS objects created by an administrator for the use
of clients. The two kinds of JMS administered objects are destinations and connection factories. 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.
Admin Tool ---- Bind -->JNDI Namespace [Connection Factory & Destination]----inject Resouce---> JMS Client
JMS Client ---- Logical Connection ---> JMS Provider
Messaging Domains
Point to Point [PTP] - Messaging Domain[Queue]
A point-to-point (PTP) product or application is built on the concept of message queues,
senders, and receivers. Each message is addressed to a specific queue, and receiving clients
extract messages from the queues established to hold their messages. Queues retain all messages sent to them until the messages are consumed or until the messages expire.
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.
Client A --Msg-->Queue <--->Consumes & Acknowledges <--->Client B
Publish/Subscribe Messaging Domain [Topic]
In a publish/subscribe (pub/sub) product or application, clients address messages to a topic,
which functions somewhat like a bulletin board. Publishers and subscribers are generally
anonymous and can dynamically publish or subscribe to the content hierarchy. The system
takes care of distributing the messages arriving from a topic’s multiple publishers to its multiple
subscribers. Topics retain messages only as long as it takes to distribute them to current
subscribers.
Pub/sub messaging has the following characteristics.
■ 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. Durable subscriptions provide the flexibility and reliability of queues but still allow clients to send messages to many recipients. Use pub/sub messaging when each message can be processed by zero, one, or many consumers.
JMS API Programming Model
1. Admininistered Objects
Destination and Connection Factories are maintained by JMS Provider.
These objects can be located through JNDI
@Resource(mappedName="jms/ConnectionFactory")
private static ConnectionFactory connectionFactory;
@Resource(mappedName="jms/Queue")
private static Queue queue;
@Resource(mappedName="jms/Topic")
private static Topic topic;
2.Connections
A connection encapsulates a virtual connection with a JMS provider. A connection could
represent an open TCP/IP socket between a client and a provider service daemon. You use a
connection to create one or more sessions.
Connection connection = connectionFactory.createConnection();
3.Sessions
Session session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
A session is a single-threaded context for producing and consuming messages. You use sessions
to create the following:
■ Message producers -created by a session and used for sending messages to adestination
MessageProducer producer = session.createProducer(dest);
producer.send(message);
■ Message consumers - created by a session and used for receiving messages sent
to a destination
MessageConsumer consumer = session.createConsumer(dest);
connection.start();
Message m = consumer.receive();
■ JMS Message Listener
A message listener is an object that acts as an asynchronous event handler for messages. Thisobject implements the MessageListener interface, which contains one method, onMessage. Inthe onMessage method, you define the actions to be taken when a message arrives.You register the message listener with a specific MessageConsumer by using thesetMessageListener method. For example, if you define a class named Listener thatimplements the MessageListener interface, you can register the message listener as follows:
Listener myListener = new Listener();
consumer.setMessageListener(myListener);
After you register the message listener, you call the start method on the Connection to beginmessage delivery
■ Messages
Message has three parts - Message Headers, Message Properties and Message Bodies
Headers contains number of predefined fields that contain values that both clients and providers use to identify and to route messages like JMSMessagID, JMSDestination, JMSPriority etc
Message Properties are used to provide compatibility with other messaging systems.
Following message body formats are defined
Text Message -String message
MapMessage - A set of name value pairs with names as String and value as primitive
BytesMessage - a stream of uninterpreted bytes
StreamMessage- Primitives processed sequentially
ObjectMessage - Java Serialized object
Message - Message with just header and properties
Ex :
Sender
TextMessage message = session.createTextMessage();
message.setText(msg_text); // msg_text is a String
producer.send(message);
Receiver:
Message m = consumer.receive();
if (m instanceof TextMessage) {
TextMessage message = (TextMessage) m;
System.out.println("Reading message: " + message.getText());
} else {
// Handle error
}
8.JMS Message Selectors
To filter the messages
9.JMS Queue Browsers
To browse queue to chk specific message
10.JMS Exception
Root level checked exception JMSException
--------------------------------------
No comments:
Post a Comment