O'Reilly - Java Message Service

Java Message Service
multiple consumers can use the same queue, but each message delivered to the queue can
only be received by one of the queue's consumers. How messages delivered to a queue are
distributed to the queue's consumers depends on the policies of the JMS provider. Some
JMS providers use load-balancing techniques to distribute messages evenly among
consumers, while others will use more arbitrary policies.
Messages intended for a p2p queue can be either persistent or nonpersistent. Persistent
messages survive JMS provider failures, while nonpersistent messages do not. Messages
may have a priority and an expiration time. One important difference between point-topoint
and publish/subscribe messaging is that p2p messages are always delivered,
regardless of the current connection status of the receiver. Once a message is delivered to a
queue, it stays there even if there is no consumer currently connected. More details on
failure scenarios can be found in Chapter 6.
The interfaces for connecting, creating, sending and receiving are similar to the interfaces
for topics, as shown in Table 5.1.
Table 5.1. Interfaces for Topics and Queues
Topic Queue
TopicConnectionFactory QueueConnectionFactory
TopicSession QueueSession
TopicPublisher QueueSender
TopicSubscriber QueueReceiver
createTopicConnection( ) createQueueConnection( )
createTopicSession( ) createQueueSession( )
createTemporaryTopic( ) createTemporaryQueue( )
... ...
5.1.1 When to Use Point-to-Point Messaging
First, let's talk about why two distinct models exist. The rationale behind the two models
lies in the origin of the JMS specification. JMS started out as a way of providing a
common API for accessing existing messaging systems. At the time of its conception,
some messaging vendors had a p2p model, and some had a pub/sub model. Hence JMS
needed to provide an API for both models to gain wide industry support. The JMS 1.0.2
specification does not require a JMS provider to support both models, although most JMS
vendors do.
Almost anything that can be done with the pub/sub model can be done with point-to-point,
and vice versa. An analogy can be drawn to developers' programming language
preferences. In theory, any application that can be written with Pascal can also be written
with C. Anything that can be written in C++ can also be written in Java. In some cases it
comes down to a matter of preference, or which model you are already familiar with.
In most cases, the decision about which model to use depends on the distinct merits of
each model. With pub/sub, any number of subscribers can be listening on a topic, all
receiving copies of the same message. The publisher may not care if everybody is
70