使用 json4s 将嵌套的序列化 json 提取到 Scala 中的案例类中

Question

我正在尝试在 Scala 中使用 json4s 解析以下 Json，但由于嵌套结构，我无法解析：

[
 {
    "body":"8",
    "start":29,
    "value":{
        "value":8,
        "type":"value"
        },
    "end":30,
    "dim":"number",
    "latent":false
 },
 {
    "body":"2",
    "start":42,
    "value":{
        "value":2,
        "type":"value"
        },
    "end":43,
    "dim":"number",
    "latent":false
 }
]

用下面的代码，我只能提取第一个case类，但是嵌套类没有提取出来：

println(stdout)
val obs = parse(stdout.toString())
val obs2 = parse(stdout.toString()).extract[DucklingList]
println(obs2.list)

这是上面的输出：

[0m[[0minfo[0m] [0m[{"body":"8","start":29,"value":{"value":8,"type":"value"},"end":30,"dim":"number","latent":false},{"body":"2","start":42,"value":{"value":2,"type":"value"},"end":43,"dim":"number","latent":false}][0m
[0m[[0minfo[0m] [0mList(JObject(List((body,JString(8)), (start,JInt(29)), (value,JObject(List((value,JInt(8)), (type,JString(value))))), (end,JInt(30)), (dim,JString(number)), (latent,JBool(false)))), JObject(List((body,JString(2)), (start,JInt(42)), (value,JObject(List((value,JInt(2)), (type,JString(value))))), (end,JInt(43)), (dim,JString(number)), (latent,JBool(false)))))[0m
[0m[[0minfo[0m] [0mJObject(List((value,JInt(8)), (type,JString(value))))[0m
[0m[[0minfo[0m] [0mDucklingList(List(JObject(List((body,JString(8)), (start,JInt(29)), (value,JObject(List((value,JInt(8)), (type,JString(value))))), (end,JInt(30)), (dim,JString(number)), (latent,JBool(false)))), JObject(List((body,JString(2)), (start,JInt(42)), (value,JObject(List((value,JInt(2)), (type,JString(value))))), (end,JInt(43)), (dim,JString(number)), (latent,JBool(false))))))[0m

我尝试使用 json4s 提取方法以及下面列出的案例类和序列化程序来提取它。

case class DucklingValue(

    value: Int,
    typ: String
  )

  case class DucklingEntity(
    body: String,
    start: Int,
    end: Int,
    value: List[JField],
    dim: String,
    latent: Boolean
  )

  case class DucklingList(
    list: List[JValue]
  )

class DucklingEntitySerializer extends CustomSerializer[DucklingEntity](format => (
  {
    case JObject(
      JField("body", JString(body))
      :: JField("start", JInt(start))
      :: JField("end", JInt(end))
      :: JField("value", JObject(value))
      :: JField("dim", JString(dim))
      :: JField("latent", JBool(latent))
      :: Nil
    ) => DucklingEntity(body, start.toInt, end.toInt, value, dim, latent)
  },
  {
    case duckling_entity: DucklingEntity =>
      JObject(
        JField("body", JString(duckling_entity.body))
        :: JField("start", JInt(duckling_entity.start))
        :: JField("end", JInt(duckling_entity.end))
        :: JField("value", JObject(duckling_entity.value))
        :: JField("dim", JString(duckling_entity.dim))
        :: JField("latent", JBool(duckling_entity.latent))
        :: Nil
      )
  }
))

class DucklingValueSerializer extends CustomSerializer[DucklingValue](format => (
  {
    case JObject(
      JField("value", JInt(value))
      :: JField("type", JString(typ))
      :: Nil
    ) => DucklingValue(value.toInt, typ)
  },
  {
    case duckling_value: DucklingValue =>
      JObject(
        JField("value", JInt(duckling_value.value))
        :: JField("type", JString(duckling_value.typ))
        :: Nil
      )
  }
))


class DucklingListSerializer extends CustomSerializer[DucklingList](format => (
  {
    case JArray(list) => DucklingList(list)
  },
  {
    case duckling_list: DucklingList =>
      JArray(duckling_list.list)
  }
))

如何让嵌套的序列化案例类 DucklingEntity 也被提取到 DucklingList 下？

Answer 1

json4s 将递归解析嵌套对象，因此您不需要自定义序列化程序。

问题是您在反序列化类中放置了JSON 类型（JValue 和JField），而您应该只放置适当的案例类。以下是您的类的修改版本，应该在没有任何自定义序列化程序的情况下进行解析：

case class DucklingValue(
  value: Int,
  typ: String
)

case class DucklingEntity(
  body: String,
  start: Int,
  end: Int,
  value: DucklingValue,
  dim: String,
  latent: Boolean
)

case class DucklingList(
  list: List[DucklingEntity]
)

---

另请注意，您的反序列化程序具有限制性，因为它们要求字段按您指定的特定顺序出现。最好提取各个字段，如下所示：

case obj: JObject =>
  DucklingValue(
    (obj \ "value").Extract[Int],
    (obj \ "type").Extract[String]
  )

这也允许字段按任意顺序排列。使用这种方法还允许您处理可选字段等，而简单的match 表达式则不能。