Even trivial serialization examples in Scala don't work. Why?

Question

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. 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. The file "test.obj" is created, over 2Kb in size and has plausible contents. EDIT: Reading the "test.obj" back in (from the 2nd answer below) causes Welcome to Scala version 2.10.3 (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0_51). Type in expressions to have them evaluated. Type :help for more information. scala> import java.io._ import java.io._ scala> val fis = new FileInputStream( "test.obj" ) fis: java.io.File…

Accepted Answer

Note that `@serializable` scaladoc tells that it is deprecated since 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:

```
class Person(val age: Int) extends Serializable
```

This works for me (type `:paste` in REPL and paste these lines):

```
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.

Edit (on why you're getting `NotSerializableException` when you run Scala script from file)

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. Here is my speculation on why it happens.

According to the stack trace a weird class `Main$$anon$1` is not serializable. Logical question is: why it is there in the first place? We're trying to serialize `Person` after all, not something weird.

Scala script is special in that it is implicitly wrapped into an object called `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). This instance method in turn tries to create an instance of a class `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):

```
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; 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. 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`. 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. BTW, serializing non-static inner classes is a notorious thing in Java world, it is known to cause problems like this one.

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. Hence serialization works normally for them.

Even trivial serialization examples in Scala don't work. Why?

Solution

Problem