Question

我在尝试将JSON数组反序列化为Scala对象时遇到了重大问题

      [{"name":"Cool","city":"College Park","address":"806","id":1},{"name":"Mars ","city":"Durham","address":"12","id":2},{"name":"Something","city":"Raleigh 
","address":"","id":3},{"name":"test","city":"","address":"","id":5}]

我试过gson，jerkson（杰克逊斯卡拉包装），sjson，flexjson。他们都没有工作。我在这里有一个客户列表。列表[客户]。

这是我最接近的：

val array = new JsonParser().parse( customers ).getAsJsonArray()

这给了我一个4阵列。它显然没有给我一个客户对象。我试过Jerkson。

val array = parse[List[Customer]](customers)

但我明白了。

GenericSignatureFormatError occured : null

我只是想找到一种简单的方式，就像我在Java中那样。

这是我的Scala课程。

    case class Customer(
    id : Pk[ Int ],
    name : String,
    address : Option[ String ],
    city : Option[ String ],
    state : Option[ String ],
    user_id : Int )

    object Customer extends Magic[ Customer ]( Option( "Customer" ) ) { 

    def apply( name : String, address : String, city : String, state : String, user_id : Int ) = {
        new Customer( NotAssigned, name, Some( address ), Some( city ), Some( state ), user_id )
    }

    def delete( id : Int ) = {
        SQL( "DELETE from Customer where id = {id}" ).onParams( id ).executeUpdate()
    }

}

感谢您的帮助。

Answer 1

使用gson，你可以编写自己的json阅读器：

case class Customer(id: Int, name: String, address: Option[String], 
  city: Option[String], state: Option[String], user_id: Int)

object CustomerJsonReader {

   def read(in: Reader) = readCustomers(new JsonReader(in))

   def readCustomers(reader: JsonReader) = {
     val customers = new ListBuffer[Customer]
     reader.beginArray()
     while (reader.hasNext()) {
       customers += readCustomer(reader)
     }
     reader.endArray()
     customers toList
   }

   def readCustomer(reader: JsonReader): Customer = {
     var id = 0
     var customerName = ""
     var address: Option[String] = None
     var city: Option[String] = None
     var state: Option[String] = None
     var userId = 0

     reader.beginObject()
     while (reader.hasNext()) {
       val name = reader.nextName()
       name match {
         case "id" => id = reader.nextInt()
         case "address" => address = Some(reader.nextString())
         case "state" => state = Some(reader.nextString())
         case "user_id" => userId = reader.nextInt()
         case "name" => customerName = reader.nextString()
         case "city" => city = Some(reader.nextString())
         case _ => reader.skipValue()
       }
     }
     reader.endObject()
     Customer(id, customerName, address, city, state, userId)
   }

}

val json = 
  """
  [{"name":"Cool","city":"College Park","address":"806","id":1},
  {"name":"Mars ","city":"Durham","address":"12","id":2},
  {"name":"Something","city":"Raleigh  ","address":"","id":3},
  {"name":"test","city":"","address":"","id":5}] 
  """

val customers: List[Customer] = 
  CustomerJsonReader.read(new StringReader(json))

Answer 2

我知道使用gson，你需要Array而不是scala.List。我建议给那个镜头。我认为你应该使用gson.fromJson。

Answer 3

您也可以尝试Jerkson = Jackson + Scala
即使我遇到包含“ - ”的特殊JSON字段的问题，也很容易使用我最近在Twitter上看到的一个小tuto：http://logician.free.fr/index.php/2011/09/16/play-scala-and-json/

Answer 4

我现在被这个疯狂了，并经历了尝试GSON，Lift-Json，Sjson以及最后Jerkson，并找到了与那个人的和平。

以下是我与Play结合使用的方法：

http://logician.eu/index.php/2011/09/16/play-scala-and-json/

http://logician.eu/index.php/2011/11/01/writing-custom-deserializers-for-jerkson/

Answer 5

我使用Lift的json library来实现此目的，它可以轻松地解析JSON并将值提取到案例类中。它被打包成一个单独的罐子，所以你不需要整个升降机架来使用它。

import net.liftweb.json._
import net.liftweb.json.JsonDSL._

implicit val formats = DefaultFormats

val json: String = "[{...."
val parsed: JValue = parse(json)
val customers: List[Customer] = parsed.extract[List[Customer]]

确保使用Option在案例类中定义任何可选字段。我注意到在您的代码中，对象缺少user_id字段，如果user_id字段被声明为Int而不是Option[Int]，则会导致解析错误。

Answer 6

除了尝试制作Jerkson（这是一个很好的库，可以使用我所听到的），你也可以尝试Jackson的Scala module - 模块是Jackson扩展到处理第三方数据类型的官方方式以及其他JVM语言的本机数据类型和结构。（这并不是说这比Jerkson更官方，只是有许多开发人员不熟悉的有用的Jackson扩展模块）

主要的Jackson邮件列表（user@jackson.codehaus.org）讨论了Scala模块的问题;你可能找到了一个可以修复的边缘情况。

Answer 7

我编写了一个解析器/验证器dsl，它允许您显式解决任何类型的擦除问题。开箱即用它处理案例类，元组，选项，Either，List，Map，joda DatetTime，管道到函数，多键映射和键名重新映射。

它使用Jackson解析器

https://github.com/HigherState/jameson

Answer 8

使用scala以及播放库和代码

非常简单

import play.api.libs.json.{Format, Json}
case class Customer(name:String, city:String, address:String, id:Int)
object Customer {
   implicit val jsonFormat: Format[Customer] = Json.format(Customer)
}

val jsonDef = Json.parse(<json-string>)
val customers = jsonDef.as[List[Customer]]

customers是Customer个对象的列表。

将Json数组反序列化为Scala对象

8 个答案: