All Classes and Interfaces
Class
Description
An abstract JMS
MessageListener
adapter providing the necessary
infrastructure to extract the payload of a JMS Message
.Base
JmsListenerContainerFactory
for Spring's base container implementation.Base model for a JMS listener endpoint.
Common base class for all containers which need to implement listening
based on a JMS Connection (either shared or freshly obtained for each attempt).
Exception that indicates that the initial setup of this container's
shared JMS Connection failed.
Abstract base class for Spring message listener container implementations.
Base class for listener container implementations which are based on polling.
DestinationResolver
implementation based on a Spring BeanFactory
.Callback for browsing the messages in a JMS queue.
SingleConnectionFactory
subclass that adds Session
caching as well as
MessageProducer
and MessageConsumer
caching.Extension of the DestinationResolver interface,
exposing methods for clearing the cache.
Implementation of the JMS ExceptionListener interface that supports chaining,
allowing the addition of multiple ExceptionListener instances in order.
Helper class for managing a JMS
ConnectionFactory
, in particular
for obtaining transactional JMS resources for a given ConnectionFactory.Callback interface for resource creation.
A
JmsListenerContainerFactory
implementation to build a
JCA-based JmsMessageEndpointManager
.Default implementation of the
JmsActivationSpecFactory
interface.A
JmsListenerContainerFactory
implementation to build a regular
DefaultMessageListenerContainer
.Message listener container variant that uses plain JMS client APIs, specifically
a loop of
MessageConsumer.receive()
calls that also allow for
transactional reception of messages (registering them with XA transactions).ConnectionFactory
implementation that delegates all calls
to a given target ConnectionFactory
, adapting specific
create(Queue/Topic)Connection
calls to the target ConnectionFactory
if necessary (e.g.Thrown by a DestinationResolver when it cannot resolve a destination name.
Strategy interface for resolving JMS destinations.
Simple
DestinationResolver
implementation resolving destination names
as dynamic destinations.Enable JMS listener annotated endpoints that are created under the cover
by a
JmsListenerContainerFactory
.Runtime exception mirroring the JMS IllegalStateException.
Runtime exception mirroring the JMS InvalidClientIDException.
Runtime exception mirroring the JMS InvalidDestinationException.
Runtime exception mirroring the JMS InvalidSelectorException.
Base class for
JmsTemplate
and other
JMS-accessing gateway helpers, defining common properties such as the
JMS ConnectionFactory
to operate on.Common configuration object for activating a JMS message endpoint.
Strategy interface for creating JCA 1.5 ActivationSpec objects
based on a configured
JmsActivationSpecConfig
object.@Configuration
class that registers a JmsListenerAnnotationBeanPostProcessor
bean capable of processing Spring's @JmsListener
annotation.Base class for
JmsTemplate
and other
JMS-accessing gateway helpers, adding destination-related properties to
JmsAccessor's
common properties.Base class for exception thrown by the framework whenever it
encounters a problem related to JMS.
Convenient superclass for application classes that need JMS access.
Strategy interface for mapping
Message
headers to an outbound JMS Message
(e.g.Pre-defined names and prefixes to be used for setting and/or retrieving
JMS attributes from/to generic message headers.
Annotation that marks a method to be the target of a JMS message listener on the
specified
JmsListener.destination()
.Bean post-processor that registers methods annotated with
JmsListener
to be invoked by a JMS message listener container created under the cover
by a JmsListenerContainerFactory
according to the attributes of the annotation.Optional interface to be implemented by a Spring managed bean willing
to customize how JMS listener endpoints are configured.
Configuration constants for internal sharing across subpackages.
Factory of
MessageListenerContainer
based on a
JmsListenerEndpoint
definition.Model for a JMS listener endpoint.
Helper bean for registering
JmsListenerEndpoint
with a JmsListenerEndpointRegistry
.Creates the necessary
MessageListenerContainer
instances for the
registered endpoints.Container annotation that aggregates several
JmsListener
annotations.JMS-specific implementation of the JCA 1.7
MessageEndpointFactory
interface,
providing transaction management capabilities for a JMS listener object
(e.g.Internal exception thrown when a ResourceException has been encountered
during the endpoint invocation.
Extension of the generic JCA 1.5
GenericMessageEndpointManager
,
adding JMS-specific support for ActivationSpec configuration.A
MessageHeaderAccessor
implementation giving access to JMS-specific headers.A specialization of
MessageSendingOperations
, MessageReceivingOperations
and MessageRequestReplyOperations
for JMS related operations that allow to specify
a destination name rather than the actual Destination
.An implementation of
JmsMessageOperations
.A
NamespaceHandler
for the JMS namespace.Specifies a basic set of JMS operations.
Resource holder wrapping a JMS
Connection
and a JMS Session
.Return type of any JMS listener method used to indicate the actual response
destination alongside the response itself.
Runtime exception mirroring the JMS JMSSecurityException.
Helper class that simplifies synchronous JMS access code.
PlatformTransactionManager
implementation
for a single JMS ConnectionFactory
.Generic utility methods for working with JMS.
DestinationResolver
implementation which interprets destination names
as JNDI locations (with a configurable fallback strategy).Exception to be thrown when the execution of a listener method failed.
Message converter that uses Jackson 2.x to convert messages to and from JSON.
Thrown by
MessageConverter
implementations when the conversion
of an object to/from a Message
fails.Strategy interface that specifies a converter between Java objects and JMS messages.
Creates a JMS message given a
Session
.Runtime exception mirroring the JMS MessageEOFException.
Runtime exception mirroring the JMS MessageFormatException.
Message listener adapter that delegates the handling of messages to target
listener methods via reflection, with flexible message type conversion.
Internal abstraction used by the framework representing a message
listener container.
Runtime exception mirroring the JMS MessageNotReadableException.
Runtime exception mirroring the JMS MessageNotWriteableException.
To be used with JmsTemplate's send method that converts an object to a message.
Constants that indicate a target message type to convert to: a
TextMessage
, a BytesMessage
,
a MapMessage
or an ObjectMessage
.Convert a
Message
from the messaging abstraction to and from a
Message
using an underlying MessageConverter
for the payload and a JmsHeaderMapper
to map the JMS headers to and from standard message headers.A
MessageListener
adapter that invokes a configurable
InvocableHandlerMethod
.A
JmsListenerEndpoint
providing the method to invoke to process
an incoming message for this endpoint.Callback for sending a message to a JMS destination.
Gather the Quality-of-Service settings that can be used when sending a message.
Exception to be thrown when the reply of a message failed to be sent.
Runtime exception mirroring the JMS ResourceAllocationException.
Variant of the standard JMS
MessageListener
interface,
offering not only the received Message but also the underlying
JMS Session object.Callback for executing any number of operations on a provided
Session
.Subinterface of
Session
to be implemented by
Session proxies.Simple implementation of
JmsHeaderMapper
.A
JmsListenerContainerFactory
implementation to build a
standard SimpleMessageListenerContainer
.A
JmsListenerEndpoint
simply providing the MessageListener
to
invoke to process an incoming message for this endpoint.A simple message converter which is able to handle TextMessages, BytesMessages,
MapMessages, and ObjectMessages.
Message listener container that uses the plain JMS client API's
MessageConsumer.setMessageListener()
method to
create concurrent MessageConsumers for the specified listeners.A JMS ConnectionFactory adapter that returns the same Connection
from all
SingleConnectionFactory.createConnection()
calls, and ignores calls to
Connection.close()
.Extension of the
jakarta.jms.ConnectionFactory
interface,
indicating how to release Connections obtained from it.An extended
MessageConverter
SPI with conversion hint support.Standard implementation of the
JmsActivationSpecFactory
interface.Interface to be implemented by message listener objects that suggest a specific
name for a durable subscription that they might be registered with.
Exception thrown when a synchronized local transaction failed to complete
(after the main transaction has already completed).
Proxy for a target JMS
ConnectionFactory
, adding awareness of
Spring-managed transactions.Runtime exception mirroring the JMS TransactionInProgressException.
Runtime exception mirroring the JMS TransactionRolledBackException.
JmsException to be thrown when no other matching subclass found.
An adapter for a target JMS
ConnectionFactory
, applying the
given user credentials to every standard createConnection()
call,
that is, implicitly invoking createConnection(username, password)
on the target.