Question Quelle bibliothèque JSON utiliser dans Scala? [fermé]


J'ai besoin de construire une chaîne JSON, quelque chose comme ça:

[
  { 'id': 1, 'name': 'John'},
  { 'id': 2, 'name': 'Dani'}
]

val jArray = JsArray();
jArray += (("id", "1"), ("name", "John"))
jArray += (("id", "2"), ("name", "Dani"))
println(jArray.dump)

Je dois pouvoir ajouter des lignes à la jArray, quelque chose comme jArray += ...

Quelle est la bibliothèque / solution la plus proche de cela?


107
2017-11-08 16:47


origine


Réponses:


Malheureusement, l'écriture d'une bibliothèque JSON est la version de la communauté Scala pour coder une application de liste de tâches.

Il existe une grande variété d’alternatives. Je les liste sans ordre particulier, avec des notes:

  1. parsing.json.JSON - Attention cette bibliothèque est disponible uniquement jusqu'à la version 2.9.x de Scala (supprimée dans les nouvelles versions)
  2. spray-json - Extrait du projet Spray
  3. Jerkson ± - Attention une belle bibliothèque (construite sur Java Jackson) mais maintenant abandonware. Si vous allez utiliser ceci, suivez probablement l'exemple du projet Scalding et utilisez le fourche backchat.io
  4. sjson - par Debasish Ghosh
  5. lift-json - Peut être utilisé séparément du projet Lift
  6. json4s § ± - Une extraction de lift-json, qui tente de créer un AST JSON standard que d'autres bibliothèques JSON peuvent utiliser. Comprend une implémentation basée sur Jackson
  7. Argonaute § - Une bibliothèque JSON orientée FP pour Scala, par les personnes derrière Scalaz
  8. play-json ± - Maintenant disponible autonome, voir cette réponse pour plus de détails
  9. dijon - Attention abandonné. Une bibliothèque Scala JSON à typage dynamique
  10. sonofjson - Bibliothèque JSON visant à une API super simple
  11. Jawn - Bibliothèque JSON d'Erik Osheim visant une vitesse Jackson plus rapide
  12. Rapture JSON ± - un frontal JSON pouvant utiliser 2, 4, 5, 6, 7, 11 ou Jackson comme back-end
  13. faire le tour - la fourche d'Argonaut construite sur le dessus chats au lieu de scalaz
  14. jsoniter-scala - Macros Scala pour la génération à la compilation de codecs JSON ultra-rapides

§ = a l'intégration de Scalaz, ± = prend en charge l'interopérabilité avec Jackson JsonNode

Dans Chasse-neige nous utilisons des json4 avec le back-end de Jackson; nous avons eu de bonnes expériences avec Argonaut aussi.


181
2018-01-21 16:09



Lift-json est à la version 2.6 et il fonctionne très bien (et est également très bien pris en charge, le responsable est toujours prêt à corriger les bogues que les utilisateurs peuvent trouver. Vous pouvez trouver des exemples en l'utilisant sur le dépôt github

Le mainteneur (Joni Freeman) est toujours joignable sur le Envoi postal liste. Il y a aussi d'autres utilisateurs sur la liste de diffusion qui sont également très utiles.

Comme le souligne @Alexey, si vous souhaitez utiliser la bibliothèque avec d’autres versions de Scala, dites 2.11.x, changement scalaVersion et utilise %% comme suit:

scalaVersion := "2.11.5" 

"net.liftweb" %% "lift-json" % "2.6"

Vous pouvez vérifier le liftweb.net site pour découvrir la dernière version au fil du temps.


17
2017-11-08 17:06



Je suggère d'utiliser Jerkson, il prend en charge la plupart des conversions de type de base:

scala> import com.codahale.jerkson.Json._

scala> val l = List( 
                 Map( "id" -> 1, "name" -> "John" ),
                 Map( "id" -> 2, "name" -> "Dani")
               )

scala> generate( l )

res1: String = [{"id":1,"name":"John"},{"id":2,"name":"Dani"}]

15
2017-11-08 16:52



Le numéro 7 sur la liste est Jackson, sans Jerkson. Il prend en charge les objets Scala (classes de cas, etc.).

Vous trouverez ci-dessous un exemple d'utilisation.

object MyJacksonMapper extends JacksonMapper
val jsonString = MyJacksonMapper.serializeJson(myObject)
val myNewObject = MyJacksonMapper.deserializeJson[MyCaseClass](jsonString)

Cela le rend très simple. En outre, le XmlSerializer et la prise en charge des annotations JAXB sont très pratiques.

Ce billet décrit son utilisation avec les annotations JAXB et le framework Play.

http://krasserm.blogspot.co.uk/2012/02/using-jaxb-for-xml-and-json-apis-in.html

Voici mon JacksonMapper actuel.

trait JacksonMapper {

  def jsonSerializer = {
    val m = new ObjectMapper()
    m.registerModule(DefaultScalaModule)
    m
  }

  def xmlSerializer = {
    val m = new XmlMapper()
    m.registerModule(DefaultScalaModule)
    m
  }

  def deserializeJson[T: Manifest](value: String): T = jsonSerializer.readValue(value, typeReference[T])
  def serializeJson(value: Any) = jsonSerializer.writerWithDefaultPrettyPrinter().writeValueAsString(value)
  def deserializeXml[T: Manifest](value: String): T = xmlSerializer.readValue(value, typeReference[T])
  def serializeXml(value: Any) = xmlSerializer.writeValueAsString(value)

  private[this] def typeReference[T: Manifest] = new TypeReference[T] {
    override def getType = typeFromManifest(manifest[T])
  }

  private[this] def typeFromManifest(m: Manifest[_]): Type = {
     if (m.typeArguments.isEmpty) { m.erasure }
     else new ParameterizedType {
       def getRawType = m.erasure

       def getActualTypeArguments = m.typeArguments.map(typeFromManifest).toArray

       def getOwnerType = null
     }
  }
}   

10
2018-04-02 06:47



J'ai peut-être un peu de retard, mais vous devriez vraiment essayer d'utiliser la bibliothèque json à partir de la structure de lecture. Vous pourriez regarder Documentation. Dans la version 2.1.1 actuelle, vous ne pouviez pas l'utiliser séparément sans le jeu entier 2, donc la dépendance ressemblera à ceci:

val typesaferepo  = "TypeSafe Repo" at "http://repo.typesafe.com/typesafe/releases"
val play2 = "play" %% "play" % "2.1.1"

Cela vous apportera toute la structure de jeu avec toutes les choses à bord.

Mais comme je sais que les gars de Typesafe ont un plan pour le séparer dans la version 2.2. Donc, il y a autonome play-json à partir de 2.2-instantané.


7
2018-06-21 05:05



Vous devriez vérifier Genson. Cela fonctionne et est beaucoup plus facile à utiliser que la plupart des alternatives existantes à Scala. Il est rapide, possède de nombreuses fonctionnalités et intégrations avec d'autres bibliothèques (jodatime, api DOM json4s ...).

Tout cela sans aucun code inutile comme les implicits, les lecteurs / graveurs personnalisés pour les cas de base, l'API illisible due à la surcharge d'opérateur ...

Son utilisation est aussi simple que:

import com.owlike.genson.defaultGenson_

val json = toJson(Person(Some("foo"), 99))
val person = fromJson[Person]("""{"name": "foo", "age": 99}""")

case class Person(name: Option[String], age: Int)

Disclaimer: Je suis auteur Gensons, mais ça ne me dit pas que je ne suis pas objectif :)


5
2018-04-13 11:55



Voici une implémentation de base de l'écriture puis de la lecture json utiliser le fichier json4s.

import org.json4s._
import org.json4s.jackson.JsonMethods._
import org.json4s.JsonDSL._
import java.io._
import scala.io.Source


object MyObject { def main(args: Array[String]) {

  val myMap = Map("a" -> List(3,4), "b" -> List(7,8))

  // writing a file 
  val jsonString = pretty(render(myMap))

  val pw = new PrintWriter(new File("my_json.json"))
  pw.write(jsonString)
  pw.close()

  // reading a file 
  val myString = Source.fromFile("my_json.json").mkString
  println(myString)

  val myJSON = parse(myString)

  println(myJSON)

  // Converting from JOjbect to plain object
  implicit val formats = DefaultFormats
  val myOldMap = myJSON.extract[Map[String, List[Int]]]

  println(myOldMap)
 }
}

5
2018-05-14 22:02



Jawn est une bibliothèque de parseurs JSON très flexible à Scala. Il permet également la génération d'AST personnalisées; il vous suffit de lui fournir un petit trait à associer à l'AST.

A bien fonctionné pour un projet récent nécessitant un peu d'analyse JSON.


4
2017-09-02 10:35