Was ist der Unterschied zwischen onComplete und foreach für eine Zukunft in Scala?

Question

Ich wundere mich über den Unterschied zwischen onComplete und foreach, wenn wir eine Zukunft in Scala verwenden.

f onComplete (_ => doSomething(_))

und

f foreach (_ => doSomething(_))

1. die obigen Codezeilen führen zum gleichen Ergebnis tun?

2. Wenn ich mit Future f nur etwas tun will, nachdem es fertig ist. Was soll ich machen? Soll ich IsCompleted wie folgt verwenden:

   if(f.isCompleted) f onComplete (_ => doSomething(_))

Danke Jungs viel

Answer 1

Der Hauptunterschied ist die onComplete Rückruf selbst aufgerufen wird, wenn die Zukunft mit einem Ausfall, während foreach abgeschlossen (und onSuccess) Funktionen werden nur im Falle eines erfolgreichen Ergebnisses aufgerufen.

Tatsächlich onComplete ‚s-Parameter ist eine Funktion Try[T] => U: die Funktion, die Sie mit einem Success[T] als Argument aufgerufen wird passieren, wenn die Zukunft erfolgreich ist oder mit einem Failure, wenn es eine Ausnahme:

val f = Future { ??? } // this future completes with a failure 

// foreach only calls the callback if the future is successful 
f.foreach(_ => thisWillNeverExecute()) 

// This will print "future failed" after the future completes 
f.onComplete { 
    case Success(_) => println("future completed successfully") 
    case Failure(e) => println("future failed") 
} 

Außerdem müssen Sie nichts überprüfen, um die genannten Methoden aufzurufen: onComplete/onSuccess/onFailure/foreach Planen Sie einen Rückruf, der im impliziten Format ExecutionContext aufgerufen wird, nur dann, wenn die Zukunft abgeschlossen ist.

Sie können sie auch anrufen, wenn isCompleted falsch ist, sie werden nur ausgeführt, wenn die Zukunft erfolgreich abgeschlossen wird oder fehlschlägt, je nachdem, welche Sie ausgewählt haben.

Lassen Sie uns einen Blick auf ihre Unterschriften haben:

def onComplete[U](@f: Try[T] => U)(implicit executor: ExecutionContext): Unit 

• onComplete nimmt eine Try[T] => U Funktion: Diese Funktion wird auf dem implicit executor ausgeführt werden, wenn die Zukunft abgeschlossen ist. Das Argument wird entweder ein Success[T] wenn die Zukunft erfolgreich ist oder ein Failure wenn die Zukunft nicht bestanden

---

def onFailure[U](pf: PartialFunction[Throwable, U])(implicit executor: ExecutionContext): Unit 

• onFailure Parameter sind ein PartialFunction, die nur auf den implicit executor ausgeführt wird, wenn die Zukunft nicht mit einer Throwable, für die pf definiert ist. Es ist im Grunde das gleiche wie Call onComplete nur mit einigen Failure s, und in der Tat ist es genau so, wie es in der Standard-Bibliothek implementiert ist.

---

def onSuccess[U](pf: PartialFunction[T, U])(implicit executor: ExecutionContext): Unit 

• onSuccess Parameter ist, symmetrisch zu onFailure, ein PartialFunction, die nur auf dem implicit executor ausgeführt wird, wenn die Zukunft wird erfolgreich abgeschlossen und die mitgelieferte PartialFunction für den Wert definiert.

---

def foreach[U](f: T => U)(implicit executor: ExecutionContext): Unit 

• foreach ist grundsätzlich die gleiche wie onSuccess aber es dauert eine Gesamtfunktion. Das bedeutet, dass f wird immer dann ausgeführt, wenn die Zukunft

---

N. B erfolgreich abgeschlossen .: ‚onSuccess‘ und ‚onFailure‘ werden in 2,12 veraltet werden. Ich schlage vor, Sie lesen this series of posts by Viktor Klang, um herauszufinden, wie Sie von den Änderungen betroffen sein werden