json4解析json ——scala解析json

一、org.json4s 引入pom的方法

  <json4s.version>3.6.9</json4s.version>

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

二、Json4s 数据类型

son4s类型包括两个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]

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

3.1 解析 jsonString 中的 String 类型字段

import org.json4s.{Formats, ShortTypeHints}
import org.json4s.jackson.JsonMethods.parse
import org.json4s.jackson.Serialization

object TestJsonParse{
  def main(args: Array[String]): Unit = {
    val str =
      """
        |{"key":"login","name":"tom","id":3990}
      """.stripMargin
    val value = parseValueString(str, "key")
    println("value: "+value)
  }
  /**
    * 解析 jsonString 中的 String 类型字段
    */
  def parseValueString(in: String, key: String): String = {
    implicit val formats: Formats = Serialization.formats(ShortTypeHints(List()))
    (parse(in) \ key).extractOrElse[String]("").trim
  }

输出结果：

3.2 解析 jsonString 中的 Int类型字段

import org.apache.commons.lang3.StringUtils
import org.json4s.{Formats, ShortTypeHints}
import org.json4s.jackson.JsonMethods.parse
import org.json4s.jackson.Serialization
object TestJsonParse {
  def main(args: Array[String]): Unit = {
    val str =
      """
        |{"key":"login","name":"tom","id":3990}
      """.stripMargin
    val value = parseValueInt(str, "id")
    println("value: "+value)
  }
  /**
    * 解析 jsonString 中的 Int 类型字段
    */
  def parseValueInt(in: String, key: String): Int = {
    implicit val formats: Formats = Serialization.formats(ShortTypeHints(List()))
    val numStr = (parse(in) \ key).extractOrElse[String]("0")
    if (numStr.nonEmpty && StringUtils.isNumeric(numStr)) numStr.toInt else 0
  }

输出结果：

3.3 解析单层嵌套json其他类型字段值

 /**
    * 解析 jsonString 中的 Long 类型字段
    */
  def parseValueLong(in: String, key: String): Long = {
    implicit val formats: Formats = Serialization.formats(ShortTypeHints(List()))
    val numStr = (parse(in) \ key).extractOrElse[String]("0")
    if (numStr.nonEmpty && StringUtils.isNumeric(numStr)) numStr.toLong else 0L
  }

  /**
    * 解析 jsonString 中的 Double 类型字段
    */
  def parseValueDouble(in: String, key: String): Double = {
    implicit val formats: Formats = Serialization.formats(ShortTypeHints(List()))
    val numStr = (parse(in) \ key).extractOrElse[String]("0")
    if (numStr.nonEmpty) numStr.toDouble else 0.0
  }

  /**
    * 解析 jsonString 中的 Long 类型字段为 time
    */
  def parseValueTime(in: String, key: String): String = {
    implicit val formats: Formats = Serialization.formats(ShortTypeHints(List()))
    val ts = (parse(in) \ key).extractOrElse[String]("0")
    if (StringUtils.isNumeric(ts)) {
      val timestamp = ts.toLong
      ts.length match {
        case 10 => DateUtil.timestampToTime(timestamp * 1000)
        case 13 => DateUtil.timestampToTime(timestamp)
        case _ => DateUtil.getNowTime
      }
    } else {
      ts
    }
  }

  /**
    * 解析 jsonString 中的 Long 类型字段为 date
    */
  def parseValueDate(in: String, key: String): String = {
    implicit val formats: Formats = Serialization.formats(ShortTypeHints(List()))
    val ts = (parse(in) \ key).extractOrElse[String]("0")
    if (StringUtils.isNumeric(ts)) {
      val timestamp = ts.toLong
      ts.length match {
        case 10 => DateUtil.timestampToDate(timestamp * 1000)
        case 13 => DateUtil.timestampToDate(timestamp)
        case _ => DateUtil.getTodayDate
      }
    } else {
      ts
    }
  }

4 多层嵌套套取单值

// 方法一：逐层访问
val value: String = (parseJson \ “data” \ “name”).extract[String]
// 方法二:循环访问
val value: String = (parseJson \ “name”).extract[String]

import org.json4s.{Formats, ShortTypeHints}
import org.json4s.jackson.JsonMethods.parse
import org.json4s.jackson.Serialization
object TestJsonParse {
  def main(args: Array[String]): Unit = {
    val str =
      """
        | {"key":"login","data": {"name":"tom","id":3990}}
      """.stripMargin

    val value = parseMapValueString(str, "name")
    println("value: " + value)
  }
  /**
    * 解析 jsonString 嵌套中的 String 类型字段
    */
  def parseMapValueString(in: String, key: String): String = {
    implicit val formats: Formats = Serialization.formats(ShortTypeHints(List()))
    (parse(in) \\ key).extractOrElse[String]("").trim
  }

5 解析提取数组的json串

简单值数组

import org.json4s.JsonAST.{JArray, JInt}
import org.json4s.jackson.JsonMethods.parse
object TestJsonParse {
  def main(args: Array[String]): Unit = {
    val str =
      """
        | {"number": [1,2,3,4]}
      """.stripMargin
    //将 jsonString 转换为 JValue
    val JValue = parse(str)
    val listValue: List[BigInt] = for {JArray(child) <- JValue; JInt(value) <- child} yield value
    listValue.map(println)
  }

嵌套数组json串解析

import org.json4s.JsonAST.{JField, JInt, JObject, JString}
import org.json4s.jackson.JsonMethods.parse
object TestJsonParse {
  def main(args: Array[String]): Unit = {
    val str =
      """
        |  { "name": "joe",
        |           "children": [
        |             {
        |               "name": "Mary",
        |               "age": 5
        |             },
        |             {
        |               "name": "Mazy",
        |               "age": 3
        |             }
        |           ]
        |         }
      """.stripMargin
    //将 jsonString 转换为 JValue
    val json = parse(str)
//  List(JObject(List((name,JString(Mary)), (age,JInt(5)))), JObject(List((name,JString(Mazy)), (age,JInt(3)))))

    val listValue: List[BigInt] =  for {
      JObject(child) <- json
      JField("age", JInt(age)) <- child
    } yield age
    listValue.map(println)

    // 嵌套取数组中某个字段值，并添加过滤
    val listValue2: List[(String,BigInt)] = for {
      JObject(child) <- json
      JField("name", JString(name)) <- child
      JField("age", JInt(age)) <- child
      if age > 4
    } yield (name, age)

    listValue2.map(println)
  }
}

输出结果：

7 合并两个json

import org.json4s.jackson.JsonMethods.parse
import org.json4s.jackson.Serialization
import org.json4s.jackson.Serialization.write
import org.json4s.{DefaultFormats, Formats, ShortTypeHints}
import scala.collection.mutable
object TestJsonParse {
  def main(args: Array[String]): Unit = {
    val str =
      """
        |{"cp_game_id":692,"game_id":3990,"key":39891132}
        |""".stripMargin

    val str2 =
      """
        |{"game_id":611,"haha":"heihei"}
        |""".stripMargin
    
    val map1 = parseJsonStringToMap(str)
    val map2 = parseJsonStringToMap(str2)
    println(map1)
    println(map2)

    println("===========================")
    println(mergeJson(str, str2))
  }

  /**
    * 合并两个json
    */
  def mergeJson(json1: String, json2: String): String = {
    // 先转换为map
    val map = parseJsonStringToMap(json1).++(parseJsonStringToMap(json2))
    parseObjToJsonString(map)
  }

  /**
    * 将 jsonString 转换为 map
    */
  def parseJsonStringToMap(json: String): mutable.Map[String, Any] = {
    implicit val formats: Formats = Serialization.formats(ShortTypeHints(List()))
    parse(json, useBigDecimalForDouble = true).extract[mutable.Map[String, Any]]
  }

  /**
    * 将对象转换为 jsonString
    */
  def parseObjToJsonString(value: AnyRef): String = {
    implicit val formats: Formats = DefaultFormats
    write(value)
  }

输出结果：