En la página de inicio de Play Framework afirman que "JSON es un ciudadano de primera clase". Todavía tengo que ver la prueba de eso.

En mi proyecto estoy tratando con algunas estructuras JSON bastante complejas. Este es solo un ejemplo muy simple:

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

Ahora entiendo que Play está usando a Jackson para analizar JSON. Utilizo Jackson en mis proyectos Java y haría algo simple como esto:

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

Esto podría analizar muy bien mi JSON en el objeto Map, que es lo que quiero: mapear pares de cadenas y objetos y me permitiría convertir fácilmente la matriz aArrayList.

El mismo ejemplo en Scala / Play se vería así:

val obj: JsValue = Json.parse(jsonString)

Esto en cambio me da un propietario.JsObject tipo que no es realmente lo que estoy buscando.

Mi pregunta es: ¿puedo analizar la cadena JSON en Scala / Play toMap en lugar deJsObject ¿Tan fácilmente como lo haría en Java?

Pregunta lateral: ¿hay alguna razón por la cualJsObject se utiliza en lugar deMap en Scala / Play?

Mi pila: Play Framework 2.2.1 / Scala 2.10.3 / Java 8 64bit / Ubuntu 13.10 64bit

ACTUALIZAR: Puedo ver que la respuesta de Travis está mejorada, por lo que creo que tiene sentido para todos, pero todavía no veo cómo se puede aplicar para resolver mi problema. Digamos que tenemos este ejemplo (jsonString):

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

Bueno, de acuerdo con todas las instrucciones, ahora debería poner todo el contenido que de otra manera no entiendo el propósito de:

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

Se ve bien para ir, ¿eh? Pero espere un minuto, llega otro elemento a la matriz que arruina totalmente este enfoque:

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

El tercer elemento ya no coincide con mi clase de caso definida: estoy en el punto uno de nuevo. Soy capaz de usar estructuras JSON mucho más complicadas en Java todos los días. ¿Scala sugiere que debería simplificar mis JSON para que se ajusten a su política de "seguridad de tipo"? Corríjame si me equivoco, pero ¿creo que ese lenguaje debería servir los datos, y no al revés?

ACTUALIZACIÓN2: La solución es usar el módulo Jackson para scala (ejemplo en mi respuesta).