How to pass data down the reactive chain

Question

Whenever I need to pass data down the reactive chain I end up doing something like this:

public Mono<String> doFooAndPassDtoAsMono(Dto dto) {
    return Mono.just(dto)
        .flatMap(dtoMono -> {
            Mono<String> result = // remote call returning a Mono
            return Mono.zip(Mono.just(dtoMono), result);
        })
        .flatMap(tup2 -> {
            return doSomething(tup2.getT1().getFoo(), tup2.getT2()); // do something that requires foo and result and returns a Mono
        });
}

Given the below sample Dto class:

class Dto {
    private String foo;

    public String getFoo() {
        return this.foo;
    }
}

Because it often gets tedious to zip the data all the time to pass it down the chain (especially a few levels down) I was wondering if it's ok to simply reference the dto directly like so:

public Mono<String> doFooAndReferenceParam(Dto dto) {
       Mono<String> result = // remote call returning a Mono
        return result.flatMap(result -> {
            return doSomething(dto.getFoo(), result); // do something that requires foo and result and returns a Mono
        });
}

My concern about the second approach is that assuming a subscriber subscribes to this Mono on a thread pool would I need to guarantee that Dto is thread safe (the above example is simple because it just carries a String but what if it's not)?

Also, which one is considered "best practice"?

score 0 · Answer 1 · answered Sep 15 '18 at 02:06

0

Based on what you have shared, you can simply do following:

public Mono<String> doFooAndPassDtoAsMono(Dto dto) {
    return Mono.just(dto.getFoo());
}

The way you are using zip in the first option doesn't solve any purpose. Similarly, the 2nd option will not work either as once the mono is empty then the next flat map will not be triggered.

answered Sep 15 '18 at 02:06

Vikram Rawat

1,472
11
16

I’ve modified my question to be more explicit. Mono result is just an arbitrary mono as a result of a remote call. – voychris Sep 15 '18 at 02:24
1

In that case, your second option is fine. I assume your DTO gets created as new object for every db hit. And if yes, then no additional thread safety should be needed. – Vikram Rawat Sep 15 '18 at 02:44

score 0 · Answer 2 · answered Apr 02 '19 at 13:45

The case is simple if

The reference data is available from the beginning (i.e. before the creation of the chain), and
The chain is created for processing at most one event (i.e. starts with a Mono), and
The reference data is immutable.

Then you can simple refer to the reference data in a parameter or local variable – just like in your second solution. This is completely okay, and there are no concurrency issues.

Using mutable data in reactive flows is strongly discouraged. If you had a mutable Dto class, you might still be able to use it (assuming proper synchronization) – but this will be very surprising to readers of your code.

How to pass data down the reactive chain

2 Answers2

Linked