|
Spring Integration | ||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
MessageStore.AbstractCorrelatingMessageHandlerMessageDispatcher implementations.FileInfo; provides a setter
for the remote directory and a generic toString implementation.FileListFilter whose criteria can be
evaluated against each File in isolation.SessionFactory used to acquire Session instances.
MessageGroupStore and MessageStoreMailReceiver implementations.MessageChannel implementations providing common
properties such as the channel name.MessageProcessor.Transformer implementations that modify the payload
of a Message.Pattern)MessageHandler advice classes.RequestResponseScenariosMessageProcessor for scripting implementations to extend.MessageChannel that invokes the subscribed
handler(s) by delegating to a MessageDispatcher.TcpConnection.Transformer implementations.MessageSelector implementations.XPathExpression evaluates to true
XPathExpression matches the regex.
XPathExpression is equal to the valueToTestFor.
FileListFilter that always returns true.CollectionFilter that remembers the elements passed in
the previous invocation in order to avoid returning those elements more than once.FileListFilter that passes files only one time.ResourceHolder instance
TcpListener, this
method is called each time a new connection is made.
DataSource and
JdbcChannelMessageStore.setChannelMessageStoreQueryProvider(ChannelMessageStoreQueryProvider)).
SimpleJdbcCallOperations
and ensures the appropriate SqlParameterSourceFactory is defined
when ProcedureParameter are passed in.
MessagingTemplate to send downstream.
AbstractCorrelatingMessageHandler.@Aggregator annotation.HeaderMapper
but parameterized with MessageProperties.ApplicationEvents within messages.MessageHandler that publishes each Message it receives as
a MessagingEvent.MessageSource implementation that retrieves the current
value of a JMX attribute each time AbstractMessageSource.receive() is invoked.ChannelResolver implementation based on a Spring BeanFactory.BeanFactoryChannelResolver class.
BeanFactoryChannelResolver class.
SqlParameterSourceFactory which creates an SqlParameterSource to
reference bean properties in its input.MessageSelector.MessageSelector supporting
multiple namespaces.
MessageSelector supporting a single namespace.
MessageSelector with no namespace support.
MessageSelector using the
provided XPathExpression.
ByteArrayLengthHeaderSerializer.HEADER_SIZE_INT
InputStream.MessageHandler that writes a byte array to an OutputStream.MessageHandler implementation that writes to a GemFire Region.SessionFactory implementation that caches Sessions for reuse without
requiring reconnection each time the Session is retrieved from the factory.ConfigAttributes for secured channel
send and receive operations.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.ChannelSecurityInterceptor.JdbcChannelMessageStore to provide database-specific queries.Messages from one or more
QueueChannels.MessageChannel.BeanPostProcessor that proxies MessageChannels to apply a ChannelSecurityInterceptor.SecurityMetadataSource implementation for secured MessageChannels.Readers.MessageHandler that writes characters to a Writer.Messages from this channel.
UnsupportedOperationException
FileListFilter that predicates its matches against any of many
configured FileListFilter.TransactionInterceptor
with "transactionManager" and other "transactionDefinition" properties.
DefaultTransactionAttribute
with provided "transactionDefinition" properties.
Region.UUIDConverter.getUUID(Object).
ProcedureParameter to
a Map containing only expression parameters.
ProcedureParameter to
a Map containing only static parameters.
CorrelationStrategy.SqlParameterSource.
ParameterSource.
ServerSocket.
Socket.
Source instance for payload
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)
AmqpHeaderMapper.ConfigAttributes for secured channel
send and receive operations based on simple String values.HeaderMapper implementation for HTTP.JmsHeaderMapper.LockRegistry which uses Masked Hashcode algorithm to obtain locks.MultipartFileReader implementation that reads the MultipartFile
content directly into a new MultipartFile instance that is not restricted
to the HTTP request scope.SftpSession instances.HeaderMapper implementation for mapping to and from a SoapHeader.ServerSocket and
Socket.SSLServerSocket and
SSLSocket.TcpNioConnectionSupport for non-SSL
NIO connections.TcpNioConnectionSupport for SSL
NIO connections.TcpSocketSupport; makes no
changes to sockets.TcpSSLContextSupport; uses a
'TLS' (by default) SSLContext, initialized with 'JKS'
keystores, managed by 'SunX509' Key and Trust managers.TransactionSynchronizationFactory which takes an instance of
TransactionSynchronizationProcessor allowing you to create a TransactionSynchronization
using {DefaultTransactionSynchronizationFactory.create(Object) method.XmlPayloadConverter.XmppHeaderMapper.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.
SourceFactory implementation which supports creation of a DOMSource
from a Document, File or String payload.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.
JdbcChannelMessageStore
means the channel identifier.
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.Message is
available to extract ProcedureParameter values from it.
Message is
available to extract ProcedureParameter values from it.
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.SqlParameterSourceFactory which creates an SqlParameterSource that evaluates
Spring EL expressions.TransactionSynchronizationFactory
allows you to configure SpEL expressions, with their execution being coordinated (synchronized) with a
transaction - see TransactionSynchronization.TcpConnections
that can iterate over a connection from each factory until the write
succeeds or the list is exhausted.MessageSource will produce individual
SyndEntrys for a feed identified with the 'feedUrl' attribute.MultipartFileReader implementation that copies the MulitpartFile's
content to a new temporary File in the specified directory.FileCopyingMultipartFileReader that creates temporary
Files in the default temporary directory.
FileCopyingMultipartFileReader that creates temporary
Files in the given directory.
MessageSource that creates messages from a file system directory.PriorityBlockingQueue
ordered with the passed in Comparator
The size of the queue used should be large enough to hold all the files
in the input directory in order to sort all of them, so restricting the
size of the queue is mutually exclusive with ordering.
MessageHandler implementation that transfers files to a remote server.MessageHandler implementation that writes the Message payload to a
file.FileWritingMessageHandler.destinationDirectoryExpression using
a LiteralExpression.
FileWritingMessageHandler.destinationDirectoryExpression.
FileWritingMessageHandlers.@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.
FileInfo implementation for FTP/FTPS.AbstractInboundFileSynchronizer for FTP.SessionFactory used to acquire Session instances.
MessageSource implementation for FTP.AbstractRegexPatternFileListFilter for FTP.Session for FTP.AbstractSimplePatternFileListFilter for FTP.MessageStore and
MessageGroupStoreSearchTerm
IntegrationObjectSupport.componentName field.
AbstractConnectionFactory.setSingleUse(boolean) was called with
true, a new connection is returned; otherwise a single connection is
reused for all requests while the connection remains open.
TcpSendingMessageHandler.obtainConnection(Message).
TODO: remove in 3.0
ConversionService bean whose name is "integrationConversionService" if available.
PollerMetadata bean if available.
MessageChannel bean whose name is "errorChannel".
FileExistsMode.
next() invocations.
Set of this dispatcher's handlers.
CacheStats}) for the
StoredProcExecutor.jdbcCallOperationsCache, which is used to store
instances of SimpleJdbcCallOperations.
CacheStats}) for the
StoredProcExecutor.jdbcCallOperationsCache.
BeanDefinitionBuilder for the class JpaExecutor.
ManagedList of BeanDefinitions containing parsed
JPA Parameters.
MessageGroupStore.addMessageToGroup(Object, Message) with this group id.
MessagingTemplate for subclasses.
MessagingTemplate access for subclasses.
MetadataStore bean whose name is "metadataStore".
BeanDefinitionBuilder for the class JpaExecutor
that is specific for JPA Outbound Gateways.
AbstractConnectionFactory.setTaskExecutor(Executor).
TaskScheduler bean whose name is "taskScheduler".
ServerSocketFactory to be used to
create new ServerSockets.
SocketFactory to be used to
create new Sockets.
BeanDefinitionBuilder for the class StoredProcExecutor.
TaskScheduler bean whose name is "taskScheduler" if available.
GroovyCommandMessageProcessor that will use the DefaultScriptVariableGenerator.
GroovyCommandMessageProcessor that will use the provided ScriptVariableGenerator.
GroovyCommandMessageProcessor that will use the DefaultScriptVariableGenerator
and provided Binding.
GroovyCommandMessageProcessor that will use the provided ScriptVariableGenerator and Binding.
MessageHandler instances to handle a message as a Groovy Script.ScriptSource that will use a
DefaultScriptVariableGenerator.
ScriptSource that will use the provided
ScriptVariableGenerator.
SqlParameterSourceFactory.
DelayHandler.releaseMessageAfterDelay(org.springframework.integration.Message, long) and DelayHandler.DelayedMessageWrapper).
maxNumberOfFiles
elements from a directory listing.CorrelationStrategy.MessageHeaders to and from other
types of objects.MessageHeaders of a Message containing any entry
or multiple that match?MessageHandler implementation that executes HTTP requests by delegating
to a RestTemplate instance.Controller interface to be used with a DispatcherServlet front
controller.MailReceiver implementation for receiving mail messages from a
mail server that supports the IMAP protocol.Message.TaskScheduler and ConversionService instances.ResourceHolder which holds an instance of the current Message
and the synchronization resourceMessageHandlerChain.handlers)
MessageGroups
MessageGroupStore using a relational
database via JDBC.MessageStore with all mandatory properties.
DataSource from which the DB Connection can be obtained and the select query to
execute to retrieve new rows.
JdbcOperations instance to use for query execution and the select query to execute to
retrieve new rows.
MessageStore using a relational database via JDBC.MessageStore with all mandatory properties.
JdbcMessageStore.DataSource from which the DB Connection can be
obtained and the select query to execute to retrieve new rows.
JdbcOperations instance to use for query
execution and the select query to execute to retrieve new rows.
JdbcPollingChannelAdapter.Types.Message payload.EntityManagerFactory from which the
EntityManager can be obtained.
EntityManager directly.
JpaOperations
can be passed in.
JpaOperations failsOutboundGatewayType, the outbound gateway
will use either the JpaExecutor's poll method or its
executeOutboundJpaOperation method.JpaExecutor that wraps all JPA Operations.
JpaOutboundGatewayFactoryBean creates instances of the
JpaOutboundGateway.JpaExecutor that wraps all JPA Operations.
BeanDefinitions.JpaExecutor that provide all required JPA
functionality.
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.MessageHandlerMetrics that exposes in addition the Lifecycle interface.MessageSourceMetrics that exposes in addition the Lifecycle interface.true if it was
successful, false otherwise.
true if it was
successful, false otherwise.
Messages.MessageSource implementation that delegates to a
MailReceiver to poll a mailbox.MessageHandler implementation for sending mail.Message to a String.AbstractEndpoint that exposes a management interface.Map.AbstractTransformer that delegates to an OXM Marshaller.MarshallingWebServiceInboundGateway.
MarshallingWebServiceInboundGateway with the given marshaller.
MarshallingWebServiceInboundGateway with the given marshaller and unmarshaller.
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.JdbcChannelMessageStore.setRegion(String)).
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.Message from a result set
row.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.ApplicationEvent that wraps a Message.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.Message matcher creation.MessageSource which returns a Message with a payload
which is the result of execution of a Query.MongoDbFactory and SpEL expression
which should resolve to a MongoDb 'query' string
(see http://www.mongodb.org/display/DOCS/Querying).
MongoOperations and SpEL expression
which should resolve to a Mongo 'query' string
(see http://www.mongodb.org/display/DOCS/Querying).
MessageStore and MessageGroupStore
strategies that relies upon MongoDB for persistence.MongoDbFactory.and the default collection name.
MongoDbFactory and collection name.
MessageHandler which writes Message payload into a MongoDb collection
identified by evaluation of the MongoDbStoringMessageHandler.collectionNameExpression.MongoDbFactory
MongoOperations
MessageHandler implementation that maps a Message into
a UDP datagram packet and sends that to the specified multicast address
(224.0.0.0 to 239.255.255.255) and port.HttpMessageConverter implementation that delegates to an instance of
XmlAwareFormHttpMessageConverter while adding the capability to read
multipart/form-data content in an HTTP request.MultipartFile content.NotificationListener implementation that will send Messages
containing the JMX Notification instances as their payloads.toString() method.ContextRefreshedEvent to invoke DelayHandler.reschedulePersistedMessages()
as late as possible after application context startup.
MultipartResolver bean based on the default name defined by the
DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME constant if available.
SimpleJdbcCallOperations
and ensures the appropriate SqlParameterSourceFactory is defined
when ProcedureParameter are passed in.
SimpleJdbcCallOperations
and ensures the appropriate SqlParameterSourceFactory is defined
when ProcedureParameter are passed in.
MessageHandler implementation for invoking JMX operations based on
the Message sent to its AbstractMessageHandler.handleMessage(Message) method.JdbcChannelMessageStore.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.ResourcesBaseMatcher implementations.TestUtils provides convenience
helpers to easily retrieve private bean properties.ResultFactory that
will return Result, possibly taking into account
payload instance.MessageSelector
implementations.SourceFactory
implementations.AbstractMessageSplitter.AbstractXmppConnectionAwareEndpoint.AbstractXmppConnectionAwareMessageHandlerMessage to an Object.AbstractOutboundChannelAdapterParser.doParseAndRegisterConsumer(Element, ParserContext)
LockRegistry implementation which has no effect.Message equal to a given value or is matching
a given matcher?MessageChannel based on the
Message's payload type.MessageSelector implementation that checks the type of the
Message payload.PollableChannel implementation that is backed by an AMQP Queue.MessageHandler implementation
to a PollableChannel.MessageGroup (in FIFO style if supported by the implementation)
while also removing the polled Message
MailReceiver implementation that polls a mail server using the
POP3 protocol.ServerSocket.accept().
Socket after
the socket has been created by a client, or accepted by
a server, and after any configured atributes have been
set.
Messages when a
particular Presence event occurs within the logged-in user's Roster.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
MultipartFile content.
Message converting and returning it as
a Spring Integration Message.
JpaExecutor.poll() to executes the JPA operation.
Query returning its results as the Message payload.
RedisStore identified
by RedisStoreMessageSource.keyExpression
MessageStore and MessageGroupStoreRedisTemplate and SpEL expression
which should resolve to a 'key' name of the collection to be used.
RedisConnectionFactory and SpEL expression
which should resolve to a 'key' name of the collection to be used.
MessageHandler which writes Message data into a Redis store
identified by a key String.RedisTemplate.
RedisConnectionFactory.
MessageSelector that tests if a provided String value
matches a given Regular Expression.XPathExpression.
MessageGroupStore.expireMessageGroups(long).
ReleaseStrategy.ExpressionSource implementation that accesses resource bundles using specified basenames.UnsupportedOperationException
TcpListener, this
method is called each time a connection is closed.
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.Result possibly taking into account the
provided message payload instance.Document from a Result payload.Result to an instance of String.Result
objects to other formats.RetryState instance
based on a message.LoadBalancingStrategy.@Router.IntegrationMBeanExporter.stopActiveComponents(boolean, long).
timeout provided.
ScriptSource using the provided ScriptExecutor using the DefaultScriptVariableGenerator
ScriptSource using the provided ScriptExecutor
ScriptSource using the provided ScriptExecutor using the DefaultScriptVariableGenerator
SearchTerm
See ImapMailReceiverChannelSecurityInterceptor
to control send and receive access, and creates a bean post-processor to apply the
interceptor to MessageChannels
whose names match the specified patterns.Message to this channel.
ReleaseStrategy that simply compares the current size of the message list to the
expected 'sequenceSize'.HttpMessageConverter implementation for Serializable instances.SerializingHttpMessageConverter.
@ServiceActivator.ServiceActivatingHandler instances.Session instances.SourceFactory.
BeanFactory which is used to add a
BeanResolver to the StandardEvaluationContext.
@beanName in the expression.
XPathExpression
to test value should be case sensitive.
ChannelMessageStoreQueryProvider to use.
ChannelResolver that is to be used to resolve
MessageChannel references for this template.
ChannelResolver strategy to use.
Expression that should resolve to a collection name
used by the Query.
Expression that should resolve to a collection name
used by MongoOperations to store data
RedisCollectionFactoryBean.CollectionType.
AbstractClientConnectionFactory or AbstractServerConnectionFactory.
ConversionService to use when trying to convert to
one of this channel's supported datatypes for a Message whose payload
does not already match.
XmlPayloadConverter to use when converting a Message payload prior to XPath evaluation.
GroovyObjectCustomizer for this processor.
GroovyObjectCustomizer for this processor.
DataSource to use when interacting with the database.
DataSource to use when interacting with the database.
List to advise DelayHandler.ReleaseMessageHandler proxy.
false, which means that
deletion occurs on a per object basis if a collection of entities is being
deleted.
DestinationResolver to use when resolving either a
'requestDestinationName' or 'replyDestinationName' value.
MongoTemplate.find(Query, Class) or MongoTemplate.findOne(Query, Class)
method.
ErrorHandler strategy for handling Exceptions that
occur downstream from this channel.
ResponseErrorHandler for the underlying RestTemplate.
Errors in the core, in the case that message handling fails.
XPathEvaluationType.
ResponseEntity and will
be returned as a payload of the reply Message.
Expression to determine the type for the expected response
The returned value of the expression could be an instance of Class or
String representing a fully qualified class name
Also see HttpRequestExecutingMessageHandler.setExpectedResponseTypeExpression(Expression)
MongoTemplate.
MessageGroups
MessageHandler throws an Exception.
FileExistsMode that specifies what will happen in
case the destination exists.
FileNameGenerator strategy to use when generating
the destination file's name.
FTP constants:
FTP.ASCII_FILE_TYPE
FTP.EBCDIC_FILE_TYPE
FTP.BINARY_FILE_TYPE (DEFAULT)
FTP.LOCAL_FILE_TYPE
FileListFilter.
NotificationFilter to be passed to the server
when registering this listener.
StoredProcExecutor.setIsFunction(boolean) instead.
StoredProcExecutor
HeaderMapper to use when mapping between HTTP headers and MessageHeaders.
HeaderMapper to use when mapping between HTTP headers and MessageHeaders.
JmsHeaderMapper implementation to use when
converting between JMS Messages and Spring Integration Messages.
JmsHeaderMapper implementation for mapping the
Spring Integration Message Headers to/from JMS Message properties.
HttpMethod for requests.
Expression to determine HttpMethod dynamically
SimpleJdbcCall can
retrieve the parameter information for the to be invoked Stored Procedure
from the JDBC Meta-data.
StoredProcExecutor
StoredProcExecutor
StoredProcExecutor
StoredProcExecutor
Session will be created with these properties (and the JavaMailAuthenticator if provided).
SimpleJdbcCallOperations
(SimpleJdbcCall) instances to be held by
StoredProcExecutor.jdbcCallOperationsCache.
JdbcOperations to use when interacting with the database.
JdbcOperations to use when interacting with the database.
LoadBalancingStrategy for this dispatcher.
LobHandler that is used to create and unpack large objects in SQL queries.
LobHandler that is used to create and unpack large objects in SQL queries.
AbstractMailReceiver.receive().
MessageConverter that is to be used to convert
between Messages and objects for this template.
MessageConverter implementation to use when
converting between JMS Messages and Spring Integration Messages.
MessageConverter strategy to use for converting the
Spring Integration request Message into a JMS Message and for converting
the JMS reply Messages back into Spring Integration Messages.
HttpMessageConverters to be used by the underlying RestTemplate.
MessageRowMapper.
MessageGroupStore that should be used to store Messages
while awaiting the delay.
MongoConverter used to assist in deserialization
data read from MongoDb.
MongoConverter used to assist in serialization
of data written to MongoDb.
MultipartFileReader to use when reading MultipartFile content.
MultipartResolver to use when checking requests.
NodeMapper to use for generating the result object.
ObjectName.
MessageChannel where Messages should be sent.
ParameterSource that would be used to provide
additional parameters.
AbstractConnectionFactory.setTaskExecutor(Executor).
Use AbstractServerConnectionFactory.setBacklog(int) to set the connection backlog.
AbstractServerConnectionFactory.setBacklog(int) to set the connection backlog.
Resource, which represents the location of the
private key used for authenticating against the remote host.
Expression.
StoredProcExecutor
StoredProcExecutor
StoredProcExecutor
SSLContext.getInstance(String); default "TLS".
Proxy.
HttpRequestHandlingEndpointSupport.setExtractReplyPayload(boolean) is false).
OutboundMessageMapper for mapping to objects from
any reply Messages received in receive or sendAndReceive operations.
ClientHttpRequestFactory for the underlying RestTemplate.
InboundMessageMapper for creating request Messages
from any object passed in a send or sendAndReceive operation.
HttpMessageConverters.
RowMapper to convert the ResultSet to meaningful objects.
StoredProcExecutor
StoredProcExecutor
StoredProcExecutor
StoredProcExecutor
RecursiveLeafOnlyDirectoryScanner
AbstractEndpoint.setTaskScheduler(TaskScheduler)
AbstractEndpoint.setTaskScheduler(TaskScheduler)
TcpSendingMessageHandler.setTaskScheduler(TaskScheduler)
SearchTermStrategy to compile a SearchTerm
to be applied when retrieving mail
Executor used to send messages received by the
adapter.
Session.
Properties, you can set additional configuration settings on
the underlying JSch Session.
FolderClosedException while waiting for messages.
null values, such as might be returned from
an expression evaluation, should be skipped.
true then all results from a stored
procedure call that don't have a corresponding SqlOutParameter
declaration will be bypassed.
StoredProcExecutor
StoredProcExecutor
SocketFactory.
SqlParameter explicitly.
StoredProcExecutor
StoredProcExecutor
StoredProcExecutor
SqlParameterSourceFactory.
StoredProcExecutor
StoredProcExecutor
StoredProcExecutor
StoredProcExecutor
StoredProcExecutor
StoredProcExecutor
StoredProcExecutor.storedProcedureNameExpression the
Message can be used as source for the name of the
Stored Procedure or Stored Function.
MessageRejectedException when its selector does not accept a
Message.
MulticastSocket time to live property.
ServletServerHttpResponse.
HttpRequestHandlingEndpointSupport.setupResponseAndConvertReply(ServletServerHttpResponse, Message) instead.
StoredProcExecutor
StoredProcExecutor
FileInfo implementation for SFTP.MessageSource implementation for SFTP
that delegates to an InboundFileSynchronizer.AbstractRegexPatternFileListFilter for SFTP.AbstractSimplePatternFileListFilter for SFTP.MessageStore and group id.MessageStore and MessageGroupStore.SimpleMessageStore.SimpleMessageStore(int, int).
MetadataStore that uses an in-memory map only.MultipartFileReader implementation that does not maintain metadata from
the original MultipartFile instance.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.RequestResponseScenario testHeaderMapper
but parameterized with SoapHeader.Source using a SourceFactory.Source possibly taking into account
the provided message payload instance.MessageSource to a MessageChannel.Message.@Splitter.SqlParameterSource for use in update operations.DataSource from which the DB Connection can be
obtained.
StoredProcExecutor instead
StoredProcExecutor.
StoredProcExecutor instead
StoredProcExecutor.
StoredProcExecutor instead
StoredProcExecutor.
SourceFactory implementation which supports creation of a StringSource
from a Document, File or String payloadMessageSelector that tests if a provided value supports
payloads of type Document or String.XPathExpression.
MessageHandler as a subscriber to this channel.
Socket and SocketChannel that
sends Message objects by serializing the payload
and streaming it to the destination.TcpConnectionTcpConnection to a Message.TcpNetConnections.Socket.TcpNetConnections using
a ServerSocket.TcpNioConnections.SocketChannel.TcpNioConnection object.TcpNioConnections using
a ServerSocketChannel.TcpConnection supporting SSL/TLS over NIO.SSLContext object
for use with SSL/TLS sockets.MessageSource lets Spring Integration consume
given account's timeline as messages.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.
URLName, where the
password has been protected.
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 implementation that maps a Message into
a UDP datagram packet and sends that to the specified host and port.Transformer that delegates to an OXM
Unmarshaller.MessageHandler from the subscribers of this channel.
AbstractRequestHandlerAdvice.ThrowableHolderException.
AbstractRequestHandlerAdvice.ThrowableHolderException.
MultipartFile implementation that represents an uploaded File.HandlerMapping implementation that matches
against the value of the 'path' attribute, if present, on a Spring Integration HTTP
<inbound-channel-adapter> or <inbound-gateway> element.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.
Document, Node or Source
instances from other types (e.g.XmlValidator.
XMPPConnection object.HeaderMapper
but parameterized with the Smack API Message.Message objects
that handle XMPP events.XPathExpression to split a
Document, File or String payload into a NodeList.XPathExpression evaluation to determine channel names.XPathTransformer that will create an XPath expression from the given String
to be evaluated against converted inbound Message payloads.
XPathTransformer that will evaluate the given XPathExpression
against converted inbound Message payloads.
Source, Document, or String.
|
Spring Integration | ||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||