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();
}
}
```
In questo esempio, il `fromJson` metodo converte la stringa JSON in un oggetto. `S3EventNotification` I campi mancanti nella stringa JSON produrranno `null` valori nei campi degli oggetti Java corrispondenti e tutti i campi aggiuntivi nel JSON verranno ignorati.
Ulteriori informazioni APIs relative al record di notifica degli eventi sono disponibili nel riferimento API per. `[S3EventNotificationRecord](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/eventnotifications/s3/model/S3EventNotificationRecord.html)`
#### Convertire un'`S3EventNotification`istanza in una stringa JSON
Utilizzate il metodo `toJson` (or`toJsonPretty`) per convertire un `S3EventNotification` oggetto in una stringa JSON, come mostrato nell'esempio seguente.
```
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);
}
}
```
I campi per `GlacierEventData``ReplicationEventData`,`IntelligentTieringEventData`, e `LifecycleEventData` sono esclusi dal JSON se lo sono. `null` Gli altri `null` campi verranno serializzati come. `null`
Di seguito viene mostrato un esempio di output del `toJsonPretty` metodo per un evento di tagging di oggetti 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
}
}
} ]
}
```
È disponibile un [esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/75c3daadf750406156fc87fa30ee499a206b4a36/javav2/example_code/s3/src/main/java/com/example/s3/ProcessS3EventNotification.java#L117) GitHub che mostra come utilizzare l'API per gestire le notifiche ricevute da una coda Amazon SQS.
## Elabora gli eventi S3 in Lambda con le librerie Java: e AWS SDK for Java 2.x `aws-lambda-java-events`
Invece di utilizzare l'SDK for Java 2.x per elaborare le notifiche degli eventi di Amazon S3 in una funzione Lambda, puoi utilizzare la libreria nella versione 3.x.x. `[aws-lambda-java-events](https://github.com/aws/aws-lambda-java-libs/tree/main/aws-lambda-java-events)` AWS gestisce la `aws-lambda-java-events` libreria in modo indipendente e ha i propri requisiti di dipendenza. La `aws-lambda-java-events` libreria funziona solo con gli eventi S3 nelle funzioni Lambda, mentre l'SDK per Java 2.x funziona con gli eventi S3 nelle funzioni Lambda, Amazon SNS e Amazon SQS.
Entrambi gli approcci modellano il payload di notifica degli eventi JSON in modo orientato agli oggetti con similari. APIs La tabella seguente mostra le notevoli differenze tra l'utilizzo dei due approcci.
****
| | AWS SDK per Java | aws-lambda-java-events libreria |
| --- | --- | --- |
| Denominazione dei pacchetti | `software.amazon.awssdk.eventnotifications.s3.model.S3EventNotification` | com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification |
| Parametro RequestHandler | Scrivi l'`RequestHandler`implementazione della tua funzione Lambda per ricevere una stringa 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.
...
}
}
| Scrivi l'RequestHandlerimplementazione della tua funzione Lambda per ricevere un S3Event oggetto: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.
...
}
}
|
| Dipendenze da 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
|
# Lavora con Amazon Simple Notification Service
Con Amazon Simple Notification Service, puoi inviare facilmente messaggi di notifica in tempo reale dalle tue applicazioni agli abbonati su più canali di comunicazione. In questo argomento viene descritto come eseguire alcune delle funzioni di base di Amazon SNS.
## Creazione di un argomento
Un **argomento** è un raggruppamento logico di canali di comunicazione che definisce a quali sistemi inviare un messaggio, ad esempio suddividendo un messaggio AWS Lambda e un webhook HTTP. I messaggi vengono inviati ai Amazon SNS canali definiti nell'argomento e poi vengono distribuiti ai canali definiti nell'argomento. Questo rende i messaggi disponibili per gli abbonati.
Per creare un argomento, crea prima un [CreateTopicRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/CreateTopicRequest.html)oggetto, con il nome dell'argomento impostato utilizzando il `name()` metodo nel generatore. Quindi, invia l'oggetto della richiesta a Amazon SNS utilizzando il `createTopic()` metodo di. [SnsClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/SnsClient.html) È possibile acquisire il risultato di questa richiesta come [CreateTopicResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/CreateTopicResponse.html)oggetto, come illustrato nel seguente frammento di codice.
**Importazioni**
```
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;
```
**Codice**
```
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 "";
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/CreateTopic.java) su. GitHub
## Elenca i tuoi Amazon SNS argomenti
Per recuperare un elenco dei tuoi Amazon SNS argomenti esistenti, crea un [ListTopicsRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/ListTopicsRequest.html)oggetto. Quindi, invia l'oggetto della richiesta a Amazon SNS utilizzando il `listTopics()` metodo di. `SnsClient` È possibile acquisire il risultato di questa richiesta come [ListTopicsResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/ListTopicsResponse.html)oggetto.
Il seguente frammento di codice stampa il codice di stato HTTP della richiesta e un elenco di Amazon Resource Names (ARNs) per i tuoi Amazon SNS argomenti.
**Importazioni**
```
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;
```
**Codice**
```
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);
}
}
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/ListTopics.java) su. GitHub
## Sottoscrizione di un endpoint a un argomento
Dopo aver creato un argomento, puoi configurare quali canali di comunicazione saranno endpoint per tale argomento. I messaggi vengono distribuiti a questi endpoint dopo averli Amazon SNS ricevuti.
Per configurare un canale di comunicazione come endpoint per un argomento, sottoscrivi tale endpoint all'argomento. Per iniziare, costruisci un [SubscribeRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/SubscribeRequest.html)oggetto. Specificate il canale di comunicazione (ad esempio, `lambda` o`email`) come`protocol()`. Imposta la `endpoint()` posizione di output pertinente (ad esempio, l'ARN di una Lambda funzione o un indirizzo e-mail), quindi imposta l'ARN dell'argomento a cui desideri iscriverti come. `topicArn()` Inviate l'oggetto della richiesta a Amazon SNS utilizzando il `subscribe()` metodo di. `SnsClient` È possibile acquisire il risultato di questa richiesta come [SubscribeResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/SubscribeResponse.html)oggetto.
Il frammento di codice seguente mostra come sottoscrivere un indirizzo e-mail a un argomento.
**Importazioni**
```
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;
```
**Codice**
```
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);
}
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/SubscribeEmail.java) su GitHub.
## Pubblicazione di un messaggio in un argomento
Dopo avere configurato un argomento e uno o più endpoint, puoi pubblicare un messaggio. Per iniziare, costruisci un [PublishRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/PublishRequest.html)oggetto. Specifica `message()` per l'invio e l'ARN dell'argomento (`topicArn()`) a cui inviarlo. Quindi, invia l'oggetto della richiesta a Amazon SNS utilizzando il `publish()` metodo di`SnsClient`. È possibile acquisire il risultato di questa richiesta come [PublishResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/PublishResponse.html)oggetto.
**Importazioni**
```
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;
```
**Codice**
```
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);
}
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/PublishTopic.java) su GitHub.
## Annullamento della sottoscrizione di un endpoint da un argomento
Puoi rimuovere i canali di comunicazione configurati come endpoint per un argomento. Dopo aver eseguito questa operazione, l'argomento stesso continua a esistere e distribuire i messaggi a qualsiasi altro endpoint configurato per tale argomento.
Per rimuovere un canale di comunicazione come endpoint per un argomento, annulla la sottoscrizione dell'endpoint dall'argomento. Per iniziare, crea un [UnsubscribeRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/UnsubscribeRequest.html)oggetto e imposta l'ARN dell'argomento a cui desideri annullare l'iscrizione come. `subscriptionArn()` Quindi invia l'oggetto della richiesta a SNS utilizzando il metodo `unsubscribe()` di `SnsClient`. Puoi acquisire il risultato di questa richiesta come oggetto [UnsubscribeResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/UnsubscribeResponse.html).
**Importazioni**
```
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;
```
**Codice**
```
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);
}
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/Unsubscribe.java) su GitHub.
## Eliminazione di un argomento
Per eliminare un Amazon SNS argomento, crea prima un [DeleteTopicRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/DeleteTopicRequest.html)oggetto con l'ARN dell'argomento impostato come `topicArn()` metodo nel generatore. Quindi invia l'oggetto della richiesta a Amazon SNS utilizzando il `deleteTopic()` metodo di. `SnsClient` È possibile acquisire il risultato di questa richiesta come [DeleteTopicResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/DeleteTopicResponse.html)oggetto, come illustrato nel seguente frammento di codice.
**Importazioni**
```
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;
```
**Codice**
```
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);
}
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/DeleteTopic.java) su. GitHub
Per ulteriori informazioni, consulta la [Guida per gli sviluppatori di Amazon Simple Notification Service](https://docs.aws.amazon.com/sns/latest/dg/).
# Lavora con Amazon Simple Queue Service
Questa sezione fornisce esempi di programmazione [Amazon Simple Queue Service](https://docs.aws.amazon.com/sqs/)con AWS SDK per Java 2.x.
Gli esempi seguenti includono solo il codice necessario per dimostrare ciascuna tecnica. Il [codice di esempio completo è disponibile su. GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2) Da qui puoi scaricare un singolo file sorgente o clonare l'archivio localmente per ottenere tutti gli esempi da creare ed eseguire.
**Topics**
+ [Utilizza il raggruppamento automatico delle richieste](sqs-auto-batch.md)
+ [Operazioni di coda](examples-sqs-message-queues.md)
+ [Operazioni relative ai messaggi](examples-sqs-messages.md)
# Utilizza il batching automatico delle richieste per Amazon SQS con AWS SDK for Java 2.x
L'API Automatic Request Batching per Amazon SQS è una libreria di alto livello che fornisce un modo efficiente per creare batch e bufferizzare le richieste per le operazioni SQS. Utilizzando l'API di batching, riduci il numero di richieste a SQS, il che migliora la produttività e minimizza i costi.
Poiché i metodi dell'API batch corrispondono ai `[SqsAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/SqsAsyncClient.html)` metodi—`sendMessage`,, `changeMessageVisibility``deleteMessage`, `receiveMessage` —puoi utilizzare l'API batch come sostituto immediato con modifiche minime.
Questo argomento offre una panoramica su come configurare e utilizzare l'API Automatic Request Batching per Amazon SQS.
## Verifica i prerequisiti
È necessario utilizzare la versione *2.28.0* o successiva dell'SDK for Java 2.x per avere accesso all'API di batch. Il tuo Maven `pom.xml` dovrebbe contenere almeno i seguenti elementi.
```
software.amazon.awssdk
bom
2.28.231
pom
import
software.amazon.awssdk
sqs
```
[1 Ultima versione](https://central.sonatype.com/artifact/software.amazon.awssdk/bom)
## Crea un gestore di batch
L'API di raggruppamento automatico delle richieste è implementata dall'[SqsAsyncBatchManager](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html)interfaccia. È possibile creare un'istanza del gestore in due modi.
### Configurazione predefinita utilizzando `SqsAsyncClient`
Il modo più semplice per creare un gestore di batch consiste nel chiamare il metodo `batchManager` factory su un'[SqsAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/SqsAsyncClient.html)istanza esistente. L'approccio semplice è illustrato nel frammento seguente.
```
SqsAsyncClient asyncClient = SqsAsyncClient.create();
SqsAsyncBatchManager sqsAsyncBatchManager = asyncClient.batchManager();
```
Quando utilizzate questo approccio, l'`SqsAsyncBatchManager`istanza utilizza i valori predefiniti mostrati nella tabella della sezione. [Sostituisci le impostazioni di configurazione per `SqsAsyncBatchManager`](#sqs-auto-batch-config-settings) Inoltre, l'`SqsAsyncBatchManager`istanza utilizza `ExecutorService` l'`SqsAsyncClient`istanza da cui è stata creata.
### Configurazione personalizzata utilizzando `SqsAsyncBatchManager.Builder`
Per casi d'uso più avanzati, è possibile personalizzare il gestore batch utilizzando [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). Utilizzando questo approccio per creare un'`SqsAsyncBatchManager`istanza, è possibile ottimizzare il comportamento di batch. Il seguente frammento mostra un esempio di come utilizzare il builder per personalizzare il comportamento del batch.
```
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();
```
Quando utilizzate questo approccio, potete regolare le impostazioni sull'`BatchOverrideConfiguration`oggetto mostrate nella tabella della sezione. [Sostituisci le impostazioni di configurazione per `SqsAsyncBatchManager`](#sqs-auto-batch-config-settings) È inoltre possibile fornire una personalizzazione [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)per il gestore dei batch utilizzando questo approccio.
## Inviare messaggi
Per inviare messaggi con il gestore batch, usa il `[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))` metodo. L'SDK memorizza le richieste e le invia come batch quando vengono raggiunti `sendRequestFrequency` i valori `maxBatchSize` or.
L'esempio seguente mostra una `sendMessage` richiesta immediatamente successiva a un'altra richiesta. In questo caso, l'SDK invia entrambi i messaggi in un unico batch.
```
// 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();
```
## Modifica il timeout di visibilità dei messaggi
È possibile modificare il timeout di visibilità dei messaggi in un batch utilizzando il [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))metodo. L'SDK memorizza le richieste nel buffer e le invia in batch quando vengono raggiunti `sendRequestFrequency` i valori `maxBatchSize` or.
L'esempio seguente mostra come chiamare il `changeMessageVisibility` metodo.
```
CompletableFuture futureOne =
sqsAsyncBatchManager.changeMessageVisibility(r ->
r.receiptHandle("receiptHandle")
.queueUrl("queue"));
ChangeMessageVisibilityResponse response = futureOne.join();
```
## Eliminare i messaggi
È possibile eliminare i messaggi in batch utilizzando il [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))metodo. L'SDK memorizza le richieste nel buffer e le invia come batch quando vengono raggiunti `sendRequestFrequency` i valori `maxBatchSize` or.
L'esempio seguente mostra come chiamare il `deleteMessage` metodo.
```
CompletableFuture futureOne =
sqsAsyncBatchManager.deleteMessage(r ->
r.receiptHandle("receiptHandle")
.queueUrl("queue"));
DeleteMessageResponse response = futureOne.join();
```
## Ricevere messaggi
### Usa le impostazioni predefinite
Quando esegui il polling del `[SqsAsyncBatchManager\$1receiveMessage](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html#receiveMessage(java.util.function.Consumer))` metodo nell'applicazione, il gestore batch recupera i messaggi dal suo buffer interno, che l'SDK aggiorna automaticamente in background.
L'esempio seguente mostra come chiamare il metodo. `receiveMessage`
```
CompletableFuture responseFuture =
sqsAsyncBatchManager.receiveMessage(r -> r.queueUrl("queueUrl"));
```
### Usa impostazioni personalizzate
Se desideri personalizzare ulteriormente la richiesta, ad esempio impostando tempi di attesa personalizzati e specificando il numero di messaggi da recuperare, puoi personalizzare la richiesta come mostrato nell'esempio seguente.
```
CompletableFuture response =
sqsAsyncBatchManager.receiveMessage(r ->
r.queueUrl("queueUrl")
.waitTimeSeconds(5)
.visibilityTimeout(20));
```
**Nota**
Se chiami `receiveMessage` con un `[ReceiveMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ReceiveMessageRequest.html)` che include uno dei seguenti parametri, l'SDK ignora il gestore batch e invia una normale richiesta asincrona: `receiveMessage`
`messageAttributeNames`
`messageSystemAttributeNames`
`messageSystemAttributeNamesWithStrings`
`overrideConfiguration`
## Sostituisci le impostazioni di configurazione per `SqsAsyncBatchManager`
È possibile modificare le seguenti impostazioni quando si crea un'`SqsAsyncBatchManager`istanza. Il seguente elenco di impostazioni è disponibile in [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).
| Impostazione | Description | Valore predefinito |
| --- | --- | --- |
| maxBatchSize | Numero massimo di richieste per batch per ciascuna SendMessageBatchRequestChangeMessageVisibilityBatchRequest, oDeleteMessageBatchRequest. Il valore massimo è 10. | 10 |
| sendRequestFrequency | Tempo prima dell'invio di un batch, a meno che non `maxBatchSize` venga raggiunto prima. Valori più alti possono ridurre le richieste ma aumentare la latenza. | 200 ms |
| receiveMessageVisibilityTimeout | Timeout di visibilità per i messaggi. Se non è impostato, viene utilizzato il valore predefinito della coda. | L'impostazione predefinita della coda |
| receiveMessageMinWaitDuration | Tempo di attesa minimo per le receiveMessage richieste. Evita di impostarlo su 0 per evitare sprechi di CPU. | 50 ms |
| receiveMessageSystemAttributeNames | Elenco dei [nomi degli attributi di sistema](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/MessageSystemAttributeName.html) da richiedere per receiveMessage le chiamate. | Nessuno |
| receiveMessageAttributeNames | Elenco dei [nomi degli attributi](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-metadata.html#sqs-message-attributes) da richiedere per receiveMessage le chiamate. | Nessuno |
# Lavora con le code di Amazon Simple Queue Service messaggi
Una *coda di messaggi* è il contenitore logico utilizzato per inviare messaggi in modo affidabile. Amazon Simple Queue Service Sono disponibili due tipi di code: *standard* e *first-in, first-out* (FIFO). [Per ulteriori informazioni sulle code e sulle differenze tra questi tipi, consulta la Guida per gli Amazon Simple Queue Service sviluppatori.](https://docs.aws.amazon.com//AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html)
Questo argomento descrive come creare, elencare, eliminare e ottenere l'URL di una Amazon Simple Queue Service coda utilizzando. AWS SDK per Java
La `sqsClient` variabile utilizzata negli esempi seguenti può essere creata dal seguente frammento.
```
SqsClient sqsClient = SqsClient.create();
```
[Quando si crea un `SqsClient` utilizzando il `create()` metodo statico, l'SDK configura la regione utilizzando la catena di provider di aree [predefinita e le credenziali utilizzando la catena di provider](region-selection.md#default-region-provider-chain) di credenziali predefinita.](credentials-chain.md)
## Crea una coda
Utilizzate il `SqsClient’s` `createQueue` metodo e fornite un `[CreateQueueRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/CreateQueueRequest.html)` oggetto che descriva i parametri della coda come mostrato nel seguente frammento di codice.
**Importazioni**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Codice**
```
CreateQueueRequest createQueueRequest = CreateQueueRequest.builder()
.queueName(queueName)
.build();
sqsClient.createQueue(createQueueRequest);
```
Vedi l'esempio [completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L52) su. GitHub
## Elencare code
Per elencare le Amazon Simple Queue Service code relative al tuo account, chiama il `SqsClient’s` `listQueues` metodo con un `[ListQueuesRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ListQueuesRequest.html)` oggetto.
Quando utilizzate il modulo del [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())metodo che non accetta parametri, il servizio restituisce *tutte le code, fino a 1.000 code*.
È possibile fornire un prefisso per il nome della coda all'`[ListQueuesRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ListQueuesRequest.html)`oggetto per limitare i risultati alle code che corrispondono a tale prefisso, come illustrato nel codice seguente.
**Importazioni**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Codice**
```
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);
}
```
[Guarda l'esempio completo su.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L79) GitHub
## Ottenere l'URL di una coda
Il codice seguente mostra come ottenere l'URL di una coda chiamando il `SqsClient’s` `getQueueUrl` metodo con un `[GetQueueUrlRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/GetQueueUrlRequest.html)` oggetto.
**Importazioni**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Codice**
```
GetQueueUrlResponse getQueueUrlResponse =
sqsClient.getQueueUrl(GetQueueUrlRequest.builder().queueName(queueName).build());
String queueUrl = getQueueUrlResponse.queueUrl();
return queueUrl;
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/7486a1a092aa8e16a21698ef26f9d524fef62e55/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L70) su. GitHub
## Elimina una coda
Fornisci l'[URL](#sqs-get-queue-url) della coda all'`[DeleteQueueRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/DeleteQueueRequest.html)`oggetto. Quindi chiamate il `SqsClient’s` `deleteQueue` metodo per eliminare una coda come mostrato nel codice seguente.
**Importazioni**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Codice**
```
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);
}
}
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/6240df86c5f17eae1e23d1139d1435c7dc4b2a11/javav2/example_code/sqs/src/main/java/com/example/sqs/DeleteQueue.java#L48) su. GitHub
## Ulteriori informazioni
+ [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)nell' Amazon Simple Queue Service API Reference
+ [GetQueueUrl](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueUrl.html)nell' Amazon Simple Queue Service API Reference
+ [ListQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html)nell' Amazon Simple Queue Service API Reference
+ [DeleteQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueue.html)nell' Amazon Simple Queue Service API Reference
# Inviare, ricevere ed eliminare Amazon Simple Queue Service messaggi
Un messaggio è una parte di dati che possono essere inviati e ricevuti da componenti distribuiti. I messaggi vengono sempre distribuiti tramite una [coda SQS](examples-sqs-message-queues.md).
La `sqsClient` variabile utilizzata negli esempi seguenti può essere creata dal seguente frammento.
```
SqsClient sqsClient = SqsClient.create();
```
[Quando si crea un `SqsClient` utilizzando il `create()` metodo statico, l'SDK configura la regione utilizzando la catena di provider di aree [predefinita e le credenziali utilizzando la catena di provider](region-selection.md#default-region-provider-chain) di credenziali predefinita.](credentials-chain.md)
## Invio di un messaggio
Aggiungi un singolo messaggio a una Amazon Simple Queue Service coda chiamando il metodo client. SqsClient `sendMessage` Fornisci un [SendMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageRequest.html)oggetto che contenga l'[URL](examples-sqs-message-queues.md#sqs-get-queue-url) della coda, il corpo del messaggio e il valore di ritardo opzionale (in secondi).
**Importazioni**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Codice**
```
sqsClient.sendMessage(SendMessageRequest.builder()
.queueUrl(queueUrl)
.messageBody("Hello world!")
.delaySeconds(10)
.build());
sqsClient.sendMessage(sendMsgRequest);
```
## Invia più messaggi in una richiesta
Invia più messaggi in una singola richiesta utilizzando il metodo SqsClient di `sendMessageBatch`. Questo metodo richiede un file [SendMessageBatchRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageBatchRequest.html)che contenga l'URL della coda e un elenco di messaggi da inviare. (Ogni messaggio è un [SendMessageBatchRequestEntry](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageBatchRequestEntry.html).) Puoi anche ritardare l'invio di un messaggio specifico impostando un valore di ritardo nel messaggio.
**Importazioni**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Codice**
```
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);
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L133) su GitHub.
## Recuperare messaggi
Recupera eventuali messaggi che si trovano attualmente nella coda chiamando il metodo SqsClient di `receiveMessage`. Questo metodo accetta un file [ReceiveMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ReceiveMessageRequest.html)che contiene l'URL della coda. Puoi specificare il numero massimo di messaggi da restituire. I messaggi vengono restituiti come un elenco di oggetti [Message](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/Message.html).
**Importazioni**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Codice**
```
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;
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L148) su. GitHub
## Eliminare un messaggio dopo la ricezione
Dopo aver ricevuto un messaggio e averne elaborato il contenuto, eliminatelo dalla coda inviando al metodo l'handle di ricezione e l'URL di coda del `SqsClient's` [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))messaggio.
**Importazioni**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Codice**
```
try {
for (Message message : messages) {
DeleteMessageRequest deleteMessageRequest = DeleteMessageRequest.builder()
.queueUrl(queueUrl)
.receiptHandle(message.receiptHandle())
.build();
sqsClient.deleteMessage(deleteMessageRequest);
}
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L187) su. GitHub
## Ulteriori informazioni
+ [Come funzionano Amazon Simple Queue Service le code](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-basic-architecture.html) nella Guida per gli Amazon Simple Queue Service sviluppatori
+ [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)nell' Amazon Simple Queue Service API Reference
+ [SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)nell' Amazon Simple Queue Service API Reference
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)nell' Amazon Simple Queue Service API Reference
+ [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)nell' Amazon Simple Queue Service API Reference
# Lavora con Amazon Transcribe
L'esempio seguente mostra come funziona lo streaming bidirezionale con Amazon Transcribe. Lo streaming bidirezionale implica che ci sia un flusso di dati verso il servizio e in direzione opposta in tempo reale. L'esempio utilizza la trascrizione Amazon Transcribe in streaming per inviare un flusso audio e ricevere un flusso di testo trascritto in tempo reale.
Per ulteriori informazioni [su questa funzionalità, consulta Streaming Transcription](https://docs.aws.amazon.com//transcribe/latest/dg/streaming.html) nella Guida per gli Amazon Transcribe sviluppatori.
Per [iniziare a utilizzare](https://docs.aws.amazon.com//transcribe/latest/dg/getting-started.html), consulta la sezione Guida introduttiva nella Guida per gli Amazon Transcribe sviluppatori. Amazon Transcribe
## Configura il microfono
Questo codice usa il pacchetto javax.sound.sampled per lo streaming audio da un dispositivo di input.
**Codice**
```
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;
}
}
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/Microphone.java) su GitHub.
## Crea un editore
Questo codice implementa un editore che pubblica dati audio dal flusso Amazon Transcribe audio.
**Codice**
```
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();
}
}
}
```
Vedi l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/AudioStreamPublisher.java) su. GitHub
## Crea il client e avvia lo streaming
Nel metodo principale, è necessario creare un oggetto richiesta, avviare il flusso di input audio e creare un'istanza per il publisher con l’input audio.
È inoltre necessario creare un [StartStreamTranscriptionResponseHandler](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/transcribestreaming/model/StartStreamTranscriptionResponseHandler.html)file per specificare come gestire la risposta da Amazon Transcribe.
Quindi, usa il `startStreamTranscription` metodo TranscribeStreamingAsyncClient's per avviare lo streaming bidirezionale.
**Importazioni**
```
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;
```
**Codice**
```
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);
}
}
```
Guarda l'[esempio completo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/BidirectionalStreaming.java) su. GitHub
## Ulteriori informazioni
+ [Come funziona](https://docs.aws.amazon.com//transcribe/latest/dg/how-it-works.html) nella Guida per gli Amazon Transcribe sviluppatori.
+ [Guida introduttiva allo streaming audio](https://docs.aws.amazon.com//transcribe/latest/dg/getting-started.html) nella Guida per Amazon Transcribe gli sviluppatori.