|
What is JMS?
|
Java Message Service: An
interface implemented by most J2EE containers to provide point-to-point
queueing and topic (publish/subscribe) behavior. JMS is frequently used
by EJB's that need to start another process asynchronously.
For example, instead of sending an email directly from an Enterprise
JavaBean, the bean may choose to put the message onto a JMS queue to be
handled by a Message-Driven Bean (another type of EJB) or another
system in the enterprise. This technique allows the EJB to return to
handling requests immediately instead of waiting for a potentially
lengthy process to complete.
|
What
are the advantages of JMS?
|
You can use it in the context of
mutithreading but it means JMS is not meant for Multithreading. Its
basically meant for object communication.
It will be useful when you are writing some event based applications
like Chat Server which needs a publish kind of event mechanism to send
messages between the server to the clients who got connected with the
server.
Moreover JMS gives Loosely-coupled kind of mechanism when compared with
RMI which is tightly-coupled. In JMS there is no need for the
destination object to be available online while sending a message from
the client to the server. But in RMI it is necessary. So we can use JMS
in place of RMI where we need to have loosely-coupled mechanism.
|
What
are major JMS products available in the market?
|
IBM's MQ Series, SonicMQ, iBus
etc.
All the J2EE compliant application servers come built with thier own
implementation of JMS.
|
What
are the different types of messages available in the JMS API?
|
Message, TextMessage,
BytesMessage, StreamMessage, ObjectMessage, MapMessage are the
different messages available in the JMS API.
|
What
is the difference between Point to Point and Publish/Subscribe
Messaging Domains
|
A point-to-point (PTP) product
or application is built around the concept of message queues, senders,
and receivers. Each message is addressed to a specific queue, and
receiving clients extract messages from the queue(s) established to
hold their messages. Queues retain all messages sent to them until the
messages are consumed or until the messages expire
In a publish/subscribe (pub/sub) product or application, clients
address messages to a topic. Publishers and subscribers are generally
anonymous and may dynamically publish or subscribe to the content
hierarchy. The system takes care of distributing the messages arriving
from a topic's multiple publishers to its multiple subscribers. Topics
retain messages only as long as it takes to distribute them to current
subscribers.
|
What
is the diffrence between JAVA Mail and JMS Queue
|
Java Mail – API siting on top of
e-mail protocols like SMTP, POP, IMAP – essentially same stuff e-mail
clients like MS outlook use .. hence make sense if at least on one side
of conversation we have human.
JMS Queue – is asynchronous point-to-point communication between
systems
|
What
is the difference between ic and queue?
|
A ic is typically used for one
to many messaging i.e. it supports publish subscribe model of
messaging. While queue is used for one-to-one messaging i.e. it
supports Point to Point Messaging.
|
What
is the role of JMS in enterprise solution development?
|
JMS is typically used in the
following scenarios
1. Enterprise Application Integration: - Where a legacy application is
integrated with a new application via messaging.
2. B2B or Business to Business: - Businesses can interact with each
other via messaging because JMS allows organizations to cooperate
without tightly coupling their business systems.
3. Geographically dispersed units: - JMS can ensure safe exchange of
data amongst the geographically dispersed units of an organization.
4. One to many applications: - The applications that need to push data
in packet to huge number of clients in a one-to-many fashion are good
candidates for the use JMS. Typical such applications are Auction
Sites, Stock Quote Services etc.
|
What
is the use of Message object?
|
Message is a light weight
message having only header and properties and no payload. Thus if the
receivers are to be notified about an event, and no data needs to be
exchanged then using Message can be very efficient.
|
What
are the three components of a Message ?
|
A JMS message consists of three
parts:
Message header
For message identification. For example, the header is used to
determine if a given message is appropriate for a "subscriber"
Properties
For application-specific, provider-specific, and optional header fields
Body
Holds the content of the message. Several formats are supported,
including TextMessage, which wrap a simple String, that wrap arbitrary
Java objects (which must be serializable). Other formats are supported
as well.
|
What
kind of information found in the header of a Message ?
|
The header of a message contains
message identification and routing information. This includes , but is
not limited to :
JMSDestination
JMSDeliveryMode
JMSMessageID
JMSTimeStamp
JMSExpiration
JMSReplyTO
JMSCorrelationID
JMSType
JMSRedelivered
|
What
is the basic difference between Publish Subscribe model and P2P model?
|
Publish Subscribe model is
typically used in one-to-many situation. It is unreliable but very
fast. P2P model is used in one-to-one situation. It is highly reliable.
|
 |
What is the use of BytesMessage?
|
BytesMessage contains an array
of primitive bytes in it's payload. Thus it can be used for transfer of
data between two applications in their native format which may not be
compatible with other Message types. It is also useful where JMS is
used purely as a transport between two systems and the message payload
is opaque to the JMS client. Whenever you store any primitive type, it
is converted into it's byte representation and then stored in the
payload. There is no boundary line between the different data types
stored. Thus you can even read a long as short. This would result in
erroneous data and hence it is advisable that the payload be read in
the same order and using the same type in which it was created by the
sender.
|
What
is the use of StreamMessage?
|
StreamMessage carries a stream
of Java primitive types as it's payload. It contains some conveient
methods for reading the data stored in the payload. However
StreamMessage prevents reading a long value as short, something that is
allwed in case of BytesMessage. This is so because the StreamMessage
also writes the type information alonwgith the value of the primitive
type and enforces a set of strict conversion rules which actually
prevents reading of one primitive type as another.
|
What
is the use of TextMessage?
|
TextMessage contains instance of
java.lang.String as it's payload. Thus it is very useful for exchanging
textual data. It can also be used for exchanging complex character data
such as an XML document.
|
What
is the use of ObjectMessage?
|
ObjectMessage contains a
Serializable java object as it's payload. Thus it allows exchange of
Java objects between applications. This in itself mandates that both
the applications be Java applications. The consumer of the message must
typecast the object received to it's appropriate type. Thus the
consumer should before hand know the actual type of the object sent by
the sender. Wrong type casting would result in ClassCastException.
Moreover the class definition of the object set in the payload should
be available on both the machine, the sender as well as the consumer.
If the class definition is not available in the consumer machine, an
attempt to type cast would result in ClassNotFoundException. Some of
the MOMs might support dynamic loading of the desired class over the
network, but the JMS specification does not mandate this behavior and
would be a value added service if provided by your vendor. And relying
on any such vendor specific functionality would hamper the portability
of your application. Most of the time the class need to be put in the
classpath of both, the sender and the consumer, manually by the
developer.
|
What
is the use of MapMessage?
|
A MapMessage carries name-value
pair as it's payload. Thus it's payload is similar to the
java.util.Properties object of Java. The values can be Java primitives
or their wrappers.
|
What
is the difference between BytesMessage and StreamMessage?
|
BytesMessage stores the
primitive data types by converting them to their byte representation.
Thus the message is one contiguous stream of bytes. While the
StreamMessage maintains a boundary between the different data types
stored because it also stores the type information along with the value
of the primitive being stored. BytesMessage allows data to be read
using any type. Thus even if your payload contains a long value, you
can invoke a method to read a short and it will return you something.
It will not give you a semantically correct data but the call will
succeed in reading the first two bytes of data. This is strictly
prohibited in the StreamMessage. It maintains the type information of
the data being stored and enforces strict conversion rules on the data
being read.
|
What
is point-to-point messaging?
|
With point-to-point message
passing the sending application/client establishes a named message
queue in the JMS broker/server and sends messages to this queue. The
receiving client registers with the broker to receive messages posted
to this queue. There is a one-to-one relationship between the sending
and receiving clients.
|
Can
two different JMS services talk to each other? For instance, if A and B
are two different JMS providers, can Provider A send messages directly
to Provider B? If not, then can a subscriber to Provider A act as a
publisher to Provider B?
|
The answers are no to the first
question and yes to the second. The JMS specification does not require
that one JMS provider be able to send messages directly to another
provider. However, the specification does require that a JMS client
must be able to accept a message created by a different JMS provider,
so a message received by a subscriber to Provider A can then be
published to Provider B. One caveat is that the publisher to Provider B
is not required to handle a JMSReplyTo header that refers to a
destination that is specific to Provider A.
|
What
is the advantage of persistent message delivery compared to
nonpersistent delivery?
|
If the JMS server experiences a
failure, for example, a power outage, any message that it is holding in
primary storage potentially could be lost. With persistent storage, the
JMS server logs every message to secondary storage. (The logging occurs
on the front end, that is, as part of handling the send operation from
the message producing client.) The logged message is removed from
secondary storage only after it has been successfully delivered to all
consuming clients .
|
Give
an example of using the publish/subscribe model.
|
JMS can be used to broadcast
shutdown messages to clients connected to the Weblogic server on a
module wise basis. If an application has six modules, each module
behaves like a subscriber to a named ic on the server.
|
Why
doesn't the JMS API provide end-to-end synchronous message delivery and
notification of delivery?
|
Some messaging systems provide
synchronous delivery to destinations as a mechanism for implementing
reliable applications. Some systems provide clients with various forms
of delivery notification so that the clients can detect dropped or
ignored messages. This is not the model defined by the JMS API.
JMS API messaging provides guaranteed delivery via the
once-and-only-once delivery semantics of PERSISTENT messages. In
addition, message consumers can ensure reliable processing of messages
by using either CLIENT_ACKNOWLEDGE mode or transacted sessions. This
achieves reliable delivery with minimum synchronization and is the
enterprise messaging model most vendors and developers prefer.
The JMS API does not define a schema of systems messages (such as
delivery notifications). If an application requires acknowledgment of
message receipt, it can define an application-level acknowledgment
message.
|
What
are the various message types supported by JMS?
|
Stream Messages -- Group of Java
Primitives
Map Messages -- Name Value Pairs. Name being a string& Value being
a java primitive
Text Messages -- String messages (since being widely used a separate
messaging Type has been supported)
Object Messages -- Group of serialize able java object
Bytes Message -- Stream of uninterrupted bytes
|
How
is a java object message delivered to a non-java Client?
|
It is according to the
specification that the message sent should be received in the same
format. A non-java client cannot receive a message in the form of java
object. The provider in between handles the conversion of the data type
and the message is transferred to the other end.
|
What
is MDB and What is the special feature of that?
|
MDB is Message driven bean,
which very much resembles the Stateless session bean. The incoming and
out going messages can be handled by the Message driven bean. The
ability to communicate asynchronously is the special feature about the
Message driven bean.
|
What
are the types of messaging?
|
There are two kinds of Messaging.
Synchronous Messaging: Synchronous messaging involves a client that
waits for the server to respond to a message.
Asynchronous Messaging: Asynchronous messaging involves a client that
does not wait for a message from the server. An event is used to
trigger a message from a server.
|
What
are the core JMS-related objects required for each JMS-enabled
application?
|
Each JMS-enabled client must
establish the following:
• A connection object provided by the JMS server (the message broker)
• Within a connection, one or more sessions, which provide a context
for message sending and receiving
• Within a session, either a queue or ic object representing the
destination (the message staging area) within the message broker
• Within a session, the appropriate sender or publisher or receiver or
subscriber object (depending on whether the client is a message
producer or consumer and uses a point-to-point or publish/subscribe
strategy, respectively)
Within a session, a message object (to send or to receive)
|
|
|
|