Connexion d'une application Java à votre agent Amazon MQ

Après avoir créé un agent ActiveMQ Amazon MQ, vous pouvez y connecter votre application. Les exemples suivants montrent comment utiliser Java Message Service (JMS) pour créer une connexion à l'agent, créer une file d'attente et envoyer un message. Pour un exemple Java complet et fonctionnel, consultez Working Java Example.

Vous pouvez vous connecter à des agents ActiveMQ à l’aide de différents clients ActiveMQ. Nous vous recommandons d’utiliser le client ActiveMQ.

Prérequis

Activer les attributs du VPC

Pour vous assurer que votre agent est accessible dans votre VPC, vous devez activer les attributs enableDnsHostnames et enableDnsSupport du VPC. Pour plus d'informations, consultez Prise en charge du DNS dans votre VPC dans le Guide de l'utilisateur Amazon VPC.

Activation des connexions entrantes

1. Connectez-vous à la console Amazon MQ.

2. Dans la liste des courtiers, choisissez le nom de votre courtier (par exemple, MyBroker).

3. Sur la MyBrokerpage, dans la section Connexions, notez les adresses et les ports de l'URL de la console Web du courtier et des protocoles au niveau du fil.

4. Dans la section Details (Détails), sous Security and network (Sécurité et réseau), choisissez le nom de votre groupe de sécurité ou .

   La page Groupes de sécurité du tableau de bord EC2 est affichée.

5. Dans la liste des groupes de sécurité, choisissez votre groupe de sécurité.

6. Au bas de la page, choisissez Entrant, puis Modifier.

7. Dans la boîte de dialogue Edit inbound rules (Modifier les règles entrantes), ajoutez une règle pour chaque URL ou point de terminaison pour qu'ils soient accessibles publiquement (l'exemple suivant montre comment procéder pour une console web d'agent).

   1. Choisissez Add Rule (Ajouter une règle).

   2. Pour Type, sélectionnez Custom TCP (TCP personnalisé).

   3. Pour Port Range (Plage de ports), saisissez le port de la console web (8162).

   4. Pour Source, laissez l'option Custom (Personnalisée) sélectionnée, puis tapez l'adresse IP du système qui doit pouvoir accéder à la console web (par exemple, 192.0.2.1).

   5. Choisissez Enregistrer.

      Votre agent peut désormais accepter les connexions entrantes.

Ajout de dépendances Java

Ajoutez les packages activemq-client.jar et activemq-pool.jar au chemin de classe Java. L'exemple suivant illustre ces dépendances dans un fichier pom.xml de projet Maven.

<dependencies>
    <dependency>
        <groupId>org.apache.activemq</groupId>
        <artifactId>activemq-client</artifactId>
        <version>5.15.16</version>
    </dependency>
    <dependency>
        <groupId>org.apache.activemq</groupId>
        <artifactId>activemq-pool</artifactId>
        <version>5.15.16</version>
    </dependency>
</dependencies>

Pour plus d'informations sur activemq-client.jar, consultez Configuration initiale dans la documentation ActiveMQ Apache.

Important

Dans l'exemple de code suivant, les producteurs et les consommateurs s'exécutent dans un seul thread. Pour les systèmes de production (ou pour tester le basculement d'instance d'agent), assurez-vous que vos producteurs et vos consommateurs s'exécutent sur des hôtes ou des threads distincts.

Pour créer un producteur de messages et envoyer un message

1. Créez une fabrique de connexions groupées JMS pour le producteur de messages à l'aide du point de terminaison de votre agent, puis appelez la méthode createConnection par rapport à la fabrique.

   Note

   Pour un agent actif/en veille, Amazon MQ fournit deux URL de console web ActiveMQ, mais une seule URL est active à la fois. De même, Amazon MQ fournit deux points de terminaison pour chaque protocole de niveau filaire, mais un seul point de terminaison est actif dans chaque paire à la fois. Les suffixes -1 et -2 indiquent une paire redondante. Pour de plus amples informations, veuillez consulter Broker Architecture.

   Pour les points de terminaison de protocole de niveau filaire, vous pouvez autoriser votre application à se connecter à l'un ou l'autre des points de terminaison à l'aide du transport de basculement.

   // Create a connection factory.
   final ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(wireLevelEndpoint);
   
   // Pass the sign-in credentials.
   connectionFactory.setUserName(activeMqUsername);
   connectionFactory.setPassword(activeMqPassword);
   
   // Create a pooled connection factory.
   final PooledConnectionFactory pooledConnectionFactory = new PooledConnectionFactory();
   pooledConnectionFactory.setConnectionFactory(connectionFactory);
   pooledConnectionFactory.setMaxConnections(10);
   
   // Establish a connection for the producer.
   final Connection producerConnection = pooledConnectionFactory.createConnection();
   producerConnection.start(); 
   
   // Close all connections in the pool.
   pooledConnectionFactory.clear();

   Note

   Les producteurs de messages doivent toujours utiliser la classe PooledConnectionFactory. Pour plus d’informations, consultez Toujours utiliser le regroupement de connexions.

2. Créez une session, une file d'attente nommée MyQueue et un producteur de messages.

   // Create a session.
   final Session producerSession = producerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
   
   // Create a queue named "MyQueue".
   final Destination producerDestination = producerSession.createQueue("MyQueue");
   
   // Create a producer from the session to the queue.
   final MessageProducer producer = producerSession.createProducer(producerDestination);
   producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);

3. Créez la chaîne de message "Hello from Amazon MQ!", puis envoyez le message.

   // Create a message.
   final String text = "Hello from Amazon MQ!";
   TextMessage producerMessage = producerSession.createTextMessage(text);
   
   // Send the message.
   producer.send(producerMessage);
   System.out.println("Message sent.");

4. Nettoyez le producteur.

   producer.close();
   producerSession.close();
   producerConnection.close();

Pour créer un consommateur de messages et recevoir le message

1. Créez une fabrique de connexions JMS pour le producteur de messages à l'aide du point de terminaison de votre agent, puis appelez la méthode createConnection par rapport à la fabrique.

   // Create a connection factory.
   final ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(wireLevelEndpoint);
   
   // Pass the sign-in credentials.
   connectionFactory.setUserName(activeMqUsername);
   connectionFactory.setPassword(activeMqPassword);
   
   // Establish a connection for the consumer.
   final Connection consumerConnection = connectionFactory.createConnection();
   consumerConnection.start();

   Note

   Les consommateurs de messages ne doivent jamais utiliser la classe PooledConnectionFactory. Pour plus d’informations, consultez Toujours utiliser le regroupement de connexions.

2. Créez une session, une file d'attente nommée MyQueue et un consommateur de messages.

   // Create a session.
   final Session consumerSession = consumerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
   
   // Create a queue named "MyQueue".
   final Destination consumerDestination = consumerSession.createQueue("MyQueue");
   
   // Create a message consumer from the session to the queue.
   final MessageConsumer consumer = consumerSession.createConsumer(consumerDestination);

3. Commencez à attendre les messages et recevez le message lorsqu'il arrive.

   // Begin to wait for messages.
   final Message consumerMessage = consumer.receive(1000);
   
   // Receive the message when it arrives.
   final TextMessage consumerTextMessage = (TextMessage) consumerMessage;
   System.out.println("Message received: " + consumerTextMessage.getText());

   Note

   Contrairement aux services de AWS messagerie (tels qu'Amazon SQS), le consommateur est constamment connecté au courtier.

4. Fermez le consommateur, la session et la connexion.

   consumer.close();
   consumerSession.close();
   consumerConnection.close();