Futures - carte vs flatmap

J'ai lu les docs sur map et flatMap et je comprends que flatMap est utilisé pour une opération qui accepte un Future paramètre et renvoie une autre Future. Ce que je n'ai pas entièrement comprendre, c'est pourquoi je veux le faire. Prenez cet exemple:

  1. Utilisateur accède à mon webservice demandant de "faire des trucs"
  2. - Je télécharger un fichier (qui est lent)
  3. - Je traiter le fichier (qui est consommateur d'UC)
  4. Rendre le résultat

Je comprends que j'ai envie d'utiliser un avenir pour télécharger le fichier, mais j'ai deux options re de traitement:

val downloadFuture = Future { downloadFile }
val processFuture = downloadFuture map { processFile }
processFuture onSuccess { case r => renderResult(r) }

ou

val downloadFuture = Future { //download the file }
val processFuture = downloadFuture flatMap { Future { processFile } }
processFuture onSuccess { case r => renderResult(r) }

En ajoutant des instructions de débogage (Thread.currentThread().getId) je vois que dans les deux cas de téléchargement, process et render se produire dans le même thread (à l'aide de ExecutionContext.Implicits.global).

Aurais-je utiliser flatMap simplement à découpler downloadFile et processFile et de s'assurer que processFile s'exécute toujours dans un Future même si elle n'a pas été cartographiés à partir de downloadFile?

source d'informationauteur

  1. 18

    s'assurer que processFile s'exécute toujours dans un Future même si elle n'a pas été cartographiés à partir de downloadFile?

    Oui, c'est correct.

    Cependant la plupart du temps, vous ne l'utilisez Future { ... } directement, vous pouvez utiliser les fonctions (d'autres bibliothèques ou de votre propre) qui renvoie un Future.

    Imaginer les fonctions suivantes :

    def getFileNameFromDB{id: Int) : Future[String] = ???
def downloadFile(fileName: String) : Future[java.io.File] = ???
def processFile(file: java.io.File) : Future[ProcessResult] = ???

    Vous pouvez utiliser flatMap de les combiner entre eux :

    val futResult: Future[ProcessResult] =
  getFileNameFromDB(1).flatMap( name =>
    downloadFile(name).flatMap( file =>
       processFile(file)
    )
  )

    Ou à l'aide d'une compréhension :

    val futResult: Future[ProcessResult] =
  for {
    name <- getFileNameFromDB(1)
    file <- downloadFile(name)
    result <- processFile(file)
  } yield result

    La plupart du temps vous ne les qualifierais pas de onSuccess (ou onComplete). En utilisant l'une de ces fonctions, vous inscrire à une fonction de rappel qui sera exécutée lorsque le Future finitions.

    Si, dans notre exemple, vous voulez rendre le résultat du traitement d'un fichier, vous seriez de retour à quelque chose comme Future[Result] au lieu de l'appeler futResult.onSuccess(renderResult). Dans le dernier cas, votre type de retour serait Unitde sorte que vous ne pouvez pas vraiment retourner quelque chose.

    En Jeu Cadre de ce qui pourrait ressembler à :

    def giveMeAFile(id: Int) = Action.async {
  for {
    name <- getFileNameFromDB(1)
    file <- downloadFile(name)
    processed <- processFile(file)
  } yield Ok(processed.byteArray).as(processed.mimeType))
}
  2. 17

    Si vous avez un avenir, disons, Future[HttpResponse]et que vous souhaitez spécifier de quoi faire avec ce résultat, quand il est prêt, comme écrire le corps d'un fichier, vous pouvez faire quelque chose comme responseF.map(response => write(response.body). Toutefois, si write est également une méthode asynchrone qui renvoie un futur, ce map appel renvoie un type comme Future[Future[Result]].

    Dans le code suivant:

    import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

val numF = Future{ 3 }

val stringF = numF.map(n => Future(n.toString))

val flatStringF = numF.flatMap(n => Future(n.toString))

    stringF est de type Future[Future[String]] tout flatStringF est de type Future[String]. La plupart seraient d'accord, la seconde est plus utile. Plat de la Carte est donc utile pour la rédaction de plusieurs contrats à terme ensemble.

    Lorsque vous utilisez for interprétations avec des contrats à Terme, sous le capot flatMap est utilisé ensemble avec map.

    import scala.concurrent.{Await, Future}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

val threeF = Future(3)
val fourF = Future(4)
val fiveF = Future(5)

val resultF = for{
  three <- threeF
  four <- fourF
  five <- fiveF
}yield{
  three * four * five
}

Await.result(resultF, 3 seconds)

    Ce code rendement: 60.

    Sous le capot, scala traduit ce à 

    val resultF = threeF.flatMap(three => fourF.flatMap(four => fiveF.map(five => three * four * five)))
  3. 1
    def flatMap[B](f: A => Option[B]): Option[B] = 
  this match {
    case None => None
    case Some(a) => f(a)
  }

    C'est un exemple simple, où comment la flatMap travaille pour l'Option, cela peut aider à mieux comprendre, C'est en fait la composition n'est pas l'ajout d'un wrapper de nouveau.C'est ce que nous avons besoin.