Uses of Interface
org.springframework.integration.support.management.ManageableLifecycle
Package
Description
Provides classes related to message aggregation.
Provides classes related to AMQP-backed channels.
Provides classes supporting inbound endpoints.
Provides classes supporting outbound endpoints.
Provides classes representing various channel types.
Provides classes related to channel interception.
Provides core classes.
Root package of the Spring Integration Java DSL.
Provides core classes related to Endpoints.
Provides classes supporting inbound endpoints.
Base package for File support.
Base package for supporting remote files.
Provides classes supporting the synchronization of remote and
local file directories.
Classes used for tailing file system files.
Provides classes supporting the filter pattern.
Provides classes supporting inbound endpoints.
Provides classes supporting messaging gateways.
Provides classes implementing various types of message handler.
Provides classes for message handlers support.
Provides classes supporting inbound endpoints.
Provides classes supporting the capture of message history.
Provides classes supporting inbound endpoints.
Base package for IP (TCP/UDP) Support.
Base package for TCP Support.
All things related to tcp connections - client and
server factories; listener and sender interfaces.
Base package for UDP support.
Base package for JMS Support.
Base package for JMX support.
Provides classes related to message channel implementations for Apache Kafka.
Provides Spring Integration inbound components for Apache Kafka.
Provides Spring Integration outbound components for Apache Kafka.
Base package for Mail support.
Provides classes related to the Mongo inbound channel adapters
Provides inbound Spring Integration MqttAdapter components.
Provides Spring Integration components for doing outbound operations.
Provides classes related to Redis-backed channels.
Provides classes supporting inbound endpoints.
Provides classes supporting the router pattern.
Provides classes representing inbound RSocket components.
Provides classes supporting the Scatter-Gather pattern.
Provides classes supporting inbound endpoints.
Inbound Channel Adapters implementations for SMB protocol.
Provides classes supporting the splitter pattern.
Provides classes which represent inbound STOMP components.
Provides classes which represent outbound STOMP components.
Provides classes related to management support.
Provides classes for inbound endpoints.
Contains core-implementation of various Transformers which includes Enrichers
and Filters.
Provides classes supporting inbound endpoints.
Provides classes which represent inbound WebSocket components.
Provides several inbound and outbound Web Service components.
Provides classes shared across all XMPP components.
Provides XMPP inbound Endpoint implementations that extend
AbstractXmppConnectionAwareEndpoint
.Provides classes for inbound channel adapters over ZeroMQ.
Provides classes for outbound channel adapters over ZeroMQ.
-
Uses of ManageableLifecycle in org.springframework.integration.aggregator
Modifier and TypeClassDescriptionclass
Abstract Message handler that holds a buffer of correlated messages in aMessageStore
.class
Aggregator specific implementation ofAbstractCorrelatingMessageHandler
.class
TheMessageGroupProcessor
implementation with delegation to the provideddelegate
and optional aggregation for headers.class
TheAbstractMessageProducingHandler
implementation for aggregation logic based on Reactor'sFlux.groupBy(java.util.function.Function<? super T, ? extends K>)
andFlux.window(int)
operators.class
CorrelationStrategy
implementation that works as an adapter to another bean.class
MessageGroupProcessor that serves as an adapter for the invocation of a POJO method.class
A MessageListProcessor implementation that invokes a method on a target POJO.class
AReleaseStrategy
that invokes a method on a plain old Java object.class
Resequencer specific implementation ofAbstractCorrelatingMessageHandler
. -
Uses of ManageableLifecycle in org.springframework.integration.amqp.channel
Modifier and TypeClassDescriptionclass
TheAbstractSubscribableAmqpChannel
implementation for one-to-one subscription over AMQP queue.class
TheAbstractSubscribableAmqpChannel
extension for pub-sub semantics based on theFanoutExchange
. -
Uses of ManageableLifecycle in org.springframework.integration.amqp.inbound
Modifier and TypeClassDescriptionclass
Adapter that receives Messages from an AMQP Queue, converts them into Spring Integration Messages, and sends the results to a Message Channel.class
Adapter that receives Messages from an AMQP Queue, converts them into Spring Integration Messages, and sends the results to a Message Channel. -
Uses of ManageableLifecycle in org.springframework.integration.amqp.outbound
Modifier and TypeClassDescriptionclass
A baseAbstractReplyProducingMessageHandler
extension for AMQP message handlers.class
Adapter that converts and sends Messages to an AMQP Exchange.class
An outbound gateway where the sending thread is released immediately and the reply is sent on the async template's listener container thread. -
Uses of ManageableLifecycle in org.springframework.integration.channel
Modifier and TypeClassDescriptionclass
Converts a channel to a name, retaining a reference to the channel keyed by the name. -
Uses of ManageableLifecycle in org.springframework.integration.channel.interceptor
Modifier and TypeClassDescriptionclass
AChannelInterceptor
that publishes a copy of the intercepted message to a secondary target while still sending the original message to the main channel. -
Uses of ManageableLifecycle in org.springframework.integration.core
Modifier and TypeInterfaceDescriptioninterface
Endpoints implementing this interface can be paused/resumed. -
Uses of ManageableLifecycle in org.springframework.integration.dsl
Modifier and TypeClassDescriptionclass
The baseAdapter
class for theIntegrationFlow
abstraction. -
Uses of ManageableLifecycle in org.springframework.integration.endpoint
Modifier and TypeClassDescriptionclass
The base class for Message Endpoint implementations.class
AnAbstractEndpoint
extension for Polling Consumer pattern basics.class
Message Endpoint that connects anyMessageHandler
implementation to aSubscribableChannel
.class
AMessageProducerSupport
sub-class that provides ExpressionMessageProducerSupport.payloadExpression evaluation with result as a payload for Message to send.class
A support class for producer endpoints that provides a setter for the output channel and a convenience method for sending Messages.class
AMessageSource
implementation that invokes a no-argument method so that its return value may be sent to a channel.class
Message Endpoint that connects anyMessageHandler
implementation to aPollableChannel
.class
TheMessageProducerSupport
to adapt a providedMessageSource
into aFlux
and let it be subscribed in theMessageProducerSupport.subscribeToPublisher(org.reactivestreams.Publisher<? extends org.springframework.messaging.Message<?>>)
.class
AnAbstractEndpoint
implementation for Reactive Streams subscription into an input channel and reactive consumption of messages from that channel.class
A Channel Adapter implementation for connecting aMessageSource
to aMessageChannel
. -
Uses of ManageableLifecycle in org.springframework.integration.event.inbound
Modifier and TypeClassDescriptionclass
An inbound Channel Adapter that implementsGenericApplicationListener
and passes SpringApplicationEvents
within messages. -
Uses of ManageableLifecycle in org.springframework.integration.file
Modifier and TypeClassDescriptionclass
MessageSource
that creates messages from a file system directory.class
AMessageHandler
implementation that writes the Message payload to a file. -
Uses of ManageableLifecycle in org.springframework.integration.file.remote
Modifier and TypeClassDescriptionclass
A message source that produces a message with anInputStream
payload referencing a remote file. -
Uses of ManageableLifecycle in org.springframework.integration.file.remote.synchronizer
Modifier and TypeClassDescriptionclass
Factors out the common logic between the FTP and SFTP adapters. -
Uses of ManageableLifecycle in org.springframework.integration.file.tail
Modifier and TypeClassDescriptionclass
File tailer that delegates to the Apache Commons Tailer.class
Base class for file tailing inbound adapters.class
A file tailing message producer that delegates to the OS tail program. -
Uses of ManageableLifecycle in org.springframework.integration.filter
Modifier and TypeClassDescriptionclass
A base class forMessageSelector
implementations that delegate to aMessageProcessor
.class
AMessageSelector
implementation that evaluates a SpEL expression.class
Message Handler that delegates to aMessageSelector
.class
A method-invoking implementation ofMessageSelector
. -
Uses of ManageableLifecycle in org.springframework.integration.ftp.inbound
Modifier and TypeClassDescriptionclass
AMessageSource
implementation for FTP.class
Message source for streaming FTP remote file contents. -
Uses of ManageableLifecycle in org.springframework.integration.gateway
Modifier and TypeClassDescriptionclass
AGatewayProxyFactoryBean
extension for Java configuration.class
TheAbstractReplyProducingMessageHandler
implementation for mid-flow Gateway.class
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.class
A convenient base class for connecting application code toMessageChannel
s for sending, receiving, or request-reply operations. -
Uses of ManageableLifecycle in org.springframework.integration.handler
Modifier and TypeClassDescriptionclass
A compositeMessageHandler
implementation that invokes a chain of MessageHandler instances in order.class
AMessageHandler
that invokes the specified method on the provided object.class
A MessageProcessor implementation that invokes a method on a target Object.class
TheAbstractReplyProducingMessageHandler
wrapper around rawMessageHandler
for request-reply scenarios, e.g.class
-
Uses of ManageableLifecycle in org.springframework.integration.handler.support
Modifier and TypeClassDescriptionclass
A helper class for processors that invoke a method on a target Object using a combination of message payload(s) and headers as arguments. -
Uses of ManageableLifecycle in org.springframework.integration.hazelcast.inbound
Modifier and TypeClassDescriptionclass
Hazelcast Base Event-Driven Message Producer.class
Hazelcast Cluster Monitor Event Driven Message Producer is a message producer which enablesHazelcastClusterMonitorMessageProducer.HazelcastClusterMonitorListener
listener in order to listen cluster related events and sends events to related channel.class
Hazelcast Continuous Query Message Producer is a message producer which enablesAbstractHazelcastMessageProducer.HazelcastEntryListener
with aSqlPredicate
in order to listen related distributed map events in the light of defined predicate and sends events to related channel.class
Hazelcast Event Driven Message Producer is a message producer which enablesAbstractHazelcastMessageProducer.HazelcastEntryListener
,HazelcastEventDrivenMessageProducer.HazelcastItemListener
andHazelcastEventDrivenMessageProducer.HazelcastMessageListener
listeners in order to listen related cache events and sends events to related channel. -
Uses of ManageableLifecycle in org.springframework.integration.history
-
Uses of ManageableLifecycle in org.springframework.integration.http.inbound
Modifier and TypeClassDescriptionclass
TheMessagingGatewaySupport
extension for HTTP Inbound endpoints with basic properties.class
Inbound HTTP endpoint that implements Spring'sController
interface to be used with a DispatcherServlet front controller.class
Base class for HTTP request handling endpoints.class
Inbound Messaging Gateway that handles HTTP Requests. -
Uses of ManageableLifecycle in org.springframework.integration.ip
Modifier and TypeClassDescriptionclass
Base class for inbound TCP/UDP Channel Adapters.class
Base class for UDP MessageHandlers. -
Uses of ManageableLifecycle in org.springframework.integration.ip.tcp
Modifier and TypeClassDescriptionclass
Inbound Gateway using a server connection factory - threading is controlled by the factory.class
TCP outbound gateway that uses a client connection factory.class
Tcp inbound channel adapter using a TcpConnection to receive data - if the connection factory is a server factory, this Listener owns the connections.class
Tcp outbound channel adapter using a TcpConnection to send data - if the connection factory is a server factory, the TcpListener owns the connections. -
Uses of ManageableLifecycle in org.springframework.integration.ip.tcp.connection
Modifier and TypeInterfaceDescriptioninterface
A factory used to create TcpConnection objects.Modifier and TypeClassDescriptionclass
Abstract class for client connection factories; client connection factories establish outgoing connections.class
Base class for all connection factories.class
Base class for all server connection factories.class
Connection factory that caches connections from the underlying target factory.class
Given a list of connection factories, serves upTcpConnection
s that can iterate over a connection from each factory until the write succeeds or the list is exhausted.class
A client connection factory that createsTcpNetConnection
s.class
Implements a server connection factory that producesTcpNetConnection
s using aServerSocket
.class
A client connection factory that createsTcpNioConnection
s.class
/** Implements a server connection factory that producesTcpNioConnection
s using aServerSocketChannel
.class
A client connection factory that binds a connection to a thread. -
Uses of ManageableLifecycle in org.springframework.integration.ip.udp
Modifier and TypeClassDescriptionclass
Channel adapter that joins a multicast group and receives incoming packets and sends them to an output channel.class
AMessageHandler
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.class
A channel adapter to receive incoming UDP packets.class
AMessageHandler
implementation that maps a Message into a UDP datagram packet and sends that to the specified host and port. -
Uses of ManageableLifecycle in org.springframework.integration.jms
Modifier and TypeClassDescriptionclass
A wrapper around theJmsMessageDrivenEndpoint
implementingMessagingGatewaySupport
.class
A message-driven endpoint that receive JMS messages, converts them into Spring Integration Messages, and then sends the result to a channel.class
An outbound Messaging Gateway for request/reply JMS.class
AnAbstractJmsChannel
implementation for message-driven subscriptions. -
Uses of ManageableLifecycle in org.springframework.integration.jmx
Modifier and TypeClassDescriptionclass
A JMXNotificationListener
implementation that will send Messages containing the JMXNotification
instances as their payloads. -
Uses of ManageableLifecycle in org.springframework.integration.kafka.channel
Modifier and TypeClassDescriptionclass
Publish/subscribe channel backed by an Apache Kafka topic.class
Subscribable channel backed by an Apache Kafka topic. -
Uses of ManageableLifecycle in org.springframework.integration.kafka.inbound
Modifier and TypeClassDescriptionclass
KafkaInboundGateway<K,
V, R> Inbound gateway.class
Message-driven channel adapter.class
KafkaMessageSource<K,
V> Polled message source for Apache Kafka. -
Uses of ManageableLifecycle in org.springframework.integration.kafka.outbound
Modifier and TypeClassDescriptionclass
A Message Handler for Apache Kafka; when supplied with aReplyingKafkaTemplate
it is used as the handler in an outbound gateway. -
Uses of ManageableLifecycle in org.springframework.integration.mail
Modifier and TypeClassDescriptionclass
An event-driven Channel Adapter that receives mail messages from a mail server that supports the IMAP "idle" command (see RFC 2177). -
Uses of ManageableLifecycle in org.springframework.integration.mongodb.inbound
Modifier and TypeClassDescriptionclass
AMessageProducerSupport
for MongoDB Change Stream implementation. -
Uses of ManageableLifecycle in org.springframework.integration.mqtt.inbound
Modifier and TypeClassDescriptionclass
Abstract class for MQTT Message-Driven Channel Adapters.class
Eclipse Paho Implementation.class
TheAbstractMqttMessageDrivenChannelAdapter
implementation for MQTT v5. -
Uses of ManageableLifecycle in org.springframework.integration.mqtt.outbound
Modifier and TypeClassDescriptionclass
Abstract class for MQTT outbound channel adapters.class
Eclipse Paho Implementation.class
TheAbstractMqttMessageHandler
implementation for MQTT v5. -
Uses of ManageableLifecycle in org.springframework.integration.redis.channel
Modifier and TypeClassDescriptionclass
AnAbstractMessageChannel
implementation withBroadcastCapableChannel
aspect to provide a pub-sub semantics to consume messages fgrom Redis topic. -
Uses of ManageableLifecycle in org.springframework.integration.redis.inbound
Modifier and TypeClassDescriptionclass
AMessageProducerSupport
for reading messages from a Redis Stream and publishing them into the provided output channel.class
class
class
-
Uses of ManageableLifecycle in org.springframework.integration.router
Modifier and TypeClassDescriptionclass
A Message Router implementation that evaluates the specified SpEL expression.class
A Message Router that invokes the specified method on the given object. -
Uses of ManageableLifecycle in org.springframework.integration.rsocket.inbound
Modifier and TypeClassDescriptionclass
TheMessagingGatewaySupport
implementation for theIntegrationRSocketEndpoint
. -
Uses of ManageableLifecycle in org.springframework.integration.scattergather
Modifier and TypeClassDescriptionclass
TheMessageHandler
implementation for the Scatter-Gather EIP pattern. -
Uses of ManageableLifecycle in org.springframework.integration.sftp.inbound
Modifier and TypeClassDescriptionclass
AMessageSource
implementation for SFTP that delegates to an InboundFileSynchronizer.class
Message source for streaming SFTP remote file contents. -
Uses of ManageableLifecycle in org.springframework.integration.smb.inbound
Modifier and TypeClassDescriptionclass
AMessageSource
implementation for SMB.class
Message source for streaming SMB remote file contents. -
Uses of ManageableLifecycle in org.springframework.integration.splitter
Modifier and TypeClassDescriptionclass
A Message Splitter implementation that evaluates the specified SpEL expression.class
A Message Splitter implementation that invokes the specified method on the given object. -
Uses of ManageableLifecycle in org.springframework.integration.stomp.inbound
Modifier and TypeClassDescriptionclass
TheMessageProducerSupport
for STOMP protocol to handle STOMP frames from provided destination and send messages to theoutputChannel
. -
Uses of ManageableLifecycle in org.springframework.integration.stomp.outbound
Modifier and TypeClassDescriptionclass
TheAbstractMessageHandler
implementation to send messages to STOMP destinations. -
Uses of ManageableLifecycle in org.springframework.integration.support.management
Modifier and TypeInterfaceDescriptioninterface
ExtendManageableLifecycle
to make those methods manageable. -
Uses of ManageableLifecycle in org.springframework.integration.syslog.inbound
Modifier and TypeClassDescriptionclass
Base support class for inbound channel adapters.class
TCP implementation of a syslog inbound channel adapter.class
UDP implementation of a syslog inbound channel adapter. -
Uses of ManageableLifecycle in org.springframework.integration.transformer
Modifier and TypeClassDescriptionclass
Base class for Message Transformers that delegate to aMessageProcessor
.class
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.class
A Message Transformer implementation that evaluates the specified SpEL expression.class
A reply-producingMessageHandler
that delegates to aTransformer
instance to modify the receivedMessage
and sends the result to its output channel.class
A Message Transformer implementation that invokes the specified method on the given object. -
Uses of ManageableLifecycle in org.springframework.integration.webflux.inbound
Modifier and TypeClassDescriptionclass
AMessagingGatewaySupport
implementation for Spring WebFlux HTTP requests execution. -
Uses of ManageableLifecycle in org.springframework.integration.websocket.inbound
Modifier and TypeClassDescriptionclass
TheMessageProducerSupport
for inbound WebSocket messages. -
Uses of ManageableLifecycle in org.springframework.integration.ws
Modifier and TypeClassDescriptionclass
class
class
-
Uses of ManageableLifecycle in org.springframework.integration.xmpp.core
-
Uses of ManageableLifecycle in org.springframework.integration.xmpp.inbound
Modifier and TypeClassDescriptionclass
This component logs in as a user and forwards any messages to that user on to downstream components.class
An inbound endpoint that is able to login and then emit particular Presence event occurs within the logged-in user'sRoster
. -
Uses of ManageableLifecycle in org.springframework.integration.zeromq.inbound
Modifier and TypeClassDescriptionclass
AMessageProducerSupport
implementation for consuming messages from ZeroMq socket. -
Uses of ManageableLifecycle in org.springframework.integration.zeromq.outbound
Modifier and TypeClassDescriptionclass
TheAbstractReactiveMessageHandler
implementation for publishing messages over ZeroMq socket.