Clarification regarding JMS msg Consumer vs Msg Listener

[hildich kilal]

I am confused between how a message consumer differs from message listener.
So I understand messageListener is for asynchronous messaging. We create a message consumer and then
set messageListener on it.

So usually when i create separate MessageConsumer and explicitely set a message Listener to them then it means
that there are many consumers but one Listener only listening on queue. But how does it help? Because the logic
to handle a message is still at one place? How will creating multiple consumers with same listener helps?

MessageConsumer consumer = session.createConsumer(myQueue);
	MessageConsumer consumer1 = session.createConsumer(myQueue);
	Listener myListener = new Listener();
	consumer.setMessageListener(myListener); 
	consumer1.setMessageListener(myListener); 

If I have a class which implements Messagelistener and then creates a messageConsumer inside it and
uses setMessagListener(this) to register listener . some thing like following

	public class JmsQueueListener implements MessageListener {
	 private InitialContext              context;
	  private QueueConnectionFactory      queueConnectionFactory;
	  private Queue                       queue;
	  private QueueConnection             connection;
	  private QueueSession                session;
	  private MessageConsumer             consumer;
	  private String                      queueName;
	  private JmsDestinationConfiguration config;
	..
	
	public void configure(final JmsDestinationConfiguration configuration) throws Exception
		  {
		    //super.configure(configuration);
		    config =  configuration;
	
		    queueName = config.getDestinationName();
	
		    try
		    {
		      // Get an InitialContext
		      final Hashtable<Object, Object> h = new Hashtable<Object, Object>();
		      /*if (config.getProperties() != null)
		      {
		        @SuppressWarnings("unchecked")
		        final Map<String, Object> map = ConversionManager.getInstance()
		            .convert(config.getProperties(), Map.class, null);
		        h.putAll(map);
		      }
		      */
		      h.put(Context.INITIAL_CONTEXT_FACTORY, config.getInitialContextFactory());
		      h.put(Context.PROVIDER_URL, config.getProviderUrl());
		      
		      
		      ...
		      ..
		      ..
		      consumer = session.createConsumer(queue);
		      consumer.setMessageListener(this);
		    } catch (final NamingException e)
		    {
		      throw e;
		    } catch (final JMSException e)
		    {
		      throw e;
		    } 
		    
		    @Override
		    	  public  void onMessage(Message message){
		    	  //Do some thing. My logic to handle message.
		    	  }
		    
		    	  
		  public void shutdown() throws IOException
		  {
		    try
		    {
		      connection.stop();
		    } catch (final JMSException e)
		    {
		      throw new IOException(e);
		    }
		  }
		    
		  /**
		   * @see com.xweld.toolkit.io.IReader#startup()
		   */
		  public void startup() throws IOException
		  {
		    try
		    {
		      connection.start();
		    } catch (final JMSException e)
		    {
		      throw new IOException(e);
		    }
		  }
	  
		
	}

Now if I create multilpe instances of this class and call start() on them does that mean that now there are
multiple listeners listening on the queue?

Thanks,

[H Paul]

Hope this will anwer your questions.

http://java.sun.com/javaee/5/docs/tutorial/doc/bncdq.html
http://java.sun.com/javaee/5/docs/tutorial/doc/bncdx.html
Point-to-Point Messaging Domain
Message Consumption

http://java.sun.com/javaee/5/docs/tutorial/doc/bnceh.html
JMS Message Consumers
JMS Message Listeners

[ntumba lobo]

You can see the JMS consumer as the generic component for message consumption, Message listener is a specialized consumer.
You can consume messages in two different ways
a) asynchronously : you use a Message Listener that you set up on your consumer object
b) synchronously : you call receive() on the consumer object