IT

스칼라에서 사용할 JSON 라이브러리는 무엇입니까?

lottoking 2020. 7. 17. 07:49
반응형

스칼라에서 사용할 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 += ...

가장 가까운 라이브러리 / 솔루션은 무엇입니까?

불행히도 JSON 라이브러리 작성은 스칼라 커뮤니티의 할 일 목록 앱 코딩 버전입니다.

상당히 다양한 대안이 있습니다. 메모와 함께 특정 순서로 설치하지 않습니다.

  1. parsing.json.JSON이 - 경고 이 라이브러리 [해석]까지만 스칼라 버전 2.9.x 사용할 수 있습니다 (최신 버전에서 제거)
  2. spray-json- 스프레이 프로젝트에서 추출
  3. Jerkson ±- 좋은 라이브러리 (Java Jackson 위에 구축)를 경고 했지만 이제는 버림. 이것을 사용하려면 아마도 끓는 프로젝트의 예제를 따르고 backchat.io 포크를 사용하십시오.
  4. sjson - Debasish 고쉬 제작
  5. lift-json- Lift 프로젝트와 사용할 수 있습니다.
  6. json4s § ± -lift -json에서 추출하여 다른 JSON 라이브러리에서 사용할 수있는 표준 JSON AST를 작성합니다. Jackson 지원 구현 포함
  7. Argonaut §-Scalaz 사용자의 Scala 용 FP 지향 JSON 라이브러리
  8. play-json ±-사용 가능 독립형 입니다. 자세한 내용 은 이 답변을 참조하십시오.
  9. 디종 - 경고가 취소되었습니다. 동적으로 유형이 지정된 스칼라 JSON 라이브러리
  10. sonofjson- 매우 간단한 API를 목표로하는 JSON 라이브러리
  11. Jawn- 빠른 속도를 목표로하는 Erik Osheim의 JSON 라이브러리
  12. Rapture JSON ± -2, 4, 5, 6, 7, 11 또는 Jackson을 백엔드로 사용할 수있는 JSON 엔드 엔드
  13. circe- 스칼라 즈 대신 고양이 위에 지어진 Argonaut의 포크
  14. jsoniter- scala- 초고속 JSON 코덱의 타임 생성을위한 매크로 매크로

§ = Scalaz 통합, ± = Jackson과의 상호 운용 지원 JsonNode

Snowplow 에서는 Jackson 백엔드와 함께 json4를 사용합니다. 우리는 Argonaut 와도 좋은 경험을했습니다.

Lift-json은 버전 2.6이며 실제로 작동합니다. 또한 매우 잘 지원되는 관리자는 항상 모든 설치가 준비가되어 있습니다. github 저장소 에서 예제를 사용할 수 있습니다.

관리자 (Joni Freeman)는 항상 모든 메일 링 리스트 에서 접근 할 수 있습니다. 메일 링리스트는 매우 유용합니다.

@Alexey가 지적했듯이 라이브러리를 다른 Scala 버전과 함께 사용하는 다음과 같이 2.11.x변경 scalaVersion하고 사용하십시오 %%.

scalaVersion := "2.11.5" 

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

liftweb.net 사이트에서 시간이 지남에 따라 최신 버전을 사용할 수 있습니다 .

저크 슨을 사용하는 것이 좋습니다 . 대부분의 기본 유형 변환을 지원합니다.

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 번은 Jerkson을 사용하지 않는 Jackson입니다. 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
     }
  }
}

어쩌면 조금 늦었지만 프레임 워크에서 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 스냅 샷에서 독립형 play-json이 있습니다.

Genson 을 확인해야합니다 . 그것은 대안 대부분보다 작동하고 사용하기가 있습니다. 빠르며 다른 기능 (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 저자이지만 객관적이지 않습니다 :)

다음은을 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)
 }
}

Jawn 은 스칼라의 매우 유연한 JSON 파서 라이브러리입니다. 또한 AST를 생성 할 수 있습니다. AST에 매핑하기 위해 작은 특성 만 제공됩니다.

약간의 JSON 구문 분석이 필요한 최근 프로젝트에서 훌륭하게 작동했습니다.

휴거가 답변 목록에없는 것 가변합니다. http://rapture.io/ 에서 얻을 수있는 다음 과 같은 기능을 제공합니다.

  • JSON 백엔드를 선택하십시오. 이미 가져 왔을 때 매우 유용합니다.
  • Try, Future, Option, Either 등으로 작업 할 결정 (가져 오기 상태)
  • 한 줄의 코드로 많은 작업을 수행하십시오.

페이지에서 Rapture 예제를 복사 / 옮기고 싶지 않습니다. Rapture의 기능에 대한 멋진 프레젠테이션은 SBTB 2014에서 Jon Pretty가 제공했습니다. https://www.youtube.com/watch?v=ka5-OLJgybI

@AlaxDean의 # 7 답변, Argonaut 는 sbt 및 intellij와 함께 빠르게 작업 할 수있는 유일한 회사입니다. 실제로 json4s도 시간이 거의 걸리지라는 원시 AST를 다루는 것은 내가 원하는 것이 아닙니다. 내 빌드에 한 줄을 넣어서 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이 될 수있는 값 인 옵션 에 익숙해야합니다 ( 널 안전합니다). 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)
}

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/

JSON 버전 의 SON 도 제공합니다 .

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 프레임 워크에 포함되어 있음)를 사용하면 간단한 한 줄의 암묵적으로 json과 케이스 클래스간에 케이스 변환이 가능합니다.

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

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

중첩 된 케이스 클래스를 자동으로 처리한다는 큰 장점이있는 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"

참고 URL : https://stackoverflow.com/questions/8054018/what-json-library-to-use-in-scala

반응형

'IT' 카테고리의 다른 글

안드로이드 위치 클라이언트 -GPS 또는 네트워크는?  (0) 2020.07.17
서비스 경로없이 요청 URI를 얻는 방법은 무엇입니까?  (0) 2020.07.17
jQuery는 선택이 선택되어 있는지 확인합니다.  (0) 2020.07.17
Java / Android- 전체 스택 추적을 인쇄하는 방법은 무엇입니까?  (0) 2020.07.17
SMTP 서버에서 PHP로 이메일 보내기  (0) 2020.07.17

'IT'의 다른글

  • 현재글스칼라에서 사용할 JSON 라이브러리는 무엇입니까?

관련글

댓글

티스토리툴바