Java ActiveMQ : découvrir les secrets du middleware de messagerie hautes performances

Java ActiveMQ, en tant que middleware de messagerie haute performance, est largement utilisé dans les systèmes au niveau de l'entreprise. Sa stabilité et sa fiabilité sont très appréciées, mais son fonctionnement interne est au centre des préoccupations de nombreux développeurs. Dans cet article, l'éditeur PHP Apple vous dévoilera les secrets de Java ActiveMQ et vous donnera une compréhension approfondie du principe de fonctionnement et des techniques d'optimisation des performances de ce middleware de messages.

Java ActiveMQ est un middleware de messagerie open source, conçu pour fournir aux applications un mécanisme de messagerie fiable, évolutif et performant. Cet article approfondira les secrets de hautes performances de Java ActiveMQ sous les aspects suivants :

1. Noyau léger et communication asynchrone

L'idée de base de la conception de Java ActiveMQ est une communication légère et asynchrone. Il adopte un modèle de messagerie asynchrone, c'est-à-dire qu'une fois que le producteur a envoyé le message au middleware de messages, il n'a pas besoin d'attendre que le consommateur le reçoive immédiatement, mais continue d'effectuer d'autres tâches. Cette méthode de communication asynchrone réduit considérablement la surcharge du système et améliore le débit.

Exemple de code :

import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;

public class Producer {
public static void main(String[] args) throws Exception {
// 创建连接工厂
ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
// 创建连接
Connection connection = connectionFactory.createConnection();
connection.start();
// 创建会话
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
// 创建队列
Destination destination = session.createQueue("test.queue");
// 创建消息生产者
MessageProducer producer = session.createProducer(destination);
// 创建文本消息
TextMessage message = session.createTextMessage("Hello, ActiveMQ!");
// 发送消息
producer.send(message);
// 关闭资源
producer.close();
session.close();
connection.close();
}
}

Dans l'exemple ci-dessus, le producteur envoie le message à la file d'attente "test.queue" de manière asynchrone et peut continuer à effectuer d'autres tâches sans attendre que le consommateur le reçoive immédiatement, ce qui améliore le débit du système.

2. Gestion efficace de la mémoire

Java ActiveMQ utilise intelligemment la technologie de gestion de la mémoire pour assurer une transmission haute performance des messages. Il utilise une mémoire non tas pour stocker les messages, évitant ainsi un nettoyage fréquent de la mémoire tas par le garbage collector, réduisant ainsi la surcharge du système et améliorant l'efficacité du traitement des messages.

Exemple de code :

import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;

public class Consumer {
public static void main(String[] args) throws Exception {
// 创建连接工厂
ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
// 创建连接
Connection connection = connectionFactory.createConnection();
connection.start();
// 创建会话
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
// 创建队列
Destination destination = session.createQueue("test.queue");
// 创建消息消费者
MessageConsumer consumer = session.createConsumer(destination);
// 接收消息
Message message = consumer.receive();
if (message instanceof TextMessage) {
TextMessage textMessage = (TextMessage) message;
System.out.println("Received message: " + textMessage.getText());
}
// 关闭资源
consumer.close();
session.close();
connection.close();
}
}

Dans l'exemple ci-dessus, le consommateur reçoit les messages de manière asynchrone de la file d'attente "test.queue" et imprime le contenu du message. Étant donné que Java ActiveMQ utilise de la mémoire non tas pour stocker les messages, les consommateurs n'ont pas besoin d'attendre que le ramasse-miettes nettoie la mémoire tas, améliorant ainsi l'efficacité du traitement des messages.

3. Mécanisme de transmission de messages fiable

Java ActiveMQ fournit une série de mécanismes de transmission de messages fiables pour garantir que les messages ne sont pas perdus ou endommagés pendant la transmission. Il prend en charge les messages persistants, stocke les messages sur des supports de stockage fiables et garantit l'intégrité des messages même en cas de panne du système ou de panne de courant.

Exemple de code :

import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;

public class PersistentProducer {
public static void main(String[] args) throws Exception {
// 创建连接工厂
ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
// 设置持久化连接
connectionFactory.setUseAsyncSend(true);
// 创建连接
Connection connection = connectionFactory.createConnection();
connection.start();
// 创建会话
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
// 创建队列
Destination destination = session.createQueue("test.queue");
// 创建消息生产者
MessageProducer producer = session.createProducer(destination);
// 设置持久化消息
producer.setDeliveryMode(DeliveryMode.PERSISTENT);
// 创建文本消息
TextMessage message = session.createTextMessage("Hello, ActiveMQ!");
// 发送消息
producer.send(message);
// 关闭资源
producer.close();
session.close();
connection.close();
}
}

Dans l'exemple ci-dessus, le producteur s'assure que le message n'est pas perdu pendant le processus d'envoi en définissant le message en mode persistance. Même en cas de panne du système ou de panne de courant, le consommateur peut toujours recevoir et traiter le message de la file d'attente.

4. Évolutivité et haute disponibilité

Java ActiveMQ prend en charge le déploiement de cluster et peut être facilement étendu à plusieurs serveurs pour répondre aux exigences croissantes en matière de débit de messages. En même temps, il fournit des mécanismes de basculement et de équilibrage de charge pour garantir qu'en cas de panne de l'un des serveurs, d'autres serveurs peuvent prendre en charge son travail, garantissant ainsi la haute disponibilité du système.

Exemple de code :

<clusteredBrokers>
<broker address="tcp://localhost:61616" name="BrokerA"/>
<broker address="tcp://localhost:61617" name="BrokerB"/>
</clusteredBrokers>

Dans l'exemple ci-dessus, deux serveurs de cluster ActiveMQ sont configurés pour l'équilibrage de charge et le basculement. Lorsqu'un serveur tombe en panne, l'autre serveur peut reprendre son travail, garantissant ainsi la disponibilité continue du système.

5.Des outils de gestion riches

Java ActiveMQ fournit une multitude d'outils de gestion , simplifiant la gestion du système et la surveillance . Les administrateurs peuvent facilement afficher l'état de fonctionnement du système, le débit des messages, la taille de la file d'attente et d'autres informations via la console ActiveMQ WEB, JConsole ou d'autres outils tiers, et gérer et entretenir le système.

Exemple de code :

$ jconsole

Dans l'exemple ci-dessus, utilisez JConsole pour vous connecter au serveur ActiveMQ afin d'afficher l'état d'exécution du système, le débit des messages, la taille de la file d'attente et d'autres informations.

Résumé

Java ActiveMQ est un middleware de messagerie hautes performances, fiable et évolutif qui est largement utilisé dans les applications d'entreprise, les systèmes de trading financier, l'Internet des objets et d'autres domaines. Cet article explore en profondeur les secrets de haute performance de Java ActiveMQ, notamment la communication légère et asynchrone, la gestion efficace de la mémoire, le mécanisme de transmission de messages fiable, l'évolutivité et la haute disponibilité, ainsi que les outils de gestion riches. Java ActiveMQ est un middleware de messagerie fiable qui renforce la fiabilité des entreprises

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!