0Pricing
Java Academy · Lektion

Verketten mit thenApply und thenCompose

Transformieren Sie Ergebnisse mit thenApply und bilden Sie mit thenCompose asynchrone Schritte per flatMap ab, um verschachtelte Futures zu vermeiden.

Verketten mit thenApply und thenCompose ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

thenApply: Das Ergebnis transformieren

thenApply(Function) wendet eine synchrone Funktion auf das Ergebnis eines abgeschlossenen Futures an und gibt ein neues Future mit dem transformierten Typ zurück. Es startet keine neue asynchrone Aufgabe.

CompletableFuture<String> nameFuture = CompletableFuture
    .supplyAsync(() -> 42L)            // CF<Long>
    .thenApply(id -> "User#" + id);    // CF<String>
System.out.println(nameFuture.join()); // "User#42"

thenApplyAsync: Auf einem Thread transformieren

thenApplyAsync führt die Transformationsfunktion im ForkJoinPool (oder in einem angegebenen Executor) aus, sodass der Thread, der die vorherige Berechnung abschließt, sofort freigegeben wird.

CompletableFuture<String> result = fetchUserAsync()
    .thenApplyAsync(user -> serialize(user)); // runs on pool thread

thenAccept: Ohne Rückgabe verarbeiten

thenAccept(Consumer) verarbeitet das Ergebnis, gibt aber CompletableFuture<Void> zurück. Verwenden Sie es als letzten Schritt einer Pipeline, wenn Sie keinen Wert weitergeben müssen.

fetchUserAsync()
    .thenApply(User::getName)
    .thenAccept(name -> System.out.println("Hello, " + name));

thenRun: Nach dem Abschluss ausführen

thenRun(Runnable) führt eine Aufgabe aus, nachdem das Future abgeschlossen wurde, und ignoriert dabei das Ergebnis. Das eignet sich zum Schließen von Ressourcen oder zum Auslösen von Seiteneffekten.

downloadFileAsync(url)
    .thenRun(() -> System.out.println("Download complete"));

Mehrere thenApply-Aufrufe verketten

Mehrere Aufrufe von thenApply bilden eine Pipeline. Jeder Schritt erhält die Ausgabe des vorherigen Schritts.

CompletableFuture<Double> result = CompletableFuture
    .supplyAsync(() -> "  42.5  ")
    .thenApply(String::trim)
    .thenApply(Double::parseDouble)
    .thenApply(d -> d * 1.21); // apply 21% VAT
System.out.println(result.join()); // 51.425

thenCompose: Verschachtelte Futures abflachen

thenCompose(Function<T, CompletionStage<U>>) entspricht flatMap für Futures. Es vermeidet CompletableFuture<CompletableFuture<T>>, indem es das verschachtelte Future abflacht.

// Wrong with thenApply — returns CF<CF<Order>>:
CompletableFuture<CompletableFuture<Order>> nested =
    fetchUser(id).thenApply(u -> fetchLatestOrder(u.getId()));
// Correct with thenCompose — returns CF<Order>:
CompletableFuture<Order> flat =
    fetchUser(id).thenCompose(u -> fetchLatestOrder(u.getId()));

thenCompose für sequenzielle asynchrone Aufrufe

Verwenden Sie thenCompose, wenn jeder asynchrone Schritt vom Ergebnis des vorherigen abhängt – dadurch werden die Schritte sequenziell und ergebnisabhängig ausgeführt.

fetchUser(userId)
    .thenCompose(user -> fetchOrders(user.getId()))
    .thenCompose(orders -> computeTotal(orders))
    .thenAccept(total -> System.out.println("Total: " + total));

thenApply oder thenCompose

thenApply: bildet T -> U ab (synchrone Transformation). thenCompose: bildet T -> CompletableFuture<U> ab und flacht das Ergebnis ab. Verwenden Sie compose, wenn der nächste Schritt ebenfalls asynchron ist.

Zwischenfehler mit handle behandeln

handle(BiFunction<T, Throwable, U>) wird unabhängig davon aufgerufen, ob das Future normal oder mit einer Ausnahme abgeschlossen wurde. Dadurch können Sie Fehler in der Mitte der Pipeline behandeln oder umwandeln.

fetchUser(id)
    .thenApply(User::getProfile)
    .handle((profile, ex) -> {
        if (ex != null) return Profile.empty(); // recover
        return profile;
    })
    .thenAccept(System.out::println);

whenComplete: Seiteneffekt nach jedem Ergebnis

whenComplete(BiConsumer) wird nach dem Abschluss (normal oder mit einer Ausnahme) zum Protokollieren oder Aufräumen aufgerufen. Anders als handle ändert es das Ergebnis nicht.

fetchAsync()
    .whenComplete((result, ex) -> {
        if (ex != null) log.error("Failed", ex);
        else            log.info("Result: " + result);
    });

Beispiel für eine nicht blockierende Pipeline

Erstellen Sie eine vollständig nicht blockierende Pipeline: Rufen Sie einen Benutzer ab, rufen Sie dessen Bestellungen ab und berechnen Sie eine Zusammenfassung – alle Schritte werden asynchron ausgeführt, wobei jeder vom vorherigen abhängt.

CompletableFuture<String> summary =
    fetchUser(userId)
        .thenCompose(u -> fetchOrders(u.getId()))
        .thenApply(orders -> orders.size() + " orders")
        .exceptionally(ex -> "Error: " + ex.getMessage());
System.out.println(summary.join());

Schnelltest

Wann sollten Sie thenCompose statt thenApply verwenden?

Zusammenfassung

thenApply transformiert synchrone Werte in einer Pipeline. thenCompose verkettet asynchrone Schritte (flatMap für Futures). handle und whenComplete fügen Fehlerbehandlung und Seiteneffekte hinzu. Bauen Sie Pipelines für bessere Lesbarkeit von links nach rechts auf.

Häufig gestellte Fragen

Ist die Lektion „Verketten mit thenApply und thenCompose“ kostenlos?

Ja — der vollständige Text von „Verketten mit thenApply und thenCompose“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Verketten mit thenApply und thenCompose“?

Transformieren Sie Ergebnisse mit thenApply und bilden Sie mit thenCompose asynchrone Schritte per flatMap ab, um verschachtelte Futures zu vermeiden. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Verketten mit thenApply und thenCompose“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. CompletableFutures erstellen und abschließen
  2. Verketten mit thenApply und thenCompose
  3. Futures kombinieren: allOf und anyOf
  4. Fehlerbehandlung und asynchrone HTTP-Pipeline
← Zurück zu Java Academy