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 JMS avec Amazon SQS
<a name="sqs-java-message-service-jms-client"></a>

La bibliothèque de messagerie Java Amazon SQS est une interface de service de message Java (JMS) pour Amazon SQS qui vous permet de tirer parti d'Amazon SQS dans les applications qui utilisent déjà JMS. L'interface vous permet d'utiliser Amazon SQS en tant que fournisseur JMS avec peu de changements de code. Avec le kit AWS SDK pour Java, la bibliothèque de messagerie Java Amazon SQS vous permet de créer des connexions et des sessions JMS, ainsi que des producteurs et des consommateurs qui envoient et reçoivent des messages de files d'attente Amazon SQS.

La bibliothèque prend en charge l'envoi et la réception de messages vers une file d'attente (le point-to-point modèle JMS) conformément à la spécification [JMS 1.1](http://docs.oracle.com/javaee/6/api/javax/jms/package-summary.html). Elle prend également en charge l'envoi de messages de texte, d'octets ou d'objets de façon synchrone aux files d'attente Amazon SQS. ainsi que la réception d'objets de façon synchrone ou asynchrone.

[Pour plus d'informations sur les fonctionnalités de la bibliothèque de messagerie Java Amazon SQS qui prennent en charge la spécification JMS 1.1, consultez [Implémentations de JMS 1.1 prises en charge par Amazon SQS](supported-implementations.md) et Amazon SQS. FAQs](https://aws.amazon.com/sqs/faqs/)

# Conditions requises pour travailler avec JMS et Amazon SQS
<a name="prerequisites"></a>

Avant de commencer, les prérequis suivants doivent être remplis :
+ **SDK pour Java**

  Il existe deux façons d'inclure le kit SDK pour Java dans votre projet :
  + Téléchargez et installez le kit SDK pour Java.
  + Utilisez Maven pour obtenir la bibliothèque de messagerie Java Amazon SQS.
**Note**  
Le kit SDK pour Java est fourni en tant que dépendance.  
Le [kit SDK pour Java](https://aws.amazon.com/sdkforjava/) et la bibliothèque client étendue Amazon SQS pour Java nécessitent le kit de développement J2SE 8.0 ou version ultérieure.

    Pour plus d'informations sur le téléchargement du kit SDK pour Java, consultez [SDK pour Java](https://aws.amazon.com/sdkforjava/).
+ **Bibliothèque de messagerie Java Amazon SQS** 

  Si vous n'utilisez pas Maven, vous devez ajouter le package `amazon-sqs-java-messaging-lib.jar` au chemin de classe Java. Pour plus d'informations sur le téléchargement de la bibliothèque, consultez [Bibliothèque de messagerie Java Amazon SQS](https://github.com/awslabs/amazon-sqs-java-messaging-lib).
**Note**  
La bibliothèque de messagerie Java Amazon SQS inclut la prise en charge de [Maven](http://maven.apache.org/) et du [framework Spring](http://projects.spring.io/spring-framework/).  
Pour obtenir des exemples de code qui utilisent Maven, le framework Spring et la bibliothèque de messagerie Java Amazon SQS, consultez la section [Exemples Java fonctionnels pour l'utilisation de JMS avec les files d'attente standard Amazon SQS](sqs-jms-code-examples.md).  

  ```
  <dependency>
    <groupId>com.amazonaws</groupId>
    <artifactId>amazon-sqs-java-messaging-lib</artifactId>
    <version>1.0.4</version>
    <type>jar</type>
  </dependency>
  ```
+ **File d'attente Amazon SQS**

  Créez une file d'attente à l'aide de l'`CreateQueue`API AWS Management Console pour Amazon SQS, ou du client Amazon SQS encapsulé inclus dans la bibliothèque de messagerie Java Amazon SQS.
  + Pour plus d'informations sur la création d'une file d'attente avec Amazon SQS à l'aide de la AWS Management Console ou de l'API `CreateQueue`, consultez [Création d'une file d'attente](creating-sqs-standard-queues.md#step-create-standard-queue).
  + Pour plus d'informations sur l'utilisation de la bibliothèque de messagerie Java Amazon SQS, consultez [Utilisation de la bibliothèque de messagerie Java Amazon SQS](getting-started.md).

# Utilisation de la bibliothèque de messagerie Java Amazon SQS
<a name="getting-started"></a>

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
<a name="creating-connection"></a>

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
<a name="creating-queue"></a>

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
<a name="creating-queue-standard"></a>

```
// 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
<a name="creating-queue-FIFO"></a>

```
// 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<String, String> attributes = new HashMap<String, String>();
    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
<a name="send-messages-synchronously"></a>

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
<a name="receive-messages-synchronously"></a>

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
<a name="receive-messages-asynchronously"></a>

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
<a name="using-client-acknowledge-mode"></a>

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
<a name="using-unordered-acknowledge-mode"></a>

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
```

# Utilisation du service de message Java avec d'autres clients Amazon SQS
<a name="sqs-jms-client-with-sqs-clients"></a>

L'utilisation du client Amazon SQS Java Message Service (JMS) avec le AWS SDK limite la taille des messages Amazon SQS à 256 Ko. Cependant, vous pouvez créer un fournisseur JMS avec n'importe quel client Amazon SQS. Par exemple, vous pouvez utiliser le client JMS avec la bibliothèque client étendue Amazon SQS pour Java afin d'envoyer un message Amazon SQS qui contient une référence à une charge utile de message (jusqu'à 2 Go) dans Amazon S3. Pour de plus amples informations, veuillez consulter [Gestion de messages Amazon SQS volumineux à l'aide de Java et Amazon S3](sqs-s3-messages.md).

L'exemple de code Java suivant crée le fournisseur JMS pour la bibliothèque client étendue.

Consultez les conditions préalables [Conditions requises pour travailler avec JMS et Amazon SQS](prerequisites.md) avant de tester cet exemple.

```
AmazonS3 s3 = new AmazonS3Client(credentials);
Region s3Region = Region.getRegion(Regions.US_WEST_2);
s3.setRegion(s3Region);
 
// Set the Amazon S3 bucket name, and set a lifecycle rule on the bucket to
// permanently delete objects a certain number of days after each object's creation date.
// Next, create the bucket, and enable message objects to be stored in the bucket.
BucketLifecycleConfiguration.Rule expirationRule = new BucketLifecycleConfiguration.Rule();
expirationRule.withExpirationInDays(14).withStatus("Enabled");
BucketLifecycleConfiguration lifecycleConfig = new BucketLifecycleConfiguration().withRules(expirationRule);
 
s3.createBucket(s3BucketName);
s3.setBucketLifecycleConfiguration(s3BucketName, lifecycleConfig);
System.out.println("Bucket created and configured.");

// Set the SQS extended client configuration with large payload support enabled.
ExtendedClientConfiguration extendedClientConfig = new ExtendedClientConfiguration()
    .withLargePayloadSupportEnabled(s3, s3BucketName);
 
AmazonSQS sqsExtended = new AmazonSQSExtendedClient(new AmazonSQSClient(credentials), extendedClientConfig);
Region sqsRegion = Region.getRegion(Regions.US_WEST_2);
sqsExtended.setRegion(sqsRegion);
```

L'exemple de code Java suivant crée la fabrique de connexions :

```
// Create the connection factory using the environment variable credential provider.
// Pass the configured Amazon SQS Extended Client to the JMS connection factory.
SQSConnectionFactory connectionFactory = new SQSConnectionFactory(
        new ProviderConfiguration(),
        sqsExtended
        );
 
// Create the connection.
SQSConnection connection = connectionFactory.createConnection();
```

# Exemples Java fonctionnels pour l'utilisation de JMS avec les files d'attente standard Amazon SQS
<a name="sqs-jms-code-examples"></a>

Les exemples de code suivants montrent comment utiliser le service de messagerie Java (JMS) avec les files d'attente Amazon SQS standard. Pour plus d'informations sur l'utilisation des files d'attente FIFO, consultez [Pour créer une file d'attente FIFO](getting-started.md#creating-queue-FIFO), [Envoi de messages de façon synchrone](getting-started.md#send-messages-synchronously) et [Réception des messages de façon synchrone](getting-started.md#receive-messages-synchronously). (La réception synchrone des messages est identique pour les files d'attente standard et FIFO. Toutefois, les messages des files d'attente FIFO contiennent davantage d'attributs.)

Consultez les conditions préalables [Conditions requises pour travailler avec JMS et Amazon SQS](prerequisites.md) avant de tester les exemples suivants.

## ExampleConfiguration.java
<a name="example-configuration"></a>

L'exemple de code Java SDK v 1.x suivant définit le nom de file d'attente par défaut, la région et les informations d'identification à utiliser avec les autres exemples Java.

```
/*
 * Copyright 2010-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *  https://aws.amazon.com/apache2.0
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 *
 */

public class ExampleConfiguration {
    public static final String DEFAULT_QUEUE_NAME = "SQSJMSClientExampleQueue";
    
    public static final Region DEFAULT_REGION = Region.getRegion(Regions.US_EAST_2);
    
    private static String getParameter( String args[], int i ) {
        if( i + 1 >= args.length ) {
            throw new IllegalArgumentException( "Missing parameter for " + args[i] );
        }
        return args[i+1];
    }
    
    /**
     * Parse the command line and return the resulting config. If the config parsing fails
     * print the error and the usage message and then call System.exit
     * 
     * @param app the app to use when printing the usage string
     * @param args the command line arguments
     * @return the parsed config
     */
    public static ExampleConfiguration parseConfig(String app, String args[]) {
        try {
            return new ExampleConfiguration(args);
        } catch (IllegalArgumentException e) {
            System.err.println( "ERROR: " + e.getMessage() );
            System.err.println();
            System.err.println( "Usage: " + app + " [--queue <queue>] [--region <region>] [--credentials <credentials>] ");
            System.err.println( "  or" );
            System.err.println( "       " + app + " <spring.xml>" );
            System.exit(-1);
            return null;
        }
    }
    
    private ExampleConfiguration(String args[]) {
        for( int i = 0; i < args.length; ++i ) {
            String arg = args[i];
            if( arg.equals( "--queue" ) ) {
                setQueueName(getParameter(args, i));
                i++;
            } else if( arg.equals( "--region" ) ) {
                String regionName = getParameter(args, i);
                try {
                    setRegion(Region.getRegion(Regions.fromName(regionName)));
                } catch( IllegalArgumentException e ) {
                    throw new IllegalArgumentException( "Unrecognized region " + regionName );  
                }
                i++;
            } else if( arg.equals( "--credentials" ) ) {
                String credsFile = getParameter(args, i);
                try {
                    setCredentialsProvider( new PropertiesFileCredentialsProvider(credsFile) );
                } catch (AmazonClientException e) {
                    throw new IllegalArgumentException("Error reading credentials from " + credsFile, e );
                }
                i++;
            } else {
                throw new IllegalArgumentException("Unrecognized option " + arg);
            }
        }
    }
    
    private String queueName = DEFAULT_QUEUE_NAME;
    private Region region = DEFAULT_REGION;
    private AWSCredentialsProvider credentialsProvider = new DefaultAWSCredentialsProviderChain();
    
    public String getQueueName() {
        return queueName;
    }
    
    public void setQueueName(String queueName) {
        this.queueName = queueName;
    }
    
    public Region getRegion() {
        return region;
    }
    
    public void setRegion(Region region) {
        this.region = region;
    }
 
    public AWSCredentialsProvider getCredentialsProvider() {
        return credentialsProvider;
    }
    
    public void setCredentialsProvider(AWSCredentialsProvider credentialsProvider) {
        // Make sure they're usable first
        credentialsProvider.getCredentials();
        this.credentialsProvider = credentialsProvider;
    }
}
```

## TextMessageSender.java
<a name="example-sender"></a>

L'exemple de code Java suivant crée un producteur de messages texte.

```
/*
 * Copyright 2010-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *  https://aws.amazon.com/apache2.0
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 *
 */

public class TextMessageSender {
    public static void main(String args[]) throws JMSException {
        ExampleConfiguration config = ExampleConfiguration.parseConfig("TextMessageSender", args);
        
        ExampleCommon.setupLogging();
        
        // Create the connection factory based on the config       
        SQSConnectionFactory connectionFactory = new SQSConnectionFactory(
                new ProviderConfiguration(),
                AmazonSQSClientBuilder.standard()
                        .withRegion(config.getRegion().getName())
                        .withCredentials(config.getCredentialsProvider())
                );
        
        // Create the connection
        SQSConnection connection = connectionFactory.createConnection();
        
        // Create the queue if needed
        ExampleCommon.ensureQueueExists(connection, config.getQueueName());
            
        // Create the session
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        MessageProducer producer = session.createProducer( session.createQueue( config.getQueueName() ) );
        
        sendMessages(session, producer);
 
        // Close the connection. This closes the session automatically
        connection.close();
        System.out.println( "Connection closed" );
    }
 
    private static void sendMessages( Session session, MessageProducer producer ) {
        BufferedReader inputReader = new BufferedReader(
            new InputStreamReader( System.in, Charset.defaultCharset() ) );
        
        try {
            String input;
            while( true ) { 
                System.out.print( "Enter message to send (leave empty to exit): " );
                input = inputReader.readLine();
                if( input == null || input.equals("" ) ) break;
                
                TextMessage message = session.createTextMessage(input);
                producer.send(message);
                System.out.println( "Send message " + message.getJMSMessageID() );
            }
        } catch (EOFException e) {
            // Just return on EOF
        } catch (IOException e) {
            System.err.println( "Failed reading input: " + e.getMessage() );
        } catch (JMSException e) {
            System.err.println( "Failed sending message: " + e.getMessage() );
            e.printStackTrace();
        }
    }
}
```

## SyncMessageReceiver.java
<a name="example-synchronous-message-receiver"></a>

L'exemple de code Java suivant crée un consommateur de messages synchrone.

```
/*
 * Copyright 2010-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *  https://aws.amazon.com/apache2.0
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 *
 */

public class SyncMessageReceiver {
public static void main(String args[]) throws JMSException {
    ExampleConfiguration config = ExampleConfiguration.parseConfig("SyncMessageReceiver", args);
    
    ExampleCommon.setupLogging();
    
    // Create the connection factory based on the config
    SQSConnectionFactory connectionFactory = new SQSConnectionFactory(
            new ProviderConfiguration(),
            AmazonSQSClientBuilder.standard()
                    .withRegion(config.getRegion().getName())
                    .withCredentials(config.getCredentialsProvider())
            );
    
    // Create the connection
    SQSConnection connection = connectionFactory.createConnection();
    
    // Create the queue if needed
    ExampleCommon.ensureQueueExists(connection, config.getQueueName());
        
    // Create the session
    Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
    MessageConsumer consumer = session.createConsumer( session.createQueue( config.getQueueName() ) );

    connection.start();
    
    receiveMessages(session, consumer);

    // Close the connection. This closes the session automatically
    connection.close();
    System.out.println( "Connection closed" );
}

private static void receiveMessages( Session session, MessageConsumer consumer ) {
    try {
        while( true ) {
            System.out.println( "Waiting for messages");
            // Wait 1 minute for a message
            Message message = consumer.receive(TimeUnit.MINUTES.toMillis(1));
            if( message == null ) {
                System.out.println( "Shutting down after 1 minute of silence" );
                break;
            }
            ExampleCommon.handleMessage(message);
            message.acknowledge();
            System.out.println( "Acknowledged message " + message.getJMSMessageID() );
        }
    } catch (JMSException e) {
        System.err.println( "Error receiving from SQS: " + e.getMessage() );
        e.printStackTrace();
    }
}
}
```

## AsyncMessageReceiver.java
<a name="example-asynchronous-message-receiver"></a>

L'exemple de code Java suivant crée un consommateur de messages asynchrone.

```
/*
 * Copyright 2010-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *  https://aws.amazon.com/apache2.0
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 *
 */

public class AsyncMessageReceiver {
    public static void main(String args[]) throws JMSException, InterruptedException {
        ExampleConfiguration config = ExampleConfiguration.parseConfig("AsyncMessageReceiver", args);
         
        ExampleCommon.setupLogging();          
         
        // Create the connection factory based on the config
        SQSConnectionFactory connectionFactory = new SQSConnectionFactory(
                new ProviderConfiguration(),
                AmazonSQSClientBuilder.standard()
                        .withRegion(config.getRegion().getName())
                        .withCredentials(config.getCredentialsProvider())
                );
         
        // Create the connection
        SQSConnection connection = connectionFactory.createConnection();
         
        // Create the queue if needed
        ExampleCommon.ensureQueueExists(connection, config.getQueueName());
             
        // Create the session
        Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
        MessageConsumer consumer = session.createConsumer( session.createQueue( config.getQueueName() ) );
         
        // No messages are processed until this is called
        connection.start();

        ReceiverCallback callback = new ReceiverCallback();
        consumer.setMessageListener( callback );
         
        callback.waitForOneMinuteOfSilence();
        System.out.println( "Returning after one minute of silence" );

        // Close the connection. This closes the session automatically
        connection.close();
        System.out.println( "Connection closed" );
    }
    
    
    private static class ReceiverCallback implements MessageListener {
        // Used to listen for message silence
        private volatile long timeOfLastMessage = System.nanoTime();
         
        public void waitForOneMinuteOfSilence() throws InterruptedException {
            for(;;) {
                long timeSinceLastMessage = System.nanoTime() - timeOfLastMessage;
                long remainingTillOneMinuteOfSilence = 
                    TimeUnit.MINUTES.toNanos(1) - timeSinceLastMessage;
                if( remainingTillOneMinuteOfSilence < 0 ) {
                    break;
                }
                TimeUnit.NANOSECONDS.sleep(remainingTillOneMinuteOfSilence);
            }
        }
         

        @Override
        public void onMessage(Message message) {
            try {
                ExampleCommon.handleMessage(message);
                message.acknowledge();
                System.out.println( "Acknowledged message " + message.getJMSMessageID() );
                timeOfLastMessage = System.nanoTime();
            } catch (JMSException e) {
                System.err.println( "Error processing message: " + e.getMessage() );
                e.printStackTrace();
            }
        }
    }
}
```

## SyncMessageReceiverClientAcknowledge.java
<a name="example-synchronous-receiver-client-acknowledge-mode"></a>

L'exemple de code Java suivant crée un consommateur synchrone avec le mode de reconnaissance du client.

```
/*
 * Copyright 2010-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *  https://aws.amazon.com/apache2.0
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 *
 */

/**
 * An example class to demonstrate the behavior of CLIENT_ACKNOWLEDGE mode for received messages. This example
 * complements the example given in {@link SyncMessageReceiverUnorderedAcknowledge} for UNORDERED_ACKNOWLEDGE mode.
 *
 * First, a session, a message producer, and a message consumer are created. Then, two messages are sent. Next, two messages
 * are received but only the second one is acknowledged. After waiting for the visibility time out period, an attempt to
 * receive another message is made. It's shown that no message is returned for this attempt since in CLIENT_ACKNOWLEDGE mode,
 * as expected, all the messages prior to the acknowledged messages are also acknowledged.
 *
 * This ISN'T the behavior for UNORDERED_ACKNOWLEDGE mode. Please see {@link SyncMessageReceiverUnorderedAcknowledge}
 * for an example.
 */
public class SyncMessageReceiverClientAcknowledge {
 
    // Visibility time-out for the queue. It must match to the one set for the queue for this example to work.
    private static final long TIME_OUT_SECONDS = 1;
 
    public static void main(String args[]) throws JMSException, InterruptedException {
        // Create the configuration for the example
        ExampleConfiguration config = ExampleConfiguration.parseConfig("SyncMessageReceiverClientAcknowledge", args);
 
        // Setup logging for the example
        ExampleCommon.setupLogging();
 
        // Create the connection factory based on the config
        SQSConnectionFactory connectionFactory = new SQSConnectionFactory(
                new ProviderConfiguration(),
                AmazonSQSClientBuilder.standard()
                        .withRegion(config.getRegion().getName())
                        .withCredentials(config.getCredentialsProvider())
                );
 
        // Create the connection
        SQSConnection connection = connectionFactory.createConnection();
 
        // Create the queue if needed
        ExampleCommon.ensureQueueExists(connection, config.getQueueName());
 
        // Create the session  with client acknowledge mode
        Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
 
        // Create the producer and consume
        MessageProducer producer = session.createProducer(session.createQueue(config.getQueueName()));
        MessageConsumer consumer = session.createConsumer(session.createQueue(config.getQueueName()));
 
        // Open the connection
        connection.start();
 
        // Send two text messages
        sendMessage(producer, session, "Message 1");
        sendMessage(producer, session, "Message 2");
 
        // Receive a message and don't acknowledge it
        receiveMessage(consumer, false);
 
        // Receive another message and acknowledge it
        receiveMessage(consumer, true);
 
        // Wait for the visibility time out, so that unacknowledged messages reappear in the queue
        System.out.println("Waiting for visibility timeout...");
        Thread.sleep(TimeUnit.SECONDS.toMillis(TIME_OUT_SECONDS));
 
        // Attempt to receive another message and acknowledge it. This results in receiving no messages since
        // we have acknowledged the second message. Although we didn't explicitly acknowledge the first message,
        // in the CLIENT_ACKNOWLEDGE mode, all the messages received prior to the explicitly acknowledged message
        // are also acknowledged. Therefore, we have implicitly acknowledged the first message.
        receiveMessage(consumer, true);
 
        // Close the connection. This closes the session automatically
        connection.close();
        System.out.println("Connection closed.");
    }
 
    /**
     * Sends a message through the producer.
     *
     * @param producer Message producer
     * @param session Session
     * @param messageText Text for the message to be sent
     * @throws JMSException
     */
    private static void sendMessage(MessageProducer producer, Session session, String messageText) throws JMSException {
        // Create a text message and send it
        producer.send(session.createTextMessage(messageText));
    }
 
    /**
     * Receives a message through the consumer synchronously with the default timeout (TIME_OUT_SECONDS).
     * If a message is received, the message is printed. If no message is received, "Queue is empty!" is
     * printed.
     *
     * @param consumer Message consumer
     * @param acknowledge If true and a message is received, the received message is acknowledged.
     * @throws JMSException
     */
    private static void receiveMessage(MessageConsumer consumer, boolean acknowledge) throws JMSException {
        // Receive a message
        Message message = consumer.receive(TimeUnit.SECONDS.toMillis(TIME_OUT_SECONDS));
 
        if (message == null) {
            System.out.println("Queue is empty!");
        } else {
            // Since this queue has only text messages, cast the message object and print the text
            System.out.println("Received: " + ((TextMessage) message).getText());
 
            // Acknowledge the message if asked
            if (acknowledge) message.acknowledge();
        }
    }
}
```

## SyncMessageReceiverUnorderedAcknowledge.java
<a name="example-synchronous-receiver-unordered-acknowledge-mode"></a>

L'exemple de code Java suivant crée un consommateur synchrone avec le mode de reconnaissance sans ordre de réception.

```
/*
 * Copyright 2010-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *  https://aws.amazon.com/apache2.0
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 *
 */

/**
 * An example class to demonstrate the behavior of UNORDERED_ACKNOWLEDGE mode for received messages. This example
 * complements the example given in {@link SyncMessageReceiverClientAcknowledge} for CLIENT_ACKNOWLEDGE mode.
 *
 * First, a session, a message producer, and a message consumer are created. Then, two messages are sent. Next, two messages
 * are received but only the second one is acknowledged. After waiting for the visibility time out period, an attempt to
 * receive another message is made. It's shown that the first message received in the prior attempt is returned again
 * for the second attempt. In UNORDERED_ACKNOWLEDGE mode, all the messages must be explicitly acknowledged no matter what
 * the order they're received.
 *
 * This ISN'T the behavior for CLIENT_ACKNOWLEDGE mode. Please see {@link SyncMessageReceiverClientAcknowledge}
 * for an example.
 */
public class SyncMessageReceiverUnorderedAcknowledge {
 
    // Visibility time-out for the queue. It must match to the one set for the queue for this example to work.
    private static final long TIME_OUT_SECONDS = 1;
 
    public static void main(String args[]) throws JMSException, InterruptedException {
        // Create the configuration for the example
        ExampleConfiguration config = ExampleConfiguration.parseConfig("SyncMessageReceiverUnorderedAcknowledge", args);
 
        // Setup logging for the example
        ExampleCommon.setupLogging();
 
        // Create the connection factory based on the config
        SQSConnectionFactory connectionFactory = new SQSConnectionFactory(
                new ProviderConfiguration(),
                AmazonSQSClientBuilder.standard()
                        .withRegion(config.getRegion().getName())
                        .withCredentials(config.getCredentialsProvider())
                );
 
        // Create the connection
        SQSConnection connection = connectionFactory.createConnection();
 
        // Create the queue if needed
        ExampleCommon.ensureQueueExists(connection, config.getQueueName());
 
        // Create the session  with unordered acknowledge mode
        Session session = connection.createSession(false, SQSSession.UNORDERED_ACKNOWLEDGE);
 
        // Create the producer and consume
        MessageProducer producer = session.createProducer(session.createQueue(config.getQueueName()));
        MessageConsumer consumer = session.createConsumer(session.createQueue(config.getQueueName()));
 
        // Open the connection
        connection.start();
 
        // Send two text messages
        sendMessage(producer, session, "Message 1");
        sendMessage(producer, session, "Message 2");
 
        // Receive a message and don't acknowledge it
        receiveMessage(consumer, false);
 
        // Receive another message and acknowledge it
        receiveMessage(consumer, true);
 
        // Wait for the visibility time out, so that unacknowledged messages reappear in the queue
        System.out.println("Waiting for visibility timeout...");
        Thread.sleep(TimeUnit.SECONDS.toMillis(TIME_OUT_SECONDS));
 
        // Attempt to receive another message and acknowledge it. This results in receiving the first message since
        // we have acknowledged only the second message. In the UNORDERED_ACKNOWLEDGE mode, all the messages must
        // be explicitly acknowledged.
        receiveMessage(consumer, true);
 
        // Close the connection. This closes the session automatically
        connection.close();
        System.out.println("Connection closed.");
    }
 
    /**
     * Sends a message through the producer.
     *
     * @param producer Message producer
     * @param session Session
     * @param messageText Text for the message to be sent
     * @throws JMSException
     */
    private static void sendMessage(MessageProducer producer, Session session, String messageText) throws JMSException {
        // Create a text message and send it
        producer.send(session.createTextMessage(messageText));
    }
 
    /**
     * Receives a message through the consumer synchronously with the default timeout (TIME_OUT_SECONDS).
     * If a message is received, the message is printed. If no message is received, "Queue is empty!" is
     * printed.
     *
     * @param consumer Message consumer
     * @param acknowledge If true and a message is received, the received message is acknowledged.
     * @throws JMSException
     */
    private static void receiveMessage(MessageConsumer consumer, boolean acknowledge) throws JMSException {
        // Receive a message
        Message message = consumer.receive(TimeUnit.SECONDS.toMillis(TIME_OUT_SECONDS));
 
        if (message == null) {
            System.out.println("Queue is empty!");
        } else {
            // Since this queue has only text messages, cast the message object and print the text
            System.out.println("Received: " + ((TextMessage) message).getText());
 
            // Acknowledge the message if asked
            if (acknowledge) message.acknowledge();
        }
    }
}
```

## SpringExampleConfiguration.xml
<a name="example-spring-configuration"></a>

L'exemple de code XML suivant est un fichier de configuration bean pour [SpringExample.java](#example-spring).

```
<!--
    Copyright 2010-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.

    Licensed under the Apache License, Version 2.0 (the "License").
    You may not use this file except in compliance with the License.
    A copy of the License is located at

    https://aws.amazon.com/apache2.0

    or in the "license" file accompanying this file. This file is distributed
    on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
    express or implied. See the License for the specific language governing
    permissions and limitations under the License.
-->

<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:util="http://www.springframework.org/schema/util"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd
    ">
    
    <bean id="CredentialsProviderBean" class="com.amazonaws.auth.DefaultAWSCredentialsProviderChain"/>
    
    <bean id="ClientBuilder" class="com.amazonaws.services.sqs.AmazonSQSClientBuilder" factory-method="standard">
        <property name="region" value="us-east-2"/>
        <property name="credentials" ref="CredentialsProviderBean"/>               
    </bean>
    
    <bean id="ProviderConfiguration" class="com.amazon.sqs.javamessaging.ProviderConfiguration">
        <property name="numberOfMessagesToPrefetch" value="5"/>
    </bean>
    
    <bean id="ConnectionFactory" class="com.amazon.sqs.javamessaging.SQSConnectionFactory">
        <constructor-arg ref="ProviderConfiguration" />
        <constructor-arg ref="ClientBuilder" />
    </bean>
    
    <bean id="Connection" class="javax.jms.Connection"
        factory-bean="ConnectionFactory"
        factory-method="createConnection"
        init-method="start"
        destroy-method="close" />
    
    <bean id="QueueName" class="java.lang.String">
        <constructor-arg value="SQSJMSClientExampleQueue"/>
    </bean>
</beans>
```

## SpringExample.java
<a name="example-spring"></a>

L'exemple de code Java suivant utilise le fichier de configuration bean pour initialiser vos objets.

```
/*
 * Copyright 2010-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *  https://aws.amazon.com/apache2.0
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 *
 */
                
public class SpringExample {
    public static void main(String args[]) throws JMSException {
        if( args.length != 1 || !args[0].endsWith(".xml")) {
            System.err.println( "Usage: " + SpringExample.class.getName() + " <spring config.xml>" );
            System.exit(1);
        }
        
        File springFile = new File( args[0] );
        if( !springFile.exists() || !springFile.canRead() ) {
            System.err.println( "File " + args[0] + " doesn't exist or isn't readable.");
            System.exit(2);
        }
        
        ExampleCommon.setupLogging();
        
        FileSystemXmlApplicationContext context = 
            new FileSystemXmlApplicationContext( "file://" + springFile.getAbsolutePath() );
        
        Connection connection;
        try {
            connection = context.getBean(Connection.class);
        } catch( NoSuchBeanDefinitionException e ) {
            System.err.println( "Can't find the JMS connection to use: " + e.getMessage() );
            System.exit(3);
            return;
        }
        
        String queueName;
        try {
            queueName = context.getBean("QueueName", String.class);
        } catch( NoSuchBeanDefinitionException e ) {
            System.err.println( "Can't find the name of the queue to use: " + e.getMessage() );
            System.exit(3);
            return;
        }
        
        if( connection instanceof SQSConnection ) {
            ExampleCommon.ensureQueueExists( (SQSConnection) connection, queueName );
        }
        
        // Create the session
        Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
        MessageConsumer consumer = session.createConsumer( session.createQueue( queueName) );
        
        receiveMessages(session, consumer);
 
        // The context can be setup to close the connection for us
        context.close();
        System.out.println( "Context closed" );
    }
 
    private static void receiveMessages( Session session, MessageConsumer consumer ) {
        try {
            while( true ) {
                System.out.println( "Waiting for messages");
                // Wait 1 minute for a message
                Message message = consumer.receive(TimeUnit.MINUTES.toMillis(1));
                if( message == null ) {
                    System.out.println( "Shutting down after 1 minute of silence" );
                    break;
                }
                ExampleCommon.handleMessage(message);
                message.acknowledge();
                System.out.println( "Acknowledged message" );
            }
        } catch (JMSException e) {
            System.err.println( "Error receiving from SQS: " + e.getMessage() );
            e.printStackTrace();
        }
    }
}
```

## ExampleCommon.java
<a name="example-common"></a>

L'exemple de code Java suivant vérifie s'il existe une file d'attente Amazon SQS, puis en crée une si ce n'est pas le cas. Il comprend également un exemple de code de journalisation.

```
/*
 * Copyright 2010-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *  https://aws.amazon.com/apache2.0
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 *
 */

public class ExampleCommon {
    /**
     * A utility function to check the queue exists and create it if needed. For most  
     * use cases this is usually done by an administrator before the application is run. 
     */
    public static void ensureQueueExists(SQSConnection connection, String queueName) throws JMSException {
        AmazonSQSMessagingClientWrapper client = connection.getWrappedAmazonSQSClient();
        
        /**
         * In most cases, you can do this with just a createQueue call, but GetQueueUrl 
         * (called by queueExists) is a faster operation for the common case where the queue 
         * already exists. Also many users and roles have permission to call GetQueueUrl
         * but don't have permission to call CreateQueue.
         */
        if( !client.queueExists(queueName) ) {
            client.createQueue( queueName );
        }
    }
 
    public static void setupLogging() {
        // Setup logging
        BasicConfigurator.configure();
        Logger.getRootLogger().setLevel(Level.WARN);
    }
 
    public static void handleMessage(Message message) throws JMSException {
        System.out.println( "Got message " + message.getJMSMessageID() );
        System.out.println( "Content: ");
        if( message instanceof TextMessage ) {
            TextMessage txtMessage = ( TextMessage ) message;
            System.out.println( "\t" + txtMessage.getText() );
        } else if( message instanceof BytesMessage ){
            BytesMessage byteMessage = ( BytesMessage ) message;
            // Assume the length fits in an int - SQS only supports sizes up to 256k so that
            // should be true
            byte[] bytes = new byte[(int)byteMessage.getBodyLength()];
            byteMessage.readBytes(bytes);
            System.out.println( "\t" +  Base64.encodeAsString( bytes ) );
        } else if( message instanceof ObjectMessage ) {
            ObjectMessage objMessage = (ObjectMessage) message;
            System.out.println( "\t" + objMessage.getObject() );
        }
    }
}
```

# Implémentations de JMS 1.1 prises en charge par Amazon SQS
<a name="supported-implementations"></a>

La bibliothèque de messagerie Java Amazon SQS prend en charge les [implémentations JMS 1.1](http://docs.oracle.com/javaee/6/api/javax/jms/package-summary.html) suivantes. Pour plus d'informations sur les fonctionnalités prises en charge de la bibliothèque de messagerie Java Amazon SQS, consultez la [Foire aux questions sur Amazon SQS](https://aws.amazon.com/sqs/faqs/).

## Interfaces courantes prises en charge
<a name="supported-common-interfaces"></a>
+ `Connection`
+ `ConnectionFactory`
+ `Destination`
+ `Session`
+ `MessageConsumer`
+ `MessageProducer`

## Types de messages pris en charge
<a name="supported-message-types"></a>
+ `ByteMessage`
+ `ObjectMessage`
+ `TextMessage`

## Modes de reconnaissance des messages pris en charge
<a name="supported-message-acknowledgement-modes"></a>
+ `AUTO_ACKNOWLEDGE`
+ `CLIENT_ACKNOWLEDGE`
+ `DUPS_OK_ACKNOWLEDGE`
+ `UNORDERED_ACKNOWLEDGE`

**Note**  
Le mode `UNORDERED_ACKNOWLEDGE` ne fait pas partie de la spécification JMS 1.1. Ce mode permet à Amazon SQS d'autoriser un client JMS à accepter explicitement un message.

## En-têtes définis par JMS et propriétés réservées
<a name="jms-defined-headers-reserved-properties"></a>

### Pour l'envoi de messages
<a name="for-sending-messages"></a>

Lorsque vous envoyez des messages, vous pouvez définir les en-têtes et propriétés ci-après pour chaque message :
+ `JMSXGroupID` (obligatoire pour les files d'attente FIFO, non autorisé pour les files d'attente standard)
+ `JMS_SQS_DeduplicationId` (facultatif pour les files d'attente FIFO, non autorisé pour les files d'attente standard)

Après l'envoi de messages, Amazon SQS définit les en-têtes et propriétés ci-après pour chaque message :
+ `JMSMessageID`
+ `JMS_SQS_SequenceNumber` (uniquement pour les files d'attente FIFO)

### Pour la réception de messages
<a name="for-receiving-messages"></a>

Lorsque vous recevez des messages, Amazon SQS définit les en-têtes et propriétés ci-après pour chaque message :
+ `JMSDestination`
+ `JMSMessageID`
+ `JMSRedelivered`
+ `JMSXDeliveryCount`
+ `JMSXGroupID` (uniquement pour les files d'attente FIFO)
+ `JMS_SQS_DeduplicationId` (uniquement pour les files d'attente FIFO)
+ `JMS_SQS_SequenceNumber` (uniquement pour les files d'attente FIFO)