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 der Amazon SQS Java Messaging-Bibliothek
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
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
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
```
// 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
```
// Get the wrapped client
AmazonSQSMessagingClientWrapper client = connection.getWrappedAmazonSQSClient();
// Create an Amazon SQS FIFO queue named MyQueue.fifo, if it doesn't already exist
if (!client.queueExists("MyQueue.fifo")) {
Map attributes = new HashMap();
attributes.put("FifoQueue", "true");
attributes.put("ContentBasedDeduplication", "true");
client.createQueue(new CreateQueueRequest().withQueueName("MyQueue.fifo").withAttributes(attributes));
}
```
**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
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
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
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
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
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
```