poller | A full stack polling app built with React , Redux , Express | State Container library

1. It is the main method, so there is no need to cleanup. When main returns, the program exits. If this wasn't the main, then you would be correct.

2. There is no best practice that fits all use cases. The code you show here is a very common pattern. The function creates a goroutine, and returns a channel so that others can communicate with that goroutine. There is no rule that governs how channels must be created. There is no way to terminate that goroutine though. One use case this pattern fits well is reading a large resultset from a database. The channel allows streaming data as it is read from the database. In that case usually there are other means of terminating the goroutine though, like passing a context.

3. Again, there are no hard rules on how channels should be created/closed. A channel can be left open, and it will be garbage collected when it is no longer used. If the use case demands so, the channel can be left open indefinitely, and the scenario you worry about will never happen.

The runtime server socket endpoints registration is available only starting with Spring Integration 5.5 version: https://docs.spring.io/spring-integration/docs/current/reference/html/whats-new.html#x5.5-websocket.

The test-case on the matter looks like: https://github.com/spring-projects/spring-integration/blob/main/spring-integration-websocket/src/test/java/org/springframework/integration/websocket/dsl/WebSocketDslTests.java#L66

UPDATE

There is indeed a problem in the framework, when we have not only plain Spring Integration, but whole Spring Boot. I'm going to fix it somehow on my side, but for now here is a workaround:

1. Use only a @SpringBootApplication. It brings for us @EnableIntegration.

2. Don't use @EnableWebSocket since that one is going to override whatever Spring Integration would like to do. In other words @EnableWebSocket is not compatible with Spring Integration Websocket support. (Or wise versa)

3. You must this bean into your application context:

You are using an outdated API.

The annotation-based configuration model has been long deprecated in favor of functional programming model, so EnableBinding, StreamListener etc are on their way out.

For you case you can simply use Supplier with StreamBridge. See this section for more details. And then you can do programmatic start/stop binding using the available lifecycle features of spring-cloud-stream.

Now, that doesn't mean your other problem will be resolved, but without a full stack trace and sufficient detail (e.g., version of frameworks you are using) it is difficult to say.

If the Bean definition is not present in your code. Then, following should work:

The job has huge data to process , many partition messages are publishing to queue and the aggregator of response from replyChannnel is failing with timeout of messages as all messages cant be processed in a given time.

You need to increase your timeout or add more workers. The Javadoc of MessageChannelPartitionHandler is clear about that:

Indeed this is not supported for functional programming model at the moment as it really violates a concept of microservices for which spring-cloud-stream was designed for, where one of the main principles is you do one thing and do it well without affecting others. And in your case (especially with sources) you have multiple microservices grouped together in a single JVM process, thus one service affecting another.

That said, feel free to raise an issue so we can consider adding this feature

The problem is that you are not sharing a specific bean instance as the call bean(StateBean.class, ...) are supposed to create a new instance of the bean of the required class

You should use something like .beanRef("name-of-the-bean", ....)

I would advice to re-think your vision about reactive stream and start avoiding calling that .block() manually.

Looking to your whole flow requirements, it is really better to make that fromR2dbcChannel as a FluxMessageChannel, so your Mono from R2DBC is going to be subscribed and processed smoothly internally by the framework if there is data.

Your @Transformer(inputChannel = "fromR2dbcChannel", outputChannel = "fromTransformer") then could just deal with a plain Event as an input parameter. Then your KinesisMessageHandler is good to deal with whatever you send to its input channel in the palyoad from that event.getDetails().

UPDATE

So, my bad. Independently of the channel for @InboundChannelAdapter, it still going to produce a Mono in the payload of the message. From here the channel type really doesn't matter. |But at the same time you can make that validationChannel as a FluxMessageChannel and then your transformer must be changed to the service activator:

For now I only can answer that if you have already a JPA repository, you should use a generic method invocation MessageSource instead of that Jpa.inboundChannelAdapter(). The last one technically does for us whatever repository does but more in messaging manner.

The issue with dialect not clear for me: looks like you use the same. The dialect if not set explicitly is derived from the JpaVendorAdapter. The HibernateJpaConfiguration should do a stuff for us on the matter. Not clear if @DataJpaTest does for us everything what we needed.

Nothing to do with Spring Integration though. I'd like to see some simple project from you to play with locally on my side.