JMS est la norme de l'API de communication de message de la plate-forme Java, prenant en charge les modèles point à point et Publish / souscript, et ActiveMQ est le Message Middleware qu'il implémente; 1. Démarrez le service ActiveMQ et écoutez le port par défaut; 2. Ajouter une dépendance activeMQ-Client dans le projet Maven; 3. Créer des producteurs pour envoyer des messages dans des files d'attente via ConnectionFactory; 4. Créer des consommateurs pour recevoir des messages de manière asynchrone via MessageListener; Cette combinaison réalise le découplage du système, la coupe de pointe du trafic, la livraison fiable et le traitement asynchrone, et convient aux applications traditionnelles d'entreprise Java. Bien qu'il existe des alternatives plus modernes, ils ont toujours de l'apprentissage et utilisent de la valeur.

Dans les systèmes distribués modernes, la communication asynchrone est un moyen clé pour améliorer le découplage du système, l'évolutivité et la réactivité. Java Message Service (JMS) combiné avec ActiveMQ est une combinaison classique de messagerie asynchrone, en particulier adaptée aux applications Java au niveau de l'entreprise.

Que sont JMS et ActiveMQ?

JMS est une norme API pour envoyer et recevoir des messages sur la plate-forme Java, en prenant en charge deux modèles de messages:

• Point à point (file d'attente) : le message est envoyé à la file d'attente et un consommateur traite un message.
• Publier / abonner (sujet) : le message est publié sur un sujet et plusieurs abonnés peuvent recevoir le même message.

ActiveMQ est un middleware de messagerie open source basé sur des spécifications JMS (courtier de messages) développé par Apache. Il prend en charge plusieurs protocoles (tels que OpenWire, Stomp, MQTT) et peut se dérouler sur les plates-formes, ce qui le rend idéal pour construire des systèmes asynchrones couplés de manière lache.

Comment implémenter une communication asynchrone à l'aide de JMS ActiveMQ?

Pour utiliser JMS pour communiquer de manière asynchrone avec ActiveMQ, les étapes suivantes sont généralement incluses:

1. Démarrer le service ActiveMQ

Tout d'abord, téléchargez et démarrez le service à partir du site officiel d'Apache ActiveMQ :

 bin / activemq start

Par défaut, ActiveMQ écoute tcp://localhost:61616 et fournit une console Web http://localhost:8161 .

2. Ajouter des dépendances Maven

Dans votre projet Java (comme l'utilisation de Maven), ajoutez les dépendances suivantes:

 <dépendance>
    <groupId> org.apache.activemq </rombandid>
    <ArtefactId> activeMQ-Client </Retifactid>
    <version> 5.17.3 </ version>
</Dependance>

3. Créer un producteur de message (producteur)

Le producteur envoie des messages à une file d'attente ou à un sujet:

 importer javax.jms. *;
import org.apache.activemq.ACTIVEMQConnectionFactory;

classe publique MessageProducer {
    String final statique privé Broker_url = "tcp: // localhost: 61616";
    String statique final statique queue_name = "Exemple.Queue";

    public static void main (String [] args) lève jmsexception {
        ConnectionFactory Factory = new activeMQConnectionFactory (Broker_Url);
        Connexion connexion = factory.CreateConnection ();
        connection.start ();

        Session Session = Connection.CreateSession (false, session.auto_acknowledge);
        Destination destination = session.createqueue (queue_name);
        MessageProducer producteur = session.CreateProducer (destination);

        TextMessage message = session.CreateTextMessage ("Hello From JMS Producer!");
        producteur.send (message);
        System.out.println ("Message envoyé:" message.GetText ());

        producteur.close ();
        session.close ();
        connection.close ();
    }
}

4. Créer un consommateur de message

Les consommateurs re?oivent des messages de manière asynchrone, en utilisant généralement MessageListener pour implémenter:

 importer javax.jms. *;
import org.apache.activemq.ACTIVEMQConnectionFactory;

classe publique MessageConsumer {
    public static void main (String [] args) lève jmsexception {
        ConnectionFactory Factory = new activeMQConnectionFactory (Broker_Url);
        Connexion connexion = factory.CreateConnection ();
        connection.start ();

        Session Session = Connection.CreateSession (false, session.auto_acknowledge);
        Destination destination = session.createqueue (queue_name);
        MessageConsumer Consumer = Session.CreateConsumer (destination);

        Consumer.SetMessageListener (new MessageListener () {
            @Outrepasser
            public void OnMessage (message de message) {
                if (instance de message de textMessage) {
                    essayer {
                        System.out.println ("Re?u:" ((TextMessage) Message) .GetText ());
                    } catch (jmsexception e) {
                        e.printStackTrace ();
                    }
                }
            }
        });

        // Gardez le programme en cours d'exécution et attendez des messages (peut être de manière plus élégante dans les applications réelles)
        System.out.println ("En attente de messages ...");
    }
}

Remarque: Une fois que le consommateur a utilisé setMessageListener , le traitement des messages est asynchrone et ne bloquera pas le thread principal.

Scénarios d'utilisation et avantages

• Découplage du système : les producteurs n'ont pas besoin de conna?tre l'existence des consommateurs.
• Coupe de pics de trafic : Dans les scénarios de concurrence élevés, la file d'attente de messages peut tamponner les demandes.
• Livraison fiable : ActiveMQ prend en charge les messages persistants pour s'assurer que les messages ne sont pas perdus.
• Traitement asynchrone : les opérations longues telles que l'envoi d'e-mails et le traitement des journaux peuvent être placées dans la file d'attente pour l'exécution asynchrone.

Choses à noter

• Gestion de la connexion : il est recommandé d'utiliser des pools de connexion (tels que PooledConnectionFactory ) dans les environnements de production.
• Mode de transaction et de confirmation : sélectionnez Session.SESSION_TRANSACTED ou confirmez manuellement en fonction des exigences de fiabilité.
• Gestion des exceptions : lorsqu'un réseau est interrompu ou un crash des consommateurs, les mécanismes de reconnexion et de réessayer doivent être raisonnablement configurés.
• Abonnement persistant : pour le modèle de sujet, si le consommateur est hors ligne, il peut recevoir des messages manqués grace à un abonnement persistant.

Fondamentalement, c'est tout. JMS ActiveMQ n'est pas la dernière technologie (désormais des options plus modernes telles que Kafka, RabbitMQ, etc.), mais elle est toujours largement utilisée dans les projets Java EE ou Spring traditionnels, en particulier adaptés aux scénarios qui nécessitent un support JMS standard. Le ma?triser est très utile pour comprendre les principes du middleware du message.

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!