java-ee
Java Messaging Service (JMS)
Zoeken…
Invoering
De Java Message Service is een Java API waarmee toepassingen berichten kunnen maken, verzenden, ontvangen en lezen. De JMS API definieert een gemeenschappelijke set interfaces en bijbehorende semantiek waarmee programma's geschreven in de Java-programmeertaal kunnen communiceren met andere berichtenimplementaties. JMS maakt communicatie mogelijk die niet alleen losjes is gekoppeld, maar ook asynchroon en betrouwbaar.
Opmerkingen
Java Message Service (JMS) is een standaard Java-API waarmee toepassingen asynchroon berichten kunnen maken, verzenden, ontvangen en lezen.
JMS definieert de algemene set interfaces en klassen waarmee toepassingen kunnen communiceren met andere berichtenaanbieders.
JMS is vergelijkbaar met JDBC: JDBC maakt verbinding met verschillende databases (Derby, MySQL, Oracle, DB2 enz.) En JMS maakt verbinding met verschillende providers (OpenMQ, MQSeries, SonicMQ enzovoort).
JMS referentie-implementatie is Open Message Queue (OpenMQ). Het is een open source project en kan worden gebruikt in zelfstandige applicaties of kan worden ingebouwd in een applicatieserver. Het is de standaard JMS-provider die is geïntegreerd in GlassFish.
ConnectionFactory maken
Verbindingsfabrieken zijn de beheerde objecten waarmee de toepassing verbinding kan maken met de provider door een Connection maken. javax.jms.ConnectionFactory is een interface die configuratieparameters omvat die zijn gedefinieerd door een beheerder.
Voor het gebruik van ConnectionFactory moet de client JNDI-lookup uitvoeren (of een injectie gebruiken). De volgende code haalt het JNDI InitialContext object op en gebruikt het om te zoeken naar het ConnectionFactory object onder de JNDI-naam:
Context ctx = new InitialContext();
ConnectionFactory connectionFactory =
(ConnectionFactory) ctx.lookup("jms/javaee7/ConnectionFactory");
De beschikbare methoden in deze interface zijn createConnection() -methoden die een Connection object retourneren en nieuwe JMS 2.0 createContext() -methoden die een JMSContext .
Het is mogelijk om een Connection of een JMSContext te maken met de standaardgebruikersidentiteit of door een gebruikersnaam en wachtwoord op te geven:
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);
}
ActiveMQ-bibliotheek gebruiken voor berichten (specifieke implementaties van activemq jms-providers)
ActiveMQ instellen
- Download een ActiveMQ-distributie van activemq.apache.org en pak het ergens uit
- U kunt de server onmiddellijk starten, onbeveiligd op localhost, met behulp van de script bin / activemq
- Wanneer deze wordt uitgevoerd, hebt u toegang tot de console van uw lokale server op http: // localhost: 8161 / admin /
- Configureer het door conf / activemq.xml te wijzigen
- Zoals de titel de volgende voorbeelden suggereert, moeten gebruikerspecifieke implementaties van activemq jms-providers en dus activemq-all.jar aan het klassenpad worden toegevoegd.
Een bericht verzenden via een zelfstandige 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 */ }
}
}
}
}
Polling voor berichten
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 gebruiken
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();
}
}
}
}
Op jndi gebaseerde lookup gebruiken voor berichten (niet-implementatiespecifiek voorbeeld)
Met deze methode kan niet-implementatiespecifieke code worden geschreven en op meerdere JMS-platforms worden geïmplementeerd. Onderstaand basisvoorbeeld maakt verbinding met activemq jms-server en verzendt een bericht.
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();
}
}
}
}