Développement d'un client JMS

Cette fonction permet de développer une application cliente JMS utilisant des messages pour la communication avec les applications d'entreprise.

Pourquoi et quand exécuter cette tâche

Cette rubrique présente les étapes nécessaires au développement d'une application client JMS. Cette rubrique décrit le cas JMS ; elle ne décrit pas la programmation de client générale que vous devez déjà connaître. For detailed information about these steps, and for examples of developing JMS clients, see the Java™ Message Service Documentation and the Using Java section of the IBM MQ information center.

Un client JMS suppose que les ressources JMS (telles que la fabrique de connexions de file d'attente et la destination de file d'attente) existent déjà. Une application client peut obtenir des ressources appropriées soit à l'aide d'une recherche par JNDI, soit à l'aide d'un programme sans l'utilisation de JNDI.

Pour plus d'informations sur le programme Thin Client for JMS with WebSphere Application Server, technologie intégrable qui fournit des connexions JMS V1.1 à un moteur de messagerie du fournisseur de messagerie par défaut WebSphere Application Server, voir Utilisation du service JMS pour la connexion à un moteur de messagerie de fournisseur de messagerie par défaut de WebSphere Application Server.

Pour plus d'informations sur le développement des applications client et la configuration des ressources JMS pour celles-ci, reportez-vous à la rubrique Développement de code client pour une application J2EE et aux tâches connexes.

Pour utiliser JMS, un programme client JMS typique effectue les étapes générales suivantes. Cet exemple se base sur l'utilisation de recherches JNDI pour obtenir des ressources JMS.

Procédure

  1. Importation des packages JMS. Une application d'entreprise qui utilise JMS commence par un grand nombre d'instructions d'importation pour JMS ; par exemple :
    import javax.naming.Context;
    import javax.naming.InitialContext;
    import javax.rmi.PortableRemoteObject;
    import javax.jms.*;
  2. Obtention d'un contexte initial.
       try     {
            ctx = new InitialContext(env);
    ...
  3. Définissez les paramètres que doit utiliser le client, par exemple pour identifier la fabrique de connexions de file d'attente et assembler un message à envoyer.
    public class JMSppSampleClient
    {
      public static void main(String[] args)
      throws JMSException, Exception
    
      {
        String  messageID                 = null;
        String  outString                 = null;
        String  qcfName                   = "java:comp/env/jms/ConnectionFactory";
        String  qnameIn                   = "java:comp/env/jms/Q1";
        String  qnameOut                  = "java:comp/env/jms/Q2";
        boolean verbose                   = false;
    
        QueueSession           session    = null;
        QueueConnection        connection = null;
        Context                ctx        = null;
    
        QueueConnectionFactory qcf        = null;
        Queue                  inQueue    = null;
        Queue                  outQueue   = null;
    
    ...
  4. Récupération des objets administrés de l'espace de nom JNDI. La méthode InitialContext.lookup() est utilisée pour extraire les objets administrés (une fabrique de connexions de file d'attente et les destinations de file d'attente) :
           qcf = (QueueConnectionFactory)ctx.lookup( qcfName );
    ...
           inQueue = (Queue)ctx.lookup( qnameIn );
           outQueue = (Queue)ctx.lookup( qnameOut );
    ...
  5. Création d'une connexion au fournisseur de service de messagerie. La connexion fournit l'accès au transport sous-jacent et est utilisée pour créer des sessions. La méthode createQueueConnection() sur l'objet fabrique est utilisée pour créer la connexion.
           connection = qcf.createQueueConnection();
    La spécification JMS définit les connexions qui devraient être créées à l'état arrêté. Tant que la connexion n'a pas démarré, les MessageConsumers associés à cette connexion ne peuvent pas recevoir de messages. Pour démarrer la connexion, lancez la commande suivante :
           connection.start();
  6. Création d'une session, pour envoi et réception des messages. La session fournit un contexte pour envoyer et recevoir des messages y compris les méthodes utilisées pour créer des MessageProducers et des MessageConsumers. La méthode createQueueSession est utilisée sur la connexion pour obtenir une session. La méthode utilise deux paramètres :
    • Un paramètre booléen qui détermine si la session comporte une transaction.
    • Un paramètre qui détermine le mode d'accusé de réception.
           boolean transacted = false;
           session = connection.createQueueSession( transacted,
                                                   Session.AUTO_ACKNOWLEDGE);

    Dans cet exemple, la session est sans transaction et devrait automatiquement accuser réception aux messages reçus. Avec ces paramètres, un message est annulé uniquement après une erreur système ou si l'application cliente se termine de façon imprévue.

  7. Envoi du message.
    1. Création de MessageProducers pour créer des messages. Pour la messagerie point à point, le MessageProducer est un QueueSender qui est créé en passant un objet de file d'attente de sortie (précédemment récupéré) dans la méthode createSender de la session. Un expéditeur QueueSender est généralement créé pour une file d'attente pour que tous les messages envoyés par l'expéditeur soit reçus dans la même destination.
             QueueSender queueSender = session.createSender(inQueue);
    2. Création du message. Utilisez la session pour créer un message vide et ajouter les données transmises.

      JMS fournit plusieurs types de messages, chacun d'eux renfermant une connaissance de son contenu. Pour éviter de référencer les noms de classes spécifiques au fournisseur pour les types de messages, des méthodes sont fournies sur l'objet Session pour la création de messages.

      Dans cet exemple, un message texte est créé à partir de la propriété outString, qui pourrait être fournie comme paramètre d'entrée sur appel du programme client ou construit d'une autre manière :
             TextMessage outMessage = session.createTextMessage(outString);
    3. Envoi du message.
      Le message est transmis vers la méthode send sur le QueueSender :
             queueSender.send(outMessage);
  8. Réception des réponses.
    1. Création d'un ID corrélation pour lier le message aux réponses. Dans cet exemple, le client reçoit des réponses qui sont associées au message envoyé, en utilisant un ID de message spécifique au fournisseur dans un JMSCorrelationID.
             messageID = outMessage.getJMSMessageID();
      L'ID de corrélation est ensuite utilisé dans un sélecteur de messages, pour sélectionner uniquement les messages qui ont un ID :
             String selector = "JMSCorrelationID = '"+messageID+"'";
    2. Création d'un MessageReceiver pour réception des messages. Pour la messagerie point à point, le MessageReceiver est un QueueReceiver qui est créé en transmettant un objet de file d'attente d'entrée (précédemment récupéré) et le sélecteur de messages dans la méthode createReceiver de la session.
             QueueReceiver queueReceiver = session.createReceiver(outQueue, selector);
    3. Récupération de la réponse. La méthode de réception sur le QueueReceiver est utilisée pour récupérer un message de réponse :
             Message inMessage = queueReceiver.receive(2000);

      Le paramètre de l'appel de réception est une temporisation en millisecondes. Ce paramètre définit le temps d'attente de la méthode s'il n'y a pas de message immédiatement disponible. Si vous omettez ce paramètre, l'appel est bloquée indéfiniment. Si vous ne voulez pas de délai du tout, utilisez la méthode receiveNoWait(). Dans cet exemple, l'appel de réception revient lorsque le message arrive, ou après 2000 ms.

    4. Intervention sur le message reçu. Vous pouvez agir sur un message reçu, selon vos besoins, à l'aide de la logique de gestion du client. Certaines des actions JMS générales consistent à vérifier que le type de message est correct et à extraire le contenu du message. Pour extraire le contenu du corps du message, transtypez la classe générique Message (qui est le type de retour déclaré des méthodes de réception) vers une sous-classe plus spécifique, telle que TextMessage. Il est préférable de tester la classe du message avant transtypage, afin de gérer toute erreur imprévue.

      Dans cet exemple, l'opérateur instanceof est utilisé afin de vérifier que le message reçu est de type TextMessage. Le contenu du message est ensuite extrait en le transtypant vers la sous-classe TextMessage.

             if ( inMessage instanceof TextMessage )
      
      ...
                 String replyString = ((TextMessage) inMessage).getText();
  9. Fermeture. Si l'application a besoin de créer de nombreux objets JMS de brève durée, il est important de fermer toutes les ressources JMS utilisées. Pour cela, vous appelez la méthode close() sur les différentes classes (QueueConnection, QueueSession, QueueSender, et QueueReceiver) lorsque les ressources ne sont plus requises.
           queueReceiver.close();
    ...
           queueSender.close();
    ...
           session.close();
           session = null;
    ...
           connection.close();
           connection = null;
  10. Publication de messages et abonnement. Les actions client générales de la messagerie par publication/abonnement sont identiques à celles de la messagerie point à point, par exemple, pour créer une session et une connexion. La différence tient au fait que les ressources de rubriques sont utilisées à la place des ressources de file d'attente (par exemple TopicPublisher au lieu de QueueSender), comme illustré dans l'exemple suivant pour publier un message :
    // Creating a TopicPublisher
           TopicPublisher pub = session.createPublisher(topic);
    ...
           pub.publish(outMessage);
    ...
           // Closing TopicPublisher
           pub.close();
  11. Gestion des erreurs Toutes les erreurs d'exécution JMS sont rapportées sous forme d'exceptions. La majorité des méthodes dans JMS transmettent des JMSExceptions pour indiquer les erreurs. Au niveau de la programmation, il est conseillé d'intercepter ces exceptions et de les afficher sur une sortie appropriée.

    Contrairement aux exceptions Java normales, une JMSException peut contenir une autre exception. La mise en oeuvre de JMSException n'inclut pas cette exception intégrée dans la sortie de sa méthode toString(). Vous devez donc rechercher explicitement une exception intégrée et l'imprimer, comme indiqué dans l'exemple suivant :

        catch (JMSException je)
        {
           System.out.println("JMS failed with "+je);
           Exception le = je.getLinkedException();
           if (le != null)
           {
               System.out.println("linked exception "+le);
           }
        }

Que faire ensuite

Pour plus d'informations sur l'exécution d'un client sur un serveur distant spécificque : Exécution d'une application client Java EE avec launchClient.


Icône indiquant le type de rubrique Rubrique de tâche



Icône d'horodatage Dernière mise à jour: last_date
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=tmj_devcl
Nom du fichier : tmj_devcl.html