Formations — 1 037 leçons en français

Accueil › Spring Boot › Programmation réactive : Mono et Flux

Programmation réactive : Mono et Flux

Programmation réactiveavance

La programmation réactive gère des flux de données asynchrones et non bloquants : au lieu qu'un thread attende un résultat (I/O réseau, base de données), il se rend disponible pour autre chose et est notifié quand le résultat arrive. Objectif : servir beaucoup de requêtes concurrentes avec peu de threads, utile quand l'application passe le plus clair de son temps à attendre du réseau plutôt qu'à calculer.

Project Reactor (utilisé par Spring) propose deux types, tous deux implémentant l'interface standard Publisher de Reactive Streams :

Mono<Client> client = clientRepository.findById(id);        // 0 ou 1 élément
Flux<Commande> commandes = commandeRepository.findAll();    // 0 à N éléments

On les manipule avec des opérateurs qui construisent un pipeline, sans jamais rien exécuter tant que personne ne s'abonne (subscribe()) :

Mono<CommandeDto> resultat = commandeRepository.findById(id)
        .flatMap(commande -> clientRepository.findById(commande.getClientId())
                .map(client -> new CommandeDto(commande, client)))
        .switchIfEmpty(Mono.error(new CommandeIntrouvableException(id)))
        .onErrorResume(TimeoutException.class, e -> Mono.just(CommandeDto.parDefaut()));

Dans Spring WebFlux, le framework s'abonne lui-même à ce qu'un contrôleur renvoie. Ne jamais appeler block() dans ce contexte : ça reviendrait à attendre de façon bloquante sur un thread prévu pour ne jamais bloquer.

Les termes à connaître

Reactive Streams

Spécification standard de la JVM (interfaces Publisher, Subscriber, Subscription, Processor) pour le traitement asynchrone de flux de données avec backpressure — le consommateur contrôle le débit auquel le producteur lui envoie des éléments. Project Reactor, RxJava et Akka Streams l'implémentent.

Mono<T>

Publisher réactif de 0 ou 1 élément (ou une erreur). Remplace typiquement un Optional<T> ou un simple retour de méthode dans une chaîne asynchrone.

Flux<T>

Publisher réactif de 0 à N éléments, potentiellement infini. Remplace typiquement une List<T> ou un flux de données continu (événements, lignes d'un fichier).

Backpressure

Mécanisme par lequel l'abonné (Subscriber) signale au producteur combien d'éléments il est prêt à recevoir (Subscription.request(n)), pour éviter d'être submergé par un producteur plus rapide que lui.

Évaluation paresseuse (lazy)

Un Mono ou un Flux ne déclenche aucun traitement tant que personne ne s'y abonne. Il décrit une séquence d'opérations, pas un calcul déjà lancé — à la différence d'un CompletableFuture, déjà en cours d'exécution dès sa création.

Scheduler

Abstraction Reactor qui définit sur quel thread (ou pool de threads) s'exécute une partie de la chaîne. Schedulers.boundedElastic() est réservé au code bloquant ; Schedulers.parallel() au calcul intensif en CPU.

StepVerifier

Utilitaire de reactor-test qui s'abonne à un Mono/Flux et vérifie, étape par étape, les éléments émis, les erreurs et la complétion — l'équivalent d'une assertion pour du code réactif.

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.