Jackson Scala 模块、嵌套列表和映射

Question

我希望转换 json 对象列表，这些对象本身可能包含 Json 对象或 Json 对象列表，并且希望结果是适当的 Scala 映射或列表，但是，我只能将顶级对象转换为地图或列表。 有没有一种简单的方法可以做到这一点？

例如在 REPL

objectMapper.readValue("{\"test\":\"113123\",\"myList\":[{\"test2\":\"321323\"},{\"test3\":\"11122\"}]}", classOf[Map[String,Any]])

中将返回

res: Map[String,Any] = Map(test -> 113123, myList -> [{test2=321323}, {test3=11122}])

我想要的位置

res: Map[String,Any] = Map(test -> 113123, myList -> List(Map(test2 -> 321323), Map(test3 -> 111222)))

Answer 1

好的，所以使用更高版本的 scala jackson 模块我创建了这个类

private class NestedTypeObjectDeserializer extends JacksonUntypedObjectDeserializer {

  override def mapArray(jp: JsonParser, ctxt: DeserializationContext): AnyRef =
    super.mapArray(jp, ctxt).asInstanceOf[ArrayList[AnyRef]].asScala.toList

  override def mapObject(jp: JsonParser, ctxt: DeserializationContext): AnyRef =
    super.mapObject(jp, ctxt).asInstanceOf[LinkedHashMap[String, AnyRef]].asScala.toMap
}


private object NestedTypeObjectDeserializerResolver extends Deserializers.Base {

  lazy val OBJECT = classOf[AnyRef]

  override def findBeanDeserializer(javaType: JavaType,
                                    config: DeserializationConfig,
                                    beanDesc: BeanDescription) =
    if (!OBJECT.equals(javaType.getRawClass)) null
    else new NestedTypeObjectDeserializer
}

trait NestedTypeObjectDeserializerModule extends JacksonModule {
  this += (_ addDeserializers NestedTypeObjectDeserializerResolver)
}

，您可以将其应用于对象映射器

val objectMapper = new ObjectMapper()
val module = new OptionModule with MapModule with SeqModule with IteratorModule with NestedTypeObjectDeserializerModule {}
objectMapper.registerModule(module)

Answer 2

如果这不能按预期工作，请在 [https://github.com/FasterXML/jackson-module-scala/issues] 上针对 Jackson Scala 模块提出问题。在“无类型”模式（即非 bean，使用列表、映射等）处理内容时可能会出现问题，scala 模块需要为其添加特殊处理。潜在的挑战是 Scala 集合通常不能与 JDK 集合完全映射。

Answer 3

我没有使用过 Jackson Scala 模块，但 Jerkson 中的行为是相同的，所以我会冒险猜测发生了什么。当 REPL 打印时：

myList -> [{test2=321323}, {test3=11122}])

它告诉您有一个包含“myList”的元组和一个 java.util.ArrayList。 ArrayList 包含两个 java.util.LinkedHashMap。 （我解释这一点是因为一开始这对我来说并不明显，我不得不花一些时间使用 getClass 和 asInstanceOf 来研究 REPL 来深入研究该结构。）

我相当确定没有办法获得 Jackson Scala 模块或 Jerkson 返回带有本机 Scala 集合的反序列化 JSON。您可以导入 scala.collect.JavaConversions 到让这些值看起来更像 Scala 一点。即使你这样做了，你仍然需要改变一些事情。例如：

import com.codahale.jerkson.Json._
import collection.JavaConversions._
import java.util._
res("myList").asInstanceOf[ArrayList[LinkedHashMap[String,String]]](0)("test2")
  >> String = 321323

如果您不想摆弄所有的转换，我认为您需要做的是定义一个要反序列化的类。例如，使用 Jerkson：（

import com.codahale.jerkson.Json._
import collection.immutable.{Map,List}

case class MyClass(test: Integer, myList: List[Map[String,String]])

object M {
  def main(args: Array[String]) {
    val t =parse[MyClass]("""{"test":"113123","myList":[{"test2":"321323"},{"test3":"11122"}]}""")
    println(t.myList(0)("test2"))
  }
}

我将其写为完整程序的原因是 Jerkson 不处理 REPL 中的反序列化案例类。）

我知道您可以使用 Jackson 反序列化为对象，但上次我查看它花了再走几步。

这是回答您的问题的正确途径吗？

Answer 4

最终我听从了Leif的建议，编写了这段代码来解决问题

private def mapToMap(map:java.util.Map[String,Any]) : Map[String,Any] = {
  val mb = new MapBuilder[String, Any, HashMap[String, String]](new HashMap[String, String])
  val iterator = map.keySet().iterator
  while (iterator.hasNext) {
    val key = iterator.next
    mb += (key -> checkValue(map.get(key)))
  }

  mb.result
}

private def arrayToList(array:java.util.ArrayList[Any]) : List[Any] = {
  val lb = new ListBuffer[Any]()
  val iterator = array.iterator
  while(iterator.hasNext) lb += checkValue(iterator.next)
  lb.result
}

private def checkValue(value:Any) : Any = value match {
  case l: java.util.ArrayList[Any] => arrayToList(l)
  case m: java.util.Map[String,Any] => mapToMap(m)
  case _ => value
}