Message-Oriented-Middleware
provide a common reliable way for programs to create,
send, receive and read messages in any distributed
Enterprise System.
MOM ensures fast, reliable asynchronous electronic
communication, guaranteed message delivery, receipt
notification and transaction control.
The Java Message Service (JMS) provides a standard
Java-based interface to the message services of a MOM
of some other provider.
Messaging systems are classified into
different models that determine which client receives
a message. The most common messaging models are:
Publish-Subscribe
Messaging
Point-To-Point
Messaging
Request-Reply
Messaging
Not
all MOM providers support all these models.
Publish-Subscribe Messaging
When multiple applications need to
receive the same messages, Publish-Subscribe
Messaging is used. The central concept in a Publish-Subscribe
messaging system is the Topic. Multiple Publishers
may send messages to a Topic, and all Subscribers to
that Topic receive all the messages sent to that
Topic. This model, as shown in Figure 1, is extremely
useful when a group of applications want to notify
each other of a particular occurrence.
The point to note in Publish-Subscribe Messaging is
that, there may be multiple Senders and multiple
Receivers.
Figure 1: Publish-Subscribe
Based Messaging System
Point-To-Point Messaging
When one process needs to send a
message to another process, Point-To-Point Messaging
can be used. However, this may or may not be a one-way
relationship. The client to a Messaging system may
only send messages, only receive messages, or send
and receive messages. At the same time, another
client can also send and/or receive messages. In the
simplest case, one client is the Sender of the
message and the other client is the Receiver of the
message.
There are two basic types of Point-to-Point Messaging
systems. The first one involves a client that
directly sends a message to another client. The
second and more common implementation is based on the
concept of a Message Queue. Such a system is shown in
Figure 2.
The point to note in Point-to-Point messaging is that,
even though there may be multiple Senders of messages,
there is only a single Receiver for the messages.
Figure 2: Queue
Based (Point-to-Point) Messaging System
Request-Reply Messaging
When an application sends a message and expects to
receive a message in return, Request-Reply Messaging
can be used. This is the standard synchronous object-messaging
format. This messaging model is often defined as a
subset of one of the other two models. JMS does not
explicitly support Request-Reply Messaging, though it
allows it in the context of the other methods.
The Java Message Service (JMS)
Architecture
Figure 3 shows the JMS Architecture. As shown in
Figure 3, JMS Service Providers implement the JMS
interface on top of their messaging services. JMS
defines Queues and Topics, but it does not require
the provider to implement both. JMS thus tries to
maximize portability of the solution with as many
features as possible.
Figure 3: The
Java Message Service Architecture
The primary features of JMS are as
follows:
Connection
Factories are used in JMS to create connections to a
specific JMS provider.
In JMS, both
Publish-Subscribe Messaging and Point-To-Point are
implemented and defined by separate interfaces so
that a Provider does not have to support both.
JMS defines
the concept of a Topic or a Queue as the target for a
Message. Topics are used for Publish-Subscribe
Messaging. Queues are used for Point-to-Point
Messaging.
The Providers’
code is defined by interfaces in JMS, freeing the
implementation from the limitations of subclassing.
JMS provides
support for distributed transactions.
The
Java Message Service API
Both Publish-Subscribe Messaging and Point-To-Point
Messaging inherit from a common set of abstract
interfaces as shown in Table 1.
.gif){kind=small}