jackson-module-scala将Map中的长键序列化/反序列化为字符串

Question

Using jackson-module-Scala, I try to serialize and deserialize an object with an inner Map using a Long as key , but the Jackson serializes the key as String and doesn't deserialize it as Long ifgnoring the type efined in the Class. Is it a BUG? Am I doing something wrong?

import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.module.scala.DefaultScalaModule
import com.fasterxml.jackson.module.scala.experimental.ScalaObjectMapper

case class InnerMap(map: Map[Long, Long])

object CrazyJackson {

  def main(args: Array[String]): Unit = {
    val mapper = new ObjectMapper() with ScalaObjectMapper
    mapper.registerModule(DefaultScalaModule)

    val innerMap = InnerMap(Map(1L->1L))
    val serialized = mapper.writeValueAsString(innerMap)
    val newObj = mapper.readValue(serialized, classOf[InnerMap])
    println(serialized) // Why the key is serialized as a String?
    println(innerMap)
    println(newObj)
    assert(newObj == innerMap)
  }

}

The assert fails and the output of the println(serialized) statement is :

{"map":{"1":1}}

It is strange that printing newObj and innerMap is the same:

InnerMap(Map(1 -> 1))
InnerMap(Map(1 -> 1))

As @Varren says, the problem really is in the assert. But:

import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.module.scala.DefaultScalaModule
import com.fasterxml.jackson.module.scala.experimental.ScalaObjectMapper
import org.scalatest.FunSuite

class CrazyJacksonTest extends FunSuite {
  test("test json comparision") {
    val mapper = new ObjectMapper() with ScalaObjectMapper
    mapper.registerModule(DefaultScalaModule)

    val innerMap = InnerMap(Map(1L->1L))
    val serialized = mapper.writeValueAsString(innerMap)
    val newObj = mapper.readValue(serialized, classOf[InnerMap])
    assert(newObj.map == innerMap.map)
  }
}

The assert result:

Map("1" -> 1) did not equal Map(1 -> 1)
ScalaTestFailureLocation: CrazyJacksonTest$$anonfun$1 at (CrazyJacksonTest.scala:17)
Expected :Map(1 -> 1)
Actual   :Map("1" -> 1)

I am lost! The map must be a Map[Long,Long] !

I must use this version because of Spark dependencies:

• Scala 2.11.11
• jackson-module-scala 2.6.5 and also test with version 2.9.1 with the same result.

Other info:

• Example: https://github.com/angelcervera/jackson-scala-map-bug

Answer 1

JSON allows key names to be strings only. ECMA-404 The JSON Data Interchange Standard

An object structure is represented as a pair of curly bracket tokens surrounding zero or more name/value pairs. A name is a string.

You are right and the assertion problem comes from Jackson. As you can see classOf[InnerMap] actually maps to Map<Object, Object> inside InnerMap but you have to submit typeinfo of this map to jackson to deserialize it correctly. It is explained in this documentation and according to it you can just use

case class InnerMap(@JsonDeserialize(keyAs = classOf[java.lang.Long])
                    map: Map[Long, Long])

Answer 2

The Scala Jackson module does not infer the type of the key in the Map. As @Varren responded, the solution is to annotate the model with Jackson annotations, but on this way:

• The model is tied to a specific parser (Jackson annotations in the model definition).
• The code is less clear.

So I decided to move from Jackson to Circe and remove annotations to keep the code clean. This is a test that proves that it is parsing and unparsing correctly:

  test("test json circe comparision") {

    import io.circe._
    import io.circe.generic.auto._
    import io.circe.parser._
    import io.circe.syntax._

    val innerMap = InnerMap(Map(1L -> 1L))

    val jsonStr = innerMap.asJson.noSpaces
    decode[InnerMap](jsonStr) match {
      case Right(innerMap2) => assert(innerMap2 == innerMap)
      case Left(error) => fail(error)
    }

  }

It is not mean that this is the best solution for everybody. Circe has a plugin to use it in combination with Jackson parser, but I did not test it.