如何使用JSON4S反序列化Scala树

Question

序列化工作正常，但是我不需要反序列化。 我在这里找到了抽象类的有趣解决方案。 如何在Scala中使用Json4s序列化密封的抽象类？ 但它不涉及树木。

这是我使用标准JSON4S测试的代码：

import org.json4s._
import org.json4s.native.JsonMethods._
import org.json4s.native.Serialization.{ read, write }
import org.json4s.native.Serialization

abstract class Tree
case class Node(nameN: String, trees: List[Tree]) extends Tree
case class Leaf(nameL: String) extends Tree

object Tree extends App {
  implicit val formats = Serialization.formats(NoTypeHints)

  // object creation to test the serialization
  val root =
    Node(
      "Grand Pavois project",
      List(
        Node(
          "studies",
          List(
            Leaf("preliminary studies"),
            Leaf("detailled studies")
          )
        ),
        Node(
          "realization",
          List(
            Leaf("ground"),
            Leaf("building"),
            Leaf("roof")
          )
        ),
        Node(
          "delivery",
          List(
            Leaf("quality inspection"),
            Leaf("customer delivery")
          )
        )
      )
    )

  val serialized = write(root) // object creation and serialization
  println(s"serialized: $serialized") // print the result, this is OK

  // and now what about deserialization?
  // string creation for deserialization
  // ( it is the same as serialized above, I do like that to trace for the demo)
  val rootString = """
{
  "nameN": "Grand Pavois project",
  "trees": [
    {
      "nameN": "studies",
      "trees": [
        {
          "nameL": "preliminary studies"
        },
        {
          "nameL": "detailled studies"
        }
      ]
    },
    {
      "nameN": "realization",
      "trees": [
        {
          "nameL": "ground"
        },
        {
          "nameL": "building"
        },
        {
          "nameL": "roof"
        }
      ]
    },
    {
      "nameN": "delivery",
      "trees": [
        {
          "nameL": "quality inspection"
        },
        {
          "nameL": "customer delivery"
        }
      ]
    }
  ]
}
"""
//standard deserialization below that produce an error :
// "Parsed JSON values do not match with class constructor"
val rootFromString = read[Tree](rootString)
}

现在我猜想解决方案是使用自定义解串器，可能是一种可追溯的解决方案，但是如何定义呢？ 就是那个问题。 谢谢你的帮助。

Answer 1

此解决方案不使用自定义反序列化器，而是创建一个同时匹配Node和Leaf的类型，然后在以后转换为适当的类型。

case class JsTree(nameN: Option[String], nameL: Option[String], trees: Option[List[JsTree]])

def toTree(node: JsTree): Tree = node match {
  case JsTree(Some(name), None, Some(trees)) =>
    Node(name, trees.map(toTree))
  case JsTree(None, Some(name), None) =>
    Leaf(name)
  case _ =>
    throw new IllegalArgumentException
}

val rootFromString = toTree(read[JsTree](rootString))

JsTree类将匹配Node和Leaf值，因为它具有与两个类中的所有字段都匹配的选项字段。 该toTree方法递归转换JsTree到适当的Tree子类基于哪个字段是实际存在。

更新：自定义序列化程序

这是使用自定义序列化程序的解决方案：

import org.json4s.JsonDSL._

class TreeSerializer extends CustomSerializer[Tree](format => ({
  case obj: JObject =>
    implicit val formats: Formats = format

    if ((obj \ "trees") == JNothing) {
      Leaf(
        (obj \ "nameL").extract[String]
      )
    } else {
      Node(
        (obj \ "nameN").extract[String],
        (obj \ "trees").extract[List[Tree]]
      )
    }
}, {
  case node: Node =>
    JObject("nameN" -> JString(node.nameN), "trees" -> node.trees.map(Extraction.decompose))
  case leaf: Leaf =>
    "nameL" -> leaf.nameL
}))

像这样使用它：

implicit val formats: Formats = DefaultFormats + new TreeSerializer

read[Tree](rootString)