Jackson：反序列化JSON到Scala ADT

Question

假设您有一个JSON，它看起来像这样：

[{"foo": 1, "bar": 2}, {"foo": 3, "bar": {"baz": 4}}]

使用Scala和类型来表示这一点似乎很自然：

sealed trait Item
case class IntItem(foo: Int, bar: Int) extends Item
case class Baz(baz: Int)
case class BazItem(foo: Int, bar: Baz) extends Item

我的问题是：是否可以使用Jackson的Scala模块将上面的JSON序列化为一个List[Item]？

我的尝试：

val string = "[{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": {\"baz\": 4}}]"
val mapper = new ObjectMapper() with ScalaObjectMapper
mapper.registerModule(DefaultScalaModule)
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
mapper.readValue[List[Item]](string)

例外情况：

线程“main”com.fasterxml.jackson.databind.JsonMappingExctive中的异常：无法构造...项目的实例，问题：抽象类型需要映射到具体类型，具有自定义反序列化器，或者在[源：[{"foo"： 1，"bar"：{"baz"： 2}}，{"foo"： 3，"bar"：{"baz"： 4}}]中使用其他类型信息实例化；行：1，列：2]（通过引用链：com.fasterxml.jackson.module.scala.deser.BuilderWrapper[0]）

这相当清楚地说明了问题所在，但我不确定如何最好地解决它。

Answer 1

正如@Dima所指出的，我不认为存在一个涵盖所有情况的通用解决方案。此外，我不确定它是否存在，因为差异可能隐藏得很深，我怀疑足够聪明的人可能会因此制造出一个停顿的问题。然而，许多具体案例都可以解决。

首先，如果您控制双方（序列化和反序列化），您应该考虑使用JsonTypeIdResolver注释和一些TypeIdResolver子类，这些子类将把类型的名称放在JSON本身中。

如果不能使用JsonTypeIdResolver，可能唯一的解决方案就是按照错误提示推出定制的JsonDeserializer。您在问题中提供的示例可以通过以下方式处理：

sealed trait Item
case class IntItem(foo: Int, bar: Int) extends Item
case class Baz(baz: Int)
case class BazItem(foo: Int, bar: Baz) extends Item



import com.fasterxml.jackson.core._
import com.fasterxml.jackson.databind._
import com.fasterxml.jackson.databind.module.SimpleModule
import com.fasterxml.jackson.databind.util.TokenBuffer
import com.fasterxml.jackson.databind.deser.std.StdDeserializer
import com.fasterxml.jackson.databind.node._
import com.fasterxml.jackson.databind.exc._
import java.io.IOException

class ItemDeserializer() extends StdDeserializer[Item](classOf[Item]) {

  @throws[IOException]
  @throws[JsonProcessingException]
  def deserialize(jp: JsonParser, ctxt: DeserializationContext): Item = {
    // 1) Buffer current state of the JsonParser
    // 2) Use firstParser (from the buffer) to parser whole sub-tree into a generic JsonNode
    // 3) Analyze tree to find out the real type to be parser
    // 3) Using the buffer roll back history and create objectParser to parse the sub-tree as known type
    val tb = new TokenBuffer(jp, ctxt)
    tb.copyCurrentStructure(jp)

    val firstParser = tb.asParser
    firstParser.nextToken
    val curNode = firstParser.getCodec.readTree[JsonNode](firstParser)

    val objectParser = tb.asParser
    objectParser.nextToken()

    val bar = curNode.get("bar")
    if (bar.isInstanceOf[IntNode]) {
      objectParser.readValueAs[IntItem](classOf[IntItem])
    }
    else if (bar.isInstanceOf[ObjectNode]) {
      objectParser.readValueAs[BazItem](classOf[BazItem])
    }
    else {
      throw ctxt.reportBadDefinition[JsonMappingException](classOf[Item], "Unknown subtype of Item") // Jackson 2.9
      //throw InvalidDefinitionException.from(jp, "Unknown subtype of Item", ctxt.constructType(classOf[Item])) // Jackson 2.8
    }
  }
}

然后你可以使用它如下

def test() = {
  import com.fasterxml.jackson.module.scala._
  import com.fasterxml.jackson.module.scala.experimental._

  val mapper = new ObjectMapper() with ScalaObjectMapper
  mapper.registerModule(DefaultScalaModule)

  // add our custom ItemDeserializer
  val module = new SimpleModule
  module.addDeserializer(classOf[Item], new ItemDeserializer)
  mapper.registerModule(module)

  mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)

  val string = "[{\"foo\": 1, \"bar\": 2}, {\"foo\": 3, \"bar\": {\"baz\": 4}}]"

  val list = mapper.readValue[List[Item]](string)
  println(list.mkString(", "))
}

哪个指纹

第一项（1,2），第三项（3，第四项）

ItemDeserializer中的主要技巧是使用TokenBuffer两次解析JSON：第一次分析JSON树，找出应该解析为什么类型，第二次实际解析已知类型的对象。