在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)

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

我需要能够将行添加到

jArray

，类似于

jArray+=…

与此最接近的库/解决方案是什么？

我建议使用，它支持最基本的类型转换：

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"}]

---

Lift json的版本是2.6，它运行得非常好（而且也得到了很好的支持，维护人员随时准备修复用户可能发现的任何bug）。 你可以在网上找到使用它的例子

维护人员（Joni Freeman）在列表中总是可以联系到的。邮件列表中还有其他用户也非常有帮助

正如@Alexey所指出的，如果您想将该库与其他Scala版本一起使用，可以说

2.11.x

，更改

scalaVersion

并使用

%%

，如下所示：

scalaVersion := "2.11.5" 

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

---

随着时间的推移，您可以查看该网站以了解最新版本。

不幸的是，编写JSON库是Scala社区编写待办事项列表应用程序的版本

有很多种选择。我没有按特定顺序列出它们，并附上注释：

-警告此库仅在Scala 2.9.x版之前可用（在较新版本中删除）

-从喷洒项目中提取

±-警告一个很好的库（构建在Java Jackson之上），但现在放弃了它。如果您要使用它，可能要遵循Burning项目的示例并使用

-德巴西什·戈什

-可与电梯项目分开使用

---

列表中的第7位是Jackson，没有使用Jerkson。它支持Scala对象（case类等）

下面是我如何使用它的一个例子

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

此外，XmlSerializer和对JAXB注释的支持非常方便

这篇博文描述了它与JAXB注释和Play框架的结合使用

这是我现在的JacksonApper

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
     }
  }
}   

---

也许我晚了一点，但您确实应该尝试使用play framework中的json库。 您可以看看。在当前的2.1.1版本中，如果没有完整的play 2，您无法单独使用它，因此依赖关系如下所示：

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

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

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

它会给你带来一个完整的游戏框架和所有的东西

但据我所知，Typesafe的人计划在2.2版本中将其分离。因此，2.2-snapshot中有独立版本。

@AlaxDean的#7答案，是我唯一能够快速使用sbt和intellij的答案。实际上json4s也花了很少的时间，但处理原始AST并不是我想要的。我让argonaut通过putt工作在我的build.st中插入一行代码：

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"))
}

请确保您熟悉的只是一个也可以为null的值（我猜是null-safe）。Argonaut会利用它，如果您看到一些您不理解的东西，比如符号

\/

（一个或操作），它可能是Scalaz。

我使用PLAY JSON库 您可以在这里找到仅用于JSON库而不是整个框架的MavnRepo

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

有关如何使用它们的非常好的教程，请访问：

是Scala中一个非常灵活的JSON解析器库。它还允许生成自定义AST；您只需要为它提供一个小特性来映射到AST

对于最近的一个需要一点JSON解析的项目来说效果非常好。

让我再给你一个版本：

---

答案列表中似乎缺少欣喜若狂。 它可以从以下位置获得，并允许您（除其他外）：

• 选择JSON后端，如果您已经使用了JSON后端（在导入中），这将非常有用
• 决定是否使用Try、Future、Option、other等（也在导入中）
• 在一行代码中完成大量工作

我不想复制/粘贴Rapture页面上的示例。Jon Pretty在SBTB 2014上对Rapture的功能做了一个很好的介绍：

你应该检查一下。 与Scala中的大多数现有替代方案相比，它工作正常且易于使用。它速度快，具有许多功能，并与其他一些LIB（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的作者，但这并不意味着我不客观：）

以下是使用

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)
 }
}

您可以尝试以下方法：

它很简单，只有一个scala文件，代码不到300行

有以下样本：

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)
}

---

Play发布了独立于Play框架处理JSON的模块

写了一篇关于这个的博客文章，请访问

使用case类，并且（已经包含在Play框架中）使用简单的一行隐式语句在json和case类之间进行case转换

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

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

我使用它的最大优点是它将自动处理嵌套的案例类：

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))  
}

将此添加到您的

build.sbt

以使用uPickle：

libraryDependencies += "com.lihaoyi" %% "upickle" % "0.4.3"

---

它还对case类提供了一些非常棒的支持，可以实现一些非常优雅和类型安全的JSON处理。这个库已经被作者放弃了，还有其他选择吗？让我们不要忘记它“是一系列Scala库，为常见编程任务提供了漂亮的惯用Scala API，如处理I/O、加密和JSON&XML处理。”我也使用lift JSON，可以证明它是一个很棒的库。它使解析和生成/序列化JSON非常容易。+1表示“net.liftweb”%“lift-JSON_2.10”%“2.5.1对于Scala 2.11：“net.liftweb”%”lift-json_2.11“%”2.6-M4“lift-json对象已存档。最好的现代解决方案是。的可能副本是最好的现代解决方案