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.
# Aktivierung der clientseitigen Pufferung und der Batchverarbeitung von Anfragen mit Amazon SQS
[AWS SDK für Java](https://aws.amazon.com/sdkforjava/) enthält den `AmazonSQSBufferedAsyncClient`, der auf Amazon SQS zugreift. Dieser Client ermöglicht eine einfache Batchverarbeitung von Anfragen mithilfe der clientseitigen Pufferung. Aufrufe vom Client werden zuerst gepuffert und dann als Batch-Anfrage an Amazon SQS gesendet.
Mit der clientseitigen Pufferung können bis zu 10 Anforderungen zwischengespeichert und als Stapelanforderung gesendet werden. Dadurch werden Ihre Kosten für die Verwendung von Amazon SQS gesenkt und die Anzahl der gesendeten Anforderungen verringert. `AmazonSQSBufferedAsyncClient` puffert synchrone und asynchrone Aufrufe. Als Stapel verarbeitete Anforderungen und die Unterstützung für [langes Abrufen](sqs-short-and-long-polling.md) können ebenfalls zu einem erhöhten Durchsatz beitragen. Weitere Informationen finden Sie unter [Steigerung des Durchsatzes durch horizontale Skalierung und Action-Batching mit Amazon SQS](sqs-throughput-horizontal-scaling-and-batching.md).
Da `AmazonSQSBufferedAsyncClient` die gleiche Schnittstelle implementiert wie `AmazonSQSAsyncClient`, sollte die Migration von `AmazonSQSAsyncClient` zu `AmazonSQSBufferedAsyncClient` in der Regel lediglich minimale Änderungen an Ihrem vorhandenen Code erfordern.
**Anmerkung**
Der Amazon SQS Buffered Asynchronous Client unterstützt derzeit keine FIFO-Warteschlangen.
## Amazon verwenden SQSBuffered AsyncClient
Bevor Sie beginnen, führen Sie die Schritte in [Einrichten von Amazon SQS](sqs-setting-up.md) aus.
### AWS SDK for Java 1.x
Für AWS SDK for Java 1.x können Sie ein neues erstellen, das auf dem folgenden Beispiel `AmazonSQSBufferedAsyncClient` basiert:
```
// Create the basic Amazon SQS async client
final AmazonSQSAsync sqsAsync = new AmazonSQSAsyncClient();
// Create the buffered client
final AmazonSQSAsync bufferedSqs = new AmazonSQSBufferedAsyncClient(sqsAsync);
```
Nachdem Sie den neuen `AmazonSQSBufferedAsyncClient` erstellt haben, können Sie ihn verwenden, um mehrere Anforderungen an Amazon SQS zu senden (wie mit dem `AmazonSQSAsyncClient`), beispielsweise:
```
final CreateQueueRequest createRequest = new CreateQueueRequest().withQueueName("MyQueue");
final CreateQueueResult res = bufferedSqs.createQueue(createRequest);
final SendMessageRequest request = new SendMessageRequest();
final String body = "Your message text" + System.currentTimeMillis();
request.setMessageBody( body );
request.setQueueUrl(res.getQueueUrl());
final Future sendResult = bufferedSqs.sendMessageAsync(request);
final ReceiveMessageRequest receiveRq = new ReceiveMessageRequest()
.withMaxNumberOfMessages(1)
.withQueueUrl(queueUrl);
final ReceiveMessageResult rx = bufferedSqs.receiveMessage(receiveRq);
```
### Amazon konfigurieren SQSBuffered AsyncClient
`AmazonSQSBufferedAsyncClient` ist mit Einstellungen vorkonfiguriert, die für die meisten Anwendungsfälle verwendet werden können. Sie können `AmazonSQSBufferedAsyncClient` weiter konfigurieren, z. B.:
1. Erstellen Sie eine Instance der Klasse `QueueBufferConfig` mit den erforderlichen Konfigurationsparametern.
1. Stellen Sie die Instance dem `AmazonSQSBufferedAsyncClient`-Konstruktor zur Verfügung.
```
// Create the basic Amazon SQS async client
final AmazonSQSAsync sqsAsync = new AmazonSQSAsyncClient();
final QueueBufferConfig config = new QueueBufferConfig()
.withMaxInflightReceiveBatches(5)
.withMaxDoneReceiveBatches(15);
// Create the buffered client
final AmazonSQSAsync bufferedSqs = new AmazonSQSBufferedAsyncClient(sqsAsync, config);
```
**QueueBufferConfig Konfigurationsparameter**
| Parameter | Standardwert | Description |
| --- | --- | --- |
| longPoll | true | Wenn `longPoll` auf `true` festgelegt ist, versucht `AmazonSQSBufferedAsyncClient`, Nachrichten durch langes Abrufen abzurufen. |
| longPollWaitTimeoutSeconds | 20 s | Die maximale Dauer (in Sekunden), die ein `ReceiveMessage`-Aufruf beim Warten auf das Auftauchen von Nachrichten in der Warteschlange auf dem Server blockiert wird, bevor er mit einem leeren Empfangsergebnis zurückkehrt. Wenn langes Abrufen deaktiviert ist, hat diese Einstellung hat keine Auswirkungen. |
| maxBatchOpenMs | 200 ms | Die maximale Dauer (in Millisekunden), die ein ausgehender Aufruf auf andere Aufrufe desselben Typs wartet, mit denen er Nachrichten desselben Typs zu einem Stapel zusammenfasst. Je höher die Einstellung, desto weniger Stapel sind erforderlich, um dieselbe Anzahl an Aufgaben auszuführen (der erste Aufruf eines Stapels muss jedoch länger in der Warteschlange warten). Wenn Sie diesen Parameter auf `0` einstellen, warten gesendete Anforderungen nicht auf andere Anforderungen, wodurch die Stapelverarbeitung effektiv deaktiviert wird. |
| maxBatchSize | 10 Anforderungen pro Stapel | Die maximale Anzahl von Nachrichten, die in einer einzelnen Stapelanforderung zusammengefasst werden. Je höher die Einstellung, desto weniger Stapel müssen die gleiche Anzahl von Anforderungen ausführen. 10 Anforderungen pro Stapel ist der maximal zulässige Wert für Amazon SQS. |
| maxBatchSizeBytes | 1 MiB | Die maximale Größe eines Nachrichtenstapels in Bytes, die der Client versucht, an Amazon SQS zu senden. 1 MiB ist der maximal zulässige Wert für Amazon SQS. |
| maxDoneReceiveBatches | 10 Stapel | Die maximale Anzahl von Empfangsstapeln, die `AmazonSQSBufferedAsyncClient` vorab abruft und clientseitig speichert. Je höher die Einstellung, desto mehr Empfangsanforderungen können erfüllt werden, ohne dass ein Aufruf an Amazon SQS gestartet werden muss (je mehr Nachrichten jedoch vorab abgerufen werden, desto länger bleiben sie im Puffer, was bedeutet, dass deren Zeitbeschränkung für die Sichtbarkeit abläuft). `0`gibt an, dass der gesamte Vorabruf von Nachrichten deaktiviert ist und Nachrichten nur bei Bedarf abgerufen werden. |
| maxInflightOutboundBatches | 5 Stapel | Die maximale Anzahl der aktiven ausgehenden Stapel, die gleichzeitig verarbeitet werden können. Je höher die Einstellung, desto schneller können ausgehende Stapel gesendet werden (in Abhängigkeit von anderen Kontingenten, z. B. durch CPU oder Bandbreite) und desto mehr Threads werden von `AmazonSQSBufferedAsyncClient` verbraucht. |
| maxInflightReceiveBatches | 10 Stapel | Die maximale Anzahl der aktiven Empfangsstapel, die gleichzeitig verarbeitet werden können. Je höher die Einstellung, desto mehr Nachrichten können empfangen werden (in Abhängigkeit von anderen Kontingenten, z. B. durch CPU oder Bandbreite) und desto mehr Threads werden von `AmazonSQSBufferedAsyncClient` verbraucht. `0`gibt an, dass der gesamte Vorabruf von Nachrichten deaktiviert ist und Nachrichten nur bei Bedarf abgerufen werden. |
| visibilityTimeoutSeconds | -1 | Wenn dieser Parameter auf einen positiven Wert ungleich null festgelegt ist, überschreibt die hier festgelegte Zeitbeschränkung für die Sichtbarkeit diejenige, die für die Warteschlange festgelegt ist, über die Nachrichten abgerufen werden. `-1` gibt an, dass die Standardeinstellung für die Warteschlange ausgewählt ist. Sie können als Zeitbeschränkung für die Sichtbarkeit nicht `0` festlegen. |
### AWS SDK for Java 2.x
Für AWS SDK for Java 2.x können Sie ein neues erstellen, das auf dem folgenden Beispiel `SqsAsyncBatchManager` basiert:
```
// Create the basic Sqs Async Client
SqsAsyncClient sqs = SqsAsyncClient.builder()
.region(Region.US_EAST_1)
.build();
// Create the batch manager
SqsAsyncBatchManager sqsAsyncBatchManager = sqs.batchManager();
```
Nachdem Sie den neuen `SqsAsyncBatchManager` erstellt haben, können Sie ihn verwenden, um mehrere Anforderungen an Amazon SQS zu senden (wie mit dem `SqsAsyncClient`), beispielsweise:
```
final String queueName = "MyAsyncBufferedQueue" + UUID.randomUUID();
final CreateQueueRequest request = CreateQueueRequest.builder().queueName(queueName).build();
final String queueUrl = sqs.createQueue(request).join().queueUrl();
System.out.println("Queue created: " + queueUrl);
// Send messages
CompletableFuture sendMessageFuture;
for (int i = 0; i < 10; i++) {
final int index = i;
sendMessageFuture = sqsAsyncBatchManager.sendMessage(
r -> r.messageBody("Message " + index).queueUrl(queueUrl));
SendMessageResponse response= sendMessageFuture.join();
System.out.println("Message " + response.messageId() + " sent!");
}
// Receive messages with customized configurations
CompletableFuture receiveResponseFuture = customizedBatchManager.receiveMessage(
r -> r.queueUrl(queueUrl)
.waitTimeSeconds(10)
.visibilityTimeout(20)
.maxNumberOfMessages(10)
);
System.out.println("You have received " + receiveResponseFuture.join().messages().size() + " messages in total.");
// Delete messages
DeleteQueueRequest deleteQueueRequest = DeleteQueueRequest.builder().queueUrl(queueUrl).build();
int code = sqs.deleteQueue(deleteQueueRequest).join().sdkHttpResponse().statusCode();
System.out.println("Queue is deleted, with statusCode " + code);
```
### Konfiguration SqsAsyncBatchManager
`SqsAsyncBatchManager` ist mit Einstellungen vorkonfiguriert, die für die meisten Anwendungsfälle verwendet werden können. Sie können `SqsAsyncBatchManager` weiter konfigurieren, z. B.:
Erstellen einer benutzerdefinierten Konfiguration über`SqsAsyncBatchManager.Builder`:
```
SqsAsyncBatchManager customizedBatchManager = SqsAsyncBatchManager.builder()
.client(sqs)
.scheduledExecutor(Executors.newScheduledThreadPool(5))
.overrideConfiguration(b -> b
.maxBatchSize(10)
.sendRequestFrequency(Duration.ofMillis(200))
.receiveMessageMinWaitDuration(Duration.ofSeconds(10))
.receiveMessageVisibilityTimeout(Duration.ofSeconds(20))
.receiveMessageAttributeNames(Collections.singletonList("*"))
.receiveMessageSystemAttributeNames(Collections.singletonList(MessageSystemAttributeName.ALL)))
.build();
```
**`BatchOverrideConfiguration`-Parameter**
| Parameter | Standardwert | Description |
| --- | --- | --- |
| maxBatchSize | 10 Anforderungen pro Stapel | Die maximale Anzahl von Nachrichten, die in einer einzelnen Stapelanforderung zusammengefasst werden. Je höher die Einstellung, desto weniger Stapel müssen die gleiche Anzahl von Anforderungen ausführen. Der zulässige Höchstwert für Amazon SQS beträgt 10 Anfragen pro Stapel. |
| sendRequestFrequency | 200 ms | Die maximale Dauer (in Millisekunden), die ein ausgehender Aufruf auf andere Aufrufe desselben Typs wartet, mit denen er Nachrichten desselben Typs zu einem Stapel zusammenfasst. Je höher die Einstellung, desto weniger Stapel sind erforderlich, um dieselbe Anzahl an Aufgaben auszuführen (der erste Aufruf eines Stapels muss jedoch länger in der Warteschlange warten). Wenn Sie diesen Parameter auf `0` einstellen, warten gesendete Anforderungen nicht auf andere Anforderungen, wodurch die Stapelverarbeitung effektiv deaktiviert wird. |
| receiveMessageVisibilityTimeout | -1 | Wenn dieser Parameter auf einen positiven Wert ungleich null festgelegt ist, überschreibt die hier festgelegte Zeitbeschränkung für die Sichtbarkeit diejenige, die für die Warteschlange festgelegt ist, über die Nachrichten abgerufen werden. `1` gibt an, dass die Standardeinstellung für die Warteschlange ausgewählt ist. Sie können als Zeitbeschränkung für die Sichtbarkeit nicht `0` festlegen. |
| receiveMessageMinWaitDuration | 50 ms | Die Mindestzeit (in Millisekunden), die ein `receiveMessage` Anruf darauf wartet, dass verfügbare Nachrichten abgerufen werden. Je höher die Einstellung, desto weniger Batches sind erforderlich, um dieselbe Anzahl von Anfragen auszuführen. |