Integrating Amazon SQS with Spring Boot In 2024

What is Amazon SQS?

Amazon Simple Queue Service (SQS) is a fully managed message queuing service offered by AWS. It is designed to enable decoupling of distributed systems, microservices, and serverless applications by allowing messages to be sent, stored, and received between different components without requiring direct dependencies or real-time interactions. With SQS, you can improve the scalability and fault tolerance of your application by ensuring that messages are not lost and can be processed independently by various parts of your application.

Types of Amazon SQS Queues

1. Standard Queues

Standard queues provide high throughput, with almost unlimited transactions per second, and are suitable for most applications where exact message order and duplicate messages are not critical. Key characteristics include:

• At-Least-Once Delivery: Messages are guaranteed to be delivered at least once but might be delivered more than once, resulting in possible duplicates.
• Best-Effort Ordering: While standard queues try to deliver messages in the order they were sent, they do not guarantee strict message ordering.
• Unlimited Throughput: You can process a virtually unlimited number of messages per second in a standard queue.

2. FIFO (First-In-First-Out) Queues

FIFO queues are designed for applications where the exact order of messages is critical and where each message must be processed only once. These queues are useful for processing transactions or other workflows that require strict ordering. Key characteristics include:

• Exactly-Once Processing: Ensures that each message is delivered and processed only once, avoiding duplicates.
• Guaranteed Order: Messages are strictly ordered according to their arrival in the queue.
• Limited Throughput: FIFO queues have a limited throughput of 3,000 messages per second with batching or 300 messages per second without batching.

How to Connect to Amazon SQS in Spring Boot

Connecting to SQS from a Spring Boot application involves configuring the AWS SDK and then creating a service to send messages to the queue. Let’s go through the process step-by-step.

Step 1: Add the AWS SDK for SQS to Your Project

In your Spring Boot project, you’ll need to include the AWS SDK for SQS. If you’re using Maven, add the following dependency to your pom.xml

<dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>sqs</artifactId>
    <version>2.20.0</version>
</dependency>

For Gradle, add the dependency in build.gradle:

implementation 'software.amazon.awssdk:sqs:2.20.0'

Step 2: Configure AWS Credentials

The AWS SDK for Java will automatically use the default credentials provider chain, which will check for credentials in this order:

1. Environment variables (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY).
2. Java system properties (aws.accessKeyId, aws.secretAccessKey).
3. The AWS credentials file (~/.aws/credentials on Linux or macOS, or C:\Users\USER_NAME\.aws\credentials on Windows).
4. The Amazon ECS container credentials or the instance profile credentials on Amazon EC2.

Alternatively, you can set up the AWS CLI and configure credentials by running aws configure in your terminal.

Step 3: Create a Bean for the SQS Client

In your Spring Boot application, create a configuration class to initialize the SqsClient bean. This client will handle interactions with SQS.

import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.regions.Region;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AwsSqsConfig {

    @Bean
    public SqsClient sqsClient() {
        return SqsClient.builder()
                        .region(Region.US_EAST_1) // Set your preferred region
                        .build();
    }
}

Here, replace Region.US_EAST_1 with your AWS region. You can use the Region enum to specify any supported AWS region.

Step 4: Create a Service to Send Messages to SQS

Now, create a service class that uses the SqsClient to send messages to a specific queue.

import software.amazon.awssdk.services.sqs.SqsClient;
import software.amazon.awssdk.services.sqs.model.SendMessageRequest;
import software.amazon.awssdk.services.sqs.model.SendMessageResponse;
import org.springframework.stereotype.Service;

@Service
public class SqsMessageService {

    private final SqsClient sqsClient;

    public SqsMessageService(SqsClient sqsClient) {
        this.sqsClient = sqsClient;
    }

    public void sendMessage(String queueUrl, String messageBody) {
        SendMessageRequest sendMsgRequest = SendMessageRequest.builder()
                                                              .queueUrl(queueUrl)
                                                              .messageBody(messageBody)
                                                              .build();
        SendMessageResponse response = sqsClient.sendMessage(sendMsgRequest);
        System.out.println("Message sent with ID: " + response.messageId());
    }
}

• The sendMessage method takes the SQS queue URL and the message body as parameters.
• The sendMessage method constructs a SendMessageRequest object, specifying the queue URL and message content.
• The SendMessageResponse object provides details about the message, including its ID, which can be useful for tracking purposes.

Step 5: Use the Service to Send Messages

Now, you can autowire the SqsMessageService in your Spring Boot application and call the sendMessage method to push messages to your SQS queue:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SqsController {

    @Autowired
    private SqsMessageService sqsMessageService;

    @GetMapping("/send")
    public String sendMessage() {
        String queueUrl = "https://sqs.us-east-1.amazonaws.com/123456789012/my-queue";
        sqsMessageService.sendMessage(queueUrl, "Hello, SQS!");
        return "Message sent to SQS";
    }
}

• Replace the queueUrl variable with the actual URL of your SQS queue.
• The @GetMapping endpoint triggers the message sending when accessed.

Conclusion

Integrating Amazon SQS with Spring Boot is a powerful way to build scalable and reliable distributed systems. By using SQS, you can decouple components, handle asynchronous messaging, and improve the resilience of your application. With just a few steps—adding the AWS SDK, configuring credentials, and setting up a service to send messages—you can quickly start leveraging SQS in your Spring Boot applications.

Whether you’re handling event-driven processing, task queuing, or communication between microservices, SQS provides the flexibility and reliability needed to support a wide range of use cases. By following the steps in this guide, you’re well on your way to building a robust messaging system that can scale with your application.

Get to know more about Amazon SQS here.

Explore our diverse collection of blogs covering a wide range of topics here.