Gerenciando filas do MQ

import com.ibm.mq.MQException;
import com.ibm.mq.MQGetMessageOptions;
import com.ibm.mq.MQMessage;
import com.ibm.mq.MQPutMessageOptions;
import com.ibm.mq.MQQueue;
import com.ibm.mq.MQQueueManager;
import com.ibm.mq.constants.MQConstants;

/**
 * Simple example program
 */
public class MQSample {

  // code identifier
  static final String sccsid = "@(#) samples/wmqjava/MQSample.java, jmscc.samples, k000, k000-L080311.1 1.4 08/03/10 15:04:15";

  // define the name of the QueueManager
  private static final String qManager = "my_queue_manager";
  // and define the name of the Queue
  private static final String qName = "SYSTEM.DEFAULT.LOCAL.QUEUE";

  /**
   * Main entry point
   * 
   * @param args - command line arguments (ignored)
   */
  public static void main(String args[]) {
    try {
      // Create a connection to the QueueManager
      System.out.println("Connecting to queue manager: " + qManager);
      MQQueueManager qMgr = new MQQueueManager(qManager);

      // Set up the options on the queue we wish to open
      int openOptions = MQConstants.MQOO_INPUT_AS_Q_DEF | MQConstants.MQOO_OUTPUT;

      // Now specify the queue that we wish to open and the open options
      System.out.println("Accessing queue: " + qName);
      MQQueue queue = qMgr.accessQueue(qName, openOptions);

      // Define a simple WebSphere MQ Message ...
      MQMessage msg = new MQMessage();
      // ... and write some text in UTF8 format
      msg.writeUTF("Hello, World!");

      // Specify the default put message options
      MQPutMessageOptions pmo = new MQPutMessageOptions();

      // Put the message to the queue
      System.out.println("Sending a message...");
      queue.put(msg, pmo);

      // Now get the message back again. First define a WebSphere MQ
      // message
      // to receive the data
      MQMessage rcvMessage = new MQMessage();

      // Specify default get message options
      MQGetMessageOptions gmo = new MQGetMessageOptions();

      // Get the message off the queue.
      System.out.println("...and getting the message back again");
      queue.get(rcvMessage, gmo);

      // And display the message text...
      String msgText = rcvMessage.readUTF();
      System.out.println("The message is: " + msgText);

      // Close the queue
      System.out.println("Closing the queue");
      queue.close();

      // Disconnect from the QueueManager
      System.out.println("Disconnecting from the Queue Manager");
      qMgr.disconnect();
      System.out.println("Done!");
    }
    catch (MQException ex) {
      System.out.println("A WebSphere MQ Error occured : Completion Code " + ex.completionCode
          + " Reason Code " + ex.reasonCode);
    }
    catch (java.io.IOException ex) {
      System.out.println("An IOException occured whilst writing to the message buffer: " + ex);
    }
  }
}

public class ManangerQueueWebMain {
	
	private QueueConnectionFactory queueConnectionFactory = null;
	private QueueConnection queueConnection = null;
	private Queue queue = null;
	private QueueSender queueSender = null;
	private QueueSession queueSession = null;
	private String connectionFactoryName = null;
	private String queueName = null;
	private QueueReceiver receiver = null;

	/**
	 * Envia a mensagem para a fila
	 * @param final String asyncXml
	 * @see createContextMessage()
	 * 
	 * */
	public boolean sendToQueue(final String asyncXml) throws MQException{
		TextMessage msg = null;
		boolean msgSend = false;
		
		try {
			/* Cria o contexto para o envio da mensagem */
			this.createContextMessage();
			
			/* Prepara a mensagem para ser enviada como BytesMessage */
			msg = queueSession.createTextMessage();
			msg.setText(asyncXml);
			
			if (findMessage(msg) == null) {
				queueSender.send(msg);
				System.out.println("Mensagem enviada!");
			} else {
				System.err.println("Mensagem nao enviada! Ja existe na fila!:" + asyncXml);
			}
		} catch (JMSException e) {
			throw new com.ford.nfe.exception.MQException(e);
		} catch (NamingException e) {
			throw new com.ford.nfe.exception.MQException(e);
		} catch (Exception e) {
			System.out.println(""+e);
		}finally{
			if(queueSession != null){
				try {
					queueSession.close();
				} catch (JMSException e1) {
					throw new MQException(e1);
				}
			}
			if(queueConnection != null){
				try {
					queueConnection.close();
				} catch (JMSException e1) {
					throw new MQException(e1);
				}
			}
		}
		return msgSend;
	}
	
	private void createContextMessage() throws NamingException, JMSException {
		Context ctx = new InitialContext();
		queueConnectionFactory = (QueueConnectionFactory) PortableRemoteObject.narrow(ctx.lookup(connectionFactoryName), QueueConnectionFactory.class);
		queueConnection = queueConnectionFactory.createQueueConnection();

		this.connectionFactoryName = "jms/QueueConnectionFactory";
		this.queueName = "jms/MFQueue";

		boolean transacted = false;
		queueSession = queueConnection.createQueueSession(transacted,QueueSession.AUTO_ACKNOWLEDGE);
		queue =	(Queue) PortableRemoteObject.narrow(ctx.lookup(queueName),	Queue.class);
		queueSender = queueSession.createSender(queue);
		receiver = queueSession.createReceiver(queue);
		queueConnection.start();
	}
	
	private TextMessage findMessage(TextMessage message) { 
		
		TextMessage msgFound = null;
		
		try {
			QueueBrowser browser = queueSession.createBrowser((Queue)queueSender.getDestination());
			Enumeration enumeration = browser.getEnumeration();
			while (enumeration.hasMoreElements()) {
				TextMessage messageOnQueue = (TextMessage)enumeration.nextElement();
				if (messageOnQueue.getText().equals(message.getText())) {
					msgFound = messageOnQueue;
					break;
				}
			}
		} catch (JMSException e) {
			/*
			 * Exceção ignorada para não comprometer 
			 * a inclusão de mensagens na fila
			 */
		}
		return msgFound;
	}

	private void removeMessageFromQueue(TextMessage textMessage) throws QueueException {
		
		try {
			if (textMessage == null) {
				receiver = queueSession.createReceiver(queue);
			} else {
				textMessage = findMessage(textMessage);
				receiver = queueSession.createReceiver(queue, "JMSMessageID='" + textMessage.getJMSMessageID() + "'");
			}
			
			while (receiver.receiveNoWait() != null) {
				receiver.receiveNoWait();
			}
			
		} catch (JMSException e) {
			System.err.println("Erro ao tentar remover os itens da fila." + e);
			throw new QueueException("Erro ao tentar remover os itens da fila." + e, e);
		}
	}
	
	public void removeMessageFromQueue(String message) throws QueueException {
		try {
			this.createContextMessage();
			TextMessage msg = null;
			
			if (message != null) {
				msg = queueSession.createTextMessage();
				msg.setText(message);
			}
			
			removeMessageFromQueue(msg);
		} catch (JMSException e) {
			System.err.println("Erro ao tentar remover os itens da fila." + e);
			throw new QueueException("Erro ao tentar remover os itens da fila." + e, e);
		} catch (NamingException e) {
			System.err.println("Erro ao inicializar context na remoção das mensagens da fila: " + e);
			throw new QueueException("Erro ao inicializar context na remoção das mensagens da fila: " + e, e);
		}
	}
	
	public Collection<TextMessage> listMessage(String message) throws QueueException { 
		
		List<TextMessage> listaMensagens = new ArrayList<TextMessage>();
		TextMessage msg = null;
		
		try {
			this.createContextMessage();
			
			if (message != null) {
				msg = queueSession.createTextMessage(message);
			} else {
				msg = queueSession.createTextMessage();
			}
			
			QueueBrowser browser = queueSession.createBrowser((Queue)queueSender.getDestination());
			Enumeration enumeration = browser.getEnumeration();
			
			while (enumeration.hasMoreElements()) {
				try {
					TextMessage messageOnQueue = (TextMessage)enumeration.nextElement();
					if (message == null || message.equals("")) {
						listaMensagens.add((TextMessage)enumeration.nextElement());
					} else if (messageOnQueue.getText().indexOf(msg.getText()) > -1) {
						listaMensagens.add((TextMessage)enumeration.nextElement());
					}
				} catch (NoSuchElementException e) {
					/*
					 * Exceção que pode ser disparada caso a mensagem seja 
					 * processada e retirada da fila antes do término da iteração da lista.
					 * Exceção será ignorada para que a iteração nas 
					 * mensagens possa prosseguir 
					 */
				}
			}
		} catch (JMSException e) {
			System.err.println("Erro ao listar mensagens na da fila: " + e);
			throw new QueueException("Erro ao listar mensagens na da fila: " + e, e);
		} catch (NamingException e) {
			System.err.println("Erro ao inicializar context na listagem das mensagens da fila: " + e);
			throw new QueueException("Erro ao inicializar context na listagem das mensagens da fila: " + e, e);
		}

		return listaMensagens;
	}
}

ManangerQueueWebMain queueMainframe = new ManangerQueueWebMain();
			Collection<TextMessage> lstTxtMsg = queueMainframe.listMessage(null);
			int qtdeMsg = lstTxtMsg.size();

gerenciadorFilas = new MQQueueManager(qManager);
         
int openOptions = MQC.MQOO_INPUT_AS_Q_DEF | MQC.MQOO_OUTPUT | MQC.MQOO_INQUIRE;
                        
MQQueue filaMsg = gerenciadorFilas.accessQueue("TESTE", openOptions);
         
while(filaMsg.getCurrentDepth() > 0)
{
   MQMessage mensagemFilaTeste = new MQMessage();
   MQGetMessageOptions gmo = new MQGetMessageOptions();
            
    filaMsg.get(mensagemFilaTeste, gmo);
    //com esse .readLine() eu consigo o corpo da msg... essa msg é uma string....
    System.out.println(mensagemFilaTeste.readLine());
    System.out.println("************************");
            
}

mensagemFilaTeste.messageId;

mensagemFilaTeste.correlationId