web-dev-qa-db-fra.com

Comment utiliser Java JMS avec MQseries

J'essaie de développer un JMS application autonome pour lire et écrire dans une file d'attente sur MQSeries. Mon patron m'a demandé d'utiliser pure Java JMS (pas ibm.mq lib) pour le faire.

Voici les informations nécessaires pour établir la connexion jms:

  mq.hostname=10.10.10.10
  mq.channel=API.CLIENTCHL
  mq.queueManager=MQPETAPI
  mq.port=1422

Savez-vous comment faire cela ou avez-vous un lien qui m'apprend à le faire.

javajmsibm-mq
31
David

Le problème ici est l'exigence que "mon patron m'a demandé d'utiliser pur Java JMS (pas ibm.mq lib) pour ce faire." JMS est une spécification et chaque implémentation doit se conformer à l'API et la sémantique, mais est libre de faire ce qu'il veut à un niveau bas. Il est toujours nécessaire d'utiliser les classes d'implémentation fournies par le fournisseur de transport. Par conséquent, si vous utilisez WebSphere MQ comme transport, vous devrez utiliser IBM MQ Classes JMS pour écrire une application JMS.

Cela dit, si vous vous en tenez aux appels d'API JMS purs, vous pourrez connecter les classes de n'importe quel fournisseur de transport. C'est ce qui est généralement prévu lorsque vous recevez des exigences telles que celles mentionnées dans le message d'origine.

Il y a un article décrivant exactement ce que vous cherchez à faire appelé Exécution d'une application autonome Java application sur WebSphere MQ V6. Il utilise uniquement l'API JMS et il utilise JNDI dans un système de fichiers local (un fichier .bindings) .En échangeant les classes IBM JMS pour un autre fournisseur et en utilisant leurs outils JNDI, vous pourrez vous connecter dans n'importe quel transport JMS sans changer votre code en utilisant cette approche.

Si vous voulez faire la même chose sans JNDI, regardez les exemples de programmes fournis avec l'installation du client MQ où vous avez obtenu vos classes Java. Dans un système UNIX/Linux, elles se trouvent dans /opt/mqm/samp et sous Windows, ils sont dans install_dir/tools/jms/samples. Le SimpleRequestor.Java sample contient le code suivant pour initialiser votre fabrique de connexions sans JNDI:

try {
  // Create a connection factory
  JmsFactoryFactory ff = JmsFactoryFactory.getInstance(WMQConstants.WMQ_PROVIDER);
  JmsConnectionFactory cf = ff.createConnectionFactory();

  // Set the properties
  cf.setStringProperty(WMQConstants.WMQ_Host_NAME, "localhost");
  cf.setIntProperty(WMQConstants.WMQ_PORT, 1414);
  cf.setStringProperty(WMQConstants.WMQ_CHANNEL, "SYSTEM.DEF.SVRCONN");
  cf.setIntProperty(WMQConstants.WMQ_CONNECTION_MODE, WMQConstants.WMQ_CM_CLIENT);
  cf.setStringProperty(WMQConstants.WMQ_QUEUE_MANAGER, "QM1");

Étant donné que cette approche n'utilise pas JNDI, vous devez écrire du code qui n'est pas transportable entre les fournisseurs de transport. Il est spécifique à IBM WebSphere MQ.

Si vous avez récupéré les bocaux MQ quelque part et que vous n'avez pas l'installation complète (et que vous n'avez donc pas d'exemples), vous pouvez le télécharger en tant que SupportPac MQC7 . Le téléchargement est gratuit. En général, vous devez utiliser le dernier client, même avec un gestionnaire de files d'attente de niveau supérieur. Évidemment, vous n'obtenez pas la fonctionnalité V7 d'un QMgr V6, mais l'implémentation JMS dans le client V7 est bien améliorée, même pour la fonctionnalité V6. Si pour une raison quelconque, vous devez vraiment utiliser le client V6, vous pouvez le télécharger en tant que SupportPacMQC6 . Quelle que soit la version du client que vous utilisez, assurez-vous d'utiliser l'Infocenter correspondant.

Infocentre V6
Infocentre V7

Enfin, la page de destination avec un index pour tous les SupportPacs est ici .

48
T.Rob

ne application JMS autonome (synchrone) complète avec TextMessage.
Il est spécifique à IBM WebSphere MQ.

import javax.jms.DeliveryMode;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueReceiver;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.jms.Session;
import javax.jms.TextMessage;

import com.ibm.mq.jms.JMSC;
import com.ibm.mq.jms.MQQueueConnectionFactory;

public class JMSApplicationStandAlone {
    public static void main(String[] args) {
        try {
            /*MQ Configuration*/
            MQQueueConnectionFactory mqQueueConnectionFactory = new MQQueueConnectionFactory();
            mqQueueConnectionFactory.setHostName("localhost");
            mqQueueConnectionFactory.setChannel("MQ.CHANNEL");//communications link
            mqQueueConnectionFactory.setPort(1416);
            mqQueueConnectionFactory.setQueueManager("QUEUE.MGR");//service provider 
            mqQueueConnectionFactory.setTransportType(JMSC.MQJMS_TP_CLIENT_MQ_TCPIP);

            /*Create Connection */
            QueueConnection queueConnection = mqQueueConnectionFactory.createQueueConnection();
            queueConnection.start();

            /*Create session */
            QueueSession queueSession = queueConnection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);

            /*Create response queue */
            Queue queue = queueSession.createQueue("QUEUE.RESPONSE");


            /*Create text message */
            TextMessage textMessage = queueSession.createTextMessage("put some message here");
            textMessage.setJMSReplyTo(queue);
            textMessage.setJMSType("mcd://xmlns");//message type
            textMessage.setJMSExpiration(2*1000);//message expiration
            textMessage.setJMSDeliveryMode(DeliveryMode.PERSISTENT); //message delivery mode either persistent or non-persistemnt

            /*Create sender queue */
            QueueSender queueSender = queueSession.createSender(queueSession.createQueue("QUEUE.REQEST"));
            queueSender.setTimeToLive(2*1000);
            queueSender.send(textMessage);

            /*After sending a message we get message id */
            System.out.println("after sending a message we get message id "+ textMessage.getJMSMessageID());
            String jmsCorrelationID = " JMSCorrelationID = '" + textMessage.getJMSMessageID() + "'";


            /*Within the session we have to create queue reciver */
            QueueReceiver queueReceiver = queueSession.createReceiver(queue,jmsCorrelationID);


            /*Receive the message from*/
            Message message = queueReceiver.receive(60*1000);
            String responseMsg = ((TextMessage) message).getText();

            queueSender.close();
            queueReceiver.close();
            queueSession.close();
            queueConnection.close();


        } catch (JMSException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Remarque: remplacez les valeurs de configuration

10
Premraj

Si cela ne vous dérange pas d'écrire du code spécifique à WMQ, vous pouvez le faire

MQConnectionFactory cf = new MQConnectionFactory();
cf.setHostName(HOSTNAME);
cf.setPort(PORT);
cf.setChannel(CHANNEL);
cf.setQueueManager(QMNAME);
cf.setTransportType(WMQConstants.WMQ_CM_CLIENT);

puis les ressources JMS habituelles

Connection c = cf.createConnection();
Session s = c.createSession(false, Session.AUTO_ACKNOWLEDGE);
Queue q = s.createQueue("myQueue"); // replace with real queue name
MessageProducer p = s.createProducer(q);

et enfin créer et envoyer un message

Message m = s.createTextMessage("Hello, World!);
p.send(m);

(J'ai tapé ça du haut de ma tête donc je ne peux pas exclure une faute de frappe, mais c'est fondamentalement correct). Si vous êtes vraiment censé utiliser 'JMS pur' - c'est-à-dire sans objets spécifiques au fournisseur - alors vous devez lier un objet MQConnectionFactory dans JNDI (jetez un œil à l'outil JMSAdmin, il est dans les documents) puis recherchez-le de votre application, c.-à-d.

InitialContext ic = new InitialContext(); // or as appropraite
ConnectionFactory cf = (ConnectionFactory)ic.lookup("myMQfactory"); // replace with JNDI name
9
strmqm

En règle générale, avec JMS, vous définissez le QueueConnectionFactory dans votre conteneur via le mécanisme de configuration qu'il met à disposition, puis l'ajoutez au registre JNDI du conteneur. Chaque conteneur aurait ses propres méthodes pour le faire (c'est-à-dire Tomcat contre WebSphere).

Si vous souhaitez renoncer à JNDI, vous pouvez créer une instance de com.ibm.mq.jms.MQQueueConnectionFactory directement et définissez le nom d'hôte, le port, le gestionnaire de files d'attente et les propriétés de canal sur celui-ci. Vous pouvez ensuite utiliser cet objet comme vous le feriez pour une instance de javax.jms.QueueConnectionFactory car il l'implémente.

3
laz

Je ne peux pas vous enseigner JMS dans un seul article, mais je peux vous indiquer certaines des ressources que j'ai utilisées pour l'apprendre moi-même:

  1. The O'Reilly Java Message Service livre
  2. IBM Developerworks JMS Tutorial (plus spécifique à MQSeries/Websphere MQ)
  3. Le framework Spring peut vous aider à utiliser JMS plus efficacement, surtout si vous développez une application autonome en dehors d'un serveur d'application J2EE: Spring Java Documentation Service Message
2
Kaypro II

C'est assez courant. Ici sont quelques exemples.

0
Preston