From 7f2580a07a06adf99cb12c7de18e9ee2a110d217 Mon Sep 17 00:00:00 2001 From: Tejas Ganesh Naik <“tejasgn@amazon.com”> Date: Tue, 1 Jul 2025 15:09:20 -0700 Subject: [PATCH 1/4] Send and Receive SQS Java Follow --- .doc_gen/metadata/sqs_metadata.yaml | 11 +- javav2/example_code/sqs/README.md | 1 + .../java/com/example/sqs/SendRecvBatch.java | 333 ++++++++++++++++++ .../com/example/sqs/SendRecvBatchTest.java | 128 +++++++ 4 files changed, 472 insertions(+), 1 deletion(-) create mode 100644 javav2/example_code/sqs/src/main/java/com/example/sqs/SendRecvBatch.java create mode 100644 javav2/example_code/sqs/src/test/java/com/example/sqs/SendRecvBatchTest.java diff --git a/.doc_gen/metadata/sqs_metadata.yaml b/.doc_gen/metadata/sqs_metadata.yaml index 60d2b83ee2a..a056463e42b 100644 --- a/.doc_gen/metadata/sqs_metadata.yaml +++ b/.doc_gen/metadata/sqs_metadata.yaml @@ -866,7 +866,16 @@ sqs_Scenario_SendReceiveBatch: - python.example_code.sqs.DeleteMessageBatch - description: Use the wrapper functions to send and receive messages in batches. snippet_tags: - - python.example_code.sqs.Scenario_SendReceiveBatch + - python.example_code.sqs.Scenario_SendReceiveBatch + Java: + versions: + - sdk_version: 2 + github: javav2/example_code/sqs + sdkguide: + excerpts: + - description: Create functions to wrap &SQS; message functions and use them to send and receive messages in batches. + snippet_tags: + - sqs.java2.sendRecvBatch.main services: sqs: {CreateQueue, DeleteQueue, SendMessageBatch, ReceiveMessage, DeleteMessageBatch} sqs_GetQueueAttributes: diff --git a/javav2/example_code/sqs/README.md b/javav2/example_code/sqs/README.md index 02e10ae1769..4a07b3cd4e2 100644 --- a/javav2/example_code/sqs/README.md +++ b/javav2/example_code/sqs/README.md @@ -59,6 +59,7 @@ functions within the same service. - [Publish messages to queues](../../usecases/topics_and_queues/src/main/java/com/example/sns/SNSWorkflow.java) - [Use the Amazon SQS Java Messaging Library to work with the JMS interface](../sqs-jms/src/main/java/com/example/sqs/jms/stdqueue/TextMessageSender.java) - [Work with queue tags](src/main/java/com/example/sqs/TagExamples.java) +- [Send and receive batches of messages](src/main/java/com/example/sqs/TagExamples.java) diff --git a/javav2/example_code/sqs/src/main/java/com/example/sqs/SendRecvBatch.java b/javav2/example_code/sqs/src/main/java/com/example/sqs/SendRecvBatch.java new file mode 100644 index 00000000000..8628189e410 --- /dev/null +++ b/javav2/example_code/sqs/src/main/java/com/example/sqs/SendRecvBatch.java @@ -0,0 +1,333 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package com.example.sqs; + +// snippet-start:[sqs.java2.sendRecvBatch.main] +// snippet-start:[sqs.java2.sendRecvBatch.import] +import software.amazon.awssdk.regions.Region; +import software.amazon.awssdk.services.sqs.SqsClient; +import software.amazon.awssdk.services.sqs.model.*; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.logging.Level; +import java.util.logging.Logger; +// snippet-end:[sqs.java2.sendRecvBatch.import] + + +/** + * Before running this Java V2 code example, set up your development + * environment, including your credentials. + * + * For more information, see the following documentation topic: + * + * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html + */ + +/** + * This code demonstrates basic message operations in Amazon Simple Queue Service (Amazon SQS). + */ + +public class SendRecvBatch { + private static final Logger logger = Logger.getLogger(SendRecvBatch.class.getName()); + static { + Logger rootLogger = Logger.getLogger(""); + rootLogger.setLevel(Level.WARNING); + } + private static final SqsClient sqsClient = SqsClient.builder() + .region(Region.US_WEST_2) + .build(); + + // snippet-start:[sqs.java2.sendRecvBatch.sendBatch] + /** + * Send a batch of messages in a single request to an SQS queue. + * This request may return overall success even when some messages were not sent. + * The caller must inspect the Successful and Failed lists in the response and + * resend any failed messages. + * + * @param queueUrl The URL of the queue to receive the messages. + * @param messages The messages to send to the queue. Each message contains a body and attributes. + * @return The response from SQS that contains the list of successful and failed messages. + */ + public static SendMessageBatchResponse sendMessages( + String queueUrl, List messages) { + + try { + List entries = new ArrayList<>(); + + for (int i = 0; i < messages.size(); i++) { + MessageEntry message = messages.get(i); + entries.add(SendMessageBatchRequestEntry.builder() + .id(String.valueOf(i)) + .messageBody(message.getBody()) + .messageAttributes(message.getAttributes()) + .build()); + } + + SendMessageBatchRequest sendBatchRequest = SendMessageBatchRequest.builder() + .queueUrl(queueUrl) + .entries(entries) + .build(); + + SendMessageBatchResponse response = sqsClient.sendMessageBatch(sendBatchRequest); + + if (!response.successful().isEmpty()) { + for (SendMessageBatchResultEntry resultEntry : response.successful()) { + logger.info("Message sent: " + resultEntry.messageId() + ": " + + messages.get(Integer.parseInt(resultEntry.id())).getBody()); + } + } + + if (!response.failed().isEmpty()) { + for (BatchResultErrorEntry errorEntry : response.failed()) { + logger.warning("Failed to send: " + errorEntry.id() + ": " + + messages.get(Integer.parseInt(errorEntry.id())).getBody()); + } + } + + return response; + + } catch (SqsException e) { + logger.log(Level.SEVERE, "Send messages failed to queue: " + queueUrl, e); + throw e; + } + } + // snippet-end:[sqs.java2.sendRecvBatch.sendBatch] + + // snippet-start:[sqs.java2.sendRecvBatch.recvBatch] + /** + * Receive a batch of messages in a single request from an SQS queue. + * + * @param queueUrl The URL of the queue from which to receive messages. + * @param maxNumber The maximum number of messages to receive. The actual number + * of messages received might be less. + * @param waitTime The maximum time to wait (in seconds) before returning. When + * this number is greater than zero, long polling is used. This + * can result in reduced costs and fewer false empty responses. + * @return The list of Message objects received. These each contain the body + * of the message and metadata and custom attributes. + */ + public static List receiveMessages(String queueUrl, int maxNumber, int waitTime) { + try { + ReceiveMessageRequest receiveRequest = ReceiveMessageRequest.builder() + .queueUrl(queueUrl) + .maxNumberOfMessages(maxNumber) + .waitTimeSeconds(waitTime) + .messageAttributeNames("All") + .build(); + + List messages = sqsClient.receiveMessage(receiveRequest).messages(); + + for (Message message : messages) { + logger.info("Received message: " + message.messageId() + ": " + message.body()); + } + + return messages; + + } catch (SqsException e) { + logger.log(Level.SEVERE, "Couldn't receive messages from queue: " + queueUrl, e); + throw e; + } + } + // snippet-end:[sqs.java2.sendRecvBatch.recvBatch] + + // snippet-start:[sqs.java2.sendRecvBatch.delBatch] + /** + * Delete a batch of messages from a queue in a single request. + * + * @param queueUrl The URL of the queue from which to delete the messages. + * @param messages The list of messages to delete. + * @return The response from SQS that contains the list of successful and failed + * message deletions. + */ + public static DeleteMessageBatchResponse deleteMessages(String queueUrl, List messages) { + try { + List entries = new ArrayList<>(); + + for (int i = 0; i < messages.size(); i++) { + entries.add(DeleteMessageBatchRequestEntry.builder() + .id(String.valueOf(i)) + .receiptHandle(messages.get(i).receiptHandle()) + .build()); + } + + DeleteMessageBatchRequest deleteRequest = DeleteMessageBatchRequest.builder() + .queueUrl(queueUrl) + .entries(entries) + .build(); + + DeleteMessageBatchResponse response = sqsClient.deleteMessageBatch(deleteRequest); + + if (!response.successful().isEmpty()) { + for (DeleteMessageBatchResultEntry resultEntry : response.successful()) { + logger.info("Deleted " + messages.get(Integer.parseInt(resultEntry.id())).receiptHandle()); + } + } + + if (!response.failed().isEmpty()) { + for (BatchResultErrorEntry errorEntry : response.failed()) { + logger.warning("Could not delete " + messages.get(Integer.parseInt(errorEntry.id())).receiptHandle()); + } + } + + return response; + + } catch (SqsException e) { + logger.log(Level.SEVERE, "Couldn't delete messages from queue " + queueUrl, e); + throw e; + } + } + // snippet-end:[sqs.java2.sendRecvBatch.delBatch] + + // snippet-start:[sqs.java2.sendRecvBatch.scenario] + /** + * Helper class to represent a message with body and attributes. + */ + public static class MessageEntry { + private final String body; + private final Map attributes; + + public MessageEntry(String body, Map attributes) { + this.body = body; + this.attributes = attributes != null ? attributes : new HashMap<>(); + } + + public String getBody() { + return body; + } + + public Map getAttributes() { + return attributes; + } + } + + /** + * Shows how to: + * * Read the lines from this Java file and send the lines in + * batches of 10 as messages to a queue. + * * Receive the messages in batches until the queue is empty. + * * Reassemble the lines of the file and verify they match the original file. + */ + public static void usageDemo() { + System.out.println("-".repeat(88)); + System.out.println("Welcome to the Amazon Simple Queue Service (Amazon SQS) demo!"); + System.out.println("-".repeat(88)); + + // Create a queue for the demo + String queueName = "sqs-usage-demo-message-wrapper-"+System.currentTimeMillis(); + CreateQueueRequest createRequest = CreateQueueRequest.builder() + .queueName(queueName) + .build(); + String queueUrl = sqsClient.createQueue(createRequest).queueUrl(); + System.out.println("Created queue: " + queueUrl); + + try { + // Read the lines from this Java file + Path projectRoot = Paths.get(System.getProperty("user.dir")); + Path filePath = projectRoot.resolve("src/main/java/com/example/sqs/SendRecvBatch.java"); + List lines = Files.readAllLines(filePath); + + + // Send file lines in batches + int batchSize = 10; + System.out.println("Sending file lines in batches of " + batchSize + " as messages."); + + for (int i = 0; i < lines.size(); i += batchSize) { + List messageBatch = new ArrayList<>(); + + for (int j = i; j < Math.min(i + batchSize, lines.size()); j++) { + String line = lines.get(j); + if (line == null || line.trim().isEmpty()) { + continue; // Skip empty lines + } + + Map attributes = new HashMap<>(); + attributes.put("path", MessageAttributeValue.builder() + .dataType("String") + .stringValue(filePath.toString()) + .build()); + attributes.put("line", MessageAttributeValue.builder() + .dataType("String") + .stringValue(String.valueOf(j)) + .build()); + + messageBatch.add(new MessageEntry(lines.get(j), attributes)); + } + + sendMessages(queueUrl, messageBatch); + System.out.print("."); + System.out.flush(); + } + + System.out.println("\nDone. Sent " + lines.size() + " messages."); + + // Receive and process messages + System.out.println("Receiving, handling, and deleting messages in batches of " + batchSize + "."); + String[] receivedLines = new String[lines.size()]; + boolean moreMessages = true; + + while (moreMessages) { + List receivedMessages = receiveMessages(queueUrl, batchSize, 5); + System.out.print("."); + System.out.flush(); + + for (Message message : receivedMessages) { + int lineNumber = Integer.parseInt(message.messageAttributes().get("line").stringValue()); + receivedLines[lineNumber] = message.body(); + } + + if (!receivedMessages.isEmpty()) { + deleteMessages(queueUrl, receivedMessages); + } else { + moreMessages = false; + } + } + + System.out.println("\nDone."); + + // Verify all lines were received correctly + boolean allLinesMatch = true; + for (int i = 0; i < lines.size(); i++) { + String originalLine = lines.get(i); + String receivedLine = receivedLines[i] == null ? "" : receivedLines[i]; + + if (!originalLine.equals(receivedLine)) { + allLinesMatch = false; + break; + } + } + + if (allLinesMatch) { + System.out.println("Successfully reassembled all file lines!"); + } else { + System.out.println("Uh oh, some lines were missed!"); + } + + } catch (IOException e) { + logger.log(Level.SEVERE, "Error reading file", e); + } finally { + // Clean up by deleting the queue + DeleteQueueRequest deleteQueueRequest = DeleteQueueRequest.builder() + .queueUrl(queueUrl) + .build(); + sqsClient.deleteQueue(deleteQueueRequest); + System.out.println("Deleted queue: " + queueUrl); + } + + System.out.println("Thanks for watching!"); + System.out.println("-".repeat(88)); + } + + public static void main(String[] args) { + usageDemo(); + } +} +// snippet-end:[sqs.java2.sendRecvBatch.scenario] +// snippet-end:[sqs.java2.sendRecvBatch.main] \ No newline at end of file diff --git a/javav2/example_code/sqs/src/test/java/com/example/sqs/SendRecvBatchTest.java b/javav2/example_code/sqs/src/test/java/com/example/sqs/SendRecvBatchTest.java new file mode 100644 index 00000000000..7bb6e4de3d1 --- /dev/null +++ b/javav2/example_code/sqs/src/test/java/com/example/sqs/SendRecvBatchTest.java @@ -0,0 +1,128 @@ +// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +// SPDX-License-Identifier: Apache-2.0 + +package com.example.sqs; + +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import software.amazon.awssdk.services.sqs.SqsClient; +import software.amazon.awssdk.services.sqs.model.*; + +import java.util.*; +import java.util.stream.Stream; + +import static org.junit.jupiter.api.Assertions.*; + +public class SendRecvBatchTest { + private static final Logger logger = LoggerFactory.getLogger(SendRecvBatchTest.class); + private static final SqsClient sqsClient = SqsClient.create(); + private String queueUrl = ""; + + @BeforeEach + void setUp() { + String queueName = "SendRecvBatch-queue-" + UUID.randomUUID().toString().replace("-", "").substring(0, 20); + queueUrl = sqsClient.createQueue(b -> b.queueName(queueName)).queueUrl(); + logger.info("Created test queue: {}", queueUrl); + } + + @AfterEach + void tearDown() { + sqsClient.deleteQueue(b -> b.queueUrl(queueUrl)); + logger.info("Deleted test queue: {}", queueUrl); + } + + private static Stream sendMessageBatchTestData() { + return Stream.of( + Arguments.of(List.of( + new SendRecvBatch.MessageEntry("Message 1", Collections.emptyMap()), + new SendRecvBatch.MessageEntry("Message 2", Collections.emptyMap()) + )), + Arguments.of(List.of( + new SendRecvBatch.MessageEntry("Message with attributes", Map.of( + "type", MessageAttributeValue.builder() + .stringValue("test") + .dataType("String") + .build() + )) + )) + ); + } + + @ParameterizedTest + @MethodSource("sendMessageBatchTestData") + void testSendMessages(List messages) { + logger.info("Testing send messages with {} messages", messages.size()); + SendMessageBatchResponse response = SendRecvBatch.sendMessages(queueUrl, messages); + assertEquals(messages.size(), response.successful().size()); + logger.info("Successfully sent {} messages", response.successful().size()); + } + + @Test + void testReceiveMessages() { + logger.info("Testing receive messages"); + // First send some messages + List messages = List.of( + new SendRecvBatch.MessageEntry("Test message 1", Collections.emptyMap()), + new SendRecvBatch.MessageEntry("Test message 2", Collections.emptyMap()) + ); + SendRecvBatch.sendMessages(queueUrl, messages); + logger.info("Sent {} messages for receive test", messages.size()); + + List receivedMessages = SendRecvBatch.receiveMessages(queueUrl, 10, 5); + assertFalse(receivedMessages.isEmpty()); + logger.info("Received {} messages", receivedMessages.size()); + } + + @Test + void testDeleteMessages() { + logger.info("Testing delete messages"); + // First send and receive messages + List messages = List.of( + new SendRecvBatch.MessageEntry("Test message", Collections.emptyMap()) + ); + SendRecvBatch.sendMessages(queueUrl, messages); + logger.info("Sent {} messages for delete test", messages.size()); + + List receivedMessages = SendRecvBatch.receiveMessages(queueUrl, 10, 5); + assertFalse(receivedMessages.isEmpty()); + logger.info("Received {} messages to delete", receivedMessages.size()); + + DeleteMessageBatchResponse response = SendRecvBatch.deleteMessages(queueUrl, receivedMessages); + assertEquals(receivedMessages.size(), response.successful().size()); + logger.info("Successfully deleted {} messages", response.successful().size()); + } + + @Test + void testMessageEntry() { + logger.info("Testing MessageEntry with attributes"); + Map attributes = Map.of( + "test", MessageAttributeValue.builder() + .stringValue("value") + .dataType("String") + .build() + ); + + SendRecvBatch.MessageEntry entry = new SendRecvBatch.MessageEntry("Test body", attributes); + + assertEquals("Test body", entry.getBody()); + assertEquals(attributes, entry.getAttributes()); + logger.info("MessageEntry test passed with body: {}", entry.getBody()); + } + + @Test + void testMessageEntryWithNullAttributes() { + logger.info("Testing MessageEntry with null attributes"); + SendRecvBatch.MessageEntry entry = new SendRecvBatch.MessageEntry("Test body", null); + + assertEquals("Test body", entry.getBody()); + assertNotNull(entry.getAttributes()); + assertTrue(entry.getAttributes().isEmpty()); + logger.info("MessageEntry null attributes test passed"); + } +} From 084a6c2557e3449d9c647ffe6db43ea3bbef5a9a Mon Sep 17 00:00:00 2001 From: Tejas Ganesh Naik <“tejasgn@amazon.com”> Date: Tue, 1 Jul 2025 15:14:22 -0700 Subject: [PATCH 2/4] updating README with correct link --- .doc_gen/metadata/sqs_metadata.yaml | 2 +- javav2/example_code/sqs/README.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.doc_gen/metadata/sqs_metadata.yaml b/.doc_gen/metadata/sqs_metadata.yaml index a056463e42b..304c14bd093 100644 --- a/.doc_gen/metadata/sqs_metadata.yaml +++ b/.doc_gen/metadata/sqs_metadata.yaml @@ -875,7 +875,7 @@ sqs_Scenario_SendReceiveBatch: excerpts: - description: Create functions to wrap &SQS; message functions and use them to send and receive messages in batches. snippet_tags: - - sqs.java2.sendRecvBatch.main + - sqs.java2.sendRecvBatch.main services: sqs: {CreateQueue, DeleteQueue, SendMessageBatch, ReceiveMessage, DeleteMessageBatch} sqs_GetQueueAttributes: diff --git a/javav2/example_code/sqs/README.md b/javav2/example_code/sqs/README.md index 4a07b3cd4e2..24e6e2a326a 100644 --- a/javav2/example_code/sqs/README.md +++ b/javav2/example_code/sqs/README.md @@ -59,7 +59,7 @@ functions within the same service. - [Publish messages to queues](../../usecases/topics_and_queues/src/main/java/com/example/sns/SNSWorkflow.java) - [Use the Amazon SQS Java Messaging Library to work with the JMS interface](../sqs-jms/src/main/java/com/example/sqs/jms/stdqueue/TextMessageSender.java) - [Work with queue tags](src/main/java/com/example/sqs/TagExamples.java) -- [Send and receive batches of messages](src/main/java/com/example/sqs/TagExamples.java) +- [Send and receive batches of messages](src/main/java/com/example/sqs/SendRecvBatch.java) From 98fbb08cb7b017aa8768f9b37bcf341091bb95d4 Mon Sep 17 00:00:00 2001 From: Tejas Ganesh Naik <“tejasgn@amazon.com”> Date: Thu, 3 Jul 2025 16:16:31 -0700 Subject: [PATCH 3/4] added necessary testing annotations and added periods on comments --- .../main/java/com/example/sqs/SendRecvBatch.java | 14 +++++++------- .../java/com/example/sqs/SendRecvBatchTest.java | 11 +++++++++++ 2 files changed, 18 insertions(+), 7 deletions(-) diff --git a/javav2/example_code/sqs/src/main/java/com/example/sqs/SendRecvBatch.java b/javav2/example_code/sqs/src/main/java/com/example/sqs/SendRecvBatch.java index 8628189e410..346fa2ff0ce 100644 --- a/javav2/example_code/sqs/src/main/java/com/example/sqs/SendRecvBatch.java +++ b/javav2/example_code/sqs/src/main/java/com/example/sqs/SendRecvBatch.java @@ -220,7 +220,7 @@ public static void usageDemo() { System.out.println("Welcome to the Amazon Simple Queue Service (Amazon SQS) demo!"); System.out.println("-".repeat(88)); - // Create a queue for the demo + // Create a queue for the demo. String queueName = "sqs-usage-demo-message-wrapper-"+System.currentTimeMillis(); CreateQueueRequest createRequest = CreateQueueRequest.builder() .queueName(queueName) @@ -229,13 +229,13 @@ public static void usageDemo() { System.out.println("Created queue: " + queueUrl); try { - // Read the lines from this Java file + // Read the lines from this Java file. Path projectRoot = Paths.get(System.getProperty("user.dir")); Path filePath = projectRoot.resolve("src/main/java/com/example/sqs/SendRecvBatch.java"); List lines = Files.readAllLines(filePath); - // Send file lines in batches + // Send file lines in batches. int batchSize = 10; System.out.println("Sending file lines in batches of " + batchSize + " as messages."); @@ -245,7 +245,7 @@ public static void usageDemo() { for (int j = i; j < Math.min(i + batchSize, lines.size()); j++) { String line = lines.get(j); if (line == null || line.trim().isEmpty()) { - continue; // Skip empty lines + continue; // Skip empty lines. } Map attributes = new HashMap<>(); @@ -268,7 +268,7 @@ public static void usageDemo() { System.out.println("\nDone. Sent " + lines.size() + " messages."); - // Receive and process messages + // Receive and process messages. System.out.println("Receiving, handling, and deleting messages in batches of " + batchSize + "."); String[] receivedLines = new String[lines.size()]; boolean moreMessages = true; @@ -292,7 +292,7 @@ public static void usageDemo() { System.out.println("\nDone."); - // Verify all lines were received correctly + // Verify all lines were received correctly. boolean allLinesMatch = true; for (int i = 0; i < lines.size(); i++) { String originalLine = lines.get(i); @@ -313,7 +313,7 @@ public static void usageDemo() { } catch (IOException e) { logger.log(Level.SEVERE, "Error reading file", e); } finally { - // Clean up by deleting the queue + // Clean up by deleting the queue. DeleteQueueRequest deleteQueueRequest = DeleteQueueRequest.builder() .queueUrl(queueUrl) .build(); diff --git a/javav2/example_code/sqs/src/test/java/com/example/sqs/SendRecvBatchTest.java b/javav2/example_code/sqs/src/test/java/com/example/sqs/SendRecvBatchTest.java index 7bb6e4de3d1..e62e7d73053 100644 --- a/javav2/example_code/sqs/src/test/java/com/example/sqs/SendRecvBatchTest.java +++ b/javav2/example_code/sqs/src/test/java/com/example/sqs/SendRecvBatchTest.java @@ -18,7 +18,13 @@ import java.util.stream.Stream; import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.api.TestMethodOrder; +import org.junit.jupiter.api.MethodOrderer; +import org.junit.jupiter.api.Order; +@TestInstance(TestInstance.Lifecycle.PER_CLASS) +@TestMethodOrder(MethodOrderer.OrderAnnotation.class) public class SendRecvBatchTest { private static final Logger logger = LoggerFactory.getLogger(SendRecvBatchTest.class); private static final SqsClient sqsClient = SqsClient.create(); @@ -56,6 +62,7 @@ private static Stream sendMessageBatchTestData() { @ParameterizedTest @MethodSource("sendMessageBatchTestData") + @Order(1) void testSendMessages(List messages) { logger.info("Testing send messages with {} messages", messages.size()); SendMessageBatchResponse response = SendRecvBatch.sendMessages(queueUrl, messages); @@ -64,6 +71,7 @@ void testSendMessages(List messages) { } @Test + @Order(2) void testReceiveMessages() { logger.info("Testing receive messages"); // First send some messages @@ -80,6 +88,7 @@ void testReceiveMessages() { } @Test + @Order(3) void testDeleteMessages() { logger.info("Testing delete messages"); // First send and receive messages @@ -99,6 +108,7 @@ void testDeleteMessages() { } @Test + @Order(4) void testMessageEntry() { logger.info("Testing MessageEntry with attributes"); Map attributes = Map.of( @@ -116,6 +126,7 @@ void testMessageEntry() { } @Test + @Order(5) void testMessageEntryWithNullAttributes() { logger.info("Testing MessageEntry with null attributes"); SendRecvBatch.MessageEntry entry = new SendRecvBatch.MessageEntry("Test body", null); From 221b84cf5575d73dee78e1b0f1b453e5f68432f0 Mon Sep 17 00:00:00 2001 From: Tejas Ganesh Naik <“tejasgn@amazon.com”> Date: Tue, 8 Jul 2025 16:30:45 -0700 Subject: [PATCH 4/4] updated logging framework and removed region --- .../java/com/example/sqs/SendRecvBatch.java | 43 +++++++++++-------- 1 file changed, 24 insertions(+), 19 deletions(-) diff --git a/javav2/example_code/sqs/src/main/java/com/example/sqs/SendRecvBatch.java b/javav2/example_code/sqs/src/main/java/com/example/sqs/SendRecvBatch.java index 346fa2ff0ce..55479728717 100644 --- a/javav2/example_code/sqs/src/main/java/com/example/sqs/SendRecvBatch.java +++ b/javav2/example_code/sqs/src/main/java/com/example/sqs/SendRecvBatch.java @@ -17,8 +17,9 @@ import java.util.HashMap; import java.util.List; import java.util.Map; -import java.util.logging.Level; -import java.util.logging.Logger; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; // snippet-end:[sqs.java2.sendRecvBatch.import] @@ -36,13 +37,10 @@ */ public class SendRecvBatch { - private static final Logger logger = Logger.getLogger(SendRecvBatch.class.getName()); - static { - Logger rootLogger = Logger.getLogger(""); - rootLogger.setLevel(Level.WARNING); - } + + private static final Logger logger = LoggerFactory.getLogger(SendRecvBatch.class); + private static final SqsClient sqsClient = SqsClient.builder() - .region(Region.US_WEST_2) .build(); // snippet-start:[sqs.java2.sendRecvBatch.sendBatch] @@ -79,15 +77,16 @@ public static SendMessageBatchResponse sendMessages( SendMessageBatchResponse response = sqsClient.sendMessageBatch(sendBatchRequest); if (!response.successful().isEmpty()) { + int successCount = 0; for (SendMessageBatchResultEntry resultEntry : response.successful()) { - logger.info("Message sent: " + resultEntry.messageId() + ": " + - messages.get(Integer.parseInt(resultEntry.id())).getBody()); + successCount++; } + logger.info("Successfully sent " + successCount + " messages to queue: " + queueUrl); } if (!response.failed().isEmpty()) { for (BatchResultErrorEntry errorEntry : response.failed()) { - logger.warning("Failed to send: " + errorEntry.id() + ": " + + logger.warn("Failed to send: " + errorEntry.id() + ": " + messages.get(Integer.parseInt(errorEntry.id())).getBody()); } } @@ -95,7 +94,7 @@ public static SendMessageBatchResponse sendMessages( return response; } catch (SqsException e) { - logger.log(Level.SEVERE, "Send messages failed to queue: " + queueUrl, e); + logger.error("Send messages failed to queue: " + queueUrl, e); throw e; } } @@ -125,14 +124,18 @@ public static List receiveMessages(String queueUrl, int maxNumber, int List messages = sqsClient.receiveMessage(receiveRequest).messages(); + int receivedCount = 0; for (Message message : messages) { - logger.info("Received message: " + message.messageId() + ": " + message.body()); + receivedCount++; } + if (receivedCount > 0) { + logger.info("Received " + receivedCount + " messages from queue: " + queueUrl); + } return messages; } catch (SqsException e) { - logger.log(Level.SEVERE, "Couldn't receive messages from queue: " + queueUrl, e); + logger.error("Couldn't receive messages from queue: " + queueUrl, e); throw e; } } @@ -166,21 +169,23 @@ public static DeleteMessageBatchResponse deleteMessages(String queueUrl, List