All Classes and Interfaces
Class
Description
Base class for MessageGroupProcessor implementations that aggregate the group of Messages into a single Message.
The base
AbstractMessageChannel implementation for AMQP.A base
AbstractReplyProducingMessageHandler extension for AMQP message handlers.Base class for (de)serializers that provide a mechanism to
reconstruct a byte array from an arbitrary stream.
Base implementation of a
Candidate.Base parser for Channel Adapters.
Base class for channel parsers.
Abstract class for client connection factories; client connection factories
establish outgoing connections.
The abstract MongoDB
AbstractMessageGroupStore implementation to provide configuration for common options
for implementations of this class.Base class for all connection factories.
AbstractConnectionFactorySpec<S extends AbstractConnectionFactorySpec<S,C>,C extends AbstractConnectionFactory>
Base class parser for elements that create Message Endpoints.
Abstract Message handler that holds a buffer of correlated messages in a
MessageStore.Base class for parsers that create an instance of
AbstractCorrelatingMessageHandler.A file list filter that can be configured to always accept (pass) directories.
Base class for
MessageDispatcher implementations.The base class for Message Endpoint implementations.
Abstract class for integration evaluation context factory beans.
The
AbstractSubscribableChannel base implementation for those inheritors
which logic may be based on the Executor.A message source that can limit the number of remote objects it fetches.
Abstract implementation of
FileInfo; provides a setter
for the remote directory and a generic toString implementation.A convenience base class for any
FileListFilter whose criteria can be
evaluated against each File in isolation.Convenience base class for implementing FileLockers that check a lock before accepting a file.
Base class for transformers that convert a File payload.
Base class for File payload transformer parsers.
AbstractFtpSessionFactory<T extends org.apache.commons.net.ftp.FTPClient>
Base class for FTP SessionFactory implementations.
The base
HandleMessageAdvice for advices which can be applied only
for the MessageHandler.handleMessage(Message).Abstract base class for
RequestReplyHeaderMapper implementations.A composite
AbstractHeaderMapper.HeaderMatcher that matches if one of provided
AbstractHeaderMapper.HeaderMatchers matches to the headerName.A content-based
AbstractHeaderMapper.HeaderMatcher that matches if the specified
header is contained within a list of candidates.Strategy interface to determine if a given header name matches.
A pattern-based
AbstractHeaderMapper.HeaderMatcher that matches if the specified
header matches one of the specified simple patterns.A prefix-based
AbstractHeaderMapper.HeaderMatcher that matches if the specified
header starts with a configurable prefix.A pattern-based
AbstractHeaderMapper.HeaderMatcher that matches if the specified
header matches the specified simple pattern.Base class for http outbound adapter/gateway.
Base class charged with knowing how to connect to a remote file system,
scan it for new files and then download the files.
Factors out the common logic between the FTP and SFTP adapters.
Base class for inbound gateway parsers.
Base class for NamespaceHandlers that registers a BeanFactoryPostProcessor
for configuring default bean definitions.
Base class for inbound TCP/UDP Channel Adapters.
Base class for UDP MessageHandlers.
Base class for Jackson
JsonObjectMapper implementations.The Abstract Parser for the JPA Outbound Gateways.
Abstract
InboundMessageMapper implementation that maps incoming JSON messages
to a Message with the specified payload type.Abstract MessageChannel backed by an Apache Kafka topic.
Spec for a message channel backed by an Apache Kafka topic.
Base class for implementations of Key/Value style
MessageGroupStore and MessageStore.Base class for
Codecs using Kryo.Base class for
KryoRegistrar implementations.Base
ApplicationEvent class for leader based events.Base class for Transformers that convert from a JavaMail Message to a
Spring Integration Message.
Base class for
MailReceiver implementations.Base class for all Message Routers that support mapping from arbitrary String values
to Message Channel names.
A FileListFilter that only passes files matched by one or more
FileListFilter
if a corresponding marker file is also present to indicate a file transfer is complete.Base class for
MessageChannel implementations providing common
properties such as the channel name.A convenience wrapper class for the list of ChannelInterceptors.
Base class for
MessageHandler implementations.AbstractMessageListenerContainerSpec<S extends AbstractMessageListenerContainerSpec<S,C>,C extends AbstractMessageListenerContainer>
Base class for container specs.
A base class for
MessageSelector implementations that delegate to
a MessageProcessor.Base class for Message Transformers that delegate to a
MessageProcessor.The base
AbstractMessageHandler implementation for the MessageProducer.Base class for all Message Routers.
Abstract message source.
Deprecated.
Base class for Message-splitting handlers.
Base class for Method-level annotation post-processors.
An
AbstractMessageSource extension for common MongoDB sources options and support methods.AbstractMongoDbMessageSourceSpec<S extends AbstractMongoDbMessageSourceSpec<S,H>,H extends AbstractMongoDbMessageSource<?>>
A
MessageSourceSpec extension for common MongoDB sources options.Abstract class for MQTT Message-Driven Channel Adapters.
Abstract class for MQTT outbound channel adapters.
Base class for outbound Channel Adapter parsers.
Base class for url-based outbound gateway parsers.
A base class for
Transformer implementations that modify the payload
of a Message.Stores "seen" files in a MetadataStore to survive application restarts.
Base class for all pollable channels.
An
AbstractEndpoint extension for Polling Consumer pattern basics.Base parser for inbound Channel Adapters that poll a source.
Base class for deserializers that cannot determine the buffer size needed.
Base class for
ReactiveMessageHandler implementations.Filters a listing of files by qualifying their 'name'
against a regular expression (an instance of
Pattern).Abstract base class for parsing remote file inbound channel adapters.
Base class for Outbound Gateways that perform remote file operations.
Enumeration of commands supported by the gateways.
Enumeration of options supported by various commands.
Abstract base class for parsing remote file streaming inbound channel adapters.
A message source that produces a message with an
InputStream payload
referencing a remote file.Base class for MessageHandlers that are capable of producing replies.
An implementation of this interface is used to wrap the
AbstractReplyProducingMessageHandler.handleRequestMessage(Message)
method.Base class for
MessageHandler advice classes.Called by subclasses in doInvoke() to proceed() the invocation.
Convenience class for testing Spring Integration request-response message scenarios.
The base class for response validators used for
RequestResponseScenariosBase parser for routers.
A base connector container for common RSocket client and server functionality.
Base
MessageProcessor for scripting implementations to extend.Base Class for
ScriptExecutor.Base class for all server connection factories.
Factory bean to create and configure a
MessageHandler.Base class for filters that support ant style path expressions, which are less powerful
but more readable than regular expressions.
Base class for FactoryBeans that create standard MessageHandler instances.
Base
StompSessionManager implementation to manage a single StompSession
over its ListenableFuture from the target implementation of this class.Base implementation of
MessageChannel that
invokes the subscribed handler(s) by delegating to a
MessageDispatcher.Base class for TCP Connection Support implementations.
A base class for
Transformer implementations.A
MessageHandlerSpec for UDP MessageHandlers.Base class for outbound Web Service-invoking Messaging Gateways.
Super class for XML transformers.
Base class for XMPP inbound parsers
Base class of XMPP outbound parsers
Base class for XPath
MessageSelector implementations.Simple implementation of
FileListFilter that always returns true.An implementation of
CollectionFilter that remembers the elements passed in
the previous invocation in order to avoid returning those elements more than once.FileListFilter that passes files only one time.A general abstraction over acknowledgments.
A factory for creating
AcknowledgmentCallbacks.Utility methods for acting on
AcknowledgmentCallback headers.A message implementation that is produced by an advice after
successful message handling.
The
MessageJacksonDeserializer implementation for the AdviceMessage.The validation exception which aggregate all the XML validation errors.
An Exception that encapsulates an aggregated group of Exceptions for use by dispatchers
that may try multiple handler invocations within a single dispatch operation.
Aggregator specific implementation of
AbstractCorrelatingMessageHandler.Indicates that a method is capable of aggregating messages.
Post-processor for the
@Aggregator annotation.FactoryBean to create an
AggregatingMessageHandler.Parser for the aggregator element of the integration namespace.
A
Converter that delegates to a
Deserializer to convert data in a byte
array to an object.Factory class for AMQP components.
The base
MessageProducerSpec implementation for a AmqpInboundChannelAdapter.A base
MessagingGatewaySpec implementation for AmqpInboundGateway endpoint options.AmqpBaseOutboundEndpointSpec<S extends AmqpBaseOutboundEndpointSpec<S,E>,E extends AbstractAmqpOutboundEndpoint>
The base
MessageHandlerSpec for AbstractAmqpOutboundEndpoints.If point-to-point, we send to the default exchange with the routing key
equal to "[beanName]" and we declare that same Queue and register a listener
if message-driven or poll explicitly otherwise.
Parser for the 'channel' and 'publish-subscribe-channel' elements of the
Spring Integration AMQP namespace.
A convenience interface that extends
RequestReplyHeaderMapper,
parameterized with MessageProperties.Adapter that receives Messages from an AMQP Queue, converts them into
Spring Integration Messages, and sends the results to a Message Channel.
Defines the payload type when the listener container is configured with consumerBatchEnabled.
Spec for an inbound channel adapter with a
DirectMessageListenerContainer.Parser for the AMQP 'inbound-channel-adapter' element.
Spec for an inbound channel adapter with a
SimpleMessageListenerContainer.AmqpInboundChannelAdapterSpec<S extends AmqpInboundChannelAdapterSpec<S,C>,C extends AbstractMessageListenerContainer>
Adapter that receives Messages from an AMQP Queue, converts them into
Spring Integration Messages, and sends the results to a Message Channel.
Spec for a gateway with a
DirectMessageListenerContainer.Parser for the AMQP 'inbound-gateway' element.
Spec for a gateway with a
SimpleMessageListenerContainer.AmqpInboundGatewaySpec<S extends AmqpInboundGatewaySpec<S,C>,C extends AbstractMessageListenerContainer>
An
AmqpBaseInboundGatewaySpec implementation for a AmqpInboundGateway.Spec for a polled AMQP inbound channel adapter.
An
AmqpPollableMessageChannelSpec for a message-driven
PointToPointSubscribableAmqpChannel.An
ErrorMessageStrategy extension that adds the raw AMQP message as
a header to the ErrorMessage.A pollable
MessageSource for RabbitMQ.Information for building an AmqpAckCallback.
Namespace handler for the AMQP schema.
Parser for the AMQP 'outbound-channel-adapter' element.
Spec for an outbound AMQP channel adapter.
Adapter that converts and sends Messages to an AMQP Exchange.
Base spec for outbound AMQP endpoints.
Parser for the AMQP 'outbound-channel-adapter' element.
Spec for an outbound AMQP gateway.
AmqpPollableMessageChannelSpec<S extends AmqpPollableMessageChannelSpec<S,T>,T extends AbstractAmqpChannel>
A
MessageChannelSpec for a AbstractAmqpChannels.A MethodFilter implementation that enables the following:
matching on method name, if available
exclusion of void-returning methods if 'requiresReply' is true
limiting to annotated methods if at least one is present
.
Parser for the
<annotation-config> element of the integration namespace.Common value constants for annotation attributes.
A
GatewayProxyFactoryBean extension for Java configuration.An
AnnotationMetadata implementation to expose a metadata
by the provided Map of attributes.File tailer that delegates to the Apache Commons Tailer.
ApplicationEvent generated from Apache Mina ftp events.A listener for FTP events emitted by an Apache Mina ftp server.
ApplicationEvent generated from Apache Mina sftp events.A listener for SFTP events emitted by an Apache Mina sshd/sftp server.
An inbound Channel Adapter that implements
GenericApplicationListener and
passes Spring ApplicationEvents within messages.Parser for the <application-event-multicaster> element of the
integration namespace.
An outbound gateway where the sending thread is released immediately and the reply
is sent on the async template's listener container thread.
A
MessageSource implementation that
retrieves the current value of a JMX attribute each time AbstractMessageSource.receive() is invoked.Pre-defined names and prefixes for Apache Avro related headers.
A message handler that suspends the thread until a message with corresponding
correlation is passed into the
trigger method or
the timeout occurs.Parser for
<int:barrier/>.A
MessageHandlerSpec for the BarrierMessageHandler.The
MessagingGatewaySupport extension for HTTP Inbound endpoints
with basic properties.BaseHttpInboundEndpointSpec<S extends BaseHttpInboundEndpointSpec<S,E>,E extends HttpRequestHandlingEndpointSupport>
A base
MessagingGatewaySpec for the
HttpRequestHandlingEndpointSupport implementations.BaseHttpMessageHandlerSpec<S extends BaseHttpMessageHandlerSpec<S,E>,E extends AbstractHttpRequestExecutingMessageHandler>
The base
MessageHandlerSpec for AbstractHttpRequestExecutingMessageHandlers.The
Builder pattern implementation for the EIP-method chain.BaseWsInboundGatewaySpec<S extends BaseWsInboundGatewaySpec<S,E>,E extends AbstractWebServiceInboundGateway>
Base
MessagingGatewaySpec for web services.BaseWsOutboundGatewaySpec<S extends BaseWsOutboundGatewaySpec<S,E>,E extends AbstractWebServiceOutboundGateway>
The base
MessageHandlerSpec for AbstractWebServiceOutboundGateways.Defines a minimal message group store with basic capabilities.
Simple strategy interface for parsers that are responsible
for parsing an element, creating a bean definition, and then
registering the bean.
DestinationResolver implementation based on a Spring BeanFactory.An "artificial"
MessageProcessor for lazy-load of target bean by its name.A default implementation of
SqlParameterSourceFactory which creates an SqlParameterSource to
reference bean properties in its input.Boolean XPath testing
MessageSelector.An advice that causes all downstream
RabbitOperations operations to be executed
on the same channel, as long as there are no thread handoffs, since the channel is
bound to the thread.Messaging Annotation to mark a
Bean
method for a MessageChannel to produce a
BridgeHandler and Consumer Endpoint.Post-processor for the
@BridgeFrom annotation.A simple MessageHandler implementation that passes the request Message
directly to the output channel without modifying it.
Parser for the <bridge> element.
Messaging Annotation to mark a
Bean
method for a MessageChannel to produce a
BridgeHandler and Consumer Endpoint.Post-processor for the
@BridgeTo annotation.A
SubscribableChannel variant for implementations with broadcasting capabilities.A broadcasting dispatcher implementation.
An
IntegrationComponentSpec for configuring sub-flow subscribers on the
provided BroadcastCapableChannel.Reads data in an InputStream to a byte[]; data must be terminated by \r\n
(not included in resulting byte[]).
A deserializer that uses a
ByteArrayOutputStream instead of a fixed buffer,
allowing the buffer to grow as needed.Reads data in an InputStream to a byte[]; data must be preceded by
a binary length (network byte order, not included in resulting byte[]).
A byte array (de)serializer that does nothing with the payload; sends it raw.
Reads data in an InputStream to a byte[]; data must be terminated by a single
byte (not included in resulting byte[]).
Reads data in an InputStream to a byte[]; data must be prefixed by <stx> and
terminated by <etx> (not included in resulting byte[]).
A pollable source for receiving bytes from an
InputStream.A
MessageHandler that writes a byte array to an
OutputStream.An inbound endpoint that listens to a GemFire region for events and then publishes Messages to
a channel.
The
AbstractRequestHandlerAdvice implementation for caching
AbstractReplyProducingMessageHandler.RequestHandler#handleRequestMessage(Message) results.A
MessageHandler implementation that writes to a
GemFire Region.Connection factory that caches connections from the underlying target factory.
A
SessionFactory implementation that caches Sessions for reuse without
requiring reconnection each time the Session is retrieved from the factory.A
RejectedExecutionHandler that blocks the caller until
the executor has room in its queue, or a timeout occurs (in which
case a RejectedExecutionException is thrown.Interface that defines the contract for candidates to participate
in a leader election.
The
CompositeFileListFilter extension which chains the result
of the previous filter to the next one.Parser for the <chain> element.
Interface to encapsulate
ConfigAttributes for secured channel
send and receive operations.A
InitializingBean implementation that is responsible for creating
channels that are not explicitly defined but identified via the 'input-channel'
attribute of the corresponding endpoints.A helper class for parsing the sub-elements of a channel's
interceptors element.
Secured object for
ChannelSecurityInterceptor.A marker interface that indicates this message store has optimizations for
use in a
QueueChannel.Callback to be used with the
JdbcChannelMessageStore.Common interface used in order to configure the
JdbcChannelMessageStore to provide
database-specific queries.JMS MessageListener that converts a JMS Message into a Spring Integration
Message and sends that Message to a channel.
A utility class for purging
Messages from one or more
QueueChannels.Channel resolution utilities.
An AOP interceptor that enforces authorization for MessageChannel send and/or receive calls.
The
SecurityMetadataSource implementation for secured MessageChannels.Channel utilities.
A pollable source for
Readers.A
MessageHandler
that writes characters to a Writer.Parser for the XMPP 'inbound-channel-adapter' element.
This component logs in as a user and forwards any messages to that
user on to downstream components.
Parser for the XMPP 'outbound-channel-adapter' element
MessageHandler that sends an XMPP Chat Message.
Parser for the <claim-check-in/> element.
Transformer that stores a Message and returns a new Message whose payload
is the id of the stored Message.
Parser for the <claim-check-out/> element.
Transformer that accepts a Message whose payload is a UUID and retrieves the Message associated
with that id from a MessageStore if available.
RemoteFileTemplate callback with the underlying client instance providing
access to lower level methods.RemoteFileTemplate callback with the underlying client instance providing
access to lower level methods where no result is returned.The
BodyExtractor identity function implementation
which just returns the provided ClientHttpResponse.Edpoints implementing this interface are capable
of running in client-mode.
Intended to be run on a schedule, simply gets the connection
from a client connection factory each time it is run.
A client
AbstractRSocketConnector extension to the RSocket connection.A
StompEncoder extension to prepare a message for sending/receiving
before/after encoding/decoding when used from WebSockets client side.The
IntegrationWebSocketContainer implementation for the client
Web-Socket connection.The
AbstractSingleBeanDefinitionParser implementation for
the <websocket:client-container/> element.A
CloseableIterator is intended to be used when it may hold resources (such as file or socket handles).Interface for classes that perform both encode (serialize) and decode (deserialize) on multiple classes.
A
MessageConverter that delegates to a Codec to convert.Base strategy for filtering out a subset of a Collection of elements.
The marker interface for the
IntegrationComponentSpec implementation,
when there is need to register as beans not only the target spec's components,
but some additional components, e.g.A Codec that can delegate to one out of many Codecs, each mapped to a class.
An
Executor that encapsulates two underlying executors.Simple
FileListFilter that predicates its matches against all of the
configured FileListFilter.A
KryoRegistrar that delegates and validates registrations across all components.Classes implementing this interface delegate to a list of handlers.
Represents a composite message handler.
A
Trigger that delegates the CompoundTrigger.nextExecutionTime(TriggerContext)
to one of two Triggers.A
MessageSourceMutator that uses a CompoundTrigger to adjust
the poller - when a message is present, the compound trigger's primary trigger is
used to determine the next poll.Supports atomic updates to values in the store.
A
CompositeMessageConverter extension with some default MessageConverters
which can be overridden with the given converters
or added in the end of target converters collection.An alternate MongoDB
MessageStore and
MessageGroupStore which allows the user to
configure the instance of MongoTemplate.A factory used to create TcpConnection objects.
Parser for the <stdin-channel-adapter> element.
Parser for the "stdout-" and "stderr-channel-adapter" elements.
The
FactoryBean implementation for AbstractEndpoint population.A
EndpointSpec for consumer endpoints.Action to take regarding subscrptions when consumer stops.
Content Enricher is a Message Transformer that can augment a message's payload with
either static values or by optionally invoking a downstream message flow via its
request channel and then applying values from the reply Message to the original
payload.
Interface that defines the context for candidate leadership.
Responds to a Gemfire continuous query (set using the #query field) that is
constantly evaluated against a cache
Region.SpEL
MethodFilter to restrict method invocations to:
Pausable or Lifecycle components
get, set and shutdown methods of CustomizableThreadCreator
methods with ManagedAttribute and ManagedOperation annotations
This class isn't designed for target applications and typically is used from ExpressionControlBusFactoryBean.The
BytesMessageMapper implementation to delegate to/from Message
conversion into the provided MessageConverter.This Endpoint serves as a barrier for messages that should not be processed yet.
CorrelationHandlerSpec<S extends CorrelationHandlerSpec<S,H>,H extends AbstractCorrelatingMessageHandler>
Strategy for determining how messages can be correlated.
Indicates that a given method is capable of determining the correlation key
of a message sent as parameter.
Convenience factory for XML configuration of a
CorrelationStrategy.Enumeration of GemFire Continuous Query Event Types.
The mapping to permit cross origin requests (CORS) for
HttpRequestHandlingEndpointSupport.A Spring-friendly way to build a
CuratorFramework and implementing SmartLifecycle.Message Mapper for converting to and from UDP DatagramPackets.
AbstractPayloadTransformer that delegates to a codec to decode the
payload from a byte[].Indicates that the class member has some default meaning.
The
Function implementation for a default headers merging in the aggregator
component.This implementation of MessageGroupProcessor will take the messages from the
MessageGroup and pass them on in a single message with a Collection as a payload.
Default implementation of
AmqpHeaderMapper.Simple
Candidate for leadership.Creates the
ConfigAttributes for secured channel
send and receive operations based on simple String values.A
BeanDefinitionRegistryPostProcessor implementation that registers bean definitions
for many infrastructure components with their default configurations.Default message converter for datatype channels.
Default directory scanner and base class for other directory scanners.
A simple
ErrorMessageStrategy implementations which produces
a error message with original message if the AttributeAccessor has
ErrorMessageUtils.INPUT_MESSAGE_CONTEXT_KEY attribute.Default implementation of the filename generator strategy.
Default implementation of FTP SessionFactory.
SessionFactory for FTPS.
Converts a channel to a name, retaining a reference to the channel keyed by the name.
Default
HeaderMapper implementation for HTTP.Parser for the <inbound-channel-adapter/> element.
Default implementation of
JmsHeaderMapper.Class similar to JPA template limited to the operations required for the JPA adapters/gateway
not using JpaTemplate as the class is deprecated since Spring 3.1.
Default implementation of
LeaderEventPublisher.Default implementation of
LockRegistry which uses Masked Hashcode algorithm to obtain locks.The default implementation of the
LockRepository based on the
table from the script presented in the org/springframework/integration/jdbc/schema-*.sql.Maps an inbound
MimeMessage to a Map.Default
MessageConverter; delegates to a SyslogToMapTransformer to
convert the payload to a map of values and also provides some of the map contents as
message headers.The default Message Splitter implementation.
Creates a default
MqttClient and a set of options as configured.MultipartFileReader implementation that reads the MultipartFile
content directly into a new MultipartFile instance that is not restricted
to the HTTP request scope.Parser for the <outbound-channel-adapter/> element.
Default implementation for mapping to/from Messages.
Parser for the <router/> element.
Default implementation of the
AbstractScriptExecutor.A default
ScriptVariableGenerator implementation; used by script processors.The default implementation of
SessionFactoryLocator using a simple map lookup
and an optional default to fall back on.Factory for creating
SftpSession instances.A
HeaderMapper implementation for
mapping to and from a SoapHeader.Default implementation of
TcpNetConnectionSupport.Implementation of TcpSocketFactorySupport
for non-SSL sockets
ServerSocket and
Socket.Implementation of
TcpNioConnectionSupport for non-SSL
NIO connections.Implementation of
TcpNioConnectionSupport for SSL
NIO connections.Default implementation of
TcpSocketSupport; makes no
changes to sockets.Default implementation of
TcpSSLContextSupport; uses a
'TLS' (by default) SSLContext, initialized with 'JKS'
keystores, managed by 'SunX509' Key and Trust managers.Default implementation of
TransactionSynchronizationFactory which takes an instance of
TransactionSynchronizationProcessor allowing you to create a TransactionSynchronization
using {DefaultTransactionSynchronizationFactory.create(Object) method.Default implementation of
XmlPayloadConverter.Default implementation of
XmppHeaderMapper.A
ConsumerEndpointSpec for a DelayHandler.Parser for the <delayer> element.
A
MessageHandler that is capable of delaying the continuation of a Message flow
based on the result of evaluation delayExpression on an inbound Message
or a default delay value configured on this handler.The
MessageGroupProcessor implementation with delegation to the provided delegate
and optional aggregation for headers.A channel that invokes a single subscriber for each sent Message.
Spec for a
DirectMessageListenerContainer.An event emitted when a directory is created.
An event emitted when a directory is created.
Strategy for scanning directories.
The
FileListFilter modification which can accept a Consumer
which can be called when the filter discards the file.Classes implementing this interface are capable of discarding messages.
Represents an endpoint that has a discard channel.
SourceFactory implementation which supports creation of a DOMSource
from a Document, File or String payload.The Java DSL Integration infrastructure
beanFactory initializer.An implementation of
Expression that delegates to an ExpressionSource
for resolving the actual Expression instance per-invocation at runtime.This is a dynamically changeable
Trigger.For outbound messages, uses a message-aware Jackson object mapper to render the message
as JSON.
The main configuration annotation to enable Spring Integration infrastructure:
- Registers some built-in beans;
- Adds several
BeanFactoryPostProcessors;
- Adds several BeanPostProcessors;
- Adds annotations processors.Enables the
IntegrationGraphController if
org.springframework.web.servlet.DispatcherServlet or
org.springframework.web.reactive.DispatcherHandler is present in the classpath.Enables default configuring of management in Spring Integration components in an existing application.
Enables default exporting for Spring Integration components in an existing application, as
well as well all
@ManagedResource annotated beans.Enables
MessageHistory
for Spring Integration components.Provides the registration for the
PublisherAnnotationBeanPostProcessor
to allow the use of the Publisher annotation.AbstractPayloadTransformer that delegates to a codec to encode the
payload into a byte[].When used alongside an EIP annotation (and no
@Bean), specifies the bean name of
the consumer bean with the handler bean being id.handler (for a consuming
endpoint) or id.source for a message source (e.g.Base class for all endpoints.
EndpointSpec<S extends EndpointSpec<S,F,H>,F extends BeanNameAware & FactoryBean<? extends AbstractEndpoint>,H>
An
IntegrationComponentSpec for endpoints.Utility methods for messaging endpoints.
Parser for the 'enricher' element.
A
ConsumerEndpointSpec extension for the ContentEnricher.A matcher that evaluates against the result of invoking a function,
wrapped by the
Supplier
The goal is to defer the computation until the matcher needs to be actually evaluated.Represents a composite message handler that can emit error messages
(pollable endpoint).
Represents an endpoint that has a discard channel and can emit errors
(pollable endpoint).
Represents nodes that can natively handle errors.
Represents a message handler that can produce errors (pollable).
Nodes implementing this interface are capable of emitting errors.
Represents an endpoint that can route to multiple channels and can emit errors
(pollable endpoint).
A
TaskExecutor implementation that wraps an existing Executor
instance in order to catch any exceptions.A Message Router that resolves the target
MessageChannel for
messages whose payload is a Throwable.Parser for the <exception-type-router/> element.
The
MessageJacksonDeserializer implementation for the ErrorMessage.The component which can be used as general purpose of errors publishing.
A
RecoveryCallback that sends the final throwable as an
ErrorMessage after
retry exhaustion.A strategy to build an
ErrorMessage based on the provided
Throwable and AttributeAccessor as a context.Utilities for building error messages.
Message Endpoint that connects any
MessageHandler implementation to a SubscribableChannel.Namespace handler for Spring Integration's 'event' namespace.
Enumeration of GemFire event types.
An implementation of
MessageChannel
that delegates to an instance of
UnicastingDispatcher which in turn delegates all dispatching
invocations to an Executor.The
InterceptableChannel extension for the cases when
the ExecutorChannelInterceptors
may have reason (e.g.A
LockRegistry implementing this interface supports the removal of aged locks
that are not currently locked.Components that implement this interface are capable of supporting a primary
SpEL expression as part of their configuration.
A MessageProcessor implementation that expects an Expression or expressionString
as the Message payload.
FactoryBean for creating
MessageHandler instances to handle a message as a SpEL expression.
An immutable
AbstractMap implementation that wraps a Map<String, Object>,
where values must be instances of String or Expression,
and evaluates an expression for the provided key from the underlying
original Map.The
ExpressionEvalMap.EvaluationCallback implementation which evaluates an expression using
the provided context, root and returnType variables.Implementations of this interface can be provided to build 'on demand
ExpressionEvalMap.get(Object) logic'
for ExpressionEvalMap.The builder class to instantiate
ExpressionEvalMap.CorrelationStrategy implementation that evaluates an expression.A
MessageGroupProcessor implementation that evaluates a SpEL expression.A
MessageHandler that evaluates
the provided Expression expecting a void return.A base class for aggregators that evaluates a SpEL expression with the message list as the root object within the
evaluation context.
A
MessageProcessor implementation that evaluates a SpEL expression
with the Message itself as the root object within the evaluation context.A SpEL expression based
ParameterSourceFactory implementation.A
ReleaseStrategy that evaluates an expression.Used to advise
MessageHandlers.A Message Router implementation that evaluates the specified SpEL
expression.
The
Expression based RoutingSlipRouteStrategy implementation.A
MessageSelector implementation that
evaluates a SpEL expression.A Message Splitter implementation that evaluates the specified SpEL
expression.
An implementation of
SqlParameterSourceFactory which creates
an SqlParameterSource that evaluates Spring EL expressions.This implementation of
TransactionSynchronizationFactory
allows you to configure SpEL expressions, with their execution being coordinated
(synchronized) with a transaction - see
TransactionSynchronization.A Message Transformer implementation that evaluates the specified SpEL
expression.
FactoryBean for creating Expression instances.
A SpEL expression based
AbstractFileListFilter implementation.A
MessageProducerSupport sub-class that provides ExpressionMessageProducerSupport.payloadExpression
evaluation with result as a payload for Message to send.Strategy interface for retrieving Expressions.
Utility class with static methods for helping with evaluation of SpEL expressions.
Given a list of connection factories, serves up
TcpConnections
that can iterate over a connection from each factory until the write
succeeds or the list is exhausted.The Spring Integration Feed components Factory.
This implementation of
MessageSource will
produce individual SyndEntrys for a feed identified with the 'feedUrl'
attribute.A
MessageSourceSpec for a FeedEntryMessageSource.Handles parsing the configuration for the feed inbound-channel-adapter.
NamespaceHandler for the feed module.
An
AbstractAggregatingMessageGroupProcessor implementation for file content collecting
previously splitted by the FileSplitter
with the markers option turned on.A convenient component to utilize
a
FileSplitter.FileMarker-based aggregation logic.MultipartFileReader implementation that copies the MultipartFile's
content to a new temporary File in the specified directory.When writing file, this enumeration indicates what action shall be taken in
case the destination file already exists.
Pre-defined header names to be used when storing or retrieving
File-related values to/from integration Message Headers.
Parser for the <inbound-channel-adapter> element of the 'file' namespace.
Represents a remote file info - an abstraction over the underlying implementation.
A
KryoRegistrar used to validateRegistration a File serializer.Strategy interface for filtering a group of files.
A FileLocker is a strategy that can ensure that files are only processed a
single time.
A
ReleaseStrategy which makes a decision based on the presence of
FileSplitter.FileMarker.Mark.END
message in the group and its FileHeaders.LINE_COUNT header.Strategy interface for generating a file name from a message.
Namespace handler for Spring Integration's 'file' namespace.
Parser for the <outbound-channel-adapter/> element of the 'file'
namespace.
Parser for the 'outbound-gateway' element of the file namespace.
MessageSource that creates messages
from a file system directory.The Spring Integration File components Factory.
A custom Kryo
Serializer for serializing File payloads.Base class for file server events.
The
AbstractMessageSplitter implementation to split the File Message
payload to lines.The
MessageHandlerSpec for the FileSplitter.File system implementation of
AbstractMarkerFilePresentFileListFilter.Base class for file tailing inbound adapters.
A payload transformer that copies a File's contents to a byte array.
Parser for the <file-to-bytes-transformer> element.
A payload transformer that copies a File's contents to a String.
Parser for the <file-to-string-transformer> element.
A
MessageHandler implementation that transfers files to a remote server.The
MessageHandlerSpec for the FileTransferringMessageHandler.Utilities for operations on Files.
A
MessageHandler implementation
that writes the Message payload to a
file.When using
FileExistsMode.APPEND_NO_FLUSH, an implementation of this
interface is called for each file that has pending data to flush and close when
FileWritingMessageHandler.flushIfNeeded(FlushPredicate) is invoked.When using
FileExistsMode.APPEND_NO_FLUSH
an implementation of this interface is called for each file that has pending data
to flush when a trigger message is received.Factory bean used to create
FileWritingMessageHandlers.The
MessageHandlerSpec for the FileWritingMessageHandler.An event that is emitted when a file is written.
An event that is emitted when a file is written.
Indicates that a method is capable of playing the role of a Message Filter.
Post-processor for Methods annotated with
@Filter.A
ConsumerEndpointSpec implementation for the MessageFilter.Factory bean for creating a Message Filter.
Parser for the <filter/> element.
A
MethodFilter implementation that will always return
the same Method instance within a single-element list if it is
present in the candidate list.Specialized
SubscribableChannel for a single final subscriber set up during bean instantiation (unlike
other SubscribableChannels where the MessageHandler is subscribed when the endpoint
is started).Used to post process candidates for
FixedSubscriberChannel
MessageHandlers.An "artificial"
MessageChannel implementation which will be unwrapped to the
FixedSubscriberChannel on the bean
registration phase.The
AbstractMessageProducingHandler implementation for aggregation logic based
on Reactor's Flux.groupBy(java.util.function.Function<? super T, ? extends K>) and Flux.window(int) operators.The
AbstractMessageChannel implementation for the
Reactive Streams Publisher based on the Project Reactor Flux.The factory for FTP components.
A
FileInfo implementation for
FTP/FTPS.Parser for the FTP 'inbound-channel-adapter' element.
An implementation of
AbstractInboundFileSynchronizer for FTP.A
MessageSource implementation for FTP.The FTP specific
FileTransferringMessageHandler extension.A
FileTransferringMessageHandlerSpec for FTP.Provides namespace support for using FTP
Parser for FTP Outbound Channel Adapters.
Outbound Gateway for performing remote file operations via FTP/FTPS.
A
RemoteFileOutboundGatewaySpec for FTP.Persistent file list filter using the server's file timestamp to detect if we've already
'seen' this file.
Implementation of
AbstractRegexPatternFileListFilter for FTP.FTP version of
RemoteFileTemplate providing type-safe access to
the underlying FTPClient object.The
FtpRemoteFileTemplate.exists(String) operation mode.Base class for all events having an
FtpRequest.Implementation of
Session for FTP.Implementation of
AbstractSimplePatternFileListFilter for FTP.Message source for streaming FTP remote file contents.
FTP implementation of
AbstractMarkerFilePresentFileListFilter.An
Iterator implementation to convert each item from the target
FunctionIterator.iterator to a new object applying the FunctionIterator.function on FunctionIterator.next().Indicates that an interface method is capable of mapping its parameters
to a message or message payload.
A
ConsumerEndpointSpec implementation for a mid-flow GatewayMessageHandler.Provides the message header
value or expression.The
AbstractReplyProducingMessageHandler implementation for mid-flow Gateway.Represents the metadata associated with a Gateway method.
Parser for the <gateway/> element.
Generates a proxy for the provided service interface to enable interaction
with messaging components without application code being aware of them allowing
for POJO-style interaction.
A builder for the
GatewayProxyFactoryBean options
when MessagingGateway on the service interface cannot be
declared.Implementation of
LockRegistry providing a distributed lock using Gemfire.Gemfire implementation of the key/value style
MessageStore and
MessageGroupStore.Gemfire implementation of
ListenableMetadataStore.Simple runtime exception to wrap an SftpException.
A
ConsumerEndpointSpec for a MessageHandler implementations.A functional interface to specify
MessageHandler
logic with Java 8 Lambda expression:The
MessageJacksonDeserializer implementation for the GenericMessage.Generic (lambda) strategy interface for selector.
Generic (lambda) strategy interface for transformer.
ChannelInterceptor components with this
annotation will be applied as global channel interceptors
using the provided patterns to match channel names.The
IntegrationConfigurationInitializer to populate GlobalChannelInterceptorWrapper
for ChannelInterceptors marked with
GlobalChannelInterceptor annotation.Parser for 'channel-interceptor' elements.
This class applies global interceptors (
<channel-interceptor> or @GlobalChannelInterceptor)
to message channels beans.Parser for the top level 'wire-tap' element.
This object can be exposed, for example, as a JSON object over
HTTP.
An
AbstractReplyProducingMessageHandler capable of fielding
GraphQL Query, Mutation and Subscription requests.The factory to create
GroovyScriptExecutingMessageProcessor instances
if provided language == "groovy", otherwise delegates to the super class.FactoryBean for creating
MessageHandler instances to handle a message as a Groovy Script.Parser for the <groovy:control-bus/> element.
The Groovy Module Integration infrastructure
beanFactory initializer.The
MessageProcessor implementation
to evaluate Groovy scripts.Parser for the <groovy:script/> element.
A contract which can be implemented on the
ReleaseStrategy
and used in the AbstractCorrelatingMessageHandler to
populate the provided group condition supplier.The marker
MethodInterceptor interface extension
to distinguish advices for some reason.A
HandleMessageAdvice implementation with a plain delegation
to the provided MethodInterceptor.A custom scanner that only returns the first
maxNumberOfFiles
elements from a directory listing.Default implementation of
CorrelationStrategy.Implementations convert a channel to a name, retaining a reference to the channel keyed by the name.
A Transformer that adds statically configured header values to a Message.
Base support class for 'header-enricher' parsers.
An
IntegrationComponentSpec for a HeaderEnricher.Transformer that removes Message headers.
Parser for the 'header-filter' element.
Generic strategy interface for mapping
MessageHeaders to and from other
types of objects.Are the
MessageHeaders of a Message containing any entry
or multiple that match?MessageHandlers implementing this interface can propagate headers from
an input message to an output message.
A Message Router that resolves the MessageChannel from a header value.
Parser for the <header-value-router/> element.
Use to take a heap dump programmatically.
The HTTP components Factory.
Utility class for accessing HTTP integration components
from the
BeanFactory.The
BaseHttpInboundEndpointSpec implementation for the HttpRequestHandlingController.Parser for the 'inbound-channel-adapter' and 'inbound-gateway' elements
of the 'http' namespace.
HttpInboundEndpointSupportSpec<S extends HttpInboundEndpointSupportSpec<S,E>,E extends BaseHttpInboundEndpoint>
A fluent API for the
CrossOrigin.A fluent API for the
RequestMapping.The HTTP Integration infrastructure
beanFactory initializer.The
BaseHttpMessageHandlerSpec implementation for the HttpRequestExecutingMessageHandler.Namespace handler for Spring Integration's http namespace.
Parser for the 'outbound-channel-adapter' element of the http namespace.
Parser for the 'outbound-gateway' element of the http namespace.
A
MessageHandler
implementation that executes HTTP requests by delegating
to a RestTemplate instance.The
BaseHttpInboundEndpointSpec implementation for the HttpRequestHandlingMessagingGateway.Inbound HTTP endpoint that implements Spring's
Controller interface to be used with a DispatcherServlet front
controller.Base class for HTTP request handling endpoints.
Inbound Messaging Gateway that handles HTTP Requests.
A
method that has a MessagingAnnotation (@code @ServiceActivator, @Router etc.)
that also has this annotation, has an
IdempotentReceiverInterceptor applied
to the associated MessageHandler.handleMessage(org.springframework.messaging.Message<?>) method.The
IntegrationConfigurationInitializer that populates
the ConfigurableListableBeanFactory
with an IdempotentReceiverAutoProxyCreator
when IdempotentReceiverInterceptor BeanDefinitions and their mapping
to Consumer Endpoints are present.The
MethodInterceptor implementation for the
Idempotent Receiver
E.I.Parser for the <idempotent-receiver/> element.
Alternative
IdGenerator implementations.UUID.randomUUID().
FileListFilter implementation that ignores any hidden files.An event-driven Channel Adapter that receives mail messages from a mail
server that supports the IMAP "idle" command (see RFC 2177).
Parser for the <imap-idle-channel-adapter> element in the 'mail' namespace.
A
MailInboundChannelAdapterSpec for IMAP.A
MailReceiver implementation for receiving mail messages from a
mail server that supports the IMAP protocol.Post-processor for Methods annotated with
@InboundChannelAdapter.Strategy for synchronizing from a remote File system to a local directory.
Strategy interface for mapping from an Object to a
Message.Callback for stream-based file retrieval using a RemoteFileOperations.
Configures component scanning directives for use with
Configuration classes.ImportBeanDefinitionRegistrar implementation to scan and register Integration specific components.The common Builder abstraction.
BeanDefinitionRegistryPostProcessor to apply external Integration
infrastructure configurations via loading IntegrationConfigurationInitializer
implementations using SpringFactoriesLoader.The strategy to initialize the external Integration infrastructure (@{code BeanFactoryPostProcessor}s,
global beans etc.) in the provided
beanFactory.Shared utility methods for Integration configuration.
Message consumers implement this interface, the message handler within a consumer
may or may not emit output messages.
Utility methods for accessing common integration components from the BeanFactory.
A marker annotation (an analogue of
<int:converter/>) to register
Converter,
GenericConverter or
ConverterFactory beans for the integrationConversionService.The Kotlin
DslMarker annotation for classes used in scope of DSL, including all the Java DSL classes.Base class for all
ApplicationEvents generated by the framework.The main Integration DSL abstraction.
The base
Adapter class for the IntegrationFlow abstraction.A
BeanPostProcessor to parse IntegrationFlow beans and register their
components as beans in the provided
BeanFactory, if necessary.A public API for dynamic (manual) registration of
IntegrationFlows,
not via standard bean registration phase.A Builder pattern implementation for the options to register
IntegrationFlow
in the application context.The
BaseIntegrationFlowDefinition extension for syntax sugar with generics for some
type-based EIP-methods when an expected payload type is assumed from upstream.An
IntegrationFlowDefinition extension for custom Java DSL operators
and reusable solutions.The central factory for fluent
IntegrationFlowBuilder API.The REST Controller to provide the management API over
IntegrationGraphServer.The
BeanDefinitionParser for the <int-http:graph-controller> component.Registers the necessary beans for
EnableIntegrationGraphController.Builds the runtime object model graph.
A
HandlerResultHandler implementation to handle the result of the
WebFluxInboundEndpoint execution.Marker interface indicating that this
IntegrationManagement component initiates
message flow.The
AnnotationJmxAttributeSource extension to resolve ManagedResources
via IntegrationManagedResource on classes.Clone of
ManagedResource
limiting beans thus annotated so that they
will only be exported by the IntegrationMBeanExporter and prevented
from being exported by other MBeanExporters (if present).Base interface for Integration managed components.
Toggles to inform the management configurer to not set these properties since
the user has manually configured them in a bean definition.
@Configuration class that registers a IntegrationManagementConfigurer bean.Configures beans that implement
IntegrationManagement.Parser for the <management/> element.
@Configuration class that registers a IntegrationMBeanExporter bean.
MBean exporter for Spring Integration components in an existing application.
Adds standard SI Headers.
Namespace handler for the integration namespace.
Shared utility methods for integration namespace parsers.
Base class for all nodes.
A base class that provides convenient access to the bean factory as
well as
TaskScheduler and ConversionService instances.Indicates that a component implements some Enterprise Integration Pattern.
The Enterprise Integration Pattern types.
The Enterprise Integration Pattern categories.
Utility class to encapsulate infrastructure Integration properties constants and their default values.
Utilities for adapting integration components to/from reactive types.
ImportBeanDefinitionRegistrar implementation that configures integration infrastructure.The
HandlerMapping implementation that
detects and registers RequestMappingInfos for
HttpRequestHandlingEndpointSupport from a Spring Integration HTTP configuration
of <inbound-channel-adapter/> and <inbound-gateway/> elements.An implementation of the
ResourceHolder which holds an instance of the current Message
and the synchronization resource.The base
ResourceHolderSynchronization for IntegrationResourceHolder.A marker
ReactiveMessageHandler extension interface for Spring Integration
inbound endpoints.Namespace handler for the security namespace.
FactoryBean to populate SimpleEvaluationContext instances enhanced with:
a TypeConverter based on the
ConversionService
from the application context.The STOMP headers with Integration-friendly
stomp_ prefix.General utility methods.
A
WebExchangeBindException extension for validation error with a failed
message context.The high-level 'connection factory pattern' contract over low-level Web-Socket
configuration.
Utility methods and constants for IP adapter parsers.
Headers for Messages mapped from IP datagram packets.
Namespace handler for Spring Integration's ip namespace.
JsonInboundMessageMapper.JsonMessageParser implementation that parses JSON messages
and builds a Message with the specified payload type from provided JsonInboundMessageMapper.Jackson 2 JSON-processor (@link https://github.com/FasterXML)
JsonObjectMapper implementation.
Utility methods for Jackson.
The utility to check if Jackson JSON processor is present in the classpath.
Chained utility methods to simplify some Java repetitive code.
Deprecated.
since 5.5.6 in favor of
JavaUtils.
Channel-specific implementation of
MessageGroupStore using a relational
database via JDBC.An
ExpirableLockRegistry using a shared database to co-ordinate the locks.A message handler that executes an SQL update.
Implementation of
MessageStore using a relational database via JDBC.Parser for
JdbcMessageStore.Implementation of
ConcurrentMetadataStore using a relational database via JDBC.Namespace handler for the integration JDBC schema.
A polling channel adapter that creates messages from the payload returned by
executing a select query.
Parser for
JdbcPollingChannelAdapter.This Enumeration provides a handy wrapper around
Types.Factory class for JMS components.
Parser for the 'channel' and 'publish-subscribe-channel' elements of the
Spring Integration JMS namespace.
A
DefaultMessageListenerContainer specific JmsListenerContainerSpec extension.JmsDestinationAccessorSpec<S extends JmsDestinationAccessorSpec<S,A>,A extends JmsDestinationAccessor>
A base
IntegrationComponentSpec for JmsDestinationAccessors.A source for receiving JMS Messages with a polling listener.
Header enricher for JMS specific values.
Strategy interface for mapping integration Message headers to an outbound
JMS Message (e.g.
Parser for the <inbound-channel-adapter/> element of the 'jms' namespace.
A
JmsTemplate-based JmsInboundChannelAdapterSpec extension.A wrapper around the
JmsMessageDrivenEndpoint implementing
MessagingGatewaySupport.A
MessagingGatewaySpec for a JmsInboundGateway.JmsInboundGatewaySpec.JmsInboundGatewayListenerContainerSpec<S extends JmsListenerContainerSpec<S,C>,C extends AbstractMessageListenerContainer>
An
AbstractMessageListenerContainer-based JmsInboundGatewaySpec extension.JmsListenerContainerSpec<S extends JmsListenerContainerSpec<S,C>,C extends AbstractMessageListenerContainer>
A
JmsMessageChannelSpec for subscribable
AbstractJmsChannels.JmsMessageDrivenChannelAdapterSpec.JmsMessageDrivenChannelAdapterListenerContainerSpec<S extends JmsListenerContainerSpec<S,C>,C extends AbstractMessageListenerContainer>
A message-driven endpoint that receive JMS messages, converts them into
Spring Integration Messages, and then sends the result to a channel.
Parser for the <message-driven-channel-adapter> element and the
<inbound-gateway> element of the 'jms' namespace.
Namespace handler for Spring Integration's jms namespace.
Parser for the <outbound-channel-adapter/> element of the jms namespace.
A
JmsTemplate-based JmsOutboundChannelAdapterSpec extension.An outbound Messaging Gateway for request/reply JMS.
Parser for the <outbound-gateway> element of the integration 'jms' namespace.
A
MessageHandlerSpec for a JmsOutboundGateway.JmsPollableMessageChannelSpec<S extends JmsPollableMessageChannelSpec<S,T>,T extends AbstractJmsChannel>
A
MessageChannelSpec for an AbstractJmsChannel.A
JmsMessageChannelSpec for a SubscribableJmsChannel
configured with a topic.A MessageConsumer that sends the converted Message payload within a JMS Message.
A timeout occurred within an async gateway.
Constants for JMX related Message Header keys.
The JMX Integration infrastructure
beanFactory initializer.Namespace handler for Spring Integration's jmx namespace.
Factory class for JPA components.
The base
MessageHandlerSpec for JPA Outbound endpoints.Executes Jpa Operations that produce payload objects from the result of the provided:
entityClass
JpQl Select Query
Sql Native Query
JpQl Named Query
Sql Native Named Query
.
The JPA Inbound Channel adapter parser.
The namespace handler for the JPA namespace.
An Exception that would be thrown if any of the Operations from
JpaOperations fails.The Interface containing all the JpaOperations those will be executed by
the Jpa Spring Integration components.
The parser for JPA outbound channel adapter.
The Jpa Outbound Gateway will allow you to make outbound operations to either:
submit (insert, delete) data to a database using JPA
retrieve (select) data from a database
Depending on the selected
OutboundGatewayType, the outbound gateway
will use either the JpaExecutor's poll method or its
executeOutboundJpaOperation method.The
JpaOutboundGatewayFactoryBean creates instances of the
JpaOutboundGateway.Abstraction of Jpa parameters allowing to provide static parameters
and SpEl Expression based parameters.
Contains various utility methods for parsing JPA Adapter specific namespace
elements and generation the respective
BeanDefinitions.Polling message source that produces messages from the result of the provided:
entityClass
JpQl Select Query
Sql Native Query
JpQl Named Query
Sql Native Named Query
.
A
JpaBaseOutboundEndpointSpec extension for the
JpaOutboundGateway with
OutboundGatewayType.RETRIEVING mode.This Utility contains a sub-set of utility methods from the Spring Data JPA Project.
Spring-friendly factory bean to create Jsch
Proxy objects.Pre-defined names and prefixes to be used for setting and/or retrieving JSON
entries from/to Message Headers and other adapter, e.g.
InboundMessageMapper implementation that maps incoming JSON messages
to a Message with the specified payload type.The
Converter implementation for the conversion
of JsonPropertyAccessor.JsonNodeWrapper to JsonNode,
when the JsonPropertyAccessor.JsonNodeWrapper can be a result of the expression
for JSON in case of the JsonPropertyAccessor usage.Strategy interface to convert an Object to/from the JSON representation.
Simple factory to provide JsonObjectMapper
instances based on jackson-databind lib in the classpath.
OutboundMessageMapper implementation the converts a Message to a JSON
string representation.Utility class to
JsonPathUtils.evaluate(java.lang.Object, java.lang.String, com.jayway.jsonpath.Predicate...) a jsonPath on the provided object.A SpEL
PropertyAccessor that knows how to read properties from JSON objects.Transformer implementation that converts a JSON string payload into an instance of the
provided target Class.
Factory class for Apache Kafka components.
Parser for a channel backed by an Apache Kafka topic.
An extension of
ErrorMessagePublisher that can be used in a
CommonErrorHandler for recovering Kafka
delivery failures.Parser for the inbound channel adapter.
Spec for a polled Apache Kafka inbound channel adapter.
Implementations of this interface will generally support a retry template for retrying
incoming deliveries and this supports adding common attributes to the retry context.
Inbound gateway.
Inbound gateway parser.
A
MessagingGatewaySpec implementation for the KafkaInboundGateway.A
ConcurrentMessageListenerContainer
configuration KafkaInboundGatewaySpec extension.Headers specifically for Spring Integration components.
Message-driven channel adapter.
The listener mode for the container, record or batch.
Parser for the message driven channel adapter.
A
MessageProducerSpec implementation for the KafkaMessageDrivenChannelAdapter.A
ConcurrentMessageListenerContainer configuration
KafkaMessageDrivenChannelAdapterSpec extension.A helper class in the Builder pattern style to delegate options to the
ConcurrentMessageListenerContainer.Polled message source for Apache Kafka.
AcknowledgmentCallback for Kafka.
AcknowledgmentCallbackFactory for KafkaAckInfo.
Information for building an KafkaAckCallback.
The namespace handler for the Apache Kafka namespace.
Parser for the outbound channel adapter.
Parser for the outbound gateway.
A
MessageHandlerSpec
implementation for the KafkaProducerMessageHandler
as a gateway.A
KafkaTemplate-based KafkaProducerMessageHandlerSpec extension.An
IntegrationComponentSpec
implementation for the KafkaTemplate.Utilities to assist with parsing XML.
Spec for a point to point channel backed by an Apache Kafka topic.
Spec for a pollable channel.
A Message Handler for Apache Kafka; when supplied with a
ReplyingKafkaTemplate it is used as
the handler in an outbound gateway.Creates a
ProducerRecord from a Message and/or properties
derived from configuration and/or the message.A
MessageHandlerSpec implementation for the KafkaProducerMessageHandler.A
KafkaTemplate-based KafkaProducerMessageHandlerSpec extension.Spec for a publish/subscribe channel backed by an Apache Kafka topic.
An exception that is the payload of an
ErrorMessage when a send fails.Spec for a subscribable channel.
An
IntegrationComponentSpec implementation for the KafkaTemplate.An
AbstractScriptExecutor for the Kotlin scripts support.A
KryoRegistrar used to validateRegistration a
list of Java classes.A
KryoRegistrar implementation backed by a Map
used to explicitly set the registration ID for each class.Strategy interface used by
PojoCodec to configure registrations
classes consistently across Kryo instances.A
KryoRegistrar implementation backed by a List of Registration.The
MessageProcessor implementation for method invocation on the single method classes
- functional interface implementations.The
FileListFilter implementation to filter those files which
File.lastModified() is less than the LastModifiedFileListFilter.age in comparison
with the current time.Interface for publishing leader based application events.
Bootstrap leadership
candidates
with ZooKeeper/Curator.Creates a
LeaderInitiator.Represents a link between nodes.
ConcurrentMetadataStore with the ability of registering MetadataStoreListener callbacks, to be
invoked when changes occur in the metadata store.Strategy for determining the iteration order of a MessageHandler list.
Strategy for maintaining a registry of shared locks.
Component that initiates leader election based on holding a lock.
Encapsulation of the SQL shunting that is needed for locks.
A JUnit method
Rule that changes the Log4J 2 logger level for a set of classes
or packages while a test method is running.Parser for the 'logging-channel-adapter' element.
MessageHandler implementation that simply logs the Message or its payload depending on the value of the
'shouldLogFullMessage' or SpEL 'logExpression' property.
Test classes annotated with this will change logging levels between tests.
JUnit condition that adjusts and reverts log levels before/after each test.
Rule to prevent long running tests from running on every build; set environment
variable RUN_LONG_INTEGRATION_TESTS on a CI nightly build to ensure coverage.
JUnit Jupiter condition to prevent long running tests from running on every build;
set environment variable
RUN_LONG_INTEGRATION_TESTS on a CI nightly build to ensure coverage.The factory for Spring Integration Mail components.
Pre-defined header names to be used for setting and/or retrieving Mail
Message attributes from/to integration Message Headers.
The Mail specific
MapBuilder implementation.Parser for the <inbound-channel-adapter> element of Spring Integration's 'mail' namespace.
MailInboundChannelAdapterSpec<S extends MailInboundChannelAdapterSpec<S,R>,R extends AbstractMailReceiver>
Namespace handler for the 'mail' namespace.
Parser for the <outbound-channel-adapter/> element of the 'mail' namespace.
Strategy interface for receiving mail
Messages.MessageSource implementation that
delegates to a MailReceiver to poll a mailbox.A
MessageHandler implementation for sending mail.Transforms a Message payload of type
Message to a String.Parser for the <mail-to-string-transformer> element.
Collection of utility methods to work with Mail transports.
Utilities for handling mail messages.
Makes
Lifecycle methods manageable.Extend
ManageableLifecycle to make those methods manageable.Deprecated.
this is no longer used by the framework.
A
ListenerExecutionFailedException enhanced with the channel and delivery tag.A
HandlerMethodArgumentResolver implementation to resolve argument
for the MethodParameter as a Map or Properties.A
Builder pattern implementation for the Map.Matchers that examine the contents of a
Map.Serializes a
Map as JSON.Converts to/from a Map with 2 keys ('headers' and 'payload').
Exposes channel mapping operations when the router is proxied.
Utility methods used during message mapping.
Will transform Map to an instance of Object.
An implementation of
AbstractTransformer that delegates
to an OXM Marshaller.An outbound Messaging Gateway for invoking Web Services that also supports
marshalling and unmarshalling of the request and response messages.
The spec for a
MarshallingWebServiceInboundGateway.The spec for a
MarshallingWebServiceOutboundGateway.Spec for a
MarshallingWebServiceOutboundGateway where an external
WebServiceTemplate is not provided.Parser for the 'mbean-export' element of the integration JMX namespace.
A
MessageSource implementation that
retrieves a snapshot of a filtered subset of the MBean tree.The default message builder; creates immutable
GenericMessages.Represents a message channel.
Deprecated.
since 5.3 in favor of
IntegrationReactiveUtils.An "artificial"
MessageChannel implementation which will be unwrapped to the
MessageChannel bean on the bean registration phase.PojoCodec configured to encode/decode Message<?>s.The callback to be used with the
MongoDbOutboundGateway
as an alternative to other query options on the gateway.A converter to convert the raw message created by the underlying
UDP/TCP endpoint to a specific form of Syslog message.
The
Message decoration contract.Strategy interface for dispatching messages to handlers.
Exception that indicates an internal error occurred within a
MessageDispatcher
preventing message delivery.The entity class to wrap
Message to the MongoDB document.Stereotype annotation indicating that a class is capable of serving as a
Message Endpoint.
Message Handler that delegates to a
MessageSelector.Represents an inbound gateway.
A group of messages that are correlated with each other and should be processed in the same context.
Event representing the expiration of a message group.
The
MessageGroup factory strategy.Value Object holding metadata about a MessageGroup in the MessageGroupStore.
A processor for correlated groups of messages.
A
BlockingQueue that is backed by a MessageGroupStore.Defines additional storage operations on groups of messages linked by a group id.
Invoked when a MessageGroupStore expires a group.
Convenient configurable component to allow explicit timed expiry of
MessageGroup instances in a
MessageGroupStore.A composite
MessageHandler implementation that invokes a chain of
MessageHandler instances in order.Represents a message handler.
An
IntegrationComponentSpec for MessageHandlers.Base class for Message handling components that provides basic validation and error
handling capabilities.
The strategy to decorate
MessageHandlingRunnable tasks
to be used with the Executor.Inner class for each Entry in the history.
The
<message-history/> parser.The
MessageStore specific value object to keep the Message and its metadata.A Jackson
StdNodeBasedDeserializer extension for Message implementations.Registers common MessageHeader types and Serializers.
Exception that indicates an error during message mapping.
Matcher to make assertions about message equality easier.
Value Object holding metadata about a Message in the MessageStore.
Predicate to make assertions about message equality easier.
The callback to be used with the
JdbcMessageHandler
as an alternative to the SqlParameterSourceFactory.This defines the lowest-level strategy of processing a Message and returning
some Object (or null).
The
MessageSource strategy implementation
to produce a Message from underlying
MessageProcessorMessageSource.messageProcessor for polling endpoints.The
IntegrationComponentSpec specific base class
for MessageProcessors.Base interface for any component that is capable of sending
messages to a
MessageChannel.Represents an inbound message producer.
An
IntegrationComponentSpec for
MessageProducers.A support class for producer endpoints that provides a setter for the
output channel and a convenience method for sending Messages.
A
MethodInterceptor that publishes Messages to a channel.Exception that indicates a message has been rejected by a selector.
Routers implementing this interface have a default output channel.
Convenience class to be used to unpack a
Message from a result set
row.A
ChannelInterceptor that
delegates to a list of MessageSelectors to decide
whether a Message should be accepted on the MessageChannel.Strategy interface for message selection.
A message selector implementation that passes incoming messages through a
chain of selectors.
Callback invoked by
RemoteFileOperations.executeForMessage()
- allows multiple operations on a session.Base interface for any source of
Messages that can be polled.Message sources implementing this interface have additional properties that
can be set or examined using JMX.
A
ReceiveMessageAdvice extension that can mutate a MessageSource before and/or after
MessageSource.receive() is called.Represents a message source.
A
PollingOperations used to ad-hoc poll a MessageSource.An
IntegrationComponentSpec for MessageSources.Strategy interface for storing and retrieving messages.
Exception for problems that occur when using a
MessageStore implementation.Exception that indicates a timeout elapsed prior to successful message delivery.
Base Exception type for Message transformation errors.
A reply-producing
MessageHandler
that delegates to a Transformer instance to modify the received Message
and sends the result to its output channel.Classes implementing this interface can take some action when a trigger
Message
is received.Validate a message.
A
BeanPostProcessor implementation that processes method-level
messaging annotations such as @Transformer, @Splitter, @Router, and @Filter.Utility methods to support annotation processing.
A subclass of
ApplicationEvent that wraps a Message.A wrapper exception for a
MessagingException used to convey the cause and
original message to a
MessagePublishingErrorHandler.A stereotype annotation to provide an Integration Messaging Gateway Proxy
(
<gateway/>) as an abstraction over the messaging API.The
ImportBeanDefinitionRegistrar to parse MessagingGateway and its service-interface
and to register BeanDefinition GatewayProxyFactoryBean.A convenient base class for connecting application code to
MessageChannels for sending, receiving, or request-reply operations.A helper class for processors that invoke a method on a target Object using
a combination of message payload(s) and headers as arguments.
Strategy interface for storing metadata from certain adapters
to avoid duplicate delivery of messages, for example.
A callback to be invoked whenever a value changes in the data store.
Base implementation for a
MetadataStoreListener.Facade for Meters.
Strategy interface for post-processing annotated methods.
An
PublisherMetadataSource implementation that retrieves the channel
name and expression strings from an annotation.Simple wrapper class containing a
Method and an object
array containing the arguments for an invocation of that method.Implementations of this interface are
InboundMessageMappers
that map a MethodArgsHolder to a Message.CorrelationStrategy implementation that works as an adapter to another bean.MessageGroupProcessor that serves as an adapter for the invocation of a POJO method.
A
MessageHandler that invokes the specified
method on the provided object.A MessageListProcessor implementation that invokes a method on a target POJO.
A MessageProcessor implementation that invokes a method on a target Object.
A
MessageSource implementation that
invokes a no-argument method so that its return value may be sent to a channel.A
ReleaseStrategy that invokes a method on a plain old Java object.A Message Router that invokes the specified method on the given object.
A method-invoking implementation of
MessageSelector.A Message Splitter implementation that invokes the specified method
on the given object.
A Message Transformer implementation that invokes the specified method
on the given object.
A metrics facade that delegates to a concrete implementation.
A builder for a counter.
A builder for a gauge.
A builder for a timer.
The Micrometer implementation of
MetricsCaptor.MicrometerMetricsCaptor.AbstractMeter<M extends io.micrometer.core.instrument.Meter>
A
Configuration to add a MicrometerMetricsCaptor.An
ImportSelector to conditionally add a MicrometerMetricsCaptorConfiguration
bean when io.micrometer.core.instrument.MeterRegistry is present in classpath.Add micrometer metrics to the node.
Simple
StdSerializer extension to represent a MimeType object in the
target JSON as a plain string.The factory for integration specific mock components.
A
BeanFactoryAware component with an API to customize real beans
in the application context from test code.Mockito matcher factory for
Message matcher creation.The
AbstractMessageProducingHandler extension for the mocking purpose in tests.Factory class for building MongoDb components.
A
MessageProducerSupport for MongoDB Change Stream implementation.MongoDB
PriorityCapableChannelMessageStore implementation.Parser for MongoDb store inbound adapters.
An instance of
MessageSource which returns
a Message with a payload which is the result of
execution of a Query.A
AbstractMongoDbMessageSourceSpec implementation for a MongoDbMessageSource.An implementation of both the
MessageStore and
MessageGroupStore
strategies that relies upon MongoDB for persistence.MongoDbMetadataStore implementation of
ConcurrentMetadataStore.Namespace handler for Spring Integration's 'mongodb' namespace.
Parser for Mongodb store outbound adapters.
Makes outbound operations to query a MongoDb database using a
MongoOperations.Parser for MongoDb outbound gateways.
A
MessageHandlerSpec extension for the MongoDb Outbound endpoint MongoDbOutboundGateway.Implementation of
MessageHandler
which writes Message payload into a MongoDb collection
identified by evaluation of the MongoDbStoringMessageHandler.collectionNameExpression.Pre-defined names and prefixes to be used
for dealing with headers required by Mongo components.
A component that interfaces with MQTT.
Helper for typed access to incoming MQTT message headers.
The default
HeaderMapper implementation for MQTT v5 message properties mapping.Spring Integration headers.
Base class for Mqtt Events.
Extension of
MessageConverter allowing the topic to be added as
a header.An event emitted (when using aysnc) when the client indicates the message
was delivered.
Base class for events related to message delivery.
The MqttAdapter Message Driven Channel adapter parser.
An event emitted (when using async) when the client indicates that a message
has been sent.
The namespace handler for the MqttAdapter namespace.
The parser for the MqttAdapter Outbound Channel Adapter.
An extension of
MqttComponent for Eclipse Paho components.Eclipse Paho Implementation.
Eclipse Paho Implementation.
The even representing an MQTT error occured during client interaction.
MQTT Utilities.
The
AbstractMqttMessageDrivenChannelAdapter implementation for MQTT v5.The
AbstractMqttMessageHandler implementation for MQTT v5.Channel adapter that joins a multicast group and receives incoming packets and
sends them to an output channel.
A
MessageHandler implementation that maps a
Message into a UDP datagram packet and sends that to the specified multicast address
(224.0.0.0 to 239.255.255.255) and port.An
HttpMessageConverter implementation that delegates to an instance of
AllEncompassingFormHttpMessageConverter while adding the capability to read
multipart/form-data content in an HTTP request.Strategy for reading
MultipartFile content.An implementation of
Message with a generic payload.Specialized message builder that can be used within a component to avoid the overhead
of having to build multiple messages for mutations within that component.
A MessageHeaders that permits direct access to and modification of the
header map.
The
MessageJacksonDeserializer implementation for the MutableMessage.An exception representing a negatively acknowledged message from a
publisher confirm.
File locking strategy that uses java.nio.
A JMX
NotificationListener implementation that will send Messages
containing the JMX Notification instances as their payloads.An
AbstractMessageHandler implementation to publish an incoming message
as a JMX Notification.Simple class used for the actual MBean instances to be registered.
A
PayloadMethodArgumentResolver that treats KafkaNull payloads as null.A channel implementation that essentially behaves like "/dev/null".
A map builder creating a map with Object keys and String values.
A
StringMessageConverter extension to convert any object to string.Transformer implementation that converts a payload instance into a JSON string
representation.
Transforms an object graph into a Map.
A simple transformer that creates an outbound payload by invoking the
inbound payload Object's
toString() method.Parser for the 'object-to-string-transformer' element.
Generic event representing that a mutex could not be acquired during leader election.
Generic event representing that leader has been granted.
Generic event representing that leader has been revoked.
A
MessageHandler implementation for invoking JMX operations based on
the Message sent to its AbstractMessageHandler.handleMessage(Message) method.Contains Oracle-specific queries for the
JdbcChannelMessageStore.Interface that extends
Ordered while also exposing the
Orderable.setOrder(int) as an interface-level so that it is avaiable
on AOP proxies, etc.Interface for components that wish to be considered for
an orderly shutdown using management interfaces.
A file tailing message producer that delegates to the OS tail program.
Indicates the mode of operation for the outbound Jpa Gateway.
Strategy interface for mapping from a
Message to an Object.A
MessagingException thrown when a non-transactional operation is
performing multiple updates from a single message, e.g.A simple
TransactionSynchronizationFactory implementation which produces
an IntegrationResourceHolderSynchronization with an IntegrationResourceHolder.The
LockRegistry implementation which has no effect.The simple
MessageConverter implementation which contract is to return
Message as is for both from/to operations.The simple 'pass thru'
SubProtocolHandler, when there is no interests in the
WebSocket sub-protocols.An event emitted when a path is moved.
An event emitted when a path is moved.
An event emitted when a file or directory is removed.
An event emitted when a file or directory is removed.
Utility methods for pattern matching.
Endpoints implementing this interface can be paused/resumed.
Matcher to make assertions about message equality easier.
Transformer that deserializes the inbound byte array payload to an object by delegating
to a Converter<byte[], Object>.
Parser for the 'payload-deserializing-transformer' element.
The
HandlerMethodArgumentResolver for evaluating Payload.expression()
as a SpEL expression against message and converting result to expected parameter type.Is the payload of a
Message equal to a given value or is matching
a given matcher?This annotation marks a method parameter as being a list of message payloads, for POJO handlers that deal with lists
of messages (e.g.
The
HandlerMethodArgumentResolver for resolving a Collection
of payloads or expression against each payload.Transformer that serializes the inbound payload into a byte array by delegating to a
Converter<Object, byte[]>.
Parser for the 'payload-serializing-transformer' element.
Transformer that converts the inbound payload to an object by delegating to a
Converter<Object, Object>.
A Message Router that resolves the
MessageChannel
based on the Message's payload type.Parser for the <payload-type-router/> element.
A
MessageSelector implementation that checks the type of the
Message payload.Validate a message payload.
Indicates how entities shall be persisted to the underlying persistence store.
Parser for the <channel> element.
The
AbstractSubscribableAmqpChannel implementation for one-to-one subscription
over AMQP queue.Kryo Codec that can encode and decode arbitrary types.
A
PollableChannel implementation that is backed by an AMQP Queue.Represents a pollable channel.
Pollable channel backed by an Apache Kafka topic.
Provides the
PollerMetadata options
for the Messaging annotations for polled endpoints.An
Adapter class for the Pollers factory.Parser for the <poller> element.
An utility class to provide
PollerSpecs for
PollerMetadata configuration
variants.An
IntegrationComponentSpec for PollerMetadatas.Message Endpoint that connects any
MessageHandler implementation
to a PollableChannel.Operations to perform on some message source.
An advice that can be added to a poller's advice chain that determines
whether a poll should be skipped or not.
Implementations determine whether a particular poll should be skipped.
Represents a pool of items.
Thrown when a pooled item could not be obtained for some reason.
A
MailInboundChannelAdapterSpec for POP3.A
MailReceiver implementation that polls a mail server using the
POP3 protocol.Implementations of this interface are subclasses of
AbstractMessageHandler that perform post processing after the
AbstractMessageHandler.handleMessageInternal(org.springframework.messaging.Message)
call.Parser for 'xmpp:presence-inbound-channel-adapter' element.
An inbound endpoint that is able to login and then emit
particular Presence event occurs within the logged-in user's
Roster.Parser for 'xmpp:presence-outbound-channel-adapter' element
MessageHandler that publishes updated Presence values for a given XMPP connection.
A
ChannelMessageStore that supports the
notion of message priority.A message channel that prioritizes messages based on a
Comparator.Abstraction of Procedure parameters allowing to provide static parameters
and SpEl Expression based parameters.
A
Builder pattern implementation for the Properties.Properties file-based implementation of
MetadataStore.An implementation of
PlatformTransactionManager
that provides transaction-like semantics to
MessageSources that are not inherently
transactional.Annotation to indicate that a method, or all public methods if applied at class-level,
should publish Messages.
An advisor that will apply the
MessagePublishingInterceptor to any
methods containing the provided annotations.Post-processes beans that contain the
method-level @
Publisher annotation.Parser for the <publishing-interceptor> element.
The
AbstractSubscribableAmqpChannel extension for pub-sub semantics based on the FanoutExchange.A channel that sends Messages to each of its subscribers.
Parser for the <publish-subscribe-channel> element.
Publish/subscribe channel backed by an Apache Kafka topic.
The
PublishSubscribeChannelSpec extension to configure as a general flow callback for sub-flows
as subscribers.A
ScriptExecutor
that implements special handling required for Python to
emulate behavior similar to other JSR223 scripting languages.Simple implementation of a message channel.
Operations available on a channel that has queuing semantics.
The
ChannelMessageStore-specific QueueChannelSpec extension.Java DSL Factory class for R2DBC components.
Implementation of
ReactiveMessageHandler which writes
Message payload into a Relational Database, using reactive r2dbc support./**
The mode for the
R2dbcMessageHandler.The
ReactiveMessageHandlerSpec for the R2dbcMessageHandler.An instance of
MessageSource which returns
a Message with a payload which is the result of
execution of query.The
MessageSourceSpec for the R2dbcMessageSource.An
AbstractRequestHandlerAdvice extension for a rate limiting to service method calls.A
MessagingException wrapper for the RequestNotPermitted
with the requestMessage and target context.ErrorMessageStrategy extension that adds the raw record as
a header to the ErrorMessage.Provides reactive configuration options for the consumer endpoint making
any input channel as a reactive stream source of data.
A
MessageHandler implementation to adapt a ReactiveMessageHandler
for synchronous invocations.ReactiveMessageHandlerSpec<S extends ReactiveMessageHandlerSpec<S,H>,H extends ReactiveMessageHandler>
The
MessageHandlerSpec extension for ReactiveMessageHandler.The
MessageProducerSupport to adapt a provided MessageSource
into a Flux and let it be subscribed in the MessageProducerSupport.subscribeToPublisher(org.reactivestreams.Publisher<? extends org.springframework.messaging.Message<?>>).A
ReactiveMessageHandlerSpec extension for the Reactive MongoDb Outbound endpoint
ReactiveMongoDbStoringMessageHandler.An instance of
MessageSource which returns
a Message with a payload which is the result of
execution of a Query.A
AbstractMongoDbMessageSourceSpec implementation for a ReactiveMongoDbMessageSource.Implementation of
ReactiveMessageHandler which writes
Message payload into a MongoDb collection, using reactive MongoDb support, The
collection is identified by evaluation of the ReactiveMongoDbStoringMessageHandler.collectionNameExpression.Implementation of
ReactiveMessageHandler which writes
Message payload or Message itself (see ReactiveRedisStreamMessageHandler.extractPayload) into a Redis stream using Reactive Stream operations.A
MessageProducerSupport for reading messages from a Redis Stream and publishing them into the provided
output channel.A
MethodInterceptor for message handlers producing a Mono as a payload for reply.An
AbstractEndpoint implementation for Reactive Streams subscription into an
input channel and reactive consumption of messages from that channel.The
ReactorNettyTcpStompClient based AbstractStompSessionManager implementation.The
AbstractSubProtocolEvent implementation, which is emitted
for the WebSocket sub-protocol-specific RECEIPT frame on the client side.Counters for components that maintain receive counters.
An AOP advice to perform hooks before and/or after a
receive() contract is called.
<recipient-list-router id="simpleRouter" input-channel="routingChannelA">
<recipient channel="channel1"/>
<recipient channel="channel2"/>
</recipient-list-router>
Exposes adding/removing individual recipients operations for
RecipientListRouter.
Parser for the <recipient-list-router/> element.
An
AbstractRouterSpec for a RecipientListRouter.The
DefaultDirectoryScanner extension which walks through the directory tree
using Files.walk(Path, int, FileVisitOption...).Specialized Redis
ChannelMessageStore that uses a list to back a QueueChannel.Parser for the 'channel' and 'publish-subscribe-channel' elements of the
Spring Integration Redis namespace.
Specialized Redis
PriorityCapableChannelMessageStore that uses lists to back a QueueChannel.Pre-defined names and prefixes to be used for
for dealing with headers required by Redis components
Implementation of
ExpirableLockRegistry providing a distributed lock using Redis.Redis implementation of the key/value style
MessageStore and
MessageGroupStoreRedis implementation of
ConcurrentMetadataStore.Namespace handler for Spring Integration's 'redis' namespace.
Parser for the
<outbound-channel-adapter/> component.The Gateway component implementation to perform Redis commands with provided arguments and to return command result.
Parser for the
<int-redis:outbound-gateway/> component.Parser for the <queue-inbound-channel-adapter> element of the 'redis' namespace.
Parser for the <queue-inbound-gateway> element of the 'redis' namespace.
Parser for the <int-redis:queue-outbound-channel-adapter> element.
Parser for the <int-redis:queue-outbound-channel-adapter> element.
Parser for Redis store inbound adapters
Inbound channel adapter which returns a Message representing a view into
a Redis store.
Parser for the <redis:store-outbound-channel-adapter> element.
Implementation of
MessageHandler which writes
Message data into a Redis store identified by a key String.A
ScriptSource implementation, which caches a script string and refreshes it from the
target file (if modified) according the provided RefreshableResourceScriptSource.refreshDelay.Implementation of AbstractRegexPatternMatchingFileListFilter for java.io.File instances.
XPath
MessageSelector that tests if a
provided String value matches a given Regular Expression.Regular Expression Utilities.
Default registration ids for serializers provided by the framework.
Strategy for determining when a group of messages reaches a state of
completion (i.e.
Indicates that a method is capable of asserting if a list of messages or
payload objects is complete.
Convenience factory for XML configuration of a
ReleaseStrategy.ExpressionSource implementation that accesses resource bundles using specified basenames.RemoteFileInboundChannelAdapterSpec<F,S extends RemoteFileInboundChannelAdapterSpec<F,S,MS>,MS extends AbstractInboundFileSynchronizingMessageSource<F>>
Strategy for performing operations on remote files.
Callback for using the same session for multiple
RemoteFileTemplate operations.
The
MessageHandlerSpec for the AbstractRemoteFileOutboundGateway.RemoteFileStreamingInboundChannelAdapterSpec<F,S extends RemoteFileStreamingInboundChannelAdapterSpec<F,S,MS>,MS extends AbstractRemoteFileStreamingMessageSource<F>>
A general abstraction for dealing with remote files.
Utility methods for supporting remote file operations.
A zero-capacity version of
QueueChannel that delegates to a
SynchronousQueue internally.A
LockRegistry implementing this interface supports the renewal
of the time to live of a lock.The
AbstractReplyProducingMessageHandler wrapper around raw MessageHandler
for request-reply scenarios, e.g.Exception that indicates no reply message is produced by a handler
that does have a value of true for the 'requiresReply' property.
A circuit breaker that stops calling a failing service after threshold
failures, until halfOpenAfter milliseconds has elapsed.
An exception thrown when the circuit breaker is in an open state.
Uses spring-retry to perform stateless or stateful retry.
Class for mapping web requests onto specific
HttpRequestHandlingEndpointSupport.Interface for a request/reply Message exchange.
Request/Reply strategy interface for mapping
MessageHeaders to and from other
types of objects.Defines a Spring Integration request response test scenario.
Parser for the <resequencer> element.
This class implements all the strategy interfaces needed for a default resequencer.
Resequencer specific implementation of
AbstractCorrelatingMessageHandler.A
FileListFilter that can be reset by removing a specific file from its
state.Parser for 'resource-inbound-channel-adapter'.
Implementation of
MessageSource based on
ResourcePatternResolver which will attempt to resolve Resources based
on the pattern specified.Factory to create a
Result possibly taking into account the
provided message payload instance.Implementations of this class allow for the transformation of
Result
objects to other formats.The Parser for the Retrieving Jpa Outbound Gateway.
Strategy interface for generating a
RetryState instance
based on a message.A MessagingException for a returned message.
A
FileListFilter that allows the caller to reverse (roll back) state
changes.MessageConverter; delegates to a RFC5424SyslogParser if
necessary (TCP will have already done the syslog conversion because it needs
to handle different message framing).Parse for RFC 5424 syslog messages; when used with TCP, requires the use
of a
RFC6587SyslogDeserializer which decodes the framing.RFC5424/6587 Deserializer.
Annotate endpoints to assign them to a role.
A smart poller advice that rotates across multiple remote servers/directories.
A strategy for rotating advices to allow reconfiguring
the message source before and/or after a poll.
A key for a thread-local store and its related directory pair.
Round-robin implementation of
LoadBalancingStrategy.Indicates that a method is capable of resolving to a channel or channel name
based on a message, message header(s), or both.
Post-processor for Methods annotated with
@Router.Factory bean for creating a Message Router.
The
AbstractRouterSpec for an AbstractMappingMessageRouter.Represents an endpoint that can route to multiple channels.
The
RoutingSlip HeaderValueMessageProcessor specific implementation.The
RoutingSlip strategy to determine the next replyChannel.An
IntegrationEvent to indicate that RSocket from the client is connected
to the server.The
MessagingGatewaySupport implementation for the IntegrationRSocketEndpoint.Parser for the <inbound-gateway/> element of the 'rsocket' namespace.
The
MessagingGatewaySpec implementation for the RSocketInboundGateway.The RSocket protocol interaction models.
Namespace handler for Spring Integration XML configuration for RSocket support.
An Outbound Messaging Gateway for RSocket requests.
Parser for the 'outbound-gateway' element of the rsocket namespace.
The
MessageHandlerSpec implementation for the RSocketOutboundGateway.The RSocket components Factory.
A
DefaultScriptExecutor extension for Ruby scripting support.The
MessageHandler implementation for the
Scatter-Gather EIP pattern.Parser for the <scatter-gather> element.
A
GenericEndpointSpec extension for the ScatterGatherHandler.An
AbstractScriptExecutingMessageProcessor implementation for evaluating scripts
from the provided ScriptSource in the provided ScriptExecutor against an optional
binding variables.The
MessageSource strategy implementation
to produce a Message from underlying
ScriptExecutingMessageSource.scriptMessageProcessor for polling endpoints.The factory to create
AbstractScriptExecutingMessageProcessor instances for provided arguments.A script evaluation abstraction against
ScriptSource and optional binding variables.The scripting configuration utilities.
The
MessageSourceSpec for Dynamic Language Scripts.An
AbstractScriptParser parser extension for the <int-script:script> tag.The factory for Dynamic Language Scripts (Groovy, Ruby, Python, JavaScript etc.).
The
MessageProcessorSpec implementation for the DslScriptExecutingMessageProcessor.Strategy interface to provide a
Map of variables to the script execution context.Strategy to be used to generate a
SearchTerm.An annotation to be applied for the
MessageChannel bean definition
from JavaConfig - on @Bean method level.Creates a
ChannelSecurityInterceptor
to control send and receive access, and creates a bean post-processor to apply the
interceptor to MessageChannels
whose names match the specified patterns.The
ExecutorChannelInterceptor
implementation responsible for
the SecurityContext propagation from one message flow's thread to another
through the MessageChannels involved in the flow.The Integration Security infrastructure
beanFactory initializer.Parser for the <selector-chain/> element.
Parser for a top-level <selector/> element.
Success and failure timer stats.
An implementation of
ReleaseStrategy that simply compares the current size of
the message list to the expected 'sequenceSize'.An
HttpMessageConverter implementation for
Serializable instances.A server
AbstractRSocketConnector extension to accept and manage client RSocket connections.An
IntegrationRSocketMessageHandler extension for RSocket service side.The
AbstractSingleBeanDefinitionParser implementation for
the <websocket:server-container/> element.Indicates that a method is capable of handling a message or message payload.
Post-processor for Methods annotated with
@ServiceActivator.FactoryBean for creating
ServiceActivatingHandler instances.Parser for the <service-activator> element.
The
WebServiceException extension to indicate that the server endpoint is
temporary unavailable.Common abstraction for a Session with a remote File system.
Callback invoked by
RemoteFileOperations.execute() - allows multiple operations
on a session.Simple convenience implementation of
SessionCallback for cases where
no result is returned.An event emitted when a session is closed.
An event emitted when a session is closed.
Factory for acquiring
Session instances.A factory returning a
SessionFactory based on some key.A
MapBuilder to producer a map that maps objects to SessionFactorys.An event emitted when a session is opened.
An event emitted when a session is opened.
The factory for SFTP components.
A
FileInfo implementation for SFTP.Parser for 'sftp:inbound-channel-adapter'
Handles the synchronization between a remote SFTP directory and a local mount.
A
MessageSource implementation for SFTP
that delegates to an InboundFileSynchronizer.Subclass of
FileTransferringMessageHandler for SFTP.Provides namespace support for using SFTP.
Parser for SFTP Outbound Channel Adapters.
Outbound Gateway for performing remote file operations via SFTP.
Persistent file list filter using the server's file timestamp to detect if we've already
'seen' this file.
Implementation of
AbstractRegexPatternFileListFilter for SFTP.SFTP version of
RemoteFileTemplate providing type-safe access to
the underlying ChannelSftp object.Default SFTP
Session implementation.Implementation of
AbstractSimplePatternFileListFilter for SFTP.Message source for streaming SFTP remote file contents.
SFTP implementation of
AbstractMarkerFilePresentFileListFilter.A
SessionFactory that implements this interface is capable of supporting a shared session.Opaque object for manually acknowledging.
Deprecated.
since 5.3 in favor of
SimpleActiveIdleReceiveMessageAdvice with the same
(but more common) functionality.A simple advice that polls at one rate when messages exist and another when
there are no messages.
An Apache Avro transformer to create generated
SpecificRecord objects
from byte[].Extremely simple JSON serializer.
Represents a mutable group of correlated messages that is bound to a certain
MessageStore and group id.The
MessageGroupFactory implementation to produce SimpleMessageGroup instances.A
MessageGroupProcessor that simply returns the messages in the group.Spec for a
SimpleMessageListenerContainer.Map-based in-memory implementation of
MessageStore and MessageGroupStore.Simple implementation of
MetadataStore that uses a ConcurrentMap for the data store.MultipartFileReader implementation that does not maintain metadata from
the original MultipartFile instance.Filter that supports ant style path expressions, which are less powerful but more readable than regular expressions.
A simple
PollSkipStrategy to be used with a PollSkipAdvice.Implementation of
Pool supporting dynamic resizing and a variable
timeout when attempting to obtain an item from the pool.User of the pool provide an implementation of this interface; called during
various pool operations.
Simple implementation of
PublisherMetadataSource that allows for
configuration of a single channel name, payload expression, and
array of header key=value expressions.An implementation of
ReleaseStrategy that simply compares the current size of
the message list to the expected 'sequenceSize'.An Apache Avro transformer for generated
SpecificRecord objects.An outbound Messaging Gateway for invoking a Web Service.
The spec for a
SimpleWebServiceInboundGateway.The spec for a
SimpleWebServiceOutboundGateway.Spec for a
SimpleWebServiceOutboundGateway where an external
WebServiceTemplate is not provided.Convenience class for a single
RequestResponseScenario testBulk start/stop
SmartLifecycle in a particular role in phase order.A convenience interface that extends
RequestReplyHeaderMapper,
parameterized with SoapHeader.Configures a socket.
Simple wrapper around
Socket providing access to getters (except
input/output streams).Used to communicate that a stream has closed, but between logical
messages.
Transforms the payload to a
Source using a SourceFactory.Factory to create a
Source possibly taking into account
the provided message payload instance.A Channel Adapter implementation for connecting a
MessageSource to a MessageChannel.FactoryBean for creating a SourcePollingChannelAdapter instance.
Creates a DefaultRetryState from a
Message.A
FactoryBean implementation to encapsulate the population of a static Method
from the provided SpelFunctionFactoryBean.functionClass and SpelFunctionFactoryBean.functionMethodSignature as
a valid StandardEvaluationContext function.Parser for the <spel-function> element.
Utility class that keeps track of a Set of SpEL
PropertyAccessors
in order to register them with the "integrationEvaluationContext" upon initialization.Parser for the <spel-property-accessors> element.
Indicates that a method is capable of splitting a single message or message
payload to produce multiple messages or payloads.
Post-processor for Methods annotated with
@Splitter.A
ConsumerEndpointSpec for a AbstractMessageSplitter implementations.Factory bean for creating a Message Splitter.
Parser for the <splitter/> element.
Annotation that can be specified on a test class that runs Spring Integration based tests.
Collaborator for JDBC adapters which allows creation of
instances of
SqlParameterSource for use in update operations.Channel message store query provider for Microsoft SQL Server / Azure SQL database.
Utility methods for analyzing stack traces.
Parser for the <header-enricher> element within the core integration
namespace.
The standard implementation of the
IntegrationFlow interface instantiated
by the Framework.Standard implementation of
IntegrationFlowContext.Standard rotation policy; iterates over key/directory pairs; when the end is reached,
starts again at the beginning.
Lightweight type-safe header accessor avoiding object
creation just to access a header.
The
StompIntegrationEvent implementation for the failed connection exceptions.The
StompIntegrationEvent implementation for the exception from STOMP Adapters.The STOMP
HeaderMapper implementation.The
MessageProducerSupport for STOMP protocol to handle STOMP frames from
provided destination and send messages to the outputChannel.The
AbstractChannelAdapterParser implementation for
the <stomp:inbound-channel-adapter/> element.Base class for all
IntegrationEvents generated by the STOMP Adapters.The
AbstractMessageHandler implementation to send messages to STOMP destinations.The
AbstractOutboundChannelAdapterParser implementation for
the <stomp:outbound-channel-adapter/> element.The
StompIntegrationEvent for the STOMP RECEIPT Frames or lost receipts.The
StompIntegrationEvent indicating the STOMP session establishment.An abstraction to manage the STOMP Session and connection/disconnection
for
StompSessionHandler.This class is used by all Stored Procedure (Stored Function) components and
provides the core functionality to execute those.
A message handler that executes Stored Procedures for update purposes.
An
AbstractReplyProducingMessageHandler implementation for performing
RDBMS stored procedures which return results.A polling channel adapter that creates messages from the payload returned by
executing a stored procedure or Sql function.
Application event published when EOF is detected on a stream.
Transforms an InputStream payload to a byte[] or String (if a
charset is provided).
Parser for
<stream-transformer/> element.A map builder creating a map with String keys and values.
SourceFactory implementation which supports creation of a StringSource
from a Document, File or String payloadA map builder creating a map with String keys and values.
The utility class to encapsulate search algorithms for a set of provided
SubProtocolHandlers.Metrics for subscribable channels.
An
AbstractJmsChannel implementation for message-driven subscriptions.Subscribable channel backed by an Apache Kafka topic.
An
AbstractMessageChannel implementation with BroadcastCapableChannel
aspect to provide a pub-sub semantics to consume messages fgrom Redis topic.Headers in a
Map generated by the @link SyslogToMapTransformer that
will be added to Spring Integration messages as headers, prefixed by SyslogHeaders.PREFIX.Parses a
<int-syslog:inbound-channel-adapter/>.Namspace handler for spring-integration-syslog.
Factory bean to create syslog inbound adapters (UDP or TCP).
Base support class for inbound channel adapters.
Transforms a packet in Syslog (RFC3164) format to a Map.
A
MessageProducerSpec for file tailing adapters.Factory methods for TCP.
Factory class to create TCP Serializer/Deserializers used to
encode/decode messages to/from a TCP stream.
An abstraction over
Socket and SocketChannel
that sends Message objects by serializing the payload and streaming it to the
destination.ApplicationEvent representing normal operations on a
TcpConnection.ApplicationEvent representing exceptions on a
TcpConnection.Instantiates a TcpN(et|io)(Server|Client)ConnectionFactory, depending
on type and using-nio attributes.
An event emitted when an endpoint cannot correlate a connection id to a
connection; the cause is a messaging exception with the failed message.
An event emitted when a connection could not be established for some
reason.
Interface for TCP connection interceptor factories.
Base class for
TcpConnectionInterceptors; passes all method calls through
to the underlying TcpConnection.IpIntegrationEvent representing exceptions on a TCP server socket/channel.IpIntegrationEvent emitted when a server begins listening.Base class for TcpConnections.
Event representing an exception while decoding an incoming stream.
Channel Adapter that receives TCP stream frames and maps them to Messages.
Inbound Gateway using a server connection factory - threading is controlled by the
factory.
Classes that implement this interface may register with a
connection factory to receive messages retrieved from a
TcpConnection.Maps incoming data from a
TcpConnection to a Message.A client connection factory that creates
TcpNetConnections.A TcpConnection that uses and underlying
Socket.Used by NET connection factories to instantiate a
TcpNetConnection object.Implements a server connection factory that produces
TcpNetConnections using
a ServerSocket.A client connection factory that creates
TcpNioConnections.A TcpConnection that uses and underlying
SocketChannel.Used by NIO connection factories to instantiate a
TcpNioConnection object./**
Implements a server connection factory that produces
TcpNioConnections using
a ServerSocketChannel.Implementation of
TcpConnection supporting SSL/TLS over NIO.TCP outbound gateway that uses a client connection factory.
Parser for the <outbound-gateway> element of the integration 'jms' namespace.
A
MessageHandlerSpec for TcpOutboundGateways.Tcp inbound channel adapter using a TcpConnection to
receive data - if the connection factory is a server
factory, this Listener owns the connections.
An interface representing a sending client of a connection
factory.
Tcp outbound channel adapter using a TcpConnection to
send data - if the connection factory is a server
factory, the TcpListener owns the connections.
Connection factories that act as TCP servers, listening for incoming connections.
Strategy interface for supplying Socket Factories.
Strategy interface for modifying sockets.
Strategy interface for the creation of an
SSLContext object
for use with SSL/TLS sockets.TCP implementation of a syslog inbound channel adapter.
Convenience class providing methods for testing IP components.
Deprecated.
since 5.5 in favor of GreenMail library for mail testing.
A
GenericApplicationContext extension with some support methods
to register Spring Integration beans in the application context at runtime.A client connection factory that binds a connection to a thread.
The
ExecutorChannelInterceptor implementation responsible for
the Thread (any?) state propagation from one message flow's thread to another
through the MessageChannels involved in the flow.A
ReleaseStrategy that releases all messages if any of the following is true:
The sequence is complete (if there is one).
There are more messages than a threshold set by the user.
The time elapsed since the earliest message, according to their timestamps, if
present, exceeds a timeout set by the user.
Statistics captured from a timer meter.
A
TransactionInterceptor extension with HandleMessageAdvice marker.Provides a fluent API to build a transaction interceptor.
Strategy for implementing factories that create
TransactionSynchronization.The
FactoryBean implementation (with Builder style) to be used
from JavaConfig to populate DefaultTransactionSynchronizationFactory bean.Parser for transaction-synchronization-factory element.
Strategy for implementing transaction synchronization processors.
Indicates that a method is capable of transforming a message, message header,
or message payload.
Strategy interface for transforming a
Message.Post-processor for Methods annotated with a
@Transformer.Factory bean for creating a Message Transformer.
Parser for the <transformer/> element.
An utility class to provide methods for out-of-the-box
Transformers.Factory methods for UDP.
Channel Adapter that receives UDP datagram packets and maps them to Messages.
IpIntegrationEvent emitted when a server begins listening.UDP implementation of a syslog inbound channel adapter.
A
MessageSelector that accepts Messages that are
not yet expired.Implementation of
MessageDispatcher that will attempt to send a
Message to at most one of its handlers.A channel adapter to receive incoming UDP packets.
A
MessageHandler implementation that maps a Message into
a UDP datagram packet and sends that to the specified host and port.A marker interface extension of the
MessageGroupStore.MessageGroupCallback
for components which should be registered in the MessageGroupStore only once.An implementation of
Transformer
that delegates to an OXM Unmarshaller.The Parser for Updating JPA Outbound Gateway.
A
MultipartFile implementation that represents an uploaded File.Thin wrapper around a Semaphore that allows to create a potentially unlimited upper bound
to by used in buffers of messages (e.g.
Indicates that a POJO handler method (
@ServiceActivator, @Transformer, etc.,
or such methods invoked from XML definitions) should be invoked using SpEL.Utility to help generate UUID instances from generic objects.
A very simple hardcoded implementation of the
Expression interface that represents an
immutable value.ChannelInterceptors implementing this
interface can veto global interception of a particular channel.The WebFlux components Factory.
Utility class for accessing WebFlux integration components
from the
BeanFactory.A
MessagingGatewaySupport
implementation for Spring WebFlux HTTP requests execution.The
HttpInboundEndpointSupportSpec implementation for the WebFluxInboundEndpoint.The WebFlux Integration infrastructure
beanFactory initializer.The
HandlerMapping implementation that
detects and registers RequestMappingInfos for
HttpRequestHandlingEndpointSupport
from a Spring Integration HTTP configuration
of <inbound-channel-adapter/> and <inbound-gateway/> elements.The
BaseHttpMessageHandlerSpec implementation for the WebFluxRequestExecutingMessageHandler.Namespace handler for Spring Integration's webflux namespace.
Parser for the 'outbound-channel-adapter' element of the webflux namespace.
Parser for the 'outbound-gateway' element of the webflux namespace.
A
MessageHandler implementation that executes
HTTP requests by delegating to a Reactive WebClient instance.Pre-defined header names to be used when storing or retrieving
Web Service properties to/from integration Message Headers.
Parser for the <outbound-gateway/> element in the 'ws' namespace.
The
MessageProducerSupport for inbound WebSocket messages.The
AbstractChannelAdapterParser implementation for
the <int-websocket:inbound-channel-adapter/> element.The WebSocket Integration infrastructure
beanFactory initializer.A contract for handling incoming
WebSocketMessages messages as part of a higher
level protocol, referred to as "sub-protocol" in the WebSocket RFC specification.The
AbstractOutboundChannelAdapterParser implementation for
the <websocket:outbound-channel-adapter/> element.The
WebSocketStompClient based AbstractStompSessionManager implementation.A simple strategy callback class that allows you to provide
a code that needs to be executed under
Lock provided by
LockRegistry.A
ChannelInterceptor that publishes a copy of the intercepted message
to a secondary target while still sending the original message to the main channel.Parser for the <wire-tap> element.
The
IntegrationComponentSpec implementation for the WireTap component.Factory class for web service components.
The
IntegrationConfigurationInitializer implementation for the WebService module.The XML validation-specific
MessageSelector.This class configures an
XMPPTCPConnection object.Parser for 'xmpp:xmpp-connection' element
Parser for 'xmpp:header-enricher' element
A convenience interface that extends
RequestReplyHeaderMapper
but parameterized with the Smack API MessageBuilder.Used as keys for
Message objects
that handle XMPP events.This class parses the schema for XMPP support.
Enumeration of different types of XPath evaluation used to indicate the type
of evaluation that should be carried out using a provided XPath expression.
The xPath-specific
HeaderValueMessageProcessorParser for the <xpath-expression> element.
Parser for the <xpath-filter> element.
Transformer implementation that evaluates XPath expressions against the
message payload and inserts the result of the evaluation into a message
header.
Parser for <xpath-header-enricher> elements.
Message Splitter that uses an
XPathExpression to split a
Document, File or String payload into a NodeList.Message Router that uses
XPathExpression evaluation to determine channel names.Parser for the <xpath-router/> element.
Transformer implementation that evaluates an XPath expression against the inbound
Message payload and returns a Message whose payload is the result of that evaluation.
Parser for the 'xpath-transformer' element.
Utility class for 'xpath' support.
Factory class for ZeroMq components DSL.
The
SubscribableChannel implementation over ZeroMQ sockets.The
MessageChannelSpec for a ZeroMqChannel.The message headers constants to repsent ZeroMq message attributes.
The
AbstractReactiveMessageHandler implementation for publishing messages over ZeroMq socket.The
ReactiveMessageHandlerSpec extension for ZeroMqMessageHandler.A
MessageProducerSupport implementation for consuming messages from ZeroMq socket.This class encapsulates the logic to configure and manage a ZeroMQ proxy.
ExpirableLockRegistry implementation using Zookeeper, or more specifically,
Curator InterProcessMutex.Strategy to convert a lock key (e.g.
Zookeeper-based
ListenableMetadataStore based on a Zookeeper node.A
ZookeeperMetadataStore-specific exception.
MessageSourceMutator.