Développement d'une application d'entreprise pour l'utilisation de JMS
Cette tâche permet de développer une application d'entreprise permettant d'utiliser l'API JMS directement pour la messagerie asynchrone.
Pourquoi et quand exécuter cette tâche
Cette rubrique présente les étapes nécessaires pour développer une application d'entreprise (servlet ou bean enterprise) permettant d'utiliser l'API JMS directement pour la messagerie asynchrone.
Cette rubrique décrit le cas JMS ; elle ne décrit pas la programmation de enterprise générale que vous devez déjà connaître. Pour obtenir des informations détaillées sur ces étapes et des exemples de développement d'une application d'entreprise permettant d'utiliser JMS, reportez-vous à la documentation de Java™ Message Service
Les caractéristiques des ressources JMS utilisées par les applications d'entreprise sont définies pour WebSphere Application Server et liées à l'espace de nom JNDI par le support d'administration de WebSphere Application Server.
Pour utiliser JMS, effectuez les étapes générales suivantes :
Procédure
- Importation des packages JMS. Une application d'entreprise qui utilise JMS, commence par un grand nombre
d'instructions d'importation pour JMS et devrait inclure au moins les instructions suivantes :
import javax.jms.*; //JMS interfaces import javax.naming.*; //Used for JNDI lookup of administered objects
- Obtention d'un contexte initial :
try { ctx = new InitialContext(env); ...
- Récupération des objets administrés de l'espace de nom JNDI. La méthode InitialContext.lookup() permet d'extraire des objets administrés (une fabrique
de connexions JMS et des destinations JMS). L'exemple suivant présente comment recevoir un message d'une
file d'attente :
qcf = (QueueConnectionFactory)ctx.lookup( qcfName ); ... inQueue = (Queue)ctx.lookup( qnameIn ); ...
Une autre approche, plus difficile à gérer, pour obtenir une destination JMS définie de manière administrative par recherche JNDI consiste à utiliser la méthode Session.createQueue(String) ou la méthode Session.createTopic(String). Par exemple :
crée une instance de file d'attente JMS permettant de référencer la destination existante Q1.Queue q = mySession.createQueue("Q1");
Dans sa forme la plus simple, le paramètre de ces méthodes de création est le nom d'une destination existante. Dans les situations plus complexes, les applications peuvent utiliser un format fondé sur les URI, qui permet de fournir un nombre arbitraire de paires de valeurs de nom pour définir diverses propriétés de la destination JMS.
- 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();
- Création d'une session, pour envoi ou 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 se termine de façon imprévue.
Comme défini dans la spécification EJB, les points ci-dessous s'appliquent aux indicateurs suivants :- L'indicateur comportant une transaction et transmis sur createQueueSession est ignoré dans une transaction globale et tout le travail est effectué dans le cadre de la transaction. En dehors d'une transaction, l'indicateur comportant une transaction est pas utilisé et, s'il a la valeur true, l'application doit utiliser session.commit() et session.rollback() pour contrôler l'exécution du travail. Dans un module EJB 2.0, si l'indicateur comportant une transaction est défini sur true et est situé en dehors d'une transaction XA, la session est impliquée dans la transaction locale WebSphere et l'attribut d'action non résolue de la méthode s'applique au travail JMS, s'il n'est pas validé ou annulé par l'application.
- Les clients ne peuvent pas utiliser Message.acknowledge() pour accuser réception des messages. Si une valeur CLIENT_ACKNOWLEDGE est transmise sur l'appel createxxxSession, le serveur d'applications accuse automatiquement réception des messages et Message.acknowledge() n'est pas utilisé.
- Envoi d'un message.
- 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);
- 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 :TextMessage outMessage = session.createTextMessage(outString);
- Envoi du message. Le message est transmis vers la méthode send sur le QueueSender :
queueSender.send(outMessage);
- 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.
- Réception des réponses.
- 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+"'";
- 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);
- 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.
- 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, vous devez
transtyper la classe Message générique (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();
- 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.
- 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;
- Publication de messages et abonnement. Les actions générales de la prise en charge Publication/Abonnement JMS
sont identiques à celle 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();
- 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


http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=tmj_devap
Nom du fichier : tmj_devap.html