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();
}
}
```
在此範例中， `fromJson`方法會將 JSON 字串轉換為 `S3EventNotification` 物件。JSON 字串中缺少的欄位會導致對應 Java 物件欄位中`null`的值，且 JSON 中的任何額外欄位都會遭到忽略。
您可以在 APIs 參考中找到事件通知記錄的其他 API`[S3EventNotificationRecord](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/eventnotifications/s3/model/S3EventNotificationRecord.html)`。
#### 將`S3EventNotification`執行個體轉換為 JSON 字串
使用 `toJson`（或 `toJsonPretty`) 方法將`S3EventNotification`物件轉換為 JSON 字串，如下列範例所示。
```
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);
}
}
```
如果 `GlacierEventData`、`IntelligentTieringEventData`、 `ReplicationEventData`和 的欄位是 ，`LifecycleEventData`則會從 JSON 中排除`null`。其他`null`欄位將序列化為 `null`。
以下顯示 S3 物件標記事件的 `toJsonPretty`方法輸出範例。
```
{
"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
}
}
} ]
}
```
GitHub 提供[完整的範例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/75c3daadf750406156fc87fa30ee499a206b4a36/javav2/example_code/s3/src/main/java/com/example/s3/ProcessS3EventNotification.java#L117)，說明如何使用 API 來處理 Amazon SQS 佇列收到的通知。
## 使用 Java 程式庫處理 Lambda 中的 S3 事件： AWS SDK for Java 2.x 和 `aws-lambda-java-events`
與其使用適用於 Java 的 SDK 2.x 在 Lambda 函數中處理 Amazon S3 事件通知，您可以在 3.x.x 版使用`[aws-lambda-java-events](https://github.com/aws/aws-lambda-java-libs/tree/main/aws-lambda-java-events)`程式庫。 會獨立 AWS 維護`aws-lambda-java-events`程式庫，並且具有自己的相依性要求。`aws-lambda-java-events` 程式庫僅適用於 Lambda 函數中的 S3 事件，而適用於 Java 的 SDK 2.x 僅適用於 Lambda 函數、Amazon SNS 和 Amazon SQS 中的 S3 事件。
這兩種方法都使用類似的 APIs，以物件導向的方式建立 JSON 事件通知承載的模型。下表顯示使用兩種方法之間的顯著差異。
****
| | 適用於 Java 的 AWS SDK | aws-lambda-java-events 程式庫 |
| --- | --- | --- |
| 套件命名 | `software.amazon.awssdk.eventnotifications.s3.model.S3EventNotification` | com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification |
| RequestHandler 參數 | 撰寫 Lambda 函數的`RequestHandler`實作以接收 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.
...
}
}
| 撰寫 Lambda 函數的RequestHandler實作以接收S3Event物件：import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.S3Event;
public class Handler implements RequestHandler {
@Override
public String handleRequest(S3Event s3event, Context context) {
// Work with the s3Event object.
...
}
}
|
| 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
|
# 使用 Amazon Simple Notification Service
使用 Amazon Simple Notification Service，您可以透過多個通訊管道，輕鬆地將即時通知訊息從應用程式推送至訂閱用戶。本主題說明如何執行 的一些基本函數 Amazon SNS。
## 建立主題
**主題**是通訊通道的邏輯分組，可定義要傳送訊息的系統，例如發散訊息至 AWS Lambda 和 HTTP Webhook。您可以將訊息傳送到 Amazon SNS，然後它們會分佈到主題中定義的頻道。如此訊息就可用於訂閱者。
若要建立主題，請先建置 [CreateTopicRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/CreateTopicRequest.html) 物件，並將主題集的名稱用於建置器的 `name()` 方法。然後，使用 [SnsClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/SnsClient.html) 的 Amazon SNS `createTopic()`方法將請求物件傳送至 。您可以將此要求的結果擷取為 [CreateTopicResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/CreateTopicResponse.html) 物件，如下列程式碼片段所示。
**匯入**
```
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 "";
}
```
請參閱 GitHub 上的[完整範例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/CreateTopic.java)。
## 列出您的 Amazon SNS 主題
若要擷取現有 Amazon SNS 主題的清單，請建置 [ListTopicsRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/ListTopicsRequest.html) 物件。然後， Amazon SNS 使用 的 `listTopics()`方法，將請求物件傳送至 `SnsClient`。您可以將此要求的結果擷取為 [ListTopicsResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/ListTopicsResponse.html) 物件。
下列程式碼片段會列印請求的 HTTP 狀態碼，以及 Amazon SNS 主題的 Amazon Resource Name (ARNs) 清單。
**匯入**
```
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);
}
}
```
請參閱 GitHub 上的[完整範例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/ListTopics.java)。
## 讓端點訂閱主題
建立主題之後，您可以設定哪些通訊頻道將成為該主題的端點。訊息會在 Amazon SNS 收到後分發到這些端點。
若要將通訊頻道設定為主題的端點，請讓該端點訂閱主題。若要開始，請建置 [SubscribeRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/SubscribeRequest.html) 物件。將通訊管道 （例如 `lambda`或 `email`) 指定為 `protocol()`。將 `endpoint()`設定為相關的輸出位置 （例如， Lambda 函數的 ARN 或電子郵件地址），然後將您要訂閱的主題 ARN 設定為 `topicArn()`。 Amazon SNS 使用 的 `subscribe()`方法，將請求物件傳送至 `SnsClient`。您可以將此要求的結果擷取為 [SubscribeResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/SubscribeResponse.html) 物件。
下列程式碼片段示範如何讓電子郵件地址訂閱主題。
**匯入**
```
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);
}
}
```
請參閱 GitHub 上的[完整範例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/SubscribeEmail.java)。
## 發佈訊息至主題
擁有主題並為其設定一或多個端點之後，您可以將訊息發佈至該主題。若要開始，請建置 [PublishRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/PublishRequest.html) 物件。指定要傳送的 `message()`，以及要傳送的主題的 ARN (`topicArn()`)。然後， Amazon SNS 使用 的 `publish()`方法，將請求物件傳送至 `SnsClient`。您可以將此要求的結果擷取為 [PublishResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/PublishResponse.html) 物件。
**匯入**
```
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);
}
}
```
請參閱 GitHub 上的[完整範例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/PublishTopic.java)。
## 讓端點取消訂閱主題
您可以移除設定為主題端點的通訊頻道。這麼做之後，主題本身會繼續存在，並將訊息散佈到針對該主題設定的任何其他端點。
若要從主題端點移除通訊頻道，請從主題取消訂閱該端點。若要開始，請建置 [UnsubscribeRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/UnsubscribeRequest.html) 物件，並將您要取消訂閱的主題 ARN 設定為 `subscriptionArn()`。然後使用 `SnsClient` 的 `unsubscribe()` 方法，將要求物件傳送至 SNS。您可以將此要求的結果擷取為 [UnsubscribeResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/UnsubscribeResponse.html) 物件。
**匯入**
```
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);
}
}
```
請參閱 GitHub 上的[完整範例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/Unsubscribe.java)。
## 刪除主題
若要刪除 Amazon SNS 主題，請先建置 [DeleteTopicRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/DeleteTopicRequest.html) 物件，並將主題的 ARN 設定為建置器中的 `topicArn()` 方法。然後使用 的 `deleteTopic()`方法 Amazon SNS ，將請求物件傳送至 `SnsClient`。您可以將此要求的結果擷取為 [DeleteTopicResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/DeleteTopicResponse.html) 物件，如下列程式碼片段所示。
**匯入**
```
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);
}
}
```
請參閱 GitHub 上的[完整範例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/DeleteTopic.java)。
如需詳細資訊，請參閱《[Amazon Simple Notification Service 開發人員指南](https://docs.aws.amazon.com/sns/latest/dg/)》。
# 使用 Amazon Simple Queue Service
本節提供[Amazon Simple Queue Service](https://docs.aws.amazon.com/sqs/)使用 適用於 Java 的 AWS SDK 2.x 進行程式設計的範例。
下列範例僅包含示範每個技術所需的程式碼。[GitHub 上提供完整程式碼範例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2)。您可以從那裡下載單一原始檔案或將儲存庫複製到本機，以取得建置和執行的所有範例。
**Topics**
+ [使用自動請求批次處理](sqs-auto-batch.md)
+ [佇列操作](examples-sqs-message-queues.md)
+ [訊息操作](examples-sqs-messages.md)
# 搭配 使用 Amazon SQS 的自動請求批次處理 AWS SDK for Java 2.x
Amazon SQS 的 Automatic Request Batching API 是一個高階程式庫，提供有效的方法來批次處理和緩衝 SQS 操作的請求。透過使用批次處理 API，您可以減少對 SQS 的請求數量，從而提高輸送量並將成本降至最低。
由於批次 API 方法符合`[SqsAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/SqsAsyncClient.html)`方法 —`sendMessage`、`changeMessageVisibility``deleteMessage`、、 `receiveMessage`— 您可以使用批次 API 做為插入式取代，且變更最少。
本主題概述如何設定和使用適用於 Amazon SQS 的自動請求批次 API。
## 檢查先決條件
您需要使用適用於 Java 的 SDK *2.x 2.28.0 *版或更新版本，才能存取批次處理 API。Maven `pom.xml`應至少包含下列元素。
```
software.amazon.awssdk
bom
2.28.231
pom
import
software.amazon.awssdk
sqs
```
1 [最新版本](https://central.sonatype.com/artifact/software.amazon.awssdk/bom)
## 建立批次管理工具
[SqsAsyncBatchManager](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html) 介面會實作自動請求批次處理 API。您可以用幾種方式建立管理員的執行個體。
### 使用 的預設組態 `SqsAsyncClient`
建立批次管理工具最簡單的方法是在現有的 [SqsAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/SqsAsyncClient.html) 執行個體上呼叫`batchManager`原廠方法。簡單方法會顯示在下列程式碼片段中。
```
SqsAsyncClient asyncClient = SqsAsyncClient.create();
SqsAsyncBatchManager sqsAsyncBatchManager = asyncClient.batchManager();
```
當您使用此方法時，`SqsAsyncBatchManager`執行個體會使用 [覆寫 的組態設定 `SqsAsyncBatchManager`](#sqs-auto-batch-config-settings)區段中資料表中顯示的預設值。此外，`SqsAsyncBatchManager`執行個體會使用其建立來源`ExecutorService``SqsAsyncClient`執行個體的 。
### 使用 自訂組態 `SqsAsyncBatchManager.Builder`
如需更進階的使用案例，您可以使用 自訂批次管理工具[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)。透過使用此方法來建立`SqsAsyncBatchManager`執行個體，您可以微調批次處理行為。下列程式碼片段示範如何使用建置器來自訂批次處理行為。
```
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();
```
使用此方法時，您可以調整 [覆寫 的組態設定 `SqsAsyncBatchManager`](#sqs-auto-batch-config-settings)區段中資料表中顯示之`BatchOverrideConfiguration`物件的設定。您也可以使用此方法[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)為批次管理員提供自訂 。
## 傳送訊息
若要使用批次管理工具傳送訊息，請使用 `[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))`方法。軟體開發套件會緩衝請求，並在達到 `maxBatchSize`或 `sendRequestFrequency`值時以批次方式傳送請求。
下列範例顯示緊接另一個`sendMessage`請求的請求。在此情況下，軟體開發套件會以單一批次傳送兩個訊息。
```
// 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();
```
## 變更訊息可見性逾時
您可以使用 [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))方法變更批次中訊息的可見性逾時。軟體開發套件會緩衝請求，並在達到 `maxBatchSize`或 `sendRequestFrequency`值時以批次方式傳送請求。
下列範例顯示如何呼叫 `changeMessageVisibility`方法。
```
CompletableFuture futureOne =
sqsAsyncBatchManager.changeMessageVisibility(r ->
r.receiptHandle("receiptHandle")
.queueUrl("queue"));
ChangeMessageVisibilityResponse response = futureOne.join();
```
## 刪除訊息
您可以使用 [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))方法刪除批次中的訊息。軟體開發套件會緩衝請求，並在達到 `maxBatchSize`或 `sendRequestFrequency`值時以批次方式傳送請求。
下列範例示範如何呼叫 `deleteMessage`方法。
```
CompletableFuture futureOne =
sqsAsyncBatchManager.deleteMessage(r ->
r.receiptHandle("receiptHandle")
.queueUrl("queue"));
DeleteMessageResponse response = futureOne.join();
```
## 接收訊息
### 使用預設設定
當您在應用程式中輪詢 `[SqsAsyncBatchManager\$1receiveMessage](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html#receiveMessage(java.util.function.Consumer))`方法時，批次管理工具會從其內部緩衝區擷取訊息，開發套件會在背景自動更新。
下列範例顯示如何呼叫 `receiveMessage`方法。
```
CompletableFuture responseFuture =
sqsAsyncBatchManager.receiveMessage(r -> r.queueUrl("queueUrl"));
```
### 使用自訂設定
如果您想要進一步自訂請求，例如設定自訂等待時間並指定要擷取的訊息數量，您可以自訂請求，如下列範例所示。
```
CompletableFuture response =
sqsAsyncBatchManager.receiveMessage(r ->
r.queueUrl("queueUrl")
.waitTimeSeconds(5)
.visibilityTimeout(20));
```
**注意**
如果您`receiveMessage`使用包含下列任何參數`[ReceiveMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ReceiveMessageRequest.html)`的 呼叫 ，軟體開發套件會略過批次管理工具並傳送一般非同步`receiveMessage`請求：
`messageAttributeNames`
`messageSystemAttributeNames`
`messageSystemAttributeNamesWithStrings`
`overrideConfiguration`
## 覆寫 的組態設定 `SqsAsyncBatchManager`
您可以在建立`SqsAsyncBatchManager`執行個體時調整下列設定。下列設定清單可在 上取得[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)。
| 設定 | Description | 預設值 |
| --- | --- | --- |
| maxBatchSize | 每個 SendMessageBatchRequest、 ChangeMessageVisibilityBatchRequest或 每個批次的請求數量上限DeleteMessageBatchRequest。最大值為 10。 | 10 |
| sendRequestFrequency | 傳送批次之前的時間，除非之前`maxBatchSize`已到達。較高的值可能會減少請求，但會增加延遲。 | 200 毫秒 |
| receiveMessageVisibilityTimeout | 訊息的可見性逾時。如果取消設定，則會使用佇列的預設值。 | 佇列的預設 |
| receiveMessageMinWaitDuration | receiveMessage 請求的最短等待時間。避免將 設定為 0 以防止 CPU 浪費。 | 50 毫秒 |
| receiveMessageSystemAttributeNames | 要請求receiveMessage呼叫[的系統屬性名稱](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/MessageSystemAttributeName.html)清單。 | 無 |
| receiveMessageAttributeNames | 要請求receiveMessage呼叫的[屬性名稱](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-metadata.html#sqs-message-attributes)清單。 | 無 |
# 使用 Amazon Simple Queue Service 訊息佇列
*訊息佇列*是用於可靠傳送訊息的邏輯容器 Amazon Simple Queue Service。有兩種佇列類型：*標準*和*先進先出* (FIFO)。若要進一步了解佇列和這些類型之間的差異，請參閱 [Amazon Simple Queue Service 開發人員指南](https://docs.aws.amazon.com//AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html)。
本主題說明如何使用 建立、列出、刪除和取得 Amazon Simple Queue Service 佇列的 URL 適用於 Java 的 AWS SDK。
下列範例中使用的 `sqsClient` 變數可從下列程式碼片段建立。
```
SqsClient sqsClient = SqsClient.create();
```
當您`SqsClient`使用靜態`create()`方法建立 時，開發套件會使用[預設區域提供者鏈](region-selection.md#default-region-provider-chain)來設定區域，並使用預設登入資料[提供者鏈來設定登入資料](credentials-chain.md)。
## 建立佇列
使用 `SqsClient’s``createQueue`方法，並提供描述佇列參數的`[CreateQueueRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/CreateQueueRequest.html)`物件，如下列程式碼片段所示。
**匯入**
```
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);
```
請參閱 GitHub 上的[完整範例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L52)。
## 列出佇列
若要列出您帳戶的 Amazon Simple Queue Service 佇列，請使用 `[ListQueuesRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ListQueuesRequest.html)` 物件呼叫 `SqsClient’s``listQueues`方法。
當您使用不使用參數的 [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())方法形式時，服務會傳回*所有佇列*，最多 1，000 個佇列。
您可以將佇列名稱字首提供給`[ListQueuesRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ListQueuesRequest.html)`物件，將結果限制為符合該字首的佇列，如下列程式碼所示。
**匯入**
```
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);
}
```
請參閱 GitHub 上的[完整範例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L79)。
## 取得佇列 URL
下列程式碼說明如何透過使用 `[GetQueueUrlRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/GetQueueUrlRequest.html)` 物件呼叫 `SqsClient’s``getQueueUrl`方法來取得佇列的 URL。
**匯入**
```
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;
```
請參閱 GitHub 上的[完整範例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/7486a1a092aa8e16a21698ef26f9d524fef62e55/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L70)。
## 刪除佇列
提供`[DeleteQueueRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/DeleteQueueRequest.html)`物件的佇列 [URL](#sqs-get-queue-url)。然後呼叫 `SqsClient’s``deleteQueue`方法來刪除佇列，如下列程式碼所示。
**匯入**
```
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);
}
}
```
請參閱 GitHub 上的[完整範例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/6240df86c5f17eae1e23d1139d1435c7dc4b2a11/javav2/example_code/sqs/src/main/java/com/example/sqs/DeleteQueue.java#L48)。
## 其他資訊
+ Amazon Simple Queue Service API 參考中的 [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)
+ Amazon Simple Queue Service API 參考中的 [GetQueueUrl](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueUrl.html)
+ Amazon Simple Queue Service API 參考中的 [ListQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html)
+ Amazon Simple Queue Service API 參考中的 [DeleteQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueue.html)
# 傳送、接收和刪除 Amazon Simple Queue Service 訊息
訊息是資料片段，可透過分散式元件傳送和接收。訊息一律使用 [SQS 佇列](examples-sqs-message-queues.md)來傳送。
下列範例中使用的 `sqsClient` 變數可從下列程式碼片段建立。
```
SqsClient sqsClient = SqsClient.create();
```
當您`SqsClient`使用靜態`create()`方法建立 時，開發套件會使用[預設區域提供者鏈](region-selection.md#default-region-provider-chain)來設定區域，並使用預設登入資料[提供者鏈來設定登入資料](credentials-chain.md)。
## 傳送訊息
呼叫 SqsClient 用戶端`sendMessage`方法，將單一訊息新增至 Amazon Simple Queue Service 佇列。提供 [SendMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageRequest.html) 物件，其中包含佇列的 [URL](examples-sqs-message-queues.md#sqs-get-queue-url)、訊息本文，以及選用的延遲值 (以秒為單位)。
**匯入**
```
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);
```
## 在請求中傳送多則訊息
使用 SqsClient `sendMessageBatch`方法在單一請求中傳送多個訊息。這個方法採用 [SendMessageBatchRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageBatchRequest.html)，其中包含佇列 URL 和要傳送的訊息清單。(每個訊息都是一個 [SendMessageBatchRequestEntry](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageBatchRequestEntry.html)。) 您也可以在訊息上設定延遲值，延遲傳送特定的訊息。
**匯入**
```
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);
```
請參閱 GitHub 上的[完整範例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L133)。
## 擷取訊息
呼叫 SqsClient `receiveMessage`方法，擷取目前佇列中的任何訊息。這個方法採用 [ReceiveMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ReceiveMessageRequest.html)，其中包含佇列 URL。您也可以指定要傳回的最大訊息數量。訊息會以 [Message](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/Message.html) 物件清單的形式傳回。
**匯入**
```
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;
```
請參閱 GitHub 上的[完整範例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L148)。
## 在收到訊息後刪除訊息
收到訊息並處理其內容後，將訊息的接收控點和佇列 URL 傳送至 `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))方法，從佇列刪除訊息。
**匯入**
```
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);
}
```
請參閱 GitHub 上的[完整範例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L187)。
## 詳細資訊
+ 《 [Amazon Simple Queue Service 開發人員指南》中的佇列如何運作](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-basic-architecture.html) Amazon Simple Queue Service
+ Amazon Simple Queue Service API 參考中的 [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)
+ Amazon Simple Queue Service API 參考中的 [SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)
+ Amazon Simple Queue Service API 參考中的 [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)
+ Amazon Simple Queue Service API 參考中的 [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)
# 使用 Amazon Transcribe
以下範例顯示使用 Amazon Transcribe的雙向串流如何運作。雙向串流隱含表示資料的串流會前往服務，並即時接收回來。此範例使用 Amazon Transcribe 串流轉錄來傳送音訊串流，並即時接收轉錄文字的串流。
請參閱《 Amazon Transcribe 開發人員指南》中的[串流轉錄](https://docs.aws.amazon.com//transcribe/latest/dg/streaming.html)，以進一步了解此功能。
請參閱《 Amazon Transcribe 開發人員指南[》中的入門](https://docs.aws.amazon.com//transcribe/latest/dg/getting-started.html)以開始使用 Amazon Transcribe。
## 設定麥克風
此程式碼使用 javax.sound.sampled 套件，從輸入裝置串流音訊。
**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;
}
}
```
請參閱 GitHub 上的[完整範例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/Microphone.java)。
## 建立發佈者
此程式碼實作從音訊串流發佈 Amazon Transcribe 音訊資料的發佈者。
**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();
}
}
}
```
請參閱 GitHub 上的[完整範例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/AudioStreamPublisher.java)。
## 建立用戶端並啟動串流
在主要方法中，建立請求物件，開始音訊輸入串流並使用音訊輸入將發佈者執行個體化。
您也必須建立 [StartStreamTranscriptionResponseHandler](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/transcribestreaming/model/StartStreamTranscriptionResponseHandler.html)，以指定如何處理來自 的回應 Amazon Transcribe。
然後，使用 TranscribeStreamingAsyncClient 的 `startStreamTranscription`方法來啟動雙向串流。
**匯入**
```
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);
}
}
```
請參閱 GitHub 上的[完整範例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/BidirectionalStreaming.java)。
## 其他資訊
+ Amazon Transcribe 開發人員指南中的[運作方式](https://docs.aws.amazon.com//transcribe/latest/dg/how-it-works.html)。
+ 《 開發人員指南》中的 Amazon Transcribe [串流音訊入門](https://docs.aws.amazon.com//transcribe/latest/dg/getting-started.html)。