3

我正在尝试使用 Scala 反射来定义特征案例类，并且它们的同伴可以实现为“可导出”（例如，映射到 Map[String,Any]）和“可导入”。它适用于顶级案例类，但我不能让它适用于内部类。如果我已经有一个封闭实例的句柄，我会知道如何反射地实例化一个内部类，我可以反映到一个 InstanceMirror，但现在我正在编写一个稍后将由顶级或内部类实现的特征.

只要同伴和构造的实例将共享相同的封闭实例，我应该能够完成这项工作。但是我一直无法弄清楚如何通过反射来确定同伴的封闭实例。

这是我正在尝试做的事情的简化示例，以及发生的问题：

import scala.reflect.runtime.universe._;

trait CompanionOfReflectiveConstructable[T] {
  def tType : Type;

  lazy val mirror       : Mirror       = runtimeMirror( this.getClass.getClassLoader );
  lazy val ctorDecl     : Symbol       = tType.declaration(nme.CONSTRUCTOR);
  lazy val ctor         : MethodSymbol = ctorDecl.asMethod;
  lazy val tClass       : ClassSymbol  = tType.typeSymbol.asClass;
  lazy val tClassMirror : ClassMirror  = mirror.reflectClass( tClass );
  lazy val ctorF        : MethodMirror = tClassMirror.reflectConstructor( ctor );

  // in real-life, i'd derive arguments from ctor.paramss
  // but to highlight our issue, we'll assume a no arg constructor
  def createInstance : T = ctorF().asInstanceOf[T]; 
}

trait ReflectiveConstructable;

object Test1 extends CompanionOfReflectiveConstructable[Test1] {
  def tType = typeOf[Test1];
}
class Test1 extends ReflectiveConstructable;

class Outer {
  object Test2 extends CompanionOfReflectiveConstructable[Test2] {
    def tType = typeOf[Test2];
  }
  class Test2 extends ReflectiveConstructable;
}

这就是发生的事情。

scala> Test1.createInstance
res0: Test1 = Test1@2b52833d

scala> (new Outer).Test2.createInstance
scala.ScalaReflectionException: class Test2 is an inner class, use reflectClass on an InstanceMirror to obtain its ClassMirror
        at scala.reflect.runtime.JavaMirrors$JavaMirror.ErrorInnerClass(JavaMirrors.scala:126)
...

Test1 效果很好。Test2 的问题很明显——我需要通过 InstanceMirror 而不是通过我的顶级镜像来获取我的 ClassMirror。（请参阅此处、此处和此处。）但是，在 CompanionOfReflectiveConstructable 中，我不知道如何检查我是否是内在的或我的封闭实例是谁，以有条件地执行适当的工作。有谁知道如何做到这一点？

非常感谢！

4

1 回答 1

1

我在这里看到的主要问题是您在内部类的伴随对象内部使用反射。类 Test2 将定义一个名为 $outer 的字段，其中包含外部类，但是，从 Test2 伴随对象中，您无法获得创建 Test2 所需的 Outer 实例。我能看到的唯一解决方法是将一个可选实例传递给你的伴侣特征：

trait CompanionOfReflectiveConstructable[T] {
  def tType: Type

  def outer: Option[AnyRef] = None

  val mirror = runtimeMirror(this.getClass.getClassLoader)
  val tClassMirror = outer
    .map(a => mirror.reflect(a).reflectClass(tType.typeSymbol.asClass))
    .getOrElse(mirror.reflectClass(tType.typeSymbol.asClass))

  val ctorF = tClassMirror.reflectConstructor(tType.declaration(nme.CONSTRUCTOR).asMethod)

  // in real-life, i'd derive arguments from ctor.paramss
  // but to highlight our issue, we'll assume a no arg constructor
  def createInstance: T = ctorF().asInstanceOf[T]
}

trait ReflectiveConstructable

class Test1 extends ReflectiveConstructable

object Test1 extends CompanionOfReflectiveConstructable[Test1] {
  def tType = typeOf[Test1]
}

class Outer {

  object Test2 extends CompanionOfReflectiveConstructable[Test2] {
    def tType = typeOf[Test2]
    override def outer = Option(Outer.this)
  }

  class Test2 extends ReflectiveConstructable
}

如果有一种方法可以从 Test2 伴随对象中获取 Outer 实例，那就太好了，但遗憾的是它在运行时不可用。

于 2013-04-03T16:35:03.530 回答