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();
}
}
```
En este ejemplo, el método `fromJson` convierte la cadena JSON en un objeto `S3EventNotification`. La falta de campos en la cadena JSON generará valores de `null` en los campos de objetos de Java correspondientes y se ignorará cualquier campo adicional del JSON.
Puedes encontrar otras opciones APIs para un registro de notificaciones de eventos en la referencia de la API. `[S3EventNotificationRecord](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/eventnotifications/s3/model/S3EventNotificationRecord.html)`
#### Conversión de una instancia de `S3EventNotification` en una cadena JSON
Utilice el método `toJson` (o `toJsonPretty`) para convertir un objeto `S3EventNotification` en una cadena JSON, como se muestra en el siguiente ejemplo.
```
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);
}
}
```
Los campos para `GlacierEventData`, `ReplicationEventData`, `IntelligentTieringEventData` y `LifecycleEventData` se excluyen del JSON si son `null`. Los demás campos `null` se serializarán como `null`.
A continuación, se muestra un ejemplo de la salida del método `toJsonPretty` para un evento de etiquetado de objetos de 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
}
}
} ]
}
```
Hay disponible un [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/75c3daadf750406156fc87fa30ee499a206b4a36/javav2/example_code/s3/src/main/java/com/example/s3/ProcessS3EventNotification.java#L117) en el GitHub que se muestra cómo utilizar la API para trabajar con las notificaciones recibidas por una cola de Amazon SQS.
## Procese eventos de S3 en Lambda con bibliotecas Java: y AWS SDK for Java 2.x `aws-lambda-java-events`
En lugar de usar el SDK para Java 2.x para procesar las notificaciones de eventos de Amazon S3 en una función Lambda, puede usar `[aws-lambda-java-events](https://github.com/aws/aws-lambda-java-libs/tree/main/aws-lambda-java-events)` la biblioteca de la versión 3.x.x. AWS mantiene la `aws-lambda-java-events` biblioteca de forma independiente y tiene sus propios requisitos de dependencia. La biblioteca de `aws-lambda-java-events` solo funciona con eventos de S3 en funciones de Lambda, mientras que el SDK para Java 2.x funciona con eventos de S3 en funciones de Lambda, Amazon SNS y Amazon SQS.
Ambos enfoques modelan la carga útil de notificación de eventos de JSON de una manera orientada a objetos con similares. APIs En la tabla siguiente se muestran las notables diferencias entre el uso de los dos métodos.
****
| | AWS SDK para Java | aws-lambda-java-events biblioteca |
| --- | --- | --- |
| Nomenclatura del paquete | `software.amazon.awssdk.eventnotifications.s3.model.S3EventNotification` | com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification |
| Parámetro RequestHandler | Escriba la implementación `RequestHandler` de la función de Lambda para recibir una cadena 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.
...
}
}
| Escriba la implementación RequestHandler de la función de Lambda para recibir un 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.
...
}
}
|
| dependencias 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
|
# Trabajar con de Amazon Simple Notification Service
Con Amazon Simple Notification Service, puede enviar fácilmente mensajes de notificación push en tiempo real desde sus aplicaciones a los suscriptores a través de distintos canales de comunicación. En este tema se describe cómo ejecutar algunas de las funciones básicas de Amazon SNS.
## Crear un tema
Un **tema** es una agrupación lógica de canales de comunicación que define a qué sistemas se envía un mensaje (por ejemplo, la difusión de un mensaje a AWS Lambda y un webhook HTTP). Se envían mensajes a Amazon SNS y, a continuación, se distribuyen a los canales definidos en el tema. Esto permite que los mensajes estén disponibles para los suscriptores.
Para crear un tema, primero cree un objeto [CreateTopicRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/CreateTopicRequest.html) con el nombre del conjunto de temas utilizando el método `name()` en el creador. A continuación, envíe el objeto de solicitud a Amazon SNS mediante el método `createTopic()` de [SnsClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/SnsClient.html). Puede capturar el resultado de esta solicitud como un objeto [CreateTopicResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/CreateTopicResponse.html), como se muestra en el siguiente fragmento de código.
**Importaciones**
```
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 de**
```
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 "";
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/CreateTopic.java) en GitHub.
## Enumerar sus temas de Amazon SNS
Para recuperar una lista de los temas de Amazon SNS existentes, cree un objeto [ListTopicsRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/ListTopicsRequest.html). A continuación, envíe el objeto de solicitud a Amazon SNS mediante el método `listTopics()` de `SnsClient`. Puede capturar el resultado de esta solicitud como un objeto [ListTopicsResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/ListTopicsResponse.html).
El siguiente fragmento de código imprime el código de estado HTTP de la solicitud y una lista de nombres de recursos de Amazon (ARN) para los temas de Amazon SNS.
**Importaciones**
```
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 de**
```
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);
}
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/ListTopics.java) en GitHub.
## Suscribir un punto de enlace a un tema
Después de crear un tema, puede configurar los canales de comunicación que serán los puntos de enlace de ese tema. Los mensajes se distribuyen a estos puntos de enlace una vez que Amazon SNS los recibe.
Para configurar un canal de comunicación como punto de enlace de un tema, suscriba ese punto de enlace al tema. Para empezar, cree un objeto [SubscribeRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/SubscribeRequest.html). Especifique el canal de comunicación (por ejemplo, `lambda` o `email`) como `protocol()`. Establezca `endpoint()` en la ubicación de salida correspondiente (por ejemplo, el ARN de una función Lambda o una dirección de correo electrónico) y, a continuación, el ARN del tema al que desea suscribirse como `topicArn()`. Envíe el objeto de solicitud a Amazon SNS mediante el método `subscribe()` del `SnsClient`. Puede capturar el resultado de esta solicitud como un objeto [SubscribeResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/SubscribeResponse.html).
El siguiente fragmento de código muestra cómo suscribir una dirección de correo electrónico a un tema.
**Importaciones**
```
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 de**
```
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);
}
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/SubscribeEmail.java) en GitHub.
## Publicar un mensaje en un tema
Después de haber configurado un tema y uno o varios puntos de enlace para él, puede publicar un mensaje en el tema. Para empezar, cree un objeto [PublishRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/PublishRequest.html). Especifique el `message()` que desea enviar y el ARN del tema (`topicArn()`) al que desea enviarlo. A continuación, envíe el objeto de solicitud a Amazon SNS mediante el método `publish()` de `SnsClient`. Puede capturar el resultado de esta solicitud como un objeto [PublishResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/PublishResponse.html).
**Importaciones**
```
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 de**
```
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);
}
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/PublishTopic.java) en GitHub.
## Cancelar la suscripción de un punto de enlace de un tema
Puede quitar los canales de comunicación configurados como puntos de enlace de un tema. Una vez hecho esto, el tema sigue existiendo y distribuye mensajes a cualquier otro punto de enlace configurado para ese tema.
Para quitar un canal de comunicación como punto de enlace de un tema, cancele la suscripción de dicho punto de enlace del tema. Para empezar, cree un objeto [UnsubscribeRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/UnsubscribeRequest.html) y establezca el ARN del tema del que desea cancelar la suscripción como `subscriptionArn()`. A continuación, envíe el objeto de solicitud a SNS mediante el método `unsubscribe()` de `SnsClient`. Puede capturar el resultado de esta solicitud como un objeto [UnsubscribeResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/UnsubscribeResponse.html).
**Importaciones**
```
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 de**
```
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);
}
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/Unsubscribe.java) en GitHub.
## Eliminación de un tema
Para eliminar un tema de Amazon SNS, primero cree un objeto [DeleteTopicRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/DeleteTopicRequest.html) con el ARN del conjunto de temas como el método `topicArn()` en el creador. A continuación, envíe el objeto de solicitud a Amazon SNS mediante el método `deleteTopic()` de `SnsClient`. Puede capturar el resultado de esta solicitud como un objeto [DeleteTopicResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/DeleteTopicResponse.html), como se muestra en el siguiente fragmento de código.
**Importaciones**
```
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 de**
```
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);
}
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/DeleteTopic.java) en GitHub.
Para obtener más información, consulte [Amazon Simple Notification Service Developer Guide](https://docs.aws.amazon.com/sns/latest/dg/).
# Trabajar con de Amazon Simple Queue Service
En esta sección se proporcionan ejemplos de programación [Amazon Simple Queue Service](https://docs.aws.amazon.com/sqs/) mediante AWS SDK para Java 2.x.
Los siguientes ejemplos incluyen únicamente el código necesario para demostrar cada técnica. El [código de ejemplo completo está disponible en GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2). Desde allí, puede descargar un único archivo de código fuente o clonar el repositorio localmente para obtener todos los ejemplos para compilarlos y ejecutarlos.
**Topics**
+ [Uso de procesamiento automático de solicitudes por lotes](sqs-auto-batch.md)
+ [Operaciones de cola](examples-sqs-message-queues.md)
+ [Operaciones con mensajes](examples-sqs-messages.md)
# Utilice el procesamiento automático por lotes de solicitudes para Amazon SQS con AWS SDK for Java 2.x
La API Procesamiento automático de solicitudes por lotes para Amazon SQS es una biblioteca de alto nivel que proporciona una forma eficaz de procesar por lotes y almacenar en búfer las solicitudes de operaciones de SQS. Al utilizar la API de procesamiento por lotes, reduce el número de solicitudes a SQS, lo que mejora el rendimiento y minimiza los costos.
Dado que los métodos de la API por lotes coinciden con los métodos de `[SqsAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/SqsAsyncClient.html)` (`sendMessage`, `changeMessageVisibility`, `deleteMessage`, `receiveMessage`), puede utilizar la API por lotes como sustitución directa con cambios mínimos.
En este tema se ofrece información general sobre cómo configurar y trabajar con la API Procesamiento automático de solicitudes por lotes para Amazon SQS.
## Requisitos previos
Debe usar la versión *2.28.0* o posterior del SDK para Java 2.x para tener acceso a la API de procesamiento por lotes. Su `pom.xml` de Maven debe contener al menos los siguientes elementos.
```
software.amazon.awssdk
bom
2.28.231
pom
import
software.amazon.awssdk
sqs
```
1 [Última versión](https://central.sonatype.com/artifact/software.amazon.awssdk/bom)
## Creación de un administrador de lotes
La [SqsAsyncBatchManager](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html)interfaz implementa la API automática de procesamiento por lotes de solicitudes. Puede crear una instancia del administrador de dos formas.
### Configuración predeterminada mediante `SqsAsyncClient`
La forma más sencilla de crear un administrador de lotes es llamar al método de `batchManager` fábrica en una [SqsAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/SqsAsyncClient.html)instancia existente. Este método se muestra en el fragmento de código siguiente.
```
SqsAsyncClient asyncClient = SqsAsyncClient.create();
SqsAsyncBatchManager sqsAsyncBatchManager = asyncClient.batchManager();
```
Al usar este método, la instancia `SqsAsyncBatchManager` usa los valores predeterminados que se muestran en la tabla de la sección [Anulación de los ajustes de configuración de `SqsAsyncBatchManager`](#sqs-auto-batch-config-settings). Además, la instancia `SqsAsyncBatchManager` usa el `ExecutorService` de la instancia de `SqsAsyncClient` desde la que se creó.
### Configuración personalizada mediante `SqsAsyncBatchManager.Builder`
Para casos de uso más avanzados, puede personalizar el administrador de lotes mediante [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). Si usa este método para crear una instancia de `SqsAsyncBatchManager`, puede afinar el comportamiento del procesamiento por lotes. El siguiente fragmento de código ofrece un ejemplo de cómo utilizar el compilador para personalizar el comportamiento de procesamiento por lotes.
```
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();
```
Si utiliza este método, puede ajustar la configuración del objeto `BatchOverrideConfiguration` que se muestra en la tabla de la sección [Anulación de los ajustes de configuración de `SqsAsyncBatchManager`](#sqs-auto-batch-config-settings). También puede proporcionar un [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) personalizado para el administrador de lotes mediante este método.
## Envío de mensajes
Para enviar mensajes con el administrador de lotes, utilice el 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))`. El SDK almacena en búfer las solicitudes y las envía como un lote cuando se alcanzan los valores `maxBatchSize` o `sendRequestFrequency`.
En el siguiente ejemplo, se muestra una solicitud `sendMessage` seguida inmediatamente de otra solicitud. En este caso, el SDK envía ambos mensajes en un ú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();
```
## Cambio del tiempo de espera de visibilidad de mensajes
Puede cambiar el tiempo de espera de visibilidad de los mensajes de un lote utilizando el 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)). El SDK almacena en búfer las solicitudes y las envía como un lote cuando se alcanzan los valores `maxBatchSize` o `sendRequestFrequency`.
En el siguiente ejemplo, se muestra cómo llamar al método `changeMessageVisibility`.
```
CompletableFuture futureOne =
sqsAsyncBatchManager.changeMessageVisibility(r ->
r.receiptHandle("receiptHandle")
.queueUrl("queue"));
ChangeMessageVisibilityResponse response = futureOne.join();
```
## Cómo eliminar mensajes
Puede eliminar los mensajes de un lote con el 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)). El SDK almacena en búfer las solicitudes y las envía como un lote cuando se alcanzan los valores `maxBatchSize` o `sendRequestFrequency`.
En el siguiente ejemplo se muestra cómo llamar al método `deleteMessage`.
```
CompletableFuture futureOne =
sqsAsyncBatchManager.deleteMessage(r ->
r.receiptHandle("receiptHandle")
.queueUrl("queue"));
DeleteMessageResponse response = futureOne.join();
```
## Recepción de mensajes
### Uso de la configuración predeterminada
Al sondear el método `[SqsAsyncBatchManager\$1receiveMessage](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html#receiveMessage(java.util.function.Consumer))` en la aplicación, el administrador de lotes extrae los mensajes de su búfer interno, que el SDK actualiza automáticamente en segundo plano.
En el siguiente ejemplo, se muestra cómo llamar al método `receiveMessage`.
```
CompletableFuture responseFuture =
sqsAsyncBatchManager.receiveMessage(r -> r.queueUrl("queueUrl"));
```
### Uso de la configuración personalizada
Si quiere personalizar aún más la solicitud, por ejemplo, configurando tiempos de espera personalizados y especificando el número de mensajes que se van a recuperar, puede personalizar la solicitud como se muestra en el siguiente ejemplo.
```
CompletableFuture response =
sqsAsyncBatchManager.receiveMessage(r ->
r.queueUrl("queueUrl")
.waitTimeSeconds(5)
.visibilityTimeout(20));
```
**nota**
Si llama a `receiveMessage` con un parámetro `[ReceiveMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ReceiveMessageRequest.html)` que incluya alguno de los siguientes parámetros, el SDK omite el administrador de lotes y envía una solicitud asincrónica `receiveMessage` normal:
`messageAttributeNames`
`messageSystemAttributeNames`
`messageSystemAttributeNamesWithStrings`
`overrideConfiguration`
## Anulación de los ajustes de configuración de `SqsAsyncBatchManager`
Puede ajustar la configuración siguiente al crear una instancia `SqsAsyncBatchManager`. La siguiente lista de ajustes está disponible en [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).
| Opción | Description (Descripción) | Predeterminado |
| --- | --- | --- |
| maxBatchSize | Número máximo de solicitudes por lote para cada SendMessageBatchRequest, ChangeMessageVisibilityBatchRequest o DeleteMessageBatchRequest. El valor máximo es 10. | 10 |
| sendRequestFrequency | Tiempo antes de enviar un lote, a menos que se alcance antes `maxBatchSize`. Los valores más altos pueden reducir las solicitudes pero aumentar la latencia. | 200 ms |
| receiveMessageVisibilityTimeout | Tiempo de espera de visibilidad para los mensajes. Si no se especifica, se utiliza la configuración predeterminada de la cola. | Configuración predeterminada de la cola |
| receiveMessageMinWaitDuration | Tiempo mínimo de espera para solicitudes receiveMessage. Evite establecer el valor en 0 para evitar un uso excesivo de la CPU. | 50 ms |
| receiveMessageSystemAttributeNames | Lista de [nombres de atributos del sistema](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/MessageSystemAttributeName.html) para solicitar para llamadas receiveMessage. | Ninguno |
| receiveMessageAttributeNames | Lista de [nombres de atributos](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-metadata.html#sqs-message-attributes) para solicitar para llamadas receiveMessage. | Ninguno |
# Trabaje con colas de Amazon Simple Queue Service mensajes
Una *cola de mensajes* es el contenedor lógico que se utiliza para enviar mensajes de forma fiable. Amazon Simple Queue Service Existen dos tipos de colas: *estándar* y *primero en entrar, primero en salir* (FIFO). Para obtener más información sobre las colas y las diferencias entre estos tipos, consulte la [Guía para desarrolladores de Amazon Simple Queue Service](https://docs.aws.amazon.com//AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html).
En este tema se describe cómo crear, enumerar, eliminar y obtener la URL de una Amazon Simple Queue Service cola mediante el. AWS SDK para Java
La variable `sqsClient` que se utiliza en los ejemplos a continuación se puede crear a partir del siguiente fragmento.
```
SqsClient sqsClient = SqsClient.create();
```
Al crear un `SqsClient` utilizando el método `create()` estático, el SDK configura la región mediante la [cadena de proveedores de regiones predeterminada](region-selection.md#default-region-provider-chain) y las credenciales mediante la [cadena de proveedores de credenciales predeterminada](credentials-chain.md).
## Creación de una cola
Use el `createQueue` método de `SqsClient’s` y proporcione un objeto `[CreateQueueRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/CreateQueueRequest.html)` que describa los parámetros de la cola, como se muestra en el siguiente fragmento de código.
**Importaciones**
```
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);
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L52) en. GitHub
## Lista de colas
Para ver las Amazon Simple Queue Service colas de tu cuenta, llama al `SqsClient’s` `listQueues` método con un `[ListQueuesRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ListQueuesRequest.html)` objeto.
Si utiliza la forma del 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 no acepta parámetros, el servicio devuelve *todas las colas* hasta un máximo de 1000.
Puede proporcionar un prefijo de nombre de cola al objeto `[ListQueuesRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ListQueuesRequest.html)` para limitar los resultados a las colas que coinciden con ese prefijo, como se muestra en el código siguiente.
**Importaciones**
```
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);
}
```
Consulta el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L79) en. GitHub
## Obtener la URL de una cola
El código siguiente muestra cómo obtener la URL de una cola llamando al `getQueueUrl` método de `SqsClient’s` con un objeto `[GetQueueUrlRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/GetQueueUrlRequest.html)`.
**Importaciones**
```
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;
```
Vea el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/7486a1a092aa8e16a21698ef26f9d524fef62e55/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L70) en GitHub.
## Eliminar una cola
Proporcione la [URL](#sqs-get-queue-url) de la cola al objeto `[DeleteQueueRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/DeleteQueueRequest.html)`. A continuación, llame al método `deleteQueue` de `SqsClient’s` para eliminar una cola, como se muestra en el código siguiente.
**Importaciones**
```
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);
}
}
```
Vea el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/6240df86c5f17eae1e23d1139d1435c7dc4b2a11/javav2/example_code/sqs/src/main/java/com/example/sqs/DeleteQueue.java#L48) en GitHub.
## Más información
+ [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)en la referencia Amazon Simple Queue Service de la API
+ [GetQueueUrl](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueUrl.html)en la referencia Amazon Simple Queue Service de la API
+ [ListQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html)en la referencia Amazon Simple Queue Service de la API
+ [DeleteQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueue.html)en la referencia Amazon Simple Queue Service de la API
# Enviar, recibir y eliminar Amazon Simple Queue Service mensajes
Un mensaje es un segmento de datos que los componentes distribuidos pueden enviar y recibir. Los mensajes se envían siempre a través de una [cola de SQS](examples-sqs-message-queues.md).
La variable `sqsClient` que se utiliza en los ejemplos a continuación se puede crear a partir del siguiente fragmento.
```
SqsClient sqsClient = SqsClient.create();
```
Al crear un `SqsClient` utilizando el método `create()` estático, el SDK configura la región mediante la [cadena de proveedores de regiones predeterminada](region-selection.md#default-region-provider-chain) y las credenciales mediante la [cadena de proveedores de credenciales predeterminada](credentials-chain.md).
## Enviar un mensaje
Agrega un solo mensaje a una Amazon Simple Queue Service cola llamando al `sendMessage` método SqsClient cliente. Proporcione un [SendMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageRequest.html)objeto que contenga la [URL](examples-sqs-message-queues.md#sqs-get-queue-url) de la cola, el cuerpo del mensaje y el valor de retraso opcional (en segundos).
**Importaciones**
```
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 varios mensajes en una solicitud
Envíe varios mensajes en una sola solicitud mediante el método SqsClient `sendMessageBatch`. Este método toma una [SendMessageBatchRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageBatchRequest.html)que contiene la URL de la cola y una lista de los mensajes que se van a enviar. (Cada mensaje es un [SendMessageBatchRequestEntry](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageBatchRequestEntry.html).) También puede retrasar el envío de un mensaje específico estableciendo un valor de retraso en el mensaje.
**Importaciones**
```
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);
```
Vea el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L133) en GitHub.
## Recuperar mensajes
Recupere todos los mensajes que se encuentran actualmente en la cola llamando al método SqsClient `receiveMessage`. Este método toma una [ReceiveMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ReceiveMessageRequest.html)que contiene la URL de la cola. También puede especificar el número máximo de mensajes que se devuelven. Los mensajes se devuelven como una lista de objetos [Message](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/Message.html).
**Importaciones**
```
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;
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L148) en. GitHub
## Eliminar un mensaje después de su recepción
Tras recibir un mensaje y procesar su contenido, elimine el mensaje de la cola enviando el identificador de recepción y la URL de la cola del mensaje al 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)) de `SqsClient's`.
**Importaciones**
```
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);
}
```
Vea el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L187) en GitHub.
## Más información
+ [Cómo funcionan Amazon Simple Queue Service las colas](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-basic-architecture.html) en la guía Amazon Simple Queue Service para desarrolladores
+ [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)en la referencia de la Amazon Simple Queue Service API
+ [SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)en la referencia Amazon Simple Queue Service de la API
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)en la referencia Amazon Simple Queue Service de la API
+ [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)en la referencia Amazon Simple Queue Service de la API
# Trabaja con Amazon Transcribe
En el siguiente ejemplo se muestra cómo funciona el streaming bidireccional con Amazon Transcribe. El streaming bidireccional implica que hay una secuencia de datos que se envía al servicio y que se recibe en tiempo real. El ejemplo utiliza la transcripción Amazon Transcribe en streaming para enviar una transmisión de audio y recibir una secuencia de texto transcrito en tiempo real.
Consulta la [transcripción en streaming](https://docs.aws.amazon.com//transcribe/latest/dg/streaming.html) en la guía para Amazon Transcribe desarrolladores para obtener más información sobre esta función.
Consulte [Primeros pasos](https://docs.aws.amazon.com//transcribe/latest/dg/getting-started.html) en la Guía para Amazon Transcribe desarrolladores para empezar a utilizarla Amazon Transcribe.
## Configurar el micrófono
Este código utiliza el paquete javax.sound.sampled para transmitir audio desde un 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;
}
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/Microphone.java) en GitHub.
## Crear un editor
Este código implementa un editor que publica los datos de audio de la transmisión Amazon Transcribe de audio.
**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();
}
}
}
```
Consulte el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/AudioStreamPublisher.java) en GitHub.
## Cree el cliente e inicie la secuencia
En el método principal, cree un objeto de solicitud, inicie la secuencia de entrada de audio y cree instancias del editor con la entrada de audio.
También debe crear un [StartStreamTranscriptionResponseHandler](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/transcribestreaming/model/StartStreamTranscriptionResponseHandler.html)para especificar cómo gestionar la respuesta desde Amazon Transcribe.
A continuación, utilice el `startStreamTranscription` método TranscribeStreamingAsyncClient's para iniciar la transmisión bidireccional.
**Importaciones**
```
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);
}
}
```
Consulta el [ejemplo completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/BidirectionalStreaming.java) en. GitHub
## Más información
+ [Cómo funciona](https://docs.aws.amazon.com//transcribe/latest/dg/how-it-works.html) en la guía para Amazon Transcribe desarrolladores.
+ [Introducción al audio en streaming](https://docs.aws.amazon.com//transcribe/latest/dg/getting-started.html) en la Guía para desarrolladores de Amazon Transcribe .