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();
}
}
```
Dalam contoh ini, `fromJson` metode mengubah string JSON menjadi objek`S3EventNotification`. Bidang yang hilang dalam string JSON akan menghasilkan `null` nilai di bidang objek Java yang sesuai dan bidang tambahan apa pun di JSON akan diabaikan.
Lainnya APIs untuk catatan pemberitahuan peristiwa dapat ditemukan di referensi API untuk`[S3EventNotificationRecord](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/eventnotifications/s3/model/S3EventNotificationRecord.html)`.
#### Mengkonversi `S3EventNotification` instance ke string JSON
Gunakan metode `toJson` (or`toJsonPretty`) untuk mengubah `S3EventNotification` objek menjadi string JSON seperti yang ditunjukkan pada contoh berikut.
```
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);
}
}
```
Bidang untuk `GlacierEventData``ReplicationEventData`,`IntelligentTieringEventData`,, dan `LifecycleEventData` dikecualikan dari JSON jika memang `null` demikian. `null`Bidang lainnya akan diserialkan sebagai`null`.
Berikut ini menunjukkan contoh output dari `toJsonPretty` metode untuk peristiwa penandaan objek S3.
```
{
"Records" : [ {
"eventVersion" : "2.3",
"eventSource" : "aws:s3",
"awsRegion" : "us-east-1",
"eventTime" : "2024-07-19T20:09:18.551Z",
"eventName" : "ObjectTagging:Put",
"userIdentity" : {
"principalId" : "AWS:XXXXXXXXXXX"
},
"requestParameters" : {
"sourceIPAddress" : "XXX.XX.XX.XX"
},
"responseElements" : {
"x-amz-request-id" : "XXXXXXXXXXXX",
"x-amz-id-2" : "XXXXXXXXXXXXX"
},
"s3" : {
"s3SchemaVersion" : "1.0",
"configurationId" : "XXXXXXXXXXXXX",
"bucket" : {
"name" : "amzn-s3-demo-bucket",
"ownerIdentity" : {
"principalId" : "XXXXXXXXXXX"
},
"arn" : "arn:aws:s3:::XXXXXXXXXX"
},
"object" : {
"key" : "akey",
"size" : null,
"eTag" : "XXXXXXXXXX",
"versionId" : null,
"sequencer" : null
}
}
} ]
}
```
[Contoh lengkap](https://github.com/awsdocs/aws-doc-sdk-examples/blob/75c3daadf750406156fc87fa30ee499a206b4a36/javav2/example_code/s3/src/main/java/com/example/s3/ProcessS3EventNotification.java#L117) tersedia GitHub yang menunjukkan cara menggunakan API untuk bekerja dengan notifikasi yang diterima oleh antrean Amazon SQS.
## Proses Acara S3 di Lambda dengan Perpustakaan Java: dan AWS SDK for Java 2.x `aws-lambda-java-events`
Alih-alih menggunakan SDK for Java 2.x untuk memproses notifikasi peristiwa Amazon S3 dalam fungsi Lambda, Anda dapat menggunakan pustaka pada versi 3.xx. `[aws-lambda-java-events](https://github.com/aws/aws-lambda-java-libs/tree/main/aws-lambda-java-events)` AWS memelihara `aws-lambda-java-events` perpustakaan secara independen, dan memiliki persyaratan ketergantungan sendiri. `aws-lambda-java-events`Pustaka hanya berfungsi dengan peristiwa S3 dalam fungsi Lambda, sedangkan SDK for Java 2.x berfungsi dengan peristiwa S3 di fungsi Lambda, Amazon SNS, dan Amazon SQS.
Kedua pendekatan memodelkan payload notifikasi acara JSON dengan cara yang berorientasi objek dengan yang serupa. APIs Tabel berikut menunjukkan perbedaan mencolok antara menggunakan dua pendekatan.
****
| | AWS SDK untuk Java | aws-lambda-java-events perpustakaan |
| --- | --- | --- |
| Penamaan Package | `software.amazon.awssdk.eventnotifications.s3.model.S3EventNotification` | com.amazonaws.services.lambda.runtime.events.models.s3.S3EventNotification |
| RequestHandlerparameter | Tulis `RequestHandler` implementasi fungsi Lambda Anda untuk menerima String 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.
...
}
}
| Tulis RequestHandler implementasi fungsi Lambda Anda untuk menerima objekS3Event: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.
...
}
}
|
| Ketergantungan 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
|
# Bekerja dengan Amazon Simple Notification Service
Dengan Amazon Simple Notification Service, Anda dapat dengan mudah mendorong pesan notifikasi real-time dari aplikasi Anda ke pelanggan melalui beberapa saluran komunikasi. Topik ini menjelaskan bagaimana melakukan beberapa fungsi dasar Amazon SNS.
## Buat topik
**Topik** adalah pengelompokan logis saluran komunikasi yang mendefinisikan sistem mana yang akan mengirim pesan, misalnya, mengipasi pesan AWS Lambda dan webhook HTTP. Anda mengirim pesan ke Amazon SNS, lalu mereka didistribusikan ke saluran yang ditentukan dalam topik. Ini membuat pesan tersedia untuk pelanggan.
Untuk membuat topik, pertama-tama buat [CreateTopicRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/CreateTopicRequest.html)objek, dengan nama set topik menggunakan `name()` metode di pembuat. Kemudian, kirim objek permintaan ke Amazon SNS dengan menggunakan `createTopic()` metode [SnsClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/SnsClient.html). Anda dapat menangkap hasil permintaan ini sebagai [CreateTopicResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/CreateTopicResponse.html)objek, seperti yang ditunjukkan dalam cuplikan kode berikut.
**Impor**
```
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;
```
**Kode**
```
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 "";
}
```
Lihat [contoh lengkapnya](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/CreateTopic.java) di GitHub.
## Buat daftar Amazon SNS topik Anda
Untuk mengambil daftar Amazon SNS topik yang ada, buat [ListTopicsRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/ListTopicsRequest.html)objek. Kemudian, kirim objek permintaan ke Amazon SNS dengan menggunakan `listTopics()` metode`SnsClient`. Anda dapat menangkap hasil permintaan ini sebagai [ListTopicsResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/ListTopicsResponse.html)objek.
Cuplikan kode berikut mencetak kode status HTTP permintaan dan daftar Amazon Resource Names (ARNs) untuk topik Anda Amazon SNS .
**Impor**
```
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;
```
**Kode**
```
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);
}
}
```
Lihat [contoh lengkapnya](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/ListTopics.java) di GitHub.
## Berlangganan titik akhir ke suatu topik
Setelah Anda membuat topik, Anda dapat mengonfigurasi saluran komunikasi mana yang akan menjadi titik akhir untuk topik tersebut. Pesan didistribusikan ke titik akhir ini setelah Amazon SNS menerimanya.
Untuk mengonfigurasi saluran komunikasi sebagai titik akhir untuk suatu topik, berlangganan titik akhir tersebut ke topik tersebut. Untuk memulai, buat [SubscribeRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/SubscribeRequest.html)objek. Tentukan saluran komunikasi (misalnya, `lambda` atau`email`) sebagai`protocol()`. Atur `endpoint()` ke lokasi keluaran yang relevan (misalnya, ARN Lambda fungsi atau alamat email), lalu atur ARN dari topik yang ingin Anda berlangganan sebagai. `topicArn()` Kirim objek permintaan ke Amazon SNS dengan menggunakan `subscribe()` metode`SnsClient`. Anda dapat menangkap hasil permintaan ini sebagai [SubscribeResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/SubscribeResponse.html)objek.
Cuplikan kode berikut menunjukkan cara berlangganan alamat email ke suatu topik.
**Impor**
```
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;
```
**Kode**
```
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);
}
}
```
Lihat [contoh lengkapnya](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/SubscribeEmail.java) di GitHub.
## Publikasikan pesan ke suatu topik
Setelah Anda memiliki topik dan satu atau beberapa titik akhir yang dikonfigurasi untuk itu, Anda dapat mempublikasikan pesan ke sana. Untuk memulai, buat [PublishRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/PublishRequest.html)objek. Tentukan `message()` yang akan dikirim, dan ARN dari topik (`topicArn()`) untuk mengirimkannya. Kemudian, kirim objek permintaan ke Amazon SNS dengan menggunakan `publish()` metode`SnsClient`. Anda dapat menangkap hasil permintaan ini sebagai [PublishResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/PublishResponse.html)objek.
**Impor**
```
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;
```
**Kode**
```
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);
}
}
```
Lihat [contoh lengkapnya](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/PublishTopic.java) di GitHub.
## Berhenti berlangganan titik akhir dari suatu topik
Anda dapat menghapus saluran komunikasi yang dikonfigurasi sebagai titik akhir untuk suatu topik. Setelah melakukan itu, topik itu sendiri terus ada dan mendistribusikan pesan ke titik akhir lain yang dikonfigurasi untuk topik itu.
Untuk menghapus saluran komunikasi sebagai titik akhir topik, berhenti berlangganan titik akhir tersebut dari topik tersebut. Untuk memulai, buat [UnsubscribeRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/UnsubscribeRequest.html)objek dan atur ARN dari topik yang ingin Anda berhenti berlangganan sebagai. `subscriptionArn()` Kemudian kirim objek permintaan ke SNS dengan menggunakan `unsubscribe()` metode. `SnsClient` Anda dapat menangkap hasil permintaan ini sebagai [UnsubscribeResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/UnsubscribeResponse.html)objek.
**Impor**
```
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;
```
**Kode**
```
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);
}
}
```
Lihat [contoh lengkapnya](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/Unsubscribe.java) di GitHub.
## Hapus topik
Untuk menghapus Amazon SNS topik, pertama-tama buat [DeleteTopicRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/DeleteTopicRequest.html)objek dengan ARN dari set topik sebagai `topicArn()` metode di pembuat. Kemudian kirim objek permintaan ke Amazon SNS dengan menggunakan `deleteTopic()` metode`SnsClient`. Anda dapat menangkap hasil permintaan ini sebagai [DeleteTopicResponse](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sns/model/DeleteTopicResponse.html)objek, seperti yang ditunjukkan dalam cuplikan kode berikut.
**Impor**
```
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;
```
**Kode**
```
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);
}
}
```
Lihat [contoh lengkapnya](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/sns/src/main/java/com/example/sns/DeleteTopic.java) di GitHub.
Untuk informasi selengkapnya, lihat [Panduan Developer Amazon Simple Notification Service](https://docs.aws.amazon.com/sns/latest/dg/).
# Bekerja dengan Amazon Simple Queue Service
Bagian ini memberikan contoh pemrograman [Amazon Simple Queue Service](https://docs.aws.amazon.com/sqs/)menggunakan AWS SDK untuk Java 2.x.
Contoh berikut hanya mencakup kode yang diperlukan untuk mendemonstrasikan setiap teknik. [Kode contoh lengkap tersedia di GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2). Dari sana, Anda dapat mengunduh satu file sumber atau mengkloning repositori secara lokal untuk mendapatkan semua contoh untuk dibangun dan dijalankan.
**Topics**
+ [Gunakan batching permintaan otomatis](sqs-auto-batch.md)
+ [Operasi antrian](examples-sqs-message-queues.md)
+ [Operasi pesan](examples-sqs-messages.md)
# Gunakan batching permintaan otomatis untuk Amazon SQS dengan AWS SDK for Java 2.x
Automatic Request Batching API untuk Amazon SQS adalah pustaka tingkat tinggi yang menyediakan cara efisien untuk mengumpulkan dan menyangga permintaan untuk operasi SQS. Dengan menggunakan API batching, Anda mengurangi jumlah permintaan ke SQS, yang meningkatkan throughput dan meminimalkan biaya.
Karena metode API batch cocok dengan `[SqsAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/SqsAsyncClient.html)` metode—`sendMessage`,, `changeMessageVisibility``deleteMessage`, `receiveMessage` —Anda dapat menggunakan API batch sebagai pengganti drop-in dengan sedikit perubahan.
Topik ini memberi Anda gambaran umum tentang cara mengonfigurasi dan bekerja dengan Automatic Request Batching API untuk Amazon SQS.
## Periksa prasyarat
Anda perlu menggunakan SDK for Java *2.x versi 2.28.0* atau yang lebih baru untuk memiliki akses ke API batching. Maven Anda setidaknya `pom.xml` harus mengandung elemen-elemen berikut.
```
software.amazon.awssdk
bom
2.28.231
pom
import
software.amazon.awssdk
sqs
```
1 [Versi terbaru](https://central.sonatype.com/artifact/software.amazon.awssdk/bom)
## Buat pengelola batch
API batching permintaan otomatis diimplementasikan oleh [SqsAsyncBatchManager](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html)antarmuka. Anda dapat membuat contoh manajer beberapa cara.
### Konfigurasi default dengan menggunakan `SqsAsyncClient`
Cara paling sederhana Anda dapat membuat pengelola batch adalah dengan memanggil metode `batchManager` pabrik pada [SqsAsyncClient](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/SqsAsyncClient.html)instance yang ada. Pendekatan sederhana ditunjukkan dalam cuplikan berikut.
```
SqsAsyncClient asyncClient = SqsAsyncClient.create();
SqsAsyncBatchManager sqsAsyncBatchManager = asyncClient.batchManager();
```
Bila Anda menggunakan pendekatan ini, `SqsAsyncBatchManager` instance menggunakan nilai default yang ditampilkan dalam tabel di [Ganti pengaturan konfigurasi untuk `SqsAsyncBatchManager`](#sqs-auto-batch-config-settings) bagian. Selain itu, `SqsAsyncBatchManager` instance menggunakan `SqsAsyncClient` instance dari mana ia dibuat. `ExecutorService`
### Konfigurasi kustom dengan menggunakan `SqsAsyncBatchManager.Builder`
Untuk kasus penggunaan yang lebih lanjut, Anda dapat menyesuaikan pengelola batch menggunakan file [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). Dengan menggunakan pendekatan ini untuk membuat `SqsAsyncBatchManager` instance, Anda dapat menyempurnakan perilaku batching. Cuplikan berikut menunjukkan contoh cara menggunakan builder untuk menyesuaikan perilaku batching.
```
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();
```
Bila Anda menggunakan pendekatan ini, Anda dapat menyesuaikan pengaturan pada `BatchOverrideConfiguration` objek yang ditunjukkan pada tabel di [Ganti pengaturan konfigurasi untuk `SqsAsyncBatchManager`](#sqs-auto-batch-config-settings) bagian. Anda juga dapat memberikan kustom [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)untuk pengelola batch dengan menggunakan pendekatan ini.
## Kirim pesan
Untuk mengirim pesan dengan pengelola batch, gunakan `[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))` metode ini. Buffer SDK meminta dan mengirimkannya sebagai batch saat `sendRequestFrequency` nilai `maxBatchSize` atau tercapai.
Contoh berikut menunjukkan `sendMessage` permintaan segera diikuti oleh permintaan lain. Dalam hal ini, SDK mengirim kedua pesan dalam satu 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();
```
## Mengubah batas waktu visibilitas pesan
Anda dapat mengubah batas waktu visibilitas pesan dalam batch dengan menggunakan metode ini [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)). Buffer SDK meminta dan mengirimkannya sebagai batch saat `sendRequestFrequency` nilai `maxBatchSize` atau tercapai.
Contoh berikut menunjukkan cara memanggil `changeMessageVisibility` metode.
```
CompletableFuture futureOne =
sqsAsyncBatchManager.changeMessageVisibility(r ->
r.receiptHandle("receiptHandle")
.queueUrl("queue"));
ChangeMessageVisibilityResponse response = futureOne.join();
```
## Hapus pesan
Anda dapat menghapus pesan dalam batch menggunakan [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))metode ini. Buffer SDK meminta dan mengirimkannya sebagai batch saat `sendRequestFrequency` nilai `maxBatchSize` atau tercapai.
Contoh berikut menunjukkan bagaimana Anda dapat memanggil `deleteMessage` metode.
```
CompletableFuture futureOne =
sqsAsyncBatchManager.deleteMessage(r ->
r.receiptHandle("receiptHandle")
.queueUrl("queue"));
DeleteMessageResponse response = futureOne.join();
```
## Menerima pesan
### Gunakan pengaturan default
Saat Anda melakukan polling `[SqsAsyncBatchManager\$1receiveMessage](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/batchmanager/SqsAsyncBatchManager.html#receiveMessage(java.util.function.Consumer))` metode dalam aplikasi Anda, pengelola batch mengambil pesan dari buffer internalnya, yang diperbarui secara otomatis oleh SDK di latar belakang.
Contoh berikut menunjukkan cara memanggil `receiveMessage` metode.
```
CompletableFuture responseFuture =
sqsAsyncBatchManager.receiveMessage(r -> r.queueUrl("queueUrl"));
```
### Gunakan pengaturan khusus
Jika Anda ingin menyesuaikan permintaan lebih lanjut, misalnya dengan menyetel waktu tunggu khusus dan menentukan jumlah pesan yang akan diambil, Anda dapat menyesuaikan permintaan seperti yang ditunjukkan pada contoh berikut.
```
CompletableFuture response =
sqsAsyncBatchManager.receiveMessage(r ->
r.queueUrl("queueUrl")
.waitTimeSeconds(5)
.visibilityTimeout(20));
```
**catatan**
Jika Anda memanggil `receiveMessage` dengan `[ReceiveMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ReceiveMessageRequest.html)` yang menyertakan salah satu parameter berikut, SDK melewati pengelola batch dan mengirimkan permintaan `receiveMessage` asinkron reguler:
`messageAttributeNames`
`messageSystemAttributeNames`
`messageSystemAttributeNamesWithStrings`
`overrideConfiguration`
## Ganti pengaturan konfigurasi untuk `SqsAsyncBatchManager`
Anda dapat menyesuaikan pengaturan berikut saat membuat `SqsAsyncBatchManager` instance. Daftar pengaturan berikut tersedia di [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).
| Pengaturan | Deskripsi | Nilai default |
| --- | --- | --- |
| maxBatchSize | Jumlah maksimum permintaan per batch untuk masing-masingSendMessageBatchRequest,ChangeMessageVisibilityBatchRequest, atauDeleteMessageBatchRequest. Nilai maksimumnya adalah 10. | 10 |
| sendRequestFrequency | Waktu sebelum mengirim batch, kecuali `maxBatchSize` tercapai lebih awal. Nilai yang lebih tinggi dapat mengurangi permintaan tetapi meningkatkan latensi. | 200ms |
| receiveMessageVisibilityTimeout | Batas waktu visibilitas untuk pesan. Jika tidak disetel, default antrian digunakan. | Antrian default |
| receiveMessageMinWaitDuration | Waktu tunggu minimum untuk receiveMessage permintaan. Hindari pengaturan ke 0 untuk mencegah pemborosan CPU. | 50ms |
| receiveMessageSystemAttributeNames | Daftar [nama atribut sistem](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/MessageSystemAttributeName.html) untuk meminta receiveMessage panggilan. | Tidak ada |
| receiveMessageAttributeNames | Daftar [nama atribut](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-metadata.html#sqs-message-attributes) untuk meminta receiveMessage panggilan. | Tidak ada |
# Bekerja dengan Amazon Simple Queue Service antrian pesan
*Antrian pesan* adalah wadah logis yang digunakan untuk mengirim pesan dengan andal. Amazon Simple Queue Service Ada dua jenis antrian: *standar* dan *first-in, first-out* (FIFO). Untuk mempelajari lebih lanjut tentang antrian dan perbedaan di antara jenis-jenis ini, lihat Panduan [Amazon Simple Queue Service Pengembang](https://docs.aws.amazon.com//AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html).
Topik ini menjelaskan cara membuat, membuat daftar, menghapus, dan mendapatkan URL Amazon Simple Queue Service antrian dengan menggunakan. AWS SDK untuk Java
`sqsClient`Variabel yang digunakan dalam contoh berikut dapat dibuat dari cuplikan berikut.
```
SqsClient sqsClient = SqsClient.create();
```
Bila Anda membuat `SqsClient` dengan menggunakan `create()` metode statis, SDK akan mengonfigurasi Region menggunakan [rantai penyedia wilayah default dan kredensialnya menggunakan rantai penyedia](region-selection.md#default-region-provider-chain) kredensial [default](credentials-chain.md).
## Membuat antrean
Gunakan `SqsClient’s` `createQueue` metode ini, dan berikan `[CreateQueueRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/CreateQueueRequest.html)` objek yang menjelaskan parameter antrian seperti yang ditunjukkan pada cuplikan kode berikut.
**Impor**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Kode**
```
CreateQueueRequest createQueueRequest = CreateQueueRequest.builder()
.queueName(queueName)
.build();
sqsClient.createQueue(createQueueRequest);
```
Lihat [sampel lengkapnya](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L52) di GitHub.
## Daftar antrian
Untuk membuat daftar Amazon Simple Queue Service antrian untuk akun Anda, panggil `SqsClient’s` `listQueues` metode dengan `[ListQueuesRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ListQueuesRequest.html)` objek.
Bila Anda menggunakan bentuk [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())metode yang tidak mengambil parameter, layanan mengembalikan *semua antrian hingga 1.000* antrian.
Anda dapat memberikan awalan nama antrian ke `[ListQueuesRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ListQueuesRequest.html)` objek untuk membatasi hasil ke antrian yang cocok dengan awalan seperti yang ditunjukkan dalam kode berikut.
**Impor**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Kode**
```
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);
}
```
Lihat [sampel lengkapnya](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L79) di GitHub.
## Dapatkan URL untuk antrian
Kode berikut menunjukkan cara mendapatkan URL untuk antrian dengan memanggil `SqsClient’s` `getQueueUrl` metode dengan `[GetQueueUrlRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/GetQueueUrlRequest.html)` objek.
**Impor**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Kode**
```
GetQueueUrlResponse getQueueUrlResponse =
sqsClient.getQueueUrl(GetQueueUrlRequest.builder().queueName(queueName).build());
String queueUrl = getQueueUrlResponse.queueUrl();
return queueUrl;
```
Lihat [sampel lengkapnya](https://github.com/awsdocs/aws-doc-sdk-examples/blob/7486a1a092aa8e16a21698ef26f9d524fef62e55/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L70) di GitHub.
## Hapus antrian
Berikan [URL](#sqs-get-queue-url) antrian ke `[DeleteQueueRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/DeleteQueueRequest.html)` objek. Kemudian panggil `SqsClient’s` `deleteQueue` metode untuk menghapus antrian seperti yang ditunjukkan pada kode berikut.
**Impor**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Kode**
```
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);
}
}
```
Lihat [sampel lengkapnya](https://github.com/awsdocs/aws-doc-sdk-examples/blob/6240df86c5f17eae1e23d1139d1435c7dc4b2a11/javav2/example_code/sqs/src/main/java/com/example/sqs/DeleteQueue.java#L48) di GitHub.
## Informasi selengkapnya
+ [CreateQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)di Referensi Amazon Simple Queue Service API
+ [GetQueueUrl](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_GetQueueUrl.html)di Referensi Amazon Simple Queue Service API
+ [ListQueues](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ListQueues.html)di Referensi Amazon Simple Queue Service API
+ [DeleteQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteQueue.html)di Referensi Amazon Simple Queue Service API
# Mengirim, menerima, dan menghapus Amazon Simple Queue Service pesan
Pesan adalah sepotong data yang dapat dikirim dan diterima oleh komponen terdistribusi. Pesan selalu dikirimkan menggunakan [SQS Queue](examples-sqs-message-queues.md).
`sqsClient`Variabel yang digunakan dalam contoh berikut dapat dibuat dari cuplikan berikut.
```
SqsClient sqsClient = SqsClient.create();
```
Bila Anda membuat `SqsClient` dengan menggunakan `create()` metode statis, SDK akan mengonfigurasi Region menggunakan [rantai penyedia wilayah default dan kredensialnya menggunakan rantai penyedia](region-selection.md#default-region-provider-chain) kredensial [default](credentials-chain.md).
## Kirim pesan
Tambahkan satu pesan ke Amazon Simple Queue Service antrian dengan memanggil `sendMessage` metode SqsClient klien. Berikan [SendMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageRequest.html)objek yang berisi [URL](examples-sqs-message-queues.md#sqs-get-queue-url) antrian, isi pesan, dan nilai penundaan opsional (dalam hitungan detik).
**Impor**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Kode**
```
sqsClient.sendMessage(SendMessageRequest.builder()
.queueUrl(queueUrl)
.messageBody("Hello world!")
.delaySeconds(10)
.build());
sqsClient.sendMessage(sendMsgRequest);
```
## Kirim beberapa pesan dalam satu permintaan
Kirim lebih dari satu pesan dalam satu permintaan dengan menggunakan SqsClient `sendMessageBatch` metode ini. Metode ini mengambil [SendMessageBatchRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageBatchRequest.html)yang berisi URL antrian dan daftar pesan untuk dikirim. (Setiap pesan adalah a [SendMessageBatchRequestEntry](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/SendMessageBatchRequestEntry.html).) Anda juga dapat menunda pengiriman pesan tertentu dengan menetapkan nilai penundaan pada pesan.
**Impor**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Kode**
```
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);
```
Lihat [sampel lengkapnya](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L133) di GitHub.
## Ambil Pesan
Ambil pesan apa pun yang saat ini berada dalam antrian dengan memanggil metode. SqsClient `receiveMessage` Metode ini mengambil [ReceiveMessageRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/ReceiveMessageRequest.html)yang berisi URL antrian. Anda juga dapat menentukan jumlah maksimum pesan yang akan dikembalikan. Pesan dikembalikan sebagai daftar objek [Pesan](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sqs/model/Message.html).
**Impor**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Kode**
```
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;
```
Lihat [sampel lengkapnya](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L148) di GitHub.
## Hapus pesan setelah diterima
Setelah menerima pesan dan memproses isinya, hapus pesan dari antrian dengan mengirimkan alamat tanda terima pesan dan URL antrian ke metode. `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))
**Impor**
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.*;
import java.util.List;
```
**Kode**
```
try {
for (Message message : messages) {
DeleteMessageRequest deleteMessageRequest = DeleteMessageRequest.builder()
.queueUrl(queueUrl)
.receiptHandle(message.receiptHandle())
.build();
sqsClient.deleteMessage(deleteMessageRequest);
}
```
Lihat [sampel lengkapnya](https://github.com/awsdocs/aws-doc-sdk-examples/blob/cf25559da654a7b74bec039c0ab9397dc5951dd4/javav2/example_code/sqs/src/main/java/com/example/sqs/SQSExample.java#L187) di GitHub.
## Info Selengkapnya
+ [Cara Kerja Amazon Simple Queue Service Antrian di Panduan](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-basic-architecture.html) Pengembang Amazon Simple Queue Service
+ [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)di Referensi Amazon Simple Queue Service API
+ [SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)di Referensi Amazon Simple Queue Service API
+ [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)di Referensi Amazon Simple Queue Service API
+ [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)di Referensi Amazon Simple Queue Service API
# Bekerja dengan Amazon Transcribe
Contoh berikut menunjukkan cara kerja streaming dua arah menggunakan. Amazon Transcribe Streaming dua arah berarti bahwa ada aliran data yang masuk ke layanan dan diterima kembali secara real time. Contoh menggunakan transkripsi Amazon Transcribe streaming untuk mengirim aliran audio dan menerima aliran teks yang ditranskripsi kembali secara real time.
Lihat [Transkripsi Streaming](https://docs.aws.amazon.com//transcribe/latest/dg/streaming.html) di Panduan Amazon Transcribe Pengembang untuk mempelajari lebih lanjut tentang fitur ini.
Lihat [Memulai](https://docs.aws.amazon.com//transcribe/latest/dg/getting-started.html) di Panduan Amazon Transcribe Pengembang untuk mulai menggunakan Amazon Transcribe.
## Siapkan mikrofon
Kode ini menggunakan paket javax.sound.sampled untuk mengalirkan audio dari perangkat input.
**Kode**
```
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;
}
}
```
Lihat [contoh lengkapnya](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/Microphone.java) di GitHub.
## Buat penerbit
Kode ini mengimplementasikan penerbit yang menerbitkan data audio dari aliran audio. Amazon Transcribe
**Kode**
```
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();
}
}
}
```
Lihat [contoh lengkapnya](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/AudioStreamPublisher.java) di GitHub.
## Buat klien dan mulai streaming
Dalam metode utama, buat objek permintaan, mulai aliran input audio dan buat instance penerbit dengan input audio.
Anda juga harus membuat [StartStreamTranscriptionResponseHandler](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/transcribestreaming/model/StartStreamTranscriptionResponseHandler.html)untuk menentukan cara menangani respons dari Amazon Transcribe.
Kemudian, gunakan `startStreamTranscription` metode ini untuk memulai streaming dua arah. TranscribeStreamingAsyncClient
**Impor**
```
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;
```
**Kode**
```
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);
}
}
```
Lihat [contoh lengkapnya](https://github.com/awsdocs/aws-doc-sdk-examples/blob/ac748d8ef99cd17e297cb74fe13aa671e2679088/javav2/example_code/transcribe/src/main/java/com/amazonaws/transcribe/BidirectionalStreaming.java) di GitHub.
## Informasi selengkapnya
+ [Cara Kerjanya](https://docs.aws.amazon.com//transcribe/latest/dg/how-it-works.html) di Panduan Amazon Transcribe Pengembang.
+ [Memulai Dengan Streaming Audio](https://docs.aws.amazon.com//transcribe/latest/dg/getting-started.html) di Panduan Amazon Transcribe Pengembang.