Reactor compose vs flatMap

paul :

I continue playing with Reactor, and now I see compose operator that behave exactly like flatMap and I´m wondering if there´s any difference that I don't understand.

    @Test
public void compose() throws InterruptedException {
    Scheduler mainThread = Schedulers.single();
    Flux.just(("old element"))
            .compose(element ->
                    Flux.just("new element in new thread")
                            .subscribeOn(mainThread)
                            .doOnNext(value -> System.out.println("Thread:" + Thread.currentThread().getName())))
            .doOnNext(value -> System.out.println("Thread:" + Thread.currentThread().getName()))
            .subscribe(System.out::println);
    Thread.sleep(1000);
}

@Test
public void flatMapVsCompose() throws InterruptedException {
    Scheduler mainThread = Schedulers.single();
    Flux.just(("old element"))
            .flatMap(element ->
                    Flux.just("new element in new thread")
                            .subscribeOn(mainThread)
                            .doOnNext(value -> System.out.println("Thread:" + Thread.currentThread().getName())))
            .doOnNext(value -> System.out.println("Thread:" + Thread.currentThread().getName()))
            .subscribe(System.out::println);
    Thread.sleep(1000);
}

This two examples behave and return the same result.

Regards.

Andrew Tobilko :

An excellent explanation by Dan Lew:

The difference is that compose() is a higher level abstraction: it operates on the entire stream, not individually emitted items. In more specific terms:

• compose() is the only way to get the original Observable<T> from the stream. Therefore, operators that affect the whole stream (like subscribeOn() and observeOn()) need to use compose().

  In contrast, if you put subscribeOn()/observeOn() in flatMap(), it would only affect the Observable you create in flatMap() but not the rest of the stream.

• compose() executes immediately when you create the Observable stream, as if you had written the operators inline. flatMap() executes when its onNext() is called, each time it is called. In other words, flatMap() transforms each item, whereas compose() transforms the whole stream.

• flatMap() is necessarily less efficient because it has to create a new Observable every time onNext() is called. compose() operates on the stream as it is. If you want to replace some operators with reusable code, use compose(). flatMap() has many uses but this is not one of them.

Guess you like

Origin http://10.200.1.11:23101/article/api/json?id=475834&siteId=1

Reactor compose vs flatMap

map vs flatMap in reactor

reactor merge vs concat、flatMap vs concatMap

How to use Context with flatMap() in Reactor?

Confusion about threads in Project Reactor's flatMap

What is the difference between using a compose() and a simple flatMap()?

Which is efficient way to bifurcate List of nested object list ? java 8 flatmap vs for each?

Design pattern of Reactor reactor

Compose LazyColumn vs. RecyclerView, which one has better performance?

Reactor mode

reactor principle

OS Reactor

reactor hooks

What is a reactor?

compose

Handwritten reactor (netty reactor model)

Wie man verwendet Kontext mit flatMap () in Reactor?

Como usar Contexto com flatMap () in Reactor?

zip and flatMap not take effect

java stream flatmap

Cactoos flatMap analogy

WebFlux Conditional FlatMap

Flatmap nested collection

Is flatMap guaranteed to be lazy?

Perform flatMap operation with Collectors

parallel flatMap always sequential

[JavaScript] array method - flatMap()

Reactor Reactor single-threaded mode -----

Design Patterns (11) - Reactor Patterns (Reactor)

Reactor pattern summary