Lecture 2.1 Futures et promesses multiples de chaîne Scala

Question

J'ai une classe java existante pour le traitement des données. Comment pourrais-je utiliser le ObjectNode de la première promesse et donc plus de traitement dans mon action Scala Async?

public class JavaClass extends Controller { 
    public static Promise<ObjectNode> intensiveComputation(String imageId) { 
    } 
} 


def index = Action { 
    val futureInt = scala.concurrent.Future { JavaClass.intensiveComputation() } 
    Async { 
    futureInt.map(promise => 
     var objJs = promise.GetObjectNodeFromPromise() 
     (objJs \ Config.RESP_STATUS_PARAM).as[String] match { 
     // I WANT TO READ ObjectNode from promise and do more works here 
     } 
     Ok(Json.toJson(Map("status" -> "ok"))) 
    } 
} 

EDIT 1

J'ai essayé avec @hbf code, cependant, je me suis compiler erreur une cette ligne.

[error] found : org.codehaus.jackson.node.ObjectNode => play.api.mvc.SimpleResult[play.api.libs.json.JsValue] 
[error] required: play.libs.F.Function[org.codehaus.jackson.node.ObjectNode,?] 
[error]     var result = futureObj map { objJs: ObjectNode => 

Si je retire ObjectNode de objJs, j'ai eu cette erreur.

[error] missing parameter type 
[error]     var result = futureObj map { objJs => 

Nouveau Code

def index = Action { 
    val futureInt = JavaClass.intensiveComputation() 
    Async { 
    var result = futureObj map { objJs: ObjectNode => 
     Ok(Json.toJson(Map("status" -> "ok"))) 
    } 
    result 
} 

Answer 1

Je suppose que vous suivez le Play documentation guide, non? Tout d'abord, notez que Play est maintenant (à partir de la version 2.1) en utilisant Scala futures et de ce fait, la nomenclature a changé: votre méthode intensiveComputation() renvoie un (Scala) Future<ObjectNode> (alors qu'en pré-2.1, cela s'appelait Promise<ObjectNode>).

public class JavaClass extends Controller { 
    public static Future<ObjectNode> intensiveComputation(String imageId) { 
    /* ... */ 
    } 
} 

Notez également que dans le Play documentation example, intensiveComputation() renvoie la valeur (à savoir, ObjectNode) directement, alors que votre version retourne un avenir en maintenant la valeur (à savoir, Future<ObjectNode>). Deuxièmement, dans votre futureInt.map, la fermeture reçoit la valeur du futur et non le futur lui-même. Donc, essayez quelque chose comme:..

def index = Action { 
    val futureInt = JavaClass.intensiveComputation() // I's already a future! 
    Async { 
    futureInt.map(objJs => // `objJs` is the result of `intensiveComputation` 
     // Extract from `objJs` whatever you need ... 
     // ... and make the `Ok` call here (and not outside) 
     Ok(Json.toJson(Map("status" -> "ok"))) 
    ) 
    } 
}