records = s3EventNotification.getRecords();
S3EventNotificationRecord record = records.stream().findFirst();
// Use getters on the record to access individual attributes.
String awsRegion = record.getAwsRegion();
String eventName = record.getEventName();
String eventSource = record.getEventSource();
}
}
```
Neste exemplo, o método `fromJson` converte a string JSON em um objeto `S3EventNotification`. Os campos ausentes na string JSON resultarão em valores `null` nos campos do objeto Java correspondentes e os campos extras no JSON serão ignorados.
Outros APIs para um registro de notificação de eventos podem ser encontrados na referência da API para`[S3EventNotificationRecord](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/eventnotifications/s3/model/S3EventNotificationRecord.html)`.
#### Converter uma instância `S3EventNotification` em uma string JSON
Use o método `toJson` (ou `toJsonPretty`) para converter um objeto `S3EventNotification` em uma string JSON, conforme mostrado no exemplo a seguir.
```
import software.amazon.awssdk.eventnotifications.s3.model.S3EventNotification
public class S3EventNotificationExample {
...
void toJsonString(S3EventNotification event) {
String json = event.toJson();
String jsonPretty = event.toJsonPretty();
System.out.println("JSON: " + json);
System.out.println("Pretty JSON: " + jsonPretty);
}
}
```
Os campos para `GlacierEventData`, `ReplicationEventData`, `IntelligentTieringEventData` e `LifecycleEventData` serão excluídos do JSON se forem `null`. Outros campos `null` serão serializados como `null`.
Veja a seguir um exemplo de saída do método `toJsonPretty` para um evento de marcação de objetos do S3.
```
{
"Records" : [ {
"eventVersion" : "2.3",
"eventSource" : "aws:s3",
"awsRegion" : "us-east-1",
"eventTime" : "2024-07-19T20:09:18.551Z",
"eventName" : "ObjectTagging:Put",
"userIdentity" : {
"principalId" : "AWS:XXXXXXXXXXX"
},
"requestParameters" : {
"sourceIPAddress" : "XXX.XX.XX.XX"
},
"responseElements" : {
"x-amz-request-id" : "XXXXXXXXXXXX",
"x-amz-id-2" : "XXXXXXXXXXXXX"
},
"s3" : {
"s3SchemaVersion" : "1.0",
"configurationId" : "XXXXXXXXXXXXX",
"bucket" : {
"name" : "amzn-s3-demo-bucket",
"ownerIdentity" : {
"principalId" : "XXXXXXXXXXX"
},
"arn" : "arn:aws:s3:::XXXXXXXXXX"
},
"object" : {
"key" : "akey",
"size" : null,
"eTag" : "XXXXXXXXXX",
"versionId" : null,
"sequencer" : null
}
}
} ]
}
```
Um [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/75c3daadf750406156fc87fa30ee499a206b4a36/javav2/example_code/s3/src/main/java/com/example/s3/ProcessS3EventNotification.java#L117) está disponível em GitHub que mostra como usar a API para trabalhar com notificações recebidas por uma fila do Amazon SQS.
## Processe eventos do S3 no Lambda com bibliotecas Java: e AWS SDK for Java 2.x `aws-lambda-java-events`
Em vez de usar o SDK for Java 2.x para processar notificações de eventos do Amazon S3 em uma função Lambda, você pode usar a biblioteca na versão 3.x.x. `[aws-lambda-java-events](https://github.com/aws/aws-lambda-java-libs/tree/main/aws-lambda-java-events)` AWS mantém a `aws-lambda-java-events` biblioteca de forma independente e tem seus próprios requisitos de dependência. A biblioteca `aws-lambda-java-events` funciona somente com eventos do S3 nas funções do Lambda, enquanto o SDK para Java 2.x funciona com eventos do S3 nas funções do Lambda, Amazon SNS e Amazon SQS.
Ambas as abordagens modelam a carga útil de notificação de eventos JSON de forma orientada a objetos e similares. APIs A tabela a seguir mostra as diferenças notáveis entre o uso das duas abordagens.
****
| | AWS SDK para Java | aws-lambda-java-events biblioteca |
| --- | --- | --- |
| Nomeação do pacote | `software.amazon.awssdk.eventnotifications.s3.model.S3EventNotification` | com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification |
| Parâmetro RequestHandler | Escreva a implementação `RequestHandler` da função do Lambda para receber uma string JSON: import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import software.amazon.awssdk.eventnotifications.s3.model.S3EventNotification;
public class Handler implements RequestHandler {
@Override
public String handleRequest(String jsonS3Event, Context context) {
S3EventNotification s3Event = S3EventNotification
.fromJson(jsonS3Event);
// Work with the s3Event object.
...
}
}
| Escreva a implementação RequestHandler da função do Lambda para receber um objeto S3Event:import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.S3Event;
public class Handler implements RequestHandler {
@Override
public String handleRequest(S3Event s3event, Context context) {
// Work with the s3Event object.
...
}
}
|
| Dependências do Maven |
software.amazon.awssdk
bom
2.X.X
pom
import
software.amazon.awssdk
s3-event-notifications
|
software.amazon.awssdk
bom
2.X.X
pom
import
com.amazonaws
aws-lambda-java-core
1.2.3
com.amazonaws
aws-lambda-java-events
3.15.0
|
# Trabalhe com de Amazon Simple Notification Service
Com o Amazon Simple Notification Service, é possível enviar facilmente mensagens de notificação em tempo real dos aplicativos aos assinantes em vários canais de comunicação. Este tópico descreve como executar algumas das funções básicas do Amazon SNS.
## Criar um tópico
Um **tópico** é um agrupamento lógico de canais de comunicação que define para quais sistemas enviar uma mensagem, por exemplo, espalhando uma mensagem do AWS Lambda e um webhook HTTP. Você envia mensagens para o Amazon SNS, e elas são distribuídas para os canais definidos no tópico. Isso disponibiliza as mensagens para os assinantes.
Para criar um tópico, primeiro compile um objeto [CreateTopicRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/CreateTopicRequest.html) com o nome do conjunto de tópicos usando o método `name()` no compilador. Envie o objeto de solicitação para o Amazon SNS usando o método `createTopic()` do [SnsClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/SnsClient.html). É possível capturar o resultado dessa solicitação como um objeto [CreateTopicResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/CreateTopicResponse.html), conforme demonstrado no trecho de código a seguir.
**Importações**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.CreateTopicRequest;
import software.amazon.awssdk.services.sns.model.CreateTopicResponse;
import software.amazon.awssdk.services.sns.model.SnsException;
```
**Código da**
```
public static String createSNSTopic(SnsClient snsClient, String topicName ) {
CreateTopicResponse result = null;
try {
CreateTopicRequest request = CreateTopicRequest.builder()
.name(topicName)
.build();
result = snsClient.createTopic(request);
return result.topicArn();
} catch (SnsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
return "";
}
```
Veja o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/CreateTopic.java) no GitHub.
## Listar seus tópicos do Amazon SNS
Para recuperar uma lista dos tópicos existentes do Amazon SNS, compile um objeto [ListTopicsRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/ListTopicsRequest.html). Envie o objeto de solicitação para o Amazon SNS usando o método `listTopics()` do `SnsClient`. É possível capturar o resultado dessa solicitação como um objeto [ListTopicsResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/ListTopicsResponse.html).
O trecho de código a seguir imprime o código de status HTTP da solicitação e uma lista de nomes de recurso da Amazon (ARNs) para os tópicos do Amazon SNS.
**Importações**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.ListTopicsRequest;
import software.amazon.awssdk.services.sns.model.ListTopicsResponse;
import software.amazon.awssdk.services.sns.model.SnsException;
```
**Código da**
```
public static void listSNSTopics(SnsClient snsClient) {
try {
ListTopicsRequest request = ListTopicsRequest.builder()
.build();
ListTopicsResponse result = snsClient.listTopics(request);
System.out.println("Status was " + result.sdkHttpResponse().statusCode() + "\n\nTopics\n\n" + result.topics());
} catch (SnsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
```
Veja o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/ListTopics.java) no GitHub.
## Inscrever um endpoint em um tópico
Depois de criar um tópico, é possível configurar quais canais de comunicação serão endpoints para esse tópico. As mensagens são distribuídas para esses endpoints após o Amazon SNS recebê-las.
Para configurar um canal de comunicação como um endpoint para um tópico, inscreva esse endpoint no tópico. Para iniciar, compile um objeto [SubscribeRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/SubscribeRequest.html). Especifique o canal de comunicação (por exemplo, `lambda` ou `email`) como `protocol()`. Defina o `endpoint()` como o local de saída relevante (por exemplo, o ARN de uma função do Lambda ou um endereço de e-mail) e defina o ARN do tópico ao qual você deseja se inscrever como `topicArn()`. Envie o objeto de solicitação para o Amazon SNS usando o método `subscribe()` do `SnsClient`. É possível capturar o resultado dessa solicitação como um objeto [SubscribeResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/SubscribeResponse.html).
O trecho de código a seguir mostra como inscrever um endereço de e-mail em um tópico.
**Importações**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.SnsException;
import software.amazon.awssdk.services.sns.model.SubscribeRequest;
import software.amazon.awssdk.services.sns.model.SubscribeResponse;
```
**Código da**
```
public static void subEmail(SnsClient snsClient, String topicArn, String email) {
try {
SubscribeRequest request = SubscribeRequest.builder()
.protocol("email")
.endpoint(email)
.returnSubscriptionArn(true)
.topicArn(topicArn)
.build();
SubscribeResponse result = snsClient.subscribe(request);
System.out.println("Subscription ARN: " + result.subscriptionArn() + "\n\n Status is " + result.sdkHttpResponse().statusCode());
} catch (SnsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
```
Veja o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/SubscribeEmail.java) no GitHub.
## Publicar uma mensagem em um tópico
Depois de ter um tópico e um ou mais endpoints configurados para ele, será possível publicar uma mensagem nele. Para iniciar, compile um objeto [PublishRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/PublishRequest.html). Especifique a `message()` a ser enviada e o ARN do tópico (`topicArn()`) para o qual enviá-la. Envie o objeto de solicitação para o Amazon SNS usando o método `publish()` do `SnsClient`. É possível capturar o resultado dessa solicitação como um objeto [PublishResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/PublishResponse.html).
**Importações**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.PublishRequest;
import software.amazon.awssdk.services.sns.model.PublishResponse;
import software.amazon.awssdk.services.sns.model.SnsException;
```
**Código da**
```
public static void pubTopic(SnsClient snsClient, String message, String topicArn) {
try {
PublishRequest request = PublishRequest.builder()
.message(message)
.topicArn(topicArn)
.build();
PublishResponse result = snsClient.publish(request);
System.out.println(result.messageId() + " Message sent. Status is " + result.sdkHttpResponse().statusCode());
} catch (SnsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
```
Veja o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/PublishTopic.java) no GitHub.
## Cancelar a inscrição de um endpoint de um tópico
Você pode remover os canais de comunicação configurados como endpoints de um tópico. Depois de fazer isso, o tópico em si continua a existir e distribuir mensagens para quaisquer endpoints finais configurados para esse tópico.
Para remover um canal de comunicação como um endpoint de um tópico, cancele a inscrição desse endpoint do tópico. Para começar, compile um objeto [UnsubscribeRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/UnsubscribeRequest.html) e defina o ARN do tópico do qual você deseja cancelar a inscrição como o `subscriptionArn()`. Envie o objeto de solicitação para o SNS usando o método `unsubscribe()` do `SnsClient`. É possível capturar o resultado dessa solicitação como um objeto [UnsubscribeResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/UnsubscribeResponse.html).
**Importações**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.SnsException;
import software.amazon.awssdk.services.sns.model.UnsubscribeRequest;
import software.amazon.awssdk.services.sns.model.UnsubscribeResponse;
```
**Código da**
```
public static void unSub(SnsClient snsClient, String subscriptionArn) {
try {
UnsubscribeRequest request = UnsubscribeRequest.builder()
.subscriptionArn(subscriptionArn)
.build();
UnsubscribeResponse result = snsClient.unsubscribe(request);
System.out.println("\n\nStatus was " + result.sdkHttpResponse().statusCode()
+ "\n\nSubscription was removed for " + request.subscriptionArn());
} catch (SnsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
```
Veja o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/Unsubscribe.java) no GitHub.
## Excluir um tópico
Para excluir um tópico do Amazon SNS, primeiro compile um objeto [DeleteTopicRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/DeleteTopicRequest.html) com o ARN do tópico definido como o método `topicArn()` no compilador. Envie o objeto de solicitação para o Amazon SNS usando o método `deleteTopic()` do `SnsClient`. É possível capturar o resultado dessa solicitação como um objeto [DeleteTopicResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/DeleteTopicResponse.html), conforme demonstrado no trecho de código a seguir.
**Importações**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.DeleteTopicRequest;
import software.amazon.awssdk.services.sns.model.DeleteTopicResponse;
import software.amazon.awssdk.services.sns.model.SnsException;
```
**Código da**
```
public static void deleteSNSTopic(SnsClient snsClient, String topicArn ) {
try {
DeleteTopicRequest request = DeleteTopicRequest.builder()
.topicArn(topicArn)
.build();
DeleteTopicResponse result = snsClient.deleteTopic(request);
System.out.println("\n\nStatus was " + result.sdkHttpResponse().statusCode());
} catch (SnsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
```
Veja o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/DeleteTopic.java) no GitHub.
Para obter mais informações, consulte o [Guia do desenvolvedor do Amazon Simple Notification Service](https://docs.aws.amazon.com/sns/latest/dg/).
# Trabalhe com de Amazon Simple Queue Service
Esta seção apresenta exemplos de como programar o [Amazon Simple Queue Service](https://docs.aws.amazon.com/sqs/) usando o AWS SDK para Java 2.x.
Os exemplos a seguir incluem somente o código necessário para demonstrar cada técnica. O [código de exemplo completo está disponível no GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2). A partir daí, você pode fazer download de um único arquivo de origem ou clonar o repositório de maneira local para obter todos os exemplos para compilação e execução.
**Topics**
+ [Usar o agrupamento em lotes automático de solicitações](sqs-auto-batch.md)
+ [Operações de fila](examples-sqs-message-queues.md)
+ [Operações de mensagens](examples-sqs-messages.md)
# Use o agrupamento automático de solicitações para o Amazon SQS com o AWS SDK for Java 2.x
A API de agrupamento em lotes automáticos de solicitações para Amazon SQS é uma biblioteca de alto nível que fornece uma maneira eficiente de agrupar e armazenar solicitações em buffer para operações do SQS. Ao usar a API de agrupamento em lotes, você reduz o número de solicitações para o SQS, o que melhora o throughput e minimiza os custos.
Como os métodos da API em lote correspondem aos métodos `[SqsAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/SqsAsyncClient.html)`: `sendMessage`, `changeMessageVisibility`, `deleteMessage`, `receiveMessage`, você pode usar a API em lote como uma substituição imediata com o mínimo de alterações.
Este tópico fornece uma visão geral de como configurar e trabalhar com a API de agrupamento em lotes automático de solicitações para o Amazon SQS.
## Confira os pré-requisitos
Você precisa usar a versão *2.28.0* ou posterior do SDK para Java 2.x para ter acesso à API de agrupamento em lotes. O `pom.xml` do Maven deve conter pelo menos os elementos a seguir.
```
software.amazon.awssdk
bom
2.28.231
pom
import
software.amazon.awssdk
sqs
```
1 [Versão mais recente](https://central.sonatype.com/artifact/software.amazon.awssdk/bom)
## Criar um gerenciador de lotes
A API automática de envio em lote de solicitações é implementada pela [SqsAsyncBatchManager](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html)interface. É possível criar uma instância do gerente de duas maneiras.
### Configuração padrão usando `SqsAsyncClient`
A maneira mais simples de criar um gerenciador de lotes é chamar o método de `batchManager` fábrica em uma [SqsAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/SqsAsyncClient.html)instância existente. A abordagem simples é mostrada no trecho a seguir.
```
SqsAsyncClient asyncClient = SqsAsyncClient.create();
SqsAsyncBatchManager sqsAsyncBatchManager = asyncClient.batchManager();
```
Quando você usa essa abordagem, a instância `SqsAsyncBatchManager` usa os valores padrão que são mostrados na tabela na seção [Substituir configurações para `SqsAsyncBatchManager`](#sqs-auto-batch-config-settings). Além disso, a instância `SqsAsyncBatchManager` usa o `ExecutorService` da instância `SqsAsyncClient` da qual foi criada.
### Configuração personalizada usando `SqsAsyncBatchManager.Builder`
Para casos de uso mais avançados, você pode personalizar o gerenciador de lotes usando o [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.Builder.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.Builder.html). Ao usar essa abordagem para criar uma instância `SqsAsyncBatchManager`, você pode ajustar o comportamento do agrupamento em lotes. O trecho a seguir mostra um exemplo de como usar o compilador para personalizar o comportamento em lote.
```
SqsAsyncBatchManager batchManager = SqsAsyncBatchManager.builder()
.client(SqsAsyncClient.create())
.scheduledExecutor(Executors.newScheduledThreadPool(5))
.overrideConfiguration(b -> b
.receiveMessageMinWaitDuration(Duration.ofSeconds(10))
.receiveMessageVisibilityTimeout(Duration.ofSeconds(1))
.receiveMessageAttributeNames(Collections.singletonList("*"))
.receiveMessageSystemAttributeNames(Collections.singletonList(MessageSystemAttributeName.ALL)))
.build();
```
Ao usar essa abordagem, é possível ajustar as configurações do objeto `BatchOverrideConfiguration` que são mostradas na tabela na seção [Substituir configurações para `SqsAsyncBatchManager`](#sqs-auto-batch-config-settings). Você também pode fornecer uma personalização [https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/ScheduledExecutorService.html](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/concurrent/ScheduledExecutorService.html) para o gerenciador de lotes usando essa abordagem.
## Enviar mensagens
Para enviar mensagens com o gerenciador de lotes, use o método `[SqsAsyncBatchManager\$1sendMessage](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html#sendMessage(software.amazon.awssdk.services.sqs.model.SendMessageRequest))`. O SDK armazena as solicitações em buffer e as envia em lote quando os valores `maxBatchSize` ou `sendRequestFrequency` são atingidos.
O exemplo a seguir mostra uma solicitação `sendMessage` imediatamente seguida por outra solicitação. Nesse caso, o SDK envia as duas mensagens em um único lote.
```
// Sending the first message
CompletableFuture futureOne =
sqsAsyncBatchManager.sendMessage(r -> r.messageBody("One").queueUrl("queue"));
// Sending the second message
CompletableFuture futureTwo =
sqsAsyncBatchManager.sendMessage(r -> r.messageBody("Two").queueUrl("queue"));
// Waiting for both futures to complete and retrieving the responses
SendMessageResponse messageOne = futureOne.join();
SendMessageResponse messageTwo = futureTwo.join();
```
## Alterar o tempo limite de visibilidade de mensagens
É possível alterar o tempo limite de visibilidade das mensagens em um lote usando o método [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html#changeMessageVisibility(java.util.function.Consumer)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html#changeMessageVisibility(java.util.function.Consumer)). O SDK armazena as solicitações em buffer e as envia em lote quando os valores `maxBatchSize` ou `sendRequestFrequency` são atingidos.
O exemplo a seguir mostra como chamar o método `changeMessageVisibility`.
```
CompletableFuture futureOne =
sqsAsyncBatchManager.changeMessageVisibility(r ->
r.receiptHandle("receiptHandle")
.queueUrl("queue"));
ChangeMessageVisibilityResponse response = futureOne.join();
```
## Exclua mensagens
É possível excluir mensagens em um lote usando o método [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html#deleteMessage(java.util.function.Consumer)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html#deleteMessage(java.util.function.Consumer)). O SDK armazena as solicitações em buffer e as envia em lote quando os valores `maxBatchSize` ou `sendRequestFrequency` são atingidos.
O exemplo a seguir mostra como é possível chamar o método `deleteMessage`.
```
CompletableFuture futureOne =
sqsAsyncBatchManager.deleteMessage(r ->
r.receiptHandle("receiptHandle")
.queueUrl("queue"));
DeleteMessageResponse response = futureOne.join();
```
## Receber mensagens
### Usar configurações padrão
Quando você pesquisa o método `[SqsAsyncBatchManager\$1receiveMessage](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html#receiveMessage(java.util.function.Consumer))` na aplicação, o gerenciador de lotes busca mensagens do buffer interno, que o SDK atualiza automaticamente em segundo plano.
O exemplo a seguir mostra como chamar o método `receiveMessage`.
```
CompletableFuture responseFuture =
sqsAsyncBatchManager.receiveMessage(r -> r.queueUrl("queueUrl"));
```
### Usar configurações personalizadas
Se quiser personalizar ainda mais a solicitação, por exemplo, definindo tempos de espera personalizados e especificando o número de mensagens a serem recuperadas, você poderá personalizar a solicitação conforme mostrado no exemplo a seguir.
```
CompletableFuture response =
sqsAsyncBatchManager.receiveMessage(r ->
r.queueUrl("queueUrl")
.waitTimeSeconds(5)
.visibilityTimeout(20));
```
**nota**
Se você chamar `receiveMessage` com um `[ReceiveMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ReceiveMessageRequest.html)` que inclua qualquer um dos parâmetros a seguir, o SDK ignorará o gerenciador de lotes e enviará uma solicitação `receiveMessage` assíncrona regular:
`messageAttributeNames`
`messageSystemAttributeNames`
`messageSystemAttributeNamesWithStrings`
`overrideConfiguration`
## Substituir configurações para `SqsAsyncBatchManager`
É possível ajustar as seguintes configurações ao criar uma instância `SqsAsyncBatchManager`. A lista de configurações a seguir está disponível no [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/BatchOverrideConfiguration.Builder.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/BatchOverrideConfiguration.Builder.html).
| Configuração | Description | Valor padrão |
| --- | --- | --- |
| maxBatchSize | Número máximo de solicitações por lote para cada SendMessageBatchRequest, ChangeMessageVisibilityBatchRequest ou DeleteMessageBatchRequest. O valor máximo é 10. | 10 |
| sendRequestFrequency | Tempo antes do envio de um lote, a menos que `maxBatchSize` seja atingido antes. Valores mais altos podem reduzir as solicitações, mas aumentar a latência. | 200 ms |
| receiveMessageVisibilityTimeout | Tempo limite de visibilidade para mensagens. Se não especificado, o padrão da fila será usado. | Padrão da fila |
| receiveMessageMinWaitDuration | Tempo mínimo de espera para solicitações receiveMessage. Evite definir como 0 para evitar o desperdício da CPU. | 50 ms |
| receiveMessageSystemAttributeNames | Lista de [nomes de atributos do sistema](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/MessageSystemAttributeName.html) para solicitar chamadas receiveMessage. | Nenhum |
| receiveMessageAttributeNames | Lista de [nomes de atributos](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-metadata.html#sqs-message-attributes) para solicitar chamadas receiveMessage. | Nenhum |
# Trabalhe com filas de Amazon Simple Queue Service mensagens
Uma *fila de mensagens* é o contêiner lógico usado para enviar mensagens de forma confiável. Amazon Simple Queue Service Existem dois tipos de filas: *padrão* e *First-In, First-Out* (FIFO – Primeiro a entrar, primeiro a sair). Para saber mais sobre as filas e as diferenças entre esses tipos, consulte o [Guia do desenvolvedor do Amazon Simple Queue Service](https://docs.aws.amazon.com//AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html).
Este tópico descreve como criar, listar, excluir e obter o URL de uma Amazon Simple Queue Service fila usando o. AWS SDK para Java
A variável `sqsClient` usada nos exemplos a seguir pode ser criada a partir do trecho de código a seguir.
```
SqsClient sqsClient = SqsClient.create();
```
Ao criar um `SqsClient` usando o método estático `create()`, o SDK configura a região usando a [cadeia de provedores de região padrão](region-selection.md#default-region-provider-chain) e as credenciais usando a [cadeia de provedores de credenciais padrão](credentials-chain.md).
## Criar uma fila
Use o método `createQueue` do `SqsClient’s` e forneça um objeto `[CreateQueueRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/CreateQueueRequest.html)` que descreva os parâmetros da fila, conforme mostrado no trecho de código a seguir.
**Importações**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Código**
```
CreateQueueRequest createQueueRequest = CreateQueueRequest.builder()
.queueName(queueName)
.build();
sqsClient.createQueue(createQueueRequest);
```
Veja a [amostra completa](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L52) em GitHub.
## Listar filas
Para listar as Amazon Simple Queue Service filas da sua conta, chame o `SqsClient’s` `listQueues` método com um `[ListQueuesRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ListQueuesRequest.html)` objeto.
Quando você usa a forma do método [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/SqsClient.html#listQueues()](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/SqsClient.html#listQueues()) que não usa parâmetros, o serviço retorna *todas as filas*, até mil filas.
É possível fornecer um prefixo de nome da fila para o objeto `[ListQueuesRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ListQueuesRequest.html)` a fim de limitar os resultados para filas que correspondem a esse prefixo, conforme mostrado no código a seguir.
**Importações**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Código**
```
String prefix = "que";
try {
ListQueuesRequest listQueuesRequest = ListQueuesRequest.builder().queueNamePrefix(prefix).build();
ListQueuesResponse listQueuesResponse = sqsClient.listQueues(listQueuesRequest);
for (String url : listQueuesResponse.queueUrls()) {
System.out.println(url);
}
} catch (SqsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
```
Veja a [amostra completa](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L79) em GitHub.
## Obter o URL de uma fila
O código a seguir mostra como obter o URL de uma fila chamando o método `getQueueUrl` do `SqsClient’s` com um objeto `[GetQueueUrlRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/GetQueueUrlRequest.html)`.
**Importações**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Código**
```
GetQueueUrlResponse getQueueUrlResponse =
sqsClient.getQueueUrl(GetQueueUrlRequest.builder().queueName(queueName).build());
String queueUrl = getQueueUrlResponse.queueUrl();
return queueUrl;
```
Veja a [amostra completa](https://github.com/awsdocs/aws-doc-sdk-examples/blob/7486a1a092aa8e16a21698ef26f9d524fef62e55/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L70) em GitHub.
## Excluir uma fila
Forneça o [URL](#sqs-get-queue-url) da fila para o objeto `[DeleteQueueRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/DeleteQueueRequest.html)`. Depois, chame o método `deleteQueue` do `SqsClient’s` para excluir uma fila, conforme mostrado no código a seguir.
**Importações**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Código**
```
public static void deleteSQSQueue(SqsClient sqsClient, String queueName) {
try {
GetQueueUrlRequest getQueueRequest = GetQueueUrlRequest.builder()
.queueName(queueName)
.build();
String queueUrl = sqsClient.getQueueUrl(getQueueRequest).queueUrl();
DeleteQueueRequest deleteQueueRequest = DeleteQueueRequest.builder()
.queueUrl(queueUrl)
.build();
sqsClient.deleteQueue(deleteQueueRequest);
} catch (SqsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
```
Veja a [amostra completa](https://github.com/awsdocs/aws-doc-sdk-examples/blob/6240df86c5f17eae1e23d1139d1435c7dc4b2a11/javav2/example_code/sqs/src/main/java/com/example/sqs/DeleteQueue.java#L48) em GitHub.
## Mais informações
+ [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)na Referência da Amazon Simple Queue Service API
+ [GetQueueUrl](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueUrl.html)na Referência da Amazon Simple Queue Service API
+ [ListQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html)na Referência da Amazon Simple Queue Service API
+ [DeleteQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueue.html)na Referência da Amazon Simple Queue Service API
# Enviar, receber e excluir Amazon Simple Queue Service mensagens
Uma mensagem é um trecho de dados que pode ser enviado e recebido por componentes distribuídos. As mensagens são sempre entregues usando-se uma [fila do SQS](examples-sqs-message-queues.md).
A variável `sqsClient` usada nos exemplos a seguir pode ser criada a partir do trecho de código a seguir.
```
SqsClient sqsClient = SqsClient.create();
```
Ao criar um `SqsClient` usando o método estático `create()`, o SDK configura a região usando a [cadeia de provedores de região padrão](region-selection.md#default-region-provider-chain) e as credenciais usando a [cadeia de provedores de credenciais padrão](credentials-chain.md).
## Enviar uma mensagem
Adicione uma única mensagem a uma Amazon Simple Queue Service fila chamando o `sendMessage` método SqsClient cliente. Forneça um [SendMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageRequest.html)objeto que contenha a [URL](examples-sqs-message-queues.md#sqs-get-queue-url) da fila, o corpo da mensagem e o valor de atraso opcional (em segundos).
**Importações**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Código**
```
sqsClient.sendMessage(SendMessageRequest.builder()
.queueUrl(queueUrl)
.messageBody("Hello world!")
.delaySeconds(10)
.build());
sqsClient.sendMessage(sendMsgRequest);
```
## Enviar várias mensagens em uma solicitação
Envie mais de uma mensagem em uma única solicitação usando o método do `sendMessageBatch` do SqsClient . Esse método usa um [SendMessageBatchRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageBatchRequest.html)que contém o URL da fila e uma lista de mensagens a serem enviadas. (Cada mensagem é uma [SendMessageBatchRequestEntry](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageBatchRequestEntry.html).) Você também pode atrasar o envio de uma mensagem específica, configurando um valor de atraso na mensagem.
**Importações**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Código**
```
SendMessageBatchRequest sendMessageBatchRequest = SendMessageBatchRequest.builder()
.queueUrl(queueUrl)
.entries(SendMessageBatchRequestEntry.builder().id("id1").messageBody("Hello from msg 1").build(),
SendMessageBatchRequestEntry.builder().id("id2").messageBody("msg 2").delaySeconds(10).build())
.build();
sqsClient.sendMessageBatch(sendMessageBatchRequest);
```
Veja a [amostra completa](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L133) em GitHub.
## Recuperar mensagens
Recupere todas as mensagens que estejam atualmente na fila chamando o método do `receiveMessage` do SqsClient . Esse método usa um [ReceiveMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ReceiveMessageRequest.html)que contém o URL da fila. Você também pode especificar o número máximo de mensagens para retornar. As mensagens são retornadas como uma lista de objetos [Message](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/Message.html).
**Importações**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Código**
```
try {
ReceiveMessageRequest receiveMessageRequest = ReceiveMessageRequest.builder()
.queueUrl(queueUrl)
.maxNumberOfMessages(5)
.build();
List messages = sqsClient.receiveMessage(receiveMessageRequest).messages();
return messages;
} catch (SqsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
return null;
```
Veja a [amostra completa](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L148) em GitHub.
## Excluir uma mensagem após o recebimento
Após receber uma mensagem e processar o conteúdo, exclua a mensagem da fila enviando o identificador de recebimento da mensagem e o URL da fila para o método [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/SqsClient.html#deleteMessage(software.amazon.awssdk.services.sqs.model.DeleteMessageRequest)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/SqsClient.html#deleteMessage(software.amazon.awssdk.services.sqs.model.DeleteMessageRequest)) do `SqsClient's`.
**Importações**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Código**
```
try {
for (Message message : messages) {
DeleteMessageRequest deleteMessageRequest = DeleteMessageRequest.builder()
.queueUrl(queueUrl)
.receiptHandle(message.receiptHandle())
.build();
sqsClient.deleteMessage(deleteMessageRequest);
}
```
Veja a [amostra completa](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L187) em GitHub.
## Mais informações
+ [Como Amazon Simple Queue Service as filas funcionam](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-basic-architecture.html) no Guia do Amazon Simple Queue Service desenvolvedor
+ [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)na Referência da Amazon Simple Queue Service API
+ [SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)na Referência da Amazon Simple Queue Service API
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)na Referência da Amazon Simple Queue Service API
+ [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)na Referência da Amazon Simple Queue Service API
# Trabalhe com Amazon Transcribe
O exemplo a seguir mostra como o streaming bidirecional funciona usando o Amazon Transcribe. O streaming bidirecional indica que há um streaming de dados que vai para o serviço e que é recebido de volta em tempo real. O exemplo usa a transcrição de Amazon Transcribe streaming para enviar um fluxo de áudio e receber um fluxo de texto transcrito em tempo real.
Consulte [Transcrição de streaming](https://docs.aws.amazon.com//transcribe/latest/dg/streaming.html) no Guia do Amazon Transcribe desenvolvedor para saber mais sobre esse recurso.
Consulte [Introdução](https://docs.aws.amazon.com//transcribe/latest/dg/getting-started.html) no Guia do Amazon Transcribe desenvolvedor para começar a usar Amazon Transcribe.
## Configurar o microfone
Esse código usa o pacote javax.sound.sampled para fazer streaming de áudio de um dispositivo de entrada.
**Código**
```
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.TargetDataLine;
public class Microphone {
public static TargetDataLine get() throws Exception {
AudioFormat format = new AudioFormat(16000, 16, 1, true, false);
DataLine.Info datalineInfo = new DataLine.Info(TargetDataLine.class, format);
TargetDataLine dataLine = (TargetDataLine) AudioSystem.getLine(datalineInfo);
dataLine.open(format);
return dataLine;
}
}
```
Veja o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/Microphone.java) em GitHub.
## Criar um publicador
Esse código implementa um editor que publica dados de áudio do fluxo de Amazon Transcribe áudio.
**Código**
```
package com.amazonaws.transcribe;
import java.io.IOException;
import java.io.InputStream;
import java.io.UncheckedIOException;
import java.nio.ByteBuffer;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;
import org.reactivestreams.Publisher;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.services.transcribestreaming.model.AudioEvent;
import software.amazon.awssdk.services.transcribestreaming.model.AudioStream;
import software.amazon.awssdk.services.transcribestreaming.model.TranscribeStreamingException;
public class AudioStreamPublisher implements Publisher {
private final InputStream inputStream;
public AudioStreamPublisher(InputStream inputStream) {
this.inputStream = inputStream;
}
@Override
public void subscribe(Subscriber s) {
s.onSubscribe(new SubscriptionImpl(s, inputStream));
}
private class SubscriptionImpl implements Subscription {
private static final int CHUNK_SIZE_IN_BYTES = 1024 * 1;
private ExecutorService executor = Executors.newFixedThreadPool(1);
private AtomicLong demand = new AtomicLong(0);
private final Subscriber subscriber;
private final InputStream inputStream;
private SubscriptionImpl(Subscriber s, InputStream inputStream) {
this.subscriber = s;
this.inputStream = inputStream;
}
@Override
public void request(long n) {
if (n <= 0) {
subscriber.onError(new IllegalArgumentException("Demand must be positive"));
}
demand.getAndAdd(n);
executor.submit(() -> {
try {
do {
ByteBuffer audioBuffer = getNextEvent();
if (audioBuffer.remaining() > 0) {
AudioEvent audioEvent = audioEventFromBuffer(audioBuffer);
subscriber.onNext(audioEvent);
} else {
subscriber.onComplete();
break;
}
} while (demand.decrementAndGet() > 0);
} catch (TranscribeStreamingException e) {
subscriber.onError(e);
}
});
}
@Override
public void cancel() {
}
private ByteBuffer getNextEvent() {
ByteBuffer audioBuffer;
byte[] audioBytes = new byte[CHUNK_SIZE_IN_BYTES];
int len = 0;
try {
len = inputStream.read(audioBytes);
if (len <= 0) {
audioBuffer = ByteBuffer.allocate(0);
} else {
audioBuffer = ByteBuffer.wrap(audioBytes, 0, len);
}
} catch (IOException e) {
throw new UncheckedIOException(e);
}
return audioBuffer;
}
private AudioEvent audioEventFromBuffer(ByteBuffer bb) {
return AudioEvent.builder()
.audioChunk(SdkBytes.fromByteBuffer(bb))
.build();
}
}
}
```
Veja o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/AudioStreamPublisher.java) em GitHub.
## Criar o cliente e iniciar o streaming
No método principal, crie um objeto de solicitação, inicie o streaming da entrada de áudio e instancie o editor com a entrada de áudio.
Você também deve criar um [StartStreamTranscriptionResponseHandler](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/transcribestreaming/model/StartStreamTranscriptionResponseHandler.html)para especificar como lidar com a resposta de Amazon Transcribe.
Em seguida, use o `startStreamTranscription` método TranscribeStreamingAsyncClient's para iniciar o streaming bidirecional.
**Importações**
```
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.TargetDataLine;
import javax.sound.sampled.AudioInputStream;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.transcribestreaming.TranscribeStreamingAsyncClient;
import software.amazon.awssdk.services.transcribestreaming.model.TranscribeStreamingException ;
import software.amazon.awssdk.services.transcribestreaming.model.StartStreamTranscriptionRequest;
import software.amazon.awssdk.services.transcribestreaming.model.MediaEncoding;
import software.amazon.awssdk.services.transcribestreaming.model.LanguageCode;
import software.amazon.awssdk.services.transcribestreaming.model.StartStreamTranscriptionResponseHandler;
import software.amazon.awssdk.services.transcribestreaming.model.TranscriptEvent;
```
**Código**
```
public static void convertAudio(TranscribeStreamingAsyncClient client) throws Exception {
try {
StartStreamTranscriptionRequest request = StartStreamTranscriptionRequest.builder()
.mediaEncoding(MediaEncoding.PCM)
.languageCode(LanguageCode.EN_US)
.mediaSampleRateHertz(16_000).build();
TargetDataLine mic = Microphone.get();
mic.start();
AudioStreamPublisher publisher = new AudioStreamPublisher(new AudioInputStream(mic));
StartStreamTranscriptionResponseHandler response =
StartStreamTranscriptionResponseHandler.builder().subscriber(e -> {
TranscriptEvent event = (TranscriptEvent) e;
event.transcript().results().forEach(r -> r.alternatives().forEach(a -> System.out.println(a.transcript())));
}).build();
// Keeps Streaming until you end the Java program
client.startStreamTranscription(request, publisher, response);
} catch (TranscribeStreamingException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
```
Veja o [exemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/BidirectionalStreaming.java) em GitHub.
## Mais informações
+ [Como funciona](https://docs.aws.amazon.com//transcribe/latest/dg/how-it-works.html) no Guia do Amazon Transcribe desenvolvedor.
+ [Conceitos básicos do streaming de áudio](https://docs.aws.amazon.com//transcribe/latest/dg/getting-started.html) no Guia do desenvolvedor do Amazon Transcribe .