什么是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