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 diesem Beispiel konvertiert die `fromJson` Methode die JSON-Zeichenfolge in ein `S3EventNotification` Objekt. Fehlende Felder in der JSON-Zeichenfolge führen zu `null` Werten in den entsprechenden Java-Objektfeldern, und alle zusätzlichen Felder in der JSON-Zeichenfolge werden ignoriert.
APIs Weitere Informationen zu einer Ereignisbenachrichtigung finden Sie in der API-Referenz für`[S3EventNotificationRecord](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/eventnotifications/s3/model/S3EventNotificationRecord.html)`.
#### Konvertiert eine `S3EventNotification` Instanz in eine JSON-Zeichenfolge
Verwenden Sie die Methode `toJson` (or`toJsonPretty`), um ein `S3EventNotification` Objekt in eine JSON-Zeichenfolge zu konvertieren, wie im folgenden Beispiel gezeigt.
```
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);
}
}
```
Felder für`GlacierEventData`, `ReplicationEventData``IntelligentTieringEventData`, und `LifecycleEventData` sind aus dem JSON ausgeschlossen, falls sie es sind`null`. Andere `null` Felder werden als `null` serialisiert.
Im Folgenden wird eine Beispielausgabe der `toJsonPretty` Methode für ein S3-Objekt-Tagging-Ereignis gezeigt.
```
{
"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
}
}
} ]
}
```
Ein [vollständiges Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/75c3daadf750406156fc87fa30ee499a206b4a36/javav2/example_code/s3/src/main/java/com/example/s3/ProcessS3EventNotification.java#L117) ist verfügbar GitHub , das zeigt, wie die API verwendet wird, um mit Benachrichtigungen zu arbeiten, die von einer Amazon SQS SQS-Warteschlange empfangen wurden.
## S3-Ereignisse in Lambda mit Java-Bibliotheken verarbeiten: AWS SDK for Java 2.x und `aws-lambda-java-events`
Anstatt das SDK for Java 2.x zur Verarbeitung von Amazon S3 S3-Ereignisbenachrichtigungen in einer Lambda-Funktion zu verwenden, können Sie die `[aws-lambda-java-events](https://github.com/aws/aws-lambda-java-libs/tree/main/aws-lambda-java-events)` Bibliothek in Version 3.x.x verwenden. AWS verwaltet die `aws-lambda-java-events` Bibliothek unabhängig und hat ihre eigenen Abhängigkeitsanforderungen. Die `aws-lambda-java-events` Bibliothek funktioniert nur mit S3-Ereignissen in Lambda-Funktionen, wohingegen das SDK for Java 2.x mit S3-Ereignissen in Lambda-Funktionen, Amazon SNS und Amazon SQS funktioniert.
Beide Ansätze modellieren die Nutzlast für JSON-Ereignisbenachrichtigungen auf objektorientierte Weise mit ähnlichen Methoden. APIs Die folgende Tabelle zeigt die wesentlichen Unterschiede zwischen der Verwendung der beiden Ansätze.
****
| | AWS SDK für Java | aws-lambda-java-events Bibliothek |
| --- | --- | --- |
| Benennung von Paketen | `software.amazon.awssdk.eventnotifications.s3.model.S3EventNotification` | com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification |
| RequestHandler Parameter | Schreiben Sie die `RequestHandler` Implementierung Ihrer Lambda-Funktion, um eine JSON-Zeichenfolge zu erhalten: 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.
...
}
}
| Schreiben Sie die RequestHandler Implementierung Ihrer Lambda-Funktion, um ein S3Event Objekt zu empfangen: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.
...
}
}
|
| Maven-Abhängigkeiten |
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
|
# Arbeite mit Amazon Simple Notification Service
Mit Amazon Simple Notification Service können Sie ganz einfach Benachrichtigungen in Echtzeit von Ihren Anwendungen über mehrere Kommunikationskanäle an Abonnenten senden. In diesem Thema wird beschrieben, wie Sie einige der Grundfunktionen von ausführen Amazon SNS.
## Erstellen eines Themas
Ein **Thema** ist eine logische Gruppierung von Kommunikationskanälen, die definiert, an welche Systeme eine Nachricht gesendet werden soll, z. B. das Auffächern einer Nachricht AWS Lambda und ein HTTP-Webhook. Sie senden Nachrichten an Amazon SNS, dann werden sie an die im Thema definierten Kanäle verteilt. Dadurch werden die Nachrichten für Abonnenten zur Verfügung gestellt.
Um ein Thema zu erstellen, erstellen Sie zunächst ein [CreateTopicRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/CreateTopicRequest.html)Objekt, wobei der Name des Themas mithilfe der `name()` Methode im Builder festgelegt ist. Senden Sie dann das Anforderungsobjekt an, Amazon SNS indem Sie die `createTopic()` Methode von verwenden [SnsClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/SnsClient.html). Sie können das Ergebnis dieser Anfrage als [CreateTopicResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/CreateTopicResponse.html)Objekt erfassen, wie im folgenden Codeausschnitt gezeigt.
**Importe**
```
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 "";
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/CreateTopic.java) finden Sie unter. GitHub
## Listen Sie Ihre Amazon SNS Themen auf
Um eine Liste Ihrer vorhandenen Amazon SNS Themen abzurufen, erstellen Sie ein [ListTopicsRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/ListTopicsRequest.html)Objekt. Senden Sie dann das Anforderungsobjekt an, Amazon SNS indem Sie die `listTopics()` Methode von verwenden`SnsClient`. Sie können das Ergebnis dieser Anfrage als [ListTopicsResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/ListTopicsResponse.html)Objekt erfassen.
Der folgende Codeausschnitt druckt den HTTP-Statuscode der Anfrage und eine Liste von Amazon-Ressourcennamen (ARNs) für Ihre Amazon SNS Themen aus.
**Importe**
```
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);
}
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/ListTopics.java) finden Sie unter. GitHub
## Abonnieren eines Endpunkts für ein Thema
Nachdem Sie ein Thema erstellt haben, können Sie konfigurieren, welche Kommunikationskanäle Endpunkte für dieses Thema sein sollen. Nachrichten werden an diese Endpunkte verteilt, nachdem sie Amazon SNS empfangen wurden.
Wenn Sie einen Kommunikationskanal als Endpunkt für ein Thema konfigurieren möchten, abonnieren Sie diesen Endpunkt für das Thema. Erstellen Sie zunächst ein [SubscribeRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/SubscribeRequest.html)Objekt. Geben Sie den Kommunikationskanal (z. B. `lambda` oder`email`) als an`protocol()`. Stellen Sie das `endpoint()` auf den entsprechenden Ausgabespeicherort ein (z. B. den ARN einer Lambda Funktion oder eine E-Mail-Adresse), und legen Sie dann den ARN des Themas fest, das Sie abonnieren möchten, als`topicArn()`. Senden Sie das Anforderungsobjekt mit der `subscribe()` Methode von`SnsClient`. Amazon SNS Sie können das Ergebnis dieser Anfrage als [SubscribeResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/SubscribeResponse.html)Objekt erfassen.
Im folgenden Codeausschnitt wird dargestellt, wie Sie eine E-Mail-Adresse für ein Thema abonnieren.
**Importe**
```
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);
}
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/SubscribeEmail.java) finden Sie unter GitHub.
## Veröffentlichen einer Nachricht für ein Thema
Nachdem Sie ein Thema und einen oder mehrere Endpunkte dafür konfiguriert haben, können Sie eine Nachricht dafür veröffentlichen. Erstellen Sie zunächst ein [PublishRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/PublishRequest.html)Objekt. Geben Sie zum Senden `message()` und den ARN des Themas (`topicArn()`) an, an das es gesendet werden soll. Senden Sie dann das Anforderungsobjekt an, Amazon SNS indem Sie die `publish()` Methode von verwenden`SnsClient`. Sie können das Ergebnis dieser Anfrage als [PublishResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/PublishResponse.html)Objekt erfassen.
**Importe**
```
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);
}
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/PublishTopic.java) finden Sie unter GitHub.
## Abmelden eines Endpunkts von einem Thema
Sie können die als Endpunkte für ein Thema konfigurierten Kommunikationskanäle entfernen. Danach ist das Thema selbst weiterhin vorhanden und verteilt Nachrichten an alle anderen Endpunkte, die für dieses Thema konfiguriert sind.
Wenn Sie einen Kommunikationskanal als Endpunkt für ein Thema entfernen möchten, melden Sie diesen Endpunkt für das Thema ab. Erstellen Sie zunächst ein [UnsubscribeRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/UnsubscribeRequest.html)Objekt und legen Sie den ARN des Themas fest, von dem Sie sich abmelden möchten, als`subscriptionArn()`. Senden Sie dann das Anforderungsobjekt an SNS, indem Sie die Methode `unsubscribe()` von `SnsClient` verwenden. Sie können das Ergebnis dieser Anfrage als [UnsubscribeResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/UnsubscribeResponse.html)Objekt erfassen.
**Importe**
```
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);
}
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/Unsubscribe.java) finden Sie unter GitHub.
## Löschen eines Themas
Um ein Amazon SNS Thema zu löschen, erstellen Sie zunächst ein [DeleteTopicRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/DeleteTopicRequest.html)Objekt mit dem ARN des Themas, der als `topicArn()` Methode im Builder festgelegt ist. Senden Sie dann das Anforderungsobjekt an, Amazon SNS indem Sie die `deleteTopic()` Methode von verwenden`SnsClient`. Sie können das Ergebnis dieser Anfrage als [DeleteTopicResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/DeleteTopicResponse.html)Objekt erfassen, wie im folgenden Codeausschnitt gezeigt.
**Importe**
```
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);
}
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/DeleteTopic.java) finden Sie unter. GitHub
Weitere Informationen finden Sie im [Amazon Simple Notification Service -Entwicklerhandbuch](https://docs.aws.amazon.com/sns/latest/dg/).
# Arbeite mit Amazon Simple Queue Service
Dieser Abschnitt enthält Beispiele für die Programmierung [Amazon Simple Queue Service](https://docs.aws.amazon.com/sqs/)mit AWS SDK für Java 2.x.
Die folgenden Beispiele enthalten nur den Code, der zur Demonstration jeder Technik nötig ist. Der [vollständige Beispielcode ist verfügbar unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2). Von dort aus können Sie eine einzelne Quelldatei herunterladen oder das Repository klonen, um alle Beispiele lokal zu erstellen und auszuführen.
**Topics**
+ [Verwenden Sie die automatische Batchverarbeitung von Anfragen](sqs-auto-batch.md)
+ [Vorgänge in der Warteschlange](examples-sqs-message-queues.md)
+ [Nachrichtenoperationen](examples-sqs-messages.md)
# Verwenden Sie die automatische Batchverarbeitung von Anfragen für Amazon SQS mit dem AWS SDK for Java 2.x
Die Automatic Request Batching API für Amazon SQS ist eine Bibliothek auf hoher Ebene, die eine effiziente Möglichkeit bietet, Anfragen für SQS-Operationen zu stapeln und zu puffern. Durch die Verwendung der Batching-API reduzieren Sie die Anzahl der Anfragen an SQS, was den Durchsatz verbessert und die Kosten minimiert.
Da die Batch-API-Methoden mit den `[SqsAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/SqsAsyncClient.html)` Methoden—`sendMessage`,,`changeMessageVisibility`, `receiveMessage` —übereinstimmen`deleteMessage`, können Sie die Batch-API als direkten Ersatz mit minimalen Änderungen verwenden.
Dieses Thema gibt Ihnen einen Überblick über die Konfiguration und die Arbeit mit der Automatic Request Batching API für Amazon SQS.
## Überprüfen Sie die Voraussetzungen
Sie müssen Version *2.28.0* oder höher des SDK for Java 2.x verwenden, um auf die Batching-API zugreifen zu können. Ihr Maven `pom.xml` sollte mindestens die folgenden Elemente enthalten.
```
software.amazon.awssdk
bom
2.28.231
pom
import
software.amazon.awssdk
sqs
```
1 [Letzte Version](https://central.sonatype.com/artifact/software.amazon.awssdk/bom)
## Erstellen Sie einen Batch-Manager
Die automatische Batching-API für Anfragen wird von der [SqsAsyncBatchManager](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html)Schnittstelle implementiert. Sie können eine Instanz des Managers auf verschiedene Arten erstellen.
### Standardkonfiguration mithilfe von `SqsAsyncClient`
Die einfachste Methode zum Erstellen eines Batch-Managers besteht darin, die `batchManager` Factory-Methode für eine vorhandene [SqsAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/SqsAsyncClient.html)Instanz aufzurufen. Der einfache Ansatz wird im folgenden Snippet gezeigt.
```
SqsAsyncClient asyncClient = SqsAsyncClient.create();
SqsAsyncBatchManager sqsAsyncBatchManager = asyncClient.batchManager();
```
Wenn Sie diesen Ansatz verwenden, verwendet die `SqsAsyncBatchManager` Instanz die Standardwerte, die in der Tabelle im [Überschreiben Sie die Konfigurationseinstellungen für `SqsAsyncBatchManager`](#sqs-auto-batch-config-settings) Abschnitt aufgeführt sind. Darüber hinaus verwendet die `SqsAsyncBatchManager` Instanz die `ExecutorService` der `SqsAsyncClient` Instanz, aus der sie erstellt wurde.
### Benutzerdefinierte Konfiguration mithilfe von `SqsAsyncBatchManager.Builder`
Für fortgeschrittenere Anwendungsfälle können Sie den Batch-Manager mithilfe von anpassen [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). Wenn Sie diesen Ansatz verwenden, um eine `SqsAsyncBatchManager` Instanz zu erstellen, können Sie das Batching-Verhalten fein abstimmen. Der folgende Ausschnitt zeigt ein Beispiel dafür, wie Sie den Builder verwenden können, um das Batching-Verhalten anzupassen.
```
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();
```
Wenn Sie diesen Ansatz verwenden, können Sie die Einstellungen für das `BatchOverrideConfiguration` Objekt anpassen, die in der Tabelle im Abschnitt aufgeführt sind. [Überschreiben Sie die Konfigurationseinstellungen für `SqsAsyncBatchManager`](#sqs-auto-batch-config-settings) Mit diesem Ansatz können Sie auch einen benutzerdefinierten Wert [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)für den Batch-Manager angeben.
## Senden Sie Nachrichten
Verwenden Sie die `[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))` Methode, um Nachrichten mit dem Batch-Manager zu senden. Das SDK puffert Anfragen und sendet sie als Batch, wenn die `sendRequestFrequency` Werte `maxBatchSize` oder erreicht sind.
Das folgende Beispiel zeigt eine `sendMessage` Anfrage, auf die unmittelbar eine weitere Anfrage folgt. In diesem Fall sendet das SDK beide Nachrichten in einem einzigen 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();
```
## Ändern Sie das Timeout für die Sichtbarkeit von Nachrichten
Sie können das Sichtbarkeits-Timeout von Nachrichten in einem Batch mithilfe der [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))Methode ändern. Das SDK puffert Anfragen und sendet sie als Batch, wenn die `sendRequestFrequency` Werte `maxBatchSize` oder erreicht sind.
Das folgende Beispiel zeigt, wie die `changeMessageVisibility` Methode aufgerufen wird.
```
CompletableFuture futureOne =
sqsAsyncBatchManager.changeMessageVisibility(r ->
r.receiptHandle("receiptHandle")
.queueUrl("queue"));
ChangeMessageVisibilityResponse response = futureOne.join();
```
## Nachrichten löschen
Mit [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))dieser Methode können Sie Nachrichten stapelweise löschen. Das SDK puffert Anfragen und sendet sie als Batch, wenn die `sendRequestFrequency` Werte `maxBatchSize` oder erreicht sind.
Das folgende Beispiel zeigt, wie Sie die `deleteMessage` Methode aufrufen können.
```
CompletableFuture futureOne =
sqsAsyncBatchManager.deleteMessage(r ->
r.receiptHandle("receiptHandle")
.queueUrl("queue"));
DeleteMessageResponse response = futureOne.join();
```
## Empfangen Sie Nachrichten
### Verwenden Sie die Standardeinstellungen
Wenn Sie die `[SqsAsyncBatchManager\$1receiveMessage](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html#receiveMessage(java.util.function.Consumer))` Methode in Ihrer Anwendung abfragen, ruft der Batch-Manager Nachrichten aus seinem internen Puffer ab, den das SDK automatisch im Hintergrund aktualisiert.
Das folgende Beispiel zeigt, wie die `receiveMessage` Methode aufgerufen wird.
```
CompletableFuture responseFuture =
sqsAsyncBatchManager.receiveMessage(r -> r.queueUrl("queueUrl"));
```
### Verwenden Sie benutzerdefinierte Einstellungen
Wenn Sie die Anfrage weiter anpassen möchten, indem Sie beispielsweise benutzerdefinierte Wartezeiten festlegen und die Anzahl der abzurufenden Nachrichten angeben, können Sie die Anforderung wie im folgenden Beispiel dargestellt anpassen.
```
CompletableFuture response =
sqsAsyncBatchManager.receiveMessage(r ->
r.queueUrl("queueUrl")
.waitTimeSeconds(5)
.visibilityTimeout(20));
```
**Anmerkung**
Wenn Sie `receiveMessage` mit einer aufrufen`[ReceiveMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ReceiveMessageRequest.html)`, die einen der folgenden Parameter enthält, umgeht das SDK den Batch-Manager und sendet eine reguläre asynchrone Anfrage`receiveMessage`:
`messageAttributeNames`
`messageSystemAttributeNames`
`messageSystemAttributeNamesWithStrings`
`overrideConfiguration`
## Überschreiben Sie die Konfigurationseinstellungen für `SqsAsyncBatchManager`
Sie können die folgenden Einstellungen anpassen, wenn Sie eine `SqsAsyncBatchManager` Instanz erstellen. Die folgende Liste von Einstellungen ist auf der verfügbar [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).
| Einstellung | Description | Standardwert |
| --- | --- | --- |
| maxBatchSize | Maximale Anzahl von Anfragen pro Stapel für jedesSendMessageBatchRequest,ChangeMessageVisibilityBatchRequest, oderDeleteMessageBatchRequest. Der Höchstwert ist 10. | 10 |
| sendRequestFrequency | Zeit bis zum Senden eines Batches, sofern sie nicht `maxBatchSize` früher erreicht wurde. Höhere Werte können die Anzahl der Anfragen reduzieren, aber die Latenz erhöhen. | 200 ms |
| receiveMessageVisibilityTimeout | Timeout für die Sichtbarkeit von Nachrichten. Wenn diese Option nicht gesetzt ist, wird die Standardeinstellung der Warteschlange verwendet. | Die Standardeinstellung der Warteschlange |
| receiveMessageMinWaitDuration | Minimale Wartezeit für receiveMessage Anfragen. Vermeiden Sie es, auf 0 zu setzen, um CPU-Verschwendung zu vermeiden. | 50 ms |
| receiveMessageSystemAttributeNames | Liste der [Systemattributnamen](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/MessageSystemAttributeName.html), die für receiveMessage Anrufe angefordert werden sollen. | Keine |
| receiveMessageAttributeNames | Liste der [Attributnamen](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-metadata.html#sqs-message-attributes), die für receiveMessage Anrufe angefordert werden sollen. | Keine |
# Mit Amazon Simple Queue Service Nachrichtenwarteschlangen arbeiten
Eine *Nachrichtenwarteschlange* ist der logische Container, in den Nachrichten zuverlässig gesendet werden Amazon Simple Queue Service. Es gibt zwei Arten von Warteschlangen: *Standard* und *First-in-First-out-Verfahren* (FIFO). Weitere Informationen zu Warteschlangen und den Unterschieden zwischen diesen Typen finden Sie im [Amazon Simple Queue Service Entwicklerhandbuch](https://docs.aws.amazon.com//AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html).
In diesem Thema wird beschrieben, wie Sie mithilfe von eine Amazon Simple Queue Service Warteschlange erstellen, auflisten, löschen und deren URL abrufen. AWS SDK für Java
Die in den folgenden Beispielen verwendete `sqsClient` Variable kann aus dem folgenden Codeausschnitt erstellt werden.
```
SqsClient sqsClient = SqsClient.create();
```
Wenn Sie eine `SqsClient` mit der statischen `create()` Methode erstellen, konfiguriert das SDK die Region mithilfe der [Standardregion-Anbieterkette](region-selection.md#default-region-provider-chain) und die Anmeldeinformationen mithilfe der [Standard-Anbieterkette für Anmeldeinformationen](credentials-chain.md).
## Erstellen einer Warteschlange
Verwenden Sie die `SqsClient’s` `createQueue` Methode und stellen Sie ein `[CreateQueueRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/CreateQueueRequest.html)` Objekt bereit, das die Warteschlangenparameter beschreibt, wie im folgenden Codeausschnitt dargestellt.
**Importe**
```
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);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L52) finden Sie unter. GitHub
## Auflisten von Warteschlangen
Um die Amazon Simple Queue Service Warteschlangen für Ihr Konto aufzulisten, rufen Sie die `SqsClient’s` `listQueues` Methode mit einem `[ListQueuesRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ListQueuesRequest.html)` Objekt auf.
Wenn Sie die Form der [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())Methode verwenden, die keine Parameter akzeptiert, gibt der Dienst *alle Warteschlangen zurück — bis zu 1.000 Warteschlangen*.
Sie können dem `[ListQueuesRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ListQueuesRequest.html)` Objekt ein Präfix für den Warteschlangennamen angeben, um die Ergebnisse auf Warteschlangen zu beschränken, die diesem Präfix entsprechen, wie im folgenden Code gezeigt.
**Importe**
```
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);
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L79) finden Sie unter. GitHub
## Abrufen der URL für eine Warteschlange
Der folgende Code zeigt, wie Sie die URL für eine Warteschlange abrufen, indem Sie die `SqsClient’s` `getQueueUrl` Methode mit einem `[GetQueueUrlRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/GetQueueUrlRequest.html)` Objekt aufrufen.
**Importe**
```
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;
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/7486a1a092aa8e16a21698ef26f9d524fef62e55/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L70) finden Sie unter GitHub.
## Löschen einer Warteschlange
Geben Sie die [URL](#sqs-get-queue-url) der Warteschlange für das `[DeleteQueueRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/DeleteQueueRequest.html)` Objekt an. Rufen Sie dann die `SqsClient’s` `deleteQueue` Methode zum Löschen einer Warteschlange auf, wie im folgenden Code gezeigt.
**Importe**
```
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);
}
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/6240df86c5f17eae1e23d1139d1435c7dc4b2a11/javav2/example_code/sqs/src/main/java/com/example/sqs/DeleteQueue.java#L48) finden Sie unter GitHub.
## Weitere Informationen
+ [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)in der Amazon Simple Queue Service API-Referenz
+ [GetQueueUrl](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueUrl.html)in der Amazon Simple Queue Service API-Referenz
+ [ListQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html)in der Amazon Simple Queue Service API-Referenz
+ [DeleteQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueue.html)in der Amazon Simple Queue Service API-Referenz
# Amazon Simple Queue Service Nachrichten senden, empfangen und löschen
Eine Nachricht ist ein Datenabschnitt, der von verteilten Komponenten gesendet und empfangen werden kann. Nachrichten werden immer mit einer [SQS-Warteschlange](examples-sqs-message-queues.md) geliefert.
Die in den folgenden Beispielen verwendete `sqsClient` Variable kann aus dem folgenden Codeausschnitt erstellt werden.
```
SqsClient sqsClient = SqsClient.create();
```
Wenn Sie eine `SqsClient` mit der statischen `create()` Methode erstellen, konfiguriert das SDK die Region mithilfe der [Standardregion-Anbieterkette](region-selection.md#default-region-provider-chain) und die Anmeldeinformationen mithilfe der [Standard-Anbieterkette für Anmeldeinformationen](credentials-chain.md).
## Senden einer Nachricht
Fügen Sie einer Amazon Simple Queue Service Warteschlange eine einzelne Nachricht hinzu, indem Sie die SqsClient `sendMessage` Client-Methode aufrufen. Geben Sie ein [SendMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageRequest.html)Objekt an, das die [URL](examples-sqs-message-queues.md#sqs-get-queue-url), den Nachrichtentext und den optionalen Verzögerungswert (in Sekunden) der Warteschlange enthält.
**Importe**
```
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);
```
## Senden Sie mehrere Nachrichten in einer Anfrage
Senden mehrerer Nachrichten in einer einzigen Anforderung unter Verwendung der `sendMessageBatch`-Methode des SqsClient . Diese Methode verwendet eine [SendMessageBatchRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageBatchRequest.html), die die URL der Warteschlange und eine Liste der zu sendenden Nachrichten enthält. (Jede Nachricht ist eine [SendMessageBatchRequestEntry](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageBatchRequestEntry.html).) Sie können das Senden einer bestimmten Nachricht auch verzögern, indem Sie einen Verzögerungswert für die Nachricht festlegen.
**Importe**
```
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);
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L133) finden Sie unter GitHub.
## Nachrichten abrufen
Abrufen von aktuell in der Warteschlange enthaltenen Nachrichten durch Aufruf der `receiveMessage`-Methode des SqsClient . Diese Methode verwendet eine [ReceiveMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ReceiveMessageRequest.html), die die Warteschlangen-URL enthält. Sie können auch die maximale Anzahl von Nachrichten angeben, die zurückgegeben werden soll. Nachrichten werden als Liste von [Message](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/Message.html)-Objekten zurückgegeben.
**Importe**
```
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;
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L148) finden Sie unter GitHub.
## Löschen Sie eine Nachricht nach Erhalt
Nachdem Sie eine Nachricht empfangen und ihren Inhalt verarbeitet haben, löschen Sie die Nachricht aus der Warteschlange, indem Sie das Empfangs-Handle und die Warteschlangen-URL der Nachricht an die `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))Methode senden.
**Importe**
```
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);
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L187) finden Sie unter GitHub.
## Weitere Infos
+ [So funktionieren Amazon Simple Queue Service Warteschlangen](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-basic-architecture.html) im Amazon Simple Queue Service Entwicklerhandbuch
+ [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)in der Amazon Simple Queue Service API-Referenz
+ [SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)in der Amazon Simple Queue Service API-Referenz
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)in der Amazon Simple Queue Service API-Referenz
+ [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)in der Amazon Simple Queue Service API-Referenz
# Arbeite mit Amazon Transcribe
Das folgende Beispiel zeigt, wie bidirektionales Streaming mit Amazon Transcribe funktioniert. Bidirektionales Streaming bedeutet, dass ein Datenstrom zum Service gesendet wird und auch in Echtzeit wieder empfangen wird. Das Beispiel verwendet Amazon Transcribe Streaming-Transkription, um einen Audiostream zu senden und einen Stream mit transkribiertem Text in Echtzeit zurück zu empfangen.
Weitere Informationen zu dieser Funktion finden Sie unter [Streaming-Transkription](https://docs.aws.amazon.com//transcribe/latest/dg/streaming.html) im Amazon Transcribe Entwicklerhandbuch.
Informationen [zu den ersten](https://docs.aws.amazon.com//transcribe/latest/dg/getting-started.html) Schritten finden Sie unter Amazon Transcribe Erste Schritte im Amazon Transcribe Entwicklerhandbuch.
## Richten Sie das Mikrofon ein
Dieser Code verwendet das javax.sound.sampled-Paket zum Streamen von Audio aus einem Eingabegerät.
**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;
}
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/Microphone.java) finden Sie unter GitHub.
## Erstellen Sie einen Herausgeber
Dieser Code implementiert einen Herausgeber, der Audiodaten aus dem Amazon Transcribe Audiostream veröffentlicht.
**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();
}
}
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/AudioStreamPublisher.java) finden Sie unter GitHub.
## Erstellen Sie den Client und starten Sie den Stream
Erstellen Sie in der Hauptmethode ein Anforderungsobjekt, starten Sie den Audioeingabe-Stream und instanziieren Sie den Herausgeber mit der Audioeingabe.
Sie müssen auch eine erstellen [StartStreamTranscriptionResponseHandler](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/transcribestreaming/model/StartStreamTranscriptionResponseHandler.html), um anzugeben, wie die Antwort von behandelt werden soll Amazon Transcribe.
Verwenden Sie dann die `startStreamTranscription` Methode TranscribeStreamingAsyncClient's, um das bidirektionale Streaming zu starten.
**Importe**
```
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);
}
}
```
Das [vollständige Beispiel](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/BidirectionalStreaming.java) finden Sie unter. GitHub
## Weitere Informationen
+ [Wie es funktioniert](https://docs.aws.amazon.com//transcribe/latest/dg/how-it-works.html), finden Sie im Amazon Transcribe Entwicklerhandbuch.
+ [Erste Schritte mit dem Streamen von Audio](https://docs.aws.amazon.com//transcribe/latest/dg/getting-started.html) im Amazon Transcribe Entwicklerhandbuch.