JMS (Java Message Service) est une API qui permet de créer, d'envoyer et de lire des messages. Il fournit une communication faiblement couplée, fiable et asynchrone.

couverture rigide ou livre de poche

JMS est également connu sous le nom de service de messagerie.

Comprendre la messagerie

La messagerie est une technique permettant de communiquer des applications ou des composants logiciels.

JMS est principalement utilisé pour envoyer et recevoir des messages d’une application à une autre.

Exigence de JMS

Généralement, l'utilisateur envoie un message à l'application. Mais si nous voulons envoyer un message d’une application à une autre, nous devons utiliser l’API JMS.

Prenons un scénario : une application A s'exécute en INDE et une autre application B s'exécute aux États-Unis. Pour envoyer un message d'une application A à B, nous devons utiliser JMS.

Avantage de JMS

1) Asynchrone: Pour recevoir le message, le client n'est pas tenu d'envoyer une demande. Le message arrivera automatiquement au client.

2) Fiable: Il fournit l’assurance que le message est délivré.

Domaines de messagerie

Il existe deux types de domaines de messagerie dans JMS.

1. Domaine de messagerie point à point
2. Domaine de messagerie éditeur/abonné

1) Domaine de messagerie point à point (PTP)

Dans le modèle PTP, un message est livré à un destinataire seulement. Ici, File d'attente est utilisé comme middleware orienté message (MOM).

La file d'attente est chargée de conserver le message jusqu'à ce que le destinataire soit prêt.

Dans le modèle PTP, il y a aucune dépendance temporelle entre l'expéditeur et le destinataire.

2) Domaine de messagerie éditeur/abonné (Pub/Sub)

Dans le modèle Pub/Sub, un message est livré à tous les abonnés . C'est comme la radiodiffusion. Ici, Sujet est utilisé comme un middleware orienté message chargé de conserver et de transmettre les messages.

Dans le modèle PTP, il y a dépendance temporelle entre éditeur et abonné.

Modèle de programmation JMS

Exemple de file d'attente JMS

Pour développer un exemple de file d'attente JMS, vous devez installer n'importe quel serveur d'applications. Ici, nous utilisons poisson de verre3 serveur sur lequel nous créons deux JNDI.

1. Créer une fabrique de connexions nommée maQueueConnectionFactory
2. Créer une ressource de destination nommée maFile d'Attente

Après avoir créé JNDI, créez l'application serveur et réceptrice. Vous devez exécuter le serveur et le récepteur dans une console différente. Ici, nous utilisons Eclipse IDE, il est ouvert par défaut dans une console différente.

1) Créer une fabrique de connexions et une ressource de destination

Ouvrir la console d'administration du serveur par l'URL http://localhost:4848

Connectez-vous avec le nom d'utilisateur et le mot de passe.

Clique sur le Ressource JMS -> Fabriques de connexions -> Nouveau , écrivez maintenant le nom du pool et sélectionnez le type de ressource comme QueueConnectionFactory puis cliquez sur le bouton ok.

Clique sur le Ressource JMS -> Ressources de destination -> Nouveau , écrivez maintenant le nom JNDI et le nom de la destination physique puis cliquez sur le bouton ok.

2) Créer une application émettrice et réceptrice

Voyons le code de l'expéditeur et du destinataire. Notez que Receiver est attaché à un écouteur qui sera invoqué lorsque l'utilisateur envoie un message.

 import java.io.BufferedReader; import java.io.InputStreamReader; import javax.naming.*; import javax.jms.*; public class MySender { public static void main(String[] args) { try { //Create and start connection InitialContext ctx=new InitialContext(); QueueConnectionFactory f=(QueueConnectionFactory)ctx.lookup('myQueueConnectionFactory'); QueueConnection con=f.createQueueConnection(); con.start(); //2) create queue session QueueSession ses=con.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); //3) get the Queue object Queue t=(Queue)ctx.lookup('myQueue'); //4)create QueueSender object QueueSender sender=ses.createSender(t); //5) create TextMessage object TextMessage msg=ses.createTextMessage(); //6) write message BufferedReader b=new BufferedReader(new InputStreamReader(System.in)); while(true) { System.out.println('Enter Msg, end to terminate:'); String s=b.readLine(); if (s.equals('end')) break; msg.setText(s); //7) send message sender.send(msg); System.out.println('Message successfully sent.'); } //8) connection close con.close(); }catch(Exception e){System.out.println(e);} } } 

 import javax.jms.*; import javax.naming.InitialContext; public class MyReceiver { public static void main(String[] args) { try{ //1) Create and start connection InitialContext ctx=new InitialContext(); QueueConnectionFactory f=(QueueConnectionFactory)ctx.lookup('myQueueConnectionFactory'); QueueConnection con=f.createQueueConnection(); con.start(); //2) create Queue session QueueSession ses=con.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); //3) get the Queue object Queue t=(Queue)ctx.lookup('myQueue'); //4)create QueueReceiver QueueReceiver receiver=ses.createReceiver(t); //5) create listener object MyListener listener=new MyListener(); //6) register the listener object with receiver receiver.setMessageListener(listener); System.out.println('Receiver1 is ready, waiting for messages...'); System.out.println('press Ctrl+c to shutdown...'); while(true){ Thread.sleep(1000); } }catch(Exception e){System.out.println(e);} } } 

 import javax.jms.*; public class MyListener implements MessageListener { public void onMessage(Message m) { try{ TextMessage msg=(TextMessage)m; System.out.println('following message is received:'+msg.getText()); }catch(JMSException e){System.out.println(e);} } } 

Exécutez d’abord la classe Receiver, puis la classe Sender.

Exemple de sujet JMS

C'est la même chose que la file d'attente JMS, mais vous devez changer la file d'attente en sujet, l'expéditeur en éditeur et le destinataire en abonné.

Vous devez créer 2 JNDI nommés myTopicConnectionFactory et mon sujet .

 import java.io.BufferedReader; import java.io.InputStreamReader; import javax.naming.*; import javax.jms.*; public class MySender { public static void main(String[] args) { try { //Create and start connection InitialContext ctx=new InitialContext(); TopicConnectionFactory f=(TopicConnectionFactory)ctx.lookup('myTopicConnectionFactory'); TopicConnection con=f.createTopicConnection(); con.start(); //2) create queue session TopicSession ses=con.createTopicSession(false, Session.AUTO_ACKNOWLEDGE); //3) get the Topic object Topic t=(Topic)ctx.lookup('myTopic'); //4)create TopicPublisher object TopicPublisher publisher=ses.createPublisher(t); //5) create TextMessage object TextMessage msg=ses.createTextMessage(); //6) write message BufferedReader b=new BufferedReader(new InputStreamReader(System.in)); while(true) { System.out.println('Enter Msg, end to terminate:'); String s=b.readLine(); if (s.equals('end')) break; msg.setText(s); //7) send message publisher.publish(msg); System.out.println('Message successfully sent.'); } //8) connection close con.close(); }catch(Exception e){System.out.println(e);} } } 

 import javax.jms.*; import javax.naming.InitialContext; public class MyReceiver { public static void main(String[] args) { try { //1) Create and start connection InitialContext ctx=new InitialContext(); TopicConnectionFactory f=(TopicConnectionFactory)ctx.lookup('myTopicConnectionFactory'); TopicConnection con=f.createTopicConnection(); con.start(); //2) create topic session TopicSession ses=con.createTopicSession(false, Session.AUTO_ACKNOWLEDGE); //3) get the Topic object Topic t=(Topic)ctx.lookup('myTopic'); //4)create TopicSubscriber TopicSubscriber receiver=ses.createSubscriber(t); //5) create listener object MyListener listener=new MyListener(); //6) register the listener object with subscriber receiver.setMessageListener(listener); System.out.println('Subscriber1 is ready, waiting for messages...'); System.out.println('press Ctrl+c to shutdown...'); while(true){ Thread.sleep(1000); } }catch(Exception e){System.out.println(e);} } } 

 import javax.jms.*; public class MyListener implements MessageListener { public void onMessage(Message m) { try{ TextMessage msg=(TextMessage)m; System.out.println('following message is received:'+msg.getText()); }catch(JMSException e){System.out.println(e);} } }