Scala json4s 使用

引入

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

常用的查询方法

// 引入依赖
import org.json4s._
import org.json4s.native.JsonMethods._

// 转换
val json = JsonMethods.parse("""
    { "name": "ifan",
      "age": 1,
      "friend": [
        {
          "name": "ifan1",
          "age": 1
        },
        {
          "name": "ifan2",
          "age": 2
        }
      ]
    }
  """)

for {
  JObject(friend) <- json
  JField("age", JInt(age))  <- friend
} (
  println(age, friend)
)

for {
  JObject(friend) <- json
  JField("name", JString(name)) <- friend
  JField("age", JInt(age))  <- friend
  if age == 1
} yield (name, age)

xpath 模式获取

import org.json4s.jackson.JsonMethods._
import org.json4s.JsonDSL._
// 还是上面的Json

println(json \ "name")
println(json \ "sex")
println(compact(render(json \\ "name")))
// 过滤
println(compact(render((json removeField { _ == JField("name", JString("ifan")) }) \\ "name")))
// 查找并返回字段
println(json findField  {
  case JField("name", _) => true
  case _ => false
})
// 过滤字段
println(json filterField   {
  case JField("name", _) => true
  case _ => false
})
// 修改Json
println(json transformField {
  case JField("name", JString(s)) => ("NAME", JString(s.toUpperCase))
})
// 查看数据
println(json.values)

// 获取数组元素
println((json \ "friend" )(0))
// 获取Int类型的数据
println(json \\ classOf[JInt])

Utils 方法

package tech.valuesimplex.data.analyse.utils.common

import org.joda.time.DateTime
import org.json4s.{Formats, ShortTypeHints}
import org.json4s.jackson.Serialization
import org.json4s._
import org.json4s.jackson.JsonMethods._
import org.json4s.jackson.Serialization
import org.json4s.jackson.Serialization.{read, write}

import java.sql.Date
import java.text.SimpleDateFormat
import scala.collection.mutable
import scala.util.{Success, Try}

object JsonParseUtils {
  implicit val formats: Formats = Serialization.formats(ShortTypeHints(List()))


  /**
   * 检验json
   */
  def validateJson(in: String): Boolean = {
    try {
      parse(in)
      true
    } catch {
      case _: Exception => false
    }
  }

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

  /**
   * 将 jsonString 转换为map
   */
  def parseJsonStringToObj(in: String): Object = {
    //    compact(render(in))
    parse(in, useBigDecimalForDouble = true).extract[Object]
  }

  /**
   * 将 jsonString 转换为map
   *
   */
  def readJsonStringToObj(in: String): Object = {
    read[Object](in)
  }

  /**
   * 将 jValue 转换为 jsonString
   */
  def parseJValueToJsonString(obj: JValue): String = {
    compact(render(obj))
  }

  /**
   * 将 jValue 转换为 jsonString
   */
  def prettyJValueToJsonString(obj: JValue): String = {
    pretty(render(obj))
  }

  /**
   * 将 jsonString 转换为 JValue
   */
  def parseJsonStringToJValue(in: String): JValue = {
    parse(in)
  }

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

  /**
   * 添加或更新 jsonString 中的字段
   */
  def upsertKeyValueToJsonString(json: String, key: String, value: Any): String = {
    val map = parseJsonStringToMap(json).+((key, value))
    parseObjToJsonString(map)
  }

  /**
   * 更新 jsonString 的字段
   */
  def alterKeyValueOfJsonString(json: String, key: String, value: Any): String = {
    val map = parseJsonStringToMap(json)
    map(key) = value
    parseObjToJsonString(map)
  }

  /**
   * 移除jsonString的字段
   */
  def removeKeyOfJsonString(json: String, key: String): String = {
    val map = parseJsonStringToMap(json).-=(key)
    parseObjToJsonString(map)
  }

  /**
   * 合并两个jValue
   */
  def mergeJValue(json1: JValue, json2: JValue): String = {
    (json1 merge json2).toString
  }

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

  /**
   * 判断 jsonString 中是否包含某个 key
   */
  def containsKey(in: String, key: String): Boolean = {
    parse(in).findField(_._1.equals(key)).nonEmpty
  }

  /**
   * 解析 jsonString 中的 String 类型字段
   */
  def parseValueString(in: String, key: String): String = {
    (parse(in) \ key).extractOrElse[String]("").trim
  }

  /**
   * 解析 jsonString 中的 Int 类型字段
   */
  def parseValueInt(in: String, key: String): Int = {
    val numStr = (parse(in) \ key).extractOrElse[String]("0")
    if (numStr.nonEmpty && isNumeric(numStr)) numStr.toInt else 0
  }

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

  /**
   * 解析 jsonString 中的 Double 类型字段
   */
  def parseValueDouble(in: String, key: String): Double = {
    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 = {
    val ts = (parse(in) \ key).extractOrElse[String]("0")
    if (isNumeric(ts)) {
      val timestamp = ts.toLong
      ts.length match {
        case 10 => timestampToTime(timestamp * 1000)
        case 13 => timestampToTime(timestamp)
        case _ => getNowTime
      }
    } else {
      ts
    }
  }

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

  /**
   * 获取 JSONObject 对应 Key 的值, 过滤特殊字符
   */
  def parseRoleName(json: String, key: String): String = {
    val roleName = parseValueString(json, key)
    if (roleName.isEmpty) "" else roleName.replace("\\\n|\\\r|\"|\'|\\\\", "")
  }

  /**
   * 判断字符串是否是数字
   *
   * @param str
   * @return
   */
  def isNumeric(str: String): Boolean = {
    scala.util.Try(str.toLong) match {
      case Success(_) => true;
      case _ => false
    }
  }

  def timestampToDate(ts: Long): String = {
    new Date(ts).formatted("yyyy-MM-dd")
  }

  def timestampToTime(ts: Long): String = {
    new DateTime(ts).formatted("yyyy-MM-dd HH:mm:ss")
  }

  def getTodayDate(): String = {
    new Date(System.currentTimeMillis()).formatted("yyyy-MM-dd")
  }

  def getNowTime(): String = {
    DateTime.now().formatted("yyyy-MM-dd HH:mm:ss")
  }

}