Programmation réactive en Java : bibliothèques Project Reactor et RxJava

Programmation réactive en Java : Project Reactor et RxJava

La programmation réactive est un paradigme de développement axé sur le traitement de flux de données et d'événements asynchrones. En Java, ce paradigme s'est largement répandu grâce aux bibliothèques implémentant la spécification Reactive Streams. Les deux implémentations les plus populaires sont Project Reactor (base de Spring WebFlux) et RxJava (Reactive Extensions for Java).

Contrairement à l'approche impérative traditionnelle, la programmation réactive permet de travailler efficacement avec de grands volumes de données sans bloquer les threads d'exécution. Cela est particulièrement important pour les applications web modernes à forte charge, les microservices et les systèmes temps réel.

Concepts fondamentaux de la programmation réactive

À la base de l'approche réactive se trouvent trois notions clés :

• Observable (éditeur) — source de données pouvant générer des événements (éléments, erreurs, achèvement).
• Observer (abonné) — consommateur de données qui réagit aux événements.
• Opérateurs — fonctions de transformation des flux (map, filter, flatMap, combineLatest, etc.).

Les flux réactifs suivent le principe de backpressure (contre-pression) : l'abonné peut indiquer à l'éditeur combien d'éléments il est prêt à traiter, ce qui évite les débordements mémoire.

Project Reactor : Flux et Mono

Project Reactor est une bibliothèque réactive de Pivotal (maintenant VMware) qui constitue la base de Spring WebFlux. Elle propose deux types principaux :

• Flux<T> — un flux pouvant contenir 0, 1 ou plusieurs éléments (séquence asynchrone).
• Mono<T> — un flux contenant 0 ou 1 élément (analogue à Optional, mais asynchrone).

Exemple : création et traitement d'un Flux

import reactor.core.publisher.Flux;import reactor.core.publisher.Mono;

public class ReactorExample {    public static void main(String[] args) {        // Création d'un flux à partir d'une liste        Flux<String> names = Flux.just("Alice", "Bob", "Charlie", "Diana");

        // Application des opérateurs        names.filter(name -> name.length() > 3)             .map(String::toUpperCase)             .subscribe(                 result -> System.out.println("Reçu : " + result),                 error -> System.err.println("Erreur : " + error),                 () -> System.out.println("Flux terminé")             );

        // Mono — pour un seul élément        Mono<String> greeting = Mono.just("Bonjour, Réactif !");        greeting.subscribe(System.out::println);    }}

Résultat de l'exécution :

Reçu : ALICEReçu : CHARLIEReçu : DIANAFlux terminéBonjour, Réactif !

RxJava : Observable, Flowable et Single

RxJava est une implémentation Java des Reactive Extensions (Rx). Dans la version 3.x (RxJava 3), les types principaux suivants sont disponibles :

• Observable<T> — flux de 0..N éléments, sans support de backpressure.
• Flowable<T> — flux de 0..N éléments, avec support de backpressure.
• Single<T> — flux avec exactement un élément ou une erreur.
• Maybe<T> — flux avec 0 ou 1 élément.
• Completable — flux sans données, uniquement un signal d'achèvement ou d'erreur.

Exemple : travail avec Observable et opérateurs

import io.reactivex.rxjava3.core.Observable;import io.reactivex.rxjava3.core.Single;

public class RxJavaExample {    public static void main(String[] args) {        // Création d'un Observable à partir d'une plage de nombres        Observable<Integer> numbers = Observable