Integrating SQS with Spring Boot : Quick Start

What is Amazon SQS?

• Amazon SQS(Simple Queue Service) is a fully managed message queuing service that allows us to communicate asynchronously between the different components of our application.
• We can send, store, and receive messages between software components. It can handle any amount of data, dynamically scaling to match the throughput of our application.
• Using SQS, we pay only for what you use. There are no upfront costs or minimum fees, and we are charged based on the number of requests and the amount of data transferred.

How SQS works?

Simple Queue Service basically involves three main components: producers, consumers, and queue

• Producers: These are the components that send messages to the queue. This can be any part of your application that needs to communicate with another component.
• Queues: The queue is the temporary storage for messages. Producers send messages to the queue, where they are stored until they are processed by consumers.
• Consumers: These are the components that receive and process messages from the queue. Consumers check the queue for new messages and process them as they become available.

Integrating Simple Queue Service with Spring Boot

 1. Creating an SQS Queue :

Firstly, we need to create a queue by logging in to the AWS Management Console configure the queue settings there and create the queue.

2. Setting up Spring Boot project :

Create a new Spring Boot project using IDE or Spring Initializr and then add the necessary dependencies to the project

Using Gradle:

dependencies {
implementation 'org.springframework:spring-messaging:5.3.27'
implementation 'software.amazon.awssdk:sqs:2.26.8'
implementation 'io.awspring.cloud:spring-cloud-aws-starter-sqs'
}

 3. Add Configuration of your AWS Credentials:

Ensure your AWS credentials are configured. Add your credentials in application.properties or use the AWS CLI configuration.

aws.access.key.id=your-access-key
aws.secret.access.key=your-secret-key
aws.region=your-region

4. Create Configuration Class :

Create a configuration class to set up the SQS client and the queue.

@Configuration
public class SQSConfig {

@Bean
public SqsClient createSqsClient() {
return SqsClient.builder()
.credentialsProvider(DefaultCredentialsProvider.create())
.region(Region.of("your_region"))
.build();
}
}

5. Send Messages to SQS

Create a service class to send messages to the SQS queue.

@Service
public class SqsService {

private final String queueUrl; (// Specify your queue URL in the config file)

public void sendMessageToQueue(String messageBody) {
log.info("Sending msg to SQS queue");
try {
SqsClient sqsClient = sqsConfig.createSqsClient();
String jsonMessage;
try {
jsonMessage = objectMapper.writeValueAsString(messageBody);
} catch (JsonProcessingException e) {
log.error("Error converting message to JSON: {}", e.getMessage());
return;
}
SendMessageRequest sendMessageRequest = SendMessageRequest.builder()
.queueUrl(queueUrl)
.messageBody(jsonMessage)
.build();
sqsClient.sendMessage(sendMessageRequest);
log.info("Message sent to SQS queue");
} catch (Exception e) {
log.error("Error sending message to SQS queue: {}", e.getMessage());
}
}
}

6. Receive Messages from SQS:

Create a service class to receive messages from the SQS queue.

@Component("sqsConsumer")
@RequiredArgsConstructor
public class SQSConsumer {

@SqsListener("your_queue_name")
public void consumeQueueMessages(String message) {
log.info("Received message from SQS queue: {}", message);
processMessage(message);
}

private void processMessage(String messageBody) {
try {
log.info("Started processing queue message.");
// You can specify your logic for processing the message according to requirements
} catch (Exception e) {
log.error("Error processing message from SQS queue: {}", e.getMessage(), e);
}
}
}

7. Application Properties

You can add the queue URL to your application.properties or application.yml file

sqs.queue.url="your_queue_url"

Amazon SQS vs. Other Messaging Systems: Quick Reference

• Polling and Long Polling : Amazon SQS uses a polling model to retrieve messages. By default, it uses short polling, which returns immediately even if no messages are available. This reduces the number of empty responses and helps lower costs by reducing the number of requests made to SQS, on the other hand, RabbitMQ and Kafka require management of the broker, clustering, and scaling.
• Message Delivery : SQS provides at least-once delivery for Standard queues and exactly once delivery for FIFO queues. while Kafka supports both at-least-once and exactly-once delivery semantics depending on the configuration.
• Scalability : SQS scales automatically with the volume of messages, while RabbitMQ and Kafka require manual scaling to add nodes or configure clusters.
• Durability : In SQS messages are stored across multiple AWS Availability Zones, while in  RabbitMQ and Kafka messages and queues can be configured to be durable to withstand broker failures.

Conclusion

By following the above steps, you can effectively integrate SQS with your Spring Boot application, enabling reliable and scalable messaging capabilities. Also, ensure that messages are deleted from the queue after successful processing. Moreover, you can implement proper error handling for message processing and retries.