reactive-streams

How can I convert Flux<MyObject> directly to Mono<List<MyObject>> ? I am looking for equivalent of Single<List<MyObject>> single = observable.toList() from RxJava. With blocking operator I can do it like this: val just: Mono<List<MyObject>> = Mono.just(flux.toIterable().toList()) But it is executed at the time of declaration which doesn't seam to be right. Flux has the method collectList() doing just the same like toList() in Rx. val just: Mono<List<MyObject>> = flux.collectList() 来源： https://stackoverflow.com/questions/44039497/reactor-fluxmyobject-to-monolistmyobject

Getting started with akka-streams I want to build a simple example. In chrome using a web socket plugin I simply can connect to a stream like this one https://blockchain.info/api/api_websocket via wss://ws.blockchain.info/inv and sending 2 commands {"op":"ping"} {"op":"unconfirmed_sub"} will stream the results in chromes web socket plugin window. I tried to implement the same functionality in akka streams but am facing some problems: 2 commands are executed, but I actually do not get the streaming output the same command is executed twice (the ping command) When following the tutorial of http:

I'm trying to understand why the below code snippet is doing what it's doing. I would have thought that because the Sink cannot produce demand faster than the Source is producing content, then I would be getting dropped messages in response to some of the offers (overflow strategy is set to Drop Buffer) and also an error and queue closed message after the self destruct piece. The snippet: package playground import java.time.LocalDateTime import java.util.concurrent.atomic.AtomicInteger import akka.actor.{Actor, ActorLogging, ActorSystem, Props} import akka.stream.QueueOfferResult.{Dropped,

Let's assume we have two Akka Stream flows, each running on its own JVM. // A reactive streams publisher running on JVM 1: val stringPublisher: Publisher[String] = Source(() => "Lorem Ipsum".split("\\s").iterator).runWith(Sink.publisher[String]) // A reactive streams subscriber running on JVM 2: def subscriber: Subscriber[String] = Sink.foreach[String](println(_)).runWith(Source.subscriber[String]) // Subscribe the second stream to the first stream stringPublisher.subscribe(subscriber) This example runs fine on one JVM, but how can I subscribe to a publisher running on a different JVM? Do I

Recently, I decided to try spring 5 with projectreactor.io (io.projectreactor:3.1.1). Does anyone know what the best case of using this functions? What cons and pros of using each of them and where they should be used? Good examples will be helpful. You have two broadly different categories of operators here: Operators that work on the Flux itself transform and compose are for code mutualization When you compose chains of operators regularly and you have common operator usage patterns in your application, you can mutualize this code or give it a more descriptive name by using compose and