为列表中的每个URL发送WS请求，并将响应映射到新列表

Question

I'm developing a REST server in Play with Scala, that at some point needs to request data at one or more other web services. Based on the responses from these services the server must compose a unified result to use later on.

Example :

Event C on www.someplace.com needs to be executed. In order to execute Event C, Event A on www.anotherplace.com and Event B on www.athirdplace.com must also be executed.

Event C has a Seq(www.anotherplace.com, www.athirdplace.com) from which I would like to iterate and send a WS request to each URL respectively to check wether B and C are executed.

It is assumed that a GET to these URLs returns either true or false

How do I collect the responses from each request (preferably combined to a list) and assert that each response is equal to true ?

EDIT : An event may contain an arbitrary number of URL's. So I cant know beforehand how many WS requests i need to send.

Answer 1

Have a look at the documentation and see if you can get their example to work. Try something like this:

val futureResponse: Future[WSResponse] = for {
  responseOne <- WS.url(urlOne).get()
  responseTwo <- WS.url(responseOne.body).get()
  responseThree <- WS.url(responseTwo.body).get()
} yield responseOne && responseTwo && responseThree

You probably need to parse the response of your WebService since they (probably) won't return booleans, but you'll get the idea.

Answer 2

Short Answer

You can use sequence method available on Future object.

For example:

import scala.concurrent.Future

val urls = Seq("www.anotherplace.com", "www.athirdplace.com")
val requests = urls.map(WS.url)
val futureResponses = Future.sequence(requests.map(_.get()))

Aggregated Future

Note that the type of futureResponses will be Future[Seq[WSResponse]] . Now you can work on the results:

futureResponses.map { responses =>
  responses.map { response =>
    val body = response.body
    // do something with response body
  }
}

More Details

From ScalaDocs of sequence method:

Transforms a TraversableOnce[Future[A]] into a Future[TraversableOnce[A]]. Useful for reducing many Futures into a single Future.

Note that if any of the Future s you pass to sequence fails, the resulting Future will be failed as well. Only when all Future s are completed successfully the result will complete successfully. This is good for some purposes, especially if you want to send requests at the same time, no one after another.