reflection - 如何使用反射在 scala 中创建一个体面的 toString() 方法？

Question

为了使调试时对类的自省变得容易，我想在基类中为有问题的对象创建一个通用的 toString 方法。由于它不是性能关键代码，我想使用反射打印出字段名称/值对（“x=1，y=2”等）。

是否有捷径可寻？我尝试了几种潜在的解决方案，并遇到了安全访问问题等。

需要明确的是，基类中的 toString() 方法应该反射性地迭代从它继承的任何类中的公共 val，以及混入的任何特征。

Answer 1

例子：

override def toString() = {
  getClass().getDeclaredFields().map { field:Field => 
    field.setAccessible(true)
    field.getName() + ": " + field.getType() + " = " + field.get(this).toString()
  }.deepMkString("\n")
}

使用 Java 反射 API，所以不要忘记导入 java.lang.reflect._

此外，在某些情况下，您可能需要在 field.get(this) 调用上捕获IllegalAccessException，但这只是一个起点。

Answer 2

您是否知道 Scala 案例类获取这些编译器生成的方法：

• toString(): 字符串
• 等于（其他：任何）：布尔值
• 哈希码：整数

他们还为“new-less”构造函数和模式匹配获得伴随对象。

生成toString()的与您描述的非常相似。

Answer 3

Scala 不生成任何公共字段。他们都将是私人的。访问器方法是公开的，反映这些。给定一个像这样的类：

class A {
  var x = 5
}

生成的字节码如下所示：

private int x;
public void x_$eq(int);
public int x();

Answer 4

import util._                 // For Scala 2.8.x NameTransformer
import scala.tools.nsc.util._ // For Scala 2.7.x NameTransformer

/**
 * Repeatedly run `f` until it returns None, and assemble results in a Stream.
 */
def unfold[A](a: A, f: A => Option[A]): Stream[A] = {
  Stream.cons(a, f(a).map(unfold(_, f)).getOrElse(Stream.empty))
}

def get[T](f: java.lang.reflect.Field, a: AnyRef): T = {
  f.setAccessible(true)
  f.get(a).asInstanceOf[T]
}

/**
 * @return None if t is null, Some(t) otherwise.
 */
def optNull[T <: AnyRef](t: T): Option[T] = if (t eq null) None else Some(t)

/**
 * @return a Stream starting with the class c and continuing with its superclasses.
 */
def classAndSuperClasses(c: Class[_]): Stream[Class[_]] = unfold[Class[_]](c, (c) => optNull(c.getSuperclass))

def showReflect(a: AnyRef): String = {
  val fields = classAndSuperClasses(a.getClass).flatMap(_.getDeclaredFields).filter(!_.isSynthetic)
  fields.map((f) => NameTransformer.decode(f.getName) + "=" + get(f, a)).mkString(",")
}

// TEST
trait T {
  val t1 = "t1"
}

class Base(val foo: String, val ?? : Int) {
}

class Derived(val d: Int) extends Base("foo", 1) with T

assert(showReflect(new Derived(1)) == "t1=t1,d=1,??=1,foo=foo")