or run

npx @tessl/cli init

Version

Tile

Overview

Evals

Files

docs

configuration-properties.md connection-configuration.md error-handling.md index.md listener-configuration.md message-operations.md queue-exchange-management.md stream-processing.md

tile.json

tessl/maven-spring-boot-starter-amqp

Spring Boot starter for AMQP messaging with RabbitMQ auto-configuration, message templates, and annotation-driven listeners

Workspace: tessl
Visibility: Public
Created: 3 months ago
Last updated: 3 months ago
Describes: pkg:maven/org.springframework.boot/spring-boot-starter-amqp@2.7.x

To install, run

npx @tessl/cli install tessl/maven-spring-boot-starter-amqp@2.7.0

Spring Boot AMQP Starter

Spring Boot starter that provides AMQP messaging capabilities with RabbitMQ integration, including auto-configuration for connection factories, message templates, annotation-driven listeners, and comprehensive configuration options.

Package Information

Package Name: spring-boot-starter-amqp
Package Type: maven
Language: Java
Installation: Add to Maven <dependencies> or Gradle dependencies

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

implementation 'org.springframework.boot:spring-boot-starter-amqp'

Core Imports

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.Exchange;
import org.springframework.amqp.core.Binding;
import org.springframework.boot.autoconfigure.amqp.RabbitProperties;
import org.springframework.boot.autoconfigure.amqp.ConnectionFactoryCustomizer;
import org.springframework.boot.autoconfigure.amqp.RabbitRetryTemplateCustomizer;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.config.DirectRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.rabbit.stream.config.StreamRabbitListenerContainerFactory;
import org.springframework.rabbit.stream.producer.RabbitStreamTemplate;
import org.springframework.rabbit.stream.support.StreamAdmin;

Basic Usage

Simple Message Publishing and Consuming

@Component
public class MessageReceiver {
    
    @RabbitListener(queues = "hello")
    public void receive(String message) {
        System.out.println("Received: " + message);
    }
}

@Service
public class MessageSender {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public void send(String message) {
        rabbitTemplate.convertAndSend("hello", message);
    }
}

Queue and Exchange Declaration

@Configuration
public class RabbitConfig {
    
    @Bean
    public Queue hello() {
        return new Queue("hello");
    }
    
    @Bean
    public TopicExchange exchange() {
        return new TopicExchange("topic-exchange");
    }
    
    @Bean
    public Binding binding(Queue queue, TopicExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("routing.key");
    }
}

Stream Processing (High Throughput)

@Configuration
@EnableRabbitStreaming
public class StreamConfig {
    
    @Bean
    public RabbitStreamTemplate streamTemplate(Environment env) {
        return new RabbitStreamTemplate(env, "my-stream");
    }
}

@Service
public class StreamService {
    
    @Autowired
    private RabbitStreamTemplate streamTemplate;
    
    public void publishToStream(String message) {
        streamTemplate.convertAndSend(message);
    }
    
    @RabbitStreamListener(id = "stream-listener", queues = "my-stream")
    public void handleStreamMessage(String message) {
        System.out.println("Stream message: " + message);
    }
}

Architecture

The Spring Boot AMQP starter provides several key components that work together:

Auto-Configuration: Automatically configures RabbitMQ connections, templates, and listeners via RabbitAutoConfiguration, RabbitAnnotationDrivenConfiguration, and RabbitStreamConfiguration
Connection Management: Provides caching connection factories with connection pooling and customization through ConnectionFactoryCustomizer
Message Templates: RabbitTemplate and RabbitMessagingTemplate for message operations, with RabbitTemplateConfigurer for customization
Listener Containers: Support for Simple, Direct, and Stream message listener containers with dedicated factory configurers
Stream Support: Native RabbitMQ Streams integration for high-throughput scenarios with RabbitStreamTemplate and stream-specific listeners
Configuration Properties: Comprehensive configuration through spring.rabbitmq.* properties via RabbitProperties
Admin Operations: RabbitAdmin for queue, exchange, and binding management
Retry and Error Handling: Built-in retry mechanisms with RabbitRetryTemplateCustomizer and comprehensive error handling strategies

Capabilities

Message Template Operations

Core messaging operations using RabbitTemplate and RabbitMessagingTemplate for publishing and consuming messages.

@Service
public class MessagingService {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public void sendMessage(String routingKey, Object message) {
        rabbitTemplate.convertAndSend(routingKey, message);
    }
    
    public <T> T receiveMessage(String queueName, Class<T> type) {
        return rabbitTemplate.receiveAndConvert(queueName, type);
    }
}

Message Operations

Annotation-Driven Listeners

Configuration and usage of @RabbitListener annotation for creating message consumers with various listener container types.

@Component
public class MessageListeners {
    
    @RabbitListener(queues = "user.registration")
    public void handleUserRegistration(UserRegistrationEvent event) {
        // Process registration event
    }
    
    @RabbitListener(bindings = @QueueBinding(
        value = @Queue(value = "order.processed"),
        exchange = @Exchange(value = "orders", type = ExchangeTypes.TOPIC),
        key = "order.processed.*"
    ))
    public void handleOrderProcessed(OrderProcessedEvent event) {
        // Process order event
    }
}

Listener Configuration

Connection and Connection Factory Configuration

Auto-configuration and customization of RabbitMQ connection factories, including connection pooling, SSL, and clustering support.

@Configuration
public class ConnectionConfig {
    
    @Bean
    public ConnectionFactoryCustomizer connectionFactoryCustomizer() {
        return (connectionFactory) -> {
            connectionFactory.setRequestedHeartbeat(60);
            connectionFactory.setConnectionTimeout(30000);
        };
    }
    
    @Bean
    public CachingConnectionFactory connectionFactory() {
        CachingConnectionFactory factory = new CachingConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        return factory;
    }
}

Connection Configuration

Queue, Exchange, and Binding Management

Administrative operations for managing RabbitMQ topology using RabbitAdmin and declarative configuration.

@Configuration
public class TopologyConfig {
    
    @Bean
    public Queue userQueue() {
        return QueueBuilder.durable("user.events").build();
    }
    
    @Bean
    public DirectExchange userExchange() {
        return ExchangeBuilder.directExchange("user.exchange").build();
    }
    
    @Bean
    public Binding userBinding(Queue userQueue, DirectExchange userExchange) {
        return BindingBuilder.bind(userQueue).to(userExchange).with("user.created");
    }
}

Queue and Exchange Management

Configuration Properties

Comprehensive configuration options available through application properties for all aspects of AMQP messaging.

spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    connection-timeout: 60000ms
    publisher-confirm-type: correlated
    publisher-returns: true
    listener:
      simple:
        concurrency: 1
        max-concurrency: 3
        prefetch: 1
    template:
      retry:
        enabled: true
        initial-interval: 2s
        max-attempts: 3

Configuration Properties

Error Handling and Retry Mechanisms

Configuration of retry policies, error handlers, and dead letter queue processing for robust message handling.

@Configuration
public class ErrorHandlingConfig {
    
    @Bean
    public RabbitRetryTemplateCustomizer retryCustomizer() {
        return (Target target, RetryTemplate template) -> {
            template.setRetryPolicy(new SimpleRetryPolicy(3));
            template.setBackOffPolicy(new ExponentialBackOffPolicy());
        };
    }
    
    @Bean
    public MessageRecoverer messageRecoverer() {
        return new RejectAndDontRequeueRecoverer();
    }
}

Error Handling

Stream Processing Support

Configuration and usage of RabbitMQ Streams for high-throughput message processing scenarios.

@Configuration
@EnableRabbitStreaming
public class StreamConfig {
    
    @Bean
    public RabbitStreamTemplate streamTemplate(Environment env) {
        return new RabbitStreamTemplate(env, "my-stream");
    }
    
    @RabbitStreamListener(id = "stream-listener", queues = "my-stream")
    public void handleStreamMessage(String message) {
        // Process stream message
    }
}

Stream Processing

Auto-Configuration Classes

The Spring Boot AMQP starter provides comprehensive auto-configuration through several key classes:

// Main AMQP auto-configuration
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ RabbitTemplate.class, Channel.class })
@EnableConfigurationProperties(RabbitProperties.class)
public class RabbitAutoConfiguration {
    // Configures CachingConnectionFactory, RabbitTemplate, RabbitMessagingTemplate, and AmqpAdmin
}

// Annotation-driven listener configuration  
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(EnableRabbit.class)
public class RabbitAnnotationDrivenConfiguration {
    // Configures SimpleRabbitListenerContainerFactory and DirectRabbitListenerContainerFactory
    // Enables @RabbitListener annotation processing
}

// Stream support configuration
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(StreamRabbitListenerContainerFactory.class)
public class RabbitStreamConfiguration {
    // Configures StreamRabbitListenerContainerFactory, Environment, and RabbitStreamTemplate
}

These auto-configuration classes work together to provide zero-configuration setup while allowing full customization through properties and component beans.

Version

Tile

Files

tessl/maven-spring-boot-starter-amqp

To install, run

index.md.css-3qkkll{font-size:var(--chakra-font-sizes-sm);font-weight:var(--chakra-font-weights-normal);color:var(--chakra-colors-gray-300);}docs/

Spring Boot AMQP Starter

Package Information

Core Imports

Basic Usage

Simple Message Publishing and Consuming

Queue and Exchange Declaration

Stream Processing (High Throughput)

Architecture

Capabilities

Message Template Operations

Annotation-Driven Listeners

Connection and Connection Factory Configuration

Queue, Exchange, and Binding Management

Configuration Properties

Error Handling and Retry Mechanisms

Stream Processing Support

Auto-Configuration Classes

index.mddocs/