Json序列化，Scala中的反序列化与集合和循环依赖

Question

所以我一直在尝试在Scala中编写JSON解析器。到目前为止，我已经尝试过Jackson，gson和flexjson，但是我无法使用它包含我的示例。 这个例子看起来很愚蠢，但它证明了我的问题。

我得到的最长时间是与杰克逊一起使用注释。
@JsonIdentityInfo（generator = ObjectIdGenerators.UUIDGenerator.class）
我想要保存的每个类。这似乎创建了一个正确的JSON文件，但我无法将其反序列化回我的Garage对象。 这种方法的一个问题也是注释，如果可能的话我想跳过注释，因为在我的实例中我没有完全控制源代码。

我已经在下面插入了所有的代码（杰克逊例子）和我的依赖（以gradle格式）。

代码：

import java.io.StringWriter 

import com.fasterxml.jackson.annotation.{JsonIdentityInfo, ObjectIdGenerators} 
import com.fasterxml.jackson.databind.ObjectMapper 
import com.fasterxml.jackson.module.scala.DefaultScalaModule 

object JsonTester extends App { 

    trait TestData { 
    var volvo1 = new Car(null, "volvo") 
    var volvo2 = new Car(null, "volvo") 
    var bmw = new Car(null, "bmw") 
    var jeep1 = new Car(null, "jeep") 
    var jeep2 = new Car(null, "jeep") 
    var ford = new Car(null, "ford") 

    val p1 = new Person("John", List[Car](volvo1, jeep1)) 
    volvo1.owner = p1 
    jeep1.owner = p1 

    val p2 = new Person("Anna", List[Car](volvo2)) 
    volvo2.owner = p2 

    val p3 = new Person("Maria", List[Car](bmw)) 
    bmw.owner = p3 

    val p4 = new Person("Kevin", List(ford, jeep2)) 
    ford.owner = p4 
    jeep2.owner = p4 

    val customers = List(p1, p2, p3, p4) 
    val carModels = Map("volvo" -> List(volvo1, volvo2), "bmw" -> List(bmw), "jeep" -> List(jeep1, jeep2), "ford" -> List(ford)) 
    val garage = new Garage[Person, Car]("FixYourCar", customers, carModels); 

    } 

    new TestData() { 
    val originalToString = garage.toString 
    println("Garage: " + originalToString) 

    val json: String = toJson(garage) 
    println(json) 
    val garageFromJson: Garage[Person, Car] = fromJson(json) 
    println("garageFromJson: " + garageFromJson) 

    garageFromJson.customers.foreach(println(_)) 
    assert(originalToString.equals(garageFromJson.toString)) 
    } 

    def toJson(garage: Garage[Person, Car]): String = { 
    import com.fasterxml.jackson.module.scala.DefaultScalaModule 

    val mapper = new ObjectMapper() 
    mapper.registerModule(DefaultScalaModule) 

    println("Saving graph to json") 
    val writer = new StringWriter() 
    mapper.writeValue(writer, garage) 
    writer.toString 
    } 

    def fromJson(json: String): Garage[Person, Car] = { 
    val mapper = new ObjectMapper() 
    mapper.registerModule(DefaultScalaModule) 
    mapper.readValue[Garage[Person, Car]](json, classOf[Garage[Person, Car]]) 
    } 


} 

@JsonIdentityInfo(generator = classOf[ObjectIdGenerators.UUIDGenerator]) 
case class Garage[P, C](name: String, customers: List[P], models: Map[String, List[C]]) 

@JsonIdentityInfo(generator = classOf[ObjectIdGenerators.UUIDGenerator]) 
case class Person(name: String, cars: List[Car]) 

@JsonIdentityInfo(generator = classOf[ObjectIdGenerators.UUIDGenerator]) 
case class Car(var owner: Person, model: String) { 
    override def toString(): String = s"model: $model, owner:${owner.name}" 
} 

依赖关系： 编译 'org.scala浪：斯卡拉库：2.11.2' 编译 “org.scalatest：scalatest_2.11：2.2.2”

从运行

compile 'com.typesafe.akka:akka-actor_2.11:2.3.6' 
compile 'com.typesafe.akka:akka-testkit_2.11:2.3.6' 

compile 'net.sf.opencsv:opencsv:2.3' 

compile 'jfree:jcommon:1.0.16' 
compile 'org.jfree:jfreechart:1.0.15' 
compile 'org.jgrapht:jgrapht-ext:0.9.0' 

compile 'org.hibernate:hibernate-core:3.6.0.Final' 
compile 'org.hibernate:hibernate-entitymanager:3.6.0.Final' 
compile 'mysql:mysql-connector-java:5.1.27' 

// json 
compile 'com.fasterxml.jackson.module:jackson-module-scala_2.11:2.4.2' 
compile 'com.google.code.gson:gson:2.3' 
compile 'net.sf.flexjson:flexjson:3.2' 

结果：

Garage: ..... 
Saving graph to json 
{"@id":"282559ae-70ea-4d74-8363-4b37f1691dba".... 
garageFromJson: Garage(FixYourCar,List(Map(@id -> 7ae4b765-c0dc-4a8e-867f-23bc7672db91, name -> John, cars -> .... 
Exception in thread "main" java.lang.ExceptionInInitializerError 
    at JsonTester.main(JsonTester.scala) 
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) 
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) 
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) 
    at java.lang.reflect.Method.invoke(Method.java:606) 
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:134) 
Caused by: java.lang.ClassCastException: scala.collection.immutable.Map$Map3 cannot be cast to Person 
    at JsonTester$$anon$1$$anonfun$1.apply(JsonTester.scala:49) 
    at scala.collection.immutable.List.foreach(List.scala:381) 
    at JsonTester$$anon$1.<init>(JsonTester.scala:49) 
    at JsonTester$.<init>(JsonTester.scala:40) 
    at JsonTester$.<clinit>(JsonTester.scala) 
    ... 6 more 

Answer 1

您确定要实际上明确地将你的循环引用放入你的序列化表单中？这样做并不能获得任何信息，我可以想象你会遇到很多问题。你没有获得任何信息的原因是，如果你知道一个人拥有的汽车，那么你可以推断出每辆汽车的主人。

在下面，我会将您的示例仅限于Car和Person（即，我将省略Garage），因为此场景已经很复杂。我也不会明确地将Car的owner转换为它的序列化形式，但我会告诉你如何反序列化它并获得循环依赖。

在这个例子中，我将使用json4s，因为我对它有点熟悉，因为我听说它是​​Scala中json序列化/反序列化的实际标准。你也不必写那些你不喜欢的讨厌的注释。

序列化形式

正如我所说，我不会在你的序列化形式使用循环依赖（虽然我相信你可以通过编写自定义串行器/解串器在某种程度上做到这一点）。让我们将Car和Person的初始化阶段想象成真正的人去供应商和购买汽车。所以我们有一个CarBuyingPerson，即即将购买Car s的List。汽车必须没有车主（假设供应商不算作车主），所以我们有一个CarWithoutOwner。这两种情况下，类将如下所示：

case class CarBuyingPerson(name: String, cars: List[CarWithoutOwner]) 
case class CarWithoutOwner(model: String) 

现在，我们可以进行序列化和反序列化的车辆和人员：

val volvo1 = new CarWithoutOwner("volvo") 
val volvo2 = new CarWithoutOwner("volvo") 
val bmw = new CarWithoutOwner("bmw") 
val jeep1 = new CarWithoutOwner("jeep") 
val jeep2 = new CarWithoutOwner("jeep") 
val ford = new CarWithoutOwner("ford") 

val p1 = new CarBuyingPerson("John", List[CarWithoutOwner](volvo1, jeep1)) 
val p2 = new CarBuyingPerson("Anna", List[CarWithoutOwner](volvo2)) 
val p3 = new CarBuyingPerson("Maria", List[CarWithoutOwner](bmw)) 
val p4 = new CarBuyingPerson("Kevin", List(ford, jeep2)) 


def main(args: Array[String]) { 
    implicit val formats = Serialization.formats(NoTypeHints) 

    val ser = write(List(p1, p2, p3, p4)) 
    print(pretty(parse(ser))) 
    ??? 
} 

到目前为止好，但我们STIL希望汽车有一个老板。因此，让我们定义我们的内部类Car和Person，它们代表我们完全初始化的对象。然而，它们彼此依赖，所以我们需要以某种方式将每一个先于另一个瞬间化。我发现了另一个堆栈溢出帖子，正好解决了这个问题：Scala: circular references in immutable data types?

这个想法是不通过值传递构造函数参数。 （然而，我不确定正确的术语是“通过引用呼叫”还是“按名称呼叫”）。所以，我们定义我们的类如下：

class Person(name: String, cars: => List[Car]) { 
    override def toString = s"Person $name with cars: $cars" 
} 

class Car(owner: => Person, model: String) { 
    // must not create circular toString calls! 
    override def toString = s"Car with model: $model" 
} 

现在我们只需要能够初始化这些类。因此，让我们定义一个函数buyCars做这个：

case class CarBuyingPerson(name: String, cars: List[CarWithoutOwner]) { 
    def buyCars: Person = { 
    lazy val This: Person = new Person(name, theCars) 
    lazy val theCars: List[Car] = cars map {car => new Car(This, car.model)} 
    This 
    } 
} 

通过使用懒惰丘壑，我们可以使用尚未定义的VAL，即，我们可以实例This时使用theCars。这会给你所需的循环数据结构。

让我们来测试这在main - 方法：

def main(args: Array[String]) { 
    implicit val formats = Serialization.formats(NoTypeHints) 

    val ser = write(List(p1, p2, p3, p4)) 
    print(pretty(parse(ser))) 

    println() 
    println() 

    val deSer = read[List[CarBuyingPerson]](ser) 
    val peopleAfterBuyingCar = deSer map {_.buyCars} 
    print(peopleAfterBuyingCar) 
} 

我找到那些循环依赖不容易理解。我对你的建议是首先认真思考你是否真的需要他们。也许这会更容易改变你的设计，并使Car不知道它的主人。