即使Scala中的琐碎序列化示例也不起作用。 为什么？
[英]Even trivial serialization examples in Scala don't work. Why?
问题描述
I am trying the simplest possible serialization examples of a class: 
我正在尝试类的最简单的序列化示例：
@serializable class Person(age:Int) {}
val fred = new Person(45)
import java.io._
val out = new ObjectOutputStream(new FileOutputStream("test.obj"))
out.writeObject(fred)
out.close()
This throws exception "java.io.NotSerializableException: Main$$anon$1$Person" on me. 这会抛出异常“java.io.NotSerializableException：Main $$ anon $ 1 $ Person”。 Why? 为什么？ Is there a simple serialization example? 有简单的序列化示例吗？ I also tried 我也试过了
@serializable class Person(nm:String) {
private val name:String=nm
}
val fred = new Person("Fred")
...
and tried to remove @serializable and some other permutations. 并试图删除@serializable和其他一些排列。 The file "test.obj" is created, over 2Kb in size and has plausible contents. 创建文件“test.obj”，大小超过2Kb，内容合理。
EDIT: 编辑：
Reading the "test.obj" back in (from the 2nd answer below) causes 读回“test.obj”（从下面的第二个回答）导致
Welcome to Scala version 2.10.3 (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0_51).
scala> import java.io._ import java.io._
scala> val fis = new FileInputStream( "test.obj" ) fis: java.io.FileInputStream = java.io.FileInputStream@716ad1b3
scala> val oin = new ObjectInputStream( fis ) oin: java.io.ObjectInputStream = java.io.ObjectInputStream@1f927f0a
scala> val p= oin.readObject java.io.WriteAbortedException: writing aborted;
3 个解决方案
解决方案1
30 已采纳 2014-04-20 14:36:34
Note that @serializable scaladoc tells that it is deprecated since 2.9.0: 请注意， @serializable scaladoc告诉它自2.9.0以来已弃用：
Deprecated (Since version 2.9.0) instead of @serializable class C, use class C extends Serializable
So you just have to use Serializable trait: 所以你只需要使用Serializable特性：
class Person(val age: Int) extends Serializable
This works for me (type :paste in REPL and paste these lines): 这对我有用（类型:paste在REPL中并粘贴这些行）：
import java.io.{ObjectOutputStream, ObjectInputStream}
import java.io.{FileOutputStream, FileInputStream}
class Person(val age: Int) extends Serializable {
override def toString = s"Person($age)"
}
val os = new ObjectOutputStream(new FileOutputStream("/tmp/example.dat"))
os.writeObject(new Person(22))
os.close()
val is = new ObjectInputStream(new FileInputStream("/tmp/example.dat"))
val obj = is.readObject()
is.close()
obj
This is the output: 这是输出：
// Exiting paste mode, now interpreting.
import java.io.{ObjectOutputStream, ObjectInputStream}
import java.io.{FileOutputStream, FileInputStream}
defined class Person
os: java.io.ObjectOutputStream = java.io.ObjectOutputStream@5126abfd
is: java.io.ObjectInputStream = java.io.ObjectInputStream@41e598aa
obj: Object = Person(22)
res8: Object = Person(22)
So, you can see, the [de]serialization attempt was successful. 所以，你可以看到，[de]序列化尝试成功了。
Edit (on why you're getting NotSerializableException when you run Scala script from file) 编辑（从文件运行Scala脚本时为什么会出现NotSerializableException ）
I've put my code into a file and tried to run it via scala test.scala and got exactly the same error as you. 我已经将我的代码放入一个文件并试图通过scala test.scala运行它并得到与你完全相同的错误。 Here is my speculation on why it happens. 这是我对其发生原因的猜测。
According to the stack trace a weird class Main$$anon$1 is not serializable. 根据堆栈跟踪，一个奇怪的类Main$$anon$1不可序列化。 Logical question is: why it is there in the first place? 逻辑问题是：为什么它首先出现在那里？ We're trying to serialize Person after all, not something weird. 我们毕竟试图序列化Person ，而不是奇怪的东西。
Scala script is special in that it is implicitly wrapped into an object called Main . Scala脚本的特殊之处在于它隐式包装在名为Main的对象中。 This is indicated by the stack trace: 这由堆栈跟踪指示：
at Main$$anon$1.<init>(test.scala:9)
at Main$.main(test.scala:1)
at Main.main(test.scala)
The names here suggest that Main.main static method is the program entry point, and this method delegates to Main$.main instance method ( object 's class is named after the object but with $ appended). 这里的名称表明Main.main静态方法是程序入口点，并且此方法委托给Main$.main实例方法（ object的类以对象命名，但附加$ ）。 This instance method in turn tries to create an instance of a class Main$$anon$1 . 此实例方法依次尝试创建Main$$anon$1类的实例。 As far as I remember, anonymous classes are named that way. 据我所知，匿名类是以这种方式命名的。
Now, let's try to find exact Person class name (run this as Scala script): 现在，让我们尝试找到确切的Person类名（将其作为Scala脚本运行）：
class Person(val age: Int) extends Serializable {
override def toString = s"Person($age)"
}
println(new Person(22).getClass)
This prints something I was expecting: 这打印出我期待的东西：
class Main$$anon$1$Person
This means that Person is not a top-level class; 这意味着Person不是顶级课程; instead it is a nested class defined in the anonymous class generated by the compiler! 相反，它是由编译器生成的匿名类中定义的嵌套类！ So in fact we have something like this: 所以事实上我们有这样的事情：
object Main {
def main(args: Array[String]) {
new { // this is where Main$$anon$1 is generated, and the following code is its constructor body
class Person(val age: Int) extends Serializable { ... }
// all other definitions
}
}
}
But in Scala all nested classes are something called "nested non-static" (or "inner") classes in Java. 但是在Scala中，所有嵌套类都是Java中的“嵌套非静态”（或“内部”）类。 This means that these classes always contain an implicit reference to an instance of their enclosing class. 这意味着这些类总是包含对其封闭类的实例的隐式引用 。 In this case, enclosing class is Main$$anon$1 . 在这种情况下，封闭类是Main$$anon$1 。 Because of that when Java serializer tries to serialize Person , it transitively encounters an instance of Main$$anon$1 and tries to serialize it, but since it is not Serializable , the process fails. 因此，当Java序列化程序尝试序列化Person ，它会传递地遇到Main$$anon$1的实例并尝试序列化它，但由于它不是Serializable ，因此该过程失败。 BTW, serializing non-static inner classes is a notorious thing in Java world, it is known to cause problems like this one. 顺便说一句，序列化非静态内部类是Java世界中一个臭名昭着的东西，众所周知会引起像这样的问题。
As for why it works in REPL, it seems that in REPL declared classes somehow do not end up as inner ones, so they don't have any implicit fields. 至于为什么它在REPL中工作，似乎在REPL声明的类中某种程度上不会最终成为内部类，因此它们没有任何隐含字段。 Hence serialization works normally for them. 因此序列化通常适用于它们。
解决方案2
4 2014-04-20 14:29:05
You could use the Serializable Trait: 您可以使用Serializable Trait：
Trivial Serialization example using Java Serialization with the Serializable Trait: 使用带有Serializable Trait的Java序列化的简单序列化示例：
case class Person(age: Int) extends Serializable
Usage: 用法：
Serialization, Write Object 序列化，写对象
val fos = new FileOutputStream( "person.serializedObject" )
val o = new ObjectOutputStream( fos )
o writeObject Person(31)
Deserialization, Read Object 反序列化，读取对象
val fis = new FileInputStream( "person.serializedObject" )
val oin = new ObjectInputStream( fis )
val p= oin.readObject
Which creates following output 这会产生以下输出
fis: java.io.FileInputStream = java.io.FileInputStream@43a2bc95
oin: java.io.ObjectInputStream = java.io.ObjectInputStream@710afce3
p: Object = Person(31)
As you see the deserialization can't infer the Object Type itself, which is a clear drawback. 如您所见，反序列化无法推断出对象类型本身，这是一个明显的缺点。
Serialization with Scala-Pickling 使用Scala-Pickling进行序列化
https://github.com/scala/pickling or part of the Standard-Distribution starting with Scala 2.11 https://github.com/scala/pickling或标准分发的一部分，以Scala 2.11开头
In the exmple code the object is not written to a file and JSON is used instead of ByteCode Serialization which avoids certain problems originating in byte code incompatibilities between different Scala version. 在exmple代码中，对象不会写入文件，而是使用JSON而不是ByteCode Serialization，这避免了源自不同Scala版本之间字节代码不兼容的某些问题。
import scala.pickling._
import json._
case class Person(age: Int)
val person = Person(31)
val pickledPerson = person.pickle
val unpickledPerson = pickledPerson.unpickle[Person]
解决方案3
1 2014-04-20 13:03:34
class Person(age:Int) {} is equivalent to the Java code: class Person(age:Int) {}等同于Java代码：
class Person{
Person(Int age){}
}
which is probably not what you want. 这可能不是你想要的。 Note that the parameter age is simply discarded and Person has no member fields. 请注意，参数age被简单地丢弃，而Person没有成员字段。
You want either: 你想要：
@serializable case class Person(age:Int)@serializable class Person(val age:Int)
You can leave out the empty curly brackets at the end. 您可以在末尾省略空的花括号。 In fact, it's encouraged. 事实上，它受到了鼓励。
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.