Question

假设我有一个这样的Scala case类：

case class Stuff(id: String, values: List[String])

而且我希望能够将以下JSON值解码到其中：

{ "id": "foo", "values": ["a", "b", "c"] }
{ "id": "bar", "values": [] }
{ "id": "qux", "values": null }

在Circe中，从通用派生中获得的解码器适用于前两种情况，但不适用于第三种情况：

scala> decode[Stuff]("""{ "id": "foo", "values": ["a", "b", "c"] }""")
res0: Either[io.circe.Error,Stuff] = Right(Stuff(foo,List(a, b, c)))

scala> decode[Stuff]("""{ "id": "foo", "values": [] }""")
res1: Either[io.circe.Error,Stuff] = Right(Stuff(foo,List()))

scala> decode[Stuff]("""{ "id": "foo", "values": null }""")
res2: Either[io.circe.Error,Stuff] = Left(DecodingFailure(C[A], List(DownField(values))))

如何使我的解码器适用于这种情况，最好不必处理完全手写定义的样板。

Answer 1

使用游标进行预处理

解决此问题的最直接方法是使用半自动派生并使用prepare预处理JSON输入。例如：

import io.circe.{Decoder, Json}, io.circe.generic.semiauto._, io.circe.jawn.decode

case class Stuff(id: String, values: List[String])

def nullToNil(value: Json): Json = if (value.isNull) Json.arr() else value

implicit val decodeStuff: Decoder[Stuff] = deriveDecoder[Stuff].prepare(
  _.downField("values").withFocus(nullToNil).up
)

然后：

scala> decode[Stuff]("""{ "id": "foo", "values": null }""")
res0: Either[io.circe.Error,Stuff] = Right(Stuff(foo,List()))

比简单地使用deriveDecoder更为冗长，但是它仍然可以避免写出所有案例类成员的样板，并且如果您只有少数案例类与需要这种处理的成员，还算不错。

处理缺少的字段

如果您还想处理该字段完全丢失的情况，则需要采取额外的步骤：

implicit val decodeStuff: Decoder[Stuff] = deriveDecoder[Stuff].prepare { c =>
  val field = c.downField("values")

  if (field.failed) {
    c.withFocus(_.mapObject(_.add("values", Json.arr())))
  } else field.withFocus(nullToNil).up
}

然后：

scala> decode[Stuff]("""{ "id": "foo", "values": null }""")
res1: Either[io.circe.Error,Stuff] = Right(Stuff(foo,List()))

scala> decode[Stuff]("""{ "id": "foo" }""")
res2: Either[io.circe.Error,Stuff] = Right(Stuff(foo,List()))

这种方法实质上使解码器的行为与成员类型为Option[List[String]]时的行为完全相同。

将其捆绑

您可以使用如下所示的辅助方法使此操作更加方便：

import io.circe.{ACursor, Decoder, Json}
import io.circe.generic.decoding.DerivedDecoder

def deriveCustomDecoder[A: DerivedDecoder](fieldsToFix: String*): Decoder[A] = {
  val preparation = fieldsToFix.foldLeft[ACursor => ACursor](identity) {
    case (acc, fieldName) =>
      acc.andThen { c =>
        val field = c.downField(fieldName)

        if (field.failed) {
          c.withFocus(_.mapObject(_.add(fieldName, Json.arr())))
        } else field.withFocus(nullToNil).up
      }
  }

  implicitly[DerivedDecoder[A]].prepare(preparation)
}

您可以这样使用：

case class Stuff(id: String, values: Seq[String], other: Seq[Boolean])

implicit val decodeStuff: Decoder[Stuff] = deriveCustomDecoder("values", "other")

然后：

scala> decode[Stuff]("""{ "id": "foo", "values": null }""")
res1: Either[io.circe.Error,Stuff] = Right(Stuff(foo,List(),List()))

scala> decode[Stuff]("""{ "id": "foo" }""")
res2: Either[io.circe.Error,Stuff] = Right(Stuff(foo,List(),List()))

scala> decode[Stuff]("""{ "id": "foo", "other": [true] }""")
res3: Either[io.circe.Error,Stuff] = Right(Stuff(foo,List(),List(true)))

scala> decode[Stuff]("""{ "id": "foo", "other": null }""")
res4: Either[io.circe.Error,Stuff] = Right(Stuff(foo,List(),List()))

这使您可以轻松使用半自动推导的95％，但是如果还不够的话……

核选择

如果您的案例类很多，而成员需要这种处理，而又不想全部修改它们，则可以采用更极端的方法来修改Decoder对于{ {1}}无处不在：

Seq

然后，如果您有这样的案例类：

import io.circe.Decoder

implicit def decodeSeq[A: Decoder]: Decoder[Seq[A]] =
  Decoder.decodeOption(Decoder.decodeSeq[A]).map(_.toSeq.flatten)

派生的解码器将自动执行您想要的操作：

case class Stuff(id: String, values: Seq[String], other: Seq[Boolean])

不过，我强烈建议您使用上述更明确的版本，因为依靠将scala> import io.circe.generic.auto._, io.circe.jawn.decode import io.circe.generic.auto._ import io.circe.jawn.decode scala> decode[Stuff]("""{ "id": "foo", "values": null }""") res0: Either[io.circe.Error,Stuff] = Right(Stuff(foo,List(),List())) scala> decode[Stuff]("""{ "id": "foo" }""") res1: Either[io.circe.Error,Stuff] = Right(Stuff(foo,List(),List())) scala> decode[Stuff]("""{ "id": "foo", "other": [true] }""") res2: Either[io.circe.Error,Stuff] = Right(Stuff(foo,List(),List(true))) scala> decode[Stuff]("""{ "id": "foo", "other": null }""") res3: Either[io.circe.Error,Stuff] = Right(Stuff(foo,List(),List()))的行为更改为Decoder会使您处于必须非常谨慎的位置范围内的隐式范围是什么。

这个问题经常出现，我们可以为在以后的Circe版本中需要Seq映射到空集合的人提供具体支持。

Answer 2

您也可以在适用时使用默认值：

@ConfiguredJsonCodec
case class Stuff(id: String, values: List[String]= Nil)

object Stuff {
  implicit val configuration = Configuration.default.copy(useDefaults = true)
}

可以很好地处理所有3种情况，也可以处理缺少的一种情况。

免责声明：我完全知道我是在向circe的作者作答，他自言自语，我仍然认为添加此非常简单的选项是一个很好的补充！

如何将JSON空值解码为空集合

2 个答案:

使用游标进行预处理

处理缺少的字段

将其捆绑

核选择