The technical principles of the JAKARTA Messaging API framework in the Java Class Library IES)
Jakarta Messaging is a Java API framework for building a distributed application. It provides a reliable, asynchronous, scalable message transmission model.This article will explain the technical principles of the Jakarta Messaging API framework, and how to use the Java code example to achieve it.
1. Message transmission model:
Jakarta Messaging API uses a message -based asynchronous communication model.In this model, the application communicates by sending and receiving messages instead of directly calling the method.The message can contain any type of data, and can be transmitted by different transmission protocols (such as JMS, AMQP, STOMP, etc.).
2. Component role:
The main components in the Jakarta Messaging API include message producers, message consumers and message agents.Message producers are responsible for creating and sending messages, and messages are responsible for receiving and processing messages. The message agent is the middleware between message producers and message consumers, which is responsible for routing, filtering and transmission of news.
3. Connect the factory:
When using the Jakarta Messaging API, you need to create a factories first.Connecting the factory to create a connection with message agents, and configure related attributes connected, such as transmission protocols, authentication information, etc.
import javax.jms.ConnectionFactory;
import org.apache.activemq.artemis.jms.client.ActiveMQConnectionFactory;
ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url);
4. Destination:
The message is passed through the target object in the Jakarta Messaging API.The goal can be queue or topic.The queue is used to transmit the point-to-point message, and each message can only be accepted by one consumer.The theme is used to publish a message of the PUBLISH/Subscribe mode, and each message can be accepted by multiple consumers.
import javax.jms.Destination;
import javax.jms.Session;
import org.apache.activemq.artemis.jms.client.ActiveMQQueue;
Destination destination = new ActiveMQQueue("myQueue");
5. Producer/Consumer:
For message producers, messages can be sent by creating session objects, news objects, and message producers.
import javax.jms.MessageProducer;
import javax.jms.TextMessage;
import javax.jms.Session;
import javax.jms.DeliveryMode;
import javax.jms.Message;
import javax.jms.MessageProducer;
import javax.jms.TextMessage;
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageProducer producer = session.createProducer(destination);
TextMessage message = session.createTextMessage("Hello, Jakarta Messaging!");
producer.send(message);
For messaging consumers, they need to create a session object and message consumer object, and register a message monitor to process the received messages.
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.TextMessage;
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageConsumer consumer = session.createConsumer(destination);
consumer.setMessageListener(new MessageListener() {
@Override
public void onMessage(Message message) {
if (message instanceof TextMessage) {
TextMessage textMessage = (TextMessage)message;
try {
System.out.println("Received message: " + textMessage.getText());
} catch (Exception e) {
e.printStackTrace();
}
}
}
});
6. Asynchronous communication:
Jakarta Messaging API supports asynchronous message transmission, that is, the sending and receiving of the message is non -blocking.When the message is sent or received by the new message, it will be notified by callback function or listener.
7. Affairs support:
Jakarta Messaging API also provides transaction support to ensure the reliable transmission of messages.When using the transaction mode, transactions need to be enabled on the session object, and submit or roll back the transaction when sending/receiving messages.
Session session = connection.createSession(true, Session.SESSION_TRANSACTED);
// Producers send messages
session.commit();
// or roll back transactions
session.rollback();
In summary, the Jakarta Messaging API framework provides a reliable, asynchronous, scaling of message transmission model for Java applications. By creating a factories, goals, session, and corresponding producers and consumer objects, the message can be achieved.Send and receive.In addition, it also supports asynchronous communication and transaction processing, providing more flexible and reliable distributed application development methods.
