All Classes
| Class | Description |
|---|---|
| AbstractAggregatingMessageGroupProcessor |
Base class for MessageGroupProcessor implementations that aggregate the group of Messages into a single Message.
|
| AbstractBatchingMessageGroupStore | |
| AbstractCandidate |
Base implementation of a
Candidate. |
| AbstractChannelAdapterParser |
Base parser for Channel Adapters.
|
| AbstractChannelParser |
Base class for channel parsers.
|
| AbstractConsumerEndpointParser |
Base class parser for elements that create Message Endpoints.
|
| AbstractCorrelatingMessageHandler |
Abstract Message handler that holds a buffer of correlated messages in a
MessageStore. |
| AbstractCorrelatingMessageHandler.SequenceAwareMessageGroup | |
| AbstractCorrelatingMessageHandlerParser |
Base class for parsers that create an instance of
AbstractCorrelatingMessageHandler. |
| AbstractDispatcher |
Base class for
MessageDispatcher implementations. |
| AbstractEndpoint |
The base class for Message Endpoint implementations.
|
| AbstractEvaluationContextFactoryBean |
Abstract class for integration evaluation context factory beans.
|
| AbstractExecutorChannel |
The
AbstractSubscribableChannel base implementation for those inheritors
which logic may be based on the Executor. |
| AbstractExpressionEvaluator | |
| AbstractFetchLimitingMessageSource<T> |
A message source that can limit the number of remote objects it fetches.
|
| AbstractHandleMessageAdvice |
The base
HandleMessageAdvice for advices which can be applied only
for the MessageHandler.handleMessage(Message). |
| AbstractHeaderMapper<T> |
Abstract base class for
RequestReplyHeaderMapper implementations. |
| AbstractHeaderMapper.CompositeHeaderMatcher |
A composite
AbstractHeaderMapper.HeaderMatcher that matches if one of provided
AbstractHeaderMapper.HeaderMatchers matches to the headerName. |
| AbstractHeaderMapper.ContentBasedHeaderMatcher |
A content-based
AbstractHeaderMapper.HeaderMatcher that matches if the specified
header is contained within a list of candidates. |
| AbstractHeaderMapper.HeaderMatcher |
Strategy interface to determine if a given header name matches.
|
| AbstractHeaderMapper.PatternBasedHeaderMatcher |
A pattern-based
AbstractHeaderMapper.HeaderMatcher that matches if the specified
header matches one of the specified simple patterns. |
| AbstractHeaderMapper.PrefixBasedMatcher |
A prefix-based
AbstractHeaderMapper.HeaderMatcher that matches if the specified
header starts with a configurable prefix. |
| AbstractHeaderMapper.SinglePatternBasedHeaderMatcher |
A pattern-based
AbstractHeaderMapper.HeaderMatcher that matches if the specified
header matches the specified simple pattern. |
| AbstractHeaderValueMessageProcessor<T> | |
| AbstractInboundGatewayParser |
Base class for inbound gateway parsers.
|
| AbstractIntegrationMessageBuilder<T> | |
| AbstractIntegrationNamespaceHandler |
Base class for NamespaceHandlers that registers a BeanFactoryPostProcessor
for configuring default bean definitions.
|
| AbstractJacksonJsonObjectMapper<N,P,J> |
Base class for Jackson
JsonObjectMapper implementations. |
| AbstractJsonInboundMessageMapper<P> |
Abstract
InboundMessageMapper implementation that maps incoming JSON messages
to a Message with the specified payload type. |
| AbstractKeyValueMessageStore |
Base class for implementations of Key/Value style
MessageGroupStore and MessageStore |
| AbstractKryoCodec |
Base class for
Codecs using Kryo. |
| AbstractKryoRegistrar |
Base class for
KryoRegistrar implementations. |
| AbstractLeaderEvent |
Base
ApplicationEvent class for leader based events. |
| AbstractMappingMessageRouter |
Base class for all Message Routers that support mapping from arbitrary String values
to Message Channel names.
|
| AbstractMessageChannel |
Base class for
MessageChannel implementations providing common
properties such as the channel name. |
| AbstractMessageChannel.ChannelInterceptorList |
A convenience wrapper class for the list of ChannelInterceptors.
|
| AbstractMessageGroupStore | |
| AbstractMessageHandler |
Base class for
MessageHandler implementations. |
| AbstractMessageProcessingSelector |
A base class for
MessageSelector implementations that delegate to
a MessageProcessor. |
| AbstractMessageProcessingTransformer |
Base class for Message Transformers that delegate to a
MessageProcessor. |
| AbstractMessageProcessor<T> | |
| AbstractMessageProducingHandler |
The base
AbstractMessageHandler implementation for the MessageProducer. |
| AbstractMessageRouter |
Base class for all Message Routers.
|
| AbstractMessageSource<T> |
Abstract message source.
|
| AbstractMessageSourceAdvice | Deprecated.
since 5.3 in favor of
MessageSourceMutator. |
| AbstractMessageSplitter |
Base class for Message-splitting handlers.
|
| AbstractMethodAnnotationPostProcessor<T extends java.lang.annotation.Annotation> |
Base class for Method-level annotation post-processors.
|
| AbstractOutboundChannelAdapterParser |
Base class for outbound Channel Adapter parsers.
|
| AbstractOutboundGatewayParser |
Base class for url-based outbound gateway parsers.
|
| AbstractPayloadTransformer<T,U> |
A base class for
Transformer implementations that modify the payload
of a Message. |
| AbstractPollableChannel |
Base class for all pollable channels.
|
| AbstractPollingEndpoint | |
| AbstractPollingInboundChannelAdapterParser |
Base parser for inbound Channel Adapters that poll a source.
|
| AbstractReactiveMessageHandler |
Base class for
ReactiveMessageHandler implementations. |
| AbstractReplyProducingMessageHandler |
Base class for MessageHandlers that are capable of producing replies.
|
| AbstractReplyProducingMessageHandler.RequestHandler |
An implementation of this interface is used to wrap the
AbstractReplyProducingMessageHandler.handleRequestMessage(Message)
method. |
| AbstractReplyProducingPostProcessingMessageHandler | |
| AbstractRequestHandlerAdvice |
Base class for
MessageHandler advice classes. |
| AbstractRequestHandlerAdvice.ExecutionCallback |
Called by subclasses in doInvoke() to proceed() the invocation.
|
| AbstractRequestHandlerAdvice.ThrowableHolderException | |
| AbstractRouterParser |
Base parser for routers.
|
| AbstractRouterSpec<S extends AbstractRouterSpec<S,R>,R extends AbstractMessageRouter> | |
| AbstractSimpleMessageHandlerFactoryBean<H extends org.springframework.messaging.MessageHandler> |
Factory bean to create and configure a
MessageHandler. |
| AbstractStandardMessageHandlerFactoryBean |
Base class for FactoryBeans that create standard MessageHandler instances.
|
| AbstractSubscribableChannel |
Base implementation of
MessageChannel that
invokes the subscribed handler(s) by delegating to a
MessageDispatcher. |
| AbstractTransformer |
A base class for
Transformer implementations. |
| AbstractTransformerParser | |
| AcceptOnceCollectionFilter<T> |
An implementation of
CollectionFilter that remembers the elements passed in
the previous invocation in order to avoid returning those elements more than once. |
| AcknowledgmentCallback |
A general abstraction over acknowledgments.
|
| AcknowledgmentCallback.Status | |
| AcknowledgmentCallbackFactory<T> |
A factory for creating
AcknowledgmentCallbacks. |
| AckUtils |
Utility methods for acting on
AcknowledgmentCallback headers. |
| AdviceMessage<T> |
A message implementation that is produced by an advice after
successful message handling.
|
| AdviceMessageJacksonDeserializer |
The
MessageJacksonDeserializer implementation for the AdviceMessage. |
| AggregateMessageDeliveryException |
An Exception that encapsulates an aggregated group of Exceptions for use by dispatchers
that may try multiple handler invocations within a single dispatch operation.
|
| AggregatingMessageHandler |
Aggregator specific implementation of
AbstractCorrelatingMessageHandler. |
| Aggregator |
Indicates that a method is capable of aggregating messages.
|
| AggregatorAnnotationPostProcessor |
Post-processor for the
@Aggregator annotation. |
| AggregatorFactoryBean |
FactoryBean to create an
AggregatingMessageHandler. |
| AggregatorParser |
Parser for the aggregator element of the integration namespace.
|
| AggregatorSpec | |
| AllowListDeserializingConverter |
A
Converter that delegates to a
Deserializer to convert data in a byte
array to an object. |
| AnnotatedMethodFilter |
A MethodFilter implementation that enables the following:
matching on method name, if available
exclusion of void-returning methods if 'requiresReply' is true
limiting to annotated methods if at least one is present
|
| AnnotationConfigParser |
Parser for the <annotation-config> element of the integration namespace.
|
| AnnotationConstants |
Common value constants for annotation attributes.
|
| AnnotationGatewayProxyFactoryBean |
A
GatewayProxyFactoryBean extension for Java configuration. |
| AnnotationMetadataAdapter |
An
AnnotationMetadata implementation to expose a metadata
by the provided Map of attributes. |
| ApplicationEventMulticasterParser |
Parser for the <application-event-multicaster> element of the
integration namespace.
|
| AsyncMessagingOperations | |
| AsyncMessagingTemplate | |
| AvroHeaders |
Pre-defined names and prefixes for Apache Avro related headers.
|
| BarrierMessageHandler |
A message handler that suspends the thread until a message with corresponding
correlation is passed into the
trigger method or
the timeout occurs. |
| BarrierParser |
Parser for
<int:barrier/>. |
| BarrierSpec |
A
MessageHandlerSpec for the BarrierMessageHandler. |
| BaseIntegrationFlowDefinition<B extends BaseIntegrationFlowDefinition<B>> |
The
Builder pattern implementation for the EIP-method chain. |
| BaseIntegrationFlowDefinition.ReplyProducerCleaner | |
| BasicMessageGroupStore |
Defines a minimal message group store with basic capabilities.
|
| BeanDefinitionRegisteringParser |
Simple strategy interface for parsers that are responsible
for parsing an element, creating a bean definition, and then
registering the bean.
|
| BeanFactoryChannelResolver |
DestinationResolver implementation based on a Spring BeanFactory. |
| BeanFactoryTypeConverter | |
| BeanNameMessageProcessor<T> |
An "artificial"
MessageProcessor for lazy-load of target bean by its name. |
| BridgeFrom |
Messaging Annotation to mark a
Bean
method for a MessageChannel to produce a
BridgeHandler and Consumer Endpoint. |
| BridgeFromAnnotationPostProcessor |
Post-processor for the
@BridgeFrom annotation. |
| BridgeHandler |
A simple MessageHandler implementation that passes the request Message
directly to the output channel without modifying it.
|
| BridgeParser |
Parser for the <bridge> element.
|
| BridgeTo |
Messaging Annotation to mark a
Bean
method for a MessageChannel to produce a
BridgeHandler and Consumer Endpoint. |
| BridgeToAnnotationPostProcessor |
Post-processor for the
@BridgeTo annotation. |
| BroadcastCapableChannel |
A
SubscribableChannel variant for implementations with broadcasting capabilities. |
| BroadcastingDispatcher |
A broadcasting dispatcher implementation.
|
| BroadcastPublishSubscribeSpec |
An
IntegrationComponentSpec for configuring sub-flow subscribers on the
provided BroadcastCapableChannel. |
| BytesMessageMapper | |
| CacheRequestHandlerAdvice |
The
AbstractRequestHandlerAdvice implementation for caching
AbstractReplyProducingMessageHandler.RequestHandler#handleRequestMessage(Message) results. |
| CallerBlocksPolicy |
A
RejectedExecutionHandler that blocks the caller until
the executor has room in its queue, or a timeout occurs (in which
case a RejectedExecutionException is thrown. |
| Candidate |
Interface that defines the contract for candidates to participate
in a leader election.
|
| ChainParser |
Parser for the <chain> element.
|
| ChannelInterceptorParser |
A helper class for parsing the sub-elements of a channel's
interceptors element.
|
| ChannelMessageStore |
A marker interface that indicates this message store has optimizations for
use in a
QueueChannel. |
| ChannelPurger |
A utility class for purging
Messages from one or more
QueueChannels. |
| ChannelResolverUtils |
Channel resolution utilities.
|
| Channels | |
| ChannelUtils |
Channel utilities.
|
| ClaimCheckInParser |
Parser for the <claim-check-in/> element.
|
| ClaimCheckInTransformer |
Transformer that stores a Message and returns a new Message whose payload
is the id of the stored Message.
|
| ClaimCheckOutParser |
Parser for the <claim-check-out/> element.
|
| ClaimCheckOutTransformer |
Transformer that accepts a Message whose payload is a UUID and retrieves the Message associated
with that id from a MessageStore if available.
|
| ClassUtils | |
| CloseableIterator<E> |
A
CloseableIterator is intended to be used when it may hold resources (such as file or socket handles). |
| Codec |
Interface for classes that perform both encode (serialize) and decode (deserialize) on multiple classes.
|
| CodecMessageConverter |
A
MessageConverter that delegates to a Codec to convert |
| CollectionArgumentResolver |
A
HandlerMethodArgumentResolver implementation for Collection,
Iterator or array MethodParameter. |
| CollectionFilter<T> |
Base strategy for filtering out a subset of a Collection of elements.
|
| ComponentsRegistration |
The marker interface for the
IntegrationComponentSpec implementation,
when there is need to register as beans not only the target spec's components,
but some additional components, e.g. |
| CompositeCodec |
A Codec that can delegate to one out of many Codecs, each mapped to a class.
|
| CompositeExecutor |
An
Executor that encapsulates two underlying executors. |
| CompositeKryoRegistrar |
A
KryoRegistrar that delegates and validates registrations across all components. |
| CompositeMessageHandler |
Classes implementing this interface delegate to a list of handlers.
|
| CompositeMessageHandlerNode |
Represents a composite message handler.
|
| CompositeMessageHandlerNode.InnerHandler | |
| CompoundTrigger |
A
Trigger that delegates the CompoundTrigger.nextExecutionTime(TriggerContext)
to one of two Triggers. |
| CompoundTriggerAdvice |
A
MessageSourceMutator that uses a CompoundTrigger to adjust
the poller - when a message is present, the compound trigger's primary trigger is
used to determine the next poll. |
| ConcurrentMetadataStore |
Supports atomic updates to values in the store.
|
| ConfigurableCompositeMessageConverter |
A
CompositeMessageConverter extension with some default MessageConverters
which can be overridden with the given converters
or added in the end of target converters collection. |
| ConsumerEndpointFactoryBean |
The
FactoryBean implementation for AbstractEndpoint population. |
| ConsumerEndpointSpec<S extends ConsumerEndpointSpec<S,H>,H extends org.springframework.messaging.MessageHandler> |
A
EndpointSpec for consumer endpoints. |
| ContentEnricher |
Content Enricher is a Message Transformer that can augment a message's payload with
either static values or by optionally invoking a downstream message flow via its
request channel and then applying values from the reply Message to the original
payload.
|
| Context |
Interface that defines the context for candidate leadership.
|
| ControlBusMethodFilter |
SpEL
MethodFilter to restrict method invocations to:
Pausable or Lifecycle components
get, set and shutdown methods of CustomizableThreadCreator
methods with ManagedAttribute and ManagedOperation annotations
This class isn't designed for target applications and typically is used from ExpressionControlBusFactoryBean. |
| ControlBusParser | |
| ConverterParser | |
| ConvertingBytesMessageMapper |
The
BytesMessageMapper implementation to delegate to/from Message
conversion into the provided MessageConverter. |
| CorrelatingMessageBarrier |
This Endpoint serves as a barrier for messages that should not be processed yet.
|
| CorrelationHandlerSpec<S extends CorrelationHandlerSpec<S,H>,H extends AbstractCorrelatingMessageHandler> | |
| CorrelationStrategy |
Strategy for determining how messages can be correlated.
|
| CorrelationStrategy |
Indicates that a given method is capable of determining the correlation key
of a message sent as parameter.
|
| CorrelationStrategyFactoryBean |
Convenience factory for XML configuration of a
CorrelationStrategy. |
| CounterFacade | |
| DecodingTransformer<T> |
AbstractPayloadTransformer that delegates to a codec to decode the
payload from a byte[]. |
| Default |
Indicates that the class member has some default meaning.
|
| DefaultAggregateHeadersFunction |
The
Function implementation for a default headers merging in the aggregator
component. |
| DefaultAggregatingMessageGroupProcessor |
This implementation of MessageGroupProcessor will take the messages from the
MessageGroup and pass them on in a single message with a Collection as a payload.
|
| DefaultCandidate |
Simple
Candidate for leadership. |
| DefaultDatatypeChannelMessageConverter |
Default message converter for datatype channels.
|
| DefaultErrorMessageStrategy |
A simple
ErrorMessageStrategy implementations which produces
a error message with original message if the AttributeAccessor has
ErrorMessageUtils.INPUT_MESSAGE_CONTEXT_KEY attribute. |
| DefaultHeaderChannelRegistry |
Converts a channel to a name, retaining a reference to the channel keyed by the name.
|
| DefaultInboundChannelAdapterParser |
Parser for the <inbound-channel-adapter/> element.
|
| DefaultLeaderEventPublisher |
Default implementation of
LeaderEventPublisher. |
| DefaultLockRegistry |
Default implementation of
LockRegistry which uses Masked Hashcode algorithm to obtain locks. |
| DefaultMessageBuilderFactory | |
| DefaultMessageSplitter |
The default Message Splitter implementation.
|
| DefaultOutboundChannelAdapterParser |
Parser for the <outbound-channel-adapter/> element.
|
| DefaultRouterParser |
Parser for the <router/> element.
|
| DefaultTransactionSynchronizationFactory |
Default implementation of
TransactionSynchronizationFactory which takes an instance of
TransactionSynchronizationProcessor allowing you to create a TransactionSynchronization
using {DefaultTransactionSynchronizationFactory.create(Object) method. |
| DelayerEndpointSpec |
A
ConsumerEndpointSpec for a DelayHandler. |
| DelayerParser |
Parser for the <delayer> element.
|
| DelayHandler |
A
MessageHandler that is capable of delaying the continuation of a Message flow
based on the result of evaluation delayExpression on an inbound Message
or a default delay value configured on this handler. |
| DelayHandler.DelayedMessageWrapper | |
| DelayHandlerManagement | |
| DelegatingMessageGroupProcessor |
The
MessageGroupProcessor implementation with delegation to the provided delegate
and optional aggregation for headers. |
| DirectChannel |
A channel that invokes a single subscriber for each sent Message.
|
| DirectChannelSpec | |
| DiscardingMessageHandler |
Classes implementing this interface are capable of discarding messages.
|
| DiscardingMessageHandlerNode |
Represents an endpoint that has a discard channel.
|
| DslIntegrationConfigurationInitializer |
The Java DSL Integration infrastructure
beanFactory initializer. |
| DynamicExpression |
An implementation of
Expression that delegates to an ExpressionSource
for resolving the actual Expression instance per-invocation at runtime. |
| DynamicPeriodicTrigger |
This is a dynamically changeable
Trigger. |
| EmbeddedJsonHeadersMessageMapper |
For outbound messages, uses a message-aware Jackson object mapper to render the message
as JSON.
|
| EnableIntegration |
The main configuration annotation to enable Spring Integration infrastructure:
- Registers some built-in beans;
- Adds several
BeanFactoryPostProcessors;
- Adds several BeanPostProcessors;
- Adds annotations processors. |
| EnableIntegrationManagement |
Enables default configuring of management in Spring Integration components in an existing application.
|
| EnableMessageHistory |
Enables
MessageHistory for Integration components. |
| EnablePublisher |
Provides the registration for the
PublisherAnnotationBeanPostProcessor
to allow the use of the Publisher annotation. |
| EncodingPayloadTransformer<T> |
AbstractPayloadTransformer that delegates to a codec to encode the
payload into a byte[]. |
| EndpointId |
When used alongside an EIP annotation (and no
@Bean), specifies the bean name of
the consumer bean with the handler bean being id.handler (for a consuming
endpoint) or id.source for a message source (e.g. |
| EndpointNode |
Base class for all endpoints.
|
| EndpointSpec<S extends EndpointSpec<S,F,H>,F extends org.springframework.beans.factory.BeanNameAware,H> |
An
IntegrationComponentSpec for endpoints. |
| EnricherParser |
Parser for the 'enricher' element.
|
| EnricherSpec |
A
ConsumerEndpointSpec extension for the ContentEnricher. |
| ErrorCapableCompositeMessageHandlerNode |
Represents a composite message handler that can emit error messages
(pollable endpoint).
|
| ErrorCapableDiscardingMessageHandlerNode |
Represents an endpoint that has a discard channel and can emit errors
(pollable endpoint).
|
| ErrorCapableEndpointNode |
Represents nodes that can natively handle errors.
|
| ErrorCapableMessageHandlerNode |
Represents a message handler that can produce errors (pollable).
|
| ErrorCapableNode |
Nodes implementing this interface are capable of emitting errors.
|
| ErrorCapableRoutingNode |
Represents an endpoint that can route to multiple channels and can emit errors
(pollable endpoint).
|
| ErrorHandlingTaskExecutor |
A
TaskExecutor implementation that wraps an existing Executor
instance in order to catch any exceptions. |
| ErrorMessageExceptionTypeRouter |
A Message Router that resolves the target
MessageChannel for
messages whose payload is a Throwable. |
| ErrorMessageExceptionTypeRouterParser |
Parser for the <exception-type-router/> element.
|
| ErrorMessageJacksonDeserializer |
The
MessageJacksonDeserializer implementation for the ErrorMessage. |
| ErrorMessagePublisher |
The component which can be used as general purpose of errors publishing.
|
| ErrorMessageSendingRecoverer |
A
RecoveryCallback that sends the final throwable as an
ErrorMessage after
retry exhaustion. |
| ErrorMessageSendingRecoverer.RetryExceptionNotAvailableException | |
| ErrorMessageStrategy |
A strategy to build an
ErrorMessage based on the provided
Throwable and AttributeAccessor as a context. |
| ErrorMessageUtils |
Utilities for building error messages.
|
| EventDrivenConsumer |
Message Endpoint that connects any
MessageHandler implementation to a SubscribableChannel. |
| ExecutorChannel |
An implementation of
MessageChannel
that delegates to an instance of
UnicastingDispatcher which in turn delegates all dispatching
invocations to an Executor. |
| ExecutorChannelInterceptorAware |
The
InterceptableChannel extension for the cases when
the ExecutorChannelInterceptors
may have reason (e.g. |
| ExecutorChannelSpec | |
| ExpirableLockRegistry |
A
LockRegistry implementing this interface supports the removal of aged locks
that are not currently locked. |
| ExpressionCapable |
Components that implement this interface are capable of supporting a primary
SpEL expression as part of their configuration.
|
| ExpressionCommandMessageProcessor |
A MessageProcessor implementation that expects an Expression or expressionString
as the Message payload.
|
| ExpressionControlBusFactoryBean |
FactoryBean for creating
MessageHandler instances to handle a message as a SpEL expression. |
| ExpressionEvalMap |
An immutable
AbstractMap implementation that wraps a Map<String, Object>,
where values must be instances of String or Expression,
and evaluates an expression for the provided key from the underlying
original Map. |
| ExpressionEvalMap.ComponentsEvaluationCallback |
The
ExpressionEvalMap.EvaluationCallback implementation which evaluates an expression using
the provided context, root and returnType variables. |
| ExpressionEvalMap.EvaluationCallback |
Implementations of this interface can be provided to build 'on demand
ExpressionEvalMap.get(Object) logic'
for ExpressionEvalMap. |
| ExpressionEvalMap.ExpressionEvalMapBuilder |
The builder class to instantiate
ExpressionEvalMap. |
| ExpressionEvalMap.ExpressionEvalMapComponentsBuilder | |
| ExpressionEvalMap.ExpressionEvalMapFinalBuilder | |
| ExpressionEvaluatingCorrelationStrategy |
CorrelationStrategy implementation that evaluates an expression. |
| ExpressionEvaluatingHeaderValueMessageProcessor<T> | |
| ExpressionEvaluatingMessageGroupProcessor |
A
MessageGroupProcessor implementation that evaluates a SpEL expression. |
| ExpressionEvaluatingMessageHandler |
A
MessageHandler that evaluates
the provided Expression expecting a void return. |
| ExpressionEvaluatingMessageListProcessor |
A base class for aggregators that evaluates a SpEL expression with the message list as the root object within the
evaluation context.
|
| ExpressionEvaluatingMessageProcessor<T> |
A
MessageProcessor implementation that evaluates a SpEL expression
with the Message itself as the root object within the evaluation context. |
| ExpressionEvaluatingMessageSource<T> | |
| ExpressionEvaluatingReleaseStrategy |
A
ReleaseStrategy that evaluates an expression. |
| ExpressionEvaluatingRequestHandlerAdvice |
Used to advise
MessageHandlers. |
| ExpressionEvaluatingRequestHandlerAdvice.MessageHandlingExpressionEvaluatingAdviceException | |
| ExpressionEvaluatingRouter |
A Message Router implementation that evaluates the specified SpEL
expression.
|
| ExpressionEvaluatingRoutingSlipRouteStrategy |
The
Expression based RoutingSlipRouteStrategy implementation. |
| ExpressionEvaluatingRoutingSlipRouteStrategy.RequestAndReply | |
| ExpressionEvaluatingSelector |
A
MessageSelector implementation that
evaluates a SpEL expression. |
| ExpressionEvaluatingSplitter |
A Message Splitter implementation that evaluates the specified SpEL
expression.
|
| ExpressionEvaluatingTransactionSynchronizationProcessor |
This implementation of
TransactionSynchronizationFactory
allows you to configure SpEL expressions, with their execution being coordinated
(synchronized) with a transaction - see
TransactionSynchronization. |
| ExpressionEvaluatingTransformer |
A Message Transformer implementation that evaluates the specified SpEL
expression.
|
| ExpressionFactoryBean |
FactoryBean for creating Expression instances.
|
| ExpressionMessageProducerSupport |
A
MessageProducerSupport sub-class that provides ExpressionMessageProducerSupport.payloadExpression
evaluation with result as a payload for Message to send. |
| ExpressionSource |
Strategy interface for retrieving Expressions.
|
| ExpressionUtils |
Utility class with static methods for helping with evaluation of SpEL expressions.
|
| FileKryoRegistrar |
A
KryoRegistrar used to validateRegistration a File serializer. |
| FileSerializer |
A custom Kryo
Serializer for serializing File payloads. |
| Filter |
Indicates that a method is capable of playing the role of a Message Filter.
|
| FilterAnnotationPostProcessor |
Post-processor for Methods annotated with
@Filter. |
| FilterEndpointSpec |
A
ConsumerEndpointSpec implementation for the MessageFilter. |
| FilterFactoryBean |
Factory bean for creating a Message Filter.
|
| FilterParser |
Parser for the <filter/> element.
|
| FixedMethodFilter |
A
MethodFilter implementation that will always return
the same Method instance within a single-element list if it is
present in the candidate list. |
| FixedSubscriberChannel |
Specialized
SubscribableChannel for a single final subscriber set up during bean instantiation (unlike
other SubscribableChannels where the MessageHandler is subscribed when the endpoint
is started). |
| FixedSubscriberChannelBeanFactoryPostProcessor |
Used to post process candidates for
FixedSubscriberChannel
MessageHandlers. |
| FixedSubscriberChannelPrototype |
An "artificial"
MessageChannel implementation which will be unwrapped to the
FixedSubscriberChannel on the bean
registration phase. |
| FluxAggregatorMessageHandler |
The
AbstractMessageProducingHandler implementation for aggregation logic based
on Reactor's Flux.groupBy(java.util.function.Function<? super T, ? extends K>) and Flux.window(int) operators. |
| FluxMessageChannel |
The
AbstractMessageChannel implementation for the
Reactive Streams Publisher based on the Project Reactor Flux. |
| FluxMessageChannelSpec | |
| FunctionExpression<S> |
An
Expression that simply invokes Function.apply(Object) on its
provided Function. |
| FunctionIterator<T,V> |
An
Iterator implementation to convert each item from the target
FunctionIterator.iterator to a new object applying the FunctionIterator.function on FunctionIterator.next(). |
| Gateway |
Indicates that an interface method is capable of mapping its parameters
to a message or message payload.
|
| GatewayEndpointSpec |
A
ConsumerEndpointSpec implementation for a mid-flow GatewayMessageHandler. |
| GatewayHeader |
Provides the message header
value or expression. |
| GatewayMessageHandler |
The
AbstractReplyProducingMessageHandler implementation for mid-flow Gateway. |
| GatewayMethodMetadata |
Represents the metadata associated with a Gateway method.
|
| GatewayParser |
Parser for the <gateway/> element.
|
| GatewayProxyFactoryBean |
Generates a proxy for the provided service interface to enable interaction
with messaging components without application code being aware of them allowing
for POJO-style interaction.
|
| GatewayProxySpec |
A builder for the
GatewayProxyFactoryBean options
when MessagingGateway on the service interface cannot be
declared. |
| GaugeFacade | |
| GenericEndpointSpec<H extends org.springframework.messaging.MessageHandler> |
A
ConsumerEndpointSpec for a MessageHandler implementations. |
| GenericHandler<P> |
A functional interface to specify
MessageHandler
logic with Java 8 Lambda expression: |
| GenericMessageJacksonDeserializer |
The
MessageJacksonDeserializer implementation for the GenericMessage. |
| GenericSelector<S> |
Generic (lambda) strategy interface for selector.
|
| GenericTransformer<S,T> |
Generic (lambda) strategy interface for transformer.
|
| GlobalChannelInterceptor |
ChannelInterceptor components with this
annotation will be applied as global channel interceptors
using the provided patterns to match channel names. |
| GlobalChannelInterceptorInitializer |
The
IntegrationConfigurationInitializer to populate GlobalChannelInterceptorWrapper
for ChannelInterceptors marked with
GlobalChannelInterceptor annotation. |
| GlobalChannelInterceptorParser |
Parser for 'channel-interceptor' elements.
|
| GlobalChannelInterceptorProcessor |
This class applies global interceptors (
<channel-interceptor> or @GlobalChannelInterceptor)
to message channels beans. |
| GlobalChannelInterceptorWrapper | |
| GlobalWireTapParser |
Parser for the top level 'wire-tap' element
|
| Graph |
This object can be exposed, for example, as a JSON object over
HTTP.
|
| HandleMessageAdvice |
The marker
MethodInterceptor interface extension
to distinguish advices for some reason. |
| HandleMessageAdviceAdapter |
A
HandleMessageAdvice implementation with a plain delegation
to the provided MethodInterceptor. |
| HeaderAttributeCorrelationStrategy |
Default implementation of
CorrelationStrategy. |
| HeaderChannelRegistry |
Implementations convert a channel to a name, retaining a reference to the channel keyed by the name.
|
| HeaderEnricher |
A Transformer that adds statically configured header values to a Message.
|
| HeaderEnricherParserSupport |
Base support class for 'header-enricher' parsers.
|
| HeaderEnricherSpec |
An
IntegrationComponentSpec for a HeaderEnricher. |
| HeaderFilter |
Transformer that removes Message headers.
|
| HeaderFilterParser |
Parser for the 'header-filter' element.
|
| HeaderMapper<T> |
Generic strategy interface for mapping
MessageHeaders to and from other
types of objects. |
| HeaderPropagationAware |
MessageHandlers implementing this interface can propagate headers from
an input message to an output message.
|
| HeaderValueMessageProcessor<T> | |
| HeaderValueRouter |
A Message Router that resolves the MessageChannel from a header value.
|
| HeaderValueRouterParser |
Parser for the <header-value-router/> element.
|
| HistoryWritingMessagePostProcessor | |
| IdempotentReceiver |
A
method that has a MessagingAnnotation (@code @ServiceActivator, @Router etc.)
that also has this annotation, has an
IdempotentReceiverInterceptor applied
to the associated MessageHandler.handleMessage(org.springframework.messaging.Message<?>) method. |
| IdempotentReceiverAutoProxyCreatorInitializer |
The
IntegrationConfigurationInitializer that populates
the ConfigurableListableBeanFactory
with an IdempotentReceiverAutoProxyCreator
when IdempotentReceiverInterceptor BeanDefinitions and their mapping
to Consumer Endpoints are present. |
| IdempotentReceiverInterceptor |
The
MethodInterceptor implementation for the
Idempotent Receiver
E.I. |
| IdempotentReceiverInterceptorParser |
Parser for the <idempotent-receiver/> element.
|
| IdGeneratorConfigurer | |
| IdGenerators |
Alternative
IdGenerator implementations. |
| IdGenerators.JdkIdGenerator |
UUID.randomUUID()
|
| IdGenerators.SimpleIncrementingIdGenerator |
Based on the two
AtomicLongs, for topBits and bottomBits,
respectively. |
| InboundChannelAdapter |
Indicates that a method is capable of producing a
Message
or Message payload. |
| InboundChannelAdapterAnnotationPostProcessor |
Post-processor for Methods annotated with
@InboundChannelAdapter. |
| InboundMessageMapper<T> |
Strategy interface for mapping from an Object to a
Message. |
| IntegrationComponentScan |
Configures component scanning directives for use with
Configuration classes. |
| IntegrationComponentScanRegistrar |
ImportBeanDefinitionRegistrar implementation to scan and register Integration specific components. |
| IntegrationComponentSpec<S extends IntegrationComponentSpec<S,T>,T> |
The common Builder abstraction.
|
| IntegrationConfigurationBeanFactoryPostProcessor |
BeanDefinitionRegistryPostProcessor to apply external Integration
infrastructure configurations via loading IntegrationConfigurationInitializer
implementations using SpringFactoriesLoader. |
| IntegrationConfigurationInitializer |
The strategy to initialize the external Integration infrastructure (@{code BeanFactoryPostProcessor}s,
global beans etc.) in the provided
beanFactory. |
| IntegrationConfigUtils |
Shared utility methods for Integration configuration.
|
| IntegrationConsumer |
Message consumers implement this interface, the message handler within a consumer
may or may not emit output messages.
|
| IntegrationContextUtils |
Utility methods for accessing common integration components from the BeanFactory.
|
| IntegrationConverter |
A marker annotation (an analogue of
<int:converter/>) to register
Converter,
GenericConverter or
ConverterFactory beans for the integrationConversionService. |
| IntegrationConverterInitializer | |
| IntegrationEvaluationContextFactoryBean |
FactoryBean to populate StandardEvaluationContext instances enhanced with:
a BeanFactoryResolver. |
| IntegrationEvent |
Base class for all
ApplicationEvents generated by the framework. |
| IntegrationFlow |
The main Integration DSL abstraction.
|
| IntegrationFlowAdapter |
The base
Adapter class for the IntegrationFlow abstraction. |
| IntegrationFlowBeanPostProcessor |
A
BeanPostProcessor to parse IntegrationFlow beans and register their
components as beans in the provided
BeanFactory, if necessary. |
| IntegrationFlowBuilder | |
| IntegrationFlowContext |
A public API for dynamic (manual) registration of
IntegrationFlows,
not via standard bean registration phase. |
| IntegrationFlowContext.IntegrationFlowRegistration | |
| IntegrationFlowContext.IntegrationFlowRegistrationBuilder |
A Builder pattern implementation for the options to register
IntegrationFlow
in the application context. |
| IntegrationFlowDefinition<B extends IntegrationFlowDefinition<B>> |
The
BaseIntegrationFlowDefinition extension for syntax sugar with generics for some
type-based EIP-methods when an expected payload type is assumed from upstream. |
| IntegrationFlowExtension<B extends IntegrationFlowExtension<B>> |
An
IntegrationFlowDefinition extension for custom Java DSL operators
and reusable solutions. |
| IntegrationFlows |
The central factory for fluent
IntegrationFlowBuilder API. |
| IntegrationGraphServer |
Builds the runtime object model graph.
|
| IntegrationInboundManagement |
Marker interface indicating that this
IntegrationManagement component initiates
message flow. |
| IntegrationManagedResource |
Clone of
ManagedResource
limiting beans thus annotated so that they
will only be exported by the IntegrationMBeanExporter and prevented
from being exported by other MBeanExporters (if present). |
| IntegrationManagement |
Base interface for Integration managed components.
|
| IntegrationManagement.ManagementOverrides |
Toggles to inform the management configurer to not set these properties since
the user has manually configured them in a bean definition.
|
| IntegrationManagementConfiguration |
@Configuration class that registers a IntegrationManagementConfigurer bean. |
| IntegrationManagementConfigurer |
Configures beans that implement
IntegrationManagement. |
| IntegrationManagementParser |
Parser for the <management/> element.
|
| IntegrationMessageHeaderAccessor |
Adds standard SI Headers.
|
| IntegrationNamespaceHandler |
Namespace handler for the integration namespace.
|
| IntegrationNamespaceUtils |
Shared utility methods for integration namespace parsers.
|
| IntegrationNode |
Base class for all nodes.
|
| IntegrationObjectSupport |
A base class that provides convenient access to the bean factory as
well as
TaskScheduler and ConversionService instances. |
| IntegrationPattern |
Indicates that a component implements some Enterprise Integration Pattern.
|
| IntegrationPatternType |
The Enterprise Integration Pattern types.
|
| IntegrationPatternType.IntegrationPatternCategory |
The Enterprise Integration Pattern categories.
|
| IntegrationProperties |
Utility class to encapsulate infrastructure Integration properties constants and
their default values from resources 'META-INF/spring.integration.default.properties'.
|
| IntegrationReactiveUtils |
Utilities for adapting integration components to/from reactive types.
|
| IntegrationRegistrar |
ImportBeanDefinitionRegistrar implementation that configures integration infrastructure. |
| IntegrationResourceHolder |
An implementation of the
ResourceHolder which holds an instance of the current Message
and the synchronization resource |
| IntegrationResourceHolderSynchronization |
The base
ResourceHolderSynchronization for IntegrationResourceHolder. |
| IntegrationSimpleEvaluationContextFactoryBean |
FactoryBean to populate SimpleEvaluationContext instances enhanced with:
a TypeConverter based on the
ConversionService
from the application context. |
| IntegrationUtils |
General utility methods.
|
| Jackson2JsonMessageParser |
JsonInboundMessageMapper.JsonMessageParser implementation that parses JSON messages
and builds a Message with the specified payload type from provided JsonInboundMessageMapper. |
| Jackson2JsonObjectMapper |
Jackson 2 JSON-processor (@link https://github.com/FasterXML)
JsonObjectMapper implementation.
|
| JacksonJsonUtils |
Utility methods for Jackson.
|
| JacksonPresent |
The utility to check if Jackson JSON processor is present in the classpath.
|
| JavaUtils |
Chained utility methods to simplify some Java repetitive code.
|
| JsonHeaders |
Pre-defined names and prefixes to be used for setting and/or retrieving JSON
entries from/to Message Headers and other adapter, e.g.
|
| JsonInboundMessageMapper |
InboundMessageMapper implementation that maps incoming JSON messages
to a Message with the specified payload type. |
| JsonInboundMessageMapper.JsonMessageParser<P> | |
| JsonObjectMapper<N,P> |
Strategy interface to convert an Object to/from the JSON representation.
|
| JsonObjectMapperProvider |
Simple factory to provide JsonObjectMapper
instances based on jackson-databind lib in the classpath.
|
| JsonOutboundMessageMapper |
OutboundMessageMapper implementation the converts a Message to a JSON
string representation. |
| JsonPathUtils |
Utility class to
JsonPathUtils.evaluate(java.lang.Object, java.lang.String, com.jayway.jsonpath.Predicate...) a jsonPath on the provided object. |
| JsonPropertyAccessor |
A SpEL
PropertyAccessor that knows how to read properties from JSON objects. |
| JsonToObjectTransformer |
Transformer implementation that converts a JSON string payload into an instance of the
provided target Class.
|
| JsonToObjectTransformerParser | |
| KryoClassListRegistrar |
A
KryoRegistrar used to validateRegistration a
list of Java classes. |
| KryoClassMapRegistrar |
A
KryoRegistrar implementation backed by a Map
used to explicitly set the registration ID for each class. |
| KryoRegistrar |
Strategy interface used by
PojoCodec to configure registrations
classes consistently across Kryo instances. |
| KryoRegistrationRegistrar |
A
KryoRegistrar implementation backed by a List of Registration. |
| LambdaMessageProcessor |
The
MessageProcessor implementation for method invocation on the single method classes
- functional interface implementations. |
| LeaderEventPublisher |
Interface for publishing leader based application events.
|
| LinkNode |
Represents a link between nodes.
|
| LinkNode.Type | |
| ListenableMetadataStore |
ConcurrentMetadataStore with the ability of registering MetadataStoreListener callbacks, to be
invoked when changes occur in the metadata store. |
| LoadBalancingChannelSpec<S extends MessageChannelSpec<S,C>,C extends AbstractMessageChannel> | |
| LoadBalancingStrategy |
Strategy for determining the iteration order of a MessageHandler list.
|
| LockRegistry |
Strategy for maintaining a registry of shared locks
|
| LockRegistryLeaderInitiator |
Component that initiates leader election based on holding a lock.
|
| LoggingChannelAdapterParser |
Parser for the 'logging-channel-adapter' element.
|
| LoggingHandler |
MessageHandler implementation that simply logs the Message or its payload depending on the value of the
'shouldLogFullMessage' or SpEL 'logExpression' property.
|
| LoggingHandler.Level | |
| ManageableLifecycle |
Makes
Lifecycle methods manageable. |
| ManageableSmartLifecycle |
Extend
ManageableLifecycle to make those methods manageable. |
| MapArgumentResolver |
A
HandlerMethodArgumentResolver implementation to resolve argument
for the MethodParameter as a Map or Properties. |
| MapBuilder<B extends MapBuilder<B,K,V>,K,V> |
A
Builder pattern implementation for the Map. |
| MapMessageConverter |
Converts to/from a Map with 2 keys ('headers' and 'payload').
|
| MappingMessageRouterManagement |
Exposes channel mapping operations when the router is proxied.
|
| MapToObjectTransformer |
Will transform Map to an instance of Object.
|
| MapToObjectTransformerParser | |
| MessageBuilder<T> |
The default message builder; creates immutable
GenericMessages. |
| MessageBuilderFactory | |
| MessageChannelNode |
Represents a message channel.
|
| MessageChannelReactiveUtils | Deprecated.
since 5.3 in favor of
IntegrationReactiveUtils. |
| MessageChannelReference |
An "artificial"
MessageChannel implementation which will be unwrapped to the
MessageChannel bean on the bean registration phase. |
| MessageChannels | |
| MessageChannelSpec<S extends MessageChannelSpec<S,C>,C extends AbstractMessageChannel> | |
| MessageCodec |
PojoCodec configured to encode/decode Message<?>s. |
| MessageCountReleaseStrategy | |
| MessageDecorator |
The
Message decoration contract. |
| MessageDispatcher |
Strategy interface for dispatching messages to handlers.
|
| MessageDispatchingException |
Exception that indicates an internal error occurred within a
MessageDispatcher
preventing message delivery. |
| MessageEndpoint |
Stereotype annotation indicating that a class is capable of serving as a
Message Endpoint.
|
| MessageFilter |
Message Handler that delegates to a
MessageSelector. |
| MessageGatewayNode |
Represents an inbound gateway.
|
| MessageGroup |
A group of messages that are correlated with each other and should be processed in the same context.
|
| MessageGroupExpiredEvent |
Event representing the expiration of a message group.
|
| MessageGroupFactory |
The
MessageGroup factory strategy. |
| MessageGroupMetadata |
Value Object holding metadata about a MessageGroup in the MessageGroupStore.
|
| MessageGroupProcessor |
A processor for correlated groups of messages.
|
| MessageGroupQueue |
A
BlockingQueue that is backed by a MessageGroupStore. |
| MessageGroupStore |
Defines additional storage operations on groups of messages linked by a group id.
|
| MessageGroupStore.MessageGroupCallback |
Invoked when a MessageGroupStore expires a group.
|
| MessageGroupStoreReaper |
Convenient configurable component to allow explicit timed expiry of
MessageGroup instances in a
MessageGroupStore. |
| MessageHandlerChain |
A composite
MessageHandler implementation that invokes a chain of
MessageHandler instances in order. |
| MessageHandlerNode |
Represents a message handler.
|
| MessageHandlerSpec<S extends MessageHandlerSpec<S,H>,H extends org.springframework.messaging.MessageHandler> |
An
IntegrationComponentSpec for MessageHandlers. |
| MessageHandlerSupport |
Base class for Message handling components that provides basic validation and error
handling capabilities.
|
| MessageHandlingTaskDecorator |
The strategy to decorate
MessageHandlingRunnable tasks
to be used with the Executor. |
| MessageHeadersJacksonSerializer |
A Jackson
StdSerializer implementation to serialize MessageHeaders
as a HashMap. |
| MessageHistory | |
| MessageHistory.Entry |
Inner class for each Entry in the history.
|
| MessageHistoryConfigurer | |
| MessageHistoryParser |
The
<message-history/> parser. |
| MessageHistoryRegistrar | |
| MessageHolder |
The
MessageStore specific value object to keep the Message and its metadata. |
| MessageJacksonDeserializer<T extends org.springframework.messaging.Message<?>> |
A Jackson
StdNodeBasedDeserializer extension for Message implementations. |
| MessageKryoRegistrar |
Registers common MessageHeader types and Serializers.
|
| MessageListProcessor | |
| MessageMappingException |
Exception that indicates an error during message mapping.
|
| MessageMetadata |
Value Object holding metadata about a Message in the MessageStore.
|
| MessageProcessingHeaderValueMessageProcessor | |
| MessageProcessor<T> |
This defines the lowest-level strategy of processing a Message and returning
some Object (or null).
|
| MessageProcessorMessageSource |
The
MessageSource strategy implementation
to produce a Message from underlying
MessageProcessorMessageSource.messageProcessor for polling endpoints. |
| MessageProcessorSpec<S extends MessageProcessorSpec<S>> |
The
IntegrationComponentSpec specific base class
for MessageProcessors. |
| MessageProducer |
Base interface for any component that is capable of sending
messages to a
MessageChannel. |
| MessageProducerNode |
Represents an inbound message producer.
|
| MessageProducerSpec<S extends MessageProducerSpec<S,P>,P extends MessageProducerSupport> |
An
IntegrationComponentSpec for
MessageProducers. |
| MessageProducerSupport |
A support class for producer endpoints that provides a setter for the
output channel and a convenience method for sending Messages.
|
| MessagePublishingErrorHandler |
ErrorHandler implementation that sends an ErrorMessage to a
MessageChannel. |
| MessagePublishingInterceptor |
A
MethodInterceptor that publishes Messages to a channel. |
| MessageRejectedException |
Exception that indicates a message has been rejected by a selector.
|
| MessageRouter |
Routers implementing this interface have a default output channel.
|
| MessageSelectingInterceptor |
A
ChannelInterceptor that
delegates to a list of MessageSelectors to decide
whether a Message should be accepted on the MessageChannel. |
| MessageSelector |
Strategy interface for message selection.
|
| MessageSelectorChain |
A message selector implementation that passes incoming messages through a
chain of selectors.
|
| MessageSelectorChain.VotingStrategy | |
| MessageSequenceComparator | |
| MessageSource<T> |
Base interface for any source of
Messages that can be polled. |
| MessageSourceManagement |
Message sources implementing this interface have additional properties that
can be set or examined using JMX.
|
| MessageSourceMutator |
A
ReceiveMessageAdvice extension that can mutate a MessageSource before and/or after
MessageSource.receive() is called. |
| MessageSourceNode |
Represents a message source.
|
| MessageSourcePollingTemplate |
A
PollingOperations used to ad-hoc poll a MessageSource. |
| MessageSourceSpec<S extends MessageSourceSpec<S,H>,H extends MessageSource<?>> |
An
IntegrationComponentSpec for MessageSources. |
| MessageStore |
Strategy interface for storing and retrieving messages.
|
| MessageStoreException |
Exception for problems that occur when using a
MessageStore implementation. |
| MessageTimeoutException |
Exception that indicates a timeout elapsed prior to successful message delivery.
|
| MessageTransformationException |
Base Exception type for Message transformation errors.
|
| MessageTransformingHandler |
A reply-producing
MessageHandler
that delegates to a Transformer instance to modify the received Message
and sends the result to its output channel. |
| MessageTriggerAction |
Classes implementing this interface can take some action when a trigger
Message
is received. |
| MessagingAnnotationPostProcessor |
A
BeanPostProcessor implementation that processes method-level
messaging annotations such as @Transformer, @Splitter, @Router, and @Filter. |
| MessagingAnnotationUtils |
Utility methods to support annotation processing.
|
| MessagingExceptionWrapper |
A wrapper exception for a
MessagingException used to convey the cause and
original message to a
MessagePublishingErrorHandler. |
| MessagingGateway |
A stereotype annotation to provide an Integration Messaging Gateway Proxy
(
<gateway/>) as an abstraction over the messaging API. |
| MessagingGatewayRegistrar |
The
ImportBeanDefinitionRegistrar to parse MessagingGateway and its service-interface
and to register BeanDefinition GatewayProxyFactoryBean. |
| MessagingGatewaySpec<S extends MessagingGatewaySpec<S,G>,G extends MessagingGatewaySupport> | |
| MessagingGatewaySupport |
A convenient base class for connecting application code to
MessageChannels for sending, receiving, or request-reply operations. |
| MessagingMethodInvokerHelper |
A helper class for processors that invoke a method on a target Object using
a combination of message payload(s) and headers as arguments.
|
| MessagingMethodInvokerHelper.ParametersWrapper | |
| MessagingTemplate | |
| MetadataStore |
Strategy interface for storing metadata from certain adapters
to avoid duplicate delivery of messages, for example.
|
| MetadataStoreListener |
A callback to be invoked whenever a value changes in the data store.
|
| MetadataStoreListenerAdapter |
Base implementation for a
MetadataStoreListener. |
| MetadataStoreSelector | |
| MeterFacade |
Facade for Meters.
|
| MethodAnnotationPostProcessor<T extends java.lang.annotation.Annotation> |
Strategy interface for post-processing annotated methods.
|
| MethodAnnotationPublisherMetadataSource |
An
PublisherMetadataSource implementation that retrieves the channel
name and expression strings from an annotation. |
| MethodArgsHolder |
Simple wrapper class containing a
Method and an object
array containing the arguments for an invocation of that method. |
| MethodArgsMessageMapper |
Implementations of this interface are
InboundMessageMappers
that map a MethodArgsHolder to a Message. |
| MethodInvokingCorrelationStrategy |
CorrelationStrategy implementation that works as an adapter to another bean. |
| MethodInvokingMessageGroupProcessor |
MessageGroupProcessor that serves as an adapter for the invocation of a POJO method.
|
| MethodInvokingMessageHandler |
A
MessageHandler that invokes the specified
method on the provided object. |
| MethodInvokingMessageListProcessor<T> |
A MessageListProcessor implementation that invokes a method on a target POJO.
|
| MethodInvokingMessageProcessor<T> |
A MessageProcessor implementation that invokes a method on a target Object.
|
| MethodInvokingMessageSource |
A
MessageSource implementation that
invokes a no-argument method so that its return value may be sent to a channel. |
| MethodInvokingReleaseStrategy |
A
ReleaseStrategy that invokes a method on a plain old Java object. |
| MethodInvokingRouter |
A Message Router that invokes the specified method on the given object.
|
| MethodInvokingSelector |
A method-invoking implementation of
MessageSelector. |
| MethodInvokingSplitter |
A Message Splitter implementation that invokes the specified method
on the given object.
|
| MethodInvokingTransformer |
A Message Transformer implementation that invokes the specified method
on the given object.
|
| MethodNameMappingPublisherMetadataSource | |
| MetricsCaptor |
A metrics facade that delegates to a concrete implementation.
|
| MetricsCaptor.CounterBuilder |
A builder for a counter.
|
| MetricsCaptor.GaugeBuilder |
A builder for a gauge.
|
| MetricsCaptor.TimerBuilder |
A builder for a timer.
|
| MicrometerMetricsCaptor |
The Micrometer implementation of
MetricsCaptor. |
| MicrometerMetricsCaptor.AbstractMeter<M extends io.micrometer.core.instrument.Meter> | |
| MicrometerMetricsCaptor.MicroCounter | |
| MicrometerMetricsCaptor.MicroCounterBuilder | |
| MicrometerMetricsCaptor.MicroGauge | |
| MicrometerMetricsCaptor.MicroGaugeBuilder | |
| MicrometerMetricsCaptor.MicroTimer | |
| MicrometerMetricsCaptor.MicroTimerBuilder | |
| MicrometerMetricsCaptorRegistrar |
An
ImportBeanDefinitionRegistrar to conditionally add a MicrometerMetricsCaptor
bean when io.micrometer.core.instrument.MeterRegistry is present in classpath and
no MicrometerMetricsCaptor.MICROMETER_CAPTOR_NAME bean present yet. |
| MicrometerNodeEnhancer |
Add micrometer metrics to the node.
|
| MimeTypeSerializer |
Simple
StdSerializer extension to represent a MimeType object in the
target JSON as a plain string. |
| MutableMessage<T> |
An implementation of
Message with a generic payload. |
| MutableMessageBuilder<T> |
Specialized message builder that can be used within a component to avoid the overhead
of having to build multiple messages for mutations within that component.
|
| MutableMessageBuilderFactory | |
| MutableMessageHeaders |
A MessageHeaders that permits direct access to and modification of the
header map.
|
| MutableMessageJacksonDeserializer |
The
MessageJacksonDeserializer implementation for the MutableMessage. |
| NamedComponent | |
| NullAwarePayloadArgumentResolver |
A
PayloadMethodArgumentResolver that treats KafkaNull payloads as null. |
| NullChannel |
A channel implementation that essentially behaves like "/dev/null".
|
| ObjectStringMapBuilder |
A map builder creating a map with Object keys and String values.
|
| ObjectStringMessageConverter |
A
StringMessageConverter extension to convert any object to string. |
| ObjectToJsonTransformer |
Transformer implementation that converts a payload instance into a JSON string
representation.
|
| ObjectToJsonTransformer.ResultType | |
| ObjectToJsonTransformerParser | |
| ObjectToMapTransformer |
Transforms an object graph into a Map.
|
| ObjectToMapTransformerParser | |
| ObjectToStringTransformer |
A simple transformer that creates an outbound payload by invoking the
inbound payload Object's
toString() method. |
| ObjectToStringTransformerParser |
Parser for the 'object-to-string-transformer' element.
|
| OnFailedToAcquireMutexEvent |
Generic event representing that a mutex could not be acquired during leader election.
|
| OnGrantedEvent |
Generic event representing that leader has been granted.
|
| OnRevokedEvent |
Generic event representing that leader has been revoked.
|
| Orderable |
Interface that extends
Ordered while also exposing the
Orderable.setOrder(int) as an interface-level so that it is avaiable
on AOP proxies, etc. |
| OrderlyShutdownCapable |
Interface for components that wish to be considered for
an orderly shutdown using management interfaces.
|
| OutboundMessageMapper<T> |
Strategy interface for mapping from a
Message to an Object. |
| PartialSuccessException |
A
MessagingException thrown when a non-transactional operation is
performing multiple updates from a single message, e.g. |
| PassThroughTransactionSynchronizationFactory |
A simple
TransactionSynchronizationFactory implementation which produces
an IntegrationResourceHolderSynchronization with an IntegrationResourceHolder. |
| PassThruLockRegistry |
The
LockRegistry implementation which has no effect. |
| PassThruMessageConverter |
The simple
MessageConverter implementation which contract is to return
Message as is for both from/to operations. |
| PatternMatchUtils |
Utility methods for pattern matching.
|
| Pausable |
Endpoints implementing this interface can be paused/resumed.
|
| PayloadDeserializingTransformer |
Transformer that deserializes the inbound byte array payload to an object by delegating
to a Converter<byte[], Object>.
|
| PayloadDeserializingTransformerParser |
Parser for the 'payload-deserializing-transformer' element.
|
| PayloadExpressionArgumentResolver |
The
HandlerMethodArgumentResolver for evaluating Payload.expression()
as a SpEL expression against message and converting result to expected parameter type. |
| Payloads |
This annotation marks a method parameter as being a list of message payloads, for POJO handlers that deal with lists
of messages (e.g.
|
| PayloadsArgumentResolver |
The
HandlerMethodArgumentResolver for resolving a Collection
of payloads or expression against each payload. |
| PayloadSerializingTransformer |
Transformer that serializes the inbound payload into a byte array by delegating to a
Converter<Object, byte[]>.
|
| PayloadSerializingTransformerParser |
Parser for the 'payload-serializing-transformer' element.
|
| PayloadTypeConvertingTransformer<T,U> |
Transformer that converts the inbound payload to an object by delegating to a
Converter<Object, Object>.
|
| PayloadTypeRouter |
A Message Router that resolves the
MessageChannel
based on the Message's payload type. |
| PayloadTypeRouterParser |
Parser for the <payload-type-router/> element.
|
| PayloadTypeSelector |
A
MessageSelector implementation that checks the type of the
Message payload. |
| PointToPointChannelParser |
Parser for the <channel> element.
|
| PojoCodec |
Kryo Codec that can encode and decode arbitrary types.
|
| PollableChannelNode |
Represents a pollable channel.
|
| Poller |
Provides the
PollerMetadata options
for the Messaging annotations for polled endpoints. |
| PollerFactory |
An
Adapter class for the Pollers factory. |
| PollerMetadata | |
| PollerParser |
Parser for the <poller> element.
|
| Pollers |
An utility class to provide
PollerSpecs for
PollerMetadata configuration
variants. |
| PollerSpec |
An
IntegrationComponentSpec for PollerMetadatas. |
| PollingConsumer |
Message Endpoint that connects any
MessageHandler implementation
to a PollableChannel. |
| PollingOperations |
Operations to perform on some message source.
|
| PollSkipAdvice |
An advice that can be added to a poller's advice chain that determines
whether a poll should be skipped or not.
|
| PollSkipStrategy |
Implementations determine whether a particular poll should be skipped.
|
| Pool<T> |
Represents a pool of items.
|
| PoolItemNotAvailableException |
Thrown when a pooled item could not be obtained for some reason.
|
| PostProcessingMessageHandler |
Implementations of this interface are subclasses of
AbstractMessageHandler that perform post processing after the
AbstractMessageHandler.handleMessageInternal(org.springframework.messaging.Message)
call. |
| PriorityCapableChannelMessageStore |
A
ChannelMessageStore that supports the
notion of message priority. |
| PriorityChannel |
A message channel that prioritizes messages based on a
Comparator. |
| PriorityChannelSpec | |
| PropertiesBuilder |
A
Builder pattern implementation for the Properties. |
| PropertiesPersistingMetadataStore |
Properties file-based implementation of
MetadataStore. |
| PseudoTransactionManager |
An implementation of
PlatformTransactionManager
that provides transaction-like semantics to
MessageSources that are not inherently
transactional. |
| Publisher |
Annotation to indicate that a method, or all public methods if applied at class-level,
should publish Messages.
|
| PublisherAnnotationAdvisor |
An advisor that will apply the
MessagePublishingInterceptor to any
methods containing the provided annotations. |
| PublisherAnnotationBeanPostProcessor |
Post-processes beans that contain the
method-level @
Publisher annotation. |
| PublisherRegistrar | |
| PublishingInterceptorParser |
Parser for the <publishing-interceptor> element.
|
| PublishSubscribeChannel |
A channel that sends Messages to each of its subscribers.
|
| PublishSubscribeChannelParser |
Parser for the <publish-subscribe-channel> element.
|
| PublishSubscribeChannelSpec<S extends PublishSubscribeChannelSpec<S>> | |
| PublishSubscribeSpec |
The
PublishSubscribeChannelSpec extension to configure as a general flow callback for sub-flows
as subscribers. |
| QueueChannel |
Simple implementation of a message channel.
|
| QueueChannelOperations |
Operations available on a channel that has queuing semantics.
|
| QueueChannelSpec | |
| QueueChannelSpec.MessageStoreSpec |
The
ChannelMessageStore-specific QueueChannelSpec extension. |
| RateLimiterRequestHandlerAdvice |
An
AbstractRequestHandlerAdvice extension for a rate limiting to service method calls. |
| RateLimiterRequestHandlerAdvice.RateLimitExceededException |
A
MessagingException wrapper for the RequestNotPermitted
with the requestMessage and target context. |
| ReactiveMessageHandlerAdapter |
A
MessageHandler implementation to adapt a ReactiveMessageHandler
for synchronous invocations. |
| ReactiveMessageHandlerSpec<S extends ReactiveMessageHandlerSpec<S,H>,H extends org.springframework.messaging.ReactiveMessageHandler> |
The
MessageHandlerSpec extension for ReactiveMessageHandler. |
| ReactiveMessageSourceProducer |
The
MessageProducerSupport to adapt a provided MessageSource
into a Flux and let it be subscribed in the MessageProducerSupport.subscribeToPublisher(org.reactivestreams.Publisher<? extends org.springframework.messaging.Message<?>>) |
| ReactiveRequestHandlerAdvice |
A
MethodInterceptor for message handlers producing a Mono as a payload for reply. |
| ReactiveStreamsConsumer |
An
AbstractEndpoint implementation for Reactive Streams subscription into an
input channel and reactive consumption of messages from that channel. |
| ReactiveStreamsSubscribableChannel | |
| ReceiveCounters |
Counters for components that maintain receive counters.
|
| ReceiveCountersAware | |
| ReceiveMessageAdvice |
An AOP advice to perform hooks before and/or after a
receive() contract is called. |
| RecipientListRouter |
<recipient-list-router id="simpleRouter" input-channel="routingChannelA">
<recipient channel="channel1"/>
<recipient channel="channel2"/>
</recipient-list-router>
|
| RecipientListRouter.Recipient | |
| RecipientListRouterManagement |
Exposes adding/removing individual recipients operations for
RecipientListRouter.
|
| RecipientListRouterParser |
Parser for the <recipient-list-router/> element.
|
| RecipientListRouterSpec |
An
AbstractRouterSpec for a RecipientListRouter. |
| RegistrationIds |
Default registration ids for serializers provided by the framework.
|
| ReleaseStrategy |
Strategy for determining when a group of messages reaches a state of
completion (i.e.
|
| ReleaseStrategy |
Indicates that a method is capable of asserting if a list of messages or
payload objects is complete.
|
| ReleaseStrategyFactoryBean |
Convenience factory for XML configuration of a
ReleaseStrategy. |
| ReloadableResourceBundleExpressionSource |
ExpressionSource implementation that accesses resource bundles using specified basenames. |
| RendezvousChannel |
A zero-capacity version of
QueueChannel that delegates to a
SynchronousQueue internally. |
| RendezvousChannelSpec | |
| RenewableLockRegistry |
A
LockRegistry implementing this interface supports the renewal
of the time to live of a lock. |
| ReplyProducingMessageHandlerWrapper |
The
AbstractReplyProducingMessageHandler wrapper around raw MessageHandler
for request-reply scenarios, e.g. |
| ReplyRequiredException |
Exception that indicates no reply message is produced by a handler
that does have a value of true for the 'requiresReply' property.
|
| RequestHandlerCircuitBreakerAdvice |
A circuit breaker that stops calling a failing service after threshold
failures, until halfOpenAfter milliseconds has elapsed.
|
| RequestHandlerCircuitBreakerAdvice.CircuitBreakerOpenException |
An exception thrown when the circuit breaker is in an open state.
|
| RequestHandlerRetryAdvice |
Uses spring-retry to perform stateless or stateful retry.
|
| RequestReplyExchanger |
Interface for a request/reply Message exchange.
|
| RequestReplyHeaderMapper<T> |
Request/Reply strategy interface for mapping
MessageHeaders to and from other
types of objects. |
| ResequencerParser |
Parser for the <resequencer> element.
|
| ResequencerSpec | |
| ResequencingMessageGroupProcessor |
This class implements all the strategy interfaces needed for a default resequencer.
|
| ResequencingMessageHandler |
Resequencer specific implementation of
AbstractCorrelatingMessageHandler. |
| ResourceInboundChannelAdapterParser |
Parser for 'resource-inbound-channel-adapter'
|
| ResourceRetrievingMessageSource |
Implementation of
MessageSource based on
ResourcePatternResolver which will attempt to resolve Resources based
on the pattern specified. |
| RetryAdviceParser | |
| RetryStateGenerator |
Strategy interface for generating a
RetryState instance
based on a message. |
| Role |
Annotate endpoints to assign them to a role.
|
| RoundRobinLoadBalancingStrategy |
Round-robin implementation of
LoadBalancingStrategy. |
| Router |
Indicates that a method is capable of resolving to a channel or channel name
based on a message, message header(s), or both.
|
| RouterAnnotationPostProcessor |
Post-processor for Methods annotated with
@Router. |
| RouterFactoryBean |
Factory bean for creating a Message Router.
|
| RouterSpec<K,R extends AbstractMappingMessageRouter> |
The
AbstractRouterSpec for an AbstractMappingMessageRouter. |
| RoutingMessageHandlerNode |
Represents an endpoint that can route to multiple channels.
|
| RoutingSlipHeaderValueMessageProcessor |
The
RoutingSlip HeaderValueMessageProcessor specific implementation. |
| RoutingSlipRouteStrategy |
The
RoutingSlip strategy to determine the next replyChannel. |
| SampleFacade | |
| ScatterGatherHandler |
The
MessageHandler implementation for the
Scatter-Gather EIP pattern. |
| ScatterGatherParser |
Parser for the <scatter-gather> element.
|
| ScatterGatherSpec |
A
GenericEndpointSpec extension for the ScatterGatherHandler. |
| SelectorChainParser |
Parser for the <selector-chain/> element.
|
| SelectorParser |
Parser for a top-level <selector/> element.
|
| SendTimers |
Success and failure timer stats.
|
| SendTimersAware | |
| SequenceSizeReleaseStrategy |
An implementation of
ReleaseStrategy that simply compares the current size of
the message list to the expected 'sequenceSize'. |
| ServiceActivatingHandler | |
| ServiceActivator |
Indicates that a method is capable of handling a message or message payload.
|
| ServiceActivatorAnnotationPostProcessor |
Post-processor for Methods annotated with
@ServiceActivator. |
| ServiceActivatorFactoryBean |
FactoryBean for creating
ServiceActivatingHandler instances. |
| ServiceActivatorParser |
Parser for the <service-activator> element.
|
| SimpleAcknowledgment |
Opaque object for manually acknowledging.
|
| SimpleActiveIdleMessageSourceAdvice | Deprecated.
since 5.3 in favor of
SimpleActiveIdleReceiveMessageAdvice with the same
(but more common) functionality. |
| SimpleActiveIdleReceiveMessageAdvice |
A simple advice that polls at one rate when messages exist and another when
there are no messages.
|
| SimpleFromAvroTransformer |
An Apache Avro transformer to create generated
SpecificRecord objects
from byte[]. |
| SimpleJsonSerializer |
Extremely simple JSON serializer.
|
| SimpleMessageConverter | |
| SimpleMessageGroup |
Represents a mutable group of correlated messages that is bound to a certain
MessageStore and group id. |
| SimpleMessageGroupFactory |
The
MessageGroupFactory implementation to produce SimpleMessageGroup instances. |
| SimpleMessageGroupFactory.GroupType | |
| SimpleMessageGroupProcessor |
A
MessageGroupProcessor that simply returns the messages in the group. |
| SimpleMessageStore |
Map-based in-memory implementation of
MessageStore and MessageGroupStore. |
| SimpleMetadataStore |
Simple implementation of
MetadataStore that uses a ConcurrentMap for the data store. |
| SimplePollSkipStrategy |
A simple
PollSkipStrategy to be used with a PollSkipAdvice. |
| SimplePool<T> |
Implementation of
Pool supporting dynamic resizing and a variable
timeout when attempting to obtain an item from the pool. |
| SimplePool.PoolItemCallback<T> |
User of the pool provide an implementation of this interface; called during
various pool operations.
|
| SimplePublisherMetadataSource |
Simple implementation of
PublisherMetadataSource that allows for
configuration of a single channel name, payload expression, and
array of header key=value expressions. |
| SimpleSequenceSizeReleaseStrategy |
An implementation of
ReleaseStrategy that simply compares the current size of
the message list to the expected 'sequenceSize'. |
| SimpleToAvroTransformer |
An Apache Avro transformer for generated
SpecificRecord objects. |
| SmartLifecycleRoleController |
Bulk start/stop
SmartLifecycle in a particular role in phase order. |
| SourcePollingChannelAdapter |
A Channel Adapter implementation for connecting a
MessageSource to a MessageChannel. |
| SourcePollingChannelAdapterFactoryBean |
FactoryBean for creating a SourcePollingChannelAdapter instance.
|
| SourcePollingChannelAdapterSpec | |
| SpelExpressionRetryStateGenerator |
Creates a DefaultRetryState from a
Message. |
| SpelFunctionFactoryBean |
A
FactoryBean implementation to encapsulate the population of a static Method
from the provided SpelFunctionFactoryBean.functionClass and SpelFunctionFactoryBean.functionMethodSignature as
a valid StandardEvaluationContext function. |
| SpelFunctionParser |
Parser for the <spel-function> element.
|
| SpelPropertyAccessorRegistrar |
Utility class that keeps track of a Set of SpEL
PropertyAccessors
in order to register them with the "integrationEvaluationContext" upon initialization. |
| SpelPropertyAccessorsParser |
Parser for the <spel-property-accessors> element.
|
| Splitter |
Indicates that a method is capable of splitting a single message or message
payload to produce multiple messages or payloads.
|
| SplitterAnnotationPostProcessor |
Post-processor for Methods annotated with
@Splitter. |
| SplitterEndpointSpec<S extends AbstractMessageSplitter> |
A
ConsumerEndpointSpec for a AbstractMessageSplitter implementations. |
| SplitterFactoryBean |
Factory bean for creating a Message Splitter.
|
| SplitterParser |
Parser for the <splitter/> element.
|
| StackTraceUtils |
Utility methods for analyzing stack traces.
|
| StandardHeaderEnricherParser |
Parser for the <header-enricher> element within the core integration
namespace.
|
| StandardIntegrationFlow |
The standard implementation of the
IntegrationFlow interface instantiated
by the Framework. |
| StandardIntegrationFlowContext |
Standard implementation of
IntegrationFlowContext. |
| StaticHeaderValueMessageProcessor<T> | |
| StaticMessageHeaderAccessor |
Lightweight type-safe header accessor avoiding object
creation just to access a header.
|
| StreamTransformer |
Transforms an InputStream payload to a byte[] or String (if a
charset is provided).
|
| StreamTransformerParser |
Parser for
<stream-transformer/> element. |
| StringObjectMapBuilder |
A map builder creating a map with String keys and values.
|
| StringStringMapBuilder |
A map builder creating a map with String keys and values.
|
| SubscribableChannelManagement |
Metrics for subscribable channels.
|
| SupplierExpression<T> |
An
Expression that simply invokes Supplier.get() on its
provided Supplier. |
| SyslogToMapTransformer |
Transforms a packet in Syslog (RFC3164) format to a Map.
|
| SyslogToMapTransformerParser | |
| ThreadStatePropagationChannelInterceptor<S> |
The
ExecutorChannelInterceptor implementation responsible for
the Thread (any?) state propagation from one message flow's thread to another
through the MessageChannels involved in the flow. |
| TimeoutCountSequenceSizeReleaseStrategy |
A
ReleaseStrategy that releases all messages if any of the following is true:
The sequence is complete (if there is one).
There are more messages than a threshold set by the user.
The time elapsed since the earliest message, according to their timestamps, if
present, exceeds a timeout set by the user.
|
| TimerFacade | |
| TimerStats |
Statistics captured from a timer meter.
|
| TrackableComponent | |
| TransactionHandleMessageAdvice |
A
TransactionInterceptor extension with HandleMessageAdvice marker. |
| TransactionInterceptorBuilder |
Provides a fluent API to build a transaction interceptor.
|
| TransactionSynchronizationFactory |
Strategy for implementing factories that create
TransactionSynchronization |
| TransactionSynchronizationFactoryBean |
The
FactoryBean implementation (with Builder style) to be used
from JavaConfig to populate DefaultTransactionSynchronizationFactory bean. |
| TransactionSynchronizationFactoryParser |
Parser for transaction-synchronizatioin-factory element
|
| TransactionSynchronizationProcessor |
Strategy for implementing transaction synchronization processors
|
| Transformer |
Indicates that a method is capable of transforming a message, message header,
or message payload.
|
| Transformer |
Strategy interface for transforming a
Message. |
| TransformerAnnotationPostProcessor |
Post-processor for Methods annotated with a
@Transformer. |
| TransformerFactoryBean |
Factory bean for creating a Message Transformer.
|
| TransformerParser |
Parser for the <transformer/> element.
|
| Transformers |
An utility class to provide methods for out-of-the-box
Transformers. |
| UnexpiredMessageSelector |
A
MessageSelector that accepts Messages that are
not yet expired. |
| UnicastingDispatcher |
Implementation of
MessageDispatcher that will attempt to send a
Message to at most one of its handlers. |
| UniqueExpiryCallback |
A marker interface extension of the
MessageGroupStore.MessageGroupCallback
for components which should be registered in the MessageGroupStore only once. |
| UniqueMethodFilter | |
| UpperBound |
Thin wrapper around a Semaphore that allows to create a potentially unlimited upper bound
to by used in buffers of messages (e.g.
|
| UseSpelInvoker |
Indicates that a POJO handler method (
@ServiceActivator, @Transformer, etc.,
or such methods invoked from XML definitions) should be invoked using SpEL. |
| UUIDConverter |
Utility to help generate UUID instances from generic objects.
|
| ValueExpression<V> |
A very simple hardcoded implementation of the
Expression interface that represents an
immutable value. |
| VetoCapableInterceptor |
ChannelInterceptors implementing this
interface can veto global interception of a particular channel. |
| WhileLockedProcessor |
A simple strategy callback class that allows you to provide
a code that needs to be executed under
Lock provided by
LockRegistry
A typical usage would be to provide implementation of WhileLockedProcessor.whileLocked() method and
then call WhileLockedProcessor.doWhileLocked() |
| WireTap |
A
ChannelInterceptor that publishes a copy of the intercepted message
to a secondary target while still sending the original message to the main channel. |
| WireTapParser |
Parser for the <wire-tap> element.
|
| WireTapSpec |
The
IntegrationComponentSpec implementation for the WireTap component. |