All Classes

Class	Description
AbstractAggregatingMessageGroupProcessor	Base class for MessageGroupProcessor implementations that aggregate the group of Messages into a single Message.
AbstractBatchingMessageGroupStore
AbstractCandidate	Base implementation of a Candidate.
AbstractChannelAdapterParser	Base parser for Channel Adapters.
AbstractChannelParser	Base class for channel parsers.
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.
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.
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.HeaderMatchers 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>
AbstractInboundGatewayParser	Base class for inbound gateway parsers.
AbstractIntegrationMessageBuilder<T>
AbstractIntegrationNamespaceHandler	Base class for NamespaceHandlers that registers a BeanFactoryPostProcessor for configuring default bean definitions.
AbstractJacksonJsonObjectMapper<N,P,J>	Base class for Jackson JsonObjectMapper implementations.
AbstractJsonInboundMessageMapper<P>	Abstract InboundMessageMapper implementation that maps incoming JSON messages to a Message with the specified payload type.
AbstractKeyValueMessageStore	Base class for implementations of Key/Value style MessageGroupStore and MessageStore.
AbstractKryoCodec	Base class for Codecs using Kryo.
AbstractKryoRegistrar	Base class for KryoRegistrar implementations.
AbstractLeaderEvent	Base ApplicationEvent class for leader based events.
AbstractMappingMessageRouter	Base class for all Message Routers that support mapping from arbitrary String values to Message Channel names.
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.
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 java.lang.annotation.Annotation>	Base class for Method-level annotation post-processors.
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.
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.
AbstractReactiveMessageHandler	Base class for ReactiveMessageHandler implementations.
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
AbstractRouterParser	Base parser for routers.
AbstractRouterSpec<S extends AbstractRouterSpec<S,R>,R extends AbstractMessageRouter>	A MessageHandlerSpec for AbstractMessageRouters.
AbstractSimpleMessageHandlerFactoryBean<H extends org.springframework.messaging.MessageHandler>	Factory bean to create and configure a MessageHandler.
AbstractStandardMessageHandlerFactoryBean	Base class for FactoryBeans that create standard MessageHandler instances.
AbstractSubscribableChannel	Base implementation of MessageChannel that invokes the subscribed handler(s) by delegating to a MessageDispatcher.
AbstractTransformer	A base class for Transformer implementations.
AbstractTransformerParser
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.
AcknowledgmentCallback	A general abstraction over acknowledgments.
AcknowledgmentCallback.Status
AcknowledgmentCallbackFactory<T>	A factory for creating AcknowledgmentCallbacks.
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.
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.
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.
ApplicationEventMulticasterParser	Parser for the <application-event-multicaster> element of the integration namespace.
AsyncMessagingOperations
AsyncMessagingTemplate
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.
BaseIntegrationFlowDefinition<B extends BaseIntegrationFlowDefinition<B>>	The Builder pattern implementation for the EIP-method chain.
BaseIntegrationFlowDefinition.ReplyProducerCleaner
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.
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.
BytesMessageMapper	An OutboundMessageMapper and InboundMessageMapper that maps to/from byte[].
CacheRequestHandlerAdvice	The AbstractRequestHandlerAdvice implementation for caching AbstractReplyProducingMessageHandler.RequestHandler#handleRequestMessage(Message) results.
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.
ChainParser	Parser for the <chain> element.
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.
ChannelMessageStore	A marker interface that indicates this message store has optimizations for use in a QueueChannel.
ChannelPurger	A utility class for purging Messages from one or more QueueChannels.
ChannelResolverUtils	Channel resolution utilities.
Channels
ChannelUtils	Channel utilities.
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
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.
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.
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 MessageConverters which can be overridden with the given converters or added in the end of target converters collection.
ConsumerEndpointFactoryBean	The FactoryBean implementation for AbstractEndpoint population.
ConsumerEndpointSpec<S extends ConsumerEndpointSpec<S,H>,H extends org.springframework.messaging.MessageHandler>	A EndpointSpec for consumer endpoints.
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.
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
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.
DefaultCandidate	Simple Candidate for leadership.
DefaultConfiguringBeanFactoryPostProcessor	A BeanDefinitionRegistryPostProcessor implementation that registers bean definitions for many infrastructure components with their default configurations.
DefaultDatatypeChannelMessageConverter	Default message converter for datatype channels.
DefaultErrorMessageStrategy	A simple ErrorMessageStrategy implementations which produces a error message with original message if the AttributeAccessor has ErrorMessageUtils.INPUT_MESSAGE_CONTEXT_KEY attribute.
DefaultHeaderChannelRegistry	Converts a channel to a name, retaining a reference to the channel keyed by the name.
DefaultInboundChannelAdapterParser	Parser for the <inbound-channel-adapter/> element.
DefaultLeaderEventPublisher	Default implementation of LeaderEventPublisher.
DefaultLockRegistry	Default implementation of LockRegistry which uses Masked Hashcode algorithm to obtain locks.
DefaultMessageBuilderFactory
DefaultMessageSplitter	The default Message Splitter implementation.
DefaultOutboundChannelAdapterParser	Parser for the <outbound-channel-adapter/> element.
DefaultRouterParser	Parser for the <router/> element.
DefaultTransactionSynchronizationFactory	Default implementation of TransactionSynchronizationFactory which takes an instance of TransactionSynchronizationProcessor allowing you to create a TransactionSynchronization using {DefaultTransactionSynchronizationFactory.create(Object) method.
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.
DirectChannel	A channel that invokes a single subscriber for each sent Message.
DirectChannelSpec
DiscardingMessageHandler	Classes implementing this interface are capable of discarding messages.
DiscardingMessageHandlerNode	Represents an endpoint that has a discard channel.
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.
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 BeanFactoryPostProcessors; - Adds several BeanPostProcessors; - Adds annotations processors.
EnableIntegrationManagement	Enables default configuring of management in Spring Integration components in an existing application.
EnableMessageHistory	Enables MessageHistory for Spring 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 org.springframework.beans.factory.BeanNameAware & org.springframework.beans.factory.FactoryBean<? extends AbstractEndpoint>,H>	An IntegrationComponentSpec for endpoints.
EnricherParser	Parser for the 'enricher' element.
EnricherSpec	A ConsumerEndpointSpec extension for the ContentEnricher.
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.
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 ExecutorChannelInterceptors may have reason (e.g.
ExecutorChannelSpec
ExpirableLockRegistry	A LockRegistry implementing this interface supports the removal of aged locks that are not currently locked.
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>
ExpressionEvaluatingReleaseStrategy	A ReleaseStrategy that evaluates an expression.
ExpressionEvaluatingRequestHandlerAdvice	Used to advise MessageHandlers.
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.
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.
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.
FileKryoRegistrar	A KryoRegistrar used to validateRegistration a File serializer.
FileSerializer	A custom Kryo Serializer for serializing File payloads.
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 SubscribableChannels where the MessageHandler is subscribed when the endpoint is started).
FixedSubscriberChannelBeanFactoryPostProcessor	Used to post process candidates for FixedSubscriberChannel MessageHandlers.
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
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
GenericEndpointSpec<H extends org.springframework.messaging.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 ChannelInterceptors 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.
GroupConditionProvider	A contract which can be implemented on the ReleaseStrategy and used in the AbstractCorrelatingMessageHandler to populate the provided group condition supplier.
HandleMessageAdvice	The marker MethodInterceptor interface extension to distinguish advices for some reason.
HandleMessageAdviceAdapter	A HandleMessageAdvice implementation with a plain delegation to the provided MethodInterceptor.
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.
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.
HistoryWritingMessagePostProcessor
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 BeanDefinitions 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 AtomicLongs, for topBits and bottomBits, respectively.
InboundChannelAdapter	Indicates that a method is capable of producing a Message or Message payload.
InboundChannelAdapterAnnotationPostProcessor	Post-processor for Methods annotated with @InboundChannelAdapter.
InboundMessageMapper<T>	Strategy interface for mapping from an Object to aMessage.
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
IntegrationDsl	The Kotlin DslMarker annotation for classes used in scope of DSL, including all the Java DSL classes.
IntegrationEvaluationContextFactoryBean	FactoryBean to populate StandardEvaluationContext instances enhanced with: a BeanFactoryResolver.
IntegrationEvent	Base class for all ApplicationEvents 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 IntegrationFlows, 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.
IntegrationGraphServer	Builds the runtime object model graph.
IntegrationInboundManagement	Marker interface indicating that this IntegrationManagement component initiates message flow.
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.
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.
IntegrationResourceHolder	An implementation of the ResourceHolder which holds an instance of the current Message and the synchronization resource.
IntegrationResourceHolderSynchronization	The base ResourceHolderSynchronization for IntegrationResourceHolder.
IntegrationSimpleEvaluationContextFactoryBean	FactoryBean to populate SimpleEvaluationContext instances enhanced with: a TypeConverter based on the ConversionService from the application context.
IntegrationUtils	General utility methods.
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.
JavaUtils	Deprecated. since 5.5.6 in favor of JavaUtils.
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
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.
LeaderEventPublisher	Interface for publishing leader based application events.
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.
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
ManageableLifecycle	Makes Lifecycle methods manageable.
ManageableSmartLifecycle	Extend ManageableLifecycle to make those methods manageable.
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.
MapMessageConverter	Converts to/from a Map with 2 keys ('headers' and 'payload').
MappingMessageRouterManagement	Exposes channel mapping operations when the router is proxied.
MapToObjectTransformer	Will transform Map to an instance of Object.
MapToObjectTransformerParser
MessageBuilder<T>	The default message builder; creates immutable GenericMessages.
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.
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.
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 org.springframework.messaging.MessageHandler>	An IntegrationComponentSpec for MessageHandlers.
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 org.springframework.messaging.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.
MessageMetadata	Value Object holding metadata about a Message in the MessageStore.
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 MessageProcessors.
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 MessageProducers.
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.
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
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 MessageSources.
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.
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.
MessagingAnnotationPostProcessor	A BeanPostProcessor implementation that processes method-level messaging annotations such as @Transformer, @Splitter, @Router, and @Filter.
MessagingAnnotationUtils	Utility methods to support annotation processing.
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 MessagingGatewaySupports.
MessagingGatewaySupport	A convenient base class for connecting application code to MessageChannels 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 java.lang.annotation.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 InboundMessageMappers 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
MicrometerMetricsCaptorConfiguration	A Configuration to add a MicrometerMetricsCaptor.
MicrometerMetricsCaptorImportSelector	An ImportSelector to conditionally add a MicrometerMetricsCaptorConfiguration bean when io.micrometer.core.instrument.MeterRegistry is present in classpath.
MicrometerNodeEnhancer	Add micrometer metrics to the node.
MimeTypeSerializer	Simple StdSerializer extension to represent a MimeType object in the target JSON as a plain string.
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.
NamedComponent
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.
OnRevokedEvent	Generic event representing that leader has been revoked.
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.
OutboundMessageMapper<T>	Strategy interface for mapping from a Message to an Object.
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.
PatternMatchUtils	Utility methods for pattern matching.
Pausable	Endpoints implementing this interface can be paused/resumed.
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.
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.
PointToPointChannelParser	Parser for the <channel> element.
PojoCodec	Kryo Codec that can encode and decode arbitrary types.
PollableChannelNode	Represents a pollable channel.
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 PollerSpecs for PollerMetadata configuration variants.
PollerSpec	An IntegrationComponentSpec for PollerMetadatas.
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.
PostProcessingMessageHandler	Implementations of this interface are subclasses of AbstractMessageHandler that perform post processing after the AbstractMessageHandler.handleMessageInternal(org.springframework.messaging.Message) call.
PriorityCapableChannelMessageStore	A ChannelMessageStore that supports the notion of message priority.
PriorityChannel	A message channel that prioritizes messages based on a Comparator.
PriorityChannelSpec
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 MessageSources 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.
PublishSubscribeChannel	A channel that sends Messages to each of its subscribers.
PublishSubscribeChannelParser	Parser for the <publish-subscribe-channel> element.
PublishSubscribeChannelSpec<S extends PublishSubscribeChannelSpec<S>>
PublishSubscribeSpec	The PublishSubscribeChannelSpec extension to configure as a general flow callback for sub-flows as subscribers.
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.
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.
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 org.springframework.messaging.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<?>>).
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
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.
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.
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.
RequestReplyExchanger	Interface for a request/reply Message exchange.
RequestReplyHeaderMapper<T>	Request/Reply strategy interface for mapping MessageHeaders to and from other types of objects.
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.
ResourceInboundChannelAdapterParser	Parser for 'resource-inbound-channel-adapter'.
ResourceRetrievingMessageSource	Implementation of MessageSource based on ResourcePatternResolver which will attempt to resolve Resources based on the pattern specified.
RetryAdviceParser
RetryStateGenerator	Strategy interface for generating a RetryState instance based on a message.
Role	Annotate endpoints to assign them to a role.
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.
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.
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'.
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.
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.
SimpleMessageStore	Map-based in-memory implementation of MessageStore and MessageGroupStore.
SimpleMetadataStore	Simple implementation of MetadataStore that uses a ConcurrentMap for the data store.
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.
SmartLifecycleRoleController	Bulk start/stop SmartLifecycle in a particular role in phase order.
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 PropertyAccessors 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.
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.
StaticHeaderValueMessageProcessor<T>
StaticMessageHeaderAccessor	Lightweight type-safe header accessor avoiding object creation just to access a header.
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.
StringStringMapBuilder	A map builder creating a map with String keys and values.
SubscribableChannelManagement	Metrics for subscribable channels.
SupplierExpression<T>	An Expression that simply invokes Supplier.get() on its provided Supplier.
SyslogToMapTransformer	Transforms a packet in Syslog (RFC3164) format to a Map.
SyslogToMapTransformerParser
ThreadStatePropagationChannelInterceptor<S>	The ExecutorChannelInterceptor implementation responsible for the Thread (any?) state propagation from one message flow's thread to another through the MessageChannels involved in the flow.
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-synchronization-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 Transformers.
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.
UniqueExpiryCallback	A marker interface extension of the MessageGroupStore.MessageGroupCallback for components which should be registered in the MessageGroupStore only once.
UniqueMethodFilter
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	ChannelInterceptors implementing this interface can veto global interception of a particular channel.
WhileLockedProcessor	A simple strategy callback class that allows you to provide a code that needs to be executed under Lock provided by LockRegistry.
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.