Na stronie głównej Play Framework twierdzą, że „JSON jest obywatelem pierwszej klasy”. Nie widziałem jeszcze tego dowodu.

W moim projekcie mam do czynienia z dość złożonymi strukturami JSON. To jest bardzo prosty przykład:

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

Teraz rozumiem, że Play używa Jacksona do analizowania JSON. Używam Jacksona w moich projektach Java i zrobiłbym coś prostego w ten sposób:

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

To ładnie przeanalizowałoby mój JSON w obiekt Map, który jest tym, czego chcę - Mapa par ciągów i obiektów i pozwoliłaby mi łatwo rzutować tablicę naArrayList.

Ten sam przykład w Scala / Play wyglądałby tak:

val obj: JsValue = Json.parse(jsonString)

To daje mi zastrzeżonyJsObject rodzaj co tak naprawdę nie jest tym, czego szukam.

Moje pytanie brzmi: czy mogę przetworzyć ciąg JSON w Scala / Play naMap zamiastJsObject tak samo łatwo, jak robiłbym to w Javie?

Pytanie dodatkowe: czy jest powód, dla któregoJsObject jest używany zamiastMap w Scala / Play?

Mój stos: Play Framework 2.2.1 / Scala 2.10.3 / Java 8 64bit / Ubuntu 13.10 64bit

AKTUALIZACJA: Widzę, że odpowiedź Travisa jest poprawiona, więc myślę, że ma to sens dla wszystkich, ale wciąż nie widzę, jak można to zastosować, aby rozwiązać mój problem. Powiedzmy, że mamy ten przykład (jsonString):

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

Cóż, zgodnie ze wszystkimi wskazówkami, powinienem teraz umieścić cały ten szablon, którego inaczej nie rozumiem w celu:

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

Wygląda dobrze, prawda? Ale poczekaj chwilę, pojawia się kolejny element w tablicy, który całkowicie niszczy to podejście:

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

Trzeci element nie pasuje już do mojej zdefiniowanej klasy przypadku - znów jestem na pierwszym miejscu. Jestem w stanie codziennie używać takich i znacznie bardziej skomplikowanych struktur JSON w Javie, czy Scala sugeruje, że powinienem uprościć moje JSON, aby dopasować je do polityki „bezpiecznej dla typu”? Popraw mnie, jeśli się mylę, ale myślę, że ten język powinien służyć danym, a nie na odwrót?

UPDATE2: Rozwiązaniem jest użycie modułu Jacksona do scala (przykład w mojej odpowiedzi).