JMS (Java Message Service) ist eine API, die die Möglichkeit bietet, Nachrichten zu erstellen, zu senden und zu lesen. Es bietet eine lose gekoppelte, zuverlässige und asynchrone Kommunikation.

Latextisch

JMS wird auch als Messaging-Dienst bezeichnet.

Nachrichten verstehen

Messaging ist eine Technik zur Kommunikation von Anwendungen oder Softwarekomponenten.

JMS wird hauptsächlich zum Senden und Empfangen von Nachrichten von einer Anwendung an eine andere verwendet.

Anforderung von JMS

Im Allgemeinen sendet der Benutzer eine Nachricht an die Anwendung. Wenn wir jedoch Nachrichten von einer Anwendung an eine andere senden möchten, müssen wir die JMS-API verwenden.

Stellen Sie sich ein Szenario vor: Eine Anwendung A läuft in INDIEN und eine andere Anwendung B läuft in den USA. Um eine Nachricht von einer Anwendung an B zu senden, müssen wir JMS verwenden.

Vorteil von JMS

1) Asynchron: Um die Nachricht zu empfangen, muss der Client keine Anfrage senden. Die Nachricht wird automatisch beim Kunden eingehen.

2) Zuverlässig: Es bietet die Gewissheit, dass die Nachricht zugestellt wird.

Messaging-Domänen

Es gibt zwei Arten von Messaging-Domänen in JMS.

1. Punkt-zu-Punkt-Messaging-Domäne
2. Herausgeber-/Abonnenten-Messaging-Domäne

1) Punkt-zu-Punkt-Messaging-Domäne (PTP).

Im PTP-Modell ist eine Nachricht an einen Empfänger geliefert nur. Hier, Warteschlange wird als nachrichtenorientierte Middleware (MOM) verwendet.

Die Warteschlange ist dafür verantwortlich, die Nachricht zu halten, bis der Empfänger bereit ist.

Im PTP-Modell gibt es keine Zeitabhängigkeit zwischen Sender und Empfänger.

2) Herausgeber/Abonnent-Messaging-Domäne (Pub/Sub).

Im Pub/Sub-Modell ist eine Nachricht an alle Abonnenten zugestellt . Es ist wie eine Übertragung. Hier, Thema wird als nachrichtenorientierte Middleware verwendet, die für das Speichern und Zustellen von Nachrichten verantwortlich ist.

Im PTP-Modell gibt es Zeitabhängigkeit zwischen Herausgeber und Abonnent.

JMS-Programmiermodell

Beispiel für eine JMS-Warteschlange

Um ein Beispiel für eine JMS-Warteschlange zu entwickeln, müssen Sie einen beliebigen Anwendungsserver installieren. Hier verwenden wir Glasfisch3 Server, auf dem wir zwei JNDI erstellen.

1. Erstellen Sie eine Verbindungsfactory mit dem Namen myQueueConnectionFactory
2. Erstellen Sie eine Zielressource mit dem Namen myQueue

Erstellen Sie nach dem Erstellen von JNDI eine Server- und Empfängeranwendung. Sie müssen Server und Empfänger in unterschiedlichen Konsolen ausführen. Hier verwenden wir die Eclipse-IDE, sie wird standardmäßig in einer anderen Konsole geöffnet.

1) Erstellen Sie eine Verbindungsfabrik und eine Zielressource

Öffnen Sie die Server-Administratorkonsole über die URL http://localhost:4848

Melden Sie sich mit Benutzername und Passwort an.

Klick auf das JMS-Ressource -> Verbindungsfabriken -> Neu Geben Sie nun den Namen des Pools ein, wählen Sie den Ressourcentyp „QueueConnectionFactory“ aus und klicken Sie dann auf die Schaltfläche „OK“.

Klick auf das JMS-Ressource -> Zielressourcen -> Neu Geben Sie nun den JNDI-Namen und den Namen des physischen Ziels ein und klicken Sie dann auf die Schaltfläche „OK“.

2) Erstellen Sie eine Sender- und Empfängeranwendung

Sehen wir uns den Sender- und Empfängercode an. Beachten Sie, dass Receiver mit einem Listener verbunden ist, der aufgerufen wird, wenn der Benutzer eine Nachricht sendet.

 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);} } } 

Führen Sie zuerst die Receiver-Klasse und dann die Sender-Klasse aus.

Beispiel für ein JMS-Thema

Es ist dasselbe wie die JMS-Warteschlange, Sie müssen jedoch „Warteschlange“ in „Thema“, „Sender“ in „Herausgeber“ und „Empfänger“ in „Abonnent“ ändern.

Sie müssen zwei JNDI-Namen erstellen myTopicConnectionFactory Und mein Thema .

 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);} } }