• Años 60, Grandes empresas invirtieron grandes cantidad de dinero en Mainframes para las aplicaciones críticas, el acceso era restringido a pocas opciones de entrada.
• Años 70, los usuarios empezaron a acceder a los mainframes a través de terminales los cuales expandieron el uso de estos sistemas permitiendo el acceso concurrente de miles de usuarios.
• En los 80, además de los terminales gráficos disponibles, los PCs llegaron al mercado y la emulación de terminales se convirtió en algo común. La interconectividad se convirtió en un aspecto muy importante ya que las aplicaciones desarrolladas para ejecutarse sobre PCs necesitaban acceder a los mainframes. Esta diversidad de plataformas y protocolos introdujo nuevos problemas que había que resolver.

Solución

• Utilizar un Middleware que ofrece un mecanismo de mensajería fiable y asíncrono tales como WebShpereMQ, SonicMQ, TIBCO, Apache ActiveMQ, etc...
• Así, es posible comunicar y transferir datos entre diferentes aplicaciones, sistemas operativos, protocolos e incluso diferentes lenguajes de programación.

Midleware Orientado a Mensajes (MOM)

• Software para la intercomunicación de sistemas que ofrece una manera segura, escalable, confiable y con bajo acoplamiento.
• Permiten la comunicación entre aplicaciones mediante un conjunto de APIs ofrecidas por cada proveedor y lenguaje, así pues, tendremos un API propietaria y diferente por cada MOM existente.
• Actúa como un mediador entre los emisores y los receptores de mensajes, tanto es su conectividad como en la mensajería misma.

La mayoría de MOMs existentes en el mercado ofrecen soporte para diversos protocolos de conectividad, como pueden ser HTTP/S, SSL, TCP/IP, UDP, etc... Incluso algunos proveedores ofrecen soporte para múltiples lenguajes de programación, facilitando del uso de MOMs en una amplia variedad de entornos. Este gran abanico de protocolos, lenguajes y APIs provoca la aparición de JMS para estandarizar la mensajería dentro del mundo Java.

¿Qué es Java Message Service?

Es una API incluida actualmente en Java Enterprise Edition, busca proporcionar un estándar, sobre la variedad de protocolos existentes en los servicios de mensajería instantánea también conocidos como Middleware Orientado a Mensajes (MOM). El estándar de JMS permite a los componentes de aplicaciones que se basan en Java2 enviar y recibir mensajes pudiendo hacer uso de colas de mensajes.

• Cliente de mensajería.
• API JMS.
• Proveedor: servidor orientado a la mensajería con acceso al protocolo de JMS.
• Cliente consumidor de mensajería.

¿Por qué usar JMS?

• Simplifica el conocimiento de mensajeria empresarial que debe tener un programador de Java para desarrollar aplicaciones de mensajería.
• La comunicación es débilmente acoplada, es decir, un componente envía un mensaje a un destino y el receptor lo recoge de aquel destino.
• Ni el emisor ni el receptor tiene que estar disponibles al mismo tiempo de la comunicación (independencia y asíncronia).
• Permite portabilidad entre las diferentes implementaciones de proveedores JMS.
• JMS no se considera un MOM, más bien, abstrae la interacción entre clientes de mensajería y los MOMs.

Tipos de Modelos de Mensajería

Existen dos modelos de mensajería:
Punto a Punto (PTP): el mensaje se consume por un único consumidor.

Publicación/Subscripción (Pub/Sub): el mensaje es consumido por muchos consumidores.

¿Comó funciona JMS?

Está compuesta por los siguientes componentes:

• Cliente JMS: una aplicación en java que envía y recibe  mensajes JMS.
• Productor JMS: es un cliente que crea y envía mensajes JMS. 
• Consumidor JMS: es un cliente que recibe y procesas los mensajes JMS.
• Proveedor JMS: implementación de los interfaces JMS, el proveedor se encarga de la administración y control de los recursos JMS.
• Mensaje JMS: objeto compuesto por cabecera, propiedades y cuerpo, él cual contiene información y es enviado y recibido por clientes JMS.
• Dominio JMS: se denomina a los modelos de envía de mensajes: pear to pear y publicador/subscriptores.
• Objetos administrativos: objetos de JMS preconfigurados que contienen datos de configuración específicos del proveedor, estos son utilizados por los clientes. 

Objetos Administrativos

Los clientes acceden a estos objetos mediante JNDI (Java Naming and Dictory Interface), está interfaz es una API para servicios de directorios y permite a los clientes descubrir y buscar objetos y datos a través de un nombre. Los objetos se clasifican en: 

• Factoría de conexión: permite crear conexiones con el proveedor JMS.
• Destino: objeto del tipo cola/tópico al cual se direccionan y envían los mensajes, y desde donde también se reciben los mensajes.

Estos objetos son mantenidos mediante administración, es decir, no es necesaria la programación, mas bien, se configura dependiendo del tipo de proveedor de JMS, la administración de estos objetos se realiza dentro de un espacio de nombre de JNDI.

Los clientes acceden a estos objetos mediante interfaces que inyectan recursos a los clientes.

Factorías de Conexión

Objeto utilizado por el cliente para crear una conexión con el proveedor. Contiene un conjunto de parámetros de configuración de conexión, los cuales previamente han sido definidos por el administrador del servidor.
Cada factoría es una instancia de ConnectionFactory pudiendo ser QueueConnectionFactory o TopicConnectionFactory

Factoría común:

@Resource(mappedName="jms/ConnectionFactory")
private static ConnectionFactory connectionFactory;

Factorías especificas:

@Resource(mappedName="jms/QueueConnectionFactory")
private static QueueConnectionFactory queueConnectionFactory;
@Resource(mappedName="jms/TopicConnectionFactory")
private static TopicConnectionFactory topicConnectionFactory;

Destinos

Es el objeto que usa el cliente para especificar el destino de los mensajes que produce y el origen de los mensajes que consume. PTP los destinos son las colas(javax.jms.Queue), mientras que en Pub/Sub son los tópicos(javax.jms.Topic).

Cola y Tópico

@Resource(mappedName="jms/Queue")
private static Queue queue;
@Resource(mappedName="jms/Topic")
private static Topic topic;

Modelo de Programación JMS

• Basado en interfaces

Conexiones

Una conexión encapsula una conexión virtual con el proveedor JMS. Al crear una conexión, se crean objetos de parte del cliente y del servidor.
Mediante una conexión se pueden crear una o más sesiones en las cuales se producen y consumen los mensajes.
Las conexiones implementan la interfaz.
javax.jms.Connection

Creanción de conexiones:

Connection connection = connectionFactory.createConnection();
QueueConnection queueConnection = queueConnectionFactory.createQueueConnection();
TopicConnection topicConnection = topicConnectionFactory.createTopicConnection();

Antes de consumir mensajes se debe llamar al método start de la conexión.
Al finalizar la aplicación se debe cerrar la conexión para evitar sobrecarga del proveedor JMS.
conection.close();
Al cerrar una conexión también se cierran sus sesiones y productores y consumidores de mensajes.

Sesiones

Una sesión es un contexto monohilo para producir y consumir mensajes, mediante sesiones se crean

• Productores de mensajes.
• Consumidores de mensajes.
• Mensajes.
• Navegadores de colas.
• Colas y tópicos temporales.

Existen dos tipos de sesiones:

• Transaccionales: no es necesario enviar acuse de recibo.
• No-transaccionales: hay que elegir un tipo de acuse de recibo.

Creación sessión transaccional

Session session = connection.createSession(true, 0);

Creación sessión no-transaccional

Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); ;

Productores de Mensajes

• Un productor de mensajes es un objeto creado por una sesión y se utiliza para enviar mensajes a un destino.
• Implementa la interfaz javax.jms.MessageProducer .

A partir de la sesión y un destino se pueden crear diferentes tipos de productores.

MessageProducer producerD = session.createProducer(dest);
MessageProducer producerQ = session.createProducer(queue);
MessageProducer producerT = session.createProducer(topic);
;

Productores específicos

QueueSender sender = queueSession.createSender(queue);
TopicPublisher publisher = topicSession.createPublisher(topic);

Para enviar mensajes se utiliza el método send.

producer.send(message);

Consumidores de Mensajes

• Un consumidor de mensajes es un objeto creado por una sesión y que es utilizado para recibir mensajes enviados desde un destino.
• Implementa la interfaz javax.jms.MessageConsumer.

Usando la sesión y el destino se pueden crear diferentes tipos de productores.

MessageConsumer consumer = session.createConsumer(dest);
MessageConsumer consumer = session.createConsumer(queue);
MessageConsumer consumer = session.createConsumer(topic);

Consumidores específicos

QueueReceiver receiver = queueSession.createReceiver(queue);
TopicSubscriber subscriber = topicSession.createSubscriber(topic);

Luego de crear un consumidor, éste queda activo y se puede utilizar para recibir mensajes.
Para consumir de forma sincrónica utilizar el método receive.

connection.start();
Message m = consumer.receive();
connection.start();
Message m = consumer.receive(1000); // timeout tras un seg

Listener de Mensajes

• Es un objeto queonsumer = session.createConsumer(d actúa como un manejador de eventos asíncronicos para mensajes.
• Implemente la interfaz javax.jms.MessageListener, el cual solo posee el método onMessage, este método permite definir las acciones a realizar cuando un mensajes es recibido.

Para registrar el listener se utiliza el método

setMessageListener del interfaz MessageConsumer.

MiListener myListener = new MiListener();
consumer.setMessageListener(myListener);

Mensajes

Son creados a partir de objetos de sesión.

TextMessage message = session.createTextMessage();

Un mensaje contiene tres componentes: los campos de la cabecera, las propiedades especificas de la aplicación y el cuerpo del mensaje.

Pasos de una aplicación JMS

1. Adquirir una factoría de conexión.
2. Crear una conexión mediante la factoría de conexión.
3. Comenzar la conexión.
4. Crear una sesión a partir de la conexión.
5. Adquirir un destino.
6. Dependiendo si se envía o se recibe.
   • Crea un productor
     • Crea un productor.
     • Crea un mensaje y lo adjunta a su destino.
   • Crea un consumidor
     • Crea un consumidor.
     • Opcionalmente registrar un listener de mensajes.
7. Enviar/Recibir mensajes.
8. Cerrar los objetos (consumidor, productor, sesión, conexión)

Código

Sender.java
Receiver.java

Referencias

The Java EE 6 Tutorial/Oracle
Servicios de Mensajes con JMS/expertojava