Model :

Message Driven POJOs will have the same model as Stateless/Stateful beans. There is a bean class tagged as @org.jboss.ejb3.annotation.Consumer that must implement one or more @org.jboss.ejb3.annotation.Producer interfaces. Just as a stateless bean is tagged as @Stateless and implements one or more @Remote or @Local interfaces. Take a look at org.jboss.tutorial.consumer.bean.ExampleConsumerBean

				
@Consumer(activationConfig =
{@ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue"),
      @ActivationConfigProperty(propertyName = "destination", propertyValue = "queue/tutorial/example")})
@Depends ("jboss.messaging.destination:service=Queue,name=tutorial")
public class ExampleConsumerBean implements ExampleProducerRemote, ExampleProducerLocal, ExampleProducerXA
{
...
   public void method1(String msg, int val)
   {
      System.out.println("method1(" + msg + ", " + val + ")");
   }

   public void method2(String msg, Map<String, String> map)
   {
      System.out.println("method2: " + msg);
      for (String key : map.keySet())
      {
         System.out.println("method2 key/val: " + key + ":" + map.get(key));
      }
   }
				
			

Here's one of the @Producer interfaces :

				
@Producer
public interface ExampleProducerRemote extends ExampleProducer
{
...
				
			

You can see in this example that the ExampleConsumerBean implements the @Producer interfaces and defines the methods which can receive JMS messages. These interfaces will be used by clients(JMS Publishers) to send messages to the consumer via JMS.

Let's now look at the client org.jboss.tutorial.consumer.client.Client

				
public static void main(String[] args) throws Exception
   {
      InitialContext ctx = new InitialContext();
      ExampleProducerRemote remote = (ExampleProducerRemote) ctx.lookup(ExampleProducerRemote.class.getName());

      // you can typecast the returned proxy to obtain a ProducerManager interface that allows you to manage
      // interaction with JMS.
      ProducerManager manager = ((ProducerObject) remote).getProducerManager();


      // connect - internally creates a JMS connection
      manager.connect();

      try
      {
         // Call method1
         remote.method1("Remote method1 called", 1);
         System.out.println("Remote method1 called");

         // Call method2
         Map<String, String> map = new HashMap<String, String>();
         map.put("hello", "world");
         map.put("great", "ejb3");

         remote.method2("Remote method2 called", map);
         System.out.println("Remote method2 called");
      }
      finally
      {
         // instead of typecasting, you can use a helper class that does everything for you.
         ProducerConfig.close(remote);
      }
				
			

When the @Consumer is deployed by the EJB3 container, it looks for all of its @Producer interfaces and registers each one of them in JNDI under their fully qualified class name. The client looks up the ExampleProducerRemote from the JNDI and uses the returned proxy to send the message. The returned proxy can be cast to org.jboss.ejb3.mdb.ProducerObject. It then gets a org.jboss.ejb3.mdb.ProducerManager, that manages the JMS connection for this proxy. To start being able to send messages to the Queue, the client calls connect on the ProducerManager. When the client calls method1() on the proxy, this method call is converted into a JMS message and published to the Queue of the Consumer. The consumer will receive the message and invoke its method1 method.