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`、`ReplicationEventData`、`IntelligentTieringEventData` 和 `LifecycleEventData` 的字段如果为 `null`，则会从 JSON 中排除。其他 `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
}
}
} ]
}
```
中提供了一个[完整的示例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/75c3daadf750406156fc87fa30ee499a206b4a36/javav2/example_code/s3/src/main/java/com/example/s3/ProcessS3EventNotification.java#L117) GitHub ，其中显示了如何使用 API 来处理 Amazon SQS 队列收到的通知。
## 使用 Java 库在 Lambda 中处理 S3 事件：以及 AWS SDK for Java 2.x `aws-lambda-java-events`
您可以使用 3.x.x 版本的库，而不是使用`[aws-lambda-java-events](https://github.com/aws/aws-lambda-java-libs/tree/main/aws-lambda-java-events)`适用于 Java 2.x 的 SDK 在 Lambda 函数中处理 Amazon S3 事件通知。 AWS 独立维护该`aws-lambda-java-events`库，并且它有自己的依赖要求。`aws-lambda-java-events` 库仅适用于 Lambda 函数中的 S3 事件，而适用于 Java 的 SDK 2.x 可处理 Lambda 函数、Amazon SNS 和 Amazon SQS 中的 S3 事件。
两种方法都以类似的面向对象的方式建模 JSON 事件通知有效负载。 APIs下表显示了使用这两种方法的显著差异。
****
| | 适用于 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) 的 `createTopic()` 方法将请求对象发送到 Amazon SNS。可以将此请求的结果作为 [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;
```
**代码**
```
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 资源名称 (ARN) 列表。
**导入**。
```
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;
```
**代码**
```
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()`。使用 `SnsClient` 的 `subscribe()` 方法将请求对象发送到 Amazon SNS。可以将此请求的结果作为 [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;
```
**代码**
```
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;
```
**代码**
```
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()`。然后，使用 `unsubscribe()` 的 `SnsClient` 方法将请求对象发送到 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;
```
**代码**
```
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()` 方法。然后，使用 Amazon SNS 的 `deleteTopic()` 方法将请求对象发送到 `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;
```
**代码**
```
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
本部分提供使用适用于 Java 的 AWS SDK 2.x 对 [Amazon Simple Queue Service](https://docs.aws.amazon.com/sqs/) 进行编程的示例。
以下示例仅包含演示每种方法所需的代码。[完整的示例代码在 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 的自动请求批处理 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)
## 创建批量管理器
自动请求批处理 API 由[SqsAsyncBatchManager](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html)接口实现。您可以通过几种方式创建管理器的实例。
### 使用 `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` 实例会使用其创建来源的 `SqsAsyncClient` 实例的 `ExecutorService`。
### 使用 `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))` 方法。SDK 会缓冲请求，并在达到 `maxBatchSize` 或 `sendRequestFrequency` 值时批量发送请求。
以下示例展示了一个 `sendMessage` 请求后立即紧跟着另一个请求。在这种情况下，SDK 在单个批次中发送这两条消息。
```
// 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)) 方法批量更改消息的可见性超时。SDK 会缓冲请求，并在达到 `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)) 方法批量删除消息。SDK 会缓冲请求，并在达到 `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))` 方法时，批处理管理器会从其内部缓冲区获取消息，SDK 会在后台自动更新缓冲区。
以下示例显示了如何调用 `receiveMessage` 方法。
```
CompletableFuture responseFuture =
sqsAsyncBatchManager.receiveMessage(r -> r.queueUrl("queueUrl"));
```
### 使用自定义设置
如果您想进一步自定义请求（例如设置自定义等待时间和指定要检索的消息数量），则可以按以下示例所示自定义请求。
```
CompletableFuture response =
sqsAsyncBatchManager.receiveMessage(r ->
r.queueUrl("queueUrl")
.waitTimeSeconds(5)
.visibilityTimeout(20));
```
**注意**
如果您使用包括以下任何参数的 `[ReceiveMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ReceiveMessageRequest.html)` 来调用 `receiveMessage`，则 SDK 会绕过批处理管理器并发送常规异步 `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) 提供了以下设置列表。
| 设置 | 说明 | 默认 值 |
| --- | --- | --- |
| 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 Developer Guide](https://docs.aws.amazon.com//AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html)》。
本主题介绍如何使用创建、列出、删除队列和获取 Amazon Simple Queue Service 队列的 URL 适用于 Java 的 AWS SDK。
以下示例中使用的 `sqsClient` 变量可以通过以下代码段创建。
```
SqsClient sqsClient = SqsClient.create();
```
使用静态 `create()` 方法创建 `SqsClient` 时，SDK 使用[默认区域提供程序链](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;
```
**代码**
```
CreateQueueRequest createQueueRequest = CreateQueueRequest.builder()
.queueName(queueName)
.build();
sqsClient.createQueue(createQueueRequest);
```
请查看上[面的完整示例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L52) GitHub。
## 列出队列
要列出您账户的 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()) 方法形式时，服务会返回*所有队列*（最多 1000 个）。
您可以向 `[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;
```
**代码**
```
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);
}
```
请查看上[面的完整示例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L79) GitHub。
## 获取队列的 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;
```
**代码**
```
GetQueueUrlResponse getQueueUrlResponse =
sqsClient.getQueueUrl(GetQueueUrlRequest.builder().queueName(queueName).build());
String queueUrl = getQueueUrlResponse.queueUrl();
return queueUrl;
```
请查看上[面的完整示例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/7486a1a092aa8e16a21698ef26f9d524fef62e55/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L70) GitHub。
## 删除队列
提供队列中指向 `[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;
```
**代码**
```
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);
}
}
```
请查看上[面的完整示例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/6240df86c5f17eae1e23d1139d1435c7dc4b2a11/javav2/example_code/sqs/src/main/java/com/example/sqs/DeleteQueue.java#L48) GitHub。
## 更多信息
+ [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 API 参考中
# 发送、接收和删除 Amazon Simple Queue Service 消息
消息是可由分布式组件发送和接收的一段数据。始终使用 [SQS 队列](examples-sqs-message-queues.md)发送消息。
以下示例中使用的 `sqsClient` 变量可以通过以下代码段创建。
```
SqsClient sqsClient = SqsClient.create();
```
使用静态 `create()` 方法创建 `SqsClient` 时，SDK 使用[默认区域提供程序链](region-selection.md#default-region-provider-chain)配置区域，使用[默认凭证提供程序链](credentials-chain.md)配置凭证。
## 发送消息
通过调用 SqsClient 客户端`sendMessage`方法向 Amazon Simple Queue Service 队列中添加一条消息。提供一个包含队列的 [URL](examples-sqs-message-queues.md#sqs-get-queue-url)、消息正文和可选延迟值（以秒为单位）的[SendMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageRequest.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;
```
**代码**
```
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;
```
**代码**
```
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);
```
请查看上[面的完整示例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L133) GitHub。
## 检索消息
通过调用 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;
```
**代码**
```
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;
```
请查看上[面的完整示例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L148) GitHub。
## 收到后删除消息
在收到消息并处理其内容后，可通过将消息的接收句柄和队列 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;
```
**代码**
```
try {
for (Message message : messages) {
DeleteMessageRequest deleteMessageRequest = DeleteMessageRequest.builder()
.queueUrl(queueUrl)
.receiptHandle(message.receiptHandle())
.build();
sqsClient.deleteMessage(deleteMessageRequest);
}
```
请查看上[面的完整示例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L187) GitHub。
## 更多信息
+ 《 Amazon Simple Queue Service 开发者指南》中的@@ [Amazon Simple Queue Service 队列工作原](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-basic-architecture.html)理
+ [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 Simple Queue Service API 参考中
# 与... 一起工作 Amazon Transcribe
以下示例显示如何使用 Amazon Transcribe进行双向流式处理。双向流式处理意味着数据流同时转向服务且实时接收回来。该示例使用 Amazon Transcribe 流式转录发送音频流并实时接收转录的文本流。
要详细了解此功能，请参阅 Amazon Transcribe 开发者指南中的[流媒体转录](https://docs.aws.amazon.com//transcribe/latest/dg/streaming.html)。
[要开始使用](https://docs.aws.amazon.com//transcribe/latest/dg/getting-started.html)，请参阅 Amazon Transcribe 开发人员指南中的入门 Amazon Transcribe。
## 设置麦克风
此代码使用 javax.sound.sampled 软件包流式处理来自输入设备的音频。
**代码**
```
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;
}
}
```
请参阅上的[完整示例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/Microphone.java) GitHub。
## 创建发布者
此代码实现了一个发布者，用于发布来自音频流的 Amazon Transcribe 音频数据。
**代码**
```
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();
}
}
}
```
请参阅上的[完整示例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/AudioStreamPublisher.java) GitHub。
## 创建客户端和启动流
在 main 方法中，创建请求对象，启动音频输入流，并通过音频输入实例化发布者。
您还必须创建[StartStreamTranscriptionResponseHandler](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/transcribestreaming/model/StartStreamTranscriptionResponseHandler.html)以指定如何处理来自的响应 Amazon Transcribe。
然后，使用 TranscribeStreamingAsyncClient's `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;
```
**代码**
```
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);
}
}
```
请参阅上的[完整示例](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/BidirectionalStreaming.java) GitHub。
## 更多信息
+ Amazon Transcribe 开发者指南中的@@ [工作原理](https://docs.aws.amazon.com//transcribe/latest/dg/how-it-works.html)。
+ 《 Amazon Transcribe Developer Guide》中的 [Getting Started With Streaming Audio](https://docs.aws.amazon.com//transcribe/latest/dg/getting-started.html)。