O'Reilly - Java Message Service

Java Message Service
In addition to providing the container infrastructure for message-driven beans, EJB 2.0
provides another important advantage: concurrent processing. In EJB 2.0, a messagedriven
bean is deployed as a JMS consumer. It subscribes to a topic or connects to a queue
and waits to receive messages. At runtime, the EJB container actually instantiates many
instances of the same message-driven bean and keeps those instances in pool. When a
message is delivered to a message-driven bean, one instance of that bean is selected from a
pool to handle the message. If several messages are delivered at the same time, the
container can select a different bean instance to process each message; the messages can be
processed concurrently. Because a message-driven bean can consume messages
concurrently in a robust server environment, it is capable of much higher throughput and
better scalability than most traditional JMS clients.
Message-driven beans are composed of a bean class and an XML deployment descriptor.
The bean class must implement both the javax.ejb.MessageDrivenBean interface and the
javax.jms.MessageListener interface. The MessageDrivenBean interface defines three
methods:
package javax.ejb;
import javax.jms.Message;
public interface MessageDrivenBean {
public void ejbCreate( );
public void ejbRemove( );
public void setMessageDrivenContext(MessageDrivenContext mdc);
}
The MessageListener interface defines the onMessage( ) method:
package javax.jms;
public interface MessageListener {
public void onMessage( );
}
The setMessageDrivenContext( ) is called on each instance right after it is instantiated. It
provides the instance with a MessageDrivenContext, which is based on a standard container
interface, EJBContext. The ejbCreate( ) method is invoked on each instance after the
setMessageDrivenContext( ) method, but before the bean instance is added to the pool for
a particular message-driven bean. Once the message-driven bean has been added to the
pool, it's ready to process messages. When a message arrives, the instance is removed from
the pool and its onMessage( ) method is invoked. When the onMessage( ) method returns,
the bean instance is returned to the pool and is ready to process another message. The
ejbRemove( ) method is invoked on an instance when it is discarded. This might happen if
the container needs to reduce the size of the pool. The lifecycle of a message-driven bean
is shown in Figure 8.3.
129