寻找使用带有scala的jackson进行多态序列化反序列化的一个很好的

发布时间：2020-12-16 19:05:04 所属栏目：安全来源：网络整理

导读：寻找使用带有 scala的jackson进行多态序列化反序列化的一个很好的例子有一个例外： Exception in thread “main” Blockquote org.codehaus.jackson.map.exc.UnrecognizedPropertyException: Unrecognized field “animals” (Class Zoo),not marked as ign

寻找使用带有 scala的jackson进行多态序列化反序列化的一个很好的例子

有一个例外：

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

尝试以下代码后：

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[_],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
  }

}

文件input.json

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

解决方法

如果你在Scala中进行多态反序列化,我强烈建议使用case类和Jackson的scala模块.

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],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)))
  }
}

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!