JMS Messaging Objects and Domains

In order to send or receive messages, a JMS client must first connect
to a JMS message server (most often called a broker):
the connection opens a channel of communication between the client and the
broker. Next, the client must set up a session for creating, producing, and
consuming messages. You can think of the session as a stream of messages defining
a particular conversation between the client and the broker. The client itself
is a message producer and/or a message consumer.
The message producer sends a message to a destination
that the broker manages. The message consumer accesses that destination to
consume the message. The message includes a header, optional properties, and
a body. The body holds the data; the header contains information the broker
needs to route and manage the message; and the properties can be defined by
client applications or by a provider to serve their own needs in processing
messages. Connections, sessions, destinations, messages, producers, and consumers
are the basic objects that make up a JMS application.

Using these basic objects, a client application can use two messaging
patterns (or domains) to send and receive messages. These
are shown in Figure 1–4.

Figure 1–4 JMS Messaging Domains

Clients A and B are message producers, sending messages to clients C,
D, E, and F by way of two different kinds of destinations.

Messaging between clients A, C, and D illustrates the point-to-point domain. Using this pattern, a client sends a message to a queue
destination from which only one receiver may get it. No other receiver accessing
that destination can get that specific message.

Messaging between clients B, E, and F illustrates the publish/subscribe domain. Using this broadcast pattern, a client sends a message
to a topic destination from which any number of consuming subscribers can
retrieve it. Each subscriber gets its own copy of the message.

Message consumers in either domain can choose to receive messages synchronously
or asynchronously. Synchronous consumers make an explicit
call to retrieve a message; asynchronous consumers specify
a callback method that is invoked to pass a pending message. Consumers can
also filter out messages by specifying selection criteria for incoming messages.