Components required for JMS

JMS refers to Java Messaging Service which allows the software developers to loosely couple applications. It has an API (Application Programming Interface) through which we can receive, send, read, and create enterprise system messages.

JMS is a message oriented product which is quite expensive and complex. It provides an interface (Java) to write infrastructure code and allow solutions to be built easily and quickly.
 
Following are the main components of JMS:
 
I.   Administered Objects – Destination, ConnectionFactory
II.  Connection
III. Session
IV. Objects – MessageProducer, MessageConsumer, MessageListener, MessageSelector
 
The component relationship could be explained with the below diagram.
 
 
I. Administered Objects
 
Following are called as the administered objects as they are created by the JMS provider administrator:
 
i) Destination
ii) ConnectionFactory
 
Destination
 
This object has the configuration information provided by JMS provider. This object is used by the Client to specify the destination for messages to be send and location to receive the messages.
 
There are 2 types of Interfaces Destination uses. They are:
 
i) Queue – It belongs to PTP (Point To Point) model
ii) Topic – It belongs to pub/sub (Publish / Subscribe) model
 
Connection Factory
 
This object has the connection configuration information (IP address) provided by JMS provider. The connection is obtained through the Java Naming Directory Interface (JNDI) which enables the client to create a connection and get connected to the JMS server.
 
 
II. Connection
 
This component provides the connection (physical) to the JMS server. The physical connection is obtained with the help of ConnectionFactory object which provides the instances of configuration details to connect to the JMS server.
 
 
III. Session
 
This component is responsible to receiving and sending messages, and for handling acknowledgements and managing transactions with the help of JMS objects.
 
 
IV. Objects
 
It refers to the JMS object which are maintained and created by the admin that are used by the JMS clients. The following objects are used to receive and create messages in JMS:
 
i) MessageConsumer
ii) MessageProducer
iii) MessageSelector – This is used to filter the message that does not meet the specified criteria.
iv) MessageListener – This is used to process and receive messages asynchronously
 
 
MessageConsumer
 
MessageConsumer is for receiving messages synchronously or asynchronously to a particular destination which is created by the session object.
 
In case of synchronous communication, the consumer calls the any one of the methods receive or receiveNoWait and in case of asynchronous communication, the client registers MessageListener and starts consumer.
 
Almost all the messages in Java Messaging Service are exchanged asynchronously between clients where the producer never receive acknowledgement from consumer.
 
 
MessageProducer
 
MessageProducer is for sending messages either via PTP or through pub/sub. In PTP (Point-To-Point) model, the destination is known as queue and in pub/sub model, the destination is known as topic.
 
In producer, we can set the delivery mode either as NON-PERSISTENT or PERSISTENT using the setDeliveryMode method. Non-Persistent has less overhead as the messages are not logged in the server or database.
 
We can also use the setPriority method to set the message priority. 0 indicates low priority and 9 indicates high priority. We can also use setTimeToLive method to mention the life time of the message in milliseconds.
 
 
MessageSelector
 
MessageSelector belongs to String object which is used to filter the message that does not fit into the specified criteria.
 
The message selector can examine the header and compares an expression which is present in the String. The example for expression comprises of arithmetic operators, relational operators, string literals, and logical operators.
 
 
MessageListener
 
To process messages asynchronously, we have to use instantiate the MessageListener interface. We have to perform the following steps to process and receive messages asynchronously:
 
i) Create object which implements MessageListener interface and invoke the onMessage method
ii) Use setMessageListener method to register with the session object
iii) Use Connection object’s start method to start receiving messages.