JMS

Technologia JMS, to pewnego rodzaju uniwersalny interfejs (kolejna warstwa) do systemów kolejkowych. Systemy takie przystosowane są do obsługi komunikacji asynchronicznej. Pozwalają one na wysyłanie i odbieranie komunikatów pomiędzy systemami. Ważną zaletą technologii JMS jest to, że przesłania ona dedykowane dla konkretnego systemu kolejkowania API własnym ustandardyzowanym API, co powoduje, że ułatwione jest przejście z jednego systemu na inny bez dużych zmian w kodzie aplikacji. Jako, że jest to kolejna warstwa aplikacyjna istnieje tutaj pewien narzut na wydajności. Jeśli nie ma jakiś szczególnych wymagań co do wydajności, wydaje się, że zaleta uniwersalności przeważy te wydajnościowe niedoskonałości.

Przykładowy kod JMS realizujący wysyłkę i odbiór komunikatu może mieć postać:

package jmstest;
import java.util.*;
import javax.jms.*;
import javax.naming.*;
import javax.naming.directory.*;
public class JMSExample implements MessageListener {
        public static void main(String[] args) {
                JMSExample jms = new JMSExample();
                jms.execute();
        }
        public void execute() {
                String icf = "com.sun.jndi.fscontext.RefFSContextFactory";
                // initial context factory
                String url = "file:/d:/tools/MQSeries/Java/bin/JNDI"; //url
                QueueConnectionFactory connectionFactory = null;
                QueueConnection connection = null;
                QueueSession session = null;
                Queue queueIN = null;
                Queue queueOUT = null;
                QueueSender sender = null;
                QueueReceiver receiver = null;
                TextMessage message = null;
                Hashtable env = new Hashtable();
                env.put(Context.INITIAL_CONTEXT_FACTORY, icf);
                env.put(Context.PROVIDER_URL, url);
                env.put(Context.REFERRAL, "throw");
                Context ctx = null;
                try {
                        System.out.println("Initialising JNDI... ");
                        ctx = new InitialDirContext(env);
                } catch (NamingException nx) {
                        System.out.println("ERROR: " + nx);
                        System.exit(-1);
                }
                try {
                        System.out.println("Creating JNDI objects... ");
                        connectionFactory = (QueueConnectionFactory) ctx.lookup("QCF");
                        queueIN = (Queue) ctx.lookup("QIN");
                        queueOUT = (Queue) ctx.lookup("QOUT");
                        ctx.close();
                } catch (NamingException nx) {
                        System.out.println("ERROR: " + nx);
                        System.exit(-1);
                }
                try {
                        System.out.println("Creating objects ... ");
                        connection = connectionFactory.createQueueConnection();
                        connection.start();
                        session =
                                connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
                } catch (JMSException e) {
                        System.out.println("ERROR: " + e);
                        System.exit(-1);
                }
                
                try {
                        
                        System.out.println("Creating sender and sending... ");
                        sender = session.createSender(queueIN);
                        //dla wszystkikich komunikatów
                        sender.setTimeToLive(10000);
                        message = session.createTextMessage("TEST message");
                                                
                        sender.send(message);
                        sender.close();
                        System.out.println("getJMSMessageID: " +
                        message.getJMSCorrelationID());
                
                } catch (JMSException e) {
                        System.out.println("ERROR: " + e);
                        System.exit(-1);
                }
                
                try {
                        System.out.println("Creating receiver and receiving... ");
                        receiver = session.createReceiver(queueIN);
                        
                        Message msg = receiver.receive(1000);
                        if (msg == null) {
                                System.out.println("Brak komunikatu");
                        } else if (msg instanceof TextMessage) {
                                message = (TextMessage) msg;
                                
                                String a=message.getText();
                                System.out.println("message=" + a);
                                System.out.println("Reading message: " + message.getText());
                        } else {
                                System.out.println("HANDLER ERROR: " + msg.toString());
                        }
                } catch (JMSException e) {
                        System.out.println("ERROR: " + e);
                        System.exit(-1);
                }
                
        }
        public void onMessage(Message arg0) {
                System.out.println("arg0.toString());
        }
}

Wielowątkowość

W przypadku aplikacji wielowątkowych ważne jest, że wszystkie obiekty administracyjne i obiekty związane z połączeniem mogą być współdzielone przez wątki. Obiekt typu Session oraz obiekty typu MessageProducers i MessageConsumer z kolei są przystosowane do pracy w ramach jednego wątku JAVA

Powrót