Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation de la bibliothèque de messagerie Java Amazon SQS
Pour commencer à utiliser le service de messagerie Java (JMS) avec Amazon SQS, utilisez les exemples de code de cette section. Les sections suivantes montrent comment créer une connexion et une session JMS, et comment envoyer et recevoir un message.
L'objet client Amazon SQS encapsulé inclus dans la bibliothèque de messagerie Java Amazon SQS vérifie l'existence d'une file d'attente Amazon SQS. Si elle n'existe pas, le client la crée.
## Création d'une connexion JMS
Avant de commencer, consultez les prérequis dans[Conditions requises pour travailler avec JMS et Amazon SQS](prerequisites.md).
1. Créez une fabrique de connexions et appelez la méthode `createConnection` par rapport à cette fabrique.
```
// Create a new connection factory with all defaults (credentials and region) set automatically
SQSConnectionFactory connectionFactory = new SQSConnectionFactory(
new ProviderConfiguration(),
AmazonSQSClientBuilder.defaultClient()
);
// Create the connection.
SQSConnection connection = connectionFactory.createConnection();
```
La classe `SQSConnection` étend `javax.jms.Connection`. Avec les méthodes de connexion standard JMS, `SQSConnection` propose des méthodes supplémentaires, comme `getAmazonSQSClient` et `getWrappedAmazonSQSClient`. Ces deux méthodes vous permettent d'effectuer des opérations administratives non comprises dans la spécification JMS, telles que la création de files d'attente. Toutefois, la méthode `getWrappedAmazonSQSClient` fournit également une version encapsulée du client Amazon SQS utilisé par la connexion en cours. Le wrapper convertit toutes les exceptions en `JMSException` depuis le client, afin d'en faciliter l'utilisation par le code existant qui attend des occurrences `JMSException`.
1. Vous pouvez utiliser les objets client renvoyés par `getAmazonSQSClient` et `getWrappedAmazonSQSClient` pour effectuer des opérations administratives non comprises dans la spécification JMS (par exemple, vous pouvez créer une file d'attente Amazon SQS).
Si votre code existant attend des exceptions JMS, vous devez alors utiliser `getWrappedAmazonSQSClient` :
+ Si vous utilisez `getWrappedAmazonSQSClient`, l'objet client renvoyé transforme toutes les exceptions en exceptions JMS.
+ Si vous utilisez `getAmazonSQSClient`, les exceptions sont toutes des exceptions Amazon SQS.
## Création d'une file d'attente Amazon SQS
L'objet client encapsulé vérifie s'il existe une file d'attente Amazon SQS.
Si elle n'existe pas, le client la crée. Si la file d'attente existe, la fonction ne renvoie rien. Pour plus d'informations, consultez la section « Création de la file d'attente selon les besoins » section dans l'exemple [TextMessageSender.java](sqs-jms-code-examples.md#example-sender).
### Pour créer une file d'attente standard
```
// Get the wrapped client
AmazonSQSMessagingClientWrapper client = connection.getWrappedAmazonSQSClient();
// Create an SQS queue named MyQueue, if it doesn't already exist
if (!client.queueExists("MyQueue")) {
client.createQueue("MyQueue");
}
```
### Pour créer une file d'attente FIFO
```
// Get the wrapped client
AmazonSQSMessagingClientWrapper client = connection.getWrappedAmazonSQSClient();
// Create an Amazon SQS FIFO queue named MyQueue.fifo, if it doesn't already exist
if (!client.queueExists("MyQueue.fifo")) {
Map attributes = new HashMap();
attributes.put("FifoQueue", "true");
attributes.put("ContentBasedDeduplication", "true");
client.createQueue(new CreateQueueRequest().withQueueName("MyQueue.fifo").withAttributes(attributes));
}
```
**Note**
Le nom d'une file d'attente FIFO doit se terminer par le suffixe `.fifo`.
Pour plus d'informations sur l'attribut `ContentBasedDeduplication`, consultez [Traitement effectué en une seule fois dans Amazon SQS](FIFO-queues-exactly-once-processing.md).
## Envoi de messages de façon synchrone
1. Lorsque la connexion et la file d'attente Amazon SQS sous-jacente sont prêtes, créez une session JMS non traitée avec le mode `AUTO_ACKNOWLEDGE`.
```
// Create the nontransacted session with AUTO_ACKNOWLEDGE mode
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
```
1. Pour envoyer un SMS à la file d'attente, créez une identité de file d'attente JMS et un producteur de message.
```
// Create a queue identity and specify the queue name to the session
Queue queue = session.createQueue("MyQueue");
// Create a producer for the 'MyQueue'
MessageProducer producer = session.createProducer(queue);
```
1. Créez un SMS et envoyez-le à la file d'attente.
+ Pour envoyer un message à une file d'attente standard, vous n'avez pas besoin de définir de paramètres supplémentaires.
```
// Create the text message
TextMessage message = session.createTextMessage("Hello World!");
// Send the message
producer.send(message);
System.out.println("JMS Message " + message.getJMSMessageID());
```
+ Pour envoyer un message à une file d'attente FIFO, vous devez définir l'ID de groupe de messages. Vous pouvez aussi définir un ID de déduplication de message. Pour de plus amples informations, veuillez consulter [Termes clés de la file d'attente FIFO Amazon SQS](FIFO-key-terms.md).
```
// Create the text message
TextMessage message = session.createTextMessage("Hello World!");
// Set the message group ID
message.setStringProperty("JMSXGroupID", "Default");
// You can also set a custom message deduplication ID
// message.setStringProperty("JMS_SQS_DeduplicationId", "hello");
// Here, it's not needed because content-based deduplication is enabled for the queue
// Send the message
producer.send(message);
System.out.println("JMS Message " + message.getJMSMessageID());
System.out.println("JMS Message Sequence Number " + message.getStringProperty("JMS_SQS_SequenceNumber"));
```
## Réception des messages de façon synchrone
1. Pour recevoir les messages, créez un consommateur correspondant à la même file d'attente et appelez la méthode `start`.
Vous pouvez appeler à tout moment la méthode `start` avec cette connexion. Toutefois, le consommateur ne reçoit aucun message tant que vous ne l'appelez pas.
```
// Create a consumer for the 'MyQueue'
MessageConsumer consumer = session.createConsumer(queue);
// Start receiving incoming messages
connection.start();
```
1. Appelez la méthode `receive` au niveau du consommateur avec un délai d'attente d'une seconde, puis imprimez le contenu du message reçu.
+ Après avoir reçu un message d'une file d'attente standard, vous pouvez accéder à son contenu.
```
// Receive a message from 'MyQueue' and wait up to 1 second
Message receivedMessage = consumer.receive(1000);
// Cast the received message as TextMessage and display the text
if (receivedMessage != null) {
System.out.println("Received: " + ((TextMessage) receivedMessage).getText());
}
```
+ Après avoir reçu un message d'une file d'attente FIFO, vous pouvez accéder à son contenu et à d'autres attributs de message spécifiques à FIFO, comme l'ID de groupe de messages, l'ID de déduplication du message et le numéro de séquence. Pour de plus amples informations, veuillez consulter [Termes clés de la file d'attente FIFO Amazon SQS](FIFO-key-terms.md).
```
// Receive a message from 'MyQueue' and wait up to 1 second
Message receivedMessage = consumer.receive(1000);
// Cast the received message as TextMessage and display the text
if (receivedMessage != null) {
System.out.println("Received: " + ((TextMessage) receivedMessage).getText());
System.out.println("Group id: " + receivedMessage.getStringProperty("JMSXGroupID"));
System.out.println("Message deduplication id: " + receivedMessage.getStringProperty("JMS_SQS_DeduplicationId"));
System.out.println("Message sequence number: " + receivedMessage.getStringProperty("JMS_SQS_SequenceNumber"));
}
```
1. Fermez la connexion et la session.
```
// Close the connection (and the session).
connection.close();
```
La sortie ressemble à ce qui suit:
```
JMS Message ID:8example-588b-44e5-bbcf-d816example2
Received: Hello World!
```
**Note**
Vous pouvez utiliser le framework Spring pour initialiser ces objets.
Pour plus d'informations, consultez `SpringExampleConfiguration.xml`, `SpringExample.java` et les autres classes d'assistance sous `ExampleConfiguration.java` et `ExampleCommon.java` dans la section [Exemples Java fonctionnels pour l'utilisation de JMS avec les files d'attente standard Amazon SQS](sqs-jms-code-examples.md).
Pour obtenir des exemples complets d'envoi et de réception d'objets, consultez les sections [TextMessageSender.java](sqs-jms-code-examples.md#example-sender) et [SyncMessageReceiver.java](sqs-jms-code-examples.md#example-synchronous-message-receiver).
## Réception des messages de façon asynchrone
Dans l'exemple de la section [Utilisation de la bibliothèque de messagerie Java Amazon SQS](#getting-started), un message est envoyé à `MyQueue` et reçu de façon synchrone.
L'exemple suivant montre comment recevoir les messages de façon asynchrone via un écouteur.
1. Implémentez l'interface `MessageListener`.
```
class MyListener implements MessageListener {
@Override
public void onMessage(Message message) {
try {
// Cast the received message as TextMessage and print the text to screen.
System.out.println("Received: " + ((TextMessage) message).getText());
} catch (JMSException e) {
e.printStackTrace();
}
}
}
```
La méthode `onMessage` de l'interface `MessageListener` est appelée lorsque vous recevez un message. Dans cette implémentation d'écouteur, le texte stocké dans le message est imprimé.
1. Au lieu d'appeler explicitement la méthode `receive` au niveau du consommateur, sélectionnez une instance de l'implémentation `MyListener` pour l'écouteur de messages du consommateur. Le thread principal attend pendant une seconde.
```
// Create a consumer for the 'MyQueue'.
MessageConsumer consumer = session.createConsumer(queue);
// Instantiate and set the message listener for the consumer.
consumer.setMessageListener(new MyListener());
// Start receiving incoming messages.
connection.start();
// Wait for 1 second. The listener onMessage() method is invoked when a message is received.
Thread.sleep(1000);
```
Les autres étapes sont identiques à celles de l'exemple [Utilisation de la bibliothèque de messagerie Java Amazon SQS](#getting-started). Pour obtenir un exemple complet de consommateur asynchrone, consultez `AsyncMessageReceiver.java` dans [Exemples Java fonctionnels pour l'utilisation de JMS avec les files d'attente standard Amazon SQS](sqs-jms-code-examples.md).
La sortie correspondant à cet exemple est similaire à l'exemple suivant :
```
JMS Message ID:8example-588b-44e5-bbcf-d816example2
Received: Hello World!
```
## Utilisation du mode de reconnaissance du client
L'exemple de la section [Utilisation de la bibliothèque de messagerie Java Amazon SQS](#getting-started) utilise le mode `AUTO_ACKNOWLEDGE` où chaque message reçu est accepté automatiquement (et, par conséquent, supprimé de la file d'attente Amazon SQS sous-jacente).
1. Pour confirmer explicitement les messages après leur traitement, vous devez créer la session en mode `CLIENT_ACKNOWLEDGE`.
```
// Create the non-transacted session with CLIENT_ACKNOWLEDGE mode.
Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
```
1. Lorsque le message est reçu, affichez-le, puis reconnaissez-le explicitement.
```
// Cast the received message as TextMessage and print the text to screen. Also acknowledge the message.
if (receivedMessage != null) {
System.out.println("Received: " + ((TextMessage) receivedMessage).getText());
receivedMessage.acknowledge();
System.out.println("Acknowledged: " + message.getJMSMessageID());
}
```
**Note**
Avec ce mode, lorsqu'un message est reconnu, tous les messages reçus avant celui-ci sont implicitement reconnus aussi. Par exemple, si 10 messages sont reçus et que le 10e message est reconnu (dans l'ordre dans lequel les messages sont reçus), les 9 messages précédents sont également reconnus.
Les autres étapes sont identiques à celles de l'exemple [Utilisation de la bibliothèque de messagerie Java Amazon SQS](#getting-started). Pour obtenir un exemple complet de consommateur synchrone avec le mode de reconnaissance du client, consultez `SyncMessageReceiverClientAcknowledge.java` dans [Exemples Java fonctionnels pour l'utilisation de JMS avec les files d'attente standard Amazon SQS](sqs-jms-code-examples.md).
La sortie correspondant à cet exemple est similaire à l'exemple suivant :
```
JMS Message ID:4example-aa0e-403f-b6df-5e02example5
Received: Hello World!
Acknowledged: ID:4example-aa0e-403f-b6df-5e02example5
```
## Utilisation du mode de reconnaissance indépendamment de l'ordre de réception
Lorsque vous utilisez le mode `CLIENT_ACKNOWLEDGE`, tous les messages reçus avant un message explicitement reconnu sont reconnus automatiquement. Pour de plus amples informations, veuillez consulter [Utilisation du mode de reconnaissance du client](#using-client-acknowledge-mode).
La bibliothèque de messagerie Java Amazon SQS propose un autre mode de reconnaissance. Lorsque vous utilisez le mode `UNORDERED_ACKNOWLEDGE`, tous les messages reçus doivent être individuellement et explicitement reconnus par le client, quel que soit leur ordre de réception. Pour ce faire, créez une session avec le mode `UNORDERED_ACKNOWLEDGE`.
```
// Create the non-transacted session with UNORDERED_ACKNOWLEDGE mode.
Session session = connection.createSession(false, SQSSession.UNORDERED_ACKNOWLEDGE);
```
Les étapes suivantes sont identiques à celles de l'exemple [Utilisation du mode de reconnaissance du client](#using-client-acknowledge-mode). Pour obtenir un exemple complet de consommateur synchrone avec le mode `UNORDERED_ACKNOWLEDGE`, consultez `SyncMessageReceiverUnorderedAcknowledge.java`.
Dans cet exemple, la sortie est similaire à l'exemple suivant :
```
JMS Message ID:dexample-73ad-4adb-bc6c-4357example7
Received: Hello World!
Acknowledged: ID:dexample-73ad-4adb-bc6c-4357example7
```