Pourquoi venir récupérer pas intercepter des exceptions?

Je suis en utilisant Scala, Play Framework 2.1.x, et reactivemongo pilote.

J'ai un appel d'api :

def getStuff(userId: String) = Action(implicit request => {
    Async {
      UserDao().getStuffOf(userId = userId).toList() map {
        stuffLst => Ok(stuffLst)
      } 
    }
})

Il fonctionne très bien à 99% du temps, mais il peut manquer parfois (n'importe pas pourquoi, ce n'est pas la question).

Je voulais récupérer en cas d'erreur alors j'ai ajouté:

recover { case _ => BadRequest("")}

Mais cela ne veut pas récupérer moi de faire des erreurs.

J'ai essayé le même concept sur la scala de la console et il a travaillé:

import scala.concurrent._
import scala.concurrent.duration._
import ExecutionContext.Implicits.global
var f = future { throw new Exception("") } map {_ => 2} recover { case _ => 1}
Await.result(f, 1 nanos)

Cela renvoie 1 comme prévu.

Je suis actuellement enveloppé Async avec:

try{
  Async {...}
} catch {
  case _ => BadRequest("")
}

Et ceci intercepte les erreurs.

Je suis allé sur certains Scala Avenir de docs sur le net et je suis perplexe pourquoi récupérer n'a pas fonctionné pour moi.

Personne ne sait pourquoi? Ce qui me manque pour faire le tri?

InformationsquelleAutor samz | 2013-10-17
  1. 41

    Pourquoi il ne parvient pas réellement matière à 100%. Si nous diffuser ce code sur un certain nombre de lignes de code, vous allez comprendre pourquoi:

    def getStuff(userId: String) = Action(implicit request => {
  Async {
    val future = UserDao().getStuffOf(userId = userId).toList()
    val mappedFuture = future.map {
      stuffLst => Ok(stuffLst)
    }
    mappedFuture.recover { case _ => BadRequest("")}
  }
})

    Donc, UserDao().getStuffOf(userId = userId).toList() vous renvoie un avenir. Un futur représente peut-être pas encore arrivé. Si cette chose déclenche une exception, vous pouvez gérer cette exception à récupérer. Cependant, dans votre cas, l'erreur se passe avant que l'avenir est encore en cours de création, le UserDao().getStuffOf(userId = userId).toList() appel est de lancer une exception, pas de retour de l'avenir. Donc, l'appel de récupérer l'avenir ne sera jamais exécutée. C'est équivalent à faire à la Scala repl:

    import scala.concurrent._
import scala.concurrent.duration._
import ExecutionContext.Implicits.global
var f = { throw new Exception(""); future { "foo" } map {_ => 2} recover { case _ => 1} }
Await.result(f, 1 nanos) }

    Évidemment cela ne fonctionne pas, puisque vous n'avez jamais créé de l'avenir, en premier lieu, car l'exception a été levée avant le code pour créer l'avenir qui s'est passé.

    Donc la solution c'est soit de l'enveloppe de votre appel à UserDao().getStuffOf(userId = userId).toList() dans un bloc try catch, ou trouver pourquoi ça ne fonctionne pas quelle que soit la méthode que vous appelez, et attraper l'exception, et le retour d'un échec à l'avenir.

    • quel est exactement un "échec de l'avenir" ?
    • exception-vous pris>)
    InformationsquelleAutor James Roper
  2. 4

    Si vous avez une version plus récente de Jouer par exemple 2.2.x, vous pouvez le faire:

    def urlTest() = Action.async {
    val holder: WSRequestHolder = WS.url("www.idontexist.io")
    holder.get.map {
      response =>
        println("Yay, I worked")
        Ok
    }.recover {
      case _ =>
        Log.error("Oops, not gonna happen")
        InternalServerError("Failure")
    }
}
    InformationsquelleAutor catrapture