Jboss Messaging JMS

Question

J'ai réussi à envoyer le message au nom de file d'attente ReceiverQueue sur mon serveur localhost Jboss, comment puis-je récupérer le message que je lui ai envoyé ou comment vérifier s'il y a des messages dans la file d'attente. ou puis-je obtenir une explication quelconque de la meilleure façon de procéder? Merci

Un didacticiel d'envoi/réception est également accepté. Tout ce qui me permettra de simplement envoyer à la file d'attente et recevoir des messages de cette file obtiendra une réponse acceptée.

J'utilise Spring.

Je veux une solution qui le fait en utilisant le contexte de l'application avec injection de haricots ..

Answer 1

Autre que d'avoir une MessageDrivenBean écouter cette file d'attente?

EDIT: Vous utilisez le ressort juste pour créer la charge utile, n'est-ce pas? JMS est une spécification JavaEE. Vous n'avez pas besoin d'utiliser Spring pour envoyer/recevoir des messages. Vous n'avez pas besoin de vérifier manuellement s'il y a des messages dans la file d'attente, etc. Tout ce que vous devez faire est d'avoir un MDB (MessageDrivenBean) mis en place comme celui-ci,

@MessageDriven(activationConfig = { 
     @ActivationConfigProperty(
      propertyName = "destinationType", propertyValue = "javax.jms.Queue"), 
     @ActivationConfigProperty(
      propertyName = "destination", propertyValue = "queue/myqueue") 
    }) 
public class MyMessageDrivenBean implements MessageListener { 
    public void onMessage(Message message) { 
     ObjectMessage objMsg = (ObjectMessage) message; 
     Payload payload = (Payload)objMsg.getObject(); 
     //do stuff 
} 

}

Et puis envoyer des messages JMS.

@Stateless 
public class QueuerBean implements QueuerLocal { 

    @Resource(mappedName = "java:/JmsXA") 
    private ConnectionFactory jmsConnectionFactory; 
    @Resource(mappedName = "queue/myqueue") 
    private Queue queue; 

    private void queue(MyPayload payload) { 
     try { 
      Connection connect = jmsConnectionFactory.createConnection(); 
      Session session = connect.createSession(false, 
       Session.DUPS_OK_ACKNOWLEDGE); 
      MessageProducer producer = session.createProducer(queue); 
      // create a JMS message and send it 
      ObjectMessage objMsg = session.createObjectMessage(payload); 
      producer.send(objMsg); 
      producer.close(); 
      session.close(); 
      connect.close(); 
     } catch (JMSException e) { 
      log.error("Bad thing happened", e); 
     } 
    } 
} 

La file d'attente est configurée par l'annotation. Lorsqu'un message est envoyé, JBoss déclenche automatiquement la MDB.

Answer 2

étapes API JMS standard:
1. Créez un javax.naming.Context avec les données d'accès du serveur

context = new InitialContext(environment) 

2. Levez les yeux vers javax.jms.QueueConnectionFactory dans le contexte. Nom de l'usine est spécifique au serveur JMS

factory = (QueueConnectionFactory)context.lookup(factoryName) 

3. Créer un javax.jms.QueueConnection

connection = factory.createQueueConnection(...) 

4. Créer un javax.jms.QueueSession

session = connection.createQueueSession(...) 

5. Recherchez votre javax.jms.Queue dans le contexte

queue = (Queue) context.lookup(qJndiName) 

Jusqu'à présent, il est le même que l'envoi ....
6. Créer une javax.jms.QueueReceiver avec la session

receiver = session.createReceiver(queue) 

7. API JMS offre 2 façons de récupérer un message:
7 .a Attendre un message avec l'une des méthodes receiver.receive()
7.b Implémenter javax.jms.MessageListener dans votre classe et l'enregistrer comme l'auditeur

receiver.setMessageListener(this) 

API JMS appellera votre méthode onMessage() chaque fois qu'un nouveau message arrive
8. Ne pas oublier de commencer l'auditeur:

connection.start() 

9 Fermer le contexte (très important, lorsque vous accédez à plusieurs serveurs JMS à partir du même programme):

context.close() 

Ce qui précède est un solution typique d'une application autonome. Dans l'environnement EJB, vous devez utiliser des beans pilotés par message. Vous pouvez trouver ino sur eux sur http://java.sun.com/javaee/6/docs/tutorial/doc/gipko.html et un tutoriel sur http://schuchert.wikispaces.com/EJB3+Tutorial+5+-+Message+Driven+Beans

Voici l'exemple de travail que vous avez demandé:

import java.util.Hashtable; 
import javax.naming.*; 
import javax.jms.*; 

public class JMSJNDISample implements MessageListener { 

    public static final String JNDI_URL = "jnp://localhost:1099"; 
    public static final String JNDI_CONTEXT_FACTORY = "org.jnp.interfaces.NamingContextFactory"; 
    public static final String JMS_USER = null; 
    public static final String JMS_PASSWORD = null; 
    public static final String JMS_CONNECTION_FACTORY = "MyConnectionFactory"; 
    public static final String QUEUE_JNDI_NAME = "ReceiverQueue"; 

    QueueConnection qConn = null; 
    QueueSession qSession = null; 
    QueueSender qSender = null; 
    QueueReceiver qReceiver = null; 

    public JMSJNDISample() { 
    } 


    public void init() throws JMSException, NamingException { 
     // Set up JNDI Context 
     Hashtable env = new Hashtable(); 
     env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_CONTEXT_FACTORY); 
     env.put(Context.PROVIDER_URL, JNDI_URL); 
     if (JMS_USER != null) 
      env.put(Context.SECURITY_PRINCIPAL, JMS_USER); 
     if (JMS_PASSWORD != null) 
      env.put(Context.SECURITY_CREDENTIALS, JMS_PASSWORD); 
     Context jndiContext = new InitialContext(env); 

     // Lookup queue connection factory 
     QueueConnectionFactory cFactory = (QueueConnectionFactory)jndiContext.lookup(JMS_CONNECTION_FACTORY); 

     // Create Connection 
     if (JMS_USER == null || JMS_PASSWORD == null) 
      qConn = cFactory.createQueueConnection(); 
     else { 
      qConn = cFactory.createQueueConnection(JMS_USER, JMS_PASSWORD); 
     } 

     // Create Session 
     qSession = qConn.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); 

     // Lookup Queue 
     Queue queue = (Queue) jndiContext.lookup(QUEUE_JNDI_NAME); 

     // Create Queue Sender 
     qSender = qSession.createSender(queue); 

     // Create Queue Receiver 
     qReceiver = qSession.createReceiver(queue); 
     qReceiver.setMessageListener(this); 

     // Start receiving messages 
     qConn.start(); 

     // Close JNDI context 
     jndiContext.close(); 
    } 


    public void sendMessage (String str) throws JMSException { 
     TextMessage msg = qSession.createTextMessage(str); 
     qSender.send(msg); 
    } 


    public void onMessage (Message message) { 
     try { 
      if (message instanceof TextMessage) { 
       TextMessage textMessage = (TextMessage)message; 
       System.out.println("Text Message Received: "+textMessage.getText()); 
      } else { 
       System.out.println(message.getJMSType()+" Message Received"); 
      } 
     } catch (JMSException je) { 
      je.printStackTrace(); 
     } 
    } 


    public void destroy() throws JMSException { 
     if (qSender != null) qSender.close(); 
     if (qReceiver != null) qReceiver.close(); 
     if (qSession != null) qSession.close(); 
     if (qConn != null) qConn.close(); 
    } 


    public static void main(String args[]) { 
     try { 
      JMSJNDISample sample = new JMSJNDISample(); 
      // Initialize connetion 
      sample.init(); 
      // Send Message 
      sample.sendMessage("Hello World"); 
      // Wait 2 sec for answer 
      Thread.sleep(2000); 
      // Disconnect 
      sample.destroy(); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
    } 
} 

Answer 3

Here's an example montrant comment mettre en place un POJO message entraîné au printemps. Je recommande de suivre cet idiome si vous utilisez déjà Spring. Pour ce qui est de savoir combien de messages sont dans la file d'attente, je dirais que vous devriez utiliser la console d'administration pour JBOSS, pas votre code.

Answer 4

Je vous recommande également d'utiliser un outil comme HermesJMS (http://www.hermesjms.com/confluence/display/HJMS/Home) pour inspecter le gestionnaire de files d'attente et les files d'attente. C'est un excellent outil de débogage.