Vertel over het concept van de klasse CompletableFuture.

CompletableFuture is een klasse in Java 8+ die de interfaces Future en CompletionStage implementeert. Het vertegenwoordigt een asynchrone berekening die op een bepaald moment in de toekomst kan worden voltooid (of fout gaan), en waarop je achtereenvolgende acties declaratief kunt uitvoeren, zonder het hoofdproces te blokkeren.

Belangrijkste functies:

• Asynchrone uitvoering: Maakt het mogelijk taken uit te voeren in een aparte thread (of threadpool).
• Samenstelling: Je kunt meerdere CompletableFuture combineren, waardoor ketens van afhankelijke acties ontstaan.
• Foutafhandeling: Biedt methoden om fouten in asynchrone berekeningen te beheren.
• Niet-blokkerende operaties: Het resultaat of de uitzondering worden afgehandeld wanneer de future voltooid is, zonder expliciet te wachten (get()).

Belangrijke methoden:

• Aanmaak:
  • supplyAsync(Supplier<T> supplier): Voert een Supplier asynchroon uit en geeft een CompletableFuture met het resultaat.
  • runAsync(Runnable runnable): Voert een Runnable asynchroon uit en geeft een CompletableFuture<Void>.
  • completedFuture(T value): Maakt een al voltooid CompletableFuture met een gegeven waarde.
• Transformatie:
  • thenApply(Function<T, U> fn): Past een functie toe wanneer de future voltooid is.
  • thenAccept(Consumer<T> action): Voert een actie uit op het resultaat wanneer de future voltooid is.
  • thenRun(Runnable action): Voert een actie uit wanneer de future voltooid is, zonder het resultaat te gebruiken.
  • thenCompose(Function<T, CompletionStage<U>> fn): Maakt ketens waarbij het resultaat van een future wordt gebruikt om een andere te creëren.
• Combinatie:
  • thenCombine(CompletionStage<U> other, BiFunction<T, U, V> fn): Combineert de resultaten van twee futures.
  • allOf(CompletableFuture<?>... cfs): Geeft een CompletableFuture<Void> die voltooid wordt wanneer alle meegegeven futures voltooid zijn.
  • anyOf(CompletableFuture<?>... cfs): Geeft een CompletableFuture<Object> die voltooid wordt wanneer een van de meegegeven futures voltooid is.
• Foutafhandeling:
  • exceptionally(Function<Throwable, T> fn): Behandelt uitzonderingen en geeft een alternatief resultaat.
  • handle(BiFunction<T, Throwable, U> fn): Behandelt zowel het resultaat als de uitzondering.

Voorbeeld:

// Start een asynchrone taak
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(1000); // Simulatie van langdurig werk
    } catch (InterruptedException e) {
        throw new IllegalStateException(e);
    }
    return "Resultaat van de asynchrone operatie";
});

// Voer een actie uit nadat de taak is voltooid (niet-blokkerend)
future.thenAccept(result -> {
    System.out.println("Ontvangen resultaat: " + result);
});

// Een andere actie die afhankelijk is van de eerste
future.thenApply(String::toUpperCase)
      .thenAccept(upperCaseResult -> {
          System.out.println("Resultaat in hoofdletters: " + upperCaseResult);
      });

// Wacht op alle taken (in echte toepassingen wordt het gebruik van get/join meestal vermeden)
// future.join();

CompletableFuture is een krachtig hulpmiddel voor het schrijven van reactieve en niet-blokkerende code in Java, en vereenvoudigt het werken met asynchroniteit aanzienlijk in vergelijking met de klassieke Future-interface.