如何通过注解配置Spring Cloud AWS消息及XML配置？自定义taskExecutor

Hey there! Let's walk through how to set up Spring Cloud AWS messaging using annotations, handle XML-based configuration, and most importantly, tweak the default task executor. I've tackled these scenarios before, so I'll share practical examples to make this clear.

1. Annotation-Based Configuration for Spring Cloud AWS Messaging #

First, make sure you have the right dependency in your pom.xml (if using Maven) or build.gradle:

<!-- Maven -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-aws-messaging</artifactId>
</dependency>

Step 1: Basic AWS Setup #

You can configure AWS credentials and region either via application.properties or a configuration class:

# application.properties
cloud.aws.region.static=us-east-1
cloud.aws.credentials.access-key=YOUR_ACCESS_KEY
cloud.aws.credentials.secret-key=YOUR_SECRET_KEY

Or with a @Configuration class:

import org.springframework.cloud.aws.context.annotation.EnableAws;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableAws
public class AwsConfig {
    // Credentials and region can also be configured here via beans if needed
}

Step 2: SQS Messaging with Annotations #

Enable SQS support with @EnableSqs, then use @SqsListener to listen to queues, and AmazonSqsAsync or @SendTo to send messages:

import org.springframework.cloud.aws.messaging.config.annotation.EnableSqs;
import org.springframework.cloud.aws.messaging.core.QueueMessagingTemplate;
import org.springframework.cloud.aws.messaging.listener.annotation.SqsListener;
import org.springframework.stereotype.Component;

@Configuration
@EnableSqs
public class SqsConfig {
    // QueueMessagingTemplate for sending messages
    @Bean
    public QueueMessagingTemplate queueMessagingTemplate(AmazonSqsAsync amazonSqs) {
        return new QueueMessagingTemplate(amazonSqs);
    }
}

@Component
public class SqsMessageListener {
    // Listen to a specific SQS queue
    @SqsListener("my-queue-name")
    public void handleMessage(String message) {
        System.out.println("Received message: " + message);
    }
}

To send messages, inject QueueMessagingTemplate:

@Autowired
private QueueMessagingTemplate queueMessagingTemplate;

public void sendMessage(String message) {
    queueMessagingTemplate.convertAndSend("my-queue-name", message);
}

2. XML Configuration for Spring Cloud AWS #

If you're working with a legacy setup that uses XML, here's how to configure it:

First, add the necessary namespaces to your XML config:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aws="http://www.springframework.org/schema/cloud/aws"
       xmlns:aws-messaging="http://www.springframework.org/schema/cloud/aws/messaging"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           https://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/cloud/aws
           https://www.springframework.org/schema/cloud/aws/spring-cloud-aws.xsd
           http://www.springframework.org/schema/cloud/aws/messaging
           https://www.springframework.org/schema/cloud/aws/spring-cloud-aws-messaging.xsd">

Configure AWS Credentials and Region #

<aws:context region="us-east-1">
    <aws:credentials access-key="YOUR_ACCESS_KEY" secret-key="YOUR_SECRET_KEY"/>
</aws:context>

Configure SQS Listener and Sender #

<!-- AmazonSQS client bean -->
<aws:sqs-client id="amazonSqs" region="us-east-1"/>

<!-- Queue messaging template for sending messages -->
<bean id="queueMessagingTemplate" class="org.springframework.cloud.aws.messaging.core.QueueMessagingTemplate">
    <constructor-arg ref="amazonSqs"/>
</bean>

<!-- Message listener container -->
<aws-messaging:message-listener-container queue="my-queue-name" message-handler="sqsMessageListener">
    <!-- We'll customize task executor here later -->
</aws-messaging:message-listener-container>

<!-- Listener bean -->
<bean id="sqsMessageListener" class="com.example.SqsMessageListener"/>

3. Customizing the Default TaskExecutor #

By default, Spring Cloud AWS uses SimpleAsyncTaskExecutor for message processing, which isn't ideal for production (it creates a new thread for each task). Let's replace it with a ThreadPoolTaskExecutor for better control.

Annotation-Based Approach #

Create a custom TaskExecutor bean and configure the SimpleMessageListenerContainerFactory to use it:

import org.springframework.cloud.aws.messaging.config.SimpleMessageListenerContainerFactory;
import org.springframework.cloud.aws.messaging.config.annotation.EnableSqs;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@Configuration
@EnableSqs
public class AwsSqsConfig {

    // Custom ThreadPoolTaskExecutor
    @Bean
    public ThreadPoolTaskExecutor sqsTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5); // Minimum threads kept alive
        executor.setMaxPoolSize(10); // Maximum threads allowed
        executor.setQueueCapacity(20); // Queue size for pending tasks
        executor.setThreadNamePrefix("sqs-worker-");
        executor.initialize();
        return executor;
    }

    // Configure listener factory to use our custom executor
    @Bean
    public SimpleMessageListenerContainerFactory simpleMessageListenerContainerFactory(AmazonSqsAsync amazonSqs, ThreadPoolTaskExecutor sqsTaskExecutor) {
        SimpleMessageListenerContainerFactory factory = new SimpleMessageListenerContainerFactory();
        factory.setAmazonSqs(amazonSqs);
        factory.setTaskExecutor(sqsTaskExecutor); // Set our custom executor
        return factory;
    }
}

Now all @SqsListener methods will use your custom thread pool instead of the default.

XML-Based Approach #

Define the custom TaskExecutor bean and reference it in the message listener container:

<!-- Custom ThreadPoolTaskExecutor -->
<bean id="sqsTaskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
    <property name="corePoolSize" value="5"/>
    <property name="maxPoolSize" value="10"/>
    <property name="queueCapacity" value="20"/>
    <property name="threadNamePrefix" value="sqs-worker-"/>
</bean>

<!-- Message listener container using custom executor -->
<aws-messaging:message-listener-container queue="my-queue-name" 
                                          message-handler="sqsMessageListener"
                                          task-executor="sqsTaskExecutor">
</aws-messaging:message-listener-container>

That's it! This replaces the default executor with a managed thread pool that's more suitable for production workloads.

内容的提问来源于stack exchange，提问作者luboskrnac