Na página inicial do Play Framework, eles afirmam que "JSON é um cidadão de primeira classe". Eu ainda tenho que ver a prova disso.

No meu projeto estou lidando com algumas estruturas JSON bastante complexas. Este é apenas um exemplo muito simples:

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

Agora eu entendo que o Play está usando o Jackson para analisar o JSON. Eu uso o Jackson em meus projetos Java e eu faria algo simples assim:

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

Isso seria bom analisar meu JSON no objeto Map que é o que eu quero - Mapa de pares de seqüência de caracteres e objeto e permitir-me facilmente transmitir matriz paraArrayList.

O mesmo exemplo no Scala / Play seria assim:

val obj: JsValue = Json.parse(jsonString)

Isso, ao contrário, me dá uma propriedadeJsObject tipo que não é realmente o que eu sou depois.

Minha pergunta é: posso analisar a string JSON no Scala / Play toMap ao invés deJsObject tão facilmente como eu faria em Java?

Pergunta secundária: existe uma razão pela qualJsObject é usado em vez deMap em Scala / Play?

Minha pilha: Play Framework 2.2.1 / Scala 2.10.3 / Java 8 64 bits / Ubuntu 13.10 64 bits

ATUALIZAR: Eu posso ver que a resposta de Travis está em ascensão, então eu acho que faz sentido para todos, mas eu ainda não consigo ver como isso pode ser aplicado para resolver o meu problema. Digamos que tenhamos este exemplo (jsonString):

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

Bem, de acordo com todas as direções, eu deveria colocar todo esse clichê que eu não entendo o propósito de:

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

Parece bom ir, né? Mas espere um minuto, vem outro elemento na matriz que destrói totalmente essa abordagem:

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

O terceiro elemento não combina mais com a minha classe de caso definida - estou novamente no primeiro lugar. Eu sou capaz de usar essas estruturas JSON muito mais complicadas em Java todos os dias, Scala sugere que eu deveria simplificar meus JSONs para ajustar sua política de "tipo seguro"? Corrija-me se estiver errado, mas acho que essa linguagem deve servir os dados, e não o contrário?

UPDATE2: A solução é usar o módulo Jackson para scala (exemplo na minha resposta).