|
|||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
MessageStore.AbstractCorrelatingMessageHandlerMessageDispatcher implementations.MessageGroupStore and MessageStoreMessageChannel implementations providing common
properties such as the channel name.MessageProcessor.Transformer implementations that modify the payload
of a Message.MessageHandler advice classes.MessageChannel that invokes the subscribed
handler(s) by delegating to a MessageDispatcher.Transformer implementations.CollectionFilter that remembers the elements passed in
the previous invocation in order to avoid returning those elements more than once.ResourceHolder instance
MessagingTemplate to send downstream.
AbstractCorrelatingMessageHandler.@Aggregator annotation.ChannelResolver implementation based on a Spring BeanFactory.BeanFactoryChannelResolver class.
BeanFactoryChannelResolver class.
Messages being sent-to and/or received-from a
MessageChannel.ChannelInterceptor with no-op method implementations so that
subclasses do not have to implement all of the interface's methods.Messages from one or more
QueueChannels.MessageChannel.Messages from this channel.
UnsupportedOperationException
TransactionInterceptor
with "transactionManager" and other "transactionDefinition" properties.
DefaultTransactionAttribute
with provided "transactionDefinition" properties.
UUIDConverter.getUUID(Object).
CorrelationStrategy.StandardEvaluationContext with a MapAccessor in its
property accessor property.
StandardEvaluationContext with a MapAccessor in its
property accessor property and the supplied BeanResolver in its
beanResolver property.
StandardEvaluationContext with a MapAccessor in its
property accessor property and the supplied ConversionService in its
conversionService property.
StandardEvaluationContext with a MapAccessor in its
property accessor property, the supplied BeanResolver in its
beanResolver property, and the supplied ConversionService in its
conversionService property.
BeanFactoryResolver, extracts ConversionService and delegates to
ExpressionUtils.createStandardEvaluationContext(BeanResolver, ConversionService)
LockRegistry which uses Masked Hashcode algorithm to obtain locks.TransactionSynchronizationFactory which takes an instance of
TransactionSynchronizationProcessor allowing you to create a TransactionSynchronization
using {DefaultTransactionSynchronizationFactory.create(Object) method.MessageHandler that is capable of delaying the continuation of a
Message flow based on the presence of a delay header on an inbound Message
or a default delay value configured on this handler.MessageGroup
to store delayed Messages in the MessageGroupStore.
RoundRobinLoadBalancingStrategy
LoadBalancingStrategy.
MessageHandler. callback.execute()
invokes the handler method and returns its result, or null.
AbstractPollingEndpoint.receiveMessage() and AbstractPollingEndpoint.handleMessage(Message) instead,
to separate the concerns of retrieving and processing a message.
Consider refactoring now rather than waiting for 3.0.
Expression that delegates to an ExpressionSource
for resolving the actual Expression instance per-invocation at runtime.TaskExecutor implementation that wraps an existing Executor
instance in order to catch any exceptions.Throwable payload.MessageChannel for
messages whose payload is an Exception.MessageHandler implementation to a SubscribableChannel.MessageChannel that delegates to an instance of
UnicastingDispatcher which in turn delegates all dispatching
invocations to an Executor.Executor when dispatching Messages.
LoadBalancingStrategy that
delegates to the provided Executor when dispatching Messages.
MessageHandler instances to handle a message as a SpEL expression.CorrelationStrategy implementation that evaluates an expression.MessageGroupProcessor implementation that evaluates a SpEL expression.MessageHandler that evaluates
the provided Expression expecting a void return.MessageProcessor implementation that evaluates a SpEL expression
with the Message itself as the root object within the evaluation context.ExpressionEvaluatingMessageProcessor for the given expression.
ExpressionEvaluatingMessageProcessor for the given expression
and expected type for its evaluation result.
ReleaseStrategy that evaluates an expression.MessageHandlers.MessageSelector implementation that evaluates a SpEL expression.TransactionSynchronizationFactory
allows you to configure SpEL expressions, with their execution being coordinated (synchronized) with a
transaction - see TransactionSynchronization.@Filter.MethodFilter implementation that will always return
the same Method instance within a single-element list if it is
present in the candidate list.Message instance pre-populated with all of the headers copied from the
provided message.
IntegrationObjectSupport.componentName field.
ConversionService bean whose name is "integrationConversionService" if available.
PollerMetadata bean if available.
MessageChannel bean whose name is "errorChannel".
next() invocations.
Set of this dispatcher's handlers.
MessageGroupStore.addMessageToGroup(Object, Message) with this group id.
MessagingTemplate for subclasses.
MessagingTemplate access for subclasses.
MetadataStore bean whose name is "metadataStore".
TaskScheduler bean whose name is "taskScheduler".
TaskScheduler bean whose name is "taskScheduler" if available.
DelayHandler.releaseMessageAfterDelay(org.springframework.integration.Message, long) and DelayHandler.DelayedMessageWrapper).
CorrelationStrategy.MessageHeaders to and from other
types of objects.Message.TaskScheduler and ConversionService instances.ResourceHolder which holds an instance of the current Message
and the synchronization resourceMessageHandlerChain.handlers)
MessageGroups
InboundMessageMapper implementation that maps incoming JSON messages to a Message with the specified payload type.OutboundMessageMapper implementation the converts a Message to a JSON string representation.ReleaseStrategy that releases only the first n messages, where n is a threshold.MessageDispatcher preventing message delivery.MessageSelector.MessageSelector.
BlockingQueue that is backed by a MessageGroupStore.MessageGroup instances in a
MessageGroupStore.MessageHandler implementation that invokes a chain of
MessageHandler instances in order.Message.MessageChannel.ErrorHandler implementation that sends an ErrorMessage to a
MessageChannel.MethodInterceptor that publishes Messages to a channel.ChannelInterceptor that
delegates to a list of MessageSelectors to decide
whether a Message should be accepted on the MessageChannel.Comparator implementation based on the 'sequence number'
property of a Message's header.Messages that can be polled.MessageStore implementation.ChannelInterceptor which invokes a Transformer
when either sending-to or receiving-from a channel.MessageHandler that delegates to a
Transformer instance to modify the received Message
and sends the result to its output channel.MessageTransformingHandler instance that delegates to
the provided Transformer.
BeanPostProcessor implementation that processes method-level
messaging annotations such as @Transformer, @Splitter, @Router, and @Filter.MessageChannels for sending, receiving, or request-reply operations.MessageChannels.PublisherMetadataSource implementation that retrieves the channel
name and expression strings from an annotation.CorrelationStrategy implementation that works as an adapter to another bean.MessageHandler that invokes the specified method on the provided object.MessageSource implementation that invokes a no-argument method so
that its return value may be sent to a channel.ReleaseStrategy that invokes a method on a plain old Java object.MessageSelector.toString() method.ContextRefreshedEvent to invoke DelayHandler.reschedulePersistedMessages()
as late as possible after application context startup.
Ordered while also exposing the
Orderable.setOrder(int) as an interface-level so that it is avaiable
on AOP proxies, etc.MessageHandlers with
cross-cutting concerns.Message implementations.ResourcesMessage to an Object.AbstractOutboundChannelAdapterParser.doParseAndRegisterConsumer(Element, ParserContext)
LockRegistry implementation which has no effect.MessageChannel based on the
Message's payload type.MessageSelector implementation that checks the type of the
Message payload.MessageHandler implementation
to a PollableChannel.MessageGroup (in FIFO style if supported by the implementation)
while also removing the polled Message
MessageSelector,
send it to the secondary target.
Comparator.MetadataStore.PlatformTransactionManager that provides transaction-like semantics to
MessageSources that are not inherently transactional.MessagePublishingInterceptor to any
methods containing the provided annotations.Publisher annotation.Executor
to invoke the handlers.
Messages that are not accepted by the provided selector.
UnsupportedOperationException
UnsupportedOperationException
MessageGroupStore.expireMessageGroups(long).
ReleaseStrategy.ExpressionSource implementation that accesses resource bundles using specified basenames.UnsupportedOperationException
QueueChannel that delegates to a
SynchronousQueue internally.MessageHeaders to and from other
types of objects.AbstractCorrelatingMessageHandler.MessageChannel,
via this template's ChannelResolver if available.
MessageSource based on ResourcePatternResolver which will
attempt to resolve Resources based on the pattern specified.RetryState instance
based on a message.LoadBalancingStrategy.@Router.timeout provided.
Message to this channel.
ReleaseStrategy that simply compares the current size of the message list to the
expected 'sequenceSize'.@ServiceActivator.ServiceActivatingHandler instances.@beanName in the expression.
ChannelResolver that is to be used to resolve
MessageChannel references for this template.
ChannelResolver strategy to use.
ConversionService to use when trying to convert to
one of this channel's supported datatypes for a Message whose payload
does not already match.
List to advise DelayHandler.ReleaseMessageHandler proxy.
ErrorHandler strategy for handling Exceptions that
occur downstream from this channel.
MessageGroups
MessageHandler throws an Exception.
LoadBalancingStrategy for this dispatcher.
MessageConverter that is to be used to convert
between Messages and objects for this template.
MessageGroupStore that should be used to store Messages
while awaiting the delay.
MessageChannel where Messages should be sent.
OutboundMessageMapper for mapping to objects from
any reply Messages received in receive or sendAndReceive operations.
InboundMessageMapper for creating request Messages
from any object passed in a send or sendAndReceive operation.
null values, such as might be returned from
an expression evaluation, should be skipped.
MessageRejectedException when its selector does not accept a
Message.
MessageStore and group id.MessageStore and MessageGroupStore.SimpleMessageStore.SimpleMessageStore(int, int).
MetadataStore that uses an in-memory map only.Pool supporting dynamic resizing and a variable
timeout when attempting to obtain an item from the pool.PublisherMetadataSource that allows for
configuration of a single channel name, payload expression, and
array of header key=value expressions.MessageSource to a MessageChannel.Message.@Splitter.MessageHandler as a subscriber to this channel.
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, exceeds a timeout set by the user.
TransactionSynchronizationMessage.@Transformer.MessageSelector that accepts Messages that are
not yet expired.MessageDispatcher that will attempt to send a
Message to at most one of its handlers.MessageHandler from the subscribers of this channel.
AbstractRequestHandlerAdvice.ThrowableHolderException.
AbstractRequestHandlerAdvice.ThrowableHolderException.
Lock provided by
LockRegistry
A typical usage would be to provide implementation of WhileLockedProcessor.whileLocked() method and
then call WhileLockedProcessor.doWhileLocked()ChannelInterceptor that publishes a copy of the intercepted message
to a secondary target while still sending the original message to the main channel.MessageSelector.
MessageSelector.
Message instance with the provided payload.
|
|||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||