When developing inbound channel adapters, I couldn’t find any place that mentions the differences between AbstractMessageSource
and MessageProducerSupport
in Spring Integration. I’m asking this question in the context of reactive streams, so I’m actually looking at AbstractReactiveMessageSource
, but I guess it doesn’t matter for my question. I also wonder whether MessageProducerSupport
supports project reactor and doesn’t have an equivalent to AbstractReactiveMessageSource
.
CodePudding user response:
There is some documentation about these types of components: https://docs.spring.io/spring-integration/docs/current/reference/html/overview.html#finding-class-names-for-java-and-dsl-configuration
The inbound message flow side has its own components, which are divided into polling and listening behaviors.
So, the MessageProducerSupport
is for those protocols which provide a listening callback for us. So, we can hook up into that, build message and produce it into a channel provided by the MessageProducer
. So, it is self-eventing component which really has everything to listen to the source system and produce messages from the callback. This type of channel adapters called event-driven and samples of them are JMS, AMQP, HTTP, IMAP, Kinesis etc.
From here it is wrong to try to compare the MessageProducerSupport
with an AbstractMessageSource
because the are not relevant. The one you should look into is a SourcePollingChannelAdapter
. Exactly this one is that kind of flow beginning endpoint which is similar to MessageProducerSupport
. With only the problem that it is based on a periodic scheduled task to request for messages in the provided MessageSource
. This type of component is for those protocols which don't provide listening callback, e.g. local file system, (S)FTP, JDBC, MongoDb, POP3, S3 etc.
You probable would expect something similar to MessageSource
for the MessageProducer
level, but there is not that kind of layer because everything single event-driven protocol has its own specifics, therefore we cannot extract some common abstraction like in case of polling protocols.
If your source system provides for you a reactive Publisher
, you don't need to look into a SourcePollingChannelAdapter
and MessageSource
. You just need a MessageProducerSupport
and call its subscribeToPublisher(Publisher<? extends Message<?>> publisher)
from the start()
implementation.
There is no need in the reactive implementation for the polling since Publisher
is not pollable by itself it is event-driven. Although it has its own back-pressure specifics which is out of MessageProducerSupport
scope.
There is also some explanation in this section of the doc: https://docs.spring.io/spring-integration/docs/current/reference/html/reactive-streams.html#source-polling-channel-adapter. And see a couple next paragraphs.