ComplectableFuture bricht die Arbeitskette ausnahmsweise

Question

Die Idee der Verwendung CompletableFuture ist, weil es eine Kette bietet, während die ersten paar Schritte Bohnen einkapseln, bevor der letzte Schritt es verwendet. Da in diesen Schritten jede Ausnahme auftreten kann, wird exceptionally verwendet, um Fehler zu behandeln. Allerdings akzeptiert exceptionally nur Throwable Argument und bis jetzt habe ich keinen Weg gefunden, diese eingekapselten Bohnen zu greifen.

CompletableFuture.supplyAsync(this::msgSource) 
      .thenApply(this::sendMsg).exceptionally(this::errorHandler).thenAccept(this::saveResult) 
public List<Msg> msgSource() // take message from somewhere. 
public List<Msg> sendMsg(List<Msg>) // exceptions may happen like 403 or timeout 
public List<Msg> errorHandler() // set a success flag to false in Msg. 
public void saveResult(List<Msg>) // save send result like success or false in data center. 

Im obigen Beispiel sind Kommentare der Arbeitsablauf. Da jedoch errorHandler weder List<Msg> akzeptiert noch weitergibt, ist die Kette also kaputt. Wie bekomme ich die Rückkehr von msgSource?

EDIT

public class CompletableFutureTest { 

    private static Logger log = LoggerFactory.getLogger(CompletableFutureTest.class); 
    public static void main(String[] args) { 
     CompletableFutureTest test = new CompletableFutureTest(); 
     CompletableFuture future = new CompletableFuture(); 
     future.supplyAsync(test::msgSource) 
      .thenApply(test::sendMsg).exceptionally(throwable -> { 
      List<String> list = (List<String>) future.join(); // never complete 
      return list; 
     }).thenAccept(test::saveResult); 
     try { 
      future.get(); 
     } catch (InterruptedException e) { 
      e.printStackTrace(); 
     } catch (ExecutionException e) { 
      e.printStackTrace(); 
     } 
    } 

    private List<String> saveResult(List<String> list) { 
     return list; 
    } 

    private List<String> sendMsg(List<String> list) { 
     throw new RuntimeException(); 
    } 

    public List<String> msgSource() { 
     List<String> result = new ArrayList<>(); 
     result.add("1"); 
     result.add("2"); 
     return result; 
    } 
} 

Answer 1

A Kette impliziert, dass jeder Knoten, d.h. Vollendungsstufe, um das Ergebnis der vorherigen verwendet. Wenn jedoch die vorherige Stufe mit einer Ausnahme fehlgeschlagen ist, gibt es kein solches Ergebnis. Es ist eine spezielle Eigenschaft Ihrer Stufe sendMsg, dass ihr Ergebnis genau dem Wert entspricht, den sie von der vorherigen Stufe erhalten hat, aber dies hat keinen Einfluss auf die Logik und das API-Design. Wenn sendMsg mit einer Ausnahme fehlschlägt, führt dies zu keinem Ergebnis, das der Ausnahmebehandler verwenden könnte.

Wenn Sie das Ergebnis der msgSource Bühne im Ausnahmefall verwenden möchten, haben Sie keine lineare Kette mehr. Aber CompletableFuture erlaubt beliebige Abhängigkeitsgraphen zu modellieren, nicht nur lineare Ketten, so können Sie es ausdrücken wie

CompletableFuture<List<Msg>> source = CompletableFuture.supplyAsync(this::msgSource); 
source.thenApply(this::sendMsg) 
     .exceptionally(throwable -> { 
      List<Msg> list = source.join(); 
      for(Msg m: list) m.success = false; 
      return list; 
     }) 
     .thenAccept(this::saveResult); 

Allerdings gibt es keinen semantischen Unterschied noch Vorteil gegenüber

CompletableFuture.runAsync(() -> { 
    List<Msg> list = msgSource(); 
    try { 
     list = sendMsg(list); 
    } catch(Throwable t) { 
     for(Msg m: list) m.success = false; 
    } 
    saveResult(list); 
}); 

, die die gleiche Logik zum Ausdruck bringt als normaler Code-Fluss.