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)
}
输出结果: