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：

要允许序列化非序列化类的子类型，子类型可能承担保存和恢复状态的责任超类型的公共，受保护和（如果可访问）包领域。只有在类中，子类型才可以承担此责任它扩展了一个可访问的无参数构造函数来初始化阶级的国家。如果这样，声明一个Serializable类是错误的事实并非如此。将在运行时检测到错误。

TypeAware的ctor包含隐含参数。

编辑：一个想法是使类型标记成为成员。或类似的。它没有保存尽可能多的语法。

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可序列化在具有相同构造函数参数类型的case类中有所不同？

1 个答案: