{"id":522,"date":"2024-10-05T09:59:34","date_gmt":"2024-10-05T08:59:34","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=522"},"modified":"2024-12-23T10:03:20","modified_gmt":"2024-12-23T09:03:20","slug":"konvertierung-eines-future-in-ein-completablefuture-in-java","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=522","title":{"rendered":"Konvertierung eines Future in ein CompletableFuture in Java"},"content":{"rendered":"\n

Die Java-Programmierung bietet verschiedene Mechanismen f\u00fcr die Arbeit mit asynchronen Aufgaben. Zwei wichtige Bestandteile in diesem Kontext sind das klassische Future<\/code>-Interface und das moderner gestaltete CompletableFuture<\/code>, das mit Java 8 eingef\u00fchrt wurde. W\u00e4hrend beide Konzepte asynchrone Verarbeitung erm\u00f6glichen, unterscheiden sie sich erheblich in ihren Funktionsweisen und M\u00f6glichkeiten. In diesem Artikel gehen wir darauf ein, wie man ein Future<\/code> in ein CompletableFuture<\/code> konvertieren kann, und beleuchten die Unterschiede zwischen beiden Ans\u00e4tzen.<\/p>\n\n\n\n

\n\n\n\n

Unterschiede zwischen Future und CompletableFuture<\/h4>\n\n\n\n

Future<\/h5>\n\n\n\n

Das Future<\/code>-Interface wurde mit Java 5 eingef\u00fchrt und stellt ein einfaches Mittel bereit, um asynchrone Ergebnisse zu verarbeiten. Es erlaubt es, eine Aufgabe auszuf\u00fchren und das Ergebnis zu einem sp\u00e4teren Zeitpunkt abzurufen. Hier sind einige Kernpunkte:<\/p>\n\n\n\n

    \n
  1. Blockierende Abfrage<\/strong>: Um das Ergebnis zu erhalten, wird die Methode get()<\/code> aufgerufen. Diese blockiert den aktuellen Thread, bis das Ergebnis verf\u00fcgbar ist. Future<String> future = executorService.submit(() -> \"Hello, World!\"); String result = future.get(); \/\/ Blockiert, bis das Ergebnis verf\u00fcgbar ist<\/code><\/li>\n\n\n\n
  2. Keine direkte Abbruchm\u00f6glichkeit<\/strong>: Ein Future<\/code> kann zwar \u00fcber die Methode cancel()<\/code> abgebrochen werden, bietet aber keine Mechanismen zur Abfrage, wann oder warum es abgebrochen wurde.<\/li>\n\n\n\n
  3. Eingeschr\u00e4nkte Funktionalit\u00e4t<\/strong>: Es gibt keine eingebaute Unterst\u00fctzung f\u00fcr Callback-Mechanismen oder Verkettung von Aufgaben.<\/li>\n<\/ol>\n\n\n\n
    CompletableFuture<\/h5>\n\n\n\n

    Das CompletableFuture<\/code> wurde mit Java 8 eingef\u00fchrt, um die Einschr\u00e4nkungen des Future<\/code> zu \u00fcberwinden. Es ist Teil der java.util.concurrent<\/code>-Bibliothek und unterst\u00fctzt eine umfangreiche API f\u00fcr asynchrone Programmierung. Einige Highlights:<\/p>\n\n\n\n

      \n
    1. Non-Blocking<\/strong>: Statt zu blockieren, k\u00f6nnen Callbacks registriert werden, die automatisch ausgef\u00fchrt werden, sobald das Ergebnis verf\u00fcgbar ist. CompletableFuture.supplyAsync(() -> \"Hello, World!\") .thenAccept(System.out::println);<\/code><\/li>\n\n\n\n
    2. Kombination von Aufgaben<\/strong>: CompletableFuture<\/code> erm\u00f6glicht die Verkettung mehrerer Aufgaben (z. B. thenApply<\/code>, thenCombine<\/code>).<\/li>\n\n\n\n
    3. Manuelle Kontrolle<\/strong>: Es kann manuell abgeschlossen oder beendet werden, wodurch es flexibler ist als das klassische Future<\/code>.<\/li>\n\n\n\n
    4. Unterst\u00fctzung f\u00fcr Exception-Handling<\/strong>: Methoden wie exceptionally<\/code> oder handle<\/code> erlauben eine saubere Behandlung von Fehlern.<\/li>\n<\/ol>\n\n\n\n
      \n\n\n\n

      Konvertierung eines Future in ein CompletableFuture<\/h4>\n\n\n\n

      In bestehenden Projekten ist es oft notwendig, Future<\/code>-Objekte, die von \u00e4lteren APIs bereitgestellt werden, in ein CompletableFuture<\/code> zu konvertieren, um von dessen erweiterten Funktionen zu profitieren. Dies ist leider nicht direkt in der Standardbibliothek enthalten, aber mithilfe von Hilfsfunktionen leicht realisierbar.<\/p>\n\n\n\n

      Implementierung<\/h5>\n\n\n\n

      Die Grundidee ist, ein neues CompletableFuture<\/code> zu erstellen und den Status eines gegebenen Future<\/code> darauf zu spiegeln. Hier ein m\u00f6gliches Beispiel:<\/p>\n\n\n

      import<\/span> java.util.concurrent.*;\n\npublic class<\/span> FutureConverter<\/span> <\/span>{\n\n    public static<\/span> <T> CompletableFuture<T> convertToCompletableFuture(Future<T> future) {\n        CompletableFuture<T> completableFuture = new<\/span> CompletableFuture<>();\n\n        Executors.newSingleThreadExecutor().submit(() -> {\n            try<\/span> {\n                T result = future.get();\n                completableFuture.complete(result);\n            } catch<\/span> (Exception e) {\n                completableFuture.completeExceptionally(e);\n            }\n        });\n\n        return<\/span> completableFuture;\n    }\n\n    public static<\/span> void<\/span> main(String<\/span>[] args) throws ExecutionException, InterruptedException {\n        ExecutorService executorService = Executors.newFixedThreadPool(1<\/span>);\n        Future<String<\/span>> future = executorService.submit(() -> \"Hello, CompletableFuture!\"<\/span>);\n\n        CompletableFuture<String<\/span>> completableFuture = convertToCompletableFuture(future);\n\n        completableFuture.thenAccept(System.out::println)\n                         .exceptionally(throwable -> {\n                             System.err.println(\"Fehler: \"<\/span> + throwable);\n                             return<\/span> null<\/span>;\n                         });\n\n        executorService.shutdown();\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Erkl\u00e4rung<\/h5>\n\n\n\n
        \n
      1. Neues CompletableFuture erstellen<\/strong>: Ein leeres CompletableFuture<\/code> wird erzeugt, das sp\u00e4ter mit dem Ergebnis des Future<\/code> vervollst\u00e4ndigt wird.<\/li>\n\n\n\n
      2. Thread-Executor verwenden<\/strong>: Da Future.get()<\/code> blockierend ist, muss es in einem separaten Thread ausgef\u00fchrt werden.<\/li>\n\n\n\n
      3. Ergebnis spiegeln<\/strong>: Sobald das Future<\/code> abgeschlossen ist, wird entweder das Ergebnis oder eine Ausnahme an das CompletableFuture<\/code> weitergegeben.<\/li>\n<\/ol>\n\n\n\n
        \n\n\n\n
        Vorteile der Konvertierung<\/h4>\n\n\n\n
        Die Konvertierung eines Future<\/code> in ein CompletableFuture<\/code> bietet folgende Vorteile:<\/p>\n\n\n\n
          \n
        1. Erweiterte API<\/strong>: Es kann von Methoden wie thenApply<\/code>, thenCombine<\/code> und handle<\/code> Gebrauch gemacht werden.<\/li>\n\n\n\n
        2. Non-Blocking Mechanismen<\/strong>: Statt get()<\/code> zu blockieren, k\u00f6nnen asynchrone Callbacks registriert werden.<\/li>\n\n\n\n
        3. Einfache Fehlerbehandlung<\/strong>: Mit Funktionen wie exceptionally<\/code> l\u00e4sst sich eine robuste Fehlerverarbeitung implementieren.<\/li>\n\n\n\n
        4. Flexibilit\u00e4t<\/strong>: Aufgaben k\u00f6nnen leicht kombiniert oder Ergebnisse verarbeitet werden, ohne komplexen Boilerplate-Code zu schreiben.<\/li>\n<\/ol>\n\n\n\n
          \n\n\n\n
          Einschr\u00e4nkungen<\/h4>\n\n\n\n
            \n
          • Performance-Overhead<\/strong>: Die Verwendung eines separaten Threads zur Verarbeitung des blockierenden Future.get()<\/code> kann ineffizient sein, insbesondere bei vielen Konvertierungen.<\/li>\n\n\n\n
          • Komplexit\u00e4t der Fehlerbehandlung<\/strong>: Wenn das Original-Future<\/code> unvollst\u00e4ndig bleibt, kann dies unerwartetes Verhalten hervorrufen.<\/li>\n\n\n\n
          • Zus\u00e4tzliche Ressourcen<\/strong>: Der Einsatz eines Executors zur Umwandlung erh\u00f6ht den Ressourcenbedarf.<\/li>\n<\/ul>\n\n\n\n
            \n\n\n\n
            Fazit<\/h4>\n\n\n\n
            Die Konvertierung eines Future<\/code> in ein CompletableFuture<\/code> ist ein n\u00fctzliches Werkzeug, um \u00e4lteren Code mit modernen, nicht-blockierenden APIs zu kombinieren. W\u00e4hrend Future<\/code> einfache, blockierende Abfragen bietet, erm\u00f6glicht CompletableFuture<\/code> eine umfassende und flexible Handhabung von asynchronen Aufgaben. Mit einer durchdachten Konvertierungsstrategie k\u00f6nnen Entwickler die Vorteile der modernen API nutzen, ohne auf bew\u00e4hrte, \u00e4ltere Implementierungen verzichten zu m\u00fcssen. Dennoch sollte man sich der m\u00f6glichen Performance- und Ressourcenkosten bewusst sein und diese bei der Implementierung ber\u00fccksichtigen.<\/p>\n","protected":false},"excerpt":{"rendered":"
            Die Java-Programmierung bietet verschiedene Mechanismen f\u00fcr die Arbeit mit asynchronen Aufgaben. Zwei wichtige Bestandteile in diesem Kontext sind das klassische Future-Interface und das moderner gestaltete CompletableFuture, das mit Java 8 eingef\u00fchrt wurde. W\u00e4hrend beide Konzepte asynchrone Verarbeitung erm\u00f6glichen, unterscheiden sie sich erheblich in ihren Funktionsweisen und M\u00f6glichkeiten. In diesem Artikel gehen wir darauf ein, wie […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-522","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/522","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=522"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/522\/revisions"}],"predecessor-version":[{"id":523,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/522\/revisions\/523"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=522"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=522"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=522"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}