JMS (Java Message Service) to interfejs API umożliwiający tworzenie, wysyłanie i odczytywanie wiadomości. Zapewnia luźno powiązaną, niezawodną i asynchroniczną komunikację.

dfs kontra bfs

JMS jest również znany jako usługa przesyłania wiadomości.

Zrozumienie wiadomości

Przesyłanie wiadomości to technika komunikowania się z aplikacjami lub składnikami oprogramowania.

JMS służy głównie do wysyłania i odbierania wiadomości z jednej aplikacji do drugiej.

Wymóg JMS

Zwykle użytkownik wysyła wiadomość do aplikacji. Jeśli jednak chcemy wysłać wiadomość z jednej aplikacji do drugiej, musimy skorzystać z API JMS.

Rozważmy scenariusz, w którym jedna aplikacja A działa w Indiach, a inna aplikacja B w USA. Aby wysłać wiadomość z aplikacji A do B, musimy użyć JMS.

Zaleta JMS-a

1) Asynchroniczny: Aby otrzymać wiadomość, klient nie musi wysyłać żądania. Wiadomość dotrze automatycznie do klienta.

2) Niezawodny: Daje pewność, że wiadomość została dostarczona.

Domeny wiadomości

W JMS istnieją dwa typy domen komunikacyjnych.

1. Domena przesyłania wiadomości typu punkt-punkt
2. Domena wiadomości wydawcy/subskrybenta

1) Domena przesyłania wiadomości typu punkt-punkt (PTP).

W modelu PTP jest jeden komunikat dostarczone do jednego odbiorcy tylko. Tutaj, Kolejka jest używany jako oprogramowanie pośredniczące zorientowane na komunikaty (MOM).

Kolejka jest odpowiedzialna za zatrzymanie wiadomości do czasu, aż odbiorca będzie gotowy.

W modelu PTP tak brak zależności od czasu pomiędzy nadawcą i odbiorcą.

2) Domena komunikacyjna wydawcy/subskrybenta (Pub/Sub).

W modelu Pub/Sub jedna wiadomość to dostarczane do wszystkich abonentów . To jest jak nadawanie. Tutaj, Temat jest używany jako oprogramowanie pośredniczące zorientowane na wiadomości, które jest odpowiedzialne za przechowywanie i dostarczanie wiadomości.

W modelu PTP tak zależność od czasu pomiędzy wydawcą a subskrybentem.

Model programowania JMS

Przykład kolejki JMS

Aby opracować przykładową kolejkę JMS, należy zainstalować dowolny serwer aplikacji. Tutaj używamy szklana rybka 3 serwer, na którym tworzymy dwa JNDI.

1. Utwórz fabrykę połączeń o nazwie myQueueConnectionFactory
2. Utwórz zasób docelowy o nazwie mojaKolejka

Po utworzeniu JNDI utwórz aplikację serwera i odbiornika. Musisz uruchomić serwer i odbiornik w różnych konsolach. Tutaj używamy Eclipse IDE, domyślnie jest ono otwierane w innej konsoli.

1) Utwórz fabrykę połączeń i zasób docelowy

Otwórz konsolę administracyjną serwera za pomocą adresu URL http://localhost:4848

Zaloguj się podając nazwę użytkownika i hasło.

Kliknij na Zasoby JMS -> Fabryki połączeń -> Nowe , teraz wpisz nazwę puli i wybierz typ zasobu jako QueueConnectionFactory, a następnie kliknij przycisk OK.

Kliknij na Zasób JMS -> Zasoby docelowe -> Nowy , teraz wpisz nazwę JNDI i nazwę miejsca docelowego, a następnie kliknij przycisk OK.

2) Utwórz aplikację nadawcy i odbiorcy

Zobaczmy kod nadawcy i odbiorcy. Należy pamiętać, że odbiornik jest połączony z odbiornikiem, który zostanie wywołany, gdy użytkownik wyśle ​​wiadomość.

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

Najpierw uruchom klasę Odbiorca, a następnie klasę Nadawca.

Przykład tematu JMS

Działa tak samo jak kolejka JMS, ale musisz zmienić kolejkę na temat, nadawcę na wydawcę i odbiorcę na subskrybenta.

Musisz utworzyć 2 JNDI o nazwie myTopicConnectionFactory I mój temat .

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