Wat is CompletableFuture?

CompletableFuture in Java 8+ vertegenwoordigt een uitbreiding van het Future-model, die mogelijkheden voor asynchrone programmeren en taakcompositie toevoegt.

Het implementeert de interfaces CompletionStage en Future. CompletionStage definieert het contract voor asynchrone uitvoering en compositie van berekeningsstappen.

Belangrijke kenmerken:

• Niet-blokkerende operaties: Maakt het mogelijk taken asynchroon uit te voeren zonder de hoofdthread te blokkeren.
• Compositie: Biedt een rijke API voor het koppelen en combineren van resultaten van meerdere asynchrone operaties.
• Foutafhandeling: Ingebouwde mechanismen voor het afhandelen van fouten in asynchrone stromen.
• Creatie: Men kan CompletableFuture maken die voltooid, niet-voltooid of foutief zijn.
• Afhankelijkheden: Maakt het mogelijk ketens van afhankelijke taken te creëren, waarbij de uitvoering van de ene afhankelijk is van de voltooiing van de andere.
• Parallel uitvoeren: Methoden zoals allOf en anyOf voor het parallel uitvoeren van meerdere taken.

Voorbeelden van gebruik:

1. Aanmaak en voltooiing:

   // Een voltooide CompletableFuture maken
   CompletableFuture<String> completedFuture = CompletableFuture.completedFuture("Hallo");
   
   // Een niet-voltooide CompletableFuture maken en later voltooien
   CompletableFuture<String> future = new CompletableFuture<>();
   // ... asynchroon werk uitvoeren ...
   future.complete("Klaar");
   // Of bij een fout
   // future.completeExceptionally(new RuntimeException("Fout"));
   

2. Asynchrone taak uitvoeren:

   CompletableFuture<String> asyncFuture = CompletableFuture.supplyAsync(() -> {
       // Asynchroon werk (bijvoorbeeld lezen uit bestand, netwerkrequest)
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           throw new IllegalStateException(e);
       }
       return "Asynchrone Resultaat";
   });
   

3. Compositie met thenApply:

   CompletableFuture<Integer> result = CompletableFuture.supplyAsync(() -> 10)
       .thenApply(x -> x * 2); // Resultaat van vorige stap wordt doorgegeven aan functie
   

4. Compositie met thenCombine:

   CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 10);
   CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 20);
   
   CompletableFuture<Integer> combinedFuture = future1.thenCombine(future2, (res1, res2) -> res1 + res2); // Resultaten van twee CompletableFuture samenvoegen
   

5. Afhandeling met thenAccept:

   CompletableFuture.supplyAsync(() -> "Eindresultaat")
       .thenAccept(result -> System.out.println("Taak voltooid met resultaat: " + result)); // Actie uitvoeren na voltooiing zonder waarde terug te geven
   

6. Foutafhandeling met exceptionally:

   CompletableFuture<String> futureWithException = CompletableFuture.supplyAsync(() -> {
       throw new RuntimeException("Iets ging mis");
   }).exceptionally(ex -> {
       System.err.println("Fout opgetreden: " + ex.getMessage());
       return "Standaardwaarde"; // Teruggeven van standaardwaarde bij fout
   });
   

CompletableFuture vereenvoudigt het schrijven van asynchrone en niet-blokkerende code in Java aanzienlijk, waardoor het leesbaarder en onderhoudsvriendelijker wordt in vergelijking met traditionele callbacks of blokkerende aanroepen zoals Future.get().