#14: Mono è un pigrone? Dipende!

🕐 Tempo di lettura: 2 minuti

Nuovo sabato, nuova biblio, nuova pillola!

Hai presente quando ti chiedi se il tuo Mono si mette subito all'opera o aspetta il momento giusto – senza sprecare risorse? No? Beh, se non sei un dev o non usi WebFlux, ovviamente no – sarebbe assai strano altrimenti, eheh! Ma se sei curioso, ecco un esempio semplice semplice per capire la differenza tra Mono.just() e Mono.fromCallable().

📌 L'esperimento

Confronto due modi di creare Mono per capire chi fa il lavoro prima e chi lo rimanda ad un momento successivo.

class SampleTest014 {

    @Test
    void test_MonoJust_eagerEvaluation() {
        final AtomicBoolean called = new AtomicBoolean(false);
        // Mono.just eagerly evaluates its argument
        final Mono<String> actualMono = Mono.just(computeValue(called));
        assertTrue(called.get()); // computeValue has ALREADY been called
        final String actual = actualMono.block();
        assertEquals("computed", actual);
    }

    @Test
    void test_MonoFromCallable_lazyEvaluation() {
        final AtomicBoolean called = new AtomicBoolean(false);
        // Mono.fromCallable defers computation until subscription
        final Mono<String> actualMono = Mono.fromCallable(() -> computeValue(called));
        assertFalse(called.get()); // computeValue NOT YET called
        final String actual = actualMono.block();
        assertTrue(called.get()); // NOW computeValue has been called
        assertEquals("computed", actual);
    }

    // helper method to set the flag and return a fixed string
    private String computeValue(final AtomicBoolean flag) {
        flag.set(true);
        return "computed";
    }
}

📑 Analisi del 1° test – `MonoJust_eagerEvaluation()`

Il metodo riceve subito il valore, quindi la funzione computeValue() viene chiamata subito appena creo il Mono. Il risultato è pronto prima ancora di sottoscrivere!

📑 Analisi del 2° test – `MonoFromCallable_lazyEvaluation()`

Qui invece la funzione non viene chiamata subito, ma solo quando il Mono viene sottoscritto – cioè al momento della .block(). In pratica, il lavoro è rimandato fino all'ultimo momento possibile.

📌 Quando usare `fromCallable()`?

Se hai operazioni potenzialmente bloccanti come leggere l'output di un processo esterno con un BufferedReader, fromCallable() ti permette di rimandare tutto fino alla sottoscrizione. Così eviti di far partire l'operazione troppo presto e mantieni il flusso reattivo pulito!

Alla prossima pillola! ☕

Java Pills