Alterações no agrupamento em lotes automático de solicitações do Amazon SQS da versão 1 para a versão 2 - AWS SDK for Java 2.x
Alterações de alto nívelUsar o agrupamento em lotes automático de solicitações do SQS Diferenças de tipo de retorno assíncronoDiferenças de gerenciamento da conclusão assíncronaPrincipais parâmetros de configuração

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Alterações no agrupamento em lotes automático de solicitações do Amazon SQS da versão 1 para a versão 2

Este tópico detalha as alterações no agrupamento em lotes automático de solicitações para o Amazon SQS entre a versão 1 e a versão 2 do AWS SDK for Java.

Alterações de alto nível

O AWS SDK for Java 1.x executa o buffer do lado do cliente usando uma classe AmazonSQSBufferedAsyncClient separada que requer inicialização explícita para o agrupamento em lotes de solicitações.

O AWS SDK for Java 2.x simplifica e aprimora a funcionalidade de armazenamento em buffer com o SqsAsyncBatchManager. A implementação dessa interface fornece recursos automáticos de envio em lotes de solicitações diretamente integrados ao SqsAsyncClient padrão. Para saber mais sobre SqsAsyncBatchManager da v2, consulte o tópico Usar o agrupamento em lotes automático de solicitações para Amazon SQS com o AWS SDK for Java 2.x deste guia.

Alteração v1 v2

Dependências do Maven

 
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.amazonaws</groupId>
            <artifactId>aws-java-sdk-bom</artifactId>
            <version>1.12.7821</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
<dependencies>
    <dependency>
        <groupId>com.amazonaws</groupId>
        <artifactId>aws-java-sdk-sqs</artifactId>
    </dependency>
</dependencies>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>bom</artifactId>
            <version>2.31.152</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
<dependencies>
    <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>sqs</artifactId>
    </dependency>
</dependencies>
Nomes do pacote com.amazonaws.services.sqs.buffered software.amazon.awssdk.services.sqs.batchmanager
Nomes da classe

AmazonSQSBufferedAsyncClient

 SqsAsyncBatchManager

1 Versão mais recente. 2 Versão mais recente.

Usar o agrupamento em lotes automático de solicitações do SQS

Alteração v1 v2
Criar um gerenciador de lotes 
AmazonSQSAsync sqsAsync = new AmazonSQSAsyncClient();
AmazonSQSAsync bufferedSqs = new 
            AmazonSQSBufferedAsyncClient(sqsAsync);
 
SqsAsyncClient asyncClient = SqsAsyncClient.create();
SqsAsyncBatchManager sqsAsyncBatchManager = 
            asyncClient.batchManager();
Criar um gerenciador de lotes com configuração personalizada 
AmazonSQSAsync sqsAsync = new AmazonSQSAsyncClient();

QueueBufferConfig queueBufferConfig = new QueueBufferConfig()
        .withMaxBatchOpenMs(200)
        .withMaxBatchSize(10)
        .withMinReceiveWaitTimeMs(1000)
        .withVisibilityTimeoutSeconds(20)
        .withReceiveMessageAttributeNames(messageAttributeValues);

AmazonSQSAsync bufferedSqs = 
        new AmazonSQSBufferedAsyncClient(sqsAsync, queueBufferConfig);
 
BatchOverrideConfiguration batchOverrideConfiguration = 
    BatchOverrideConfiguration.builder()
        .sendRequestFrequency(Duration.ofMillis(200))
        .maxBatchSize(10)
        .receiveMessageMinWaitDuration(Duration.ofMillis(1000))
        .receiveMessageVisibilityTimeout(Duration.ofSeconds(20))
        .receiveMessageSystemAttributeNames(messageSystemAttributeNames)
        .receiveMessageAttributeNames(messageAttributeValues)
        .build();

SqsAsyncBatchManager sqsAsyncBatchManager = SqsAsyncBatchManager.builder()
        .overrideConfiguration(batchOverrideConfiguration)
        .client(SqsAsyncClient.create())
        .scheduledExecutor(Executors.newScheduledThreadPool(8))
        .build();
Enviar mensagens 
Future<SendMessageResult> sendResultFuture = 
        bufferedSqs.sendMessageAsync(new SendMessageRequest()
                .withQueueUrl(queueUrl)
                .withMessageBody(body));
 
CompletableFuture<SendMessageResponse> sendCompletableFuture = 
        sqsAsyncBatchManager.sendMessage(
                SendMessageRequest.builder()
                        .queueUrl(queueUrl)
                        .messageBody(body)
                        .build());
Exclua mensagens 
Future<DeleteMessageResult> deletResultFuture =
        bufferedSqs.deleteMessageAsync(new DeleteMessageRequest()
                .withQueueUrl(queueUrl));
 
CompletableFuture<DeleteMessageResponse> deleteResultCompletableFuture
        = sqsAsyncBatchManager.deleteMessage(
                DeleteMessageRequest.builder()
                        .queueUrl(queueUrl)
                        .build());
Alterar a visibilidade das mensagens 
Future<ChangeMessageVisibilityResult> changeVisibilityResultFuture =
        bufferedSqs.changeMessageVisibilityAsync
                (new ChangeMessageVisibilityRequest()
                        .withQueueUrl(queueUrl)
                        .withVisibilityTimeout(20));
 
CompletableFuture<ChangeMessageVisibilityResponse> changeResponseCompletableFuture
        = sqsAsyncBatchManager.changeMessageVisibility(
                ChangeMessageVisibilityRequest.builder()
                        .queueUrl(queueUrl)
                        .visibilityTimeout(20)
                        .build());
Receber mensagens 
ReceiveMessageResult receiveResult =
        bufferedSqs.receiveMessage(
                new ReceiveMessageRequest()
                        .withQueueUrl(queueUrl));
 
CompletableFuture<ReceiveMessageResponse> 
        responseCompletableFuture = sqsAsyncBatchManager.receiveMessage(
                ReceiveMessageRequest.builder()
                        .queueUrl(queueUrl)
                        .build());

Diferenças de tipo de retorno assíncrono

Alteração v1 v2
Tipo de retorno Future<ResultType> CompletableFuture<ResponseType>
Mecanismo de retorno de chamada Requer um AsyncHandler com métodos onSuccess e onError separados Usar APIs CompletableFuture fornecidas pelo JDK, como whenComplete(), thenCompose() e thenApply()
Gerenciamento de exceções Use o método AsyncHandler#onError() Usar APIs CompletableFuture fornecidas pelo JDK, como exceptionally(), handle() ou whenComplete()
Cancelamento Suporte básico por meio de Future.cancel() O cancelamento de um CompletableFuture principal cancela automaticamente todos os futuros secundários na cadeia

Diferenças de gerenciamento da conclusão assíncrona

Alteração v1 v2
Implementação do gerenciador de resposta 
Future<ReceiveMessageResult> future = bufferedSqs.receiveMessageAsync(
        receiveRequest,
        new AsyncHandler<ReceiveMessageRequest, ReceiveMessageResult>() {
            @Override
            public void onSuccess(ReceiveMessageRequest request, 
                              ReceiveMessageResult result) {
                List<Message> messages = result.getMessages();
                System.out.println("Received " + messages.size() + " messages");
                for (Message message : messages) {
                    System.out.println("Message ID: " + message.getMessageId());
                    System.out.println("Body: " + message.getBody());
                }
            }

            @Override
            public void onError(Exception e) {
                System.err.println("Error receiving messages: " + e.getMessage());
                e.printStackTrace();
            }
        }
);
 
CompletableFuture<ReceiveMessageResponse> completableFuture = sqsAsyncBatchManager
               .receiveMessage(ReceiveMessageRequest.builder()
               .queueUrl(queueUrl).build())
        .whenComplete((receiveMessageResponse, throwable) -> {
            if (throwable != null) {
                System.err.println("Error receiving messages: " + throwable.getMessage());
                throwable.printStackTrace();
            } else {
                List<Message> messages = receiveMessageResponse.messages();
                System.out.println("Received " + messages.size() + " messages");
                for (Message message : messages) {
                    System.out.println("Message ID: " + message.messageId());
                    System.out.println("Body: " + message.body());
                }
            }
        });

Principais parâmetros de configuração

Parameter v1 v2
Tamanho máximo do lote maxBatchSize (padrão de 10 solicitações por lote) maxBatchSize (padrão de 10 solicitações por lote)
Tempo de espera do lote maxBatchOpenMs (padrão de 200 ms) sendRequestFrequency (padrão de 200 ms)
Tempo limite de visibilidade visibilityTimeoutSeconds (-1 para a fila padrão) receiveMessageVisibilityTimeout (fila padrão)
Tempo mínimo de espera longPollWaitTimeoutSeconds (20 s quando longPoll é verdadeiro) receiveMessageMinWaitDuration (padrão de 50 ms)
Atributos de mensagens Definir usando ReceiveMessageRequest receiveMessageAttributeNames (nenhum por padrão)
Atributos do sistema Definir usando ReceiveMessageRequest receiveMessageSystemAttributeNames (nenhum por padrão)
Sondagem longa longPoll (o padrão é verdadeiro) Não há suporte para evitar conexões abertas aguardando até o servidor enviar as mensagens
Tempo máximo de espera para pesquisas longas longPollWaitTimeoutSeconds (padrão de 20 s) Não há suporte para evitar conexões abertas aguardando até o servidor enviar as mensagens
O número máximo de lotes de recebimento pré-obtidos armazenados no lado do cliente. maxDoneReceiveBatches (10 lotes) Incompatível porque é gerenciado internamente
Número máximo de lotes de saída ativos processados simultaneamente maxInflightOutboundBatches (padrão de 5 lotes) Incompatível porque é gerenciado internamente
Número máximo de lotes de recebimento ativos processados simultaneamente maxInflightReceiveBatches (padrão de 10 lotes) Incompatível porque é gerenciado internamente