Scala / Play: Parsen Sie JSON in Map anstelle von JsObject

Auf der Homepage von Play Framework wird behauptet, dass "JSON ein erstklassiger Bürger ist". Ich habe den Beweis dafür noch nicht gesehen.

In meinem Projekt beschäftige ich mich mit ziemlich komplexen JSON-Strukturen. Dies ist nur ein sehr einfaches Beispiel:

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

Jetzt verstehe ich, dass Play Jackson zum Parsen von JSON verwendet. Ich benutze Jackson in meinen Java-Projekten und würde so etwas Einfaches machen:

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

Dies würde mein JSON-Objekt schön in ein Map-Objekt zerlegen, was ich will - eine Zuordnung von String- und Objektpaaren, und es mir ermöglichen, das Array auf einfache Weise in ein Map-Objekt umzuwandelnArrayList.

Das gleiche Beispiel in Scala / Play würde so aussehen:

val obj: JsValue = Json.parse(jsonString)

Dies gibt mir stattdessen eine proprietäreJsObject Art Das ist nicht wirklich das, wonach ich suche.

Meine Frage ist: Kann ich JSON-Zeichenfolgen in Scala / Play analysieren?Map anstattJsObject genauso einfach wie ich es in Java machen würde?

Nebenfrage: Gibt es einen Grund warumJsObject wird anstelle von verwendetMap in Scala / Spielen?

Mein Stack: Play Framework 2.2.1 / Scala 2.10.3 / Java 8 64bit / Ubuntu 13.10 64bit

AKTUALISIEREN: Ich kann sehen, dass Travis 'Antwort positiv bewertet ist, also denke ich, dass es für alle sinnvoll ist, aber ich sehe immer noch nicht, wie dies zur Lösung meines Problems angewendet werden kann. Angenommen, wir haben dieses Beispiel (jsonString):

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

Nun, nach all den Anweisungen sollte ich jetzt all das einbauen, was ich sonst nicht verstehe:

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

Sieht gut aus, was? Aber Moment mal, da kommt noch ein anderes Element ins Array, das diesen Ansatz völlig ruiniert:

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

Das dritte Element entspricht nicht mehr meiner definierten Fallklasse - ich bin wieder auf dem ersten Platz. Ich bin in der Lage, solche und viel komplizierteren JSON-Strukturen in Java jeden Tag zu verwenden. Schlägt Scala vor, dass ich meine JSONs vereinfachen sollte, um sie an die "typensichere" Richtlinie anzupassen? Korrigieren Sie mich, wenn ich falsch liege, aber ich denke, diese Sprache sollte den Daten dienen, nicht umgekehrt?

UPDATE2: Lösung ist, Jackson-Modul für Scala zu verwenden (Beispiel in meiner Antwort).