다음과 같은 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 += ...
이것에 가장 가까운 라이브러리 / 솔루션은 무엇입니까?
답변:
불행히도 JSON 라이브러리를 작성하는 것은 할 일 목록 앱을 코딩하는 Scala 커뮤니티 버전입니다.
매우 다양한 대안이 있습니다. 특정 순서없이 메모와 함께 나열합니다.
💣 = 수정 된 보안 취약점 없음, § = Scalaz 통합 있음, ± = Jackson과의 상호 운용 지원 JsonNode
Snowplow 에서는 Jackson 백엔드와 함께 json4s를 사용합니다. 우리는 Argonaut에 대해서도 좋은 경험을했습니다.
Lift-json은 버전 2.6이고 정말 잘 작동합니다 (또한 매우 잘 지원되며, 관리자는 항상 사용자가 발견 할 수있는 버그를 수정할 준비가되어 있습니다. github 저장소 에서 예제를 찾을 수 있습니다.
관리자 (Joni Freeman)는 항상 Lift 메일 링 리스트 에서 연락 할 수 있습니다. 메일 링리스트에 매우 도움이되는 다른 사용자들도 있습니다.
@Alexey가 지적했듯이 다른 Scala 버전과 함께 라이브러리를 사용하려면 다음과 같이 2.11.x변경 scalaVersion하고 사용하십시오 %%.
scalaVersion := "2.11.5"
"net.liftweb" %% "lift-json" % "2.6"
liftweb.net 사이트에서 시간이 지남에 따라 최신 버전을 확인할 수 있습니다 .
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"}]
목록의 7 위는 저크 슨을 사용하지 않는 잭슨입니다. Scala 객체 (케이스 클래스 등)를 지원합니다.
아래는 내가 사용하는 방법의 예입니다.
object MyJacksonMapper extends JacksonMapper
val jsonString = MyJacksonMapper.serializeJson(myObject)
val myNewObject = MyJacksonMapper.deserializeJson[MyCaseClass](jsonString)
이것은 매우 간단합니다. 또한 XmlSerializer와 JAXB 주석에 대한 지원이 매우 편리합니다.
이 블로그 게시물은 JAXB 주석 및 Play 프레임 워크와 함께 사용하는 방법을 설명합니다.
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
}
}
}
조금 늦었을 수도 있지만 실제로 플레이 프레임 워크에서 json 라이브러리를 사용하는 것이 좋습니다. 문서를 볼 수 있습니다 . 현재 2.1.1 릴리스에서는 전체 플레이 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이 있습니다.
Genson 을 확인해야합니다 . 그것은 단지 작동하고 Scala의 기존 대안의 대부분보다 훨씬 사용하기 쉽습니다. 빠르고, 다른 라이브러리 (jodatime, json4s DOM api ...)와 많은 기능 및 통합이 있습니다.
암시 적, 기본 사례를위한 사용자 지정 판독기 / 작성기, 연산자 오버로드로 인한 ilisible 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 저자이지만 객관적이지 않습니다. :)
다음은 .NET을 json사용하여 파일 을 쓰고 읽는 기본 구현입니다 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)
}
}답변 목록에 휴거가 누락 된 것 같습니다. http://rapture.io/ 에서 구할 수 있으며 다음을 수행 할 수 있습니다 .
페이지에서 휴거 예제를 복사 / 붙여 넣기하고 싶지 않습니다. Rapture의 기능에 대한 멋진 프레젠테이션은 SBTB 2014에서 Jon Pretty에 의해 제공되었습니다. https://www.youtube.com/watch?v=ka5-OLJgybI
@AlaxDean의 # 7 대답, Argonaut 는 sbt 및 intellij로 빠르게 작업 할 수 있었던 유일한 사람입니다. 실제로 json4s도 시간이 거의 걸리지 않았지만 원시 AST를 다루는 것은 내가 원하는 것이 아닙니다. 내 build.st에 한 줄을 넣어 작업 할 argonaut를 얻었습니다.
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"null 일 수도있는 값인 Option 에 대해 잘 알고 있는지 확인하십시오 (널 안전하다고 생각합니다). Argonaut는 Scalaz 를 사용 하므로 기호 \/(또는 연산) 처럼 이해하지 못하는 것이 있으면 아마도 Scalaz 일 것입니다.
이것을 시도해 볼 수 있습니다 : https://github.com/momodi/Json4Scala
간단하고 코드가 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)
}중첩 된 케이스 클래스를 자동으로 처리한다는 큰 장점이있는 uPickle 을 사용합니다 .
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.sbtuPickle을 사용 하려면 다음 을 추가하십시오 .
libraryDependencies += "com.lihaoyi" %% "upickle" % "0.4.3"PLAY JSON 라이브러리를 사용합니다. 여기서 전체 프레임 워크가 아닌 JSON 라이브러리에 대해서만 mavn repo를 찾을 수 있습니다.
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/
import nl.typeset.sonofjson._
arr(
obj(id = 1, name = "John)
obj(id = 2, name = "Dani)
)Play는 Play Framework, Play WS 에서 독립적으로 JSON을 처리하기위한 모듈을 출시했습니다.
그것에 대한 블로그 게시물을 작성했습니다. http://pedrorijo.com/blog/scala-json/ 에서 확인 하십시오.
케이스 클래스와 Play WS (이미 Play Framework에 포함되어 있음)를 사용하면 간단한 한 줄의 암시 적 코드로 json과 케이스 클래스간에 케이스 변환이 가능합니다.
case class User(username: String, friends: Int, enemies: Int, isAlive: Boolean)
object User {
implicit val userJsonFormat = Json.format[User]
}