Looking for a good example of polymorphic serialization deserialization using jackson with scala

Question

got an exception :

Exception in thread "main" Blockquote org.codehaus.jackson.map.exc.UnrecognizedPropertyException: Unrecognized field "animals" (Class Zoo), not marked as ignorable

after trying the following code :

    import org.codehaus.jackson.annotate.{ JsonTypeInfo, JsonSubTypes }
    import org.codehaus.jackson.annotate.JsonSubTypes.Type

    @JsonTypeInfo(
      use = JsonTypeInfo.Id.NAME,
      include= JsonTypeInfo.As.PROPERTY,
      property = "type"
    )
    @JsonSubTypes(Array(
      new Type(value= classOf[Cat] , name = "cat"),
      new Type(value= classOf[Dog] , name = "dog")
    )
    )
    abstract class Animal {
      val name:String  = "NoName"

    }
class Cat extends Animal{
   val favoriteToy = "edi"
}
class Dog extends Animal{
  val breed = "German Shepherd"
  val color = "brown"
}
class Zoo {
  val animals = new scala.collection.mutable.ListBuffer[Animal]
}
import org.codehaus.jackson.map.ObjectMapper

object Foo {
  def main (args:Array[String]) {
    val mapper = new ObjectMapper()
     mapper.setPropertyNamingStrategy(CamelCaseNamingStrategy )
    val source = scala.io.Source.fromFile("input.json" )
    val input = source.mkString
    source.close
     val zoo = mapper.readValue(input,classOf[Zoo])
    println(mapper.writeValueAsString(zoo))
  }
import org.codehaus.jackson.map.introspect.{AnnotatedField, AnnotatedMethod}
import org.codehaus.jackson.map.{MapperConfig, PropertyNamingStrategy}

object CamelCaseNamingStrategy extends PropertyNamingStrategy{
 override def nameForGetterMethod (config: MapperConfig[_], method: AnnotatedMethod, defaultName: String) =
 {
   translate(defaultName)
 }

 override def nameForSetterMethod (config: MapperConfig[_], method: AnnotatedMethod, defaultName: String) = {
   translate(defaultName)
 }

  override def nameForField  (config: MapperConfig[_], field: AnnotatedField, defaultName: String) = {
    translate(defaultName)
  }

  def translate(defaultName:String) = {
    val nameChars = defaultName.toCharArray
    val nameTranslated = new StringBuilder(nameChars.length*2)
    for ( c <- nameChars){
      if (Character.isUpperCase(c)){
        nameTranslated.append("_")
      }
      nameTranslated.append( Character.toLowerCase(c))
    }
    nameTranslated.toString
  }

}

file input.json

{
"animals":
  [
    {"type":"dog","name":"Spike","breed":"mutt","color":"red"},
    {"type":"cat","name":"Fluffy","favoriteToy":"spider ring"}
  ]
}

Nate · Answer 1 · 2014-11-05T15:02:59.693

If you're doing polymorphic deserialization in Scala I'd strongly recommend using case classes and Jackson's scala module.

object Test {
  import com.fasterxml.jackson.annotation.JsonSubTypes.Type
  import com.fasterxml.jackson.annotation.{JsonSubTypes, JsonTypeInfo}
  import com.fasterxml.jackson.databind.ObjectMapper
  import com.fasterxml.jackson.module.scala.DefaultScalaModule
  import com.fasterxml.jackson.module.scala.experimental.ScalaObjectMapper

  @JsonTypeInfo(
    use = JsonTypeInfo.Id.NAME,
    include = JsonTypeInfo.As.PROPERTY,
    property = "type"
  )
  @JsonSubTypes(Array(
    new Type(value = classOf[Cat], name = "cat"),
    new Type(value = classOf[Dog], name = "dog")
  ))
  trait Animal

  case class Dog(name: String, breed: String, leash_color: String) extends Animal
  case class Cat(name: String, favorite_toy: String) extends Animal
  case class Zoo(animals: Iterable[Animal])

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

    val dogStr = """{"type": "dog", "name": "Spike", "breed": "mutt",  "leash_color": "red"}"""
    val catStr = """{"type": "cat", "name": "Fluffy", "favorite_toy": "spider ring"}"""
    val zooStr = s"""{"animals":[$dogStr, $catStr]}"""

    val zoo = objectMapper.readValue[Zoo](zooStr)

    println(zoo)
    // Prints: Zoo(List(Dog(Spike,mutt,red), Cat(Fluffy,spider ring)))
  }
}

Nate, what Jackson version and what Scala version did you run this on? I'm getting com.fasterxml.jackson.databind.JsonMappingException: Can not construct instance of TestJackson$Animal, problem: abstract types either need to be mapped to concrete types, have custom deserializer, or be instantiated with additional type information on Scala 2.10.4 with latest Jackson 2.4.3 — Grega Kešpret, Nov 05 '14 at 14:45
I've updated my post to include the specific imports (that error sounds like an incorrect import). This should work on all versions of Scala 2.9+, and Jackson 2.2+ (if not earlier). I was specifically using Scala 2.11.2 and Jackson 2.4.3. As long as there is a jackson-module-scala jar built for the combination it should work. You can find them here: http://search.maven.org/#search%7Cga%7C1%7Cjackson-module-scala — Nate, Nov 05 '14 at 15:06

igx · Answer 2 · 2013-06-18T08:41:14.167

Ok, Got it here is a working example with scala based on Deserialize JSON with Jackson into Polymorphic by Programmer Bruce:

import org.codehaus.jackson.annotate.JsonSubTypes.Type
import org.codehaus.jackson.annotate.{JsonSubTypes, JsonTypeInfo}

@JsonTypeInfo(
  use = JsonTypeInfo.Id.NAME,
  include= JsonTypeInfo.As.PROPERTY,
  property = "type"
)
@JsonSubTypes(Array(
  new Type(value= classOf[Cat] , name = "cat"),
  new Type(value= classOf[Dog] , name = "dog")
)
)
abstract class Animal {
  var name:String =""

}

class Dog extends Animal{
  var breed= "German Shepherd"
  var color = "brown"
}

class Cat extends Animal{
   var favoriteToy:String = "nothing"
}


class Zoo {
  var animals = new Array[Animal](5)
}


import org.codehaus.jackson.annotate.JsonAutoDetect.Visibility
import org.codehaus.jackson.annotate.JsonMethod
import org.codehaus.jackson.map.{DeserializationConfig, ObjectMapper}

object Foo {
   def main (args:Array[String]) {
    val mapper = new ObjectMapper().setVisibility(JsonMethod.FIELD,Visibility.ANY)
     mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES,false)
    val source =  scala.io.Source.fromFile("/input.json" )
    val input = source.mkString
     println("input " + input)
    source.close
     val zoo = mapper.readValue(input,classOf[Zoo])

    println(mapper.writeValueAsString(zoo))
  }

}

file:input.json { "animals": [ {"type":"dog","name":"Spike","breed":"mutt","color":"red"}, {"type":"cat","name":"Fluffy","favoriteToy":"spider ring"} ] }

Looking for a good example of polymorphic serialization deserialization using jackson with scala

2 Answers2

Linked