Wie verschachtelte Zukunft in Scala loswerden?

Question

Ich habe Code in meiner Play-Framework-App, der eine JSON-Anfrage analysiert und sie verwendet, um die Daten eines Benutzers zu aktualisieren. Das Problem ist, dass ich eine Future[Result] zurückgeben muss, aber meine userDAO.update Funktion gibt eine Future[Int] zurück, also habe ich geschachtelte Zukünfte.

Ich habe verwendet Await, die nicht sehr gut ist. Wie kann ich diesen Code umschreiben, um die verschachtelte Zukunft zu vermeiden?

def patchCurrentUser() = Action.async { request => 
Future { 
    request.body.asJson 
}.map { 
    case Some(rawJson) => Json.fromJson[User](rawJson).map { newUser => 
    val currentUserId = 1 

    logger.info(s"Retrieving users own profile for user ID $currentUserId") 

    val futureResult: Future[Result] = userDAO.findById(currentUserId).flatMap { 
     case Some(currentUser) => 
     val mergedUser = currentUser.copy(
      firstName = newUser.firstName  // ... and the other fields 
     ) 

     userDAO.update(mergedUser).map(_ => Ok("OK")) 
     case _ => Future { Status(404) } 
    } 

    import scala.concurrent.duration._ 
    // this is bad. How can I get rid of this? 
    Await.result(futureResult, 1 seconds) 
    }.getOrElse(Status(400)) 
    case _ => Status(400) 
} 
} 

aktualisieren:

Sod Gesetz: Kurz nach dieser Entsendung ich es hat geklappt:

Future { 
    request.body.asJson 
}.flatMap { 
    case Some(rawJson) => Json.fromJson[User](rawJson).map { newUser => 
    val currentUserId = 1 
    userDAO.findById(currentUserId).flatMap { 
     case Some(currentUser) => 
     val updatedUser = currentUser.copy(
      firstName = newUser.firstName 
     ) 

     userDAO.update(updatedUser).map(_ => Ok("OK")) 
     case _ => Future { Status(404) } 
    } 
    }.getOrElse(Future(Status(400))) 
    case _ => Future(Status(400)) 
} 

Aber ist es eine elegantere Art und Weise? Es scheint, als ob ich ganz frei um Future() pfeffern würde, was wie ein Code-Geruch aussieht.

Answer 1

Verwenden Sie flatMap anstelle von map.

flatMap[A, B](f: A => Future[B]) 

map[A, B](f: A => B) 

eleganteren Weg ist for comprehension

verwenden Verwendung Zum Verständnis Code wie diesen

for { 
     jsonOpt <- Future (request.body.asJson) 
     result <- jsonOpt match { 
     case Some(json) => 
      json.validate[User] match { 
      case JsSuccess(newUser, _) => 
       for { 
       currentUser <- userDAO.findById(1) 
       _ <- userDAO.update(currentUser.copy(firstName = newUser.firstName)) 
       } yield Ok("ok") 
      case JsError(_) => Future(Status(400)) 
      } 
     case None => Future(Status(400)) 
     } 
    } yield result 

Answer 2

sieht aus, als @pamu sagte, es Ihren Code ein Bit löschen könnte, wenn Sie eine verwenden würden, zum Verständnis.

Ein anderer interessanter Ansatz (und rein in Bezug auf die funktionale Programmierung) wäre monad transformers (normalerweise ein ähnlicher Typ wie Future[Option[T]] Screams Monade Transformator) zu verwenden.

Sie sollten sich Bibliotheken wie cats (und oder scalaz) ansehen. Ich werde versuchen, eine kleine „Pseudo-Code“ Beispiel unter Verwendung von Katzen zu geben (weil ich spielen Rahmen nicht vor Ort habe):

import cats.data.OptionT 
import cats.instances.future._ 
import scala.concurrent.ExecutionContext.Implicits.global 
import scala.concurrent.Future 

def convertJsonToUser(json: Json): Future[Option[User]] = Json.fromJson[User](json) 
def convertBodyToJson(request: Request): Future[Option[Json]] = Future {request.body.asJson} 
def updateUser(user: User): Future[HttpResult] = Future { 
    // update user 
    Ok("ok") 
} 

def myFunction: Future[HttpResult] = { 
    val resultOpt: OptionT[Future, HttpResult] = for { 
    json <- OptionT(convertBodyToJson(request)) 
    user <- OptionT(convertJsonToUser(json)) 
    result <- OptionT.lift(updateUser(user)) 
    } yield result 
    result.getOrElseF(Future {Status(400)}) 
} 

Wie Sie sehen können, in diesem Fall der Monade Transformatoren ermöglichen, eine Art zu behandeln wie Future[Option[T]] als ein einzelner "Kurzschluss" -Typ (z. B. wird das Verständnis zu stoppen, wenn Sie entweder eine gescheiterte Zukunft haben, oder eine Zukunft, die keine enthält).