All Classes and Interfaces
Class
Description
Base class for MessageGroupProcessor implementations that aggregate the group of Messages into a single Message.
Base implementation of a
Candidate.Base parser for Channel Adapters.
Base class for channel parsers.
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.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.
The base
HandleMessageAdvice for advices which can be applied only
for the MessageHandler.handleMessage(Message).Abstract base class for
RequestReplyHeaderMapper implementations.A composite
AbstractHeaderMapper.HeaderMatcher that matches if one of provided
AbstractHeaderMapper.HeaderMatchers matches to the headerName.A content-based
AbstractHeaderMapper.HeaderMatcher that matches if the specified
header is contained within a list of candidates.Strategy interface to determine if a given header name matches.
A pattern-based
AbstractHeaderMapper.HeaderMatcher that matches if the specified
header matches one of the specified simple patterns.A prefix-based
AbstractHeaderMapper.HeaderMatcher that matches if the specified
header starts with a configurable prefix.A pattern-based
AbstractHeaderMapper.HeaderMatcher that matches if the specified
header matches the specified simple pattern.Base class for inbound gateway parsers.
Base class for NamespaceHandlers that registers a BeanFactoryPostProcessor
for configuring default bean definitions.
Base class for Jackson
JsonObjectMapper implementations.Abstract
InboundMessageMapper implementation that maps incoming JSON messages
to a Message with the specified payload type.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 all Message Routers that support mapping from arbitrary String values
to Message Channel names.
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.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.
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.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
ReactiveMessageHandler implementations.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.
Base parser for routers.
AbstractSimpleMessageHandlerFactoryBean<H extends org.springframework.messaging.MessageHandler>
Factory bean to create and configure a
MessageHandler.Base class for FactoryBeans that create standard MessageHandler instances.
Base implementation of
MessageChannel that
invokes the subscribed handler(s) by delegating to a
MessageDispatcher.A base class for
Transformer implementations.An implementation of
CollectionFilter that remembers the elements passed in
the previous invocation in order to avoid returning those elements more than once.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.An Exception that encapsulates an aggregated group of Exceptions for use by dispatchers
that may try multiple handler invocations within a single dispatch operation.
Aggregator specific implementation of
AbstractCorrelatingMessageHandler.Indicates that a method is capable of aggregating messages.
Post-processor for the
@Aggregator annotation.FactoryBean to create an
AggregatingMessageHandler.Parser for the aggregator element of the integration namespace.
The repeatable container for
Aggregator annotations.A
Converter that delegates to a
Deserializer to convert data in a byte
array to an object.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.Parser for the <application-event-multicaster> element of the
integration namespace.
Pre-defined names and prefixes for Apache Avro related headers.
A message handler that suspends the thread until a message with corresponding
correlation is passed into the
trigger method or
the timeout occurs.Parser for
<int:barrier/>.A
MessageHandlerSpec for the BarrierMessageHandler.The
Builder pattern implementation for the EIP-method chain.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.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.The
AbstractRequestHandlerAdvice implementation for caching
AbstractReplyProducingMessageHandler.RequestHandler#handleRequestMessage(Message) results.A
RejectedExecutionHandler that blocks the caller until
the executor has room in its queue, or a timeout occurs (in which
case a RejectedExecutionException is thrown.Interface that defines the contract for candidates to participate
in a leader election.
Parser for the <chain> element.
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.
A marker interface that indicates this message store has optimizations for
use in a
QueueChannel.A utility class for purging
Messages from one or more
QueueChannels.Channel resolution utilities.
Channel utilities.
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.
A
CloseableIterator is intended to be used when it may hold resources (such as file or socket handles).Interface for classes that perform both encode (serialize) and decode (deserialize) on multiple classes.
A
MessageConverter that delegates to a Codec to convert.Base strategy for filtering out a subset of a Collection of elements.
The marker interface for the
IntegrationComponentSpec implementation,
when there is need to register as beans not only the target spec's components,
but some additional components, e.g.A Codec that can delegate to one out of many Codecs, each mapped to a class.
An
Executor that encapsulates two underlying executors.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.The
FactoryBean implementation for AbstractEndpoint population.ConsumerEndpointSpec<S extends ConsumerEndpointSpec<S,H>,H extends org.springframework.messaging.MessageHandler>
A
EndpointSpec for consumer endpoints.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.
CorrelationHandlerSpec<S extends CorrelationHandlerSpec<S,H>,H extends AbstractCorrelatingMessageHandler>
Strategy for determining how messages can be correlated.
Indicates that a given method is capable of determining the correlation key
of a message sent as parameter.
Convenience factory for XML configuration of a
CorrelationStrategy.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.
Simple
Candidate for leadership.A
BeanDefinitionRegistryPostProcessor implementation that registers bean definitions
for many infrastructure components with their default configurations.Default message converter for datatype channels.
A simple
ErrorMessageStrategy implementations which produces
a error message with original message if the AttributeAccessor has
ErrorMessageUtils.INPUT_MESSAGE_CONTEXT_KEY attribute.Converts a channel to a name, retaining a reference to the channel keyed by the name.
Parser for the <inbound-channel-adapter/> element.
Default implementation of
LeaderEventPublisher.Default implementation of
LockRegistry which uses Masked Hashcode algorithm to obtain locks.A default
MessageReceiverObservationConvention implementation.A default
MessageRequestReplyReceiverObservationConvention implementation.A default
MessageSenderObservationConvention implementation.The default Message Splitter implementation.
Parser for the <outbound-channel-adapter/> element.
Parser for the <router/> element.
Default implementation of
TransactionSynchronizationFactory which takes an instance of
TransactionSynchronizationProcessor allowing you to create a TransactionSynchronization
using {DefaultTransactionSynchronizationFactory.create(Object) method.A
ConsumerEndpointSpec for a DelayHandler.Parser for the <delayer> element.
A
MessageHandler that is capable of delaying the continuation of a Message flow
based on the result of evaluation delayExpression on an inbound Message
or a default delay value configured on this handler.The
MessageGroupProcessor implementation with delegation to the provided delegate
and optional aggregation for headers.A channel that invokes a single subscriber for each sent Message.
Classes implementing this interface are capable of discarding messages.
Represents an endpoint that has a discard channel.
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 default configuring of management in Spring Integration components in an existing application.
Enables
MessageHistory
for Spring Integration components.Provides the registration for the
PublisherAnnotationBeanPostProcessor
to allow the use of the Publisher annotation.AbstractPayloadTransformer that delegates to a codec to encode the
payload into a byte[].When used alongside an EIP annotation (and no
@Bean), specifies the bean name of
the consumer bean with the handler bean being id.handler (for a consuming
endpoint) or id.source for a message source (e.g.Base class for all endpoints.
EndpointSpec<S extends EndpointSpec<S,F,H>,F extends org.springframework.beans.factory.BeanNameAware & org.springframework.beans.factory.FactoryBean<? extends AbstractEndpoint>,H>
An
IntegrationComponentSpec for endpoints.Parser for the 'enricher' element.
A
ConsumerEndpointSpec extension for the ContentEnricher.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.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
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.
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
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.
A
KryoRegistrar used to validateRegistration a File serializer.A custom Kryo
Serializer for serializing File payloads.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.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.GenericEndpointSpec<H extends org.springframework.messaging.MessageHandler>
A
ConsumerEndpointSpec for a MessageHandler implementations.A functional interface to specify
MessageHandler
logic with Java 8 Lambda expression:The
MessageJacksonDeserializer implementation for the GenericMessage.Generic (lambda) strategy interface for selector.
Generic (lambda) strategy interface for transformer.
ChannelInterceptor components with this
annotation will be applied as global channel interceptors
using the provided patterns to match channel names.The
IntegrationConfigurationInitializer to populate GlobalChannelInterceptorWrapper
for ChannelInterceptors marked with
GlobalChannelInterceptor annotation.Parser for 'channel-interceptor' elements.
This class applies global interceptors (
<channel-interceptor> or @GlobalChannelInterceptor)
to message channels beans.Parser for the top level 'wire-tap' element.
This object can be exposed, for example, as a JSON object over
HTTP.
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.Default implementation of
CorrelationStrategy.Implementations convert a channel to a name, retaining a reference to the channel keyed by the name.
A Transformer that adds statically configured header values to a Message.
Base support class for 'header-enricher' parsers.
An
IntegrationComponentSpec for a HeaderEnricher.Transformer that removes Message headers.
Parser for the 'header-filter' element.
Generic strategy interface for mapping
MessageHeaders to and from other
types of objects.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.
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().
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 interface for mapping from an Object to a
Message.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.
Builds the runtime object model graph.
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.
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.An implementation of the
ResourceHolder which holds an instance of the current Message
and the synchronization resource.The base
ResourceHolderSynchronization for IntegrationResourceHolder.FactoryBean to populate SimpleEvaluationContext instances enhanced with:
a TypeConverter based on the
ConversionService
from the application context.General utility methods.
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.
Pre-defined names and prefixes to be used for setting and/or retrieving JSON
entries from/to Message Headers and other adapter, e.g.
InboundMessageMapper implementation that maps incoming JSON messages
to a Message with the specified payload type.The
Converter implementation for the conversion
of JsonPropertyAccessor.JsonNodeWrapper to JsonNode,
when the JsonPropertyAccessor.JsonNodeWrapper can be a result of the expression
for JSON in case of the JsonPropertyAccessor usage.Strategy interface to convert an Object to/from the JSON representation.
Simple factory to provide JsonObjectMapper
instances based on jackson-databind lib in the classpath.
OutboundMessageMapper implementation the converts a Message to a JSON
string representation.Utility class to
JsonPathUtils.evaluate(java.lang.Object, java.lang.String, com.jayway.jsonpath.Predicate...) a jsonPath on the provided object.A SpEL
PropertyAccessor that knows how to read properties from JSON objects.Transformer implementation that converts a JSON string payload into an instance of the
provided target Class.
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.Interface for publishing leader based application events.
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.
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.
Makes
Lifecycle methods manageable.Extend
ManageableLifecycle to make those methods manageable.A
HandlerMethodArgumentResolver implementation to resolve argument
for the MethodParameter as a Map or Properties.A
Builder pattern implementation for the Map.Converts to/from a Map with 2 keys ('headers' and 'payload').
Exposes channel mapping operations when the router is proxied.
Will transform Map to an instance of Object.
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
Message decoration contract.Strategy interface for dispatching messages to handlers.
Exception that indicates an internal error occurred within a
MessageDispatcher
preventing message delivery.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.
MessageHandlerSpec<S extends MessageHandlerSpec<S,H>,H extends org.springframework.messaging.MessageHandler>
An
IntegrationComponentSpec for MessageHandlers.Base class for Message handling components that provides basic validation and error
handling capabilities.
The strategy to decorate
MessageHandlingRunnable tasks
to be used with the Executor.Inner class for each Entry in the history.
The
<message-history/> parser.The
MessageStore specific value object to keep the Message and its metadata.MessageJacksonDeserializer<T extends org.springframework.messaging.Message<?>>
A Jackson
StdNodeBasedDeserializer extension for Message implementations.Registers common MessageHeader types and Serializers.
Exception that indicates an error during message mapping.
Value Object holding metadata about a Message in the MessageStore.
This defines the lowest-level strategy of processing a Message and returning
some Object (or null).
The
MessageSource strategy implementation
to produce a Message from underlying
MessageProcessorMessageSource.messageProcessor for polling endpoints.The
IntegrationComponentSpec specific base class
for MessageProcessors.Base interface for any component that is capable of sending
messages to a
MessageChannel.Represents an inbound message producer.
An
IntegrationComponentSpec for
MessageProducers.A support class for producer endpoints that provides a setter for the
output channel and a convenience method for sending Messages.
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.
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.Base interface for any source of
Messages that can be polled.Message sources implementing this interface have additional properties that
can be set or examined using JMX.
A
ReceiveMessageAdvice extension that can mutate a MessageSource before and/or after
MessageSource.receive() is called.Represents a message source.
A
PollingOperations used to ad-hoc poll a MessageSource.An
IntegrationComponentSpec for MessageSources.Strategy interface for storing and retrieving messages.
Exception for problems that occur when using a
MessageStore implementation.Exception that indicates a timeout elapsed prior to successful message delivery.
Base Exception type for Message transformation errors.
A reply-producing
MessageHandler
that delegates to a Transformer instance to modify the received Message
and sends the result to its output channel.Classes implementing this interface can take some action when a trigger
Message
is received.A
BeanPostProcessor implementation that processes method-level
messaging annotations such as @Transformer, @Splitter, @Router, and @Filter.Utility methods to support annotation processing.
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>
A
Configuration to add a MicrometerMetricsCaptor.An
ImportSelector to conditionally add a MicrometerMetricsCaptorConfiguration
bean when io.micrometer.core.instrument.MeterRegistry is present in classpath.Add micrometer metrics to the node.
Simple
StdSerializer extension to represent a MimeType object in the
target JSON as a plain string.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.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.
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.
Strategy interface for mapping from a
Message to an Object.A
MessagingException thrown when a non-transactional operation is
performing multiple updates from a single message, e.g.A simple
TransactionSynchronizationFactory implementation which produces
an IntegrationResourceHolderSynchronization with an IntegrationResourceHolder.The
LockRegistry implementation which has no effect.The simple
MessageConverter implementation which contract is to return
Message as is for both from/to operations.Utility methods for pattern matching.
Endpoints implementing this interface can be paused/resumed.
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.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.Parser for the <channel> element.
Kryo Codec that can encode and decode arbitrary types.
Represents a pollable channel.
Provides the
PollerMetadata options
for the Messaging annotations for polled endpoints.An
Adapter class for the Pollers factory.Parser for the <poller> element.
An utility class to provide
PollerSpecs for
PollerMetadata configuration
variants.An
IntegrationComponentSpec for PollerMetadatas.Message Endpoint that connects any
MessageHandler implementation
to a PollableChannel.Operations to perform on some message source.
An advice that can be added to a poller's advice chain that determines
whether a poll should be skipped or not.
Implementations determine whether a particular poll should be skipped.
Represents a pool of items.
Thrown when a pooled item could not be obtained for some reason.
Implementations of this interface are subclasses of
AbstractMessageHandler that perform post processing after the
AbstractMessageHandler.handleMessageInternal(org.springframework.messaging.Message)
call.A
ChannelMessageStore that supports the
notion of message priority.A message channel that prioritizes messages based on a
Comparator.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.
A channel that sends Messages to each of its subscribers.
Parser for the <publish-subscribe-channel> element.
The
PublishSubscribeChannelSpec extension to configure as a general flow callback for sub-flows
as subscribers.Simple implementation of a message channel.
Operations available on a channel that has queuing semantics.
The
ChannelMessageStore-specific QueueChannelSpec extension.An
AbstractRequestHandlerAdvice extension for a rate limiting to service method calls.A
MessagingException wrapper for the RequestNotPermitted
with the requestMessage and target context.Provides reactive configuration options for the consumer endpoint making
any input channel as a reactive stream source of data.
A
MessageHandler implementation to adapt a ReactiveMessageHandler
for synchronous invocations.ReactiveMessageHandlerSpec<S extends ReactiveMessageHandlerSpec<S,H>,H extends org.springframework.messaging.ReactiveMessageHandler>
The
MessageHandlerSpec extension for ReactiveMessageHandler.The
MessageProducerSupport to adapt a provided MessageSource
into a Flux and let it be subscribed in the MessageProducerSupport.subscribeToPublisher(org.reactivestreams.Publisher<? extends org.springframework.messaging.Message<?>>).A
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.Counters for components that maintain receive counters.
An AOP advice to perform hooks before and/or after a
receive() contract is called.
<recipient-list-router id="simpleRouter" input-channel="routingChannelA">
<recipient channel="channel1"/>
<recipient channel="channel2"/>
</recipient-list-router>
Exposes adding/removing individual recipients operations for
RecipientListRouter.
Parser for the <recipient-list-router/> element.
An
AbstractRouterSpec for a RecipientListRouter.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.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.
Interface for a request/reply Message exchange.
Request/Reply strategy interface for mapping
MessageHeaders to and from other
types of objects.Parser for the <resequencer> element.
This class implements all the strategy interfaces needed for a default resequencer.
Resequencer specific implementation of
AbstractCorrelatingMessageHandler.Parser for 'resource-inbound-channel-adapter'.
Implementation of
MessageSource based on
ResourcePatternResolver which will attempt to resolve Resources based
on the pattern specified.Strategy interface for generating a
RetryState instance
based on a message.Annotate endpoints to assign them to a role.
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.The
AbstractRouterSpec for an AbstractMappingMessageRouter.Represents an endpoint that can route to multiple channels.
The
RoutingSlip HeaderValueMessageProcessor specific implementation.The
RoutingSlip strategy to determine the next replyChannel.The
MessageHandler implementation for the
Scatter-Gather EIP pattern.Parser for the <scatter-gather> element.
A
GenericEndpointSpec extension for the ScatterGatherHandler.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'.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.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.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.Bulk start/stop
SmartLifecycle in a particular role in phase order.A Channel Adapter implementation for connecting a
MessageSource to a MessageChannel.FactoryBean for creating a SourcePollingChannelAdapter instance.
Creates a DefaultRetryState from a
Message.A
FactoryBean implementation to encapsulate the population of a static Method
from the provided SpelFunctionFactoryBean.functionClass and SpelFunctionFactoryBean.functionMethodSignature as
a valid StandardEvaluationContext function.Parser for the <spel-function> element.
Utility class that keeps track of a Set of SpEL
PropertyAccessors
in order to register them with the "integrationEvaluationContext" upon initialization.Parser for the <spel-property-accessors> element.
Indicates that a method is capable of splitting a single message or message
payload to produce multiple messages or payloads.
Post-processor for Methods annotated with
@Splitter.A
ConsumerEndpointSpec for a AbstractMessageSplitter implementations.Factory bean for creating a Message Splitter.
Parser for the <splitter/> element.
The repeatable container for
Splitter annotations.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.Lightweight type-safe header accessor avoiding object
creation just to access a header.
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.
A map builder creating a map with String keys and values.
Metrics for subscribable channels.
Transforms a packet in Syslog (RFC3164) format to a Map.
The
ExecutorChannelInterceptor implementation responsible for
the Thread (any?) state propagation from one message flow's thread to another
through the MessageChannels involved in the flow.A
ReleaseStrategy that releases all messages if any of the following is true:
The sequence is complete (if there is one).
There are more messages than a threshold set by the user.
The time elapsed since the earliest message, according to their timestamps, if
present, exceeds a timeout set by the user.
Statistics captured from a timer meter.
A
TransactionInterceptor extension with HandleMessageAdvice marker.Provides a fluent API to build a transaction interceptor.
Strategy for implementing factories that create
TransactionSynchronization.The
FactoryBean implementation (with Builder style) to be used
from JavaConfig to populate DefaultTransactionSynchronizationFactory bean.Parser for transaction-synchronization-factory element.
Strategy for implementing transaction synchronization processors.
Indicates that a method is capable of transforming a message, message header,
or message payload.
Strategy interface for transforming a
Message.Post-processor for Methods annotated with a
@Transformer.Factory bean for creating a Message Transformer.
Parser for the <transformer/> element.
The repeatable container for
Transformer annotations.An utility class to provide methods for out-of-the-box
Transformers.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 marker interface extension of the
MessageGroupStore.MessageGroupCallback
for components which should be registered in the MessageGroupStore only once.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.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.
IntegrationFlowinterface.