Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Abilitazione del buffering lato client e del batching delle richieste con Amazon SQS

AWS SDK per Java include AmazonSQSBufferedAsyncClient che accede ad Amazon SQS. Questo client consente un semplice raggruppamento delle richieste utilizzando il buffering lato client. Le chiamate effettuate dal client vengono prima memorizzate nel buffer e quindi inviate come richiesta batch ad Amazon SQS.

Il buffering lato client consente di memorizzare e inviare fino a 10 richieste in batch, riducendo il costo di utilizzo di Amazon SQS e il numero di richieste inviate. AmazonSQSBufferedAsyncClient effettua il buffering delle chiamate sincrone e asincrone. Le richieste in batch e il supporto per il polling lungo possono inoltre contribuire ad aumentare il throughput. Per ulteriori informazioni, consulta Aumento del throughput utilizzando la scalabilità orizzontale e l'action batching con Amazon SQS.

Poiché AmazonSQSBufferedAsyncClient implementa la stessa interfaccia di AmazonSQSAsyncClient, la migrazione da AmazonSQSAsyncClient a AmazonSQSBufferedAsyncClient di solito richiede solo modifiche minime al codice esistente.

Usare Amazon SQSBuffered AsyncClient

Prima di iniziare, completa i passaggi descritti in Configurazione di Amazon SQS.

AWS SDK per Java 1.x

Per AWS SDK for Java 1.x, puoi crearne uno AmazonSQSBufferedAsyncClient nuovo basato sul seguente esempio:

// Create the basic Amazon SQS async client
final AmazonSQSAsync sqsAsync = new AmazonSQSAsyncClient();
 
// Create the buffered client
final AmazonSQSAsync bufferedSqs = new AmazonSQSBufferedAsyncClient(sqsAsync);

Una volta creato il nuovo AmazonSQSBufferedAsyncClient, è possibile utilizzarlo per l'invio di più richieste ad Amazon SQS; (proprio come con AmazonSQSAsyncClient), ad esempio:

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<SendMessageResult> sendResult = bufferedSqs.sendMessageAsync(request);
 
final ReceiveMessageRequest receiveRq = new ReceiveMessageRequest()
    .withMaxNumberOfMessages(1)
    .withQueueUrl(queueUrl);
final ReceiveMessageResult rx = bufferedSqs.receiveMessage(receiveRq);

Configurazione di Amazon SQSBuffered AsyncClient

AmazonSQSBufferedAsyncClient è preconfigurato con impostazioni che funzionano per la maggior parte dei casi d'uso. È possibile configurare ulteriormente AmazonSQSBufferedAsyncClient, ad esempio:

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

AWS SDK per Java 2.x

Per AWS SDK for Java 2.x, puoi crearne uno SqsAsyncBatchManager nuovo basato sul seguente esempio:

// Create the basic Sqs Async Client
SqsAsyncClient sqs = SqsAsyncClient.builder() 
    .region(Region.US_EAST_1) 
    .build();

// Create the batch manager
SqsAsyncBatchManager sqsAsyncBatchManager = sqs.batchManager();

Una volta creato il nuovo SqsAsyncBatchManager, è possibile utilizzarlo per l'invio di più richieste ad Amazon SQS; (proprio come con SqsAsyncClient), ad esempio:

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<SendMessageResponse> 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<ReceiveMessageResponse> 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);

Configurazione di SqsAsyncBatchManager

SqsAsyncBatchManager è preconfigurato con impostazioni che funzionano per la maggior parte dei casi d'uso. È possibile configurare ulteriormente SqsAsyncBatchManager, ad esempio:

Creazione di una configurazione personalizzata tramite: 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();