La programmation réactive est une approche de programmation fonctionnelle axée sur les événements. Quelques framework réactifs ont vu le jour, notamment Akka et Sodium. Ce faisant, un ingénieur chez Microsoft nommé Erik Meijer a créé un cadre de programmation réactive pour .NET appelé Reactive Extensions. En quelques années, Reactive Extensions (également connu sous le nom de ReactiveX ou Rx) a été porté sur plusieurs langages et plateformes, dont JavaScript, Python, C++, Swift et Java. Rapidement, ReactiveX est devenu une norme de programmation réactive inter-langues.
Depuis ce temps, la programmation réactive est devenue un pilier des applications modernes, notamment dans les architectures orientées événements, les systèmes distribués ou encore les applications mobiles performantes. Dans cet article, nous allons explorer les fondamentaux de la programmation réactive en nous appuyant sur RxJava, l’une des bibliothèques les plus populaires de l’écosystème Java.
Qu’est-ce que la programmation réactive ?
La programmation réactive est un paradigme de développement qui repose sur le principe de réagir aux changements ou aux événements. Elle permet de traiter les données sous forme de flux asynchrones, tout en gérant la concurrence de manière élégante et déclarative.
Au lieu de demander un résultat (approche impérative), on s’abonne à un flux de données et on réagit à leur arrivée, leur transformation ou à leur erreur éventuelle.
Pourquoi RxJava ?
RxJava est une implémentation Java de la ReactiveX (Reactive Extensions). Elle offre un puissant ensemble d’outils pour créer, manipuler et consommer des flux de données de manière fluide, réutilisable et performante. RxJava permet :
- d’écrire du code asynchrone plus lisible et maintenable,
- de chaîner des opérations complexes de manière déclarative,
- de gérer les erreurs et le multithreading sans boilerplate.
Selon votre gestionnaire de build Maven, Gradle ou Sbt, vous pouvez l’importer à partir du repository central : https://central.sonatype.com/artifact/io.reactivex.rxjava3/rxjava
Les concepts clés de RxJava
Observable
Un Observable est la source de données réactives. Il peut émettre zéro, une ou plusieurs valeurs, ainsi qu’un signal d’erreur ou de complétion. Par exemple : des requêtes réseau, des clics utilisateur, ou des lectures de fichiers.
Observable<String> observable = Observable.just("Bonjour", "RxJava");Observer / Subscriber
Un Observer est l’élément qui s’abonne à l’Observable pour réagir à ce qu’il émet : données, erreurs, ou complétion.
observable.subscribe(
item -> System.out.println("Reçu : " + item),
error -> System.out.println("Erreur : " + error),
() -> System.out.println("Complété")
);Opérateurs
Les opérateurs permettent de transformer, filtrer, combiner ou gérer les erreurs d’un flux. Voici quelques exemples courants :
- map : transformer chaque élément
- filter : filtrer des éléments selon une condition
- flatMap : transformer un élément en un autre flux
Observable.just(1, 2, 3)
.map(i -> i * 2)
.filter(i -> i > 2)
.subscribe(System.out::println); // Résultat : 4, 6Schedulers
RxJava gère l’exécution des opérations sur des threads spécifiques grâce aux Schedulers. Cela permet d’éviter le blocage de l’UI ou des threads critiques.
- Schedulers.io() : pour les opérations réseau ou disque
- Schedulers.computation() : pour le calcul intensif
- AndroidSchedulers.mainThread() (via RxAndroid) : pour l’UI sur Android
observable
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe();Les avantages concrets de RxJava
- Code plus clair et expressif
Moins de callbacks imbriqués, plus de lisibilité grâce au chaînage fluide des opérations. - Asynchronisme simplifié
Facile à gérer sans bloquer les threads principaux (UI, backends, etc.). - Gestion d’erreurs centralisée
Les erreurs sont traitées comme des événements, donc plus faciles à capturer et à propager. - Composabilité élevée
Tu peux combiner plusieurs flux très facilement, sans écrire du code impératif lourd. - Interopérabilité avec d’autres libs
RxJava s’intègre très bien avec Retrofit, Room, Kafka, WebSockets, etc.
RxJava dispose d’autres classes puissantes que nous aborderons dans d’autres articles :
- Flowable : pour les flux à fort volume avec gestion de backpressure
- Single : pour un seul résultat
- Maybe : pour un résultat optionnel
- Completable : pour une opération sans résultat
Conclusion
RxJava est un outil incontournable si tu développes en Java (Android, Spring Boot, etc.) et que tu veux gérer des flux asynchrones, de manière propre, performante et réactive.
À travers ses concepts clés – Observable, Observer, Operators, Schedulers – RxJava te permet de transformer ton code spaghetti asynchrone en une architecture fluide et robuste.
