Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Verwenden von JMS mit Amazon SQS
<a name="sqs-java-message-service-jms-client"></a>

Die Amazon SQS Java Messaging Library ist eine Java-Message-Service (JMS)-Schnittstelle für Amazon SQS, mit der Sie Amazon SQS in Anwendungen nutzen können, die bereits JMS verwenden. Mithilfe der Schnittstelle können Sie mit nur wenigen Codeänderungen Amazon SQS als JMS-Anbieter verwenden. In Verbindung mit der AWS SDK für Java können Sie mithilfe der Amazon SQS Java Messaging Library JMS-Verbindungen und -Sitzungen sowie Produzenten und Konsumenten erstellen, die Nachrichten an und von Amazon-SQS-Warteschlangen senden und empfangen.

Die Bibliothek unterstützt das Senden und Empfangen von Nachrichten an eine Warteschlange (das point-to-point JMS-Modell) gemäß der [JMS 1.1-Spezifikation](http://docs.oracle.com/javaee/6/api/javax/jms/package-summary.html). Die Bibliothek unterstützt das synchrone Senden von Text-, Byte- und Objektnachrichten an Amazon-SQS-Warteschlangen. Außerdem wird das synchrone und asynchrone Empfangen von Objekten unterstützt.

Informationen zu Funktionen der Amazon SQS Java Messaging Library, die die JMS 1.1-Spezifikation unterstützen, finden Sie unter [Von Amazon SQS unterstützte JMS 1.1-Implementierungen](supported-implementations.md) und [Amazon](https://aws.amazon.com/sqs/faqs/) SQS. FAQs

# Voraussetzungen für die Arbeit mit JMS und Amazon SQS
<a name="prerequisites"></a>

Folgende Voraussetzungen müssen erfüllt sein, bevor Sie den Vorgang starten:
+ **SDK für Java**

  Es gibt zwei Möglichkeiten, das SDK für Java in Ihr Projekt einzubinden:
  + Laden Sie das SDK für Java herunter und installieren Sie es.
  + Verwenden Sie Maven, um die Amazon SQS Java Messaging Library zu erhalten.
**Anmerkung**  
Das SDK für Java ist als Abhängigkeit enthalten.  
Für das [SDK für Java](https://aws.amazon.com/sdkforjava/) und die Amazon SQS Extended Client Library für Java ist das J2SE Development Kit 8.0 oder eine neuere Version erforderlich.

    Weitere Informationen zum Herunterladen des SDK für Java finden Sie unter [SDK für Java](https://aws.amazon.com/sdkforjava/).
+ **Amazon SQS Java Messaging Library** 

  Wenn Sie Maven nicht verwenden, müssen Sie das Paket `amazon-sqs-java-messaging-lib.jar` zum Java-Erstellungspfad hinzufügen. Weitere Informationen zum Herunterladen der Bibliothek finden Sie unter [Amazon SQS Java Messaging Library](https://github.com/awslabs/amazon-sqs-java-messaging-lib).
**Anmerkung**  
Die Amazon SQS Java Messaging Library bietet Unterstützung für [Maven](http://maven.apache.org/) und das [Spring Framework](http://projects.spring.io/spring-framework/).  
Codebeispiele, in denen Maven, das Spring Framework und die Amazon SQS Java Messaging Library verwendet werden, finden Sie unter [Funktionierende Java-Beispiele für die Verwendung von JMS mit Amazon SQS SQS-Standardwarteschlangen](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>
  ```
+ **Amazon-SQS-Warteschlange**

  Erstellen Sie eine Warteschlange mit dem AWS-Managementkonsole für Amazon SQS, der `CreateQueue` API oder dem verpackten Amazon SQS-Client, der in der Amazon SQS Java Messaging Library enthalten ist.
  + Weitere Informationen zum Erstellen einer Warteschlange mit Amazon SQS mithilfe der AWS-Managementkonsole oder der `CreateQueue`-API finden Sie unter [Erstellen einer Warteschlange](creating-sqs-standard-queues.md#step-create-standard-queue).
  + Weitere Informationen zur Verwendung der Amazon SQS Java Messaging Library finden Sie unter [Verwenden der Amazon SQS Java Messaging-Bibliothek](getting-started.md).

# Verwenden der Amazon SQS Java Messaging-Bibliothek
<a name="getting-started"></a>

Verwenden Sie die Codebeispiele in diesem Abschnitt, um mit der Verwendung des Java Message Service (JMS) mit Amazon SQS zu beginnen. In den folgenden Abschnitten erfahren Sie, wie Sie eine JMS-Verbindung und eine Sitzung erstellen sowie eine Nachricht senden und empfangen.

Das integrierte Amazon-SQS-Clientobjekt der Amazon SQS Java Messaging Library prüft, ob bereits eine Amazon-SQS-Warteschlange vorhanden ist. Ist dies nicht der Fall, wird sie vom Client erstellt.

## Erstellen einer JMS-Verbindung
<a name="creating-connection"></a>

Bevor Sie beginnen, informieren Sie sich über die Voraussetzungen unter[Voraussetzungen für die Arbeit mit JMS und Amazon SQS](prerequisites.md).

1. Erstellen Sie eine Verbindungs-Factory und rufen Sie die Methode `createConnection` für die Factory auf.

   ```
   // 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();
   ```

   Die Klasse `SQSConnection` erweitert `javax.jms.Connection`. In Verbindung mit den JMS-Standardverbindungsmethoden bietet `SQSConnection` zusätzliche Methoden wie `getAmazonSQSClient` und `getWrappedAmazonSQSClient`. Mit beiden Methoden lassen sich administrative Aufgaben wie das Erstellen neuer Warteschlangen ausführen, die in der JMS-Spezifikation nicht enthalten sind. Die `getWrappedAmazonSQSClient`-Methode stellt jedoch auch eine integrierte Version des Amazon-SQS-Client bereit, die von der aktuellen Verbindung verwendet wird. Der Wrapper wandelt alle Ausnahmen des Clients in eine `JMSException` um. So können diese von bestehendem Code, in dem Vorkommen von `JMSException` erwartet werden, einfacher verwendet werden.

1. Sie können die von `getAmazonSQSClient` und `getWrappedAmazonSQSClient` zurückgegebenen Clientobjekte für administrative Aufgaben verwenden, die in der JMS-Spezifikation nicht enthalten sind (z. B. Erstellen einer neuen Amazon-SQS-Warteschlange).

    Wenn Ihr bestehender Code JMS-Ausnahmen erwartet, müssen Sie `getWrappedAmazonSQSClient` verwenden:
   + Wenn Sie `getWrappedAmazonSQSClient` verwenden, wandelt das zurückgegebene Clientobjekt alle Ausnahmen in JMS-Ausnahmen um.
   + Wenn Sie `getAmazonSQSClient` verwenden, sind alle Ausnahmen Amazon-SQS-Ausnahmen.

## Erstellen einer Amazon-SQS-Warteschlange
<a name="creating-queue"></a>

Das integrierte Clientobjekt prüft, ob eine Amazon-SQS-Warteschlange vorhanden ist.

Ist dies nicht der Fall, wird sie vom Client erstellt. Ist bereits eine Warteschlange vorhanden, gibt die Funktion nichts zurück. Weitere Informationen finden Sie im Abschnitt "Create the queue if needed" im Beispiel [TextMessageSender.java](sqs-jms-code-examples.md#example-sender).

### So erstellen Sie eine Standardwarteschlange
<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");
}
```

### So erstellen Sie eine FIFO-Warteschlange
<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));
}
```

**Anmerkung**  
Der Name einer FIFO-Warteschlange muss mit dem Suffix `.fifo` enden.  
Weitere Informationen zum `ContentBasedDeduplication`-Attribut finden Sie unter [Exactly-Once-Verarbeitung in Amazon SQS](FIFO-queues-exactly-once-processing.md).

## Synchrones Senden von Nachrichten
<a name="send-messages-synchronously"></a>

1. Wenn die Verbindung und die zugrundeliegende Amazon-SQS-Warteschlange bereit sind, erstellen Sie eine nicht transaktionsorientierte JMS-Sitzung mit dem Modus `AUTO_ACKNOWLEDGE`.

   ```
   // Create the nontransacted session with AUTO_ACKNOWLEDGE mode
   Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
   ```

1. Erstellen Sie zum Senden einer Textnachricht an die Warteschlange eine JMS-Warteschlangenidentität und einen Nachrichtenproduzenten.

   ```
   // 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. Erstellen Sie eine Textnachricht und senden Sie sie an die Warteschlange.
   + Um eine Nachricht an eine Standard-Warteschlange zu senden, müssen Sie keine weiteren Parameter festlegen.

     ```
     // Create the text message
     TextMessage message = session.createTextMessage("Hello World!");
      
     // Send the message
     producer.send(message);
     System.out.println("JMS Message " + message.getJMSMessageID());
     ```
   + Um eine Nachricht an eine FIFO-Warteschlange zu senden, müssen Sie die Nachrichtengruppen-ID festlegen. Darüber hinaus können Sie eine Nachrichtendeduplizierungs-ID festlegen. Weitere Informationen finden Sie unter [Schlüsselbegriffe der Amazon SQS FIFO-Warteschlange](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"));
     ```

## Synchrones Empfangen von Nachrichten
<a name="receive-messages-synchronously"></a>

1. Erstellen Sie zum Empfangen von Nachrichten einen Konsumenten für dieselbe Warteschlange und rufen Sie die Methode `start` auf.

   Sie können die Methode `start` für die Verbindung jederzeit aufrufen. Der Konsument beginnt jedoch erst mit dem Abrufen von Nachrichten, wenn Sie die Methode aufrufen.

   ```
   // Create a consumer for the 'MyQueue'
   MessageConsumer consumer = session.createConsumer(queue);
   // Start receiving incoming messages
   connection.start();
   ```

1. Rufen Sie die Methode `receive` mit einer Zeitbeschränkung von 1 Sekunde auf dem Konsumenten auf und geben Sie den Inhalt der empfangenen Nachricht aus.
   + Nachdem Sie eine Nachricht aus einer Standard-Warteschlange abgerufen haben, können Sie auf den Inhalt der Nachricht zugreifen.

     ```
     // 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());
     }
     ```
   + Nachdem Sie eine Nachricht aus einer FIFO-Warteschlange abgerufen haben, können Sie auf den Inhalt der Nachricht sowie auf andere FIFO-spezifische Nachrichtenattribute wie die Nachrichtengruppen-ID, die Nachrichtendeduplizierungs-ID und die Sequenznummer zugreifen. Weitere Informationen finden Sie unter [Schlüsselbegriffe der Amazon SQS FIFO-Warteschlange](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. Schließen Sie die Verbindung und die Sitzung.

   ```
   // Close the connection (and the session).
   connection.close();
   ```

Die Ausgabe sieht folgendermaßen oder ähnlich aus:

```
JMS Message ID:8example-588b-44e5-bbcf-d816example2
Received: Hello World!
```

**Anmerkung**  
Sie können das Spring Framework zum Initialisieren dieser Objekte verwenden.  
Weitere Informationen finden Sie unter `SpringExampleConfiguration.xml`, `SpringExample.java`. Informationen zu den anderen unterstützenden Klassen finden Sie unter `ExampleConfiguration.java` und `ExampleCommon.java` im Abschnitt [Funktionierende Java-Beispiele für die Verwendung von JMS mit Amazon SQS SQS-Standardwarteschlangen](sqs-jms-code-examples.md).

Umfassende Beispiele für das Senden und Empfangen von Objekten finden Sie unter [TextMessageSender.java](sqs-jms-code-examples.md#example-sender) und [SyncMessageReceiver.java](sqs-jms-code-examples.md#example-synchronous-message-receiver).

## Asynchrones Empfangen von Nachrichten
<a name="receive-messages-asynchronously"></a>

Im Beispiel unter [Verwenden der Amazon SQS Java Messaging-Bibliothek](#getting-started) wird eine Nachricht an `MyQueue` gesendet und synchron empfangen.

Im folgenden Beispiel wird gezeigt, wie Nachrichten mithilfe eines Listeners asynchron empfangen werden können.

1. Implementieren Sie die `MessageListener`-Schnittstelle.

   ```
   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();
           }
       }
   }
   ```

   Beim Empfang einer Nachricht wird die Methode `onMessage` der `MessageListener`-Schnittstelle aufgerufen. In dieser Implementierung des Listeners wird der in der Nachricht gespeicherte Text ausgegeben.

1. Statt die Methode `receive` auf dem Konsumenten explizit aufzurufen, richten Sie den Nachrichten-Listener des Konsumenten auf einer Instance der `MyListener`-Implementierung ein. Der Haupt-Thread wartet eine Sekunde lang.

   ```
   // 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);
   ```

Die restlichen Schritte sind identisch wie im Beispiel [Verwenden der Amazon SQS Java Messaging-Bibliothek](#getting-started). Ein umfassendes Beispiel für einen asynchronen Konsumenten finden Sie unter `AsyncMessageReceiver.java` in den [Funktionierende Java-Beispiele für die Verwendung von JMS mit Amazon SQS SQS-Standardwarteschlangen](sqs-jms-code-examples.md).

Die Ausgabe für dieses Beispiel sieht in etwa wie folgt aus:

```
JMS Message ID:8example-588b-44e5-bbcf-d816example2
Received: Hello World!
```

## Verwenden des Client-Bestätigungsmodus
<a name="using-client-acknowledge-mode"></a>

In dem Beispiel in [Verwenden der Amazon SQS Java Messaging-Bibliothek](#getting-started) wird der `AUTO_ACKNOWLEDGE`-Modus verwendet, um jede empfangene Nachricht automatisch zu bestätigen (und somit aus der zugrundeliegenden Amazon-SQS-Warteschlange zu löschen).

1. Um die Nachrichten nach der Verarbeitung explizit zu bestätigen, müssen Sie die Sitzung im `CLIENT_ACKNOWLEDGE`-Modus erstellen.

   ```
   // Create the non-transacted session with CLIENT_ACKNOWLEDGE mode.
   Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
   ```

1. Zeigen Sie die Nachricht nach dem Empfangen an und bestätigen Sie sie explizit.

   ```
   // 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());
   }
   ```
**Anmerkung**  
Wenn eine Nachricht in diesem Modus bestätigt wird, werden alle Nachrichten, die vor dieser Nachricht empfangen wurden, ebenfalls implizit bestätigt. Wenn Sie beispielsweise 10 Nachrichten empfangen haben und nur die 10. Nachricht bestätigen (in der Reihenfolge, in der die Nachrichten empfangen wurden) werden die vorherigen 9 Nachrichten ebenfalls bestätigt.

Die restlichen Schritte sind identisch wie im Beispiel [Verwenden der Amazon SQS Java Messaging-Bibliothek](#getting-started). Ein umfassendes Beispiel für einen synchronen Konsumenten im Client-Bestätigungsmodus finden Sie unter `SyncMessageReceiverClientAcknowledge.java` in den [Funktionierende Java-Beispiele für die Verwendung von JMS mit Amazon SQS SQS-Standardwarteschlangen](sqs-jms-code-examples.md).

Die Ausgabe für dieses Beispiel sieht in etwa wie folgt aus:

```
JMS Message ID:4example-aa0e-403f-b6df-5e02example5
Received: Hello World!
Acknowledged: ID:4example-aa0e-403f-b6df-5e02example5
```

## Verwenden des ungeordneten Bestätigungsmodus
<a name="using-unordered-acknowledge-mode"></a>

Wenn Sie den `CLIENT_ACKNOWLEDGE`-Modus verwenden, werden alle Nachrichten, die vor einer explizit bestätigten Nachricht empfangen wurden, automatisch bestätigt. Weitere Informationen finden Sie unter [Verwenden des Client-Bestätigungsmodus](#using-client-acknowledge-mode).

Die Amazon SQS Java Messaging Library stellt einen weiteren Bestätigungsmodus bereit. Wenn Sie den `UNORDERED_ACKNOWLEDGE`-Modus verwenden, müssen alle empfangenen Nachrichten unabhängig von der Empfangsreihenfolge einzeln und explizit vom Client bestätigt werden. Erstellen Sie hierzu eine Sitzung im `UNORDERED_ACKNOWLEDGE`-Modus.

```
// Create the non-transacted session with UNORDERED_ACKNOWLEDGE mode.
Session session = connection.createSession(false, SQSSession.UNORDERED_ACKNOWLEDGE);
```

Die restlichen Schritte sind identisch wie im Beispiel [Verwenden des Client-Bestätigungsmodus](#using-client-acknowledge-mode). Ein umfassendes Beispiel für einen synchronen Konsumenten im `UNORDERED_ACKNOWLEDGE`-Modus finden Sie unter `SyncMessageReceiverUnorderedAcknowledge.java`.

In diesem Beispiel sieht die Ausgabe in etwa wie folgt aus:

```
JMS Message ID:dexample-73ad-4adb-bc6c-4357example7
Received: Hello World!
Acknowledged: ID:dexample-73ad-4adb-bc6c-4357example7
```

# Verwenden des Java Message Service mit anderen Amazon SQS SQS-Clients
<a name="sqs-jms-client-with-sqs-clients"></a>

Wenn Sie den Amazon SQS Java Message Service (JMS) -Client mit dem AWS SDK verwenden, wird die Amazon SQS SQS-Nachrichtengröße auf 256 KB begrenzt. Sie können jedoch mit einem beliebigen Amazon-SQS-Client einen JMS-Anbieter erstellen. Verwenden Sie beispielsweise den JMS-Client mit der Amazon SQS Extended Client Library für Java, um eine Amazon-SQS-Nachricht zu senden, die einen Verweis auf eine Nachrichtennutzlast (bis zu 2 GB) in Amazon S3 enthält. Weitere Informationen finden Sie unter [Verwaltung großer Amazon SQS SQS-Nachrichten mit Java und Amazon S3](sqs-s3-messages.md).

Das folgende Java-Codebeispiel erstellt den JMS-Provider für die Extended Client Library.

Sehen Sie sich die Voraussetzungen unter an, [Voraussetzungen für die Arbeit mit JMS und Amazon SQS](prerequisites.md) bevor Sie dieses Beispiel testen.

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

Im folgenden Java-Codebeispiel wird die Verbindungs-Factory erstellt:

```
// 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();
```

# Funktionierende Java-Beispiele für die Verwendung von JMS mit Amazon SQS SQS-Standardwarteschlangen
<a name="sqs-jms-code-examples"></a>

Das folgende Codebeispiel veranschaulicht die Verwendung des Java Message Service (JMS) mit Amazon-SQS-Standard-Warteschlangen. Weitere Informationen zur Arbeit mit FIFO-Warteschlangen finden Sie unter [So erstellen Sie eine FIFO-Warteschlange](getting-started.md#creating-queue-FIFO), [Synchrones Senden von Nachrichten](getting-started.md#send-messages-synchronously) und [Synchrones Empfangen von Nachrichten](getting-started.md#receive-messages-synchronously). (Der synchrone Empfang von Nachrichten ist für Standard- und FIFO-Warteschlangen identisch. Nachrichten in FIFO-Warteschlangen enthalten jedoch mehr Attribute.)

Sehen Sie sich die Voraussetzungen unter an, [Voraussetzungen für die Arbeit mit JMS und Amazon SQS](prerequisites.md) bevor Sie die folgenden Beispiele testen.

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

Das folgende Codebeispiel für Java SDK v 1.x legt den Standard-Warteschlangennamen, die Region und die Anmeldeinformationen fest, die mit den anderen Java-Beispielen verwendet werden sollen.

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

Im folgenden Java-Codebeispiel wird ein Textnachrichtenproduzent erstellt.

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

Im folgenden Java-Codebeispiel wird ein synchroner Nachrichtenkonsument erstellt.

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

Im folgenden Java-Codebeispiel wird ein asynchroner Nachrichtenkonsument erstellt.

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

Im folgenden Java-Codebeispiel wird ein synchroner Konsument im Client-Bestätigungsmodus erstellt.

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

Im folgenden Java-Codebeispiel wird ein synchroner Konsument im ungeordneten Bestätigungsmodus erstellt.

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

Das folgende XML-Codebeispiel ist eine Bean-Konfigurationsdatei für [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>

Im folgenden Java-Codebeispiel wird die Bean-Konfigurationsdatei verwendet, um Ihre Objekte zu initialisieren.

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

Im folgenden Java-Codebeispiel wird geprüft, ob bereits eine Amazon-SQS-Warteschlange vorhanden ist, und gegebenenfalls eine neue Warteschlange erstellt. Außerdem ist Beispiel-Code für die Protokollierung enthalten.

```
/*
 * 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() );
        }
    }
}
```

# Von Amazon SQS unterstützte JMS 1.1-Implementierungen
<a name="supported-implementations"></a>

Die Amazon SQS Java Messaging Library unterstützt die folgenden [JMS-1.1-Implementierungen](http://docs.oracle.com/javaee/6/api/javax/jms/package-summary.html). Weitere Informationen zu den unterstützten Features und Fähigkeiten der Amazon SQS Java Messaging Library finden Sie in den [Häufig gestellten Fragen zu Amazon SQS](https://aws.amazon.com/sqs/faqs/).

## Unterstützte gängige Schnittstellen
<a name="supported-common-interfaces"></a>
+ `Connection`
+ `ConnectionFactory`
+ `Destination`
+ `Session`
+ `MessageConsumer`
+ `MessageProducer`

## Unterstützte Nachrichtentypen
<a name="supported-message-types"></a>
+ `ByteMessage`
+ `ObjectMessage`
+ `TextMessage`

## Unterstützte Nachrichtenbestätigungsmodi
<a name="supported-message-acknowledgement-modes"></a>
+ `AUTO_ACKNOWLEDGE`
+ `CLIENT_ACKNOWLEDGE`
+ `DUPS_OK_ACKNOWLEDGE`
+ `UNORDERED_ACKNOWLEDGE`

**Anmerkung**  
Der `UNORDERED_ACKNOWLEDGE`-Modus ist nicht Bestandteil der JMS 1.1-Spezifikation. Mithilfe dieses Modus kann Amazon SQS einem JMS-Client explizit die Bestätigung einer Nachricht erlauben.

## JMS-definierte Kopfzeilen und reservierte Eigenschaften
<a name="jms-defined-headers-reserved-properties"></a>

### Für den Nachrichtenversand
<a name="for-sending-messages"></a>

Beim Senden von Nachrichten können Sie die folgenden Kopfzeilen und Eigenschaften für einzelne Nachrichten festlegen:
+ `JMSXGroupID` (erforderlich für FIFO-Warteschlangen, nicht zulässig für Standard-Warteschlangen)
+ `JMS_SQS_DeduplicationId` (optional für FIFO-Warteschlangen, nicht zulässig für Standard-Warteschlangen)

Nach dem Senden von Nachrichten legt Amazon SQS die folgenden Kopfzeilen und Eigenschaften für einzelne Nachrichten fest:
+ `JMSMessageID`
+ `JMS_SQS_SequenceNumber` (nur für FIFO-Warteschlangen)

### Für den Nachrichtenempfang
<a name="for-receiving-messages"></a>

Beim Empfang von Nachrichten legt Amazon SQS die folgenden Kopfzeilen und Eigenschaften für einzelne Nachrichten fest:
+ `JMSDestination`
+ `JMSMessageID`
+ `JMSRedelivered`
+ `JMSXDeliveryCount`
+ `JMSXGroupID` (nur für FIFO-Warteschlangen)
+ `JMS_SQS_DeduplicationId` (nur für FIFO-Warteschlangen)
+ `JMS_SQS_SequenceNumber` (nur für FIFO-Warteschlangen)