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();
}
}
```
Dans cet exemple, la `fromJson` méthode convertit la chaîne JSON en `S3EventNotification` objet. Les champs manquants dans la chaîne JSON se traduiront par `null` des valeurs dans les champs d'objet Java correspondants et tous les champs supplémentaires dans le JSON seront ignorés.
D'autres APIs informations relatives à un enregistrement de notification d'événement peuvent être trouvées dans la référence de l'API pour`[S3EventNotificationRecord](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/eventnotifications/s3/model/S3EventNotificationRecord.html)`.
#### Convertir une `S3EventNotification` instance en chaîne JSON
Utilisez la méthode `toJson` (or`toJsonPretty`) pour convertir un `S3EventNotification` objet en chaîne JSON, comme illustré dans l'exemple suivant.
```
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);
}
}
```
Les champs pour `GlacierEventData``ReplicationEventData`,`IntelligentTieringEventData`, et `LifecycleEventData` sont exclus du JSON s'ils le sont`null`. `null`Les autres champs seront sérialisés en tant que`null`.
Voici un exemple de sortie de la `toJsonPretty` méthode pour un événement de balisage d'objets 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
}
}
} ]
}
```
Un [exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/75c3daadf750406156fc87fa30ee499a206b4a36/javav2/example_code/s3/src/main/java/com/example/s3/ProcessS3EventNotification.java#L117) est disponible dans GitHub lequel il montre comment utiliser l'API pour traiter les notifications reçues par une file d'attente Amazon SQS.
## Traitez les événements S3 dans Lambda avec les bibliothèques Java : et AWS SDK for Java 2.x `aws-lambda-java-events`
Au lieu d'utiliser le SDK pour Java 2.x pour traiter les notifications d'événements Amazon S3 dans une fonction Lambda, vous pouvez utiliser `[aws-lambda-java-events](https://github.com/aws/aws-lambda-java-libs/tree/main/aws-lambda-java-events)` la bibliothèque en version 3.x.x. AWS gère la `aws-lambda-java-events` bibliothèque de manière indépendante, et elle a ses propres exigences de dépendance. La `aws-lambda-java-events` bibliothèque fonctionne uniquement avec les événements S3 dans les fonctions Lambda, tandis que le SDK pour Java 2.x fonctionne avec les événements S3 dans les fonctions Lambda, Amazon SNS et Amazon SQS.
Les deux approches modélisent la charge utile des notifications d'événements JSON d'une manière orientée objet avec une approche similaire. APIs Le tableau suivant montre les différences notables entre l'utilisation des deux approches.
****
| | AWS SDK pour Java | aws-lambda-java-events bibliothèque |
| --- | --- | --- |
| Dénomination du package | `software.amazon.awssdk.eventnotifications.s3.model.S3EventNotification` | com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification |
| RequestHandler paramètre | Écrivez l'`RequestHandler`implémentation de votre fonction Lambda pour recevoir une chaîne 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.
...
}
}
| Écrivez l'RequestHandlerimplémentation de votre fonction Lambda pour recevoir un S3Event objet :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.
...
}
}
|
| Dépendances de 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
|
# Travaillez avec Amazon Simple Notification Service
Avec Amazon Simple Notification Service, vous pouvez facilement envoyer des messages de notification en temps réel de vos applications aux abonnés via plusieurs canaux de communication. Cette rubrique décrit comment exécuter certaines des fonctions de base de Amazon SNS.
## Créer une rubrique
Un **sujet** est un regroupement logique de canaux de communication qui définit les systèmes auxquels envoyer un message, par exemple en diffusant un message AWS Lambda et en envoyant un webhook HTTP. Vous envoyez des messages à Amazon SNS, puis ils sont distribués aux canaux définis dans le sujet. Les messages sont alors disponibles pour les abonnés.
Pour créer un sujet, créez d'abord un [CreateTopicRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/CreateTopicRequest.html)objet, avec le nom du sujet défini à l'aide de la `name()` méthode du générateur. Envoyez ensuite l'objet de demande à Amazon SNS en utilisant la `createTopic()` méthode du [SnsClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/SnsClient.html). Vous pouvez capturer le résultat de cette demande sous forme d'[CreateTopicResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/CreateTopicResponse.html)objet, comme illustré dans l'extrait de code suivant.
**Importations**
```
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;
```
**Code**
```
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 "";
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/CreateTopic.java) sur GitHub.
## Listez vos Amazon SNS sujets
Pour récupérer la liste de vos Amazon SNS sujets existants, créez un [ListTopicsRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/ListTopicsRequest.html)objet. Envoyez ensuite l'objet de demande à Amazon SNS en utilisant la `listTopics()` méthode du`SnsClient`. Vous pouvez capturer le résultat de cette demande sous forme d'[ListTopicsResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/ListTopicsResponse.html)objet.
L'extrait de code suivant affiche le code d'état HTTP de la demande et une liste des Amazon Resource Names (ARNs) pour vos Amazon SNS sujets.
**Importations**
```
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;
```
**Code**
```
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);
}
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/ListTopics.java) sur GitHub.
## Abonner un point de terminaison à une rubrique
Après avoir créé une rubrique, vous pouvez configurer les canaux de communication qui deviendront des points de terminaison pour cette rubrique. Les messages sont distribués à ces points de terminaison après les avoir Amazon SNS reçus.
Pour configurer un canal de communication en tant que point de terminaison pour une rubrique, abonnez ce point de terminaison à la rubrique. Pour commencer, créez un [SubscribeRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/SubscribeRequest.html)objet. Spécifiez le canal de communication (par exemple, `lambda` ou`email`) en tant que`protocol()`. Définissez l'emplacement `endpoint()` de sortie approprié (par exemple, l'ARN d'une Lambda fonction ou une adresse e-mail), puis définissez l'ARN du sujet auquel vous souhaitez vous abonner en tant que`topicArn()`. Envoyez l'objet de demande à Amazon SNS en utilisant la `subscribe()` méthode du`SnsClient`. Vous pouvez capturer le résultat de cette demande sous forme d'[SubscribeResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/SubscribeResponse.html)objet.
L'extrait de code suivant montre comment abonner une adresse e-mail à une rubrique.
**Importations**
```
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;
```
**Code**
```
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);
}
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/SubscribeEmail.java) sur GitHub.
## Publier un message dans une rubrique
Après avoir configuré une rubrique et un ou plusieurs points de terminaison, vous pouvez y publier un message. Pour commencer, créez un [PublishRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/PublishRequest.html)objet. Spécifiez le `message()` à envoyer et l'ARN de la rubrique (`topicArn()`) à laquelle l'envoyer. Envoyez ensuite l'objet de demande à Amazon SNS en utilisant la `publish()` méthode du`SnsClient`. Vous pouvez capturer le résultat de cette demande sous forme d'[PublishResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/PublishResponse.html)objet.
**Importations**
```
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;
```
**Code**
```
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);
}
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/PublishTopic.java) sur GitHub.
## Désabonner un point de terminaison à une rubrique
Vous pouvez supprimer les canaux de communication configurés en tant que points de terminaison pour une rubrique. Après cela, la rubrique elle-même continue d'exister et de diffuser des messages à tous les autres points de terminaison configurés pour cette rubrique.
Pour supprimer un canal de communication en tant que point de terminaison pour une rubrique, annulez l’abonnement du point de terminaison à la rubrique. Pour commencer, créez un [UnsubscribeRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/UnsubscribeRequest.html)objet et définissez l'ARN du sujet dont vous souhaitez vous désabonner comme étant le`subscriptionArn()`. Ensuite, envoyez l'objet de demande à SNS en utilisant la méthode `unsubscribe()` du `SnsClient`. Vous pouvez capturer le résultat de cette demande sous forme d'[UnsubscribeResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/UnsubscribeResponse.html)objet.
**Importations**
```
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;
```
**Code**
```
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);
}
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/Unsubscribe.java) sur GitHub.
## Supprimer une rubrique
Pour supprimer un Amazon SNS sujet, créez d'abord un [DeleteTopicRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/DeleteTopicRequest.html)objet avec l'ARN du sujet défini comme `topicArn()` méthode dans le générateur. Envoyez ensuite l'objet de demande à Amazon SNS en utilisant la `deleteTopic()` méthode du`SnsClient`. Vous pouvez capturer le résultat de cette demande sous forme d'[DeleteTopicResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/DeleteTopicResponse.html)objet, comme illustré dans l'extrait de code suivant.
**Importations**
```
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;
```
**Code**
```
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);
}
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/DeleteTopic.java) sur GitHub.
Pour plus d’informations, consultez le [Manuel du développeur Amazon Simple Notification Service](https://docs.aws.amazon.com/sns/latest/dg/).
# Travaillez avec Amazon Simple Queue Service
Cette section fournit des exemples de programmation à l'[Amazon Simple Queue Service](https://docs.aws.amazon.com/sqs/)aide de la version AWS SDK pour Java 2.x.
Les exemples suivants incluent uniquement le code nécessaire pour démontrer chaque technique. L'[exemple de code complet est disponible sur GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2). À partir de là, vous pouvez télécharger un fichier source unique ou cloner le référentiel en local pour obtenir tous les exemples à générer et exécuter.
**Topics**
+ [Utiliser le traitement automatique des demandes par lots](sqs-auto-batch.md)
+ [Opérations sur les files](examples-sqs-message-queues.md)
+ [Opérations relatives aux messages](examples-sqs-messages.md)
# Utilisez le traitement automatique des demandes par lots pour Amazon SQS avec AWS SDK for Java 2.x
L'API Automatic Request Batching pour Amazon SQS est une bibliothèque de haut niveau qui fournit un moyen efficace de regrouper et de mettre en mémoire tampon les demandes pour les opérations SQS. En utilisant l'API de traitement par lots, vous réduisez le nombre de demandes adressées à SQS, ce qui améliore le débit et minimise les coûts.
Comme les méthodes de l'API par lots correspondent aux `[SqsAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/SqsAsyncClient.html)` méthodes (`sendMessage`,,,),`changeMessageVisibility`,`deleteMessage`,,`receiveMessage`,,,,,,, vous pouvez utiliser l'API par lots en remplacement avec un minimum de modifications.
Cette rubrique explique comment configurer et utiliser l'API Automatic Request Batching pour Amazon SQS.
## Vérifiez les prérequis
Vous devez utiliser la version *2.28.0* ou ultérieure du SDK pour Java 2.x pour avoir accès à l'API de traitement par lots. Votre Maven `pom.xml` doit au moins contenir les éléments suivants.
```
software.amazon.awssdk
bom
2.28.231
pom
import
software.amazon.awssdk
sqs
```
1 [Dernière version](https://central.sonatype.com/artifact/software.amazon.awssdk/bom)
## Création d'un gestionnaire de lots
L'API de traitement automatique des demandes par lots est implémentée par l'[SqsAsyncBatchManager](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html)interface. Vous pouvez créer une instance du gestionnaire de plusieurs manières.
### Configuration par défaut en utilisant `SqsAsyncClient`
Le moyen le plus simple de créer un gestionnaire de lots consiste à appeler la méthode d'`batchManager`usine sur une [SqsAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/SqsAsyncClient.html)instance existante. L'approche simple est illustrée dans l'extrait suivant.
```
SqsAsyncClient asyncClient = SqsAsyncClient.create();
SqsAsyncBatchManager sqsAsyncBatchManager = asyncClient.batchManager();
```
Lorsque vous utilisez cette approche, l'`SqsAsyncBatchManager`instance utilise les valeurs par défaut indiquées dans le tableau de la [Remplacer les paramètres de configuration pour `SqsAsyncBatchManager`](#sqs-auto-batch-config-settings) section. En outre, l'`SqsAsyncBatchManager`instance utilise `ExecutorService` l'`SqsAsyncClient`instance à partir de laquelle elle a été créée.
### Configuration personnalisée en utilisant `SqsAsyncBatchManager.Builder`
Pour des cas d'utilisation plus avancés, vous pouvez personnaliser le gestionnaire de lots à l'aide du [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). En utilisant cette approche pour créer une `SqsAsyncBatchManager` instance, vous pouvez affiner le comportement de traitement par lots. L'extrait suivant montre un exemple d'utilisation du générateur pour personnaliser le comportement de traitement par lots.
```
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();
```
Lorsque vous utilisez cette approche, vous pouvez ajuster les paramètres de l'`BatchOverrideConfiguration`objet présentés dans le tableau de la [Remplacer les paramètres de configuration pour `SqsAsyncBatchManager`](#sqs-auto-batch-config-settings) section. Vous pouvez également fournir une personnalisation [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)pour le gestionnaire de lots en utilisant cette approche.
## Envoyer des messages
Pour envoyer des messages avec le gestionnaire de lots, utilisez la `[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))` méthode. Le SDK met en mémoire tampon les demandes et les envoie sous forme de lot lorsque les `sendRequestFrequency` valeurs `maxBatchSize` or sont atteintes.
L'exemple suivant montre une `sendMessage` demande immédiatement suivie d'une autre demande. Dans ce cas, le SDK envoie les deux messages en un seul lot.
```
// 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();
```
## Modifier le délai de visibilité des messages
Vous pouvez modifier le délai de visibilité des messages d'un lot à l'aide de [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))cette méthode. Le SDK met en mémoire tampon les demandes et les envoie sous forme de lot lorsque les `sendRequestFrequency` valeurs `maxBatchSize` or sont atteintes.
L'exemple suivant montre comment appeler la `changeMessageVisibility` méthode.
```
CompletableFuture futureOne =
sqsAsyncBatchManager.changeMessageVisibility(r ->
r.receiptHandle("receiptHandle")
.queueUrl("queue"));
ChangeMessageVisibilityResponse response = futureOne.join();
```
## Supprimer des messages
Vous pouvez supprimer des messages par lots à l'aide de [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))cette méthode. Le SDK met en mémoire tampon les demandes et les envoie sous forme de lot lorsque les `sendRequestFrequency` valeurs `maxBatchSize` or sont atteintes.
L'exemple suivant montre comment appeler la `deleteMessage` méthode.
```
CompletableFuture futureOne =
sqsAsyncBatchManager.deleteMessage(r ->
r.receiptHandle("receiptHandle")
.queueUrl("queue"));
DeleteMessageResponse response = futureOne.join();
```
## Recevoir des messages
### Utiliser les paramètres par défaut
Lorsque vous interrogez la `[SqsAsyncBatchManager\$1receiveMessage](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html#receiveMessage(java.util.function.Consumer))` méthode dans votre application, le gestionnaire de lots extrait les messages de sa mémoire tampon interne, que le SDK met automatiquement à jour en arrière-plan.
L'exemple suivant montre comment appeler la `receiveMessage` méthode.
```
CompletableFuture responseFuture =
sqsAsyncBatchManager.receiveMessage(r -> r.queueUrl("queueUrl"));
```
### Utiliser des paramètres personnalisés
Si vous souhaitez personnaliser davantage la demande, par exemple en définissant des temps d'attente personnalisés et en spécifiant le nombre de messages à récupérer, vous pouvez personnaliser la demande comme indiqué dans l'exemple suivant.
```
CompletableFuture response =
sqsAsyncBatchManager.receiveMessage(r ->
r.queueUrl("queueUrl")
.waitTimeSeconds(5)
.visibilityTimeout(20));
```
**Note**
Si vous appelez `receiveMessage` avec un `[ReceiveMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ReceiveMessageRequest.html)` qui inclut l'un des paramètres suivants, le SDK contourne le gestionnaire de lots et envoie une demande asynchrone `receiveMessage` normale :
`messageAttributeNames`
`messageSystemAttributeNames`
`messageSystemAttributeNamesWithStrings`
`overrideConfiguration`
## Remplacer les paramètres de configuration pour `SqsAsyncBatchManager`
Vous pouvez ajuster les paramètres suivants lorsque vous créez une `SqsAsyncBatchManager` instance. La liste de paramètres suivante est disponible sur le [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).
| Paramètre | Description | Valeur par défaut |
| --- | --- | --- |
| maxBatchSize | Nombre maximum de demandes par lot pour chaque SendMessageBatchRequestChangeMessageVisibilityBatchRequest, ouDeleteMessageBatchRequest. La valeur maximale est 10. | 10 |
| sendRequestFrequency | Durée avant l'envoi d'un lot, sauf si `maxBatchSize` elle est atteinte plus tôt. Des valeurs plus élevées peuvent réduire les demandes mais augmenter le temps de latence. | 200 ms |
| receiveMessageVisibilityTimeout | Délai de visibilité pour les messages. S'il n'est pas défini, la valeur par défaut de la file d'attente est utilisée. | Par défaut de la file d'attente |
| receiveMessageMinWaitDuration | Temps d'attente minimal pour les receiveMessage demandes. Évitez de mettre à 0 pour éviter le gaspillage du processeur. | 50 ms |
| receiveMessageSystemAttributeNames | Liste des [noms d'attributs système](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/MessageSystemAttributeName.html) à demander pour les receiveMessage appels. | Aucune |
| receiveMessageAttributeNames | Liste des [noms d'attributs](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-metadata.html#sqs-message-attributes) à demander pour les receiveMessage appels. | Aucune |
# Travailler avec les files d'attente de Amazon Simple Queue Service messages
Une *file de messages* est le conteneur logique utilisé pour envoyer des messages de manière fiable Amazon Simple Queue Service. Il existe deux types de files d'attente : *standard* et *FIFO* (premier entré, premier sorti). Pour en savoir plus sur les files d'attente et les différences entre ces types, consultez le [guide du Amazon Simple Queue Service développeur](https://docs.aws.amazon.com//AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html).
Cette rubrique décrit comment créer, répertorier, supprimer et obtenir l'URL d'une Amazon Simple Queue Service file d'attente à l'aide du AWS SDK pour Java.
La `sqsClient` variable utilisée dans les exemples suivants peut être créée à partir de l'extrait de code suivant.
```
SqsClient sqsClient = SqsClient.create();
```
Lorsque vous créez un en `SqsClient` utilisant la `create()` méthode statique, le SDK configure la région en utilisant la chaîne de fournisseurs de régions par [défaut et les informations d'identification en utilisant la chaîne de fournisseurs](region-selection.md#default-region-provider-chain) d'informations [d'identification par défaut](credentials-chain.md).
## Création d’une file d’attente
Utilisez la `SqsClient’s` `createQueue` méthode et fournissez un `[CreateQueueRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/CreateQueueRequest.html)` objet qui décrit les paramètres de la file d'attente, comme indiqué dans l'extrait de code suivant.
**Importations**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Code**
```
CreateQueueRequest createQueueRequest = CreateQueueRequest.builder()
.queueName(queueName)
.build();
sqsClient.createQueue(createQueueRequest);
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L52) sur GitHub.
## Répertorier les files d'attente
Pour répertorier les Amazon Simple Queue Service files d'attente pour votre compte, appelez la `SqsClient’s` `listQueues` méthode avec un `[ListQueuesRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ListQueuesRequest.html)` objet.
Lorsque vous utilisez la forme de la [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())méthode qui ne prend aucun paramètre, le service renvoie *toutes les files d'attente, jusqu'à 1 000 files d'attente*.
Vous pouvez fournir un préfixe de nom de file d'attente à l'`[ListQueuesRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ListQueuesRequest.html)`objet pour limiter les résultats aux files d'attente correspondant à ce préfixe, comme indiqué dans le code suivant.
**Importations**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Code**
```
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);
}
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L79) sur GitHub.
## Obtenir l'URL d'une file d'attente
Le code suivant montre comment obtenir l'URL d'une file d'attente en appelant la `SqsClient’s` `getQueueUrl` méthode avec un `[GetQueueUrlRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/GetQueueUrlRequest.html)` objet.
**Importations**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Code**
```
GetQueueUrlResponse getQueueUrlResponse =
sqsClient.getQueueUrl(GetQueueUrlRequest.builder().queueName(queueName).build());
String queueUrl = getQueueUrlResponse.queueUrl();
return queueUrl;
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/7486a1a092aa8e16a21698ef26f9d524fef62e55/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L70) sur GitHub.
## Suppression d’une file d’attente
Fournissez l'[URL](#sqs-get-queue-url) de la file d'attente vers l'`[DeleteQueueRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/DeleteQueueRequest.html)`objet. Appelez ensuite la `SqsClient’s` `deleteQueue` méthode pour supprimer une file d'attente comme indiqué dans le code suivant.
**Importations**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Code**
```
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);
}
}
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/6240df86c5f17eae1e23d1139d1435c7dc4b2a11/javav2/example_code/sqs/src/main/java/com/example/sqs/DeleteQueue.java#L48) sur GitHub.
## En savoir plus
+ [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)dans la référence de Amazon Simple Queue Service l'API
+ [GetQueueUrl](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueUrl.html)dans la référence de Amazon Simple Queue Service l'API
+ [ListQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html)dans la référence de Amazon Simple Queue Service l'API
+ [DeleteQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueue.html)dans la référence de Amazon Simple Queue Service l'API
# Envoyer, recevoir et supprimer Amazon Simple Queue Service des messages
Un message est une portion de données qui peut être envoyée et reçue par des composants distribués. Les messages sont toujours livrés à l'aide d'une [file d'attente SQS](examples-sqs-message-queues.md).
La `sqsClient` variable utilisée dans les exemples suivants peut être créée à partir de l'extrait de code suivant.
```
SqsClient sqsClient = SqsClient.create();
```
Lorsque vous créez un en `SqsClient` utilisant la `create()` méthode statique, le SDK configure la région en utilisant la chaîne de fournisseurs de régions par [défaut et les informations d'identification en utilisant la chaîne de fournisseurs](region-selection.md#default-region-provider-chain) d'informations [d'identification par défaut](credentials-chain.md).
## Envoyer un message
Ajoutez un seul message à une Amazon Simple Queue Service file d'attente en appelant la `sendMessage` méthode SqsClient client. Fournissez un [SendMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageRequest.html)objet contenant l'[URL](examples-sqs-message-queues.md#sqs-get-queue-url) de la file d'attente, le corps du message et la valeur de délai facultative (en secondes).
**Importations**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Code**
```
sqsClient.sendMessage(SendMessageRequest.builder()
.queueUrl(queueUrl)
.messageBody("Hello world!")
.delaySeconds(10)
.build());
sqsClient.sendMessage(sendMsgRequest);
```
## Envoyer plusieurs messages dans une demande
Envoyez plusieurs messages dans une seule demande à l'aide de la méthode `sendMessageBatch` d' SqsClient . Cette méthode utilise un [SendMessageBatchRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageBatchRequest.html)qui contient l'URL de la file d'attente et une liste de messages à envoyer. (Chaque message est un [SendMessageBatchRequestEntry](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageBatchRequestEntry.html).) Vous pouvez aussi retarder l'envoi d'un message spécifique en définissant une valeur de retard sur le message.
**Importations**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Code**
```
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);
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L133) sur GitHub.
## Extraction des messages
Récupérez tous les messages qui sont actuellement dans la file d'attente en appelant la méthode `receiveMessage` d' SqsClient . Cette méthode utilise un [ReceiveMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ReceiveMessageRequest.html)qui contient l'URL de la file d'attente. Vous pouvez également spécifier le nombre maximal de messages à renvoyer. Les messages sont renvoyés sous la forme d'une liste d'objets [Message](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/Message.html).
**Importations**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Code**
```
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;
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L148) sur GitHub.
## Supprimer un message après réception
Après avoir reçu un message et traité son contenu, supprimez-le de la file d'attente en envoyant le descripteur de réception du message et l'URL de la file d'attente à la `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))méthode.
**Importations**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Code**
```
try {
for (Message message : messages) {
DeleteMessageRequest deleteMessageRequest = DeleteMessageRequest.builder()
.queueUrl(queueUrl)
.receiptHandle(message.receiptHandle())
.build();
sqsClient.deleteMessage(deleteMessageRequest);
}
```
Voir l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L187) sur GitHub.
## Plus d'informations
+ [Comment fonctionnent les Amazon Simple Queue Service files d'attente](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-basic-architecture.html) dans le guide du Amazon Simple Queue Service développeur
+ [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)dans la référence de Amazon Simple Queue Service l'API
+ [SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)dans la référence de Amazon Simple Queue Service l'API
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)dans la référence de Amazon Simple Queue Service l'API
+ [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)dans la référence de Amazon Simple Queue Service l'API
# Travaillez avec Amazon Transcribe
L'exemple suivant montre comment le streaming bidirectionnel fonctionne avec Amazon Transcribe. Le streaming bidirectionnel implique qu'un flux de données soit à la fois envoyé au service et reçu en temps réel. L'exemple utilise la transcription Amazon Transcribe en continu pour envoyer un flux audio et recevoir un flux de texte transcrit en temps réel.
Consultez la section [Transcription en streaming](https://docs.aws.amazon.com//transcribe/latest/dg/streaming.html) dans le guide du Amazon Transcribe développeur pour en savoir plus sur cette fonctionnalité.
Consultez [Getting Started](https://docs.aws.amazon.com//transcribe/latest/dg/getting-started.html) dans le guide du Amazon Transcribe développeur pour commencer à utiliser Amazon Transcribe.
## Configurez le microphone
Ce code utilise le package javax.sound.sampled pour créer un flux en streaming audio à partir d'un périphérique d'entrée.
**Code**
```
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;
}
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/Microphone.java) sur GitHub.
## Création d'un éditeur
Ce code implémente un éditeur qui publie les données audio à partir du flux Amazon Transcribe audio.
**Code**
```
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();
}
}
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/AudioStreamPublisher.java) sur GitHub.
## Créez le client et lancez le stream
Dans la méthode principale, créez une demande d'objet, démarrez le flux d'entrée audio et instanciez l'éditeur avec l'entrée audio.
Vous devez également créer un [StartStreamTranscriptionResponseHandler](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/transcribestreaming/model/StartStreamTranscriptionResponseHandler.html)pour spécifier comment gérer la réponse de Amazon Transcribe.
Ensuite, utilisez la `startStreamTranscription` méthode TranscribeStreamingAsyncClient's pour démarrer le streaming bidirectionnel.
**Importations**
```
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;
```
**Code**
```
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);
}
}
```
Consultez l'[exemple complet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/BidirectionalStreaming.java) sur GitHub.
## En savoir plus
+ [Comment cela fonctionne](https://docs.aws.amazon.com//transcribe/latest/dg/how-it-works.html) dans le guide du Amazon Transcribe développeur.
+ [Pour démarrer avec le streaming audio](https://docs.aws.amazon.com//transcribe/latest/dg/getting-started.html), consultez le guide du Amazon Transcribe développeur.