scala解析json —— json4s 解析json方法汇总

使用json4s的框架，包括spark,flink

1、org.json4s 引入pom的方法

对于本地支持，引入以下依赖项添加到pom中

<dependency>
  <groupId>org.json4s</groupId>
  <artifactId>json4s-jackson_${scala.version}</artifactId>
  <version>{latestVersion}</version>
</dependency>

对于jackson支持，引入以下依赖项添加到pom中

<dependency>
  <groupId>org.json4s</groupId>
  <artifactId>json4s-jackson_${scala.version}</artifactId>
  <version>{latestVersion}</version>
</dependency>

2、Json4s 数据类型

json4s类型包括两个10个类型和一个type类型对象

case object JNothing extends JValue // 'zero' for JValue
case object JNull extends JValue
case class JString(s: String) extends JValue
case class JDouble(num: Double) extends JValue
case class JDecimal(num: BigDecimal) extends JValue
case class JInt(num: BigInt) extends JValue
case class JLong(num: Long) extends JValue
case class JBool(value: Boolean) extends JValue
case class JObject(obj: List[JField]) extends JValue
case class JArray(arr: List[JValue]) extends JValue
 
type JField = (String, JValue)

JField不再是JValue这意味着更高的类型安全性，因为不再可能创建无效的JSON，例如 JFields 直接添加到JArrays中，此更改最明显的结果是map、transform、find和filter有两种版本：

def map(f: JValue => JValue): JValue
def mapField(f: JField => JField): JValue
def transform(f: PartialFunction[JValue, JValue]): JValue
def transformField(f: PartialFunction[JField, JField]): JValue
def find(p: JValue => Boolean): Option[JValue]
def findField(p: JField => Boolean): Option[JField]

3、使用org.json4s解析json字符串

提取不嵌套的json串

import org.json4s._
import org.json4s.native.JsonMethods._
 
// parse解析返回值为Jvalue
scala> parse("""{"name":"Toy","price":35.35}""", useBigDecimalForDouble = true)
res1: org.json4s.package.JValue =
      JObject(List((name,JString(Toy)), (price,JDecimal(35.35))))

提取json中的元素的值
1）单层嵌套取单值

//val parseJson: JValue = parse( """{"name":"Toy","price":35.35}""", useBigDecimalForDouble = true)
val parseJson: JValue = parse( """{"name":"Toy","price":35.35}""")
 
// 方法一：JString模式匹配方式
val JString(name) = (parseJson \ "name")
println(name)
 
//方法二：extract[String]提取值，
val name：String = (parseJson \ "name").extract[String] // 直接提取内容(不安全)
val name：Option[String] = (parseJson \ "name").extractOpt[String]// 返回Option类型(安全)
val name: String = (parseJson \ "name").extractOrElse[String]("") // 设置默认值

2）多层嵌套套取单值

val parseJson: JValue = parse( """{"name":{"tome":"new"},"price":35.35}""", useBigDecimalForDouble = true)
println(parseJson)
// 方法一：逐层访问
val value: String = (parseJson \ "name" \ "tome").extract[String]
// 方法二:循环访问
val value: String = (parseJson \\ "tome").extract[String]

解析提取数组的json串

简单值数组

// 解析列表
parse(""" { "numbers" : [1, 2, 3, 4] } """)
res0: org.json4s.JsonAST.JValue =
      JObject(List((numbers,JArray(List(JInt(), JInt(), JInt(), JInt())))))
 
// 程序解析
val listValue : List[BigInt]  = for {JArray(child) <- jArray; JInt(value) <- child} yield value
 
listValue.map(println)

嵌套数组json串解析

val json = parse(
      """
         { "name": "joe",
           "children": [
             {
               "name": "Mary",
               "age":
             },
             {
               "name": "Mazy",
               "age":
             }
           ]
         }
      """)
 
// 嵌套返回值
for (JArray(child) <- json) println(child)
res0: List(JObject(List((name,JString(Mary)), (age,JInt()))), JObject(List((name,JString(Mazy)), (age,JInt()))))
 
// 嵌套取数组中某个字段值
for {
   JObject(child) <- json
   JField("age", JInt(age)) <- child
} yield age
 
// 嵌套取数组中某个字段值，并添加过滤
for {
  JObject(child) <- json
  JField("name", JString(name)) <- child
  JField("age", JInt(age)) <- child
  if age >
} yield (name, age)

json和对象的转换

/** json转化为对象（不带外层字段） **/
case class ClassA(a: Int, b: Int)
 
val json2: String = """[{"a":1,"b":2},{"a":1,"b":2}]"""
 
val bb: List[ClassA] = parse(json2).extract[List[ClassA]]
 
println(bb)
 
/** json转对象(带外层字段名) */
case class ClassC(a: Int, b: Int)
 
case class ClassB(c: List[ClassC])
 
val json3: String = """{"c":[{"a":1,"b":2},{"a":1,"b":2}]}"""
 
val cc: ClassB = parse(json3).extract[ClassB]
 
println(cc)

4、使用org.json4s产生json字符串

基本数据类型转化为普通json
1) 序列Seq转化为Json字符串

scala> val json = List(, , )
 
scala> compact(render(json))
res0: String = [,,]

2) Tuple2[String, A] 类型转化为json字符串

scala> val json = ("name" -> "joe")
 
scala> compact(render(json))
res1: String = {"name":"joe"}

3) ~ 合并object对象转化为json串

scala> val json = ("name" -> "joe") ~ ("age" -> )
 
scala> compact(render(json))
res2: String = {"name":"joe","age":}

4) option 类型转化为串

scala> val json = ("name" -> "joe") ~ ("age" -> Some())
 
scala> compact(render(json))
res3: String = {"name":"joe","age":}
 
scala> val json = ("name" -> "joe") ~ ("age" -> (None: Option[Int]))
 
scala> compact(render(json))
res4: String = {"name":"joe"}

5) case class 类转化为Json串

object JsonExample extends App {
  import org.json4s._
  import org.json4s.JsonDSL._
  import org.json4s.jackson.JsonMethods._
 
  case class Winner(id: Long, numbers: List[Int])
  case class Lotto(id: Long, winningNumbers: List[Int], winners: List[Winner], drawDate: Option[java.util.Date])
 
  val winners = List(Winner(, List(, , , , , )), Winner(, List(, , , , , )))
  val lotto = Lotto(, List(, , , , , , ), winners, None)
 
  val json =
    ("lotto" ->
      ("lotto-id" -> lotto.id) ~
      ("winning-numbers" -> lotto.winningNumbers) ~
      ("draw-date" -> lotto.drawDate.map(_.toString)) ~
      ("winners" ->
        lotto.winners.map { w =>
          (("winner-id" -> w.id) ~
           ("numbers" -> w.numbers))}))
 
  println(compact(render(json)))
}

5、使用org.json4s其他用法

1) 格式化json串

scala> pretty(render(JsonExample.json))
 
{
  "lotto":{
    "lotto-id":,
    "winning-numbers":[,,,,,,],
    "winners":[{
      "winner-id":,
      "numbers":[,,,,,]
    },{
      "winner-id":,
      "numbers":[,,,,,]
    }]
  }
}

2) 合并两个json 串

scala> import org.json4s._
scala> import org.json4s.jackson.JsonMethods._
 
scala> val lotto1 = parse("""{
         "lotto":{
           "lotto-id":,
           "winning-numbers":[,,,,,,],
           "winners":[{
             "winner-id":,
             "numbers":[,,,,,]
           }]
         }
       }""")
 
scala> val lotto2 = parse("""{
         "lotto":{
           "winners":[{
             "winner-id":,
             "numbers":[,,,,,]
           }]
         }
       }""")
 
scala> val mergedLotto = lotto1 merge lotto2
 
scala> pretty(render(mergedLotto))
res0: String =
{
  "lotto":{
    "lotto-id":,
    "winning-numbers":[,,,,,,],
    "winners":[{
      "winner-id":,
      "numbers":[,,,,,]
    },{
      "winner-id":,
      "numbers":[,,,,,]
    }]
  }
}

3) 两个json 串查找差异

scala> val Diff(changed, added, deleted) = mergedLotto diff lotto1
changed: org.json4s.JsonAST.JValue = JNothing
added: org.json4s.JsonAST.JValue = JNothing
deleted: org.json4s.JsonAST.JValue = JObject(List((lotto,JObject(List(JField(winners,
JArray(List(JObject(List((winner-id,JInt()), (numbers,JArray(
List(JInt(), JInt(), JInt(), JInt(), JInt(), JInt())))))))))))))

> 参考链接：https://blog.csdn.net/leehbing/article/details/74391308