15

假设我需要解码如下所示的 JSON 数组，其中开头有几个字段，一些任意数量的同质元素，然后是其他一些字段：

[ "Foo", "McBar", true, false, false, false, true, 137 ]

我不知道为什么有人会选择这样对他们的数据进行编码，但是人们会做一些奇怪的事情，假设在这种情况下我只需要处理它。

我想将此 JSON 解码为这样的案例类：

case class Foo(firstName: String, lastName: String, age: Int, stuff: List[Boolean])

我们可以这样写：

import cats.syntax.either._
import io.circe.{ Decoder, DecodingFailure, Json }

implicit val fooDecoder: Decoder[Foo] = Decoder.instance { c =>
  c.focus.flatMap(_.asArray) match {
    case Some(fnJ +: lnJ +: rest) =>
      rest.reverse match {
        case ageJ +: stuffJ =>
          for {
            fn    <- fnJ.as[String]
            ln    <- lnJ.as[String]
            age   <- ageJ.as[Int]
            stuff <- Json.fromValues(stuffJ.reverse).as[List[Boolean]]
          } yield Foo(fn, ln, age, stuff)
        case _ => Left(DecodingFailure("Foo", c.history))
      }
    case None => Left(DecodingFailure("Foo", c.history))
  }
}

…有效：

scala> fooDecoder.decodeJson(json"""[ "Foo", "McBar", true, false, 137 ]""")
res3: io.circe.Decoder.Result[Foo] = Right(Foo(Foo,McBar,137,List(true, false)))

但是，这太可怕了。错误消息也完全没用：

scala> fooDecoder.decodeJson(json"""[ "Foo", "McBar", true, false ]""")
res4: io.circe.Decoder.Result[Foo] = Left(DecodingFailure(Int, List()))

当然有一种方法可以做到这一点，它不涉及在光标和值之间来回切换Json，在我们的错误消息中丢弃历史，并且通常只是令人眼花缭乱？

一些上下文：关于编写像这样的自定义 JSON 数组解码器的问题经常出现（例如今天早上）。如何做到这一点的具体细节可能会在即将发布的 circe 版本中发生变化（尽管 API 会类似；有关一些细节，请参阅这个实验项目），所以我真的不想花很多时间添加一个像这样的文档示例，但它出现的足够多，我认为它确实值得堆栈溢出问答。

4

1 回答 1

23

使用游标

有一个更好的方法！您可以更简洁地编写此代码，同时还可以通过直接使用游标来维护有用的错误消息：

case class Foo(firstName: String, lastName: String, age: Int, stuff: List[Boolean])

import cats.syntax.either._
import io.circe.Decoder

implicit val fooDecoder: Decoder[Foo] = Decoder.instance { c =>
  val fnC = c.downArray

  for {
    fn     <- fnC.as[String]
    lnC     = fnC.deleteGoRight
    ln     <- lnC.as[String]
    ageC    = lnC.deleteGoLast
    age    <- ageC.as[Int]
    stuffC  = ageC.delete
    stuff  <- stuffC.as[List[Boolean]]
  } yield Foo(fn, ln, age, stuff)
}

这也有效：

scala> fooDecoder.decodeJson(json"""[ "Foo", "McBar", true, false, 137 ]""")
res0: io.circe.Decoder.Result[Foo] = Right(Foo(Foo,McBar,137,List(true, false)))

但它也为我们提供了错误发生位置的指示：

scala> fooDecoder.decodeJson(json"""[ "Foo", "McBar", true, false ]""")
res1: io.circe.Decoder.Result[Foo] = Left(DecodingFailure(Int, List(DeleteGoLast, DeleteGoRight, DownArray)))

此外，它更短、更具声明性，并且不需要那种不可读的嵌套。

这个怎么运作

关键思想是我们将“阅读”操作（.as[X]光标上的调用）与导航/修改操作（downArray以及三个delete方法调用）交错。

当我们开始时，c是一个HCursor我们希望指向的数组。c.downArray将光标移动到数组中的第一个元素。如果输入根本不是数组，或者是空数组，则此操作将失败，我们将收到一条有用的错误消息。如果成功，for-comprehension 的第一行将尝试将第一个元素解码为字符串，并使光标指向第一个元素。

-comprehension中的第二行for说“好的，我们已经完成了第一个元素，所以让我们忘记它并转到第二个”。方法名称的delete一部分并不意味着它实际上正在改变任何东西——几乎没有任何东西会以用户可以观察到的任何方式改变任何东西——它只是意味着该元素将不可用于对结果光标的任何未来操作。

第三行尝试将原始 JSON 数组中的第二个元素（现在是新光标中的第一个元素）解码为字符串。完成后，第四行“删除”该元素并移动到数组的末尾，然后第五行尝试将最终元素解码为Int.

下一行可能是最有趣的：

    stuffC  = ageC.delete

这表示，好的，我们在 JSON 数组的修改视图中的最后一个元素（之前我们删除了前两个元素）。现在我们删除最后一个元素并将光标向上移动，使其指向整个（修改后的）数组，然后我们可以将其解码为布尔值列表，我们就完成了。

更多的错误积累

实际上，您可以使用一种更简洁的方式来编写此代码：

import cats.syntax.all._
import io.circe.Decoder

implicit val fooDecoder: Decoder[Foo] = (
  Decoder[String].prepare(_.downArray),
  Decoder[String].prepare(_.downArray.deleteGoRight),
  Decoder[Int].prepare(_.downArray.deleteGoLast),
  Decoder[List[Boolean]].prepare(_.downArray.deleteGoRight.deleteGoLast.delete)
).map4(Foo)

这也将起作用，并且它还有一个额外的好处，即如果多个成员的解码失败，您可以同时收到所有失败的错误消息。例如，如果我们有这样的事情，我们应该预期三个错误（对于非字符串名字、非整数年龄和非布尔值）：

val bad = """[["Foo"], "McBar", true, "true", false, 13.7 ]"""

val badResult = io.circe.jawn.decodeAccumulating[Foo](bad)

这就是我们所看到的（以及每次故障的具体位置信息）：

scala> badResult.leftMap(_.map(println))
DecodingFailure(String, List(DownArray))
DecodingFailure(Int, List(DeleteGoLast, DownArray))
DecodingFailure([A]List[A], List(MoveRight, DownArray, DeleteGoParent, DeleteGoLast, DeleteGoRight, DownArray))

您应该更喜欢这两种方法中的哪一种，取决于您的喜好以及您是否关心错误累积——我个人认为第一种更具可读性。

于 2017-09-10T19:09:52.113 回答