java-ee
Java Messaging Service (JMS)
Suche…
Einführung
Der Java Message Service ist eine Java-API, mit der Anwendungen Nachrichten erstellen, senden, empfangen und lesen können. Die JMS-API definiert einen gemeinsamen Satz von Schnittstellen und die zugehörige Semantik, mit der Programme, die in der Java-Programmiersprache geschrieben sind, mit anderen Messaging-Implementierungen kommunizieren können. JMS ermöglicht eine Kommunikation, die nicht nur lose gekoppelt, sondern auch asynchron und zuverlässig ist.
Bemerkungen
Java Message Service (JMS) ist eine Standard-Java-API, mit der Anwendungen Nachrichten asynchron erstellen, senden, empfangen und lesen können.
JMS definiert allgemeine Schnittstellen und Klassen, mit denen Anwendungen mit anderen Nachrichtenanbietern interagieren können.
JMS ähnelt JDBC: JDBC stellt eine Verbindung zu verschiedenen Datenbanken (Derby, MySQL, Oracle, DB2 usw.) her und JMS stellt eine Verbindung zu verschiedenen Anbietern (OpenMQ, MQSeries, SonicMQ usw.) her.
Die Implementierung der JMS-Referenz ist Open Message Queue (OpenMQ). Es ist ein Open Source-Projekt und kann in eigenständigen Anwendungen verwendet oder in Anwendungsserver integriert werden. Es ist der Standard-JMS-Anbieter, der in GlassFish integriert ist.
ConnectionFactory erstellen
Verbindungsfactorys sind die verwalteten Objekte, mit denen die Anwendung eine Verbindung zum Provider herstellen kann, indem ein Connection wird. javax.jms.ConnectionFactory ist eine Schnittstelle, die von einem Administrator definierte Konfigurationsparameter enthält.
Für die Verwendung von ConnectionFactory muss der Client eine JNDI-Suche ausführen (oder Injektion verwenden). Der folgende Code ruft das JNDI- InitialContext Objekt ab und verwendet es, um das ConnectionFactory Objekt unter dem JNDI-Namen zu suchen:
Context ctx = new InitialContext();
ConnectionFactory connectionFactory =
(ConnectionFactory) ctx.lookup("jms/javaee7/ConnectionFactory");
Die in dieser Schnittstelle verfügbaren Methoden sind createConnection() -Methoden, die ein Connection Objekt zurückgeben, und neue JMS 2.0- createContext() -Methoden, die einen JMSContext .
Es ist möglich, eine Connection oder einen JMSContext zu erstellen, entweder mit der Standardbenutzeridentität oder durch Angabe eines Benutzernamens und Kennworts:
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);
}
Verwenden der ActiveMQ-Bibliothek für das Messaging (für spezifische Implementierungen von activemq jms-Providern)
Richten Sie ActiveMQ ein
- Laden Sie eine ActiveMQ-Distribution von activemq.apache.org herunter und entpacken Sie sie irgendwo
- Sie können den Server sofort starten und mit dem Skript bin / activemq unsicher auf localhost ausführen
- Wenn es ausgeführt wird, können Sie unter http: // localhost: 8161 / admin / auf die Konsole Ihres lokalen Servers zugreifen.
- Konfigurieren Sie es durch Ändern von conf / activemq.xml
- Da der Titel folgende Beispiele vorschlägt, müssen benutzeraktivierte jms-Provider-spezifische Implementierungen und daher activemq-all.jar zum Klassenpfad hinzugefügt werden.
Senden einer Nachricht über einen Standalone-Client
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 */ }
}
}
}
}
Nachrichten abfragen
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 */ }
}
}
}
MessageListener verwenden
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();
}
}
}
}
Verwenden der jndi-basierten Suche für Messaging (nicht implementierungsspezifisches Beispiel)
Mit dieser Methode kann nicht implementierungsspezifischer Code auf mehreren JMS-Plattformen geschrieben und bereitgestellt werden. Das folgende grundlegende Beispiel stellt eine Verbindung zum activemq jms-Server her und sendet eine Nachricht.
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();
}
}
}
}