scala使用jackson解析json成对象

什么是Jackson

Jackson是一个简单的基于Java的库，用于将Java对象序列化为JSON，也可以把JSON转换为Java对象。

Jackons的特征

• 易于使用：-Jackson API提供了高级外观，以简化常用使用。

• 无需创建映射：Jackson API为大多数序列化的对象提供了默认映射。

• 性能：Jackson轻便快速，内存占用少，适用于大型对象图或系统。

• 干净的JSON：Jackson创建了简洁的JSON，易于阅读。

• 没有依赖关系：Jackson库除JDK以外不需要任何其他库。

• 开源：Jackson库是开源的，可以免费使用。

Jackson有一个很好的附加模块来支持Scala数据类型，这是包的依赖

<!-- jackon -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.11.1</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.11.1</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.11.1</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.module</groupId>
    <artifactId>jackson-module-scala_2.11</artifactId>
    <version>2.11.1</version>
</dependency>

实例代码

import com.fasterxml.jackson.databind.{DeserializationFeature, ObjectMapper}
import com.fasterxml.jackson.module.scala.experimental.ScalaObjectMapper
import com.fasterxml.jackson.module.scala.DefaultScalaModule



object JsonUtil {
/**
 * scala中object的属性和方法都可以当做类似java中的静态成员，都可以通过object.成员来进行调用
 * 其作用类似于单例模式
 */
  val mapper = new ObjectMapper() with ScalaObjectMapper
  mapper.registerModule(DefaultScalaModule)
  mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)


  def toJson(value: Map[Symbol, Any]): String = {
    toJson(value map { case (k,v) => k.name -> v})
  }


  // 将对象转成字符串
  def toJson(value: Any): String = {
    mapper.writeValueAsString(value)
  }


  // 将字符串转成map
  def toMap[V](json:String)(implicit m: Manifest[V]) = fromJson[Map[String,V]](json)


  // 将字符串转成对象
  def fromJson[T](json: String)(implicit m : Manifest[T]): T = {
    mapper.readValue[T](json)
  }
}

使用上述的代码

1： 将map 转字符串； 或 字符串转map

/*
* (Un)marshalling a simple map
*/
val originalMap = Map("a" -> List(1,2), "b" -> List(3,4,5), "c" -> List())
val json = JsonUtil.toJson(originalMap)
// json: String = {"a":[1,2],"b":[3,4,5],"c":[]}
val map = JsonUtil.toMap[Seq[Int]](json)
// map: Map[String,Seq[Int]] = Map(a -> List(1, 2), b -> List(3, 4, 5), c -> List())

2： json 转化为指定格式的map

/*
* Unmarshalling to a specific type of Map
*/
val mutableSymbolMap = JsonUtil.fromJson[collection.mutable.Map[Symbol,Seq[Int]]](json)
// mutableSymbolMap: scala.collection.mutable.Map[Symbol,Seq[Int]] = Map('b -> List(3, 4, 5), 'a -> List(1, 2), 'c -> List())

3： 将对象转成字符串；  或将字符串转成对象

/*
* (Un)marshalling nested case classes
*/
case class Person(name: String, age: Int)
case class Group(name: String, persons: Seq[Person], leader: Person)


val jeroen = Person("Jeroen", 26)
val martin = Person("Martin", 54)


val originalGroup = Group("Scala ppl", Seq(jeroen,martin), martin)
// originalGroup: Group = Group(Scala ppl,List(Person(Jeroen,26), Person(Martin,54)),Person(Martin,54))



val groupJson = JsonUtil.toJson(originalGroup)
// groupJson: String = {"name":"Scala ppl","persons":[{"name":"Jeroen","age":26},{"name":"Martin","age":54}],"leader":{"name":"Martin","age":54}}



val group = JsonUtil.fromJson[Group](groupJson)
// group: Group = Group(Scala ppl,List(Person(Jeroen,26), Person(Martin,54)),Person(Martin,54))

使用隐式转换封装， 来简化解析的过程

object MarshallableImplicits {


  implicit class Unmarshallable(unMarshallMe: String) {
    def toMap: Map[String,Any] = JsonUtil.toMap(unMarshallMe)
    def fromJson[T]()(implicit m: Manifest[T]): T =  JsonUtil.fromJson[T](unMarshallMe)
  }


  implicit class Marshallable[T](marshallMe: T) {
    def toJson: String = JsonUtil.toJson(marshallMe)
  }
}

如果导入隐式转换，你可以在任何对象上调用toJson，在任何字符串上调用toMap或fromJson。

import utils.MarshallableImplicits._     //隐式转换


case class Person(name:String, age: Int)


val jeroen = Person("Jeroen", 26)




val jeroenJson = jeroen.toJson
// jeroenJson:  String = {"name":"Jeroen","age":26}


val jeroenMap = jeroenJson.toMap
// jeroenMap: Map[String,Any] = Map(name -> Jeroen, age -> 26)

// 将Person对象转成字符串， 然后将字符串转成Person对象
val s = jeroen.toJson.fromJson[Person]
//Person("Jeroen", 26)

参考： https://coderwall.com/p/o--apg/easy-json-un-marshalling-in-scala-with-jackson