All Classes and Interfaces
Class
Description
Stage responsible for executing the
AsyncMessageInterceptors after message processing.Stage responsible for executing the
AsyncMessageInterceptors before message processing.Base implementation for
ContainerOptions.AbstractContainerOptions.Builder<B extends ContainerOptionsBuilder<B,O>,O extends ContainerOptions<O,B>>
MessageProcessingPipelineSink implementation that delegates method invocations to the provided delegate.Base class for implementing a
HandlerMethodEndpoint.BeanPostProcessor implementation that scans beans for a @SqsListener annotation, extracts
information to a SqsEndpoint, and registers it in the EndpointRegistrar.Observation for Message Listener Containers.
ReceiverContext for message listeners.ObservationConvention for message listener key values.ObservationDocumentation for message listener keys.High cardinality tags.
Low cardinality tags.
Observation-related instances that are specific to a messaging system.
A
MessageSource implementation capable of converting messages from a Source type to a Target type.AbstractMessageListenerContainer<T,O extends ContainerOptions<O,B>,B extends ContainerOptionsBuilder<B,O>>
Base implementation for
MessageListenerContainer with SmartLifecycle and component management
capabilities.AbstractMessageListenerContainerFactory<T,C extends MessageListenerContainer<T>,O extends ContainerOptions<O,B>,B extends ContainerOptionsBuilder<B,O>>
Base implementation for a
MessageListenerContainerFactory.Base implementation for
MessageProcessingPipelineSink containing SmartLifecycle features and useful
execution methods that can be used by subclasses.Base
MessagingMessageConverter implementation.Base class for
MessagingOperationsBase class for template options, to be extended by subclasses.
Base class for invoking an
InvocableHandlerMethod.Base implementation for a
AcknowledgementProcessor with SmartLifecycle
capabilities.AbstractPipelineMessageListenerContainer<T,O extends ContainerOptions<O,B>,B extends ContainerOptionsBuilder<B,O>>
Base
MessageListenerContainer implementation for managing Message
instances' lifecycles.Base
PollingMessageSource implementation with SmartLifecycle
capabilities.MessageSource implementation for polling messages from a SQS queue and converting them to messaging
Message.Observation for
MessagingOperations.SenderContext for message listeners.AbstractTemplateObservation.Convention for template key values.ObservationDocumentation for template keys.High cardinality tags.
Low cardinality tags.
Contains observation-related instances that are specific to a messaging system.
Interface representing a message acknowledgement.
MessageConversionContext specialization that enables setting an AcknowledgementCallback to be used
when mapping acknowledgement related properties.Interface representing an acknowledgement callback to be executed, usually by a
AcknowledgementHandler implementation.Allows executing acknowledgements for a batch of messages.
Interface for managing acknowledgement in success and failure scenarios.
Stage responsible for executing the
AcknowledgementHandler.Configures the acknowledgement behavior for this container.
Configures the ordering of acknowledgements.
MessageSource specialization that enables processing acknowledgements for the
Message instances through an
AcknowledgementExecutorTop-level interface for a component capable of processing acknowledgements.
Provides actions to be executed after a message acknowledgement completes with either success or failure.
Exception representing a failure to execute a
AcknowledgementResultCallback.HandlerMethodArgumentResolver implementation for resolving Acknowledgement arguments.Stage responsible for executing the
AsyncMessageInterceptor instances from the
MessageProcessingContext after message processing.Stage responsible for executing the
AsyncMessageInterceptors after message processing.AcknowledgementHandler implementation that acknowledges on both success and error. * @author Tomaz FernandesProvides actions to be executed after a message acknowledgement completes with either success or failure.
Exception representing a failure on an execution attempted by a blocking adapter.
Utility class for adapting blocking components to their asynchronous variants.
Base class for BlockingComponentAdapters.
Interface for handling message processing errors async.
Async interface for intercepting messages before and after execution.
Async listener to process individual
Message instances.AsyncMessageListener implementation to handle a message by invoking a method handler.Asynchronous messaging operations.
Constants for Backoff Error Handler.
Abstraction to handle backpressure within a
PollingMessageSource.Utility class for creating
BackPressureHandlerFactory instances used to apply back pressure strategies in SQS
listener containers.Factory interface for creating
BackPressureHandler instances to manage queue consumption backpressure.Configuration for application throughput.
Enables acknowledging messages for
ListenerMode.BATCH.HandlerMethodArgumentResolver implementation for resolving BatchAcknowledgement arguments.BackPressureHandler specialization that allows requesting batches.AcknowledgementProcessor implementation that adds the messages
to a BlockingQueue to be acknowledged according to ContainerOptions.getAcknowledgementInterval() and
ContainerOptions.getAcknowledgementThreshold().An
SqsAsyncClient adapter that provides automatic batching capabilities using AWS SDK's
SqsAsyncBatchManager.MessageSink implementation that emits the whole received batch of messages to the configured
MessageProcessingPipeline.HandlerMethodArgumentResolver implementation for resolving List arguments.BatchVisibility interface that can be injected as parameter into a listener method.
HandlerMethodArgumentResolver for BatchVisibility method parameters.Stage responsible for executing the
AsyncMessageInterceptors from the MessageProcessingContext before
message processing.Stage responsible for executing the
AsyncMessageInterceptors before message processing.Utility methods for using convenient
CompletableFuture methods from later JDK versions in Java 8.Composite
BackPressureHandler implementation that delegates the back-pressure handling to a list of
BackPressureHandlers.A composite of
InvocableHandlerMethod that delegates message handling to a list of registered handlers,
selecting the appropriate one based on the received message payload type.A blocking
BackPressureHandler that limits concurrency using a Semaphore.Representation of a
MessageListenerContainer component that can be configured using a
ContainerOptions instance.Utility class for conditional configurations.
A factory for creating components for the
MessageListenerContainer.Contains the options to be used by the
MessageListenerContainer at runtime.A builder for creating a
ContainerOptions instance.A
HeaderMapper specialization that supports receiving a MessageConversionContext for mapping context
dependent headers.A
MessagingMessageConverter specialization that enables receving a MessageConversionContext that can
be used to add context specific properties to the converted message.MessageListenerContainerRegistry implementation that registers the MessageListenerContainer instances
and manage their lifecycle.Default implementation of
MethodPayloadTypeInferrer that infers the payload type by analyzing method
parameters and their associated argument resolvers.Represents a messaging endpoint from which messages can be consumed by a
MessageListenerContainer.Processes the registered
Endpoint instances using the appropriate MessageListenerContainerFactory.Interface for handling errors.
Stage responsible for executing the
AsyncErrorHandler after a failed
MessageListener execution.Utility methods for Error Handler.
Utilities to handle exceptions.
AcknowledgementProcessor specialization that allows for delegating acknowledgement execution to a
AcknowledgementExecutor.An implementation of an Exponential Backoff error handler for asynchronous message processing.
MessageProcessingPipelineSink implementation that executes messages from the provided batch in parallel.Grouping strategy for Fifo SQS with batch listener mode.
ContainerComponentFactory implementation for creating components for FIFO queues.AbstractSqsMessageSource implementation for FIFO queues.Methods related to FIFO queues.
Non-blocking
BackPressureHandler implementation that ensures the exact batch size is requested.Endpoint specialization that indicates that Message instances coming
from this endpoint will be handled by a HandlerMethod.Mapper interface to map from and to
MessageHeaders and a given source type.Representation of a component that can be assigned an id.
A default error handler implementation for asynchronous message processing.
Exception thrown when a
MessageInterceptor throws during
before-processing execution.Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated, for removal: This API element is subject to removal in a future version.
Strategy interface for applying jitter to exponential backoff calculations.
Context for jitter calculations.
Deprecated.
Deprecated, for removal: This API element is subject to removal in a future version.
Deprecated.
Deprecated.
Deprecated.
Deprecated.
Deprecated.
Deprecated.
Deprecated.
Deprecated.
Handler for lifecycle methods.
An implementation of a Linear Backoff error handler for asynchronous message processing.
Exception thrown when the
AsyncMessageListener completes with an exception.Configure the delivery strategy to be used by a
MessageListenerContainer.Marker interface for a message conversion context.
Factory util class to construct
MessageConverter Jackson 3 specific.A
Thread implementation for processing messages.CustomizableThreadFactory implementation for creating MessageExecutionThread instances.AbstractDelegatingMessageListeningSinkAdapter implementation that groups the received batch according to the
provided grouping function and emits each sub batch to the delegate separately.ContextAccessor that use MessageHeaders to hold the Observation context.Utility class for extracting
MessageHeaders from a Message.Interface for intercepting messages before and after execution.
Interface to process incoming
Messages.A container for an
AsyncMessageListener with SmartLifecycle capabilities.Creates
MessageListenerContainer instances for given Endpoint instances or endpoint names.Interface for registering and looking up containers at startup and runtime.
Stage responsible for executing the
AsyncMessageListener.Holds the components that will be used on the
MessageProcessingPipeline.A message processing context that can be used for communication between components.
Implemented by exceptions that carry references to the
Message instances that failed during processing.Represents a stage in the processing pipeline that will be used to process
Message instances.Entrypoint for constructing a
MessageProcessingPipeline MessageProcessingPipelineBuilder.ComposingMessagePipelineStage.MessageSink specialization that uses a MessageProcessingPipeline as the output.Component that handles the flow of
Messages.A source of
Message instances.An
AbstractDelegatingMessageListeningSinkAdapter that adds an
MessageVisibilityExtendingSinkAdapter<T>.io.awspring.cloud.sqs.listener.sink.adapter.MessageVisibilityExtendingSinkAdapter.OriginalBatchMessageVisibilityExtendingInterceptor to the MessageProcessingContext.MessageHeaders associated with messaging operations.A converter for converting source or target objects to and from Spring Messaging
Messages.MessageHeaders implementation that allows providing an external UUID.MessageListener implementation to handle a message by invoking a method
handler.Exception to represent the failure of a Messaging Operation.
Synchronous messaging operations.
Options to be used by the template.
Strategy interface for inferring the payload type from a listener method signature.
A
SqsEndpoint extension that supports multiple handler methods annotated with SqsHandlerAcknowledgementHandler implementation that never acknowledges regardless of the result.Represents a
AbstractPipelineMessageListenerContainer component that can be observed.AcknowledgementHandler implementation that only acknowledges on success.MessageProcessingPipelineSink implementation that processes provided messages sequentially and in order.MessageSource extension that provides polling configurations and SmartLifecycle capabilities.Queue attributes extracted from SQS, as well as the queue name and url.
Implementations are enabled to receive a
QueueAttributes instance.HandlerMethodArgumentResolver implementation for resolving QueueAttributes arguments.Resolves
QueueAttributes for the specified queue.A builder for creating
QueueAttributesResolver instances.Exception thrown when a
QueueAttributesResolver fails.BatchVisibility implementation for SQS messages.Visibility implementation for SQS messages.Configure the strategy to be used when a specified queue is not found at container startup.
Deprecated.
The strategy to use when handling a send batch operation that has at least one failed message.
Exception representing a partial or complete failure in sending a batch of messages to an endpoint.
The result of a send operation.
The result of a batch send operation.
The result of a failed send operation.
SmartMessageConverter implementation that returns the payload unchanged if the target class for Serialization
/ Deserialization matches the payload class.Wrapper for SNS notifications that provides access to both the message payload and metadata.
Represents an SNS message attribute.
Resolves method parameters with
SnsNotification object.Converter that extracts SNS notifications from SQS messages and creates
SnsNotification objects.Annotation that is used to map SNS notification value on an SQS Queue to a variable that is annotated.
Annotation that is used to map SNS notification subject on an SQS Queue to a variable that is annotated.
Exception representing an error during acknowledgement execution.
AcknowledgementExecutor implementation for SQS queues.Implementations are enabled to receive a
SqsAsyncClient instance.Sqs-specific asynchronous messaging operations for Standard and Fifo queues.
Utility class containing the bean names used for the framework's bean registration.
Registers the
DefaultListenerContainerRegistry and EndpointRegistrar that will be used to bootstrap
the AWS SQS integration.Sqs specific implementation of
ContainerOptions.ContainerOptionsBuilder specialization for SQS specific options.Endpoint implementation for SQS endpoints.Top-level exception for Sqs
RuntimeException instances.Methods that are from classes annotated with
SqsListener and are annotated with SqsHandler will be
marked as the target of the SQS message listener based on the message payload type.A
HeaderMapper implementation for SQS Messages.The
MessageHeaders names used for Message
instances created from SQS messages.Deprecated, for removal: This API element is subject to removal in a future version.
Methods with this annotation will be wrapped by a
MessageListener or
AsyncMessageListener and set to a
MessageListenerContainer.Acknowledgement strategies supported by the
SqsListener annotation.AbstractListenerAnnotationBeanPostProcessor implementation for @SqsListener.Beans implementing this interface can configure the
EndpointRegistrar instance used to process
Endpoint instances and change general settings for processing all
SqsListener annotations.SQS-specific Observation for
SqsMessageListenerContainer.SqsListenerObservation.Context for SQS message listeners.ObservationConvention for SQS message listener key values.ObservationConvention for SQS listener key values.ObservationDocumentation for SQS message listener keys.SQS-specific high cardinality tags.
Observation-related instances that are specific to SQS.
MessageConversionContext implementation that contains SQS related properties for mapping additional
MessageHeaders.The
MessageProducerSupport implementation for the Amazon SQS receiveMessage.The
AbstractMessageProducingHandler implementation for the Amazon SQS.MessageListenerContainer implementation for SQS queues.MessageListenerContainerFactory implementation for creating SqsMessageListenerContainer instances.Resolves original SQS message object {@link (software.amazon.awssdk.services.sqs.model.Message)} from Spring
Messaging message object
Message.MessagingMessageConverter implementation for converting SQS
Message instances to Spring Messaging
Message instances.Sqs-specific synchronous messaging operations for Standard and Fifo queues.
Options for receiving messages from SQS queues, with a method chaining API.
Options for sending messages to SQS queues, with a method chaining API.
Sqs-specific implementation of
AbstractMessagingTemplateBuilder interface for creating a
SqsTemplate instance.Observation for
SqsTemplate.ObservationConvention for SqsTemplate key values.ObservationConvention for SQS template key values.ObservationDocumentation for SqsTemplate keys.High cardinality tags.
Observation-related instances that are specific to SQS.
Sqs specific options for the
SqsTemplate.SQS parameters added to
SendResult objects as additional information.A
ContainerComponentFactory implementation for Standard SQS queues.AbstractSqsMessageSource implementation for standard queues.Enables a class to receive a container managed
TaskExecutor.Acknowledgement modes to be used by a
MessageReceivingOperations
implementation.The ContentBasedDeduplication queue attribute value to be used by the
SqsTemplate when sending messages to a
FIFO queue.A non-blocking
BackPressureHandler that dynamically switches between high- and low-throughput modes to
optimize polling behavior based on recent message availability.Exception thrown when an executor is provided with an unsupported
ThreadFactory.Visibility interface that can be injected as parameter into a listener method.
HandlerMethodArgumentResolver for Visibility method parameters.