Pre-create inner Mono as a variable

Assume simple reactive stream line this:

        Flux.just(1, 2, 3, 4, 5)
                .flatMap(i -> 
                        Mono.just(i)
                                .map( ... map some value)
                                .flatMap( ... async call)
                                .map(... more mappings)
                )
                .doOnNext(log::info)
                .blockLast()
        ;

Assume Mono inside parent stream .flatMap() is complicated reactive stream with complex logic. Is there a way to save that Mono as a variable that could be passed to the parent stream? In other words, something like this:

final Function<Integer, Publisher<String>> monoPublisher = Mono.something()
                .map( ... map some value)
                .flatMap( ... async call)
                .map(... more mappings);

        Flux.just(1, 2, 3, 4, 5)
                .flatMap(monoPublisher)
                .doOnNext(log::info)
                .blockLast()
        ;

The naive answer would be:

final Function<Integer, Publisher<String>> monoPublisher = i -> Mono.just(i) ...

However, that would still defer initialization of Mono until actual subscription, and new Mono would be created for each element in parent stream.

I am familiar with Mono.create() but I don't see how to make it work here, without creating my own Publisher implementation that wraps around sink that is returned by Mono.create()

EDIT:
Thanks for ESala for the suggestion. I just modified his example to use ThreadLocal instead of Queue, which is not needed for this example using Flux.just() but would prevent race conditions when using multi-threaded producer

final ThreadLocal<Integer> threadLocalStorage = new ThreadLocal<>();

        final Mono<String> mono = Mono.fromSupplier(threadLocalStorage::get)
                .map(Objects::toString);

        Flux.just(1, 2, 3, 4, 5)
                .flatMap(i -> {
                    threadLocalStorage.set(i);
                    return mono;
                })
                .doOnNext(System.out::println)
                .blockLast()
        ;

Maybe something like this would work, just replace the LinkedList with something fancier that supports concurrent access:

Queue<Integer> arguments = new LinkedList<>();

Publisher<String> expensivePublisher =
        Mono.fromSupplier(arguments::remove)
                .map( ... map some value)
                .flatMap( ... async call)
                .map(... more mappings);

Flux.just(1, 2, 3)
        .flatMap(
                i -> {
                    arguments.add(i);
                    return expensivePublisher;
                })
        .blockLast();

But it still feels like a hack. If there truly are 100 operators in the inner, then would suggest trying to optimize on that side. Improvements in that area will likely have higher impact than reusing the Publisher to avoid recreating it.