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.