All Classes and Interfaces

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