All Classes (Spring Integration 5.5.0-RC1 API)

Class	Description
AbstractAggregatingMessageGroupProcessor	Base class for MessageGroupProcessor implementations that aggregate the group of Messages into a single Message.
AbstractAmqpChannel
AbstractAmqpOutboundEndpoint
AbstractAmqpOutboundEndpoint.CorrelationDataWrapper
AbstractBatchingMessageGroupStore
AbstractByteArraySerializer	Base class for (de)serializers that provide a mechanism to reconstruct a byte array from an arbitrary stream.
AbstractCandidate	Base implementation of a `Candidate`.
AbstractChannelAdapterParser	Base parser for Channel Adapters.
AbstractChannelMessageStoreQueryProvider
AbstractChannelParser	Base class for channel parsers.
AbstractClientConnectionFactory	Abstract class for client connection factories; client connection factories establish outgoing connections.
AbstractConfigurableMongoDbMessageStore	The abstract MongoDB `AbstractMessageGroupStore` implementation to provide configuration for common options for implementations of this class.
AbstractConnectionFactory	Base class for all connection factories.
AbstractConnectionFactorySpec<S extends AbstractConnectionFactorySpec<S,C>,C extends AbstractConnectionFactory>	An `IntegrationComponentSpec` for `AbstractConnectionFactory`s.
AbstractConsumerEndpointParser	Base class parser for elements that create Message Endpoints.
AbstractCorrelatingMessageHandler	Abstract Message handler that holds a buffer of correlated messages in a `MessageStore`.
AbstractCorrelatingMessageHandler.SequenceAwareMessageGroup
AbstractCorrelatingMessageHandlerParser	Base class for parsers that create an instance of `AbstractCorrelatingMessageHandler`.
AbstractDirectoryAwareFileListFilter<F>	A file list filter that can be configured to always accept (pass) directories.
AbstractDispatcher	Base class for `MessageDispatcher` implementations.
AbstractEndpoint	The base class for Message Endpoint implementations.
AbstractEvaluationContextFactoryBean	Abstract class for integration evaluation context factory beans.
AbstractExecutorChannel	The `AbstractSubscribableChannel` base implementation for those inheritors which logic may be based on the `Executor`.
AbstractExpressionEvaluator
AbstractFetchLimitingMessageSource<T>	A message source that can limit the number of remote objects it fetches.
AbstractFileInfo<F>	Abstract implementation of `FileInfo`; provides a setter for the remote directory and a generic toString implementation.
AbstractFileListFilter<F>	A convenience base class for any `FileListFilter` whose criteria can be evaluated against each File in isolation.
AbstractFileLockerFilter	Convenience base class for implementing FileLockers that check a lock before accepting a file.
AbstractFilePayloadTransformer<T>	Base class for transformers that convert a File payload.
AbstractFilePayloadTransformerParser	Base class for File payload transformer parsers.
AbstractFtpSessionFactory<T extends org.apache.commons.net.ftp.FTPClient>	Base class for FTP SessionFactory implementations.
AbstractHandleMessageAdvice	The base `HandleMessageAdvice` for advices which can be applied only for the `MessageHandler.handleMessage(Message)`.
AbstractHeaderMapper<T>	Abstract base class for `RequestReplyHeaderMapper` implementations.
AbstractHeaderMapper.CompositeHeaderMatcher	A composite `AbstractHeaderMapper.HeaderMatcher` that matches if one of provided `AbstractHeaderMapper.HeaderMatcher`s matches to the `headerName`.
AbstractHeaderMapper.ContentBasedHeaderMatcher	A content-based `AbstractHeaderMapper.HeaderMatcher` that matches if the specified header is contained within a list of candidates.
AbstractHeaderMapper.HeaderMatcher	Strategy interface to determine if a given header name matches.
AbstractHeaderMapper.PatternBasedHeaderMatcher	A pattern-based `AbstractHeaderMapper.HeaderMatcher` that matches if the specified header matches one of the specified simple patterns.
AbstractHeaderMapper.PrefixBasedMatcher	A prefix-based `AbstractHeaderMapper.HeaderMatcher` that matches if the specified header starts with a configurable prefix.
AbstractHeaderMapper.SinglePatternBasedHeaderMatcher	A pattern-based `AbstractHeaderMapper.HeaderMatcher` that matches if the specified header matches the specified simple pattern.
AbstractHeaderValueMessageProcessor<T>
AbstractHttpRequestExecutingMessageHandler	Base class for http outbound adapter/gateway.
AbstractInboundFileSynchronizer<F>	Base class charged with knowing how to connect to a remote file system, scan it for new files and then download the files.
AbstractInboundFileSynchronizingMessageSource<F>	Factors out the common logic between the FTP and SFTP adapters.
AbstractInboundGatewayParser	Base class for inbound gateway parsers.
AbstractIntegrationMessageBuilder<T>
AbstractIntegrationNamespaceHandler	Base class for NamespaceHandlers that registers a BeanFactoryPostProcessor for configuring default bean definitions.
AbstractInternetProtocolReceivingChannelAdapter	Base class for inbound TCP/UDP Channel Adapters.
AbstractInternetProtocolSendingMessageHandler	Base class for UDP MessageHandlers.
AbstractJacksonJsonObjectMapper<N,P,J>	Base class for Jackson `JsonObjectMapper` implementations.
AbstractJmsChannel
AbstractJpaOutboundGatewayParser	The Abstract Parser for the JPA Outbound Gateways.
AbstractJsonInboundMessageMapper<P>	Abstract `InboundMessageMapper` implementation that maps incoming JSON messages to a `Message` with the specified payload type.
AbstractKafkaChannel	Abstract MessageChannel backed by an Apache Kafka topic.
AbstractKafkaChannelSpec<S extends AbstractKafkaChannelSpec<S,C>,C extends AbstractKafkaChannel>	Spec for a message channel backed by an Apache Kafka topic.
AbstractKeyValueMessageStore	Base class for implementations of Key/Value style `MessageGroupStore` and `MessageStore`
AbstractKryoCodec	Base class for `Codec`s using `Kryo`.
AbstractKryoRegistrar	Base class for `KryoRegistrar` implementations.
AbstractLeaderEvent	Base `ApplicationEvent` class for leader based events.
AbstractMailMessageTransformer<T>	Base class for Transformers that convert from a JavaMail Message to a Spring Integration Message.
AbstractMailReceiver	Base class for `MailReceiver` implementations.
AbstractMappingMessageRouter	Base class for all Message Routers that support mapping from arbitrary String values to Message Channel names.
AbstractMarkerFilePresentFileListFilter<F>	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.
AbstractMessageChannel	Base class for `MessageChannel` implementations providing common properties such as the channel name.
AbstractMessageChannel.ChannelInterceptorList	A convenience wrapper class for the list of ChannelInterceptors.
AbstractMessageGroupStore
AbstractMessageHandler	Base class for `MessageHandler` implementations.
AbstractMessageListenerContainerSpec<S extends AbstractMessageListenerContainerSpec<S,C>,C extends AbstractMessageListenerContainer>	Base class for container specs.
AbstractMessageProcessingSelector	A base class for `MessageSelector` implementations that delegate to a `MessageProcessor`.
AbstractMessageProcessingTransformer	Base class for Message Transformers that delegate to a `MessageProcessor`.
AbstractMessageProcessor<T>
AbstractMessageProducingHandler	The base `AbstractMessageHandler` implementation for the `MessageProducer`.
AbstractMessageRouter	Base class for all Message Routers.
AbstractMessageSource<T>	Abstract message source.
AbstractMessageSourceAdvice	Deprecated. since 5.3 in favor of `MessageSourceMutator`.
AbstractMessageSplitter	Base class for Message-splitting handlers.
AbstractMethodAnnotationPostProcessor<T extends Annotation>	Base class for Method-level annotation post-processors.
AbstractMongoDbMessageSource<T>	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.
AbstractMqttMessageDrivenChannelAdapter	Abstract class for MQTT Message-Driven Channel Adapters.
AbstractMqttMessageHandler	Abstract class for MQTT outbound channel adapters.
AbstractOutboundChannelAdapterParser	Base class for outbound Channel Adapter parsers.
AbstractOutboundGatewayParser	Base class for url-based outbound gateway parsers.
AbstractPayloadTransformer<T,U>	A base class for `Transformer` implementations that modify the payload of a `Message`.
AbstractPersistentAcceptOnceFileListFilter<F>	Stores "seen" files in a MetadataStore to survive application restarts.
AbstractPollableChannel	Base class for all pollable channels.
AbstractPollingEndpoint	An `AbstractEndpoint` extension for Polling Consumer pattern basics.
AbstractPollingInboundChannelAdapterParser	Base parser for inbound Channel Adapters that poll a source.
AbstractPooledBufferByteArraySerializer	Base class for deserializers that cannot determine the buffer size needed.
AbstractReactiveMessageHandler	Base class for `ReactiveMessageHandler` implementations.
AbstractRegexPatternFileListFilter<F>	Filters a listing of files by qualifying their 'name' against a regular expression (an instance of `Pattern`)
AbstractRemoteFileInboundChannelAdapterParser	Abstract base class for parsing remote file inbound channel adapters.
AbstractRemoteFileOutboundGateway<F>	Base class for Outbound Gateways that perform remote file operations.
AbstractRemoteFileOutboundGateway.Command	Enumeration of commands supported by the gateways.
AbstractRemoteFileOutboundGateway.Option	Enumeration of options supported by various commands.
AbstractRemoteFileOutboundGatewayParser
AbstractRemoteFileStreamingInboundChannelAdapterParser	Abstract base class for parsing remote file streaming inbound channel adapters.
AbstractRemoteFileStreamingMessageSource<F>	A message source that produces a message with an `InputStream` payload referencing a remote file.
AbstractReplyProducingMessageHandler	Base class for MessageHandlers that are capable of producing replies.
AbstractReplyProducingMessageHandler.RequestHandler	An implementation of this interface is used to wrap the `AbstractReplyProducingMessageHandler.handleRequestMessage(Message)` method.
AbstractReplyProducingPostProcessingMessageHandler
AbstractRequestHandlerAdvice	Base class for `MessageHandler` advice classes.
AbstractRequestHandlerAdvice.ExecutionCallback	Called by subclasses in doInvoke() to proceed() the invocation.
AbstractRequestHandlerAdvice.ThrowableHolderException
AbstractRequestResponseScenarioTests	Convenience class for testing Spring Integration request-response message scenarios.
AbstractResponseValidator<T>	The base class for response validators used for `RequestResponseScenario`s
AbstractRouterParser	Base parser for routers.
AbstractRouterSpec<S extends AbstractRouterSpec<S,R>,R extends AbstractMessageRouter>	A `MessageHandlerSpec` for `AbstractMessageRouter`s.
AbstractRSocketConnector	A base connector container for common RSocket client and server functionality.
AbstractScriptExecutingMessageProcessor<T>	Base `MessageProcessor` for scripting implementations to extend.
AbstractScriptExecutor	Base Class for `ScriptExecutor`.
AbstractScriptParser
AbstractServerConnectionFactory	Base class for all server connection factories.
AbstractSimpleMessageHandlerFactoryBean<H extends MessageHandler>	Factory bean to create and configure a `MessageHandler`.
AbstractSimplePatternFileListFilter<F>	Base class for filters that support ant style path expressions, which are less powerful but more readable than regular expressions.
AbstractStandardMessageHandlerFactoryBean	Base class for FactoryBeans that create standard MessageHandler instances.
AbstractStompSessionManager	Base `StompSessionManager` implementation to manage a single `StompSession` over its `ListenableFuture` from the target implementation of this class.
AbstractSubscribableChannel	Base implementation of `MessageChannel` that invokes the subscribed `handler(s)` by delegating to a `MessageDispatcher`.
AbstractTcpConnectionSupport	Base class for TCP Connection Support implementations.
AbstractTransformer	A base class for `Transformer` implementations.
AbstractTransformerParser
AbstractUdpOutboundChannelAdapterSpec<S extends AbstractUdpOutboundChannelAdapterSpec<S>>	A `MessageHandlerSpec` for UDP `MessageHandler`s.
AbstractWebServiceInboundGateway
AbstractWebServiceOutboundGateway	Base class for outbound Web Service-invoking Messaging Gateways.
AbstractXmlTransformer	super class for XmlTransformer
AbstractXmppConnectionAwareEndpoint
AbstractXmppConnectionAwareMessageHandler
AbstractXmppInboundChannelAdapterParser	Base class for XMPP inbound parsers
AbstractXmppOutboundChannelAdapterParser	Base class of XMPP outbound parsers
AbstractXPathMessageSelector	Base class for XPath `MessageSelector` implementations.
AcceptAllFileListFilter<F>	Simple implementation of `FileListFilter` that always returns true.
AcceptOnceCollectionFilter<T>	An implementation of `CollectionFilter` that remembers the elements passed in the previous invocation in order to avoid returning those elements more than once.
AcceptOnceFileListFilter<F>	`FileListFilter` that passes files only one time.
AcknowledgmentCallback	A general abstraction over acknowledgments.
AcknowledgmentCallback.Status
AcknowledgmentCallbackFactory<T>	A factory for creating `AcknowledgmentCallback`s.
AckUtils	Utility methods for acting on `AcknowledgmentCallback` headers.
AdviceMessage<T>	A message implementation that is produced by an advice after successful message handling.
AdviceMessageJacksonDeserializer	The `MessageJacksonDeserializer` implementation for the `AdviceMessage`.
AggregatedXmlMessageValidationException
AggregateMessageDeliveryException	An Exception that encapsulates an aggregated group of Exceptions for use by dispatchers that may try multiple handler invocations within a single dispatch operation.
AggregatingMessageHandler	Aggregator specific implementation of `AbstractCorrelatingMessageHandler`.
Aggregator	Indicates that a method is capable of aggregating messages.
AggregatorAnnotationPostProcessor	Post-processor for the `@Aggregator` annotation.
AggregatorFactoryBean	`FactoryBean` to create an `AggregatingMessageHandler`.
AggregatorParser	Parser for the aggregator element of the integration namespace.
AggregatorSpec	A `CorrelationHandlerSpec` for an `AggregatingMessageHandler`.
AllowListDeserializingConverter	A `Converter` that delegates to a `Deserializer` to convert data in a byte array to an object.
Amqp	Factory class for AMQP components.
AmqpAsyncOutboundGatewaySpec
AmqpBaseInboundChannelAdapterSpec<S extends AmqpBaseInboundChannelAdapterSpec<S>>	The base `MessageProducerSpec` implementation for a `AmqpInboundChannelAdapter`.
AmqpBaseInboundGatewaySpec<S extends AmqpBaseInboundGatewaySpec<S>>	A base `MessagingGatewaySpec` implementation for `AmqpInboundGateway` endpoint options.
AmqpBaseOutboundEndpointSpec<S extends AmqpBaseOutboundEndpointSpec<S,E>,E extends AbstractAmqpOutboundEndpoint>	The base `MessageHandlerSpec` for `AbstractAmqpOutboundEndpoint`s.
AmqpChannelFactoryBean	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.
AmqpChannelParser	Parser for the 'channel' and 'publish-subscribe-channel' elements of the Spring Integration AMQP namespace.
AmqpHeaderMapper	A convenience interface that extends `RequestReplyHeaderMapper`, parameterized with `MessageProperties`.
AmqpInboundChannelAdapter	Adapter that receives Messages from an AMQP Queue, converts them into Spring Integration Messages, and sends the results to a Message Channel.
AmqpInboundChannelAdapter.BatchMode	Defines the payload type when the listener container is configured with consumerBatchEnabled.
AmqpInboundChannelAdapterDMLCSpec	Spec for an inbound channel adapter with a `DirectMessageListenerContainer`.
AmqpInboundChannelAdapterParser	Parser for the AMQP 'inbound-channel-adapter' element.
AmqpInboundChannelAdapterSMLCSpec	Spec for an inbound channel adapter with a `SimpleMessageListenerContainer`.
AmqpInboundChannelAdapterSpec<S extends AmqpInboundChannelAdapterSpec<S,C>,C extends AbstractMessageListenerContainer>	A `MessageProducerSpec` for `AmqpInboundChannelAdapter`s.
AmqpInboundGateway	Adapter that receives Messages from an AMQP Queue, converts them into Spring Integration Messages, and sends the results to a Message Channel.
AmqpInboundGatewayDMLCSpec	Spec for a gateway with a `DirectMessageListenerContainer`.
AmqpInboundGatewayParser	Parser for the AMQP 'inbound-gateway' element.
AmqpInboundGatewaySMLCSpec	Spec for a gateway with a `SimpleMessageListenerContainer`.
AmqpInboundGatewaySpec<S extends AmqpInboundGatewaySpec<S,C>,C extends AbstractMessageListenerContainer>	An `AmqpBaseInboundGatewaySpec` implementation for a `AmqpInboundGateway`.
AmqpInboundPolledChannelAdapterSpec	Spec for a polled AMQP inbound channel adapter.
AmqpMessageChannelSpec<S extends AmqpMessageChannelSpec<S,T>,T extends AbstractAmqpChannel>	An `AmqpPollableMessageChannelSpec` for a message-driven `PointToPointSubscribableAmqpChannel`.
AmqpMessageHeaderErrorMessageStrategy	An `ErrorMessageStrategy` extension that adds the raw AMQP message as a header to the `ErrorMessage`.
AmqpMessageSource	A pollable `MessageSource` for RabbitMQ.
AmqpMessageSource.AmqpAckCallback
AmqpMessageSource.AmqpAckCallbackFactory
AmqpMessageSource.AmqpAckInfo	Information for building an AmqpAckCallback.
AmqpNamespaceHandler	Namespace handler for the AMQP schema.
AmqpOutboundChannelAdapterParser	Parser for the AMQP 'outbound-channel-adapter' element.
AmqpOutboundChannelAdapterSpec	Spec for an outbound AMQP channel adapter
AmqpOutboundEndpoint	Adapter that converts and sends Messages to an AMQP Exchange.
AmqpOutboundEndpointSpec<S extends AmqpOutboundEndpointSpec<S>>	Base spec for outbound AMQP endpoints.
AmqpOutboundGatewayParser	Parser for the AMQP 'outbound-channel-adapter' element.
AmqpOutboundGatewaySpec	Spec for an outbound AMQP gateway.
AmqpPollableMessageChannelSpec<S extends AmqpPollableMessageChannelSpec<S,T>,T extends AbstractAmqpChannel>	A `MessageChannelSpec` for a `AbstractAmqpChannel`s.
AmqpPublishSubscribeMessageChannelSpec	A `AmqpMessageChannelSpec` for `PublishSubscribeAmqpChannel`s.
AnnotatedMethodFilter	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
AnnotationConfigParser	Parser for the `<annotation-config>` element of the integration namespace.
AnnotationConstants	Common value constants for annotation attributes.
AnnotationGatewayProxyFactoryBean	A `GatewayProxyFactoryBean` extension for Java configuration.
AnnotationMetadataAdapter	An `AnnotationMetadata` implementation to expose a metadata by the provided `Map` of attributes.
ApacheCommonsFileTailingMessageProducer	File tailer that delegates to the Apache Commons Tailer.
ApacheMinaFtpEvent	`ApplicationEvent` generated from Apache Mina ftp events.
ApacheMinaFtplet	A listener for FTP events emitted by an Apache Mina ftp server.
ApacheMinaSftpEvent	`ApplicationEvent` generated from Apache Mina sftp events.
ApacheMinaSftpEventListener	A listener for SFTP events emitted by an Apache Mina sshd/sftp server.
ApplicationEventListeningMessageProducer	An inbound Channel Adapter that implements `GenericApplicationListener` and passes Spring `ApplicationEvents` within messages.
ApplicationEventMulticasterParser	Parser for the <application-event-multicaster> element of the integration namespace.
ApplicationEventPublishingMessageHandler	A `MessageHandler` that publishes each `Message` it receives as a `MessagingEvent`.
ArgumentsStrategy
AsyncAmqpOutboundGateway	An outbound gateway where the sending thread is released immediately and the reply is sent on the async template's listener container thread.
AsyncMessagingOperations
AsyncMessagingTemplate
AttributePollingChannelAdapterParser
AttributePollingMessageSource	A `MessageSource` implementation that retrieves the current value of a JMX attribute each time `AbstractMessageSource.receive()` is invoked.
AvroHeaders	Pre-defined names and prefixes for Apache Avro related headers.
BarrierMessageHandler	A message handler that suspends the thread until a message with corresponding correlation is passed into the `trigger` method or the timeout occurs.
BarrierParser	Parser for `<int:barrier/>`.
BarrierSpec	A `MessageHandlerSpec` for the `BarrierMessageHandler`.
BaseHttpInboundEndpoint	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 `AbstractHttpRequestExecutingMessageHandler`s.
BaseIntegrationFlowDefinition<B extends BaseIntegrationFlowDefinition<B>>	The `Builder` pattern implementation for the EIP-method chain.
BaseIntegrationFlowDefinition.ReplyProducerCleaner
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 `AbstractWebServiceOutboundGateway`s.
BasicMessageGroupStore	Defines a minimal message group store with basic capabilities.
BeanDefinitionRegisteringParser	Simple strategy interface for parsers that are responsible for parsing an element, creating a bean definition, and then registering the bean.
BeanFactoryChannelResolver	`DestinationResolver` implementation based on a Spring `BeanFactory`.
BeanFactoryTypeConverter
BeanNameMessageProcessor<T>	An "artificial" `MessageProcessor` for lazy-load of target bean by its name.
BeanPropertyParameterSource
BeanPropertyParameterSourceFactory
BeanPropertySqlParameterSourceFactory	A default implementation of `SqlParameterSourceFactory` which creates an `SqlParameterSource` to reference bean properties in its input.
BinaryToMessageConverter
BooleanTestXPathMessageSelector	Boolean XPath testing `MessageSelector`.
BoundRabbitChannelAdvice	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.
BridgeFrom	Messaging Annotation to mark a `Bean` method for a `MessageChannel` to produce a `BridgeHandler` and Consumer Endpoint.
BridgeFromAnnotationPostProcessor	Post-processor for the `@BridgeFrom` annotation.
BridgeHandler	A simple MessageHandler implementation that passes the request Message directly to the output channel without modifying it.
BridgeParser	Parser for the <bridge> element.
BridgeTo	Messaging Annotation to mark a `Bean` method for a `MessageChannel` to produce a `BridgeHandler` and Consumer Endpoint.
BridgeToAnnotationPostProcessor	Post-processor for the `@BridgeTo` annotation.
BroadcastCapableChannel	A `SubscribableChannel` variant for implementations with broadcasting capabilities.
BroadcastingDispatcher	A broadcasting dispatcher implementation.
BroadcastPublishSubscribeSpec	An `IntegrationComponentSpec` for configuring sub-flow subscribers on the provided `BroadcastCapableChannel`.
ByteArrayCrLfSerializer	Reads data in an InputStream to a byte[]; data must be terminated by \r\n (not included in resulting byte[]).
ByteArrayElasticRawDeserializer	A deserializer that uses a `ByteArrayOutputStream` instead of a fixed buffer, allowing the buffer to grow as needed.
ByteArrayLengthHeaderSerializer	Reads data in an InputStream to a byte[]; data must be preceded by a binary length (network byte order, not included in resulting byte[]).
ByteArrayLfSerializer
ByteArrayRawSerializer	A byte array (de)serializer that does nothing with the payload; sends it raw.
ByteArraySingleTerminatorSerializer	Reads data in an InputStream to a byte[]; data must be terminated by a single byte (not included in resulting byte[]).
ByteArrayStxEtxSerializer	Reads data in an InputStream to a byte[]; data must be prefixed by <stx> and terminated by <etx> (not included in resulting byte[]).
BytesMessageMapper	An `OutboundMessageMapper` and `InboundMessageMapper` that maps to/from `byte[]`.
ByteStreamReadingMessageSource	A pollable source for receiving bytes from an `InputStream`.
ByteStreamWritingMessageHandler	A `MessageHandler` that writes a byte array to an `OutputStream`.
CacheListeningMessageProducer	An inbound endpoint that listens to a GemFire region for events and then publishes Messages to a channel.
CacheRequestHandlerAdvice	The `AbstractRequestHandlerAdvice` implementation for caching `AbstractReplyProducingMessageHandler.RequestHandler#handleRequestMessage(Message)` results.
CacheWritingMessageHandler	A `MessageHandler` implementation that writes to a GemFire Region.
CachingClientConnectionFactory	Connection factory that caches connections from the underlying target factory.
CachingSessionFactory<F>	A `SessionFactory` implementation that caches Sessions for reuse without requiring reconnection each time the Session is retrieved from the factory.
CallerBlocksPolicy	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.
Candidate	Interface that defines the contract for candidates to participate in a leader election.
ChainFileListFilter<F>	The `CompositeFileListFilter` extension which chains the result of the previous filter to the next one.
ChainParser	Parser for the <chain> element.
ChannelAccessPolicy	Interface to encapsulate `ConfigAttribute`s for secured channel send and receive operations.
ChannelInitializer	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.
ChannelInitializer.AutoCreateCandidatesCollector
ChannelInterceptorParser	A helper class for parsing the sub-elements of a channel's interceptors element.
ChannelInvocation	Secured object for `ChannelSecurityInterceptor`.
ChannelMessageStore	A marker interface that indicates this message store has optimizations for use in a `QueueChannel`.
ChannelMessageStorePreparedStatementSetter	Callback to be used with the `JdbcChannelMessageStore`.
ChannelMessageStoreQueryProvider	Common interface used in order to configure the `JdbcChannelMessageStore` to provide database-specific queries.
ChannelPublishingJmsMessageListener	JMS MessageListener that converts a JMS Message into a Spring Integration Message and sends that Message to a channel.
ChannelPurger	A utility class for purging `Messages` from one or more `QueueChannels`.
ChannelResolverUtils	Channel resolution utilities.
Channels
ChannelSecurityInterceptor	An AOP interceptor that enforces authorization for MessageChannel send and/or receive calls.
ChannelSecurityInterceptorBeanPostProcessor	A `BeanPostProcessor` that proxies `MessageChannel`s to apply a `ChannelSecurityInterceptor`.
ChannelSecurityMetadataSource	The `SecurityMetadataSource` implementation for secured `MessageChannel`s.
ChannelUtils	Channel utilities.
CharacterStreamReadingMessageSource	A pollable source for `Readers`.
CharacterStreamWritingMessageHandler	A `MessageHandler` that writes characters to a `Writer`.
ChatMessageInboundChannelAdapterParser	Parser for the XMPP 'inbound-channel-adapter' element.
ChatMessageListeningEndpoint	This component logs in as a user and forwards any messages to that user on to downstream components.
ChatMessageOutboundChannelAdapterParser	Parser for the XMPP 'outbound-channel-adapter' element
ChatMessageSendingMessageHandler	MessageHandler that sends an XMPP Chat Message.
ClaimCheckInParser	Parser for the <claim-check-in/> element.
ClaimCheckInTransformer	Transformer that stores a Message and returns a new Message whose payload is the id of the stored Message.
ClaimCheckOutParser	Parser for the <claim-check-out/> element.
ClaimCheckOutTransformer	Transformer that accepts a Message whose payload is a UUID and retrieves the Message associated with that id from a MessageStore if available.
ClassUtils
ClientCallback<C,T>	`RemoteFileTemplate` callback with the underlying client instance providing access to lower level methods.
ClientCallbackWithoutResult<C>	`RemoteFileTemplate` callback with the underlying client instance providing access to lower level methods where no result is returned.
ClientHttpResponseBodyExtractor	The `BodyExtractor` identity function implementation which just returns the provided `ClientHttpResponse`.
ClientModeCapable	Edpoints implementing this interface are capable of running in client-mode.
ClientModeConnectionManager	Intended to be run on a schedule, simply gets the connection from a client connection factory each time it is run.
ClientRSocketConnector	A client `AbstractRSocketConnector` extension to the RSocket connection.
ClientStompEncoder	A `StompEncoder` extension to prepare a message for sending/receiving before/after encoding/decoding when used from WebSockets client side.
ClientWebSocketContainer	The `IntegrationWebSocketContainer` implementation for the `client` Web-Socket connection.
ClientWebSocketContainerParser	The `AbstractSingleBeanDefinitionParser` implementation for the `<websocket:client-container/>` element.
CloseableIterator<E>	A `CloseableIterator` is intended to be used when it may hold resources (such as file or socket handles).
Codec	Interface for classes that perform both encode (serialize) and decode (deserialize) on multiple classes.
CodecMessageConverter	A `MessageConverter` that delegates to a `Codec` to convert
CollectionArgumentResolver	A `HandlerMethodArgumentResolver` implementation for `Collection`, `Iterator` or `array` `MethodParameter`.
CollectionFilter<T>	Base strategy for filtering out a subset of a Collection of elements.
CommonSocketOptions
ComponentsRegistration	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.
CompositeCodec	A Codec that can delegate to one out of many Codecs, each mapped to a class.
CompositeExecutor	An `Executor` that encapsulates two underlying executors.
CompositeFileListFilter<F>	Simple `FileListFilter` that predicates its matches against all of the configured `FileListFilter`.
CompositeKryoRegistrar	A `KryoRegistrar` that delegates and validates registrations across all components.
CompositeMessageHandler	Classes implementing this interface delegate to a list of handlers.
CompositeMessageHandlerNode	Represents a composite message handler.
CompositeMessageHandlerNode.InnerHandler
CompoundTrigger	A `Trigger` that delegates the `CompoundTrigger.nextExecutionTime(TriggerContext)` to one of two Triggers.
CompoundTriggerAdvice	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.
ConcurrentMetadataStore	Supports atomic updates to values in the store.
ConfigurableCompositeMessageConverter	A `CompositeMessageConverter` extension with some default `MessageConverter`s which can be overridden with the given converters or added in the end of target `converters` collection.
ConfigurableMongoDbMessageStore	An alternate MongoDB `MessageStore` and `MessageGroupStore` which allows the user to configure the instance of `MongoTemplate`.
ConnectionFactory	A factory used to create TcpConnection objects.
ConsoleInboundChannelAdapterParser	Parser for the <stdin-channel-adapter> element.
ConsoleOutboundChannelAdapterParser	Parser for the "stdout-" and "stderr-channel-adapter" elements.
ConsumerEndpointFactoryBean	The `FactoryBean` implementation for `AbstractEndpoint` population.
ConsumerEndpointSpec<S extends ConsumerEndpointSpec<S,H>,H extends MessageHandler>	A `EndpointSpec` for consumer endpoints.
ConsumerStopAction	Action to take regarding subscrptions when consumer stops.
ContentEnricher	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.
Context	Interface that defines the context for candidate leadership.
ContinuousQueryMessageProducer	Responds to a Gemfire continuous query (set using the #query field) that is constantly evaluated against a cache `Region`.
ControlBusMethodFilter	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`.
ControlBusParser
ConverterParser
ConvertingBytesMessageMapper	The `BytesMessageMapper` implementation to delegate to/from `Message` conversion into the provided `MessageConverter`.
CorrelatingMessageBarrier	This Endpoint serves as a barrier for messages that should not be processed yet.
CorrelationHandlerSpec<S extends CorrelationHandlerSpec<S,H>,H extends AbstractCorrelatingMessageHandler>	A `MessageHandlerSpec` for an `AbstractCorrelatingMessageHandler`.
CorrelationStrategy	Strategy for determining how messages can be correlated.
CorrelationStrategy	Indicates that a given method is capable of determining the correlation key of a message sent as parameter.
CorrelationStrategyFactoryBean	Convenience factory for XML configuration of a `CorrelationStrategy`.
CounterFacade
CqEventType	Enumeration of GemFire Continuous Query Event Types
CrossOrigin	The mapping to permit cross origin requests (CORS) for `HttpRequestHandlingEndpointSupport`.
CuratorFrameworkFactoryBean	A Spring-friendly way to build a `CuratorFramework` and implementing `SmartLifecycle`.
DatagramPacketMessageMapper	Message Mapper for converting to and from UDP DatagramPackets.
DecodingTransformer<T>	`AbstractPayloadTransformer` that delegates to a codec to decode the payload from a byte[].
Default	Indicates that the class member has some default meaning.
DefaultAggregateHeadersFunction	The `Function` implementation for a default headers merging in the aggregator component.
DefaultAggregatingMessageGroupProcessor	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.
DefaultAmqpHeaderMapper	Default implementation of `AmqpHeaderMapper`.
DefaultCandidate	Simple `Candidate` for leadership.
DefaultChannelAccessPolicy	Creates the `ConfigAttribute`s for secured channel send and receive operations based on simple String values.
DefaultDatatypeChannelMessageConverter	Default message converter for datatype channels.
DefaultDirectoryScanner	Default directory scanner and base class for other directory scanners.
DefaultErrorMessageStrategy	A simple `ErrorMessageStrategy` implementations which produces a error message with original message if the `AttributeAccessor` has `ErrorMessageUtils.INPUT_MESSAGE_CONTEXT_KEY` attribute.
DefaultFileNameGenerator	Default implementation of the filename generator strategy.
DefaultFtpSessionFactory	Default implementation of FTP SessionFactory.
DefaultFtpsSessionFactory	SessionFactory for FTPS.
DefaultHeaderChannelRegistry	Converts a channel to a name, retaining a reference to the channel keyed by the name.
DefaultHttpHeaderMapper	Default `HeaderMapper` implementation for HTTP.
DefaultInboundChannelAdapterParser	Parser for the <inbound-channel-adapter/> element.
DefaultJmsHeaderMapper	Default implementation of `JmsHeaderMapper`.
DefaultJpaOperations	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.
DefaultLeaderEventPublisher	Default implementation of `LeaderEventPublisher`.
DefaultLockRegistry	Default implementation of `LockRegistry` which uses Masked Hashcode algorithm to obtain locks.
DefaultLockRepository	The default implementation of the `LockRepository` based on the table from the script presented in the `org/springframework/integration/jdbc/schema-*.sql`.
DefaultMailHeaderMapper	Maps an inbound `MimeMessage` to a `Map`.
DefaultMBeanAttributeFilter
DefaultMBeanObjectConverter
DefaultMessageBuilderFactory
DefaultMessageConverter	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.
DefaultMessageSplitter	The default Message Splitter implementation.
DefaultMqttPahoClientFactory	Creates a default `MqttClient` and a set of options as configured.
DefaultMqttPahoClientFactory.Will
DefaultMultipartFileReader	`MultipartFileReader` implementation that reads the `MultipartFile` content directly into a new `MultipartFile` instance that is not restricted to the HTTP request scope.
DefaultOutboundChannelAdapterParser	Parser for the <outbound-channel-adapter/> element.
DefaultPahoMessageConverter	Default implementation for mapping to/from Messages.
DefaultRouterParser	Parser for the <router/> element.
DefaultScriptExecutor	Default implementation of the `AbstractScriptExecutor`.
DefaultScriptVariableGenerator	A default `ScriptVariableGenerator` implementation; used by script processors.
DefaultSessionFactoryLocator<F>	The default implementation of `SessionFactoryLocator` using a simple map lookup and an optional default to fall back on.
DefaultSftpSessionFactory	Factory for creating `SftpSession` instances.
DefaultSoapHeaderMapper	A `HeaderMapper` implementation for mapping to and from a SoapHeader.
DefaultTcpNetConnectionSupport	Default implementation of `TcpNetConnectionSupport`.
DefaultTcpNetSocketFactorySupport	Implementation of TcpSocketFactorySupport for non-SSL sockets `ServerSocket` and `Socket`.
DefaultTcpNetSSLSocketFactorySupport	Implementation of `TcpSocketFactorySupport` for SSL sockets `SSLServerSocket` and `SSLSocket`.
DefaultTcpNioConnectionSupport	Implementation of `TcpNioConnectionSupport` for non-SSL NIO connections.
DefaultTcpNioSSLConnectionSupport	Implementation of `TcpNioConnectionSupport` for SSL NIO connections.
DefaultTcpSocketSupport	Default implementation of `TcpSocketSupport`; makes no changes to sockets.
DefaultTcpSSLContextSupport	Default implementation of `TcpSSLContextSupport`; uses a 'TLS' (by default) `SSLContext`, initialized with 'JKS' keystores, managed by 'SunX509' Key and Trust managers.
DefaultTransactionSynchronizationFactory	Default implementation of `TransactionSynchronizationFactory` which takes an instance of `TransactionSynchronizationProcessor` allowing you to create a `TransactionSynchronization` using {`DefaultTransactionSynchronizationFactory.create(Object)` method.
DefaultXmlPayloadConverter	Default implementation of `XmlPayloadConverter`.
DefaultXmppHeaderMapper	Default implementation of `XmppHeaderMapper`.
DelayerEndpointSpec	A `ConsumerEndpointSpec` for a `DelayHandler`.
DelayerParser	Parser for the <delayer> element.
DelayHandler	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.
DelayHandler.DelayedMessageWrapper
DelayHandlerManagement
DelegatingMessageGroupProcessor	The `MessageGroupProcessor` implementation with delegation to the provided `delegate` and optional aggregation for headers.
DelegatingSessionFactory<F>	`SessionFactory` that delegates to a `SessionFactory` retrieved from a `SessionFactoryLocator`.
DerbyChannelMessageStoreQueryProvider
DirectChannel	A channel that invokes a single subscriber for each sent Message.
DirectChannelSpec
DirectMessageListenerContainerSpec	Spec for a `DirectMessageListenerContainer`.
DirectoryCreatedEvent	An event emitted when a directory is created.
DirectoryCreatedEvent	An event emitted when a directory is created.
DirectoryScanner	Strategy for scanning directories.
DiscardAwareFileListFilter<F>	The `FileListFilter` modification which can accept a `Consumer` which can be called when the filter discards the file.
DiscardingMessageHandler	Classes implementing this interface are capable of discarding messages.
DiscardingMessageHandlerNode	Represents an endpoint that has a discard channel.
DomResultFactory
DomSourceFactory	`SourceFactory` implementation which supports creation of a `DOMSource` from a `Document`, `File` or `String` payload.
DslIntegrationConfigurationInitializer	The Java DSL Integration infrastructure `beanFactory` initializer.
DynamicExpression	An implementation of `Expression` that delegates to an `ExpressionSource` for resolving the actual Expression instance per-invocation at runtime.
DynamicJmsTemplate
DynamicPeriodicTrigger	This is a dynamically changeable `Trigger`.
EmbeddedJsonHeadersMessageMapper	For outbound messages, uses a message-aware Jackson object mapper to render the message as JSON.
EnableIntegration	The main configuration annotation to enable Spring Integration infrastructure: - Registers some built-in beans; - Adds several `BeanFactoryPostProcessor`s; - Adds several `BeanPostProcessor`s; - Adds annotations processors.
EnableIntegrationGraphController	Enables the `IntegrationGraphController` if `org.springframework.web.servlet.DispatcherServlet` or `org.springframework.web.reactive.DispatcherHandler` is present in the classpath.
EnableIntegrationManagement	Enables default configuring of management in Spring Integration components in an existing application.
EnableIntegrationMBeanExport	Enables default exporting for Spring Integration components in an existing application, as well as well all `@ManagedResource` annotated beans.
EnableMessageHistory	Enables `MessageHistory` for Integration components.
EnablePublisher	Provides the registration for the `PublisherAnnotationBeanPostProcessor` to allow the use of the `Publisher` annotation.
EncodingPayloadTransformer<T>	`AbstractPayloadTransformer` that delegates to a codec to encode the payload into a byte[].
EndpointId	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.
EndpointNode	Base class for all endpoints.
EndpointSpec<S extends EndpointSpec<S,F,H>,F extends BeanNameAware & FactoryBean<? extends AbstractEndpoint>,H>	An `IntegrationComponentSpec` for endpoints.
EndpointUtils	Utility methods for messaging endpoints.
EnricherParser	Parser for the 'enricher' element.
EnricherSpec	A `ConsumerEndpointSpec` extension for the `ContentEnricher`.
EqualsResultMatcher<U>	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.
ErrorCapableCompositeMessageHandlerNode	Represents a composite message handler that can emit error messages (pollable endpoint).
ErrorCapableDiscardingMessageHandlerNode	Represents an endpoint that has a discard channel and can emit errors (pollable endpoint).
ErrorCapableEndpointNode	Represents nodes that can natively handle errors.
ErrorCapableMessageHandlerNode	Represents a message handler that can produce errors (pollable).
ErrorCapableNode	Nodes implementing this interface are capable of emitting errors.
ErrorCapableRoutingNode	Represents an endpoint that can route to multiple channels and can emit errors (pollable endpoint).
ErrorHandlingTaskExecutor	A `TaskExecutor` implementation that wraps an existing Executor instance in order to catch any exceptions.
ErrorMessageExceptionTypeRouter	A Message Router that resolves the target `MessageChannel` for messages whose payload is a `Throwable`.
ErrorMessageExceptionTypeRouterParser	Parser for the <exception-type-router/> element.
ErrorMessageJacksonDeserializer	The `MessageJacksonDeserializer` implementation for the `ErrorMessage`.
ErrorMessagePublisher	The component which can be used as general purpose of errors publishing.
ErrorMessageSendingRecoverer	A `RecoveryCallback` that sends the final throwable as an `ErrorMessage` after retry exhaustion.
ErrorMessageSendingRecoverer.RetryExceptionNotAvailableException
ErrorMessageStrategy	A strategy to build an `ErrorMessage` based on the provided `Throwable` and `AttributeAccessor` as a context.
ErrorMessageUtils	Utilities for building error messages.
EventDrivenConsumer	Message Endpoint that connects any `MessageHandler` implementation to a `SubscribableChannel`.
EventInboundChannelAdapterParser
EventNamespaceHandler	Namespace handler for Spring Integration's 'event' namespace.
EventOutboundChannelAdapterParser
EventType	Enumeration of GemFire event types.
ExecutorChannel	An implementation of `MessageChannel` that delegates to an instance of `UnicastingDispatcher` which in turn delegates all dispatching invocations to an `Executor`.
ExecutorChannelInterceptorAware	The `InterceptableChannel` extension for the cases when the `ExecutorChannelInterceptor`s may have reason (e.g.
ExecutorChannelSpec
ExpirableLockRegistry	A `LockRegistry` implementing this interface supports the removal of aged locks that are not currently locked.
ExpressionArgumentsStrategy
ExpressionCapable	Components that implement this interface are capable of supporting a primary SpEL expression as part of their configuration.
ExpressionCommandMessageProcessor	A MessageProcessor implementation that expects an Expression or expressionString as the Message payload.
ExpressionControlBusFactoryBean	FactoryBean for creating `MessageHandler` instances to handle a message as a SpEL expression.
ExpressionEvalMap	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.
ExpressionEvalMap.ComponentsEvaluationCallback	The `ExpressionEvalMap.EvaluationCallback` implementation which evaluates an expression using the provided `context`, `root` and `returnType` variables.
ExpressionEvalMap.EvaluationCallback	Implementations of this interface can be provided to build 'on demand `ExpressionEvalMap.get(Object)` logic' for `ExpressionEvalMap`.
ExpressionEvalMap.ExpressionEvalMapBuilder	The builder class to instantiate `ExpressionEvalMap`.
ExpressionEvalMap.ExpressionEvalMapComponentsBuilder
ExpressionEvalMap.ExpressionEvalMapFinalBuilder
ExpressionEvaluatingCorrelationStrategy	`CorrelationStrategy` implementation that evaluates an expression.
ExpressionEvaluatingHeaderValueMessageProcessor<T>
ExpressionEvaluatingMessageGroupProcessor	A `MessageGroupProcessor` implementation that evaluates a SpEL expression.
ExpressionEvaluatingMessageHandler	A `MessageHandler` that evaluates the provided `Expression` expecting a void return.
ExpressionEvaluatingMessageListProcessor	A base class for aggregators that evaluates a SpEL expression with the message list as the root object within the evaluation context.
ExpressionEvaluatingMessageProcessor<T>	A `MessageProcessor` implementation that evaluates a SpEL expression with the Message itself as the root object within the evaluation context.
ExpressionEvaluatingMessageSource<T>
ExpressionEvaluatingParameterSourceFactory	A SpEL expression based `ParameterSourceFactory` implementation.
ExpressionEvaluatingReleaseStrategy	A `ReleaseStrategy` that evaluates an expression.
ExpressionEvaluatingRequestHandlerAdvice	Used to advise `MessageHandler`s.
ExpressionEvaluatingRequestHandlerAdvice.MessageHandlingExpressionEvaluatingAdviceException
ExpressionEvaluatingRouter	A Message Router implementation that evaluates the specified SpEL expression.
ExpressionEvaluatingRoutingSlipRouteStrategy	The `Expression` based `RoutingSlipRouteStrategy` implementation.
ExpressionEvaluatingRoutingSlipRouteStrategy.RequestAndReply
ExpressionEvaluatingSelector	A `MessageSelector` implementation that evaluates a SpEL expression.
ExpressionEvaluatingSplitter	A Message Splitter implementation that evaluates the specified SpEL expression.
ExpressionEvaluatingSqlParameterSourceFactory	An implementation of `SqlParameterSourceFactory` which creates an `SqlParameterSource` that evaluates Spring EL expressions.
ExpressionEvaluatingTransactionSynchronizationProcessor	This implementation of `TransactionSynchronizationFactory` allows you to configure SpEL expressions, with their execution being coordinated (synchronized) with a transaction - see `TransactionSynchronization`.
ExpressionEvaluatingTransformer	A Message Transformer implementation that evaluates the specified SpEL expression.
ExpressionFactoryBean	FactoryBean for creating Expression instances.
ExpressionFileListFilter<F>	A SpEL expression based `AbstractFileListFilter` implementation.
ExpressionMessageProducerSupport	A `MessageProducerSupport` sub-class that provides ExpressionMessageProducerSupport.payloadExpression evaluation with result as a payload for Message to send.
ExpressionSource	Strategy interface for retrieving Expressions.
ExpressionUtils	Utility class with static methods for helping with evaluation of SpEL expressions.
FailoverClientConnectionFactory	Given a list of connection factories, serves up `TcpConnection`s that can iterate over a connection from each factory until the write succeeds or the list is exhausted.
Feed	The Spring Integration Feed components Factory.
FeedEntryMessageSource	This implementation of `MessageSource` will produce individual `SyndEntry`s for a feed identified with the 'feedUrl' attribute.
FeedEntryMessageSourceSpec	A `MessageSourceSpec` for a `FeedEntryMessageSource`.
FeedInboundChannelAdapterParser	Handles parsing the configuration for the feed inbound-channel-adapter.
FeedNamespaceHandler	NamespaceHandler for the feed module.
FileAggregatingMessageGroupProcessor	An `AbstractAggregatingMessageGroupProcessor` implementation for file content collecting previously splitted by the `FileSplitter` with the `markers` option turned on.
FileAggregator	A convenient component to utilize a `FileSplitter.FileMarker`-based aggregation logic.
FileCopyingMultipartFileReader	`MultipartFileReader` implementation that copies the MultipartFile's content to a new temporary File in the specified directory.
FileExistsMode	When writing file, this enumeration indicates what action shall be taken in case the destination file already exists.
FileHeaders	Pre-defined header names to be used when storing or retrieving File-related values to/from integration Message Headers.
FileInboundChannelAdapterParser	Parser for the <inbound-channel-adapter> element of the 'file' namespace.
FileInboundChannelAdapterSpec	A `MessageSourceSpec` for a `FileReadingMessageSource`.
FileInfo<F>	Represents a remote file info - an abstraction over the underlying implementation.
FileIntegrationEvent
FileKryoRegistrar	A `KryoRegistrar` used to validateRegistration a File serializer.
FileListFilter<F>	Strategy interface for filtering a group of files.
FileListFilterFactoryBean
FileLocker	A FileLocker is a strategy that can ensure that files are only processed a single time.
FileMarkerReleaseStrategy	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.
FileNameGenerator	Strategy interface for generating a file name from a message.
FileNamespaceHandler	Namespace handler for Spring Integration's 'file' namespace.
FileOutboundChannelAdapterParser	Parser for the <outbound-channel-adapter/> element of the 'file' namespace.
FileOutboundGatewayParser	Parser for the 'outbound-gateway' element of the file namespace.
FileParserUtils
FileReadingMessageSource	`MessageSource` that creates messages from a file system directory.
FileReadingMessageSource.WatchEventType
FileReadingMessageSourceFactoryBean
Files	The Spring Integration File components Factory.
FileSerializer	A custom Kryo `Serializer` for serializing File payloads.
FileServerEvent	Base class for file server events.
FileSplitter	The `AbstractMessageSplitter` implementation to split the `File` Message payload to lines.
FileSplitter.FileMarker
FileSplitter.FileMarker.Mark
FileSplitterParser
FileSplitterSpec	The `MessageHandlerSpec` for the `FileSplitter`.
FileSystemMarkerFilePresentFileListFilter	File system implementation of `AbstractMarkerFilePresentFileListFilter`.
FileSystemPersistentAcceptOnceFileListFilter
FileTailInboundChannelAdapterFactoryBean
FileTailInboundChannelAdapterParser
FileTailingMessageProducerSupport	Base class for file tailing inbound adapters.
FileTailingMessageProducerSupport.FileTailingEvent
FileTailingMessageProducerSupport.FileTailingIdleEvent
FileToByteArrayTransformer	A payload transformer that copies a File's contents to a byte array.
FileToByteArrayTransformerParser	Parser for the <file-to-bytes-transformer> element.
FileToStringTransformer	A payload transformer that copies a File's contents to a String.
FileToStringTransformerParser	Parser for the <file-to-string-transformer> element.
FileTransferringMessageHandler<F>	A `MessageHandler` implementation that transfers files to a remote server.
FileTransferringMessageHandlerSpec<F,S extends FileTransferringMessageHandlerSpec<F,S>>	The `MessageHandlerSpec` for the `FileTransferringMessageHandler`.
FileUtils	Utilities for operations on Files.
FileWritingMessageHandler	A `MessageHandler` implementation that writes the Message payload to a file.
FileWritingMessageHandler.FlushPredicate	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.
FileWritingMessageHandler.MessageFlushPredicate	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.
FileWritingMessageHandlerFactoryBean	Factory bean used to create `FileWritingMessageHandler`s.
FileWritingMessageHandlerSpec	The `MessageHandlerSpec` for the `FileWritingMessageHandler`.
FileWrittenEvent	An event that is emitted when a file is written.
FileWrittenEvent	An event that is emitted when a file is written.
Filter	Indicates that a method is capable of playing the role of a Message Filter.
FilterAnnotationPostProcessor	Post-processor for Methods annotated with `@Filter`.
FilterEndpointSpec	A `ConsumerEndpointSpec` implementation for the `MessageFilter`.
FilterFactoryBean	Factory bean for creating a Message Filter.
FilterParser	Parser for the <filter/> element.
FixedMethodFilter	A `MethodFilter` implementation that will always return the same Method instance within a single-element list if it is present in the candidate list.
FixedSubscriberChannel	Specialized `SubscribableChannel` for a single final subscriber set up during bean instantiation (unlike other `SubscribableChannel`s where the `MessageHandler` is subscribed when the endpoint is started).
FixedSubscriberChannelBeanFactoryPostProcessor	Used to post process candidates for `FixedSubscriberChannel` `MessageHandler`s.
FixedSubscriberChannelPrototype	An "artificial" `MessageChannel` implementation which will be unwrapped to the `FixedSubscriberChannel` on the bean registration phase.
FluxAggregatorMessageHandler	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.
FluxMessageChannel	The `AbstractMessageChannel` implementation for the Reactive Streams `Publisher` based on the Project Reactor `Flux`.
FluxMessageChannelSpec
Ftp	The factory for FTP components.
FtpFileInfo	A `FileInfo` implementation for FTP/FTPS.
FtpInboundChannelAdapterParser	Parser for the FTP 'inbound-channel-adapter' element.
FtpInboundChannelAdapterSpec	A `RemoteFileInboundChannelAdapterSpec` for an `FtpInboundFileSynchronizingMessageSource`.
FtpInboundFileSynchronizer	An implementation of `AbstractInboundFileSynchronizer` for FTP.
FtpInboundFileSynchronizingMessageSource	A `MessageSource` implementation for FTP.
FtpMessageHandler	The FTP specific `FileTransferringMessageHandler` extension.
FtpMessageHandlerSpec	A `FileTransferringMessageHandlerSpec` for FTP.
FtpNamespaceHandler	Provides namespace support for using FTP
FtpOutboundChannelAdapterParser	Parser for FTP Outbound Channel Adapters.
FtpOutboundGateway	Outbound Gateway for performing remote file operations via FTP/FTPS.
FtpOutboundGatewayParser
FtpOutboundGatewaySpec	A `RemoteFileOutboundGatewaySpec` for FTP.
FtpPersistentAcceptOnceFileListFilter	Persistent file list filter using the server's file timestamp to detect if we've already 'seen' this file.
FtpRegexPatternFileListFilter	Implementation of `AbstractRegexPatternFileListFilter` for FTP.
FtpRemoteFileTemplate	FTP version of `RemoteFileTemplate` providing type-safe access to the underlying FTPClient object.
FtpRemoteFileTemplate.ExistsMode	The `FtpRemoteFileTemplate.exists(String)` operation mode.
FtpRequestEvent	Base class for all events having an `FtpRequest`.
FtpSession	Implementation of `Session` for FTP.
FtpSimplePatternFileListFilter	Implementation of `AbstractSimplePatternFileListFilter` for FTP.
FtpStreamingInboundChannelAdapterParser
FtpStreamingInboundChannelAdapterSpec	A `RemoteFileStreamingInboundChannelAdapterSpec` for a `FtpStreamingMessageSource`.
FtpStreamingMessageSource	Message source for streaming FTP remote file contents.
FtpSystemMarkerFilePresentFileListFilter	FTP implementation of `AbstractMarkerFilePresentFileListFilter`.
FunctionExpression<S>	An `Expression` that simply invokes `Function.apply(Object)` on its provided `Function`.
FunctionIterator<T,V>	An `Iterator` implementation to convert each item from the target `FunctionIterator.iterator` to a new object applying the `FunctionIterator.function` on `FunctionIterator.next()`.
Gateway	Indicates that an interface method is capable of mapping its parameters to a message or message payload.
GatewayEndpointSpec	A `ConsumerEndpointSpec` implementation for a mid-flow `GatewayMessageHandler`.
GatewayHeader	Provides the message header `value` or `expression`.
GatewayMessageHandler	The `AbstractReplyProducingMessageHandler` implementation for mid-flow Gateway.
GatewayMethodMetadata	Represents the metadata associated with a Gateway method.
GatewayParser	Parser for the <gateway/> element.
GatewayProxyFactoryBean	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.
GatewayProxySpec	A builder for the `GatewayProxyFactoryBean` options when `MessagingGateway` on the service interface cannot be declared.
GaugeFacade
GemfireCqInboundChannelAdapterParser
GemfireInboundChannelAdapterParser
GemfireIntegrationNamespaceHandler
GemfireLockRegistry	Implementation of `LockRegistry` providing a distributed lock using Gemfire.
GemfireMessageStore	Gemfire implementation of the key/value style `MessageStore` and `MessageGroupStore`
GemfireMetadataStore	Gemfire implementation of `ListenableMetadataStore`.
GemfireOutboundChannelAdapterParser
GeneralSftpException	Simple runtime exception to wrap an SftpException.
GenericEndpointSpec<H extends MessageHandler>	A `ConsumerEndpointSpec` for a `MessageHandler` implementations.
GenericHandler<P>	A functional interface to specify `MessageHandler` logic with Java 8 Lambda expression:
GenericMessageJacksonDeserializer	The `MessageJacksonDeserializer` implementation for the `GenericMessage`.
GenericSelector<S>	Generic (lambda) strategy interface for selector.
GenericTransformer<S,T>	Generic (lambda) strategy interface for transformer.
GlobalChannelInterceptor	`ChannelInterceptor` components with this annotation will be applied as global channel interceptors using the provided `patterns` to match channel names.
GlobalChannelInterceptorInitializer	The `IntegrationConfigurationInitializer` to populate `GlobalChannelInterceptorWrapper` for `ChannelInterceptor`s marked with `GlobalChannelInterceptor` annotation.
GlobalChannelInterceptorParser	Parser for 'channel-interceptor' elements.
GlobalChannelInterceptorProcessor	This class applies global interceptors (`<channel-interceptor>` or `@GlobalChannelInterceptor`) to message channels beans.
GlobalChannelInterceptorWrapper
GlobalWireTapParser	Parser for the top level 'wire-tap' element
Graph	This object can be exposed, for example, as a JSON object over HTTP.
GroovyAwareScriptExecutingProcessorFactory	The factory to create `GroovyScriptExecutingMessageProcessor` instances if provided `language == "groovy"`, otherwise delegates to the super class.
GroovyCommandMessageProcessor
GroovyControlBusFactoryBean	FactoryBean for creating `MessageHandler` instances to handle a message as a Groovy Script.
GroovyControlBusParser	Parser for the <groovy:control-bus/> element.
GroovyIntegrationConfigurationInitializer	The Groovy Module Integration infrastructure `beanFactory` initializer.
GroovyNamespaceHandler
GroovyScriptExecutingMessageProcessor	The `MessageProcessor` implementation to evaluate Groovy scripts.
GroovyScriptParser	Parser for the <groovy:script/> element.
GroupConditionProvider	A contract which can be implemented on the `ReleaseStrategy` and used in the `AbstractCorrelatingMessageHandler` to populate the provided group condition supplier.
H2ChannelMessageStoreQueryProvider
HandleMessageAdvice	The marker `MethodInterceptor` interface extension to distinguish advices for some reason.
HandleMessageAdviceAdapter	A `HandleMessageAdvice` implementation with a plain delegation to the provided `MethodInterceptor`.
HeadDirectoryScanner	A custom scanner that only returns the first `maxNumberOfFiles` elements from a directory listing.
HeaderAttributeCorrelationStrategy	Default implementation of `CorrelationStrategy`.
HeaderChannelRegistry	Implementations convert a channel to a name, retaining a reference to the channel keyed by the name.
HeaderEnricher	A Transformer that adds statically configured header values to a Message.
HeaderEnricherParserSupport	Base support class for 'header-enricher' parsers.
HeaderEnricherSpec	An `IntegrationComponentSpec` for a `HeaderEnricher`.
HeaderFilter	Transformer that removes Message headers.
HeaderFilterParser	Parser for the 'header-filter' element.
HeaderMapper<T>	Generic strategy interface for mapping `MessageHeaders` to and from other types of objects.
HeaderMatcher<T>	Are the `MessageHeaders` of a `Message` containing any entry or multiple that match?
HeaderPropagationAware	MessageHandlers implementing this interface can propagate headers from an input message to an output message.
HeaderValueMessageProcessor<T>
HeaderValueRouter	A Message Router that resolves the MessageChannel from a header value.
HeaderValueRouterParser	Parser for the <header-value-router/> element.
HeapDumper	Use to take a heap dump programmatically.
HistoryWritingMessagePostProcessor
HsqlChannelMessageStoreQueryProvider
Http	The HTTP components Factory.
HttpContextUtils	Utility class for accessing HTTP integration components from the `BeanFactory`.
HttpControllerEndpointSpec	The `BaseHttpInboundEndpointSpec` implementation for the `HttpRequestHandlingController`.
HttpHeaders
HttpInboundEndpointParser	Parser for the 'inbound-channel-adapter' and 'inbound-gateway' elements of the 'http' namespace.
HttpInboundEndpointSupportSpec<S extends HttpInboundEndpointSupportSpec<S,E>,E extends BaseHttpInboundEndpoint>
HttpInboundEndpointSupportSpec.CrossOriginSpec	A fluent API for the `CrossOrigin`.
HttpInboundEndpointSupportSpec.RequestMappingSpec	A fluent API for the `RequestMapping`.
HttpIntegrationConfigurationInitializer	The HTTP Integration infrastructure `beanFactory` initializer.
HttpMessageHandlerSpec	The `BaseHttpMessageHandlerSpec` implementation for the `HttpRequestExecutingMessageHandler`.
HttpNamespaceHandler	Namespace handler for Spring Integration's http namespace.
HttpOutboundChannelAdapterParser	Parser for the 'outbound-channel-adapter' element of the http namespace.
HttpOutboundGatewayParser	Parser for the 'outbound-gateway' element of the http namespace.
HttpRequestExecutingMessageHandler	A `MessageHandler` implementation that executes HTTP requests by delegating to a `RestTemplate` instance.
HttpRequestHandlerEndpointSpec	The `BaseHttpInboundEndpointSpec` implementation for the `HttpRequestHandlingMessagingGateway`.
HttpRequestHandlingController	Inbound HTTP endpoint that implements Spring's `Controller` interface to be used with a DispatcherServlet front controller.
HttpRequestHandlingEndpointSupport	Base class for HTTP request handling endpoints.
HttpRequestHandlingMessagingGateway	Inbound Messaging Gateway that handles HTTP Requests.
IdempotentReceiver	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.
IdempotentReceiverAutoProxyCreatorInitializer	The `IntegrationConfigurationInitializer` that populates the `ConfigurableListableBeanFactory` with an `IdempotentReceiverAutoProxyCreator` when `IdempotentReceiverInterceptor` `BeanDefinition`s and their `mapping` to Consumer Endpoints are present.
IdempotentReceiverInterceptor	The `MethodInterceptor` implementation for the Idempotent Receiver E.I.
IdempotentReceiverInterceptorParser	Parser for the <idempotent-receiver/> element.
IdGeneratorConfigurer
IdGenerators	Alternative `IdGenerator` implementations.
IdGenerators.JdkIdGenerator	UUID.randomUUID()
IdGenerators.SimpleIncrementingIdGenerator	Based on the two `AtomicLong`s, for `topBits` and `bottomBits`, respectively.
IgnoreHiddenFileListFilter	`FileListFilter` implementation that ignores any hidden files.
ImapIdleChannelAdapter	An event-driven Channel Adapter that receives mail messages from a mail server that supports the IMAP "idle" command (see RFC 2177).
ImapIdleChannelAdapterParser	Parser for the <imap-idle-channel-adapter> element in the 'mail' namespace.
ImapIdleChannelAdapterSpec	A `MessageProducerSpec` for a `ImapIdleChannelAdapter`.
ImapMailInboundChannelAdapterSpec	A `MailInboundChannelAdapterSpec` for IMAP.
ImapMailReceiver	A `MailReceiver` implementation for receiving mail messages from a mail server that supports the IMAP protocol.
InboundChannelAdapter	Indicates that a method is capable of producing a `Message` or `Message` `payload`.
InboundChannelAdapterAnnotationPostProcessor	Post-processor for Methods annotated with `@InboundChannelAdapter`.
InboundFileSynchronizer	Strategy for synchronizing from a remote File system to a local directory.
InboundMessageMapper<T>	Strategy interface for mapping from an Object to a`Message`.
InputStreamCallback	Callback for stream-based file retrieval using a RemoteFileOperations.
IntegrationComponentScan	Configures component scanning directives for use with `Configuration` classes.
IntegrationComponentScanRegistrar	`ImportBeanDefinitionRegistrar` implementation to scan and register Integration specific components.
IntegrationComponentSpec<S extends IntegrationComponentSpec<S,T>,T>	The common Builder abstraction.
IntegrationConfigurationBeanFactoryPostProcessor	`BeanDefinitionRegistryPostProcessor` to apply external Integration infrastructure configurations via loading `IntegrationConfigurationInitializer` implementations using `SpringFactoriesLoader`.
IntegrationConfigurationInitializer	The strategy to initialize the external Integration infrastructure (@{code BeanFactoryPostProcessor}s, global beans etc.) in the provided `beanFactory`.
IntegrationConfigUtils	Shared utility methods for Integration configuration.
IntegrationConsumer	Message consumers implement this interface, the message handler within a consumer may or may not emit output messages.
IntegrationContextUtils	Utility methods for accessing common integration components from the BeanFactory.
IntegrationConverter	A marker annotation (an analogue of `<int:converter/>`) to register `Converter`, `GenericConverter` or `ConverterFactory` beans for the `integrationConversionService`.
IntegrationConverterInitializer
IntegrationEvaluationContextFactoryBean	`FactoryBean` to populate `StandardEvaluationContext` instances enhanced with: a `BeanFactoryResolver`.
IntegrationEvent	Base class for all `ApplicationEvent`s generated by the framework.
IntegrationFlow	The main Integration DSL abstraction.
IntegrationFlowAdapter	The base `Adapter` class for the `IntegrationFlow` abstraction.
IntegrationFlowBeanPostProcessor	A `BeanPostProcessor` to parse `IntegrationFlow` beans and register their components as beans in the provided `BeanFactory`, if necessary.
IntegrationFlowBuilder
IntegrationFlowContext	A public API for dynamic (manual) registration of `IntegrationFlow`s, not via standard bean registration phase.
IntegrationFlowContext.IntegrationFlowRegistration
IntegrationFlowContext.IntegrationFlowRegistrationBuilder	A Builder pattern implementation for the options to register `IntegrationFlow` in the application context.
IntegrationFlowDefinition<B extends IntegrationFlowDefinition<B>>	The `BaseIntegrationFlowDefinition` extension for syntax sugar with generics for some type-based EIP-methods when an expected payload type is assumed from upstream.
IntegrationFlowExtension<B extends IntegrationFlowExtension<B>>	An `IntegrationFlowDefinition` extension for custom Java DSL operators and reusable solutions.
IntegrationFlows	The central factory for fluent `IntegrationFlowBuilder` API.
IntegrationGraphController	The REST Controller to provide the management API over `IntegrationGraphServer`.
IntegrationGraphControllerParser	The `BeanDefinitionParser` for the `<int-http:graph-controller>` component.
IntegrationGraphServer	Builds the runtime object model graph.
IntegrationHandlerResultHandler	A `HandlerResultHandler` implementation to handle the result of the `WebFluxInboundEndpoint` execution.
IntegrationInboundManagement	Marker interface indicating that this `IntegrationManagement` component initiates message flow.
IntegrationJmxAttributeSource	The `AnnotationJmxAttributeSource` extension to resolve `ManagedResource`s via `IntegrationManagedResource` on classes.
IntegrationManagedResource	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).
IntegrationManagement	Base interface for Integration managed components.
IntegrationManagement.ManagementOverrides	Toggles to inform the management configurer to not set these properties since the user has manually configured them in a bean definition.
IntegrationManagementConfiguration	`@Configuration` class that registers a `IntegrationManagementConfigurer` bean.
IntegrationManagementConfigurer	Configures beans that implement `IntegrationManagement`.
IntegrationManagementParser	Parser for the <management/> element.
IntegrationMBeanExportConfiguration	`@Configuration` class that registers a `IntegrationMBeanExporter` bean.
IntegrationMBeanExporter	MBean exporter for Spring Integration components in an existing application.
IntegrationMessageHeaderAccessor	Adds standard SI Headers.
IntegrationNamespaceHandler	Namespace handler for the integration namespace.
IntegrationNamespaceUtils	Shared utility methods for integration namespace parsers.
IntegrationNode	Base class for all nodes.
IntegrationObjectSupport	A base class that provides convenient access to the bean factory as well as `TaskScheduler` and `ConversionService` instances.
IntegrationPattern	Indicates that a component implements some Enterprise Integration Pattern.
IntegrationPatternType	The Enterprise Integration Pattern types.
IntegrationPatternType.IntegrationPatternCategory	The Enterprise Integration Pattern categories.
IntegrationProperties	Utility class to encapsulate infrastructure Integration properties constants and their default values.
IntegrationReactiveUtils	Utilities for adapting integration components to/from reactive types.
IntegrationRegistrar	`ImportBeanDefinitionRegistrar` implementation that configures integration infrastructure.
IntegrationRequestMappingHandlerMapping	The `HandlerMapping` implementation that detects and registers `RequestMappingInfo`s for `HttpRequestHandlingEndpointSupport` from a Spring Integration HTTP configuration of `<inbound-channel-adapter/>` and `<inbound-gateway/>` elements.
IntegrationResourceHolder	An implementation of the `ResourceHolder` which holds an instance of the current Message and the synchronization resource
IntegrationResourceHolderSynchronization	The base `ResourceHolderSynchronization` for `IntegrationResourceHolder`.
IntegrationRSocketEndpoint	A marker `ReactiveMessageHandler` extension interface for Spring Integration inbound endpoints.
IntegrationSecurityNamespaceHandler	Namespace handler for the security namespace.
IntegrationSimpleEvaluationContextFactoryBean	`FactoryBean` to populate `SimpleEvaluationContext` instances enhanced with: a `TypeConverter` based on the `ConversionService` from the application context.
IntegrationStompHeaders	The STOMP headers with Integration-friendly `stomp_` prefix.
IntegrationUtils	General utility methods.
IntegrationWebExchangeBindException	A `WebExchangeBindException` extension for validation error with a failed message context.
IntegrationWebSocketContainer	The high-level 'connection factory pattern' contract over low-level Web-Socket configuration.
IntegrationXmlNamespaceHandler
IpAdapterParserUtils	Utility methods and constants for IP adapter parsers.
IpHeaders	Headers for Messages mapped from IP datagram packets.
IpIntegrationEvent
IpNamespaceHandler	Namespace handler for Spring Integration's ip namespace.
Jackson2JsonMessageParser	`JsonInboundMessageMapper.JsonMessageParser` implementation that parses JSON messages and builds a `Message` with the specified payload type from provided `JsonInboundMessageMapper`.
Jackson2JsonObjectMapper	Jackson 2 JSON-processor (@link https://github.com/FasterXML) JsonObjectMapper implementation.
JacksonJsonUtils	Utility methods for Jackson.
JacksonPresent	The utility to check if Jackson JSON processor is present in the classpath.
JavaUtils	Chained utility methods to simplify some Java repetitive code.
JdbcChannelMessageStore	Channel-specific implementation of `MessageGroupStore` using a relational database via JDBC.
JdbcLockRegistry	An `ExpirableLockRegistry` using a shared database to co-ordinate the locks.
JdbcMessageHandler	A message handler that executes an SQL update.
JdbcMessageHandlerParser
JdbcMessageStore	Implementation of `MessageStore` using a relational database via JDBC.
JdbcMessageStoreParser	Parser for `JdbcMessageStore`.
JdbcMetadataStore	Implementation of `ConcurrentMetadataStore` using a relational database via JDBC.
JdbcNamespaceHandler	Namespace handler for the integration JDBC schema.
JdbcOutboundGateway
JdbcOutboundGatewayParser
JdbcPollingChannelAdapter	A polling channel adapter that creates messages from the payload returned by executing a select query.
JdbcPollingChannelAdapterParser	Parser for `JdbcPollingChannelAdapter`.
JdbcTypesEnum	This Enumeration provides a handy wrapper around `Types`.
Jms	Factory class for JMS components.
JmsAdapterUtils
JmsChannelFactoryBean
JmsChannelParser	Parser for the 'channel' and 'publish-subscribe-channel' elements of the Spring Integration JMS namespace.
JmsDefaultListenerContainerSpec	A `DefaultMessageListenerContainer` specific `JmsListenerContainerSpec` extension.
JmsDestinationAccessorSpec<S extends JmsDestinationAccessorSpec<S,A>,A extends JmsDestinationAccessor>	A base `IntegrationComponentSpec` for `JmsDestinationAccessor`s.
JmsDestinationPollingSource	A source for receiving JMS Messages with a polling listener.
JmsHeaderEnricherParser	Header enricher for JMS specific values.
JmsHeaderMapper	Strategy interface for mapping integration Message headers to an outbound JMS Message (e.g.
JmsInboundChannelAdapterParser	Parser for the <inbound-channel-adapter/> element of the 'jms' namespace.
JmsInboundChannelAdapterSpec<S extends JmsInboundChannelAdapterSpec<S>>	A `MessageSourceSpec` for a `JmsDestinationPollingSource`.
JmsInboundChannelAdapterSpec.JmsInboundChannelSpecTemplateAware	A `JmsTemplate`-based `JmsInboundChannelAdapterSpec` extension.
JmsInboundGateway	A wrapper around the `JmsMessageDrivenEndpoint` implementing `MessagingGatewaySupport`.
JmsInboundGatewaySpec<S extends JmsInboundGatewaySpec<S>>	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 `JmsDestinationAccessorSpec` for `JmsListenerContainerSpec`s.
JmsMessageChannelSpec<S extends JmsMessageChannelSpec<S,T>,T extends AbstractJmsChannel>	A `JmsMessageChannelSpec` for subscribable `AbstractJmsChannel`s.
JmsMessageDrivenChannelAdapterSpec<S extends JmsMessageDrivenChannelAdapterSpec<S>>	A `MessageProducerSpec` for `JmsMessageDrivenEndpoint`s.
JmsMessageDrivenChannelAdapterSpec.JmsMessageDrivenChannelAdapterListenerContainerSpec<S extends JmsListenerContainerSpec<S,C>,C extends AbstractMessageListenerContainer>
JmsMessageDrivenEndpoint	A message-driven endpoint that receive JMS messages, converts them into Spring Integration Messages, and then sends the result to a channel.
JmsMessageDrivenEndpointParser	Parser for the <message-driven-channel-adapter> element and the <inbound-gateway> element of the 'jms' namespace.
JmsNamespaceHandler	Namespace handler for Spring Integration's jms namespace.
JmsOutboundChannelAdapterParser	Parser for the <outbound-channel-adapter/> element of the jms namespace.
JmsOutboundChannelAdapterSpec<S extends JmsOutboundChannelAdapterSpec<S>>	A `MessageHandlerSpec` for a `JmsSendingMessageHandler`.
JmsOutboundChannelAdapterSpec.JmsOutboundChannelSpecTemplateAware	A `JmsTemplate`-based `JmsOutboundChannelAdapterSpec` extension.
JmsOutboundGateway	An outbound Messaging Gateway for request/reply JMS.
JmsOutboundGateway.ReplyContainerProperties
JmsOutboundGatewayParser	Parser for the <outbound-gateway> element of the integration 'jms' namespace.
JmsOutboundGatewaySpec	A `MessageHandlerSpec` for a `JmsOutboundGateway`.
JmsPollableMessageChannelSpec<S extends JmsPollableMessageChannelSpec<S,T>,T extends AbstractJmsChannel>	A `MessageChannelSpec` for an `AbstractJmsChannel`.
JmsPublishSubscribeMessageChannelSpec	A `JmsMessageChannelSpec` for a `SubscribableJmsChannel` configured with a topic.
JmsSendingMessageHandler	A MessageConsumer that sends the converted Message payload within a JMS Message.
JmsTemplateSpec	A `JmsDestinationAccessorSpec` for a `DynamicJmsTemplate`.
JmsTimeoutException	A timeout occurred within an async gateway.
JmxHeaders	Constants for JMX related Message Header keys.
JmxIntegrationConfigurationInitializer	The JMX Integration infrastructure `beanFactory` initializer.
JmxNamespaceHandler	Namespace handler for Spring Integration's jmx namespace.
Jpa	Factory class for JPA components.
JpaBaseOutboundEndpointSpec<S extends JpaBaseOutboundEndpointSpec<S>>	The base `MessageHandlerSpec` for JPA Outbound endpoints.
JpaExecutor	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 When objects are being retrieved, it also possibly to: delete the retrieved object If neither entityClass nor any other query is specified then the entity-class is "guessed" from the `Message` payload.idExpression
JpaInboundChannelAdapterParser	The JPA Inbound Channel adapter parser
JpaInboundChannelAdapterSpec	A `MessageSourceSpec` for a `JpaPollingChannelAdapter`.
JpaNamespaceHandler	The namespace handler for the JPA namespace
JpaOperationFailedException	An Exception that would be thrown if any of the Operations from `JpaOperations` fails
JpaOperations	The Interface containing all the JpaOperations those will be executed by the Jpa Spring Integration components.
JpaOutboundChannelAdapterParser	The parser for JPA outbound channel adapter
JpaOutboundGateway	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.
JpaOutboundGatewayFactoryBean	The `JpaOutboundGatewayFactoryBean` creates instances of the `JpaOutboundGateway`.
JpaParameter	Abstraction of Jpa parameters allowing to provide static parameters and SpEl Expression based parameters.
JpaParserUtils	Contains various utility methods for parsing JPA Adapter specific namespace elements and generation the respective `BeanDefinition`s.
JpaPollingChannelAdapter	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 After the objects have been polled, it also possibly to either: executes an update after the select possibly to updated the state of selected records executes an update (per retrieved object or for the entire payload) delete the retrieved object
JpaRetrievingOutboundGatewaySpec	A `JpaBaseOutboundEndpointSpec` extension for the `JpaOutboundGateway` with `OutboundGatewayType.RETRIEVING` mode.
JpaUpdatingOutboundEndpointSpec	A `JpaBaseOutboundEndpointSpec` extension for the `updating` `JpaOutboundGateway` mode.
JpaUtils	This Utility contains a sub-set of utility methods from the Spring Data JPA Project.
JschProxyFactoryBean	Spring-friendly factory bean to create Jsch `Proxy` objects.
JschProxyFactoryBean.Type
JsonHeaders	Pre-defined names and prefixes to be used for setting and/or retrieving JSON entries from/to Message Headers and other adapter, e.g.
JsonInboundMessageMapper	`InboundMessageMapper` implementation that maps incoming JSON messages to a `Message` with the specified payload type.
JsonInboundMessageMapper.JsonMessageParser<P>
JsonNodeWrapperToJsonNodeConverter	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.
JsonObjectMapper<N,P>	Strategy interface to convert an Object to/from the JSON representation.
JsonObjectMapperProvider	Simple factory to provide JsonObjectMapper instances based on jackson-databind lib in the classpath.
JsonOutboundMessageMapper	`OutboundMessageMapper` implementation the converts a `Message` to a JSON string representation.
JsonPathUtils	Utility class to `JsonPathUtils.evaluate(java.lang.Object, java.lang.String, com.jayway.jsonpath.Predicate...)` a jsonPath on the provided object.
JsonPropertyAccessor	A SpEL `PropertyAccessor` that knows how to read properties from JSON objects.
JsonToObjectTransformer	Transformer implementation that converts a JSON string payload into an instance of the provided target Class.
JsonToObjectTransformerParser
Kafka	Factory class for Apache Kafka components.
KafkaChannelParser	Parser for a channel backed by an Apache Kafka topic.
KafkaInboundChannelAdapterParser	Parser for the inbound channel adapter.
KafkaInboundChannelAdapterSpec<K,V>	Spec for a polled Apache Kafka inbound channel adapter.
KafkaInboundGateway<K,V,R>	Inbound gateway.
KafkaInboundGatewayParser	Inbound gateway parser.
KafkaInboundGatewaySpec<K,V,R,S extends KafkaInboundGatewaySpec<K,V,R,S>>	A `MessagingGatewaySpec` implementation for the `KafkaInboundGateway`.
KafkaInboundGatewaySpec.KafkaInboundGatewayListenerContainerSpec<K,V,R>	A `ConcurrentMessageListenerContainer` configuration `KafkaInboundGatewaySpec` extension.
KafkaIntegrationHeaders	Headers specifically for Spring Integration components.
KafkaMessageDrivenChannelAdapter<K,V>	Message-driven channel adapter.
KafkaMessageDrivenChannelAdapter.ListenerMode	The listener mode for the container, record or batch.
KafkaMessageDrivenChannelAdapterParser	Parser for the message driven channel adapter.
KafkaMessageDrivenChannelAdapterSpec<K,V,S extends KafkaMessageDrivenChannelAdapterSpec<K,V,S>>	A `MessageProducerSpec` implementation for the `KafkaMessageDrivenChannelAdapter`.
KafkaMessageDrivenChannelAdapterSpec.KafkaMessageDrivenChannelAdapterListenerContainerSpec<K,V>	A `ConcurrentMessageListenerContainer` configuration `KafkaMessageDrivenChannelAdapterSpec` extension.
KafkaMessageListenerContainerSpec<K,V>	A helper class in the Builder pattern style to delegate options to the `ConcurrentMessageListenerContainer`.
KafkaMessageSource<K,V>	Polled message source for Apache Kafka.
KafkaMessageSource.KafkaAckCallback<K,V>	AcknowledgmentCallback for Kafka.
KafkaMessageSource.KafkaAckCallbackFactory<K,V>	AcknowledgmentCallbackFactory for KafkaAckInfo.
KafkaMessageSource.KafkaAckInfo<K,V>	Information for building an KafkaAckCallback.
KafkaNamespaceHandler	The namespace handler for the Apache Kafka namespace.
KafkaOutboundChannelAdapterParser	Parser for the outbound channel adapter.
KafkaOutboundGatewayParser	Parser for the outbound gateway.
KafkaOutboundGatewaySpec<K,V,R,S extends KafkaOutboundGatewaySpec<K,V,R,S>>	A `MessageHandlerSpec` implementation for the `KafkaProducerMessageHandler` as a gateway.
KafkaOutboundGatewaySpec.KafkaGatewayMessageHandlerTemplateSpec<K,V,R>	A `KafkaTemplate`-based `KafkaProducerMessageHandlerSpec` extension.
KafkaOutboundGatewaySpec.ReplyingKafkaTemplateSpec<K,V,R>	An `IntegrationComponentSpec` implementation for the `KafkaTemplate`.
KafkaParsingUtils	Utilities to assist with parsing XML.
KafkaPointToPointChannelSpec	Spec for a point to point channel backed by an Apache Kafka topic.
KafkaPollableChannelSpec	Spec for a pollable channel.
KafkaProducerMessageHandler<K,V>	A Message Handler for Apache Kafka; when supplied with a `ReplyingKafkaTemplate` it is used as the handler in an outbound gateway.
KafkaProducerMessageHandler.ProducerRecordCreator<K,V>	Creates a `ProducerRecord` from a `Message` and/or properties derived from configuration and/or the message.
KafkaProducerMessageHandlerSpec<K,V,S extends KafkaProducerMessageHandlerSpec<K,V,S>>	A `MessageHandlerSpec` implementation for the `KafkaProducerMessageHandler`.
KafkaProducerMessageHandlerSpec.KafkaProducerMessageHandlerTemplateSpec<K,V>	A `KafkaTemplate`-based `KafkaProducerMessageHandlerSpec` extension.
KafkaPublishSubscribeChannelSpec	Spec for a publish/subscribe channel backed by an Apache Kafka topic.
KafkaSendFailureException	An exception that is the payload of an `ErrorMessage` when a send fails.
KafkaSubscribableChannelSpec<C extends SubscribableKafkaChannel>	Spec for a subscribable channel.
KafkaTemplateSpec<K,V>	An `IntegrationComponentSpec` implementation for the `KafkaTemplate`.
KotlinScriptExecutor	An `AbstractScriptExecutor` for the Kotlin scripts support.
KryoClassListRegistrar	A `KryoRegistrar` used to validateRegistration a list of Java classes.
KryoClassMapRegistrar	A `KryoRegistrar` implementation backed by a Map used to explicitly set the registration ID for each class.
KryoRegistrar	Strategy interface used by `PojoCodec` to configure registrations classes consistently across `Kryo` instances.
KryoRegistrationRegistrar	A `KryoRegistrar` implementation backed by a List of `Registration`.
LambdaMessageProcessor	The `MessageProcessor` implementation for method invocation on the single method classes - functional interface implementations.
LastModifiedFileListFilter	The `FileListFilter` implementation to filter those files which `File.lastModified()` is less than the `LastModifiedFileListFilter.age` in comparison with the current time.
LeaderEventPublisher	Interface for publishing leader based application events.
LeaderInitiator	Bootstrap leadership `candidates` with ZooKeeper/Curator.
LeaderInitiatorFactoryBean	Creates a `LeaderInitiator`.
LeaderListenerParser
LinkNode	Represents a link between nodes.
LinkNode.Type
ListenableMetadataStore	`ConcurrentMetadataStore` with the ability of registering `MetadataStoreListener` callbacks, to be invoked when changes occur in the metadata store.
LoadBalancingChannelSpec<S extends MessageChannelSpec<S,C>,C extends AbstractMessageChannel>
LoadBalancingStrategy	Strategy for determining the iteration order of a MessageHandler list.
LockRegistry	Strategy for maintaining a registry of shared locks
LockRegistryLeaderInitiator	Component that initiates leader election based on holding a lock.
LockRepository	Encapsulation of the SQL shunting that is needed for locks.
Log4j2LevelAdjuster	A JUnit method `Rule` that changes the Log4J 2 logger level for a set of classes or packages while a test method is running.
LoggingChannelAdapterParser	Parser for the 'logging-channel-adapter' element.
LoggingHandler	MessageHandler implementation that simply logs the Message or its payload depending on the value of the 'shouldLogFullMessage' or SpEL 'logExpression' property.
LoggingHandler.Level
LogLevels	Test classes annotated with this will change logging levels between tests.
LogLevelsCondition	JUnit condition that adjusts and reverts log levels before/after each test.
LongRunningIntegrationTest	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.
LongRunningTest	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.
Mail	The factory for Spring Integration Mail components.
MailHeaderEnricherParser
MailHeaders	Pre-defined header names to be used for setting and/or retrieving Mail Message attributes from/to integration Message Headers.
MailHeadersBuilder	The Mail specific `MapBuilder` implementation.
MailInboundChannelAdapterParser	Parser for the <inbound-channel-adapter> element of Spring Integration's 'mail' namespace.
MailInboundChannelAdapterSpec<S extends MailInboundChannelAdapterSpec<S,R>,R extends AbstractMailReceiver>	A `MessageSourceSpec` for a `MailReceivingMessageSource`.
MailIntegrationEvent
MailNamespaceHandler	Namespace handler for the 'mail' namespace.
MailOutboundChannelAdapterParser	Parser for the <outbound-channel-adapter/> element of the 'mail' namespace.
MailReceiver	Strategy interface for receiving mail `Messages`.
MailReceiverFactoryBean
MailReceivingMessageSource	`MessageSource` implementation that delegates to a `MailReceiver` to poll a mailbox.
MailSendingMessageHandler	A `MessageHandler` implementation for sending mail.
MailSendingMessageHandlerSpec
MailToStringTransformer	Transforms a Message payload of type `Message` to a String.
MailToStringTransformerParser	Parser for the <mail-to-string-transformer> element.
MailTransportUtils	Collection of utility methods to work with Mail transports.
MailUtils	Utilities for handling mail messages.
ManageableLifecycle	Makes `Lifecycle` methods manageable.
ManageableSmartLifecycle	Extend `ManageableLifecycle` to make those methods manageable.
ManagedEndpoint	Deprecated. this is no longer used by the framework.
ManualAckListenerExecutionFailedException	A `ListenerExecutionFailedException` enhanced with the channel and delivery tag.
MapArgumentResolver	A `HandlerMethodArgumentResolver` implementation to resolve argument for the `MethodParameter` as a `Map` or `Properties`.
MapBuilder<B extends MapBuilder<B,K,V>,K,V>	A `Builder` pattern implementation for the `Map`.
MapContentMatchers<T,V>	Matchers that examine the contents of a `Map`.
MapJsonSerializer	Serializes a `Map` as JSON.
MapMessageConverter	Converts to/from a Map with 2 keys ('headers' and 'payload').
MappingMessageRouterManagement	Exposes channel mapping operations when the router is proxied.
MappingUtils	Utility methods used during message mapping.
MapToObjectTransformer	Will transform Map to an instance of Object.
MapToObjectTransformerParser
MarshallingTransformer	An implementation of `AbstractTransformer` that delegates to an OXM `Marshaller`.
MarshallingTransformerParser
MarshallingWebServiceInboundGateway
MarshallingWebServiceOutboundGateway	An outbound Messaging Gateway for invoking Web Services that also supports marshalling and unmarshalling of the request and response messages.
MarshallingWsInboundGatewaySpec	The spec for a `MarshallingWebServiceInboundGateway`.
MarshallingWsOutboundGatewaySpec	The spec for a `MarshallingWebServiceOutboundGateway`.
MarshallingWsOutboundGatewaySpec.MarshallingWsOutboundGatewayNoTemplateSpec	Spec for a `MarshallingWebServiceOutboundGateway` where an external `WebServiceTemplate` is not provided.
MBeanAttributeFilter
MBeanExporterParser	Parser for the 'mbean-export' element of the integration JMX namespace.
MBeanObjectConverter
MBeanTreePollingChannelAdapterParser
MBeanTreePollingMessageSource	A `MessageSource` implementation that retrieves a snapshot of a filtered subset of the MBean tree.
MessageBuilder<T>	The default message builder; creates immutable `GenericMessage`s.
MessageBuilderFactory
MessageChannelNode	Represents a message channel.
MessageChannelReactiveUtils	Deprecated. since 5.3 in favor of `IntegrationReactiveUtils`.
MessageChannelReference	An "artificial" `MessageChannel` implementation which will be unwrapped to the `MessageChannel` bean on the bean registration phase.
MessageChannels
MessageChannelSpec<S extends MessageChannelSpec<S,C>,C extends AbstractMessageChannel>
MessageCodec	`PojoCodec` configured to encode/decode `Message<?>`s.
MessageCollectionCallback<T>	The callback to be used with the `MongoDbOutboundGateway` as an alternative to other query options on the gateway.
MessageConverter	A converter to convert the raw message created by the underlying UDP/TCP endpoint to a specific form of Syslog message.
MessageConvertingTcpMessageMapper
MessageCountReleaseStrategy	A `ReleaseStrategy` that releases only the first `n` messages, where `n` is a threshold.
MessageDecorator	The `Message` decoration contract.
MessageDispatcher	Strategy interface for dispatching messages to handlers.
MessageDispatchingException	Exception that indicates an internal error occurred within a `MessageDispatcher` preventing message delivery.
MessageDocument	The entity class to wrap `Message` to the MongoDB document.
MessageDocumentFields
MessageEndpoint	Stereotype annotation indicating that a class is capable of serving as a Message Endpoint.
MessageFilter	Message Handler that delegates to a `MessageSelector`.
MessageGatewayNode	Represents an inbound gateway.
MessageGroup	A group of messages that are correlated with each other and should be processed in the same context.
MessageGroupExpiredEvent	Event representing the expiration of a message group.
MessageGroupFactory	The `MessageGroup` factory strategy.
MessageGroupMetadata	Value Object holding metadata about a MessageGroup in the MessageGroupStore.
MessageGroupProcessor	A processor for correlated groups of messages.
MessageGroupQueue	A `BlockingQueue` that is backed by a `MessageGroupStore`.
MessageGroupStore	Defines additional storage operations on groups of messages linked by a group id.
MessageGroupStore.MessageGroupCallback	Invoked when a MessageGroupStore expires a group.
MessageGroupStoreReaper	Convenient configurable component to allow explicit timed expiry of `MessageGroup` instances in a `MessageGroupStore`.
MessageHandlerChain	A composite `MessageHandler` implementation that invokes a chain of MessageHandler instances in order.
MessageHandlerNode	Represents a message handler.
MessageHandlerSpec<S extends MessageHandlerSpec<S,H>,H extends MessageHandler>	An `IntegrationComponentSpec` for `MessageHandler`s.
MessageHandlerSupport	Base class for Message handling components that provides basic validation and error handling capabilities.
MessageHandlingTaskDecorator	The strategy to decorate `MessageHandlingRunnable` tasks to be used with the `Executor`.
MessageHeadersJacksonSerializer	A Jackson `StdSerializer` implementation to serialize `MessageHeaders` as a `HashMap`.
MessageHistory
MessageHistory.Entry	Inner class for each Entry in the history.
MessageHistoryConfigurer
MessageHistoryParser	The `<message-history/>` parser.
MessageHistoryRegistrar	Registers the `MessageHistoryConfigurer` `BeanDefinition` for `MessageHistory`.
MessageHolder	The `MessageStore` specific value object to keep the `Message` and its metadata.
MessageJacksonDeserializer<T extends Message<?>>	A Jackson `StdNodeBasedDeserializer` extension for `Message` implementations.
MessageKryoRegistrar	Registers common MessageHeader types and Serializers.
MessageListProcessor
MessageMappingException	Exception that indicates an error during message mapping.
MessageMatcher	Matcher to make assertions about message equality easier.
MessageMetadata	Value Object holding metadata about a Message in the MessageStore.
MessagePredicate	Predicate to make assertions about message equality easier.
MessagePreparedStatementSetter	The callback to be used with the `JdbcMessageHandler` as an alternative to the `SqlParameterSourceFactory`.
MessageProcessingHeaderValueMessageProcessor
MessageProcessor<T>	This defines the lowest-level strategy of processing a Message and returning some Object (or null).
MessageProcessorMessageSource	The `MessageSource` strategy implementation to produce a `Message` from underlying MessageProcessorMessageSource.messageProcessor for polling endpoints.
MessageProcessorSpec<S extends MessageProcessorSpec<S>>	The `IntegrationComponentSpec` specific base class for `MessageProcessor`s.
MessageProducer	Base interface for any component that is capable of sending messages to a `MessageChannel`.
MessageProducerNode	Represents an inbound message producer.
MessageProducerSpec<S extends MessageProducerSpec<S,P>,P extends MessageProducerSupport>	An `IntegrationComponentSpec` for `MessageProducer`s.
MessageProducerSupport	A support class for producer endpoints that provides a setter for the output channel and a convenience method for sending Messages.
MessagePublishingErrorHandler	`ErrorHandler` implementation that sends an `ErrorMessage` to a `MessageChannel`.
MessagePublishingInterceptor	A `MethodInterceptor` that publishes Messages to a channel.
MessageRejectedException	Exception that indicates a message has been rejected by a selector.
MessageRouter	Routers implementing this interface have a default output channel.
MessageRowMapper	Convenience class to be used to unpack a `Message` from a result set row.
MessageSelectingInterceptor	A `ChannelInterceptor` that delegates to a list of `MessageSelectors` to decide whether a `Message` should be accepted on the `MessageChannel`.
MessageSelector	Strategy interface for message selection.
MessageSelectorChain	A message selector implementation that passes incoming messages through a chain of selectors.
MessageSelectorChain.VotingStrategy
MessageSequenceComparator
MessageSessionCallback<F,T>	Callback invoked by `RemoteFileOperations.executeForMessage()` - allows multiple operations on a session.
MessageSource<T>	Base interface for any source of `Messages` that can be polled.
MessageSourceManagement	Message sources implementing this interface have additional properties that can be set or examined using JMX.
MessageSourceMutator	A `ReceiveMessageAdvice` extension that can mutate a `MessageSource` before and/or after `MessageSource.receive()` is called.
MessageSourceNode	Represents a message source.
MessageSourcePollingTemplate	A `PollingOperations` used to ad-hoc poll a `MessageSource`.
MessageSourceSpec<S extends MessageSourceSpec<S,H>,H extends MessageSource<?>>	An `IntegrationComponentSpec` for `MessageSource`s.
MessageStore	Strategy interface for storing and retrieving messages.
MessageStoreException	Exception for problems that occur when using a `MessageStore` implementation.
MessageTimeoutException	Exception that indicates a timeout elapsed prior to successful message delivery.
MessageToBinaryConverter
MessageTransformationException	Base Exception type for Message transformation errors.
MessageTransformingHandler	A reply-producing `MessageHandler` that delegates to a `Transformer` instance to modify the received `Message` and sends the result to its output channel.
MessageTriggerAction	Classes implementing this interface can take some action when a trigger `Message` is received.
MessageValidator	Validate a message.
MessagingAnnotationPostProcessor	A `BeanPostProcessor` implementation that processes method-level messaging annotations such as @Transformer, @Splitter, @Router, and @Filter.
MessagingAnnotationUtils	Utility methods to support annotation processing.
MessagingEvent	A subclass of `ApplicationEvent` that wraps a `Message`.
MessagingExceptionWrapper	A wrapper exception for a `MessagingException` used to convey the cause and original message to a `MessagePublishingErrorHandler`.
MessagingGateway	A stereotype annotation to provide an Integration Messaging Gateway Proxy (`<gateway/>`) as an abstraction over the messaging API.
MessagingGatewayRegistrar	The `ImportBeanDefinitionRegistrar` to parse `MessagingGateway` and its `service-interface` and to register `BeanDefinition` `GatewayProxyFactoryBean`.
MessagingGatewaySpec<S extends MessagingGatewaySpec<S,G>,G extends MessagingGatewaySupport>	An `IntegrationComponentSpec` for `MessagingGatewaySupport`s.
MessagingGatewaySupport	A convenient base class for connecting application code to `MessageChannel`s for sending, receiving, or request-reply operations.
MessagingMethodInvokerHelper	A helper class for processors that invoke a method on a target Object using a combination of message payload(s) and headers as arguments.
MessagingMethodInvokerHelper.ParametersWrapper
MessagingTemplate
MetadataStore	Strategy interface for storing metadata from certain adapters to avoid duplicate delivery of messages, for example.
MetadataStoreListener	A callback to be invoked whenever a value changes in the data store.
MetadataStoreListenerAdapter	Base implementation for a `MetadataStoreListener`.
MetadataStoreSelector	The `MessageSelector` implementation using a `ConcurrentMetadataStore` and `MessageProcessor`.
MeterFacade	Facade for Meters.
MethodAnnotationPostProcessor<T extends Annotation>	Strategy interface for post-processing annotated methods.
MethodAnnotationPublisherMetadataSource	An `PublisherMetadataSource` implementation that retrieves the channel name and expression strings from an annotation.
MethodArgsHolder	Simple wrapper class containing a `Method` and an object array containing the arguments for an invocation of that method.
MethodArgsMessageMapper	Implementations of this interface are `InboundMessageMapper`s that map a `MethodArgsHolder` to a `Message`.
MethodInvokingCorrelationStrategy	`CorrelationStrategy` implementation that works as an adapter to another bean.
MethodInvokingMessageGroupProcessor	MessageGroupProcessor that serves as an adapter for the invocation of a POJO method.
MethodInvokingMessageHandler	A `MessageHandler` that invokes the specified method on the provided object.
MethodInvokingMessageListProcessor<T>	A MessageListProcessor implementation that invokes a method on a target POJO.
MethodInvokingMessageProcessor<T>	A MessageProcessor implementation that invokes a method on a target Object.
MethodInvokingMessageSource	A `MessageSource` implementation that invokes a no-argument method so that its return value may be sent to a channel.
MethodInvokingReleaseStrategy	A `ReleaseStrategy` that invokes a method on a plain old Java object.
MethodInvokingRouter	A Message Router that invokes the specified method on the given object.
MethodInvokingSelector	A method-invoking implementation of `MessageSelector`.
MethodInvokingSplitter	A Message Splitter implementation that invokes the specified method on the given object.
MethodInvokingTransformer	A Message Transformer implementation that invokes the specified method on the given object.
MethodNameMappingPublisherMetadataSource
MetricsCaptor	A metrics facade that delegates to a concrete implementation.
MetricsCaptor.CounterBuilder	A builder for a counter.
MetricsCaptor.GaugeBuilder	A builder for a gauge.
MetricsCaptor.TimerBuilder	A builder for a timer.
MicrometerMetricsCaptor	The Micrometer implementation of `MetricsCaptor`.
MicrometerMetricsCaptor.AbstractMeter<M extends io.micrometer.core.instrument.Meter>
MicrometerMetricsCaptor.MicroCounter
MicrometerMetricsCaptor.MicroCounterBuilder
MicrometerMetricsCaptor.MicroGauge
MicrometerMetricsCaptor.MicroGaugeBuilder
MicrometerMetricsCaptor.MicroTimer
MicrometerMetricsCaptor.MicroTimerBuilder
MicrometerMetricsCaptorRegistrar	An `ImportBeanDefinitionRegistrar` to conditionally add a `MicrometerMetricsCaptor` bean when `io.micrometer.core.instrument.MeterRegistry` is present in classpath and no `MicrometerMetricsCaptor.MICROMETER_CAPTOR_NAME` bean present yet.
MicrometerNodeEnhancer	Add micrometer metrics to the node.
MimeTypeSerializer	Simple `StdSerializer` extension to represent a `MimeType` object in the target JSON as a plain string.
MockIntegration	The factory for integration specific mock components.
MockIntegrationContext	A `BeanFactoryAware` component with an API to customize real beans in the application context from test code.
MockitoMessageMatchers	Mockito matcher factory for `Message` matcher creation.
MockMessageHandler	The `AbstractMessageProducingHandler` extension for the mocking purpose in tests.
MongoDb	Factory class for building MongoDb components
MongoDbChangeStreamMessageProducer	A `MessageProducerSupport` for MongoDB Change Stream implementation.
MongoDbChangeStreamMessageProducerSpec	A `MessageProducerSpec` for tne `MongoDbChangeStreamMessageProducer`.
MongoDbChannelMessageStore	MongoDB `PriorityCapableChannelMessageStore` implementation.
MongoDbInboundChannelAdapterParser	Parser for MongoDb store inbound adapters
MongoDbMessageSource	An instance of `MessageSource` which returns a `Message` with a payload which is the result of execution of a `Query`.
MongoDbMessageSourceSpec	A `AbstractMongoDbMessageSourceSpec` implementation for a `MongoDbMessageSource`.
MongoDbMessageStore	An implementation of both the `MessageStore` and `MessageGroupStore` strategies that relies upon MongoDB for persistence.
MongoDbMetadataStore	MongoDbMetadataStore implementation of `ConcurrentMetadataStore`.
MongoDbNamespaceHandler	Namespace handler for Spring Integration's 'mongodb' namespace.
MongoDbOutboundChannelAdapterParser	Parser for Mongodb store outbound adapters
MongoDbOutboundGateway	Makes outbound operations to query a MongoDb database using a `MongoOperations`
MongoDbOutboundGatewayParser	Parser for MongoDb outbound gateways
MongoDbOutboundGatewaySpec	A `MessageHandlerSpec` extension for the MongoDb Outbound endpoint `MongoDbOutboundGateway`
MongoDbStoringMessageHandler	Implementation of `MessageHandler` which writes Message payload into a MongoDb collection identified by evaluation of the `MongoDbStoringMessageHandler.collectionNameExpression`.
MongoHeaders	Pre-defined names and prefixes to be used for for dealing with headers required by Mongo components
MqttComponent<T>	A component that interfaces with MQTT.
MqttConnectionFailedEvent
MqttHeaderAccessor	Helper for typed access to incoming MQTT message headers.
MqttHeaders	Spring Integration headers.
MqttIntegrationEvent	Base class for Mqtt Events.
MqttMessageConverter	Extension of `MessageConverter` allowing the topic to be added as a header.
MqttMessageDeliveredEvent	An event emitted (when using aysnc) when the client indicates the message was delivered.
MqttMessageDeliveryEvent	Base class for events related to message delivery.
MqttMessageDrivenChannelAdapterParser	The MqttAdapter Message Driven Channel adapter parser
MqttMessageSentEvent	An event emitted (when using aysnc) when the client indicates that a message has been sent.
MqttNamespaceHandler	The namespace handler for the MqttAdapter namespace
MqttOutboundChannelAdapterParser	The parser for the MqttAdapter Outbound Channel Adapter.
MqttPahoClientFactory
MqttPahoComponent	An extension of `MqttComponent` for Eclipse Paho components.
MqttPahoMessageDrivenChannelAdapter	Eclipse Paho Implementation.
MqttPahoMessageHandler	Eclipse Paho Implementation.
MqttSubscribedEvent
MqttUtils	MQTT Utilities
MulticastReceivingChannelAdapter	Channel adapter that joins a multicast group and receives incoming packets and sends them to an output channel.
MulticastSendingMessageHandler	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.
MultipartAwareFormHttpMessageConverter	An `HttpMessageConverter` implementation that delegates to an instance of `AllEncompassingFormHttpMessageConverter` while adding the capability to read `multipart/form-data` content in an HTTP request.
MultipartFileReader<T>	Strategy for reading `MultipartFile` content.
MultipartHttpInputMessage
MutableMessage<T>	An implementation of `Message` with a generic payload.
MutableMessageBuilder<T>	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.
MutableMessageBuilderFactory
MutableMessageHeaders	A MessageHeaders that permits direct access to and modification of the header map.
MutableMessageJacksonDeserializer	The `MessageJacksonDeserializer` implementation for the `MutableMessage`.
MySqlChannelMessageStoreQueryProvider
NackedAmqpMessageException	An exception representing a negatively acknowledged message from a publisher confirm.
NamedComponent
NamedFieldsMBeanAttributeFilter
NioFileLocker	File locking strategy that uses java.nio.
NoListenerException
NotificationListeningChannelAdapterParser
NotificationListeningMessageProducer	A JMX `NotificationListener` implementation that will send Messages containing the JMX `Notification` instances as their payloads.
NotificationPublishingChannelAdapterParser
NotificationPublishingMessageHandler	An `AbstractMessageHandler` implementation to publish an incoming message as a JMX `Notification`.
NotificationPublishingMessageHandler.PublisherDelegate	Simple class used for the actual MBean instances to be registered.
NotNamedFieldsMBeanAttributeFilter
NullAwarePayloadArgumentResolver	A `PayloadMethodArgumentResolver` that treats KafkaNull payloads as null.
NullChannel	A channel implementation that essentially behaves like "/dev/null".
ObjectStringMapBuilder	A map builder creating a map with Object keys and String values.
ObjectStringMessageConverter	A `StringMessageConverter` extension to convert any object to string.
ObjectToJsonTransformer	Transformer implementation that converts a payload instance into a JSON string representation.
ObjectToJsonTransformer.ResultType
ObjectToJsonTransformerParser
ObjectToMapTransformer	Transforms an object graph into a Map.
ObjectToMapTransformerParser
ObjectToStringTransformer	A simple transformer that creates an outbound payload by invoking the inbound payload Object's `toString()` method.
ObjectToStringTransformerParser	Parser for the 'object-to-string-transformer' element.
OnFailedToAcquireMutexEvent	Generic event representing that a mutex could not be acquired during leader election.
OnGrantedEvent	Generic event representing that leader has been granted.
OnlyOnceTrigger
OnRevokedEvent	Generic event representing that leader has been revoked.
OperationInvokingChannelAdapterParser
OperationInvokingMessageHandler	A `MessageHandler` implementation for invoking JMX operations based on the Message sent to its `AbstractMessageHandler.handleMessage(Message)` method.
OperationInvokingOutboundGatewayParser
OracleChannelMessageStoreQueryProvider	Contains Oracle-specific queries for the `JdbcChannelMessageStore`.
Orderable	Interface that extends `Ordered` while also exposing the `Orderable.setOrder(int)` as an interface-level so that it is avaiable on AOP proxies, etc.
OrderlyShutdownCapable	Interface for components that wish to be considered for an orderly shutdown using management interfaces.
OSDelegatingFileTailingMessageProducer	A file tailing message producer that delegates to the OS tail program.
OutboundGatewayType	Indicates the mode of operation for the outbound Jpa Gateway.
OutboundMessageMapper<T>	Strategy interface for mapping from a `Message` to an Object.
ParameterSource
ParameterSourceFactory
PartialSuccessException	A `MessagingException` thrown when a non-transactional operation is performing multiple updates from a single message, e.g.
PassThroughTransactionSynchronizationFactory	A simple `TransactionSynchronizationFactory` implementation which produces an `IntegrationResourceHolderSynchronization` with an `IntegrationResourceHolder`.
PassThruLockRegistry	The `LockRegistry` implementation which has no effect.
PassThruMessageConverter	The simple `MessageConverter` implementation which contract is to return `Message` as is for both `from/to` operations.
PassThruSubProtocolHandler	The simple 'pass thru' `SubProtocolHandler`, when there is no interests in the WebSocket sub-protocols.
PathMovedEvent	An event emitted when a path is moved.
PathMovedEvent	An event emitted when a path is moved.
PathRemovedEvent	An event emitted when a file or directory is removed.
PathRemovedEvent	An event emitted when a file or directory is removed.
PatternMatchUtils	Utility methods for pattern matching.
Pausable	Endpoints implementing this interface can be paused/resumed.
PayloadAndHeaderMatcher<T>	Matcher to make assertions about message equality easier.
PayloadDeserializingTransformer	Transformer that deserializes the inbound byte array payload to an object by delegating to a Converter<byte[], Object>.
PayloadDeserializingTransformerParser	Parser for the 'payload-deserializing-transformer' element.
PayloadExpressionArgumentResolver	The `HandlerMethodArgumentResolver` for evaluating `Payload.expression()` as a SpEL expression against `message` and converting result to expected parameter type.
PayloadMatcher<T>	Is the payload of a `Message` equal to a given value or is matching a given matcher?
Payloads	This annotation marks a method parameter as being a list of message payloads, for POJO handlers that deal with lists of messages (e.g.
PayloadsArgumentResolver	The `HandlerMethodArgumentResolver` for resolving a `Collection` of `payloads` or expression against each `payload`.
PayloadSerializingTransformer	Transformer that serializes the inbound payload into a byte array by delegating to a Converter<Object, byte[]>.
PayloadSerializingTransformerParser	Parser for the 'payload-serializing-transformer' element.
PayloadTypeConvertingTransformer<T,U>	Transformer that converts the inbound payload to an object by delegating to a Converter<Object, Object>.
PayloadTypeRouter	A Message Router that resolves the `MessageChannel` based on the `Message's` payload type.
PayloadTypeRouterParser	Parser for the <payload-type-router/> element.
PayloadTypeSelector	A `MessageSelector` implementation that checks the type of the `Message` payload.
PayloadValidator<T>	Validate a message payload.
PersistMode	Indicates how entities shall be persisted to the underlying persistence store.
PointToPointChannelParser	Parser for the <channel> element.
PointToPointSubscribableAmqpChannel
PojoCodec	Kryo Codec that can encode and decode arbitrary types.
PollableAmqpChannel	A `PollableChannel` implementation that is backed by an AMQP Queue.
PollableChannelNode	Represents a pollable channel.
PollableJmsChannel
PollableKafkaChannel	Pollable channel backed by an Apache Kafka topic.
Poller	Provides the `PollerMetadata` options for the Messaging annotations for polled endpoints.
PollerFactory	An `Adapter` class for the `Pollers` factory.
PollerMetadata
PollerParser	Parser for the <poller> element.
Pollers	An utility class to provide `PollerSpec`s for `PollerMetadata` configuration variants.
PollerSpec	An `IntegrationComponentSpec` for `PollerMetadata`s.
PollingConsumer	Message Endpoint that connects any `MessageHandler` implementation to a `PollableChannel`.
PollingOperations	Operations to perform on some message source.
PollSkipAdvice	An advice that can be added to a poller's advice chain that determines whether a poll should be skipped or not.
PollSkipStrategy	Implementations determine whether a particular poll should be skipped.
Pool<T>	Represents a pool of items.
PoolItemNotAvailableException	Thrown when a pooled item could not be obtained for some reason.
Pop3MailInboundChannelAdapterSpec	A `MailInboundChannelAdapterSpec` for POP3.
Pop3MailReceiver	A `MailReceiver` implementation that polls a mail server using the POP3 protocol.
PositionSupportingParameterSource
PostgresChannelMessageStoreQueryProvider
PostProcessingMessageHandler	Implementations of this interface are subclasses of `AbstractMessageHandler` that perform post processing after the `AbstractMessageHandler.handleMessageInternal(org.springframework.messaging.Message)` call.
PresenceInboundChannelAdapterParser	Parser for 'xmpp:presence-inbound-channel-adapter' element.
PresenceListeningEndpoint	An inbound endpoint that is able to login and then emit particular Presence event occurs within the logged-in user's `Roster`.
PresenceOutboundChannelAdapterParser	Parser for 'xmpp:presence-outbound-channel-adapter' element
PresenceSendingMessageHandler	MessageHandler that publishes updated Presence values for a given XMPP connection.
PriorityCapableChannelMessageStore	A `ChannelMessageStore` that supports the notion of message priority.
PriorityChannel	A message channel that prioritizes messages based on a `Comparator`.
PriorityChannelSpec
ProcedureParameter	Abstraction of Procedure parameters allowing to provide static parameters and SpEl Expression based parameters.
PropertiesBuilder	A `Builder` pattern implementation for the `Properties`.
PropertiesPersistingMetadataStore	Properties file-based implementation of `MetadataStore`.
PseudoTransactionManager	An implementation of `PlatformTransactionManager` that provides transaction-like semantics to `MessageSource`s that are not inherently transactional.
Publisher	Annotation to indicate that a method, or all public methods if applied at class-level, should publish Messages.
PublisherAnnotationAdvisor	An advisor that will apply the `MessagePublishingInterceptor` to any methods containing the provided annotations.
PublisherAnnotationBeanPostProcessor	Post-processes beans that contain the method-level @`Publisher` annotation.
PublisherRegistrar
PublishingInterceptorParser	Parser for the <publishing-interceptor> element.
PublishSubscribeAmqpChannel	The `AbstractSubscribableAmqpChannel` extension for pub-sub semantics based on the `FanoutExchange`.
PublishSubscribeChannel	A channel that sends Messages to each of its subscribers.
PublishSubscribeChannelParser	Parser for the <publish-subscribe-channel> element.
PublishSubscribeChannelSpec<S extends PublishSubscribeChannelSpec<S>>
PublishSubscribeKafkaChannel	Publish/subscribe channel backed by an Apache Kafka topic.
PublishSubscribeSpec	The `PublishSubscribeChannelSpec` extension to configure as a general flow callback for sub-flows as subscribers.
PythonScriptExecutor	A `ScriptExecutor` that implements special handling required for Python to emulate behavior similar to other JSR223 scripting languages.
PythonScriptExecutor.PythonVariableParser
QueueChannel	Simple implementation of a message channel.
QueueChannelOperations	Operations available on a channel that has queuing semantics.
QueueChannelSpec
QueueChannelSpec.MessageStoreSpec	The `ChannelMessageStore`-specific `QueueChannelSpec` extension.
R2dbc	Java DSL Factory class for R2DBC components.
R2dbcMessageHandler	Implementation of `ReactiveMessageHandler` which writes Message payload into a Relational Database, using reactive r2dbc support.
R2dbcMessageHandler.Type	/** The mode for the `R2dbcMessageHandler`.
R2dbcMessageHandlerSpec	The `ReactiveMessageHandlerSpec` for the `R2dbcMessageHandler`.
R2dbcMessageSource	An instance of `MessageSource` which returns a `Message` with a payload which is the result of execution of query.
R2dbcMessageSourceSpec	The `MessageSourceSpec` for the `R2dbcMessageSource`.
RateLimiterRequestHandlerAdvice	An `AbstractRequestHandlerAdvice` extension for a rate limiting to service method calls.
RateLimiterRequestHandlerAdvice.RateLimitExceededException	A `MessagingException` wrapper for the `RequestNotPermitted` with the `requestMessage` and `target` context.
RawRecordHeaderErrorMessageStrategy	`ErrorMessageStrategy` extension that adds the raw record as a header to the `ErrorMessage`.
Reactive	Provides reactive configuration options for the consumer endpoint making any input channel as a reactive stream source of data.
ReactiveMessageHandlerAdapter	A `MessageHandler` implementation to adapt a `ReactiveMessageHandler` for synchronous invocations.
ReactiveMessageHandlerSpec<S extends ReactiveMessageHandlerSpec<S,H>,H extends ReactiveMessageHandler>	The `MessageHandlerSpec` extension for `ReactiveMessageHandler`.
ReactiveMessageSourceProducer	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<?>>)`
ReactiveMongoDbMessageHandlerSpec	A `ReactiveMessageHandlerSpec` extension for the Reactive MongoDb Outbound endpoint `ReactiveMongoDbStoringMessageHandler`.
ReactiveMongoDbMessageSource	An instance of `MessageSource` which returns a `Message` with a payload which is the result of execution of a `Query`.
ReactiveMongoDbMessageSourceSpec	A `AbstractMongoDbMessageSourceSpec` implementation for a `ReactiveMongoDbMessageSource`.
ReactiveMongoDbStoringMessageHandler	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`.
ReactiveRedisStreamMessageHandler	Implementation of `ReactiveMessageHandler` which writes Message payload or Message itself (see `ReactiveRedisStreamMessageHandler.extractPayload`) into a Redis stream using Reactive Stream operations.
ReactiveRedisStreamMessageProducer	A `MessageProducerSupport` for reading messages from a Redis Stream and publishing them into the provided output channel.
ReactiveRequestHandlerAdvice	A `MethodInterceptor` for message handlers producing a `Mono` as a payload for reply.
ReactiveStreamsConsumer	An `AbstractEndpoint` implementation for Reactive Streams subscription into an input channel and reactive consumption of messages from that channel.
ReactiveStreamsSubscribableChannel
ReactorNettyTcpStompSessionManager	The `ReactorNettyTcpStompClient` based `AbstractStompSessionManager` implementation.
ReceiptEvent	The `AbstractSubProtocolEvent` implementation, which is emitted for the WebSocket sub-protocol-specific `RECEIPT` frame on the client side.
ReceiveCounters	Counters for components that maintain receive counters.
ReceiveCountersAware
ReceiveMessageAdvice	An AOP advice to perform hooks before and/or after a `receive()` contract is called.
RecipientListRouter	`<recipient-list-router id="simpleRouter" input-channel="routingChannelA"> <recipient channel="channel1"/> <recipient channel="channel2"/> </recipient-list-router>`
RecipientListRouter.Recipient
RecipientListRouterManagement	Exposes adding/removing individual recipients operations for RecipientListRouter.
RecipientListRouterParser	Parser for the <recipient-list-router/> element.
RecipientListRouterSpec	An `AbstractRouterSpec` for a `RecipientListRouter`.
RecursiveDirectoryScanner	The `DefaultDirectoryScanner` extension which walks through the directory tree using `Files.walk(Path, int, FileVisitOption...)`.
RedisChannelMessageStore	Specialized Redis `ChannelMessageStore` that uses a list to back a QueueChannel.
RedisChannelParser	Parser for the 'channel' and 'publish-subscribe-channel' elements of the Spring Integration Redis namespace.
RedisChannelPriorityMessageStore	Specialized Redis `PriorityCapableChannelMessageStore` that uses lists to back a QueueChannel.
RedisExceptionEvent
RedisHeaders	Pre-defined names and prefixes to be used for for dealing with headers required by Redis components
RedisInboundChannelAdapter
RedisInboundChannelAdapterParser
RedisIntegrationEvent
RedisLockRegistry	Implementation of `ExpirableLockRegistry` providing a distributed lock using Redis.
RedisMessageStore	Redis implementation of the key/value style `MessageStore` and `MessageGroupStore`
RedisMetadataStore	Redis implementation of `ConcurrentMetadataStore`.
RedisNamespaceHandler	Namespace handler for Spring Integration's 'redis' namespace.
RedisOutboundChannelAdapterParser	Parser for the `<outbound-channel-adapter/>` component.
RedisOutboundGateway	The Gateway component implementation to perform Redis commands with provided arguments and to return command result.
RedisOutboundGatewayParser	Parser for the `<int-redis:outbound-gateway/>` component.
RedisPublishingMessageHandler
RedisQueueInboundChannelAdapterParser	Parser for the <queue-inbound-channel-adapter> element of the 'redis' namespace.
RedisQueueInboundGateway
RedisQueueInboundGatewayParser	Parser for the <queue-inbound-gateway> element of the 'redis' namespace.
RedisQueueMessageDrivenEndpoint
RedisQueueOutboundChannelAdapter
RedisQueueOutboundChannelAdapterParser	Parser for the <int-redis:queue-outbound-channel-adapter> element.
RedisQueueOutboundGateway
RedisQueueOutboundGatewayParser	Parser for the <int-redis:queue-outbound-channel-adapter> element.
RedisStoreInboundChannelAdapterParser	Parser for Redis store inbound adapters
RedisStoreMessageSource	Inbound channel adapter which returns a Message representing a view into a Redis store.
RedisStoreOutboundChannelAdapterParser	Parser for the <redis:store-outbound-channel-adapter> element.
RedisStoreWritingMessageHandler	Implementation of `MessageHandler` which writes Message data into a Redis store identified by a key `String`.
RefreshableResourceScriptSource	A `ScriptSource` implementation, which caches a script string and refreshes it from the target file (if modified) according the provided `RefreshableResourceScriptSource.refreshDelay`.
RegexPatternFileListFilter	Implementation of AbstractRegexPatternMatchingFileListFilter for java.io.File instances.
RegexTestXPathMessageSelector	XPath `MessageSelector` that tests if a provided String value matches a given Regular Expression.
RegexUtils	Regular Expression Utilities.
RegistrationIds	Default registration ids for serializers provided by the framework.
ReleaseStrategy	Strategy for determining when a group of messages reaches a state of completion (i.e.
ReleaseStrategy	Indicates that a method is capable of asserting if a list of messages or payload objects is complete.
ReleaseStrategyFactoryBean	Convenience factory for XML configuration of a `ReleaseStrategy`.
ReloadableResourceBundleExpressionSource	`ExpressionSource` implementation that accesses resource bundles using specified basenames.
RemoteFileInboundChannelAdapterSpec<F,S extends RemoteFileInboundChannelAdapterSpec<F,S,MS>,MS extends AbstractInboundFileSynchronizingMessageSource<F>>	A `MessageSourceSpec` for an `AbstractInboundFileSynchronizingMessageSource`.
RemoteFileOperations<F>	Strategy for performing operations on remote files.
RemoteFileOperations.OperationsCallback<F,T>	Callback for using the same session for multiple RemoteFileTemplate operations.
RemoteFileOutboundChannelAdapterParser
RemoteFileOutboundGatewaySpec<F,S extends RemoteFileOutboundGatewaySpec<F,S>>	The `MessageHandlerSpec` for the `AbstractRemoteFileOutboundGateway`.
RemoteFileStreamingInboundChannelAdapterSpec<F,S extends RemoteFileStreamingInboundChannelAdapterSpec<F,S,MS>,MS extends AbstractRemoteFileStreamingMessageSource<F>>	A `MessageSourceSpec` for an `AbstractRemoteFileStreamingMessageSource`.
RemoteFileTemplate<F>	A general abstraction for dealing with remote files.
RemoteFileUtils	Utility methods for supporting remote file operations.
RendezvousChannel	A zero-capacity version of `QueueChannel` that delegates to a `SynchronousQueue` internally.
RendezvousChannelSpec
RenewableLockRegistry	A `LockRegistry` implementing this interface supports the renewal of the time to live of a lock.
ReplyProducingMessageHandlerWrapper	The `AbstractReplyProducingMessageHandler` wrapper around raw `MessageHandler` for request-reply scenarios, e.g.
ReplyRequiredException	Exception that indicates no reply message is produced by a handler that does have a value of true for the 'requiresReply' property.
RequestHandlerCircuitBreakerAdvice	A circuit breaker that stops calling a failing service after threshold failures, until halfOpenAfter milliseconds has elapsed.
RequestHandlerCircuitBreakerAdvice.CircuitBreakerOpenException	An exception thrown when the circuit breaker is in an open state.
RequestHandlerRetryAdvice	Uses spring-retry to perform stateless or stateful retry.
RequestMapping	Class for mapping web requests onto specific `HttpRequestHandlingEndpointSupport`.
RequestReplyExchanger	Interface for a request/reply Message exchange.
RequestReplyHeaderMapper<T>	Request/Reply strategy interface for mapping `MessageHeaders` to and from other types of objects.
RequestResponseScenario	Defines a Spring Integration request response test scenario.
ResequencerParser	Parser for the <resequencer> element.
ResequencerSpec
ResequencingMessageGroupProcessor	This class implements all the strategy interfaces needed for a default resequencer.
ResequencingMessageHandler	Resequencer specific implementation of `AbstractCorrelatingMessageHandler`.
ResettableFileListFilter<F>	A `FileListFilter` that can be reset by removing a specific file from its state.
ResourceInboundChannelAdapterParser	Parser for 'resource-inbound-channel-adapter'
ResourceRetrievingMessageSource	Implementation of `MessageSource` based on `ResourcePatternResolver` which will attempt to resolve `Resource`s based on the pattern specified.
ResultFactory	Factory to create a `Result` possibly taking into account the provided message payload instance.
ResultToDocumentTransformer	Creates a `Document` from a `Result` payload.
ResultToStringTransformer	Converts the passed `Result` to an instance of `String`.
ResultTransformer	Implementations of this class allow for the transformation of `Result` objects to other formats.
RetrievingJpaOutboundGatewayParser	The Parser for the Retrieving Jpa Outbound Gateway.
RetryAdviceParser
RetryStateGenerator	Strategy interface for generating a `RetryState` instance based on a message.
ReturnedAmqpMessageException	A MessagingException for a returned message.
ReversibleFileListFilter<F>	A `FileListFilter` that allows the caller to reverse (roll back) state changes.
RFC5424MessageConverter	`MessageConverter`; delegates to a `RFC5424SyslogParser` if necessary (TCP will have already done the syslog conversion because it needs to handle different message framing).
RFC5424SyslogParser	Parse for RFC 5424 syslog messages; when used with TCP, requires the use of a `RFC6587SyslogDeserializer` which decodes the framing.
RFC5424SyslogParser.Reader
RFC5424SyslogParser.Severity
RFC6587SyslogDeserializer	RFC5424/6587 Deserializer.
RmiInboundGateway	Deprecated. since 5.4 with no replacement.
RmiInboundGatewayParser	Deprecated. since 5.4 with no replacement.
RmiNamespaceHandler	Deprecated. since 5.4 with no replacement.
RmiOutboundGateway	Deprecated. since 5.4 with no replacement.
RmiOutboundGateway.RmiProxyFactoryBeanConfigurer	Allows configuration of the proxy factory bean before the RMI proxy is created.
RmiOutboundGatewayParser	Deprecated. since 5.4 with no replacement.
Role	Annotate endpoints to assign them to a role.
RotatingServerAdvice	A smart poller advice that rotates across multiple remote servers/directories.
RotationPolicy	A strategy for rotating advices to allow reconfiguring the message source before and/or after a poll.
RotationPolicy.KeyDirectory	A key for a thread-local store and its related directory pair.
RoundRobinLoadBalancingStrategy	Round-robin implementation of `LoadBalancingStrategy`.
Router	Indicates that a method is capable of resolving to a channel or channel name based on a message, message header(s), or both.
RouterAnnotationPostProcessor	Post-processor for Methods annotated with `@Router`.
RouterFactoryBean	Factory bean for creating a Message Router.
RouterSpec<K,R extends AbstractMappingMessageRouter>	The `AbstractRouterSpec` for an `AbstractMappingMessageRouter`.
RoutingMessageHandlerNode	Represents an endpoint that can route to multiple channels.
RoutingSlipHeaderValueMessageProcessor	The `RoutingSlip` `HeaderValueMessageProcessor` specific implementation.
RoutingSlipRouteStrategy	The `RoutingSlip` strategy to determine the next `replyChannel`.
RSocketConnectedEvent	An `IntegrationEvent` to indicate that `RSocket` from the client is connected to the server.
RSocketInboundGateway	The `MessagingGatewaySupport` implementation for the `IntegrationRSocketEndpoint`.
RSocketInboundGatewayParser	Parser for the <inbound-gateway/> element of the 'rsocket' namespace.
RSocketInboundGatewaySpec	The `MessagingGatewaySpec` implementation for the `RSocketInboundGateway`.
RSocketInteractionModel	The RSocket protocol interaction models.
RSocketNamespaceHandler	Namespace handler for Spring Integration XML configuration for RSocket support.
RSocketOutboundGateway	An Outbound Messaging Gateway for RSocket requests.
RSocketOutboundGatewayParser	Parser for the 'outbound-gateway' element of the rsocket namespace.
RSocketOutboundGatewaySpec	The `MessageHandlerSpec` implementation for the `RSocketOutboundGateway`.
RSockets	The RSocket components Factory.
RubyScriptExecutor	A `DefaultScriptExecutor` extension for Ruby scripting support.
SampleFacade
ScatterGatherHandler	The `MessageHandler` implementation for the Scatter-Gather EIP pattern.
ScatterGatherParser	Parser for the <scatter-gather> element.
ScatterGatherSpec	A `GenericEndpointSpec` extension for the `ScatterGatherHandler`.
ScriptExecutingMessageProcessor	An `AbstractScriptExecutingMessageProcessor` implementation for evaluating scripts from the provided `ScriptSource` in the provided `ScriptExecutor` against an optional binding `variables`.
ScriptExecutingMessageSource	The `MessageSource` strategy implementation to produce a `Message` from underlying ScriptExecutingMessageSource.scriptMessageProcessor for polling endpoints.
ScriptExecutingProcessorFactory	The factory to create `AbstractScriptExecutingMessageProcessor` instances for provided arguments.
ScriptExecutor	A script evaluation abstraction against `ScriptSource` and optional binding `variables`.
ScriptExecutorFactory	The scripting configuration utilities.
ScriptingException
ScriptMessageSourceSpec	The `MessageSourceSpec` for Dynamic Language Scripts.
ScriptNamespaceHandler
ScriptParser	An `AbstractScriptParser` parser extension for the `<int-script:script>` tag.
Scripts	The factory for Dynamic Language Scripts (Groovy, Ruby, Python, JavaScript etc.).
ScriptSpec	The `MessageProcessorSpec` implementation for the `DslScriptExecutingMessageProcessor`.
ScriptVariableGenerator	Strategy interface to provide a `Map` of variables to the script execution context.
SearchTermStrategy	Strategy to be used to generate a `SearchTerm` See `ImapMailReceiver`
SecuredChannel	An annotation to be applied for the `MessageChannel` bean definition from JavaConfig - on `@Bean` method level.
SecuredChannelsParser	Creates a `ChannelSecurityInterceptor` to control send and receive access, and creates a bean post-processor to apply the interceptor to `MessageChannel`s whose names match the specified patterns.
SecurityContextPropagationChannelInterceptor	The `ExecutorChannelInterceptor` implementation responsible for the `SecurityContext` propagation from one message flow's thread to another through the `MessageChannel`s involved in the flow.
SecurityIntegrationConfigurationInitializer	The Integration Security infrastructure `beanFactory` initializer.
SelectorChainParser	Parser for the <selector-chain/> element.
SelectorParser	Parser for a top-level <selector/> element.
SendTimers	Success and failure timer stats.
SendTimersAware
SequenceSizeReleaseStrategy	An implementation of `ReleaseStrategy` that simply compares the current size of the message list to the expected 'sequenceSize'.
SerializingHttpMessageConverter	An `HttpMessageConverter` implementation for `Serializable` instances.
ServerRSocketConnector	A server `AbstractRSocketConnector` extension to accept and manage client RSocket connections.
ServerRSocketMessageHandler	An `IntegrationRSocketMessageHandler` extension for RSocket service side.
ServerWebSocketContainer	The `IntegrationWebSocketContainer` implementation for the `server` `WebSocketHandler` registration.
ServerWebSocketContainer.SockJsServiceOptions
ServerWebSocketContainerParser	The `AbstractSingleBeanDefinitionParser` implementation for the `<websocket:server-container/>` element.
ServiceActivatingHandler
ServiceActivator	Indicates that a method is capable of handling a message or message payload.
ServiceActivatorAnnotationPostProcessor	Post-processor for Methods annotated with `@ServiceActivator`.
ServiceActivatorFactoryBean	FactoryBean for creating `ServiceActivatingHandler` instances.
ServiceActivatorParser	Parser for the <service-activator> element.
ServiceUnavailableException	The `WebServiceException` extension to indicate that the server endpoint is temporary unavailable.
Session<F>	Common abstraction for a Session with a remote File system.
SessionCallback<F,T>	Callback invoked by `RemoteFileOperations.execute()` - allows multiple operations on a session.
SessionCallbackWithoutResult<F>	Simple convenience implementation of `SessionCallback` for cases where no result is returned.
SessionClosedEvent	An event emitted when a session is closed.
SessionClosedEvent	An event emitted when a session is closed.
SessionFactory<F>	Factory for acquiring `Session` instances.
SessionFactoryLocator<F>	A factory returning a `SessionFactory` based on some key.
SessionFactoryMapBuilder<T>	A `MapBuilder` to producer a map that maps objects to `SessionFactory`s.
SessionOpenedEvent	An event emitted when a session is opened.
SessionOpenedEvent	An event emitted when a session is opened.
Sftp	The factory for SFTP components.
SftpFileInfo	A `FileInfo` implementation for SFTP.
SftpInboundChannelAdapterParser	Parser for 'sftp:inbound-channel-adapter'
SftpInboundChannelAdapterSpec	A `RemoteFileInboundChannelAdapterSpec` for an `SftpInboundFileSynchronizingMessageSource`.
SftpInboundFileSynchronizer	Handles the synchronization between a remote SFTP directory and a local mount.
SftpInboundFileSynchronizingMessageSource	A `MessageSource` implementation for SFTP that delegates to an InboundFileSynchronizer.
SftpMessageHandler	Subclass of `FileTransferringMessageHandler` for SFTP.
SftpMessageHandlerSpec
SftpNamespaceHandler	Provides namespace support for using SFTP.
SftpOutboundChannelAdapterParser	Parser for SFTP Outbound Channel Adapters.
SftpOutboundGateway	Outbound Gateway for performing remote file operations via SFTP.
SftpOutboundGatewayParser
SftpOutboundGatewaySpec
SftpPersistentAcceptOnceFileListFilter	Persistent file list filter using the server's file timestamp to detect if we've already 'seen' this file.
SftpRegexPatternFileListFilter	Implementation of `AbstractRegexPatternFileListFilter` for SFTP.
SftpRemoteFileTemplate	SFTP version of `RemoteFileTemplate` providing type-safe access to the underlying ChannelSftp object.
SftpSession	Default SFTP `Session` implementation.
SftpSimplePatternFileListFilter	Implementation of `AbstractSimplePatternFileListFilter` for SFTP.
SftpStreamingInboundChannelAdapterParser
SftpStreamingInboundChannelAdapterSpec
SftpStreamingMessageSource	Message source for streaming SFTP remote file contents.
SftpSystemMarkerFilePresentFileListFilter	SFTP implementation of `AbstractMarkerFilePresentFileListFilter`.
SharedSessionCapable	A `SessionFactory` that implements this interface is capable of supporting a shared session.
SimpleAcknowledgment	Opaque object for manually acknowledging.
SimpleActiveIdleMessageSourceAdvice	Deprecated. since 5.3 in favor of `SimpleActiveIdleReceiveMessageAdvice` with the same (but more common) functionality.
SimpleActiveIdleReceiveMessageAdvice	A simple advice that polls at one rate when messages exist and another when there are no messages.
SimpleFromAvroTransformer	An Apache Avro transformer to create generated `SpecificRecord` objects from `byte[]`.
SimpleJsonSerializer	Extremely simple JSON serializer.
SimpleMessageConverter
SimpleMessageGroup	Represents a mutable group of correlated messages that is bound to a certain `MessageStore` and group id.
SimpleMessageGroupFactory	The `MessageGroupFactory` implementation to produce `SimpleMessageGroup` instances.
SimpleMessageGroupFactory.GroupType
SimpleMessageGroupProcessor	A `MessageGroupProcessor` that simply returns the messages in the group.
SimpleMessageListenerContainerSpec	Spec for a `SimpleMessageListenerContainer`.
SimpleMessageStore	Map-based in-memory implementation of `MessageStore` and `MessageGroupStore`.
SimpleMetadataStore	Simple implementation of `MetadataStore` that uses a `ConcurrentMap` for the data store.
SimpleMultipartFileReader	`MultipartFileReader` implementation that does not maintain metadata from the original `MultipartFile` instance.
SimplePatternFileListFilter	Filter that supports ant style path expressions, which are less powerful but more readable than regular expressions.
SimplePollSkipStrategy	A simple `PollSkipStrategy` to be used with a `PollSkipAdvice`.
SimplePool<T>	Implementation of `Pool` supporting dynamic resizing and a variable timeout when attempting to obtain an item from the pool.
SimplePool.PoolItemCallback<T>	User of the pool provide an implementation of this interface; called during various pool operations.
SimplePublisherMetadataSource	Simple implementation of `PublisherMetadataSource` that allows for configuration of a single channel name, payload expression, and array of header key=value expressions.
SimpleSequenceSizeReleaseStrategy	An implementation of `ReleaseStrategy` that simply compares the current size of the message list to the expected 'sequenceSize'.
SimpleToAvroTransformer	An Apache Avro transformer for generated `SpecificRecord` objects.
SimpleWebServiceInboundGateway
SimpleWebServiceOutboundGateway	An outbound Messaging Gateway for invoking a Web Service.
SimpleWsInboundGatewaySpec	The spec for a `SimpleWebServiceInboundGateway`.
SimpleWsOutboundGatewaySpec	The spec for a `SimpleWebServiceOutboundGateway`.
SimpleWsOutboundGatewaySpec.SimpleWsOutboundGatewayNoTemplateSpec	Spec for a `SimpleWebServiceOutboundGateway` where an external `WebServiceTemplate` is not provided.
SingleRequestResponseScenarioTests	Convenience class for a single `RequestResponseScenario` test
SmartLifecycleRoleController	Bulk start/stop `SmartLifecycle` in a particular role in phase order.
SoapHeaderMapper	A convenience interface that extends `RequestReplyHeaderMapper`, parameterized with `SoapHeader`.
SocketCustomizer	Configures a socket.
SocketInfo	Simple wrapper around `Socket` providing access to getters (except input/output streams).
SoftEndOfStreamException	Used to communicate that a stream has closed, but between logical messages.
SourceCreatingTransformer	Transforms the payload to a `Source` using a `SourceFactory`.
SourceFactory	Factory to create a `Source` possibly taking into account the provided message payload instance.
SourcePollingChannelAdapter	A Channel Adapter implementation for connecting a `MessageSource` to a `MessageChannel`.
SourcePollingChannelAdapterFactoryBean	FactoryBean for creating a SourcePollingChannelAdapter instance.
SourcePollingChannelAdapterSpec
SpelExpressionRetryStateGenerator	Creates a DefaultRetryState from a `Message`.
SpelFunctionFactoryBean	A `FactoryBean` implementation to encapsulate the population of a static `Method` from the provided SpelFunctionFactoryBean.functionClass and SpelFunctionFactoryBean.functionMethodSignature as a valid `StandardEvaluationContext` function.
SpelFunctionParser	Parser for the <spel-function> element.
SpelPropertyAccessorRegistrar	Utility class that keeps track of a Set of SpEL `PropertyAccessor`s in order to register them with the "integrationEvaluationContext" upon initialization.
SpelPropertyAccessorsParser	Parser for the <spel-property-accessors> element.
Splitter	Indicates that a method is capable of splitting a single message or message payload to produce multiple messages or payloads.
SplitterAnnotationPostProcessor	Post-processor for Methods annotated with `@Splitter`.
SplitterEndpointSpec<S extends AbstractMessageSplitter>	A `ConsumerEndpointSpec` for a `AbstractMessageSplitter` implementations.
SplitterFactoryBean	Factory bean for creating a Message Splitter.
SplitterParser	Parser for the <splitter/> element.
SpringIntegrationTest	Annotation that can be specified on a test class that runs Spring Integration based tests.
SqlParameterSourceFactory	Collaborator for JDBC adapters which allows creation of instances of `SqlParameterSource` for use in update operations.
SqlServerChannelMessageStoreQueryProvider	Channel message store query provider for Microsoft SQL Server / Azure SQL database.
StackTraceUtils	Utility methods for analyzing stack traces.
StandardHeaderEnricherParser	Parser for the <header-enricher> element within the core integration namespace.
StandardIntegrationFlow	The standard implementation of the `IntegrationFlow` interface instantiated by the Framework.
StandardIntegrationFlowContext	Standard implementation of `IntegrationFlowContext`.
StandardRotationPolicy	Standard rotation policy; iterates over key/directory pairs; when the end is reached, starts again at the beginning.
StaticHeaderValueMessageProcessor<T>
StaticMessageHeaderAccessor	Lightweight type-safe header accessor avoiding object creation just to access a header.
StompConnectionFailedEvent	The `StompIntegrationEvent` implementation for the failed connection exceptions.
StompExceptionEvent	The `StompIntegrationEvent` implementation for the exception from STOMP Adapters.
StompHeaderMapper	The STOMP `HeaderMapper` implementation.
StompInboundChannelAdapter	The `MessageProducerSupport` for STOMP protocol to handle STOMP frames from provided destination and send messages to the `outputChannel`.
StompInboundChannelAdapterParser	The `AbstractChannelAdapterParser` implementation for the `<stomp:inbound-channel-adapter/>` element.
StompIntegrationEvent	Base class for all `IntegrationEvent`s generated by the STOMP Adapters.
StompMessageHandler	The `AbstractMessageHandler` implementation to send messages to STOMP destinations.
StompNamespaceHandler
StompOutboundChannelAdapterParser	The `AbstractOutboundChannelAdapterParser` implementation for the `<stomp:outbound-channel-adapter/>` element.
StompReceiptEvent	The `StompIntegrationEvent` for the STOMP `RECEIPT` Frames or lost receipts.
StompSessionConnectedEvent	The `StompIntegrationEvent` indicating the STOMP session establishment.
StompSessionManager	An abstraction to manage the STOMP Session and connection/disconnection for `StompSessionHandler`.
StoredProcExecutor	This class is used by all Stored Procedure (Stored Function) components and provides the core functionality to execute those.
StoredProcMessageHandler	A message handler that executes Stored Procedures for update purposes.
StoredProcMessageHandlerParser
StoredProcOutboundGateway	An `AbstractReplyProducingMessageHandler` implementation for performing RDBMS stored procedures which return results.
StoredProcOutboundGatewayParser
StoredProcParserUtils
StoredProcPollingChannelAdapter	A polling channel adapter that creates messages from the payload returned by executing a stored procedure or Sql function.
StoredProcPollingChannelAdapterParser
StreamClosedEvent	Application event published when EOF is detected on a stream.
StreamNamespaceHandler
StreamTransformer	Transforms an InputStream payload to a byte[] or String (if a charset is provided).
StreamTransformerParser	Parser for `<stream-transformer/>` element.
StringObjectMapBuilder	A map builder creating a map with String keys and values.
StringResultFactory
StringSourceFactory	`SourceFactory` implementation which supports creation of a `StringSource` from a `Document`, `File` or `String` payload
StringStringMapBuilder	A map builder creating a map with String keys and values.
StringValueTestXPathMessageSelector	XPath `MessageSelector` that tests if a provided value supports payloads of type `Document` or `String`.
SubProtocolHandlerRegistry	The utility class to encapsulate search algorithms for a set of provided `SubProtocolHandler`s.
SubscribableChannelManagement	Metrics for subscribable channels.
SubscribableJmsChannel	An `AbstractJmsChannel` implementation for message-driven subscriptions.
SubscribableKafkaChannel	Subscribable channel backed by an Apache Kafka topic.
SubscribableRedisChannel	An `AbstractMessageChannel` implementation with `BroadcastCapableChannel` aspect to provide a pub-sub semantics to consume messages fgrom Redis topic.
SupplierExpression<T>	An `Expression` that simply invokes `Supplier.get()` on its provided `Supplier`.
SyslogHeaders	Headers in a `Map` generated by the @link `SyslogToMapTransformer` that will be added to Spring Integration messages as headers, prefixed by `SyslogHeaders.PREFIX`.
SyslogInboundChannelAdapterParser	Parses a `<int-syslog:inbound-channel-adapter/>`.
SyslogNamespaceHandler	Namspace handler for spring-integration-syslog.
SyslogReceivingChannelAdapterFactoryBean	Factory bean to create syslog inbound adapters (UDP or TCP).
SyslogReceivingChannelAdapterFactoryBean.Protocol
SyslogReceivingChannelAdapterSupport	Base support class for inbound channel adapters.
SyslogToMapTransformer	Transforms a packet in Syslog (RFC3164) format to a Map.
SyslogToMapTransformerParser
TailAdapterSpec	A `MessageProducerSpec` for file tailing adapters.
Tcp	Factory methods for TCP.
TcpClientConnectionFactorySpec	An `AbstractConnectionFactorySpec` for `AbstractClientConnectionFactory`s.
TcpCodecs	Factory class to create TCP Serializer/Deserializers used to encode/decode messages to/from a TCP stream.
TcpConnection	An abstraction over `Socket` and `SocketChannel` that sends `Message` objects by serializing the payload and streaming it to the destination.
TcpConnectionCloseEvent
TcpConnectionEvent	ApplicationEvent representing normal operations on a `TcpConnection`.
TcpConnectionExceptionEvent	ApplicationEvent representing exceptions on a `TcpConnection`.
TcpConnectionFactoryFactoryBean	Instantiates a TcpN(et\|io)(Server\|Client)ConnectionFactory, depending on type and using-nio attributes.
TcpConnectionFactoryParser
TcpConnectionFailedCorrelationEvent	An event emitted when an endpoint cannot correlate a connection id to a connection; the cause is a messaging exception with the failed message.
TcpConnectionFailedEvent	An event emitted when a connection could not be established for some reason.
TcpConnectionInterceptor
TcpConnectionInterceptorFactory	Interface for TCP connection interceptor factories.
TcpConnectionInterceptorFactoryChain
TcpConnectionInterceptorSupport	Base class for `TcpConnectionInterceptor`s; passes all method calls through to the underlying `TcpConnection`.
TcpConnectionOpenEvent
TcpConnectionServerExceptionEvent	`IpIntegrationEvent` representing exceptions on a TCP server socket/channel.
TcpConnectionServerListeningEvent	`IpIntegrationEvent` emitted when a server begins listening.
TcpConnectionSupport	Base class for TcpConnections.
TcpDeserializationExceptionEvent	Event representing an exception while decoding an incoming stream.
TcpInboundChannelAdapterParser	Channel Adapter that receives TCP stream frames and maps them to Messages.
TcpInboundChannelAdapterSpec	A `MessageProducerSpec` for `TcpReceivingChannelAdapter`s.
TcpInboundGateway	Inbound Gateway using a server connection factory - threading is controlled by the factory.
TcpInboundGatewayParser
TcpInboundGatewaySpec	A `MessagingGatewaySpec` for `TcpInboundGateway`s.
TcpListener	Classes that implement this interface may register with a connection factory to receive messages retrieved from a `TcpConnection`
TcpMessageMapper	Maps incoming data from a `TcpConnection` to a `Message`.
TcpNetClientConnectionFactory	A client connection factory that creates `TcpNetConnection`s.
TcpNetConnection	A TcpConnection that uses and underlying `Socket`.
TcpNetConnectionSupport	Used by NET connection factories to instantiate a `TcpNetConnection` object.
TcpNetServerConnectionFactory	Implements a server connection factory that produces `TcpNetConnection`s using a `ServerSocket`.
TcpNioClientConnectionFactory	A client connection factory that creates `TcpNioConnection`s.
TcpNioConnection	A TcpConnection that uses and underlying `SocketChannel`.
TcpNioConnectionSupport	Used by NIO connection factories to instantiate a `TcpNioConnection` object.
TcpNioServerConnectionFactory	/** Implements a server connection factory that produces `TcpNioConnection`s using a `ServerSocketChannel`.
TcpNioSSLConnection	Implementation of `TcpConnection` supporting SSL/TLS over NIO.
TcpOutboundChannelAdapterParser
TcpOutboundChannelAdapterSpec	A `MessageHandlerSpec` for `TcpSendingMessageHandler`s.
TcpOutboundGateway	TCP outbound gateway that uses a client connection factory.
TcpOutboundGatewayParser	Parser for the <outbound-gateway> element of the integration 'jms' namespace.
TcpOutboundGatewaySpec	A `MessageHandlerSpec` for `TcpOutboundGateway`s.
TcpReceivingChannelAdapter	Tcp inbound channel adapter using a TcpConnection to receive data - if the connection factory is a server factory, this Listener owns the connections.
TcpSender	An interface representing a sending client of a connection factory.
TcpSendingMessageHandler	Tcp outbound channel adapter using a TcpConnection to send data - if the connection factory is a server factory, the TcpListener owns the connections.
TcpServerConnectionFactory	Connection factories that act as TCP servers, listening for incoming connections.
TcpServerConnectionFactorySpec	An `AbstractConnectionFactorySpec` for `AbstractServerConnectionFactory`s.
TcpSocketFactorySupport	Strategy interface for supplying Socket Factories.
TcpSocketSupport	Strategy interface for modifying sockets.
TcpSSLContextSupport	Strategy interface for the creation of an `SSLContext` object for use with SSL/TLS sockets.
TcpSyslogReceivingChannelAdapter	TCP implementation of a syslog inbound channel adapter.
TestingUtilities	Convenience class providing methods for testing IP components.
TestMailServer	A basic test mail server for pop3, imap, Serves up a canned email message with each protocol.
TestMailServer.ImapServer
TestMailServer.MailServer
TestMailServer.Pop3Server
TestMailServer.SmtpServer
TestUtils
TestUtils.LevelsContainer
TestUtils.TestApplicationContext	A `GenericApplicationContext` extension with some support methods to register Spring Integration beans in the application context at runtime.
ThreadAffinityClientConnectionFactory	A client connection factory that binds a connection to a thread.
ThreadStatePropagationChannelInterceptor<S>	The `ExecutorChannelInterceptor` implementation responsible for the `Thread` (any?) state propagation from one message flow's thread to another through the `MessageChannel`s involved in the flow.
TimeoutCountSequenceSizeReleaseStrategy	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.
TimerFacade
TimerStats	Statistics captured from a timer meter.
TrackableComponent
TransactionHandleMessageAdvice	A `TransactionInterceptor` extension with `HandleMessageAdvice` marker.
TransactionInterceptorBuilder	Provides a fluent API to build a transaction interceptor.
TransactionSynchronizationFactory	Strategy for implementing factories that create `TransactionSynchronization`
TransactionSynchronizationFactoryBean	The `FactoryBean` implementation (with `Builder` style) to be used from JavaConfig to populate `DefaultTransactionSynchronizationFactory` bean.
TransactionSynchronizationFactoryParser	Parser for transaction-synchronizatioin-factory element
TransactionSynchronizationProcessor	Strategy for implementing transaction synchronization processors
Transformer	Indicates that a method is capable of transforming a message, message header, or message payload.
Transformer	Strategy interface for transforming a `Message`.
TransformerAnnotationPostProcessor	Post-processor for Methods annotated with a `@Transformer`.
TransformerFactoryBean	Factory bean for creating a Message Transformer.
TransformerParser	Parser for the <transformer/> element.
Transformers	An utility class to provide methods for out-of-the-box `Transformer`s.
Udp	Factory methods for UDP.
UdpInboundChannelAdapterParser	Channel Adapter that receives UDP datagram packets and maps them to Messages.
UdpInboundChannelAdapterSpec	A `MessageProducerSpec` for `UnicastReceivingChannelAdapter`s.
UdpMulticastOutboundChannelAdapterSpec	A `MessageHandlerSpec` for `MulticastSendingMessageHandler`s.
UdpOutboundChannelAdapterParser
UdpServerListeningEvent	`IpIntegrationEvent` emitted when a server begins listening.
UdpSyslogReceivingChannelAdapter	UDP implementation of a syslog inbound channel adapter.
UdpUnicastOutboundChannelAdapterSpec	A `MessageHandlerSpec` for `UnicastSendingMessageHandler`s.
UnexpiredMessageSelector	A `MessageSelector` that accepts `Messages` that are not yet expired.
UnicastingDispatcher	Implementation of `MessageDispatcher` that will attempt to send a `Message` to at most one of its handlers.
UnicastReceivingChannelAdapter	A channel adapter to receive incoming UDP packets.
UnicastSendingMessageHandler	A `MessageHandler` implementation that maps a Message into a UDP datagram packet and sends that to the specified host and port.
UniqueExpiryCallback	A marker interface extension of the `MessageGroupStore.MessageGroupCallback` for components which should be registered in the `MessageGroupStore` only once.
UniqueMethodFilter
UnmarshallingTransformer	An implementation of `Transformer` that delegates to an OXM `Unmarshaller`.
UnmarshallingTransformerParser
UpdatingJpaOutboundGatewayParser	The Parser for Updating JPA Outbound Gateway.
UploadedMultipartFile	A `MultipartFile` implementation that represents an uploaded File.
UpperBound	Thin wrapper around a Semaphore that allows to create a potentially unlimited upper bound to by used in buffers of messages (e.g.
UseSpelInvoker	Indicates that a POJO handler method (`@ServiceActivator, @Transformer,` etc., or such methods invoked from XML definitions) should be invoked using SpEL.
UUIDConverter	Utility to help generate UUID instances from generic objects.
ValueExpression<V>	A very simple hardcoded implementation of the `Expression` interface that represents an immutable value.
VetoCapableInterceptor	`ChannelInterceptor`s implementing this interface can veto global interception of a particular channel.
WebFlux	The WebFlux components Factory.
WebFluxContextUtils	Utility class for accessing WebFlux integration components from the `BeanFactory`.
WebFluxInboundEndpoint	A `MessagingGatewaySupport` implementation for Spring WebFlux HTTP requests execution.
WebFluxInboundEndpointParser
WebFluxInboundEndpointSpec	The `HttpInboundEndpointSupportSpec` implementation for the `WebFluxInboundEndpoint`.
WebFluxIntegrationConfigurationInitializer	The WebFlux Integration infrastructure `beanFactory` initializer.
WebFluxIntegrationRequestMappingHandlerMapping	The `HandlerMapping` implementation that detects and registers `RequestMappingInfo`s for `HttpRequestHandlingEndpointSupport` from a Spring Integration HTTP configuration of `<inbound-channel-adapter/>` and `<inbound-gateway/>` elements.
WebFluxMessageHandlerSpec	The `BaseHttpMessageHandlerSpec` implementation for the `WebFluxRequestExecutingMessageHandler`.
WebFluxNamespaceHandler	Namespace handler for Spring Integration's webflux namespace.
WebFluxOutboundChannelAdapterParser	Parser for the 'outbound-channel-adapter' element of the webflux namespace.
WebFluxOutboundGatewayParser	Parser for the 'outbound-gateway' element of the webflux namespace.
WebFluxRequestExecutingMessageHandler	A `MessageHandler` implementation that executes HTTP requests by delegating to a Reactive `WebClient` instance.
WebServiceHeaderEnricherParser
WebServiceHeaders	Pre-defined header names to be used when storing or retrieving Web Service properties to/from integration Message Headers.
WebServiceInboundGatewayParser
WebServiceOutboundGatewayParser	Parser for the <outbound-gateway/> element in the 'ws' namespace.
WebSocketInboundChannelAdapter
WebSocketInboundChannelAdapterParser	The `AbstractChannelAdapterParser` implementation for the `<int-websocket:inbound-channel-adapter/>` element.
WebSocketIntegrationConfigurationInitializer	The WebSocket Integration infrastructure `beanFactory` initializer.
WebSocketListener	A contract for handling incoming `WebSocketMessage`s messages as part of a higher level protocol, referred to as "sub-protocol" in the WebSocket RFC specification.
WebSocketNamespaceHandler
WebSocketOutboundMessageHandler
WebSocketOutboundMessageHandlerParser	The `AbstractOutboundChannelAdapterParser` implementation for the `<websocket:outbound-channel-adapter/>` element.
WebSocketStompSessionManager	The `WebSocketStompClient` based `AbstractStompSessionManager` implementation.
WhileLockedProcessor	A simple strategy callback class that allows you to provide a code that needs to be executed under `Lock` provided by `LockRegistry` A typical usage would be to provide implementation of `WhileLockedProcessor.whileLocked()` method and then call `WhileLockedProcessor.doWhileLocked()`
WireTap	A `ChannelInterceptor` that publishes a copy of the intercepted message to a secondary target while still sending the original message to the main channel.
WireTapParser	Parser for the <wire-tap> element.
WireTapSpec	The `IntegrationComponentSpec` implementation for the `WireTap` component.
Ws	Factory class for web service components.
WsIntegrationConfigurationInitializer	The `IntegrationConfigurationInitializer` implementation for the WebService module.
WsNamespaceHandler
XmlPayloadConverter	Converter for creating XML `Document`, `Node` or `Source` instances from other types (e.g.
XmlPayloadValidatingFilterParser
XmlValidatingMessageSelector
XmlValidatingMessageSelector.SchemaType
XmppConnectionFactoryBean	This class configures an `XMPPTCPConnection` object.
XmppConnectionParser	Parser for 'xmpp:xmpp-connection' element
XmppContextUtils
XmppHeaderEnricherParser	Parser for 'xmpp:header-enricher' element
XmppHeaderMapper	A convenience interface that extends `RequestReplyHeaderMapper` but parameterized with the Smack API `Message`.
XmppHeaders	Used as keys for `Message` objects that handle XMPP events.
XmppNamespaceHandler	This class parses the schema for XMPP support.
XPathEvaluationType	Enumeration of different types of XPath evaluation used to indicate the type of evaluation that should be carried out using a provided XPath expression.
XPathExpressionEvaluatingHeaderValueMessageProcessor
XPathExpressionParser	Parser for the <xpath-expression> element.
XPathFilterParser	Parser for the <xpath-filter> element.
XPathHeaderEnricher	Transformer implementation that evaluates XPath expressions against the message payload and inserts the result of the evaluation into a message header.
XPathHeaderEnricherParser	Parser for <xpath-header-enricher> elements.
XPathMessageSplitter	Message Splitter that uses an `XPathExpression` to split a `Document`, `File` or `String` payload into a `NodeList`.
XPathMessageSplitterParser
XPathRouter	Message Router that uses `XPathExpression` evaluation to determine channel names.
XPathRouterParser	Parser for the <xpath-router/> element.
XPathTransformer	Transformer implementation that evaluates an XPath expression against the inbound Message payload and returns a Message whose payload is the result of that evaluation.
XPathTransformerParser	Parser for the 'xpath-transformer' element.
XPathUtils	Utility class for 'xpath' support.
XsltPayloadTransformer	Thread safe XSLT transformer implementation which returns a transformed `Source`, `Document`, or `String`.
XsltPayloadTransformerParser
ZeroMq	Factory class for ZeroMq components DSL.
ZeroMqChannel	The `SubscribableChannel` implementation over ZeroMQ sockets.
ZeroMqChannelSpec	The `MessageChannelSpec` for a `ZeroMqChannel`.
ZeroMqHeaders	The message headers constants to repsent ZeroMq message attributes.
ZeroMqMessageHandler	The `AbstractReactiveMessageHandler` implementation for publishing messages over ZeroMq socket.
ZeroMqMessageHandlerSpec	The `ReactiveMessageHandlerSpec` extension for `ZeroMqMessageHandler`.
ZeroMqMessageProducer	A `MessageProducerSupport` implementation for consuming messages from ZeroMq socket.
ZeroMqMessageProducerSpec
ZeroMqProxy	This class encapsulates the logic to configure and manage a ZeroMQ proxy.
ZeroMqProxy.Type
ZookeeperLockRegistry	`ExpirableLockRegistry` implementation using Zookeeper, or more specifically, Curator `InterProcessMutex`.
ZookeeperLockRegistry.KeyToPathStrategy	Strategy to convert a lock key (e.g.
ZookeeperMetadataStore	Zookeeper-based `ListenableMetadataStore` based on a Zookeeper node.
ZookeeperMetadataStoreException
ZookeeperNamespaceHandler