java-ee
Java Messaging Service (JMS)
Sök…
Introduktion
Java Message Service är ett Java API som gör det möjligt för applikationer att skapa, skicka, ta emot och läsa meddelanden. JMS API definierar en gemensam uppsättning gränssnitt och tillhörande semantik som tillåter program skrivna på Java-programmeringsspråket att kommunicera med andra meddelandenimplementeringar. JMS möjliggör kommunikation som inte bara är löst kopplad utan också asynkron och pålitlig.
Anmärkningar
Java Message Service (JMS) är ett standard Java API som gör att applikationer kan skapa, skicka, ta emot och läsa meddelanden asynkront.
JMS definierar den allmänna uppsättningen gränssnitt och klasser som tillåter applikationer att interagera med andra meddelandeleverantörer.
JMS liknar JDBC: JDBC ansluter till olika databaser (Derby, MySQL, Oracle, DB2 etc.) och JMS ansluter till olika leverantörer (OpenMQ, MQSeries, SonicMQ och så vidare).
JMS-referensimplementering är Open Message Queue (OpenMQ). Det är öppen källkodsprojekt och kan användas i fristående applikationer eller kan byggas i applikationsserver. Det är standardleverantören för JMS som är integrerad i GlassFish.
Skapa ConnectionFactory
Anslutningsfabriker är de hanterade objekten som gör att applikationen kan ansluta till leverantören genom att skapa Connection . javax.jms.ConnectionFactory är ett gränssnitt som kapslar konfigurationsparametrar definierade av en administratör.
För att använda ConnectionFactory måste klienten utföra JNDI-uppslag (eller använda injektion). Följande kod får JNDI InitialContext objekt och använder det för att leta efter ConnectionFactory objekt under JNDI-namn:
Context ctx = new InitialContext();
ConnectionFactory connectionFactory =
(ConnectionFactory) ctx.lookup("jms/javaee7/ConnectionFactory");
Metoderna som finns tillgängliga i detta gränssnitt är createConnection() som returnerar ett Connection och nya JMS 2.0 createContext() -metoder som returnerar en JMSContext .
Det är möjligt att skapa en Connection eller en JMSContext antingen med standardanvändaridentiteten eller genom att ange ett användarnamn och lösenord:
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);
}
Använda ActiveMQ-bibliotek för meddelanden (Activemq jms-leverantörsspecifika implementationer)
Ställ in ActiveMQ
- Ladda ner en ActiveMQ-distribution från activemq.apache.org och packa upp den någonstans
- Du kan starta servern omedelbart, utan säkerhet på localhost med skriptfacket / activemq
- När den körs kan du komma åt din lokala serverns konsol på http: // localhost: 8161 / admin /
- Konfigurera det genom att ändra conf / activemq.xml
- Som titeln föreslår följande exempel måste användaraktivemq jms-leverantörsspecifika implementationer och därmed activemq-all.jar läggas till klassvägen.
Skickar ett meddelande via fristående klient
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 */ }
}
}
}
}
Fråga efter meddelanden
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 */ }
}
}
}
Använda 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();
}
}
}
}
Använda jndi-baserad uppslagning för meddelanden (Ej implementeringsspecifikt exempel)
Denna metod tillåter att icke-implementeringsspecifik kod kan skrivas och distribueras över flera jms-plattformar. Nedanstående grundexempel ansluter till activemq jms-server och skickar ett meddelande.
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();
}
}
}
}