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.
- 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.*;
- Obtention d'un contexte initial.
try {
ctx = new InitialContext(env);
...
- 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;
...
- 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 );
...
- 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 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.
- Envoi du 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, 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);
- Envoi du message.
Le message est transmis vers la méthode send sur le QueueSender :
queueSender.send(outMessage);
- 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,
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();
- 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 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();
- 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.