Java Message Service Sangeetha Chavala

What is Messaging? Method of Communication between software components/applications peer-to-peer facility Not another Mail API!!!

Messaging System Concepts Allows loosely coupled applications to communicate - contrast with RPC Asynchronous Reliable

Messaging Systems Advantages Platform &Network Location Independence Flexibility Scalability Anonymity Robustness Asynchronous

What is the JMS API? A common Java TM platform API for creating, sending, receiving and reading messages Design Goals -Provides most of the functionality of common messaging systems -makes client applications portable across messaging products - Leverages Java Technology

Common Models of Messaging Point-to-Point Publish/Subscribe

Point-to-Point Messaging Only one consumer of Queue Message No timing dependencies between Sender and Receiver

Publish/Subscribe Messaging Broadcast Message to all Subscribers

JMS Application JMS Provider JMS Clients Messages Administered Objects Non-JMS Clients

Messages Message Components Header Properties Body

Message Header Used for Message Identification and Routing Destination Field -includes Subject or Topic (for Pub/Sub) -queue(for point-to-point) Also include other data -delivery mode -message ID -timestamp -priority -ReplyTo

Message Properties Application-specific properties Messaging system provider-specific properties Optional fields Properties are Name/Value pairs Values can be int, string, byte etc

Message Body Holds content of message Five Types supported Each type defined by a message interface -StreamMessage -MapMessage -BytesMessage -TextMessage -ObjectMessage

Message Body Interfaces StreamMessage -contains Java primitive values -Read sequentially MapMessage -Holds name/value pairs -Read sequentially or by name BytesMessage -uninterpreted bytes -used to match an existing message format

Message Body Interfaces TextMessage -contains java.util.StringBuffer -useful for XML messages ObjectMessage -contains arbitrary java object -must be serializable

Example: Creating a Text Message To create a simple TextMessage: TextMessage message = session. createTextMessage( ); message. setText ( “greetings”);

Building a JMS Client Steps 1) Create a Connection to the provider 2) Create Sessions to send/receive messages 3) Create MessageProducers 4) Create MessageConsumers

1. Creating a Connection Connection provides access to messaging system Performs resource allocation and management ConnectionFactory used to create Connection ConnectionFactory is located through JNDI

Get the Connection Factory Context messaging = new InitialContext ( ) ; TopicConnectionFactory factory = (TopicConnectionFactory) messaging. lookup ( “TopicConnectionFactory” ) ; JNDI is used to get a ConnectionFactory 2 Types ConnectionFactory - QueueConnectionFactory for P-to-P - TopicConnectionFactory for Pub/Sub

Create the Connection TopicConnection topicConnection = factory. createTopicConnection ( ) ; QueueConnection or TopicConnection

2. Create Sessions TopicSession session = topicConnection. createTopicSession (false, CLIENT_ACKNOWLEDGE); First parameter controls transactions Second parameter specifies message acknowledgement

Locate a Topic Topic weatherTopic = messaging. Lookup ( “WeatherData” ) ; JNDI is used to locate the topic Queue or Topic

Start the Connection topicConnection. start ( ) ; During initialization, message flow is inhibited; Connection must now be started before messages will be transmitted

3. Create Message Producer TopicPublisher publisher = session. createPublisher (weatherTopic) ; Publisher will publish messages to weathetData topic

Publish a Message TextMessage message = session. createMessage ( ) ; message. setText ( “text : 35 degrees” ) ; publisher. Publish (message) ;

Specifying Quality of Service Publish (Message message, int deliveryMode, int priority, long timeToLive) ; Delivery Modes - NON-PERSISTENT - PERSISTENT Priority Time-to-Live

4. Message Consumer Subscribing to topics - Durable Subscriptions - Non-durable Subsriptions Receiving Messages - Asynchronous - Synchronous

Asynchronous Message Receipt Uses Listening Mechanism setMessageListener (MessageListener listener) Listener object must implement onMessage ( ) of MessageListener interface

Synchronous Message Receipt Message receive ( ) ; Message receive (long timeout) ; Message receiveNoWait ( ) ;

Point-to-Point Programming Queue Browsing - session. createBrowser (Queue queue); - session. createBrowser (QueueSession session, Queue queue, String messageSelector) ;

JMS Programming Techniques and Issues 1. Transactions - commit( ) ; - rollback( ) ; with respect to producer with respect to consumer 2. Programmatic Message Acknowledgement acknowledge ( );

JMS Programming Techniques and Issues 3. Message Routing - Routing via Hierarchical Topics bid_request bid_request.vehicles bid_request.vehicles.bicycle - Routing via Message Selection Property_MerchType = ‘Mountain Bike’ AND Property_ReqOvernight is NULL Selecting a Routing Approach

Using JMS to Transport XML StringBuffer body = new StringBuffer ( ) ; body.append (“?xml version=\”1.0\ “?>\n”) ; body.append (“ \n”); body.append (“ ”+username+“ \n”) ; body.append (“ ”+s+ “ \n”) ; body.append (“ \n”) ; msg.setText (body.toString( )) ; publisher. Publish (msg) ;

Consuming XML Messages Work with XML payload as a text stream Work with the XML payload through the DOM Use SAX to process the XML in an event-based manner

Performing XML-based Routing - Use Message Properties Request-Reply Programming - Replies are sent as full JMS message typically following some processing in the called ‘client’

JMS Implementations Standalone messaging servers JMS services embedded within other environments such as an application server

JMS and XML as an Integration Platform Integration Types - Data Integration - Procedural or Process Integration Messaging simplifies Application Integration - can’t use Objects - XML proves to be an optimal format

Topics discussed Messaging System Concepts JMS Features JMS Programming Techniques JMS and XML as an Integration platform