Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menggunakan Amazon SQS Java Messaging Library
Untuk mulai menggunakan Java Message Service (JMS) dengan Amazon SQS, gunakan contoh kode di bagian ini. Bagian berikut menunjukkan cara membuat koneksi JMS dan sesi, dan cara mengirim dan menerima pesan.
Objek klien Amazon SQS yang dibungkus yang disertakan dalam Perpustakaan Pesan Java Amazon SQS memeriksa apakah antrian Amazon SQS ada. Jika antrian tidak ada, klien membuatnya.
## Membuat koneksi JMS
Sebelum Anda mulai, lihat prasyarat di. [Prasyarat untuk bekerja dengan JMS dan Amazon SQS](prerequisites.md)
1. Buat pabrik koneksi dan panggil `createConnection` metode melawan pabrik.
```
// Create a new connection factory with all defaults (credentials and region) set automatically
SQSConnectionFactory connectionFactory = new SQSConnectionFactory(
new ProviderConfiguration(),
AmazonSQSClientBuilder.defaultClient()
);
// Create the connection.
SQSConnection connection = connectionFactory.createConnection();
```
`SQSConnection`Kelas meluas. `javax.jms.Connection` Bersama dengan metode koneksi standar JMS, `SQSConnection` menawarkan metode tambahan, seperti `getAmazonSQSClient` dan`getWrappedAmazonSQSClient`. Kedua metode memungkinkan Anda melakukan operasi administratif yang tidak termasuk dalam spesifikasi JMS, seperti membuat antrian baru. Namun, `getWrappedAmazonSQSClient` metode ini juga menyediakan versi terbungkus dari klien Amazon SQS yang digunakan oleh koneksi saat ini. Pembungkus mengubah setiap pengecualian dari klien menjadi`JMSException`, memungkinkannya untuk lebih mudah digunakan oleh kode yang ada yang mengharapkan `JMSException` kejadian.
1. Anda dapat menggunakan objek klien yang dikembalikan dari `getAmazonSQSClient` dan `getWrappedAmazonSQSClient` untuk melakukan operasi administratif yang tidak termasuk dalam spesifikasi JMS (misalnya, Anda dapat membuat antrean Amazon SQS).
Jika Anda memiliki kode yang mengharapkan pengecualian JMS, maka Anda harus menggunakan: `getWrappedAmazonSQSClient`
+ Jika Anda menggunakan`getWrappedAmazonSQSClient`, objek klien yang dikembalikan mengubah semua pengecualian menjadi pengecualian JMS.
+ Jika Anda menggunakan`getAmazonSQSClient`, pengecualian adalah semua pengecualian Amazon SQS.
## Membuat antrian Amazon SQS
Objek klien yang dibungkus memeriksa apakah antrian Amazon SQS ada.
Jika antrian tidak ada, klien membuatnya. Jika antrian memang ada, fungsi tidak mengembalikan apa pun. Untuk informasi selengkapnya, lihat bagian “Buat antrian jika diperlukan” pada [TextMessageSender.jawa](sqs-jms-code-examples.md#example-sender) contoh.
### Untuk membuat antrian standar
```
// Get the wrapped client
AmazonSQSMessagingClientWrapper client = connection.getWrappedAmazonSQSClient();
// Create an SQS queue named MyQueue, if it doesn't already exist
if (!client.queueExists("MyQueue")) {
client.createQueue("MyQueue");
}
```
### Untuk membuat antrian FIFO
```
// Get the wrapped client
AmazonSQSMessagingClientWrapper client = connection.getWrappedAmazonSQSClient();
// Create an Amazon SQS FIFO queue named MyQueue.fifo, if it doesn't already exist
if (!client.queueExists("MyQueue.fifo")) {
Map attributes = new HashMap();
attributes.put("FifoQueue", "true");
attributes.put("ContentBasedDeduplication", "true");
client.createQueue(new CreateQueueRequest().withQueueName("MyQueue.fifo").withAttributes(attributes));
}
```
**catatan**
Nama antrian FIFO harus diakhiri dengan akhiran. `.fifo`
Untuk informasi selengkapnya tentang `ContentBasedDeduplication` atribut, lihat[Tepat sekali diproses di Amazon SQS](FIFO-queues-exactly-once-processing.md).
## Mengirim pesan secara sinkron
1. Saat koneksi dan antrean Amazon SQS yang mendasarinya sudah siap, buat sesi JMS yang tidak ditransaksikan dengan mode. `AUTO_ACKNOWLEDGE`
```
// Create the nontransacted session with AUTO_ACKNOWLEDGE mode
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
```
1. Untuk mengirim pesan teks ke antrian, buat identitas antrian JMS dan produser pesan.
```
// Create a queue identity and specify the queue name to the session
Queue queue = session.createQueue("MyQueue");
// Create a producer for the 'MyQueue'
MessageProducer producer = session.createProducer(queue);
```
1. Buat pesan teks dan kirimkan ke antrian.
+ Untuk mengirim pesan ke antrian standar, Anda tidak perlu mengatur parameter tambahan apa pun.
```
// Create the text message
TextMessage message = session.createTextMessage("Hello World!");
// Send the message
producer.send(message);
System.out.println("JMS Message " + message.getJMSMessageID());
```
+ Untuk mengirim pesan ke antrian FIFO, Anda harus mengatur ID grup pesan. Anda juga dapat mengatur ID deduplikasi pesan. Untuk informasi selengkapnya, lihat [Istilah kunci antrian Amazon SQS FIFO](FIFO-key-terms.md).
```
// Create the text message
TextMessage message = session.createTextMessage("Hello World!");
// Set the message group ID
message.setStringProperty("JMSXGroupID", "Default");
// You can also set a custom message deduplication ID
// message.setStringProperty("JMS_SQS_DeduplicationId", "hello");
// Here, it's not needed because content-based deduplication is enabled for the queue
// Send the message
producer.send(message);
System.out.println("JMS Message " + message.getJMSMessageID());
System.out.println("JMS Message Sequence Number " + message.getStringProperty("JMS_SQS_SequenceNumber"));
```
## Menerima pesan secara sinkron
1. Untuk menerima pesan, buat konsumen untuk antrian yang sama dan panggil metode. `start`
Anda dapat memanggil `start` metode pada koneksi kapan saja. Namun, konsumen tidak mulai menerima pesan sampai Anda memanggilnya.
```
// Create a consumer for the 'MyQueue'
MessageConsumer consumer = session.createConsumer(queue);
// Start receiving incoming messages
connection.start();
```
1. Panggil `receive` metode pada konsumen dengan batas waktu diatur ke 1 detik, dan kemudian cetak konten pesan yang diterima.
+ Setelah menerima pesan dari antrian standar, Anda dapat mengakses konten pesan.
```
// Receive a message from 'MyQueue' and wait up to 1 second
Message receivedMessage = consumer.receive(1000);
// Cast the received message as TextMessage and display the text
if (receivedMessage != null) {
System.out.println("Received: " + ((TextMessage) receivedMessage).getText());
}
```
+ Setelah menerima pesan dari antrian FIFO, Anda dapat mengakses konten pesan dan atribut pesan khusus FIFO lainnya, seperti ID grup pesan, ID deduplikasi pesan, dan nomor urut. Untuk informasi selengkapnya, lihat [Istilah kunci antrian Amazon SQS FIFO](FIFO-key-terms.md).
```
// Receive a message from 'MyQueue' and wait up to 1 second
Message receivedMessage = consumer.receive(1000);
// Cast the received message as TextMessage and display the text
if (receivedMessage != null) {
System.out.println("Received: " + ((TextMessage) receivedMessage).getText());
System.out.println("Group id: " + receivedMessage.getStringProperty("JMSXGroupID"));
System.out.println("Message deduplication id: " + receivedMessage.getStringProperty("JMS_SQS_DeduplicationId"));
System.out.println("Message sequence number: " + receivedMessage.getStringProperty("JMS_SQS_SequenceNumber"));
}
```
1. Tutup koneksi dan sesi.
```
// Close the connection (and the session).
connection.close();
```
Output akan terlihat serupa dengan yang berikut ini:
```
JMS Message ID:8example-588b-44e5-bbcf-d816example2
Received: Hello World!
```
**catatan**
Anda dapat menggunakan Spring Framework untuk menginisialisasi objek-objek ini.
Untuk informasi tambahan, lihat `SpringExampleConfiguration.xml``SpringExample.java`,, dan kelas pembantu lainnya di `ExampleConfiguration.java` dan `ExampleCommon.java` di [Contoh Java yang berfungsi untuk menggunakan JMS dengan antrian standar Amazon SQS](sqs-jms-code-examples.md) bagian.
Untuk contoh lengkap mengirim dan menerima objek, lihat [TextMessageSender.jawa](sqs-jms-code-examples.md#example-sender) dan[SyncMessageReceiver.jawa](sqs-jms-code-examples.md#example-synchronous-message-receiver).
## Menerima pesan secara asinkron
Dalam contoh di[Menggunakan Amazon SQS Java Messaging Library](#getting-started), pesan dikirim ke `MyQueue` dan diterima secara serempak.
Contoh berikut menunjukkan cara menerima pesan secara asinkron melalui pendengar.
1. Menerapkan `MessageListener` antarmuka.
```
class MyListener implements MessageListener {
@Override
public void onMessage(Message message) {
try {
// Cast the received message as TextMessage and print the text to screen.
System.out.println("Received: " + ((TextMessage) message).getText());
} catch (JMSException e) {
e.printStackTrace();
}
}
}
```
`onMessage`Metode `MessageListener` antarmuka dipanggil ketika Anda menerima pesan. Dalam implementasi listener ini, teks yang disimpan dalam pesan dicetak.
1. Alih-alih secara eksplisit memanggil `receive` metode pada konsumen, atur pendengar pesan konsumen ke instance implementasi. `MyListener` Utas utama menunggu satu detik.
```
// Create a consumer for the 'MyQueue'.
MessageConsumer consumer = session.createConsumer(queue);
// Instantiate and set the message listener for the consumer.
consumer.setMessageListener(new MyListener());
// Start receiving incoming messages.
connection.start();
// Wait for 1 second. The listener onMessage() method is invoked when a message is received.
Thread.sleep(1000);
```
Langkah-langkah lainnya identik dengan yang ada di [Menggunakan Amazon SQS Java Messaging Library](#getting-started) contoh. Untuk contoh lengkap konsumen asinkron, lihat di. `AsyncMessageReceiver.java` [Contoh Java yang berfungsi untuk menggunakan JMS dengan antrian standar Amazon SQS](sqs-jms-code-examples.md)
Output untuk contoh ini terlihat mirip dengan yang berikut:
```
JMS Message ID:8example-588b-44e5-bbcf-d816example2
Received: Hello World!
```
## Menggunakan mode pengakuan klien
Contoh dalam `AUTO_ACKNOWLEDGE` mode [Menggunakan Amazon SQS Java Messaging Library](#getting-started) penggunaan di mana setiap pesan yang diterima diakui secara otomatis (dan karenanya dihapus dari antrean Amazon SQS yang mendasarinya).
1. Untuk secara eksplisit mengakui pesan setelah diproses, Anda harus membuat sesi dengan mode. `CLIENT_ACKNOWLEDGE`
```
// Create the non-transacted session with CLIENT_ACKNOWLEDGE mode.
Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
```
1. Ketika pesan diterima, tampilkan dan kemudian secara eksplisit mengakuinya.
```
// Cast the received message as TextMessage and print the text to screen. Also acknowledge the message.
if (receivedMessage != null) {
System.out.println("Received: " + ((TextMessage) receivedMessage).getText());
receivedMessage.acknowledge();
System.out.println("Acknowledged: " + message.getJMSMessageID());
}
```
**catatan**
Dalam mode ini, ketika pesan diakui, semua pesan yang diterima sebelum pesan ini secara implisit diakui juga. Misalnya, jika 10 pesan diterima, dan hanya pesan ke-10 yang diakui (dalam urutan pesan diterima), maka semua dari sembilan pesan sebelumnya juga diakui.
Langkah-langkah lainnya identik dengan yang ada di [Menggunakan Amazon SQS Java Messaging Library](#getting-started) contoh. Untuk contoh lengkap konsumen sinkron dengan mode pengakuan klien, lihat `SyncMessageReceiverClientAcknowledge.java` di. [Contoh Java yang berfungsi untuk menggunakan JMS dengan antrian standar Amazon SQS](sqs-jms-code-examples.md)
Output untuk contoh ini terlihat mirip dengan yang berikut:
```
JMS Message ID:4example-aa0e-403f-b6df-5e02example5
Received: Hello World!
Acknowledged: ID:4example-aa0e-403f-b6df-5e02example5
```
## Menggunakan mode pengakuan tidak berurutan
Saat menggunakan `CLIENT_ACKNOWLEDGE` mode, semua pesan yang diterima sebelum pesan yang diakui secara eksplisit diakui secara otomatis. Untuk informasi selengkapnya, lihat [Menggunakan mode pengakuan klien](#using-client-acknowledge-mode).
Amazon SQS Java Messaging Library menyediakan mode pengakuan lain. Saat menggunakan `UNORDERED_ACKNOWLEDGE` mode, semua pesan yang diterima harus diakui secara individual dan eksplisit oleh klien, terlepas dari pesanan penerimaan mereka. Untuk melakukan ini, buat sesi dengan `UNORDERED_ACKNOWLEDGE` mode.
```
// Create the non-transacted session with UNORDERED_ACKNOWLEDGE mode.
Session session = connection.createSession(false, SQSSession.UNORDERED_ACKNOWLEDGE);
```
Langkah-langkah yang tersisa identik dengan yang ada di [Menggunakan mode pengakuan klien](#using-client-acknowledge-mode) contoh. Untuk contoh lengkap konsumen sinkron dengan `UNORDERED_ACKNOWLEDGE` mode, lihat`SyncMessageReceiverUnorderedAcknowledge.java`.
Dalam contoh ini, outputnya terlihat mirip dengan yang berikut:
```
JMS Message ID:dexample-73ad-4adb-bc6c-4357example7
Received: Hello World!
Acknowledged: ID:dexample-73ad-4adb-bc6c-4357example7
```