Scala wiederherstellen oder wiederherstellen

Entwickeln wir einige Systeme in unserem Unternehmen in Scala, und wir haben einige Zweifel. Wir diskutierten darüber, wie die Karte der Zukunft Ausnahmen und wir wissen nicht, Wann sollte man mit der option 1 oder der option 2.

val created: Future[...] = ???

Option 1: 

val a = created recover {   
  case e: database.ADBException =>
    logger.error("Failed ...", e)
    throw new business.ABusinessException("Failed ...", e) 
}

Option 2:

val a = created recoverWith {   
  case e: database.ADBException =>
    logger.error("Failed ...", e)
    Future.failed(new business.ABusinessException("Failed ...", e))
}

Könnte jemand erklären, Wann sollte ich die option 1 oder der option 2? Was ist der Unterschied?

InformationsquelleAutor der Frage Henrique Goulart | 2016-04-12

  1. 51

    Nun, die Antwort ist klar beschrieben in scaladocs:

      /** Creates a new future that will handle any matching throwable that this
   *  future might contain. If there is no match, or if this future contains
   *  a valid result then the new future will contain the same.
   *
   *  Example:
   *
   *  {{{
   *  Future (6 /0) recover { case e: ArithmeticException => 0 } //result: 0
   *  Future (6 /0) recover { case e: NotFoundException   => 0 } //result: exception
   *  Future (6 /2) recover { case e: ArithmeticException => 0 } //result: 3
   *  }}}
   */
  def recover[U >: T](pf: PartialFunction[Throwable, U])(implicit executor: ExecutionContext): Future[U] = {

  /** Creates a new future that will handle any matching throwable that this
   *  future might contain by assigning it a value of another future.
   *
   *  If there is no match, or if this future contains
   *  a valid result then the new future will contain the same result.
   *
   *  Example:
   *
   *  {{{
   *  val f = Future { Int.MaxValue }
   *  Future (6 /0) recoverWith { case e: ArithmeticException => f } //result: Int.MaxValue
   *  }}}
   */
  def recoverWith[U >: T](pf: PartialFunction[Throwable, Future[U]])(implicit executor: ExecutionContext): Future[U] = {

    recover wraps Ebene führen Future für Sie (Analog map), während recoverWith erwartet Future als das Ergebnis (Analog flatMap).

    So, hier ist die Faustregel:

    Wenn Sie wieder mit etwas bereits gibt Future verwenden recoverWith verwenden, ansonsten recover.

    upd
    In deinem Fall, mit recover wird bevorzugt, da recover wird wickeln Sie Ihre Ausnahme in Future für Sie. Ansonsten gibt es keinen performance-Gewinn oder nichts, so kann man einfach vermeiden, dass einige boilerplate.

    InformationsquelleAutor der Antwort Aivean

  2. 6

    Mit recoverWith Sie werden gebeten, die Rückgabe einem verpackt Zukunft, mit recover Sie gefragt werden, um eine exception zu werfen.

    .recoverWith # => Future.failed(t)
.recover # => throw t

    Ich lieber mit recoverWith weil ich denke, die funktionale Programmierung bevorzugt Rücksendung Objekte als das werfen von Ausnahmen, die weniger von einem funktionalen Stil, auch wenn es interne code-block, ich denke, es hält immer noch..

    Jedoch, wenn ich einen internen code in das recovery-block, der eine Ausnahme auslösen könnte dann, in diesem Fall, anstatt fangen und wickeln Sie es mit Future oder es zu Versuchen, könnte ich genauso gut laufen dieses Stück code in Kombination mit recover und es würde die Ausnahme behandeln Verpackung für Sie, die machen den code besser lesbar und kompakt.

    InformationsquelleAutor der Antwort Tomer Ben David

Schreibe einen Kommentar