为什么 scala 可序列化性在类具有相同构造函数参数类型的情况下不同？

Question

为什么我可以连载这个：

// Serialize: OK
case class ClassWithType2[T:TypeTag](x:T)  {
  val tpe:java.lang.reflect.Type = Util.toJavaClass[T]
}

...但不是这个

class TypeAware[T:TypeTag]() {
  val tpe:java.lang.reflect.Type = Util.toJavaClass[T]
}

// Serialize: FAIL.
// No valid constructor for ClassWithType1
// in: java.io.ObjectStreamClass.checkDeserialize
case class ClassWithType1[T:TypeTag](x:T) extends TypeAware[T]

两者似乎具有相同的构造函数类型原型：

[T:TypeTag](x:T)

并且都扩展了 scala.Serializable 和 java.io.Serializable

val s1:Serializable = ClassWithType1(x=123)
val s2:Serializable = ClassWithType2(x=123)
val s3:java.io.Serializable = ClassWithType1(x=123)
val s4:java.io.Serializable = ClassWithType2(x=123)

有一种方法可以实现 TypeAware 子类：

避免必须在每个子类中声明 tpe（就像 ClassWithType2 那样）？
允许对象被序列化

这是测试工具

class TypesTest {

  @Test
  def serializeTypeTest(): Unit = {
    val obj2:Object = ClassWithType2(x=123)
    Util.copyBySerialization(obj2)  // Success!

    val obj1:Object = ClassWithType1(x=123)
    Util.copyBySerialization(obj1) // Fail
  }
}

object Util {
  def toJavaClass[T:TypeTag]: Class[_] = {
    val tpe = typeOf[T]
    runtimeMirror(tpe.getClass.getClassLoader).runtimeClass(tpe.typeSymbol.asClass)
  }

  def copyBySerialization[T](obj: T): T = deserialize(serialize(obj))

  def serialize[T](obj: T): Array[Byte] = {
    val byteOut = new ByteArrayOutputStream()
    val objOut = new ObjectOutputStream(byteOut)
    objOut.writeObject(obj)
    objOut.close()
    byteOut.close()
    byteOut.toByteArray
  }

  def deserialize[T](bytes: Array[Byte]): T = {
    val byteIn = new ByteArrayInputStream(bytes)
    val objIn = new ObjectInputStream(byteIn)
    val obj = objIn.readObject().asInstanceOf[T]
    byteIn.close()
    objIn.close()
    obj
  }

}

Answer 1

仅引用 Javadoc：

To allow subtypes of non-serializable classes to be serialized, the subtype may assume responsibility for saving and restoring the state of the supertype's public, protected, and (if accessible) package fields. The subtype may assume this responsibility only if the class it extends has an accessible no-arg constructor to initialize the class's state. It is an error to declare a class Serializable if this is not the case. The error will be detected at runtime.

TypeAware 的构造函数包含隐式参数。

编辑：一个想法是使类型标签成为一个成员。或者类似的。它没有保存那么多语法。

abstract class TypeAware {
  protected def tt: TypeTag[_]
  def tpe:java.lang.reflect.Type = Util.toJavaClass(tt)
}

case class ClassWithType1[T](x:T)(implicit val tt: TypeTag[T]) extends TypeAware

编辑，更多 linx：

tech page

faq

your question

为什么 scala 可序列化性在类具有相同构造函数参数类型的情况下不同？

Why scala serializability differs in case classes with same constructor parameter types?

scala

generics

serialization

scala-generics

为什么 scala 可序列化性在 类 具有相同构造函数参数类型的情况下不同？

Why scala serializability differs in case classes with same constructor parameter types?

scala

generics

serialization

scala-generics

为什么 scala 可序列化性在类具有相同构造函数参数类型的情况下不同？