Comment sérialiser une Carte en JSON dans Scala?

J'ai donc une Carte à la Scala comme ceci:

val m = Map[String, String](
    "a" -> "theA",
    "b" -> "theB",
    "c" -> "theC",
    "d" -> "theD",
    "e" -> "theE"
)

et je tiens à sérialiser cette structure dans une chaîne JSON à l'aide de l'ascenseur-json.

Un sait comment faire cela?

InformationsquelleAutor Jay Taylor | 2011-06-07
  1. 26

    Comment à ce sujet?

    implicit val formats = net.liftweb.json.DefaultFormats
import net.liftweb.json.JsonAST._
import net.liftweb.json.Extraction._
import net.liftweb.json.Printer._
val m = Map[String, String](
    "a" -> "theA",
    "b" -> "theB",
    "c" -> "theC",
    "d" -> "theD",
    "e" -> "theE"
)
println(compact(render(decompose(m))))

    de sortie:

    {"e":"theE","a":"theA","b":"theB","c":"theC","d":"theD"}

    EDIT:

    Pour un scala.collections.mutable.Map, vous devez le convertir en d'abord à un immuable carte: .toMap

    • Quand j'ai changer le type de scala.les collections.mutable.La carte, la sortie devient: [{"_1":"d","_2":"theD"},{"_1":"a","_2":"theA"},{"_1":"c","_2":"theC"},{"_1":"b","_2":"theB"},{"_1":"e","_2":"theE"}], ce qui me rend un peu triste.
    • Il est facile de contourner ce -- appelez simplement .toMap sur la mutable carte pour obtenir un immuable de la carte, et puis les choses fonctionnent bien à nouveau.
    • Mais que faire si vous voulez conserver l'ordre des éléments dans la carte? En gros, comment json-sérialiser une LinkedHashMap? L'appel de toMap peut modifier l'ordre des entrées.
    • N'est-ce pas de ce genre au-delà de la portée de ce qui JSON prend en charge? Cela ressemble à un travail pour un tableau.
    InformationsquelleAutor
  2. 33

    Si vous utilisez la dernière version de Scala 2.10.x et au-dessus :

    println(scala.util.parsing.json.JSONObject(m))
    • Il a été retiré de la Scala 2.11 et au-dessus.
    • on dirait qu'il est toujours là : scala-lang.org/api/2.11.8/scala-parser-combinators/...
    • Je risque de faire une erreur quelque part. Mais avez-vous été en mesure de l'utiliser? Quelle est la version de scala-parser-combinators avez-vous utilisé (une dépendance maven serait utile)?
    • On dirait qu'il ne veut pas répéter correctement dans l'objet. Par exemple, Map("0" -> 1, "1" -> List(Map("2" -> 3))) est stringified à {"0" : 1, "1" : List(Map(2 -> 3))}.
    InformationsquelleAutor Raja
  3. 6

    Vous pouvez rouler votre propre assez facilement (yay, pas de dépendances). Celui-ci fait de base de la manipulation de types et va faire de la récursivité à la différence de JSONObject qui a été mentionné:

    import scala.collection.mutable.ListBuffer
object JsonConverter {
def toJson(o: Any) : String = {
var json = new ListBuffer[String]()
o match {
case m: Map[_,_] => {
for ( (k,v) <- m ) {
var key = escape(k.asInstanceOf[String])
v match {
case a: Map[_,_] => json += "\"" + key + "\":" + toJson(a)
case a: List[_] => json += "\"" + key + "\":" + toJson(a)
case a: Int => json += "\"" + key + "\":" + a
case a: Boolean => json += "\"" + key + "\":" + a
case a: String => json += "\"" + key + "\":\"" + escape(a) + "\""
case _ => ;
}
}
}
case m: List[_] => {
var list = new ListBuffer[String]()
for ( el <- m ) {
el match {
case a: Map[_,_] => list += toJson(a)
case a: List[_] => list += toJson(a)
case a: Int => list += a.toString()
case a: Boolean => list += a.toString()
case a: String => list += "\"" + escape(a) + "\""
case _ => ;
}
}
return "[" + list.mkString(",") + "]"
}
case _ => ;
}
return "{" + json.mkString(",") + "}"
}
private def escape(s: String) : String = {
return s.replaceAll("\"" , "\\\\\"");
}
}

    Vous pouvez le voir en action comme

    println(JsonConverter.toJson(
Map("a"-> 1,
"b" -> Map(
"nes\"ted" -> "yeah{\"some\":true"),
"c" -> List(
1,
2,
"3",
List(
true,
false,
true,
Map(
"1"->"two",
"3"->"four"
)
)
)
)
)
)
{"a":1,"b":{"nes\"ted":"yeah{\"some\":true"},"c":[1,2,"3",[true,false,true,{"1":"two","3":"four"}]]}

    (Il fait partie d'une Coinbase GDAX bibliothèque que j'ai écrit, voir util.scala)

    InformationsquelleAutor jar
  4. 3

    Vous pouvez utiliser ce moyen simple si vous utilisez jouer au cadre:

    import play.api.libs.json._
Json.toJson(<your_map>)
    InformationsquelleAutor Haimei
  5. 1

    Ce code permet de convertir de nombreux objets différents, et ne nécessite pas de bibliothèques au-delà de l'intégré dans le scala.util.parsing.json._. Il ne sera pas de traiter correctement les cas limites, telles que des Cartes avec des nombres entiers comme les clés.

    import scala.util.parsing.json.{JSONArray, JSONObject}
def toJson(arr: List[Any]): JSONArray = {
JSONArray(arr.map {
case (innerMap: Map[String, Any]) => toJson(innerMap)
case (innerArray: List[Any])      => toJson(innerArray)
case (other)                      => other
})
}
def toJson(map: Map[String, Any]): JSONObject = {
JSONObject(map.map {
case (key, innerMap: Map[String, Any]) =>
(key, toJson(innerMap))
case (key, innerArray: List[Any]) =>
(key, toJson(innerArray))
case (key, other) =>
(key, other)
})
}
    InformationsquelleAutor robert
  6. 0

    Similaire à Einar de la solution, vous pouvez utiliser JSONObject de Analyseur Combinators pour ce faire. Notez qu'il n'est pas récursif, vous aurez besoin de le faire vous-même. La bibliothèque comprend également JSONArray, pour la liste comme des structures de données. Quelque chose comme ce qui suit traitera de Noel des préoccupations au sujet de structures imbriquées. Cet exemple n'est pas récursif à un niveau arbitraire, mais la poignée d'une valeur de Liste[Carte[Chaîne, Toute]].

    import scala.util.parsing.json.{JSONArray, JSONObject}
def toJson(m : Map[String, Any]): String = JSONObject(
m.mapValues {
case mp: Map[String, Any] => JSONObject(mp)
case lm: List[Map[String, Any]] => JSONArray(lm.map(JSONObject(_)))
case x => x
}
).toString
    InformationsquelleAutor jwhitlark
  7. 0

    Complétant la réponse de @Raja.

    Pour ceux objet imbriqué, j'ai modifier localement la classe d'avoir mon voulait toString() comme de cette façon:

    case class MList[T]() extends MutableList[T] {
    override def toString() = "[" + this.toList.mkString(",") + "]"
    }

    Puis à l'intérieur de l'objet Map, j'utilise ce MList au lieu de la norme List. De cette façon, mon map objet imprime fine en appelant JSONObject(map).toString().

    InformationsquelleAutor Junji Shimagaki