TechCodeview

A JMS (Java Message Service) egy API, amely lehetőséget biztosít üzenetek létrehozására, küldésére és olvasására. Lazán csatolt, megbízható és aszinkron kommunikációt biztosít.

hármas tél

A JMS üzenetküldő szolgáltatásként is ismert.

Az üzenetkezelés megértése

Az üzenetküldés az alkalmazások vagy szoftverkomponensek kommunikációjának módszere.

A JMS-t elsősorban üzenetek küldésére és fogadására használják egyik alkalmazásból a másikba.

JMS követelmény

Általában a felhasználó üzenetet küld az alkalmazásnak. De ha üzenetet akarunk küldeni egyik alkalmazásból a másikba, akkor JMS API-t kell használnunk.

Tekintsünk egy forgatókönyvet, amelyben az egyik „A” alkalmazás INDIÁBAN, a másik „B” alkalmazás pedig az Egyesült Államokban fut. Ahhoz, hogy üzenetet küldjünk A alkalmazásból B-nek, JMS-t kell használnunk.

A JMS előnyei

1) Aszinkron: Az üzenet fogadásához az ügyfélnek nem kell kérést küldenie. Az üzenet automatikusan megérkezik az ügyfélhez.

2) Megbízható: Biztosítékot nyújt az üzenet kézbesítésére.

Üzenetküldési tartományok

A JMS-ben kétféle üzenetkezelési tartomány létezik.

1. Pont-pont üzenetküldési tartomány
2. Kiadói/előfizetői üzenetküldési tartomány

1) Pont-pont (PTP) üzenetküldési tartomány

A PTP modellben egy üzenet az egy vevőhöz szállítják csak. Itt, Sor üzenetorientált köztes szoftverként (MOM) használják.

A sor felelős azért, hogy az üzenetet megtartsa, amíg a fogadó készen nem áll.

A PTP modellben van nincs időzítésfüggőség feladó és fogadó között.

2) Kiadó/előfizető (Pub/Sub) Messaging Domain

A Pub/Sub modellben egy üzenet az minden előfizetőnek kézbesítve . Ez olyan, mint a közvetítés. Itt, Téma üzenetorientált köztes szoftverként használják, amely az üzenetek tárolásáért és kézbesítéséért felelős.

A PTP modellben van időzítési függőség kiadó és előfizető között.

JMS programozási modell

JMS Queue példa

A JMS-sor példa fejlesztéséhez telepítenie kell bármely alkalmazáskiszolgálót. Itt használjuk üveghal3 szerver, ahol két JNDI-t hozunk létre.

1. Név kapcsolatgyár létrehozása myQueueConnectionFactory
2. Név célerőforrás létrehozása myQueue

A JNDI létrehozása után hozzon létre szerver és vevő alkalmazást. A szervert és a vevőt különböző konzolon kell futtatnia. Itt eclipse IDE-t használunk, alapértelmezés szerint más konzolon nyílik meg.

1) Hozzon létre kapcsolatgyárat és célerőforrást

Nyissa meg a szerver felügyeleti konzolját az URL-lel http://localhost:4848

Jelentkezzen be a felhasználónévvel és jelszóval.

Kattintson a JMS erőforrás -> Connection Factories -> New , most írja be a készlet nevét, és válassza ki az Erőforrás típusát QueueConnectionFactory néven, majd kattintson az OK gombra.

Kattintson a JMS erőforrás -> Cél erőforrások -> Új , most írja be a JNDI nevét és a fizikai célállomás nevét, majd kattintson az OK gombra.

2) Hozzon létre küldő és fogadó alkalmazást

Lássuk a küldő és fogadó kódot. Ne feledje, hogy a Vevő a figyelőhöz van csatolva, amely meghívásra kerül, amikor a felhasználó üzenetet küld.

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

Futtassa először a fogadó osztályt, majd a küldő osztályt.

JMS téma példa

Ez ugyanaz, mint a JMS Queue, de módosítania kell a Queue elemet a témakörre, a feladót a kiadóra és a fogadót az előfizetőre.

Létre kell hoznia 2 nevű JNDI-t myTopicConnectionFactory és myTopic .

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