[et_pb_section fb_built=“1″ fullwidth=“on“ _builder_version=“4.4.1″][et_pb_fullwidth_post_title meta=“off“ featured_placement=“background“ _builder_version=“4.6.6″ title_font=“||||||||“ title_text_color=“#ff6317″ title_font_size=“3.5em“ meta_font=“|300|||||||“ meta_text_color=“#ffffff“ meta_font_size=“1em“ background_enable_color=“off“ use_background_color_gradient=“on“ background_color_gradient_start=“rgba(248,248,248,0.85)“ background_color_gradient_end=“rgba(248,248,248,0.75)“ background_color_gradient_overlays_image=“on“ min_height=“20vh“ height=“400px“ custom_padding=“6vh||6vh||false|false“ locked=“off“][\/et_pb_fullwidth_post_title][\/et_pb_section][et_pb_section fb_built=“1″ admin_label=“intro“ _builder_version=“4.4.6″ custom_padding=“|||0px||“ locked=“off“][et_pb_row use_custom_gutter=“on“ _builder_version=“4.4.6″ custom_margin=“||||false|false“ custom_padding=“6vh||||false|false“ border_color_left=“rgba(0,0,0,0)“][et_pb_column type=“4_4″ _builder_version=“4.4.1″][et_pb_text _builder_version=“4.7.7″ text_font=“||||||||“ text_font_size=“1.1em“ text_line_height=“1.6em“ quote_font=“|700|||||||“ quote_text_align=“left“ quote_font_size=“16px“ header_2_text_color=“#ff6317″ header_2_font_size=“1.5em“ header_2_line_height=“0.9em“ header_3_font_size=“23px“ header_4_font=“||||||||“ header_4_font_size=“16px“ header_4_line_height=“1.5em“ header_5_font_size=“14px“ custom_margin=“||||false|false“ custom_padding=“||||false|false“ hover_enabled=“0″ border_color_left=“#ff6317″ sticky_enabled=“0″]<\/p>\n
In einem fr\u00fcheren Artikel<\/a> haben wir besprochen, wie wichtig es f\u00fcr das Softwareentwicklungsteam ist, die Gesch\u00e4ftslogik einer Softwarel\u00f6sung\/eines Softwareprodukts sowie die angestrebten Funktionen und Features zu verstehen. Die wichtigsten Ergebnisse sind ein starker Fokus auf das, was aus gesch\u00e4ftlicher Sicht am wichtigsten ist, weniger Nacharbeit und saubere Release-Pl\u00e4ne.<\/p>\n Aber das Verstehen der Ziele einer Softwarel\u00f6sung\/eines Softwareprodukts kann auch einige der kleineren Details beeinflussen \u2013 zum Beispiel, was passiert, wenn der Benutzer auf eine Schaltfl\u00e4che oder einen Link klickt. Im einfachsten Fall wird die gew\u00fcnschte Aktion ausgef\u00fchrt, und das Ergebnis wird sofort erreicht\/angezeigt (d. h., es folgt ein synchroner Prozess). In anderen F\u00e4llen muss der Benutzer m\u00f6glicherweise auf ein Ergebnis warten, w\u00e4hrend Teile der Oberfl\u00e4che vor\u00fcbergehend unzug\u00e4nglich\/deaktiviert sind (d. h. w\u00e4hrend eines asynchronen Prozesses).<\/p>\n Die Wait-\/No-Wait-F\u00e4lle werden vom Product Owner entschieden und vom Softwareentwicklungsteam als sich gegenseitig ausschlie\u00dfende synchrone\/asynchrone Prozesse implementiert:<\/p>\n Asynchrone Prozesse k\u00f6nnen auf viele verschiedene Arten verwendet\/implementiert werden. Wir schauen uns f\u00fcnf konkrete Situationen an:<\/p>\n [\/et_pb_text][\/et_pb_column][\/et_pb_row][et_pb_row use_custom_gutter=“on“ _builder_version=“4.7.7″ custom_margin=“||||false|false“ custom_padding=“6vh||||false|false“ border_color_left=“rgba(0,0,0,0)“][et_pb_column type=“4_4″ _builder_version=“4.4.1″][et_pb_text _builder_version=“4.7.7″ text_font=“||||||||“ text_font_size=“1.1em“ text_line_height=“1.6em“ quote_font=“|700|||||||“ quote_text_align=“left“ quote_font_size=“16px“ header_2_text_color=“#ff6317″ header_2_font_size=“1.5em“ header_2_line_height=“0.9em“ header_3_font_size=“23px“ header_4_font=“||||||||“ header_4_font_size=“16px“ header_4_line_height=“1.5em“ header_5_font_size=“14px“ custom_margin=“||||false|false“ custom_padding=“||||false|false“ border_color_left=“#ff6317″]<\/p>\n Einige der Benutzer werden Vorg\u00e4nge durchf\u00fchren, die auch andere Benutzer betreffen \u2013 zum Beispiel einen Kommentar zu einem Artikel hinterlassen, der von jemand anderem erstellt wurde. In diesem Fall wollen wir den Kommentar im Backend speichern und den Autor des Artikels \u00fcber den neuen Kommentar informieren. Wenn der Benutzer auf \u201eKommentar speichern\u201c klickt, wird der einzelne Backend-Aufruf daher zwei Dinge tun: den eigentlichen Kommentar speichern und eine E-Mail an den Ersteller des Artikels senden.<\/p>\n Das Speichern des eigentlichen Kommentars wird sofort durchgef\u00fchrt, da der anfragende Benutzer die R\u00fcckmeldung ben\u00f6tigt, dass er gespeichert wurde. Aber das Versenden der E-Mail ist nicht etwas, das den anfragenden Benutzer betrifft, also wird das Backend einen asynchronen Prozess ausl\u00f6sen, ohne auf das eigentliche Ergebnis zu warten. Das bedeutet eine schnellere Antwortzeit f\u00fcr die Benutzer und keine Bel\u00e4stigung mit Fehlermeldungen, wenn beim Versenden der E-Mail etwas schiefl\u00e4uft.[\/et_pb_text][\/et_pb_column][\/et_pb_row][et_pb_row _builder_version=“4.7.7″ custom_margin=“||||false|false“ custom_padding=“20px||0px||false|false“ border_color_left=“rgba(0,0,0,0)“ locked=“off“][et_pb_column type=“4_4″ _builder_version=“4.4.1″][et_pb_gallery gallery_ids=“7292″ fullwidth=“on“ hover_icon=“%%186%%“ _builder_version=“4.7.7″ _module_preset=“default“ max_width=“65%“ module_alignment=“left“][\/et_pb_gallery][et_pb_code _builder_version=“4.7.7″ _module_preset=“default“][\/et_pb_code][\/et_pb_column][\/et_pb_row][et_pb_row use_custom_gutter=“on“ _builder_version=“4.7.7″ custom_margin=“||||false|false“ custom_padding=“20px||0px||false|true“ border_color_left=“rgba(0,0,0,0)“ locked=“off“][et_pb_column type=“4_4″ _builder_version=“4.4.1″][et_pb_text _builder_version=“4.7.7″ text_font=“||||||||“ text_font_size=“1.1em“ text_line_height=“1.6em“ quote_font=“|700|||||||“ quote_text_align=“left“ quote_font_size=“16px“ header_2_text_color=“#ff6317″ header_2_font_size=“1.5em“ header_2_line_height=“0.9em“ header_3_font_size=“23px“ header_4_font=“||||||||“ header_4_font_size=“16px“ header_4_line_height=“1.5em“ header_5_font_size=“14px“ custom_margin=“20px||||false|false“ custom_padding=“||||false|false“ border_color_left=“#ff6317″]Hier ist ein Code-Beispiel f\u00fcr einen Backend-Ablauf, und zwar in dem entsprechenden Dienst, der das Speichern der Kommentare \u00fcbernimmt:[\/et_pb_text][et_pb_text _builder_version=“4.7.7″ text_font=“|300|||||||“ text_font_size=“1em“ text_line_height=“1.3em“ quote_font=“|700|||||||“ quote_text_align=“left“ quote_font_size=“1em“ header_2_text_color=“#ff6317″ header_2_font_size=“1.5em“ header_2_line_height=“0.9em“ header_3_font_size=“23px“ header_4_font=“||||||||“ header_4_font_size=“16px“ header_4_line_height=“1.5em“ header_5_font_size=“14px“ background_color=“#f8f8f8″ custom_margin=“20px|||20px|false|false“ custom_padding=“||||false|false“ border_color_left=“rgba(0,0,0,0)“ border_style_left=“none“ locked=“off“]<\/p>\n [\/et_pb_text][et_pb_text _builder_version=“4.7.7″ text_font=“||||||||“ text_font_size=“1.1em“ text_line_height=“1.6em“ quote_font=“|700|||||||“ quote_text_align=“left“ quote_font_size=“16px“ header_2_text_color=“#ff6317″ header_2_font_size=“1.5em“ header_2_line_height=“0.9em“ header_3_font_size=“23px“ header_4_font=“||||||||“ header_4_font_size=“16px“ header_4_line_height=“1.5em“ header_5_font_size=“14px“ custom_margin=“20px||||false|false“ custom_padding=“||||false|false“ border_color_left=“#ff6317″]<\/p>\n Sie k\u00f6nnen sehen, dass mailService.sendCommentSavedNotification(…)<\/em> wie ein normaler Methodenaufruf aussieht. Aber aufgrund der @Async-Annotation auf der eigentlichen Methodenimplementierung greift Spring ein und tut etwas im Hintergrund: Es verwendet einen ThreadExecutor<\/em>, um einen neuen Thread zu erzeugen. (Die eigentliche Ausf\u00fchrung dieser Methode findet in diesem neuen Thread statt.) Daher wird der Befehl mailService.sendCommentSavedNotification<\/em> sofort zur\u00fcckgegeben. Der ThreadExecutor ist, wenn er nicht explizit in der Anwendung definiert ist, der Standard-ThreadExecutor von Spring (SimpleAsyncTaskExecutor<\/em>), und das Einzige, was Sie tun m\u00fcssen, ist, ihn in einer Konfigurationsdatei wie dieser zu aktivieren:<\/p>\n [\/et_pb_text][et_pb_text _builder_version=“4.7.7″ text_font=“|300|||||||“ text_font_size=“1em“ text_line_height=“1.3em“ quote_font=“|700|||||||“ quote_text_align=“left“ quote_font_size=“1em“ header_2_text_color=“#ff6317″ header_2_font_size=“1.5em“ header_2_line_height=“0.9em“ header_3_font_size=“23px“ header_4_font=“||||||||“ header_4_font_size=“16px“ header_4_line_height=“1.5em“ header_5_font_size=“14px“ background_color=“#f8f8f8″ custom_margin=“20px|||20px|false|false“ custom_padding=“||||false|false“ border_color_left=“rgba(0,0,0,0)“ border_style_left=“none“ locked=“off“]<\/p>\n [\/et_pb_text][\/et_pb_column][\/et_pb_row][et_pb_row use_custom_gutter=“on“ _builder_version=“4.7.7″ custom_margin=“||||false|false“ custom_padding=“6vh||||false|false“ border_color_left=“rgba(0,0,0,0)“][et_pb_column type=“4_4″ _builder_version=“4.4.1″][et_pb_text _builder_version=“4.7.7″ text_font=“||||||||“ text_font_size=“1.1em“ text_line_height=“1.6em“ quote_font=“|700|||||||“ quote_text_align=“left“ quote_font_size=“16px“ header_2_text_color=“#ff6317″ header_2_font_size=“1.5em“ header_2_line_height=“0.9em“ header_3_font_size=“23px“ header_4_font=“||||||||“ header_4_font_size=“16px“ header_4_line_height=“1.5em“ header_5_font_size=“14px“ custom_margin=“||||false|false“ custom_padding=“||||false|false“ border_color_left=“#ff6317″]<\/p>\n Ein weiterer Anwendungsfall ist das Hochladen mehrerer Dokumente auf einmal, um sie an einen Artikel anzuh\u00e4ngen. Die Dokumente befinden sich m\u00f6glicherweise auf einem Server eines Drittanbieters, was bedeutet, dass das Hochladen einige Zeit in Anspruch nehmen kann. W\u00e4hrend der Wartezeit kann der Benutzer einen Ladebalken sehen und den Vorgang abbrechen.<\/p>\n Wie das funktioniert?<\/p>\n Das Frontend sendet die Dokumente an das Backend und erh\u00e4lt eine Prozess-ID. Mit dieser Prozess-ID kann das Frontend das Hochladen des Dokuments jederzeit abbrechen (wenn der Benutzer auf die Schaltfl\u00e4che Abbrechen klickt), indem es einen Abbruchaufruf durchf\u00fchrt und die Prozess-ID \u00fcbergibt.<\/p>\n Dies ist nur m\u00f6glich, weil das Hochladen von Dokumenten im Backend asynchron abl\u00e4uft, und das Backend die Prozess-ID zur\u00fcckgeben kann, bevor der Upload abgeschlossen ist. Damit der Dokumenten-Upload-Prozess den Abbruch unterst\u00fctzt, muss er aktiv auf Abbruchaktionen pr\u00fcfen und er muss wissen, wann er beendet ist.<\/p>\n Wir erhalten also einen komplexeren Prozess, der gestartet, beendet oder abgebrochen werden kann. Alle diese Prozessstadien werden in einer Ereignistabelle gehalten, die sowohl vom Frontend als auch vom Backend verwendet wird, um den Fortschritt zu verfolgen und dem Benutzer ein Ergebnis anzuzeigen, wenn der Prozess (erfolgreich oder mit Fehlern) beendet ist.[\/et_pb_text][\/et_pb_column][\/et_pb_row][et_pb_row _builder_version=“4.7.7″ custom_margin=“||||false|false“ custom_padding=“20px||0px||false|false“ border_color_left=“rgba(0,0,0,0)“ locked=“off“][et_pb_column type=“4_4″ _builder_version=“4.4.1″][et_pb_gallery gallery_ids=“7300″ fullwidth=“on“ hover_icon=“%%186%%“ _builder_version=“4.7.7″ _module_preset=“default“ max_width=“65%“ module_alignment=“left“][\/et_pb_gallery][et_pb_code _builder_version=“4.7.7″ _module_preset=“default“][\/et_pb_code][\/et_pb_column][\/et_pb_row][et_pb_row use_custom_gutter=“on“ _builder_version=“4.7.7″ custom_margin=“||||false|false“ custom_padding=“20px||0px||false|true“ border_color_left=“rgba(0,0,0,0)“ locked=“off“][et_pb_column type=“4_4″ _builder_version=“4.4.1″][et_pb_text _builder_version=“4.7.7″ text_font=“||||||||“ text_font_size=“1.1em“ text_line_height=“1.6em“ quote_font=“|700|||||||“ quote_text_align=“left“ quote_font_size=“16px“ header_2_text_color=“#ff6317″ header_2_font_size=“1.5em“ header_2_line_height=“0.9em“ header_3_font_size=“23px“ header_4_font=“||||||||“ header_4_font_size=“16px“ header_4_line_height=“1.5em“ header_5_font_size=“14px“ custom_margin=“20px||||false|false“ custom_padding=“||||false|false“ border_color_left=“#ff6317″]Hier ist ein Codebeispiel f\u00fcr die Backend-Endpunkte, die vom Frontend verwendet werden:[\/et_pb_text][et_pb_text _builder_version=“4.7.7″ text_font=“|300|||||||“ text_font_size=“1em“ text_line_height=“1.3em“ quote_font=“|700|||||||“ quote_text_align=“left“ quote_font_size=“1em“ header_2_text_color=“#ff6317″ header_2_font_size=“1.5em“ header_2_line_height=“0.9em“ header_3_font_size=“23px“ header_4_font=“||||||||“ header_4_font_size=“16px“ header_4_line_height=“1.5em“ header_5_font_size=“14px“ background_color=“#f8f8f8″ custom_margin=“20px|||20px|false|false“ custom_padding=“||||false|false“ border_color_left=“rgba(0,0,0,0)“ border_style_left=“none“ locked=“off“]<\/p>\n [\/et_pb_text][et_pb_text _builder_version=“4.7.7″ text_font=“||||||||“ text_font_size=“1.1em“ text_line_height=“1.6em“ quote_font=“|700|||||||“ quote_text_align=“left“ quote_font_size=“16px“ header_2_text_color=“#ff6317″ header_2_font_size=“1.5em“ header_2_line_height=“0.9em“ header_3_font_size=“23px“ header_4_font=“||||||||“ header_4_font_size=“16px“ header_4_line_height=“1.5em“ header_5_font_size=“14px“ custom_margin=“20px||||false|false“ custom_padding=“||||false|false“ border_color_left=“#ff6317″]<\/p>\n Wie Sie sehen k\u00f6nnen, haben wir<\/p>\n [\/et_pb_text][\/et_pb_column][\/et_pb_row][et_pb_row use_custom_gutter=“on“ _builder_version=“4.7.7″ custom_margin=“||||false|false“ custom_padding=“6vh||||false|false“ border_color_left=“rgba(0,0,0,0)“][et_pb_column type=“4_4″ _builder_version=“4.4.1″][et_pb_text _builder_version=“4.7.7″ text_font=“||||||||“ text_font_size=“1.1em“ text_line_height=“1.6em“ quote_font=“|700|||||||“ quote_text_align=“left“ quote_font_size=“16px“ header_2_text_color=“#ff6317″ header_2_font_size=“1.5em“ header_2_line_height=“0.9em“ header_3_font_size=“23px“ header_4_font=“||||||||“ header_4_font_size=“16px“ header_4_line_height=“1.5em“ header_5_font_size=“14px“ custom_margin=“||||false|false“ custom_padding=“||||false|false“ border_color_left=“#ff6317″]<\/p>\n Ein weiteres Nutzungsszenario: Der Benutzer m\u00f6chte eine Aktion ausf\u00fchren, aber das Backend muss pr\u00fcfen, ob er autorisiert ist, bevor die Anfragen tats\u00e4chlich ausgef\u00fchrt werden. Je nach Kontext ist die Autorisierung nicht einfach, und es k\u00f6nnen komplexe Berechnungen erforderlich sein. In unserem Beispiel unten muss die Autorisierung an mehreren Stellen \/ \u00fcber mehrere Prozesse hinweg gepr\u00fcft werden, wobei jeder Microprozess sein eigenes Autorisierungsergebnis liefert.<\/p>\n Konkreter: Ein Anwendungsbenutzer m\u00f6chte einen Kommentar zu einem vorhandenen Element abgeben (siehe 1. oben). Abh\u00e4ngig von der Gesch\u00e4ftslogik k\u00f6nnten nur bestimmte Benutzer berechtigt sein, Kommentare zu posten. Um die Berechtigungen eines Benutzers zu pr\u00fcfen, muss das Backend m\u00f6glicherweise mehrere Aufrufe an verschiedene Microservices durchf\u00fchren. Um dies zu beschleunigen, sollten alle diese Aufrufe parallel initiiert werden.<\/p>\n [\/et_pb_text][\/et_pb_column][\/et_pb_row][et_pb_row _builder_version=“4.7.7″ custom_margin=“||||false|false“ custom_padding=“20px||0px||false|false“ border_color_left=“rgba(0,0,0,0)“ locked=“off“][et_pb_column type=“4_4″ _builder_version=“4.4.1″][et_pb_gallery gallery_ids=“7306″ fullwidth=“on“ hover_icon=“%%186%%“ _builder_version=“4.7.7″ _module_preset=“default“ max_width=“65%“ module_alignment=“left“][\/et_pb_gallery][et_pb_code _builder_version=“4.7.7″ _module_preset=“default“][\/et_pb_code][\/et_pb_column][\/et_pb_row][et_pb_row use_custom_gutter=“on“ _builder_version=“4.7.7″ custom_margin=“||||false|false“ custom_padding=“20px||0px||false|true“ border_color_left=“rgba(0,0,0,0)“ locked=“off“][et_pb_column type=“4_4″ _builder_version=“4.4.1″][et_pb_text _builder_version=“4.7.7″ text_font=“||||||||“ text_font_size=“1.1em“ text_line_height=“1.6em“ quote_font=“|700|||||||“ quote_text_align=“left“ quote_font_size=“16px“ header_2_text_color=“#ff6317″ header_2_font_size=“1.5em“ header_2_line_height=“0.9em“ header_3_font_size=“23px“ header_4_font=“||||||||“ header_4_font_size=“16px“ header_4_line_height=“1.5em“ header_5_font_size=“14px“ custom_margin=“20px||||false|false“ custom_padding=“||||false|false“ border_color_left=“#ff6317″]<\/p>\n Hier kommt Javas CompletableFuture<\/em> zur Hilfe:<\/p>\n [\/et_pb_text][et_pb_text _builder_version=“4.7.7″ text_font=“|300|||||||“ text_font_size=“1em“ text_line_height=“1.3em“ quote_font=“|700|||||||“ quote_text_align=“left“ quote_font_size=“1em“ header_2_text_color=“#ff6317″ header_2_font_size=“1.5em“ header_2_line_height=“0.9em“ header_3_font_size=“23px“ header_4_font=“||||||||“ header_4_font_size=“16px“ header_4_line_height=“1.5em“ header_5_font_size=“14px“ background_color=“#f8f8f8″ custom_margin=“20px|||20px|false|false“ custom_padding=“||||false|false“ border_color_left=“rgba(0,0,0,0)“ border_style_left=“none“ locked=“off“]<\/p>\n\n
\n
1. Versenden einer Benachrichtigungsmail am Ende eines Benutzervorgangs, an dem auch andere Benutzer beteiligt sind<\/h2>\n
public<\/span> class<\/span> CommentService {<\/span>\n \n\tpublic<\/span> void<\/span> saveComment(<\/span>String<\/span> id, CommentRequest comment)<\/span> {<\/span>\n \n\t\tItem item =<\/span> itemService.getItem<\/span>(<\/span>id)<\/span>.orElseThrow<\/span>(<\/span>ItemNotFoundException::<\/span>new<\/span>)<\/span>;<\/span>\n\t\tUser userToNotify =<\/span> userService.get<\/span>(<\/span>item.getCreator<\/span>)<\/span>.orElseThrow<\/span>(<\/span>UserNotFoundException::<\/span>new<\/span>)<\/span>\n \n\t\tcommentService.save<\/span>(<\/span>comment)<\/span>;<\/span>\n\t\tmailService.sendCommentSavedNotification<\/span>(<\/span>userToNotify, comment)<\/span>;<\/span>\n\t}<\/span>\n}<\/span>\n \n \npublic<\/span> class<\/span> EmailService {<\/span>\n \n\t@Async\n\tpublic<\/span> void<\/span> sendCommentSavedNotification(<\/span>User userToNotify, Item item)<\/span> {<\/span>\n \n\t\tMimeMessageHelper mimeMessage =<\/span> \/\/prepare your email content here<\/span>\n\t\tjavaMailSender.send<\/span>(<\/span>mimeMessage)<\/span>;<\/span>\n\t}<\/span>\n}<\/span><\/pre>\n@Configuration\n@EnableAsync\npublic<\/span> class<\/span> AsyncConfiguration implements<\/span> AsyncConfigurer {<\/span>\/\/no special body needed yet}<\/span><\/pre>\n2. Hochladen mehrerer Dokumente mit Abbruchfunktion<\/h2>\n
public<\/span> class<\/span> DocumentController {<\/span>\n \n\t@PostMapping(<\/span>\"\/files\"<\/span>)<\/span>\/\/start multiple upload, return processId right away<\/span>\n\tpublic<\/span> ResponseEntity<<\/span>ProcessIdResult><\/span> uploadDocuments(<\/span>@Valid @NotNull @RequestPart(<\/span>\"files\"<\/span>)<\/span> List<<\/span>MultipartFile><\/span> files,\n\t\t\t@RequestParam(<\/span>\"item\"<\/span>)<\/span> String<\/span> itemId)<\/span> {<\/span>\n\t\tString<\/span> processId =<\/span> ULID.nextUlid<\/span>(<\/span>)<\/span>;<\/span>\/\/generate random Id\n
3. Komplexe Berechnungen im Backend, die durch eine Benutzeraktion angefordert werden<\/h2>\n
public<\/span> class<\/span> AuthorizationService {<\/span>\n \n\tpublic<\/span> boolean<\/span> hasAccess(<\/span>User user, Item item)<\/span> {<\/span>\n\t\tList<<\/span>CompletableFuture<<\/span>Boolean>><\/span> parallelRequests =<\/span> new<\/span> ArrayList<><\/span>(<\/span>)<\/span>;<\/span>\n\t\tCompletableFuture<<\/span>Boolean><\/span> hasRightsInService1Future =<\/span> createFutureCallService1(<\/span>user, item)<\/span>;<\/span>\n\t\tCompletableFuture<<\/span>Boolean><\/span> hasRightsInService1Future =<\/span> createFutureCallService2(<\/span>user, item)<\/span>;<\/span>\n \n\t\t\/\/run the http calls in parallel<\/span>\n\t\tCompletableFuture<<\/span>Void><\/span> combinedFuture =<\/span> CompletableFuture.allOf<\/span>(<\/span>parallelRequests.toArray<\/span>(<\/span>new<\/span> CompletableFuture[<\/span>]<\/span>{<\/span>}<\/span>)<\/span>)<\/span>;<\/span>\n \n\t\t