Question

我正在使用Akka HTTP，我有一个查询URL的客户端。代码是这样的：

def f1(): Future[HttpResponse] =  { ... }

我想写一个f2函数，它接受HttpRespons e但将其转换为Future[String]，其中String是消息的正文。所以我在寻找：

def f2(): Future[String] = f1().map(...)

我无法将其转换为正常工作。

问题＃1 ：我认为这更像是一个基本的Scala问题。我将如何转换这个未来？我能得到的最好的是：

def f2:Future[String] = {
 f1().map (_.entity.toStrict(300.milli).map(_.data.utf8String))
}

由于我最终得到Future[Future[String]]

，因此无效

问题＃2 ：这是我理解的akka-http问题。

f1().map(_.toStrict())是否意味着f1().map(_.entity.toStrict())？

如果是这样，我如何访问实体而不必同时调用它？

Answer 1

// 1.您可以使用for comprehension（使用Option [Option [T]]，Future [Future [T]]，Try [Try [T]）或flatMap或.map {_ pipeTo self}（如果在一个演员）。

val httpResponseF: Future[HttpResponse] = Future.successful(HttpResponse(entity = HttpEntity.Strict(ContentTypes.`text/plain(UTF-8)`, data = ByteString("test"))))
val res: Future[String] = for {
  httpResponse <- httpResponseF
  entity       <- httpResponse.entity.toStrict(300.milli)
} yield {
  entity match {
    case HttpEntity.Strict(contentType, data) => data.utf8String
  }
}
assert(Await.result(res, 1.second) == "test")

// 2.他们看起来与我不同： akka.http.scaladsl.model.HttpResponse

def
toStrict(timeout: FiniteDuration)(implicit ec: ExecutionContext, fm: Materializer): Future[Self]

VS

// akka.http.javadsl.model.ResponseEntity

def
toStrict(timeoutMillis: Long, materializer: Materializer): CompletionStage[HttpEntity.Strict]

一个使用含义。

以下是将字符串作为http客户端的一种方法。

object Example {
  import scala.concurrent.Future
  import akka.actor.ActorSystem
  import akka.http.scaladsl.Http
  import akka.stream.ActorMaterializer
  import akka.stream.scaladsl.Sink
  import akka.stream.scaladsl.Source
  import akka.http.scaladsl.unmarshalling._
  import akka.http.scaladsl.model._
  import scala.util.{Try,Success,Failure}
  implicit val system = ActorSystem()
  implicit val materializer = ActorMaterializer()
  implicit val ec = system.dispatcher
  // construct a pool client flow with context type `Int`
  val poolClientFlow = Http().cachedHostConnectionPool[Int]("akka.io")
  val responseFuture: Future[String] =
    Source.single(HttpRequest(uri = "/") -> 1)
      .via(poolClientFlow)
      .mapAsync(1) { 
          case (Success(response), i) => Unmarshal(response.entity).to[String]
          case (Failure(e), i)        => Future.failed(e)
      }
      .runWith(Sink.head)

}

如果有一个更具体的类型（如果使用Scala更加惯用）你试图解组而不是字符串你可以使用这个Json作为模板创建一个自定义Unmarshaller：https://github.com/hseeberger/akka-http-json/blob/master/akka-http-json4s/src/main/scala/de/heikoseeberger/akkahttpjson4s/Json4sSupport.scala否则就有Unmarshallers。字符串http://doc.akka.io/docs/akka/2.4.3/java/http/routing-dsl/marshalling.html#Unmarshalling

有时检查Spray邮件列表和文档是有帮助的，因为它已经活跃了更长时间，即使在akka-http中有一种新方法，它至少提供了一个起点。

Answer 2

对于Q1：

如果您Future[Future[_]]需要Future[_]，则应将map替换为flatMap。这同样适用于Option和集合。

所以这看起来是正确的：

def f1(): Future[HttpResponse]

def f2(): Future[String] = {
 f1().flatMap (_.entity.toStrict(300.milli).map(_.data.utf8String))
}

第二季度：

HttpMessage.toStrict会在内部调用HttpEntity.toStrict，因此他们会做同样的事情。（请注意，由于某种原因，{J>未在Java接口中公开）。

Akka-http并将Future [HttpResponse]转换为Future [String]

2 个答案: