Scala json4s Json解析工具类

我就是我 2021-09-25 04:08 400阅读 0赞

package com.sm.utils
    
    import java.util
    
    import com.sm.common.utils.DateUtil
    import org.apache.commons.lang3.StringUtils
    import org.json4s._
    import org.json4s.jackson.JsonMethods._
    import org.json4s.jackson.Serialization
    import org.json4s.jackson.Serialization.{read, write}
    
    import scala.collection.mutable
    
    /**
      * create by LiuJinHe 2021/1/24
      */
    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 && StringUtils.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 && StringUtils.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 (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 = {
        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
        }
      }
    
      /**
        * 获取 JSONObject 对应 Key 的值, 过滤特殊字符
        */
      def parseRoleName(json: String, key: String): String = {
        val roleName = parseValueString(json, key)
        if (roleName.isEmpty) "" else roleName.replace("\\\n|\\\r|\"|\'|\\\\", "")
      }
    
    }