web-dev-qa-db-ja.com

Scalaで使用するJSONライブラリは何ですか？

次のようなJSON文字列を作成する必要があります。

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

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

行をjArray（jArray += ...など）に追加できる必要があります

これに最も近いライブラリ/ソリューションは何ですか？

jsonscala
116
David Portabella

残念ながら、JSONライブラリの作成は、Scalaコミュニティのtodoリストアプリのコーディングバージョンです。

かなりさまざまな選択肢があります。メモを付けて、順不同でリストします。

  1. parsing.json.JSON -警告このライブラリはScalaまでしか使用できません_バージョン2.9.x（新しいバージョンでは削除されました）
  2. spray-json -スプレープロジェクトから抽出
  3. Jerkson ±-WarningNiceライブラリ（Java Jacksonの上に構築） ）しかし、現在は放棄されています。これを使用する場合は、おそらくScaldingプロジェクトの例に従って、 backchat.io fork を使用してください。
  4. sjson -By Debasish Ghosh
  5. lift-json -Liftプロジェクトとは別に使用できます
  6. json4s §±-他のJSONライブラリが使用できる標準JSON ASTを作成しようとしているlift-jsonからの抽出。ジャクソン支援の実装が含まれています
  7. Argonaut §-Scalazの背後にいる人々によるScala用のFP指向のJSONライブラリ
  8. play-json ±-スタンドアロンで利用可能になりました。詳細については、 この回答を参照してください
  9. dijon -警告は放棄されました。動的に型指定されたScala JSONライブラリ
  10. sonofjson -超シンプルなAPIを目指したJSONライブラリ
  11. Jawn -ジャクソン以上の速度を目指したErik OsheimによるJSONライブラリ
  12. Rapture JSON ±-バックエンドとして2、4、5、6、7、11またはJacksonを使用できるJSONフロントエンド
  13. circe -scalazの代わりに cats の上に構築されたArgonautのフォーク
  14. jsoniter-scala -コンパイル時に超高速JSONコーデックを生成するためのScalaマクロ

§= Scalaz統合、±= Jacksonとの相互運用をサポートJsonNode

Snowplow では、json4sをJacksonバックエンドで使用しています。 Argonautでも良い経験をしました。

201
Alex Dean

Lift-jsonはバージョン2.6であり、非常にうまく機能します（また、非常によくサポートされており、メンテナーはユーザーが発見したバグをいつでも修正する準備ができています。 github repository

メンテナー（Joni Freeman）は、常に Lift mailing リストにアクセスできます。メーリングリストには、非常に役立つ他のユーザーもいます。

@Alexeyが指摘しているように、他のScalaバージョンでライブラリを使用する場合、たとえば2.11.xを変更し、scalaVersionを変更し、%%を次のように使用します。

scalaVersion := "2.11.5" 

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

liftweb.net サイトをチェックして、時間が経つにつれて最新バージョンを見つけることができます。

17
fmpwizard

jerkson を使用することをお勧めします。ほとんどの基本的な型変換をサポートしています。

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
paradigmatic

リストの7番目はジャクソンで、ジャークソンは使用していません。 Scalaオブジェクトをサポートしています（ケースクラスなど）。

以下は、私がそれをどのように使用するかの例です。

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

これにより、非常に簡単になります。さらに、XmlSerializerがあり、JAXBアノテーションのサポートは非​​常に便利です。

このブログ投稿では、JAXB AnnotationsおよびPlay Frameworkでの使用について説明しています。

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

これが私の現在のJacksonMapperです。

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
Ramon

たぶん私は少し遅れましたが、あなたは本当にプレイフレームワークからjsonライブラリを使用しようとする必要があります。 documentation を見ることができます。現在の2.1.1リリースでは、play 2全体なしでは個別に使用できなかったため、依存関係は次のようになります。

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

プレイフレームワーク全体を搭載し、すべてのものを搭載します。

しかし、私が知っているように、Typesafeの人は2.2リリースでそれを分離する計画を持っています。そのため、2.2-snapshotにはスタンドアロン play-json があります。

8
Alex Povar

json4sを使用してjsonファイルを書き込んでから読み取る基本的な実装を次に示します。

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
Akavall

Genson を確認する必要があります。これは機能するだけで、Scalaの既存のほとんどの代替手段よりもはるかに簡単に使用できます。それは高速で、多くの機能と他のライブラリ（jodatime、json4s DOM api ...）との統合を備えています。

暗黙的、基本的なケース用のカスタムリーダー/ライター、オペレーターのオーバーロードによる不明瞭なAPIのような派手な不必要なコードなし...

それを使用するのは簡単です：

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)

免責事項：私はGensonsの著者ですが、それは私が客観的ではないことを意味しません:)

5
eugen

Raptureは回答のリストにないようです。 http://rapture.io/ から取得でき、（特に）次のことができます。

  • jSONバックエンドを選択します。これを既に使用している場合に非常に便利です（インポート時）
  • try、Future、Option、Etherなどで作業するかどうかを決定します（インポートでも）
  • 1行のコードで多くの作業を行います。

Raptureのサンプルをそのページからコピー/貼り付けたくありません。 Raptureの機能に関する素敵なプレゼンテーションがSBTB 2014でJon Prettyによって行われました： https://www.youtube.com/watch?v=ka5-OLJgybI

4
Piohen

Jawn は、Scalaの非常に柔軟なJSONパーサーライブラリです。また、カスタムASTを生成できます。 ASTにマッピングするための小さな特性を提供する必要があります。

少しのJSON解析を必要とする最近のプロジェクトに最適です。

4
HRJ

@AlaxDeanの＃7の答え、 Argonaut は、sbtとintellijですばやく作業できた唯一のものです。実際、json4sも少しの時間しかかかりませんでしたが、生のASTを扱うことは私が望んでいたことではありません。 build.stに1行を追加することで、アルゴノートが機能するようになりました。

libraryDependencies += "io.argonaut" %% "argonaut" % "6.0.1"

そして、JSONを取得できるかどうかを確認する簡単なテスト：

package mytest


import scalaz._, Scalaz._
import argonaut._, Argonaut._

object Mytest extends App {

  val requestJson  =
    """
    {
      "userid": "1"
    }
    """.stripMargin

  val updatedJson: Option[Json] = for {
    parsed <- requestJson.parseOption
  } yield ("name", jString("testuser")) ->: parsed

  val obj = updatedJson.get.obj
  printf("Updated user: %s\n", updatedJson.toString())
  printf("obj : %s\n", obj.toString())
  printf("userid: %s\n", obj.get.toMap("userid"))
}

その後

$ sbt
> run
Updated user: Some({"userid":"1","name":"testuser"})
obj : Some(object[("userid","1"),("name","testuser")])
userid: "1"

Option に精通していることを確認してください。これは、nullになる可能性がある単なる値です（null安全だと思います）。 Argonautは Scalaz を使用するため、シンボル\/（または操作）のように理解できないことがある場合は、おそらくScalazです。

3
Bjorn Tipling

これを試すことができます： https://github.com/momodi/Json4Scala

シンプルで、300行未満のコードを持つscalaファイルが1つだけあります。

サンプルがあります：

test("base") {
    assert(Json.parse("123").asInt == 123)
    assert(Json.parse("-123").asInt == -123)
    assert(Json.parse("111111111111111").asLong == 111111111111111l)
    assert(Json.parse("true").asBoolean == true)
    assert(Json.parse("false").asBoolean == false)
    assert(Json.parse("123.123").asDouble == 123.123)
    assert(Json.parse("\"aaa\"").asString == "aaa")
    assert(Json.parse("\"aaa\"").write() == "\"aaa\"")

    val json = Json.Value(Map("a" -> Array(1,2,3), "b" -> Array(4, 5, 6)))
    assert(json("a")(0).asInt == 1)
    assert(json("b")(1).asInt == 5)
}
test("parse base") {
    val str =
        """
          {"int":-123, "long": 111111111111111, "string":"asdf", "bool_true": true, "foo":"foo", "bool_false": false}
        """
    val json = Json.parse(str)
    assert(json.asMap("int").asInt == -123)
    assert(json.asMap("long").asLong == 111111111111111l)
    assert(json.asMap("string").asString == "asdf")
    assert(json.asMap("bool_true").asBoolean == true)
    assert(json.asMap("bool_false").asBoolean == false)
    println(json.write())
    assert(json.write().length > 0)
}
test("parse obj") {
    val str =
        """
           {"asdf":[1,2,4,{"bbb":"ttt"},432]}
        """
    val json = Json.parse(str)
    assert(json.asMap("asdf").asArray(0).asInt == 1)
    assert(json.asMap("asdf").asArray(3).asMap("bbb").asString == "ttt")
}
test("parse array") {
    val str =
        """
           [1,2,3,4,{"a":[1,2,3]}]
        """
    val json = Json.parse(str)
    assert(json.asArray(0).asInt == 1)
    assert(json(4)("a")(2).asInt == 3)
    assert(json(4)("a")(2).isInt)
    assert(json(4)("a").isArray)
    assert(json(4)("a").isMap == false)
}
test("real") {
    val str = "{\"styles\":[214776380871671808,214783111085424640,214851869216866304,214829406537908224],\"group\":100,\"name\":\"AO4614【金宏达电子】现货库存 质量保证 欢迎购买@\",\"shopgrade\":8,\"price\":0.59,\"shop_id\":60095469,\"C3\":50018869,\"C2\":50024099,\"C1\":50008090,\"imguri\":\"http://img.geilicdn.com/taobao10000177139_425x360.jpg\",\"cag\":50006523,\"soldout\":0,\"C4\":50006523}"
    val json = Json.parse(str)
    println(json.write())
    assert(json.asMap.size > 0)
}
2
momodi

ここではフレームワーク全体ではなく、JSONライブラリのみのmavnリポジトリを見つけることができるPLAY JSONライブラリを使用しています

    val json = "com.typesafe.play" %% "play-json" % version
    val typesafe = "typesafe.com" at "http://repo.typesafe.com/typesafe/releases/"

それらの使用方法に関する非常に優れたチュートリアルは、ここから入手できます。

http://mandubian.com/2012/09/08/unveiling-play-2-dot-1-json-api-part1-jspath-reads-combinators/

http://mandubian.com/2012/10/01/unveiling-play-2-dot-1-json-api-part2-writes-format-combinators/

http://mandubian.com/2012/10/29/unveiling-play-2-dot-1-json-api-part3-json-transformers/

0
Montaro

JSONのSON バージョンも教えてください：

import nl.typeset.sonofjson._

arr(
  obj(id = 1, name = "John)
  obj(id = 2, name = "Dani)
)
0
Wilfred Springer

Playは、JSONをPlayフレームワークから独立して処理するためのモジュールをリリースしました Play WS

それについてのブログ記事を作成し、 http://pedrorijo.com/blog/scala-json/ でチェックしてください。

ケースクラス、および Play WS （Play Frameworkに既に含まれています）を使用すると、単純な1ライナーの暗黙的でJSONクラスとケースクラスの間でケース変換を実行できます。

case class User(username: String, friends: Int, enemies: Int, isAlive: Boolean)

object User {
  implicit val userJsonFormat = Json.format[User]
}
0
pedrorijo91

Pickle を使用します。これは、ネストされたケースクラスを自動的に処理するという大きな利点があります。

object SerializingApp extends App {

  case class Person(name: String, address: Address)

  case class Address(street: String, town: String, zipCode: String)

  import upickle.default._

  val john = Person("John Doe", Address("Elm Street 1", "Springfield", "ABC123"))

  val johnAsJson = write(john)
  // Prints {"name":"John Doe","address":{"street":"Elm Street 1","town":"Springfield","zipCode":"ABC123"}}
  Console.println(johnAsJson)

  // Parse the JSON back into a Scala object
  Console.println(read[Person](johnAsJson))  
}

UPickleを使用するには、これをbuild.sbtに追加します。

libraryDependencies += "com.lihaoyi" %% "upickle" % "0.4.3"
0
Matthias Braun