Reaktive Programmierung in Java: Bibliotheken Project Reactor und RxJava

Reaktive Programmierung in Java: Project Reactor und RxJava

Reaktive Programmierung ist ein Entwicklungsparadigma, das auf die Verarbeitung asynchroner Datenströme und Ereignisse ausgerichtet ist. In Java hat sich dieses Paradigma dank der Bibliotheken, die die Spezifikation Reactive Streams implementieren, weit verbreitet. Die beiden bekanntesten Implementierungen sind Project Reactor (Grundlage von Spring WebFlux) und RxJava (Reactive Extensions for Java).

Im Gegensatz zum traditionellen imperativen Ansatz ermöglicht die reaktive Programmierung die effiziente Verarbeitung großer Datenmengen, ohne Ausführungsthreads zu blockieren. Dies ist besonders wichtig für moderne hochbelastete Webanwendungen, Microservices und Echtzeitsysteme.

Grundlegende Konzepte der reaktiven Programmierung

Dem reaktiven Ansatz liegen drei Schlüsselkonzepte zugrunde:

• Observable (Publisher) — eine Datenquelle, die Ereignisse (Elemente, Fehler, Abschluss) erzeugen kann.
• Observer (Subscriber) — ein Datenkonsument, der auf Ereignisse reagiert.
• Operatoren — Funktionen zur Transformation von Strömen (map, filter, flatMap, combineLatest usw.).

Reaktive Ströme folgen dem Prinzip des Backpressure (Gegendruck): Der Abonnent kann dem Herausgeber mitteilen, wie viele Elemente er zu verarbeiten bereit ist, was eine Speicherüberlastung verhindert.

Project Reactor: Flux und Mono

Project Reactor ist eine reaktive Bibliothek von Pivotal (jetzt VMware), die die Grundlage von Spring WebFlux bildet. Sie bietet zwei Haupttypen:

• Flux<T> — ein Strom, der 0, 1 oder viele Elemente enthalten kann (asynchrone Sequenz).
• Mono<T> — ein Strom, der 0 oder 1 Element enthält (Analog zu Optional, aber asynchron).

Beispiel: Erstellen und Verarbeiten eines Flux

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

public class ReactorExample {    public static void main(String[] args) {        // Erstellen eines Stroms aus einer Liste        Flux<String> names = Flux.just("Alice", "Bob", "Charlie", "Diana");

        // Anwenden von Operatoren        names.filter(name -> name.length() > 3)             .map(String::toUpperCase)             .subscribe(                 result -> System.out.println("Erhalten: " + result),                 error -> System.err.println("Fehler: " + error),                 () -> System.out.println("Strom abgeschlossen")             );

        // Mono — für ein einzelnes Element        Mono<String> greeting = Mono.just("Hallo, Reaktiv!");        greeting.subscribe(System.out::println);    }}

Ergebnis der Ausführung:

Erhalten: ALICEErhalten: CHARLIEErhalten: DIANAStrom abgeschlossenHallo, Reaktiv!

RxJava: Observable, Flowable und Single

RxJava ist eine auf Java portierte Implementierung von Reactive Extensions (Rx). In Version 3.x (RxJava 3) sind die folgenden Haupttypen verfügbar:

• Observable<T> — ein Strom mit 0..N Elementen, ohne Backpressure-Unterstützung.
• Flowable<T> — ein Strom mit 0..N Elementen, mit Backpressure-Unterstützung.
• Single<T> — ein Strom mit genau einem Element oder einem Fehler.
• Maybe<T> — ein Strom mit 0 oder 1 Element.
• Completable — ein Strom ohne Daten, nur mit Abschluss- oder Fehlersignal.

Beispiel: Arbeiten mit Observable und Operatoren

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

public class RxJavaExample {    public static void main(String[] args) {        // Erstellen eines Observable aus einem Zahlenbereich        Observable<Integer> numbers = Observable