Scala/Play：将 JSON 解析为 Map 而不是 JsObject

json java scala playframework playframework-2.0

2022-09-01 19:44:50

在Play Framework的主页上，他们声称“JSON是一等公民”。我还没有看到这方面的证据。

在我的项目中，我正在处理一些非常复杂的JSON结构。这只是一个非常简单的例子：

{
    "key1": {
        "subkey1": {
            "k1": "value1"
            "k2": [
                "val1",
                "val2"
                "val3"
            ]
        }
    }
    "key2": [
        {
            "j1": "v1",
            "j2": "v2"
        },
        {
            "j1": "x1",
            "j2": "x2"
        }
    ]
}

现在我明白了Play正在使用Jackson来解析JSON。我在我的Java项目中使用Jackson，我会做一些简单的事情，比如这样：

ObjectMapper mapper = new ObjectMapper();
Map<String, Object> obj = mapper.readValue(jsonString, Map.class);

这将很好地将我的JSON解析为Map对象，这就是我想要的 - 字符串和对象对的Map，并允许我轻松地将数组转换为。ArrayList

Scala/Play 中的相同示例如下所示：

val obj: JsValue = Json.parse(jsonString)

相反，这给了我一个专有类型，这并不是我所追求的。JsObject

我的问题是：我能否在Scala/Play中解析JSON字符串，而不是像在Java中那样容易地进行解析？MapJsObject

题外话：在Scala/Play中使用而不是使用的原因是什么？JsObjectMap

我的堆栈： Play Framework 2.2.1 / Scala 2.10.3 / Java 8 64bit / Ubuntu 13.10 64bit

更新：我可以看到特拉维斯的答案是赞成的，所以我想这对每个人都有意义，但我仍然没有看到如何应用它来解决我的问题。假设我们有这个例子（jsonString）：

[
    {
        "key1": "v1",
        "key2": "v2"
    },
    {
        "key1": "x1",
        "key2": "x2"
    }
]

好吧，根据所有方向，我现在应该放入所有我不理解其目的的样板：

case class MyJson(key1: String, key2: String)
implicit val MyJsonReads = Json.reads[MyJson]
val result = Json.parse(jsonString).as[List[MyJson]]

看起来不错，对吧？但是等一下，数组中还有另一个元素，这完全破坏了这种方法：

[
    {
        "key1": "v1",
        "key2": "v2"
    },
    {
        "key1": "x1",
        "key2": "x2"
    },
    {
        "key1": "y1",
        "key2": {
            "subkey1": "subval1",
            "subkey2": "subval2"
        }
    }
]

第三个元素不再匹配我定义的 case 类 - 我又回到了原点。我每天都可以在Java中使用如此复杂的JSON结构，Scala是否建议我应该简化我的JSON以适应它的“类型安全”策略？如果我错了，请纠正我，但是我通过这种语言应该提供数据，而不是相反？

更新2：解决方案是将Jackson模块用于scala（我的答案中的示例）。

答案 1

一般来说，Scala不鼓励使用下放，而Play Json在这方面是惯用语。下放是一个问题，因为它使编译器无法帮助您跟踪无效输入或其他错误的可能性。一旦你有了一个类型值，你就只能靠自己了——编译器无法帮助你跟踪这些值可能是什么。Map[String, Any]Any

您有几个选择。第一种方法是使用路径运算符导航到树中您知道类型的特定点：

scala> val json = Json.parse(jsonString)
json: play.api.libs.json.JsValue = {"key1": ...

scala> val k1Value = (json \ "key1" \ "subkey1" \ "k1").validate[String]
k1Value: play.api.libs.json.JsResult[String] = JsSuccess(value1,)

这类似于以下内容：

val json: Map[String, Any] = ???

val k1Value = json("key1")
  .asInstanceOf[Map[String, Any]]("subkey1")
  .asInstanceOf[Map[String, String]]("k1")

但前一种方法的优点是，以更容易推理的方式失败。而不是一个潜在的难以解释的异常，我们只会得到一个不错的值。ClassCastExceptionJsError

请注意，如果我们知道我们期望什么样的结构，我们可以在树中更高的点进行验证：

scala> println((json \ "key2").validate[List[Map[String, String]]])
JsSuccess(List(Map(j1 -> v1, j2 -> v2), Map(j1 -> x1, j2 -> x2)),)

这两个 Play 示例都是基于类型类的概念构建的，尤其是基于 Play 提供的类型类的实例。您还可以为自己定义的类型提供自己的类型类实例。这将允许您执行类似如下操作：Read

val myObj = json.validate[MyObj].getOrElse(someDefaultValue)

val something = myObj.key1.subkey1.k2(2)

或者别的什么。Play文档（上面链接）很好地介绍了如何做到这一点，如果您遇到问题，您可以随时在此处提出后续问题。

要解决问题中的更新，可以更改模型以适应的不同可能性，然后定义您自己的实例：key2Reads

case class MyJson(key1: String, key2: Either[String, Map[String, String]])

implicit val MyJsonReads: Reads[MyJson] = {
  val key2Reads: Reads[Either[String, Map[String, String]]] =
    (__ \ "key2").read[String].map(Left(_)) or
    (__ \ "key2").read[Map[String, String]].map(Right(_))

  ((__ \ "key1").read[String] and key2Reads)(MyJson(_, _))
}

它的工作原理如下：

scala> Json.parse(jsonString).as[List[MyJson]].foreach(println)
MyJson(v1,Left(v2))
MyJson(x1,Left(x2))
MyJson(y1,Right(Map(subkey1 -> subval1, subkey2 -> subval2)))

是的，这有点冗长，但是您只需支付一次即可预先冗长（这为您提供了一些很好的保证），而不是一堆可能导致令人困惑的运行时错误的转换。

它并不适合所有人，也可能不符合您的口味 - 这完全没问题。您可以使用路径运算符来处理此类情况，甚至是普通的老杰克逊。不过，我鼓励你给类型类方法一个机会——有一个陡峭的学习曲线，但很多人（包括我自己）非常喜欢它。

答案 2

我选择将Jackson模块用于scala。

import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.module.scala.DefaultScalaModule
import com.fasterxml.jackson.module.scala.experimental.ScalaObjectMapper

val mapper = new ObjectMapper() with ScalaObjectMapper
mapper.registerModule(DefaultScalaModule)
val obj = mapper.readValue[Map[String, Object]](jsonString)