java-ee
Java Messaging Service (JMS)
Recherche…
Introduction
Java Message Service est une API Java qui permet aux applications de créer, envoyer, recevoir et lire des messages. L'API JMS définit un ensemble commun d'interfaces et de sémantiques associées qui permettent aux programmes écrits dans le langage de programmation Java de communiquer avec d'autres implémentations de messagerie. JMS permet une communication qui n'est pas seulement couplée de manière souple, mais également asynchrone et fiable.
Remarques
Java Message Service (JMS) est une API Java standard qui permet aux applications de créer, envoyer, recevoir et lire des messages de manière asynchrone.
JMS définit un ensemble général d'interfaces et de classes permettant aux applications d'interagir avec d'autres fournisseurs de messages.
JMS est similaire à JDBC: JDBC se connecte à différentes bases de données (Derby, MySQL, Oracle, DB2, etc.) et JMS se connecte à différents fournisseurs (OpenMQ, MQSeries, SonicMQ, etc.).
L'implémentation de référence JMS est Open Message Queue (OpenMQ). C'est un projet open source et peut être utilisé dans des applications autonomes ou peut être intégré dans un serveur d'applications. C'est le fournisseur JMS par défaut intégré à GlassFish.
Création de ConnectionFactory
Les fabriques de connexions sont les objets gérés qui permettent à l'application de se connecter au fournisseur en créant un objet Connection . javax.jms.ConnectionFactory est une interface qui encapsule les paramètres de configuration définis par un administrateur.
Pour utiliser ConnectionFactory client doit exécuter la recherche JNDI (ou utiliser l'injection). Le code suivant obtient l'objet InitialContext JNDI et l'utilise pour rechercher l'objet ConnectionFactory sous le nom JNDI:
Context ctx = new InitialContext();
ConnectionFactory connectionFactory =
(ConnectionFactory) ctx.lookup("jms/javaee7/ConnectionFactory");
Les méthodes disponibles dans cette interface sont les méthodes createConnection() qui renvoient un objet Connection et les nouvelles méthodes JMS 2.0 createContext() qui renvoient un JMSContext .
Il est possible de créer une Connection ou un JMSContext avec l'identité d'utilisateur par défaut ou en spécifiant un nom d'utilisateur et un mot de passe:
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);
}
Utilisation de la bibliothèque ActiveMQ pour la messagerie (implémentations spécifiques au fournisseur jms de activemq)
Configurer ActiveMQ
- Téléchargez une distribution ActiveMQ à partir de activemq.apache.org et décompressez-la quelque part
- Vous pouvez démarrer le serveur immédiatement, en exécutant non sécurisé sur localhost, en utilisant le script bin / activemq
- Lorsqu'il est en cours d'exécution, vous pouvez accéder à la console de votre serveur local sur http: // localhost: 8161 / admin /
- Configurez-le en modifiant conf / activemq.xml
- Comme le titre l'indique, les exemples suivants implémentent des implémentations spécifiques à l'utilisateur activemq jms et donc activemq-all.jar doivent être ajoutés au classpath.
Envoi d'un message via un client autonome
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 */ }
}
}
}
}
Polling for messages
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 */ }
}
}
}
Utiliser 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();
}
}
}
}
Utilisation de la recherche basée sur jndi pour la messagerie (exemple non spécifique à l'implémentation)
Cette méthode permet d'écrire et de déployer du code non spécifique à l'implémentation sur plusieurs plates-formes jms. L'exemple de base ci-dessous se connecte au serveur activemq jms et envoie un message.
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();
}
}
}
}