将多个WS-Call组合为一个结果时的错误处理

Question

我正在同时学习scala、play和web服务，所以请耐心等待。我建立了一个小型聚合器服务，它将天气web服务与google的地理编码和places web服务相结合。我有些工作要做，但我对处理错误的正确方法有点困惑。（我把代码贴在了邮件的末尾。）

所以api使用lat/long的地方，所以我使用地理代码api从邮政编码中获取lat/long。在处理对地理代码api的调用的响应时，我最终会得到一个（Option[String]， Option[String]）（保存在maybeLocval中）。在检查maybeLoc的匹配语句中，如果它最终是（无，无），我返回Promise（），因为我需要从平面图调用返回Promise。

对此我有两个问题:

1.）在这些平面地图或地图调用中的一个中，处理无法进行任何进一步处理的情况的正确方法是什么？它要求我返回一个promise，但是创建一个空的Promise，当我去兑换时它会超时，这似乎是一个非常糟糕的主意。

2.） 我假设对 Promise（） 的调用会创建一个空的 promise 对象，在尝试赎回它时总是会超时，我是对的吗？我无法从scaladoc中真正分辨出来，也无法从Google中找到任何有关它的信息。

我希望我的问题对你有意义，并且足够清楚。代码如下：

def bothAsJson(zipcode:String) = Action {
    val promiseOfLoc = Geocode.buildUrlFor(zipcode).get()
    val promiseOfWeather = Weather.buildUrlFor(zipcode, "json").get()

    val result = promiseOfLoc.flatMap { locResp => 
        val maybeLoc = Geocode.extractLocation(locResp.body.toString())
        maybeLoc match {
            case (Some(lat), Some(lng)) => {
                val promiseOfPlaces = Places.buildUrlFor(lat,lng).get()
                promiseOfPlaces.flatMap { placesResp =>
                    promiseOfWeather.map { weatherResp =>
                        (weatherResp.body.toString(), placesResp.body.toString())
                    }
                }
            }
            case _ => Promise()
        }
    }

    Async {
        result.orTimeout("Timeout!", 2000).map {response =>
            response.fold(
                result => Ok("Got:\n\nweather:\n" + result._1 + "\n\nplaces:\n" + result._2),
                timeout => InternalServerError(timeout)
            )
        }
    }
}

Answer 1

如果您得到（无，无），您不应该寻求超时，而是返回另一条我相信的错误消息。我在下面提供了一个示例。

我想你需要scalaz 7的OptionT。我会这样写：

import scalaz._
import Scalaz._

def bothAsJson(zipcode:String) = Action {
    val promiseOfLoc = Geocode.buildUrlFor(zipcode).get.map { Option(_.body.toString()) }
    val promiseOfWeather = Weather.buildUrlFor(zipcode, "json").get
       .map{ lockResp => 
           val (lat,lng) = Geocode.extractLocation(locResp.body.toString())
           (lat |@| lng).tupled
       }
    def buildPlaces(lat: String, lng: String) = Places.buildUrlFor(lat,lng).get
       .map { Option(_.body.toString) }

    val result = (for {
       (lat, lng) <- OptionT(promiseOfLoc)
       places     <- OptionT(Places.buildUrlFor(lat,lng).get())
       weather    <- OptionT(promiseOfWeather)
    } yield (places, weather)).run

    Async {
        result.orTimeout("Timeout!", 2000).map {response =>
            response.fold(
                result => {
                  result.map(
                   some => Ok("Got:\n\nweather:\n" + some._1 + "\n\nplaces:\n" + some._2)
                  ).getOrElse(BadRequest("lat/lng failed probably?"))
                },
                timeout => InternalServerError(timeout)
            )
        }
    }
}

使用< code>OptionT，我们可以将flatMap视为< code >选项，如果得到None，就可以不处理任何内容。最后，我们得到了一个< code>Promise[Option[T]]，这是一个很好的例子。另一个处理错误的好方法是用同样的方法使用/EtherT。

|@|是一个应用生成器。它需要2个选项，如果双方都是一些，则返回一个Option（（Int， Int））。如果一方或双方都是无，则返回无。

注意：要实现这一点，您需要一个scalazMonad[Promise]实例

implicit val PromiseInstance = new Monad[Promise] {
  // override def map[A,B](fa: Promise[A])(f: A => B) = fa.map(f)
  def point[A](a: => A) = Promise.pure(a)
  def bind[A,B](fa: Promise[A])(f: A => Promise[B]) = fa.flatMap(f)
}

另外请注意，我已经在SO编辑器中编写了所有这些代码，可能缺少大括号。但所有代码都应该或多或少正确，我在repl中测试了其中的部分内容。

请随时在freenode irc上#scalaz或scalaz google组上寻求帮助。