java-ee
Servicio de mensajería de Java (JMS)
Buscar..
Introducción
Java Message Service es una API de Java que permite a las aplicaciones crear, enviar, recibir y leer mensajes. La API de JMS define un conjunto común de interfaces y semánticas asociadas que permiten que los programas escritos en el lenguaje de programación Java se comuniquen con otras implementaciones de mensajería. JMS permite la comunicación que no solo está acoplada de forma flexible, sino también asíncrona y confiable.
Observaciones
Java Message Service (JMS) es una API estándar de Java que permite a las aplicaciones crear, enviar, recibir y leer mensajes de forma asíncrona.
JMS define un conjunto general de interfaces y clases que permiten a las aplicaciones interactuar con otros proveedores de mensajes.
JMS es similar a JDBC: JDBC se conecta a diferentes bases de datos (Derby, MySQL, Oracle, DB2, etc.) y JMS se conecta con diferentes proveedores (OpenMQ, MQSeries, SonicMQ, etc.).
La implementación de referencia de JMS es Open Message Queue (OpenMQ). Es un proyecto de código abierto y se puede usar en aplicaciones independientes o se puede construir en un servidor de aplicaciones. Es el proveedor de JMS predeterminado integrado en GlassFish.
Creando ConnectionFactory
Las fábricas de conexiones son los objetos administrados que permiten que la aplicación se conecte al proveedor creando un objeto de Connection . javax.jms.ConnectionFactory es una interfaz que encapsula los parámetros de configuración definidos por un administrador.
Para usar ConnectionFactory cliente debe ejecutar la búsqueda JNDI (o usar la inyección). El siguiente código obtiene el objeto JNDI InitialContext y lo usa para buscar el objeto ConnectionFactory bajo el nombre JNDI:
Context ctx = new InitialContext();
ConnectionFactory connectionFactory =
(ConnectionFactory) ctx.lookup("jms/javaee7/ConnectionFactory");
Los métodos disponibles en esta interfaz son métodos createConnection() que devuelven un objeto Connection y nuevos métodos createContext() JMS 2.0 que devuelven un JMSContext .
Es posible crear una Connection o un JMSContext con la identidad de usuario predeterminada o especificando un nombre de usuario y contraseña:
public interface ConnectionFactory {
Connection createConnection() throws JMSException;
Connection createConnection(String userName, String password) throws JMSException;
JMSContext createContext();
JMSContext createContext(String userName, String password);
JMSContext createContext(String userName, String password, int sessionMode);
JMSContext createContext(int sessionMode);
}
Uso de la biblioteca ActiveMQ para mensajería (implementaciones específicas del proveedor de activemq jms)
Configurar ActiveMQ
- Descargue una distribución ActiveMQ de activemq.apache.org y descomprímala en algún lugar
- Puede iniciar el servidor inmediatamente, ejecutándose sin seguridad en localhost, usando el script bin / activemq
- Cuando se está ejecutando, puede acceder a la consola de su servidor local en http: // localhost: 8161 / admin /
- Configúralo modificando conf / activemq.xml
- Como el título sugiere los siguientes ejemplos, el usuario activemq jms implementaciones específicas del proveedor y, por lo tanto, activemq-all.jar debe agregarse a la ruta de clase.
Enviando un mensaje a través de un cliente independiente
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageProducer;
import javax.jms.Queue;
import javax.jms.Session;
import org.apache.activemq.ActiveMQConnectionFactory;
public class JmsClientMessageSender {
public static void main(String[] args) {
ConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616"); // ActiveMQ-specific
Connection con = null;
try {
con = factory.createConnection();
Session session = con.createSession(false, Session.AUTO_ACKNOWLEDGE); // non-transacted session
Queue queue = session.createQueue("test.queue"); // only specifies queue name
MessageProducer producer = session.createProducer(queue);
Message msg = session.createTextMessage("hello queue"); // text message
producer.send(msg);
} catch (JMSException e) {
e.printStackTrace();
} finally {
if (con != null) {
try {
con.close(); // free all resources
} catch (JMSException e) { /* Ignore */ }
}
}
}
}
Encuestas para mensajes
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;
public class JmsClientMessagePoller {
public static void main(String[] args) {
ConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616"); // ActiveMQ-specific
Connection con = null;
try {
con = factory.createConnection();
Session session = con.createSession(false, Session.AUTO_ACKNOWLEDGE); // non-transacted session
Queue queue = session.createQueue("test.queue"); // only specifies queue name
MessageConsumer consumer = session.createConsumer(queue);
con.start(); // start the connection
while (true) { // run forever
Message msg = consumer.receive(); // blocking!
if (!(msg instanceof TextMessage))
throw new RuntimeException("Expected a TextMessage");
TextMessage tm = (TextMessage) msg;
System.out.println(tm.getText()); // print message content
}
} catch (JMSException e) {
e.printStackTrace();
} finally {
try {
con.close();
} catch (JMSException e) {/* Ignore */ }
}
}
}
Usando MessageListener
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;
public class JmsClientMessageListener {
public static void main(String[] args) {
ConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616"); // ActiveMQ-specific
Connection con = null;
try {
con = factory.createConnection();
Session session = con.createSession(false, Session.AUTO_ACKNOWLEDGE); // non-transacted session
Queue queue = session.createQueue("test.queue"); // only specifies queue name
MessageConsumer consumer = session.createConsumer(queue);
consumer.setMessageListener(new MessageListener() {
public void onMessage(Message msg) {
try {
if (!(msg instanceof TextMessage))
throw new RuntimeException("no text message");
TextMessage tm = (TextMessage) msg;
System.out.println(tm.getText()); // print message
} catch (JMSException e) {
System.err.println("Error reading message");
}
}
});
con.start(); // start the connection
Thread.sleep(60 * 1000); // receive messages for 60s
} catch (JMSException e1) {
e1.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
try {
con.close(); // free all resources
} catch (JMSException e) {
e.printStackTrace();
}
}
}
}
Uso de la búsqueda basada en jndi para mensajería (ejemplo no específico de la implementación)
Este método permite escribir y desplegar código no específico de la implementación en múltiples plataformas jms. El siguiente ejemplo básico se conecta al servidor jms de activemq y envía un mensaje.
import java.util.Properties;
import javax.jms.JMSException;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class JmsClientJndi {
public static void main(String[] args) {
Properties jndiProps = new Properties();
// Following two could be set via a system property for flexibility in the code.
jndiProps.setProperty(Context.INITIAL_CONTEXT_FACTORY, "org.apache.activemq.jndi.ActiveMQInitialContextFactory");
jndiProps.setProperty(Context.PROVIDER_URL, "tcp://localhost:61616");
QueueConnection conn = null;
QueueSession session = null;
QueueSender sender = null;
InitialContext jndi = null;
try {
jndi = new InitialContext(jndiProps);
QueueConnectionFactory factory = (QueueConnectionFactory) jndi.lookup("ConnectionFactory");
conn = factory.createQueueConnection();
conn.start();
session = conn.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
Queue queue = (Queue) jndi.lookup("dynamicQueues/test.queue");
sender = session.createSender(queue);
TextMessage msg = session.createTextMessage();
msg.setText("Hello worlds !!!!! ");
sender.send(msg);
} catch (NamingException e) {
e.printStackTrace();
} catch (JMSException e) {
e.printStackTrace();
} finally {
try {
if (sender != null)
sender.close();
if (session != null)
session.close();
if (conn != null)
conn.close();
} catch (JMSException e) {
e.printStackTrace();
}
}
}
}