【Scala反射】Environment、Universe 和 Mirror

2019年9月2日 182次阅读 来源: gcusky

Environment、Universe 和 Mirror

Environment

反射环境（Environment）根据反射任务是在运行时还是在编译时而有所不同。在运行时或编译时使用的环境之间的区别被封装在一个所谓的universe中。 反射环境的另一个重要方面是我们可以反射访问的一组实体。 这组实体由所谓的mirror确定。

例如，通过运行时反射可访问的实体可由 ClassloaderMirror 提供。此镜像仅提供对由特定类加载器加载的实体（包，类型和成员）的访问。

Mirror 不仅确定了可反射访问的一组实体，他们还提供对这些实体进行反射的操作。例如，在运行时反射中，invoker mirror 可用于调用类的方法或构造函数。

Universe

有两种主要类型的 universe——因为存在运行时和编译时反射能力，所以使用了与各自任务相对应的universe。有以下两种：

  • scala.reflect.runtime.universe 用于运行时反射，或
  • scala.reflect.macros.Universe 用于编译时反射。

universe 为反射中使用的所有主要概念（如Type，Tree 和 Annotation）提供了一个接口。

Mirror

通过反射提供的所有信息都可以通过mirror访问。 根据要获取的信息类型或要采取的反射行为，必须使用不同的mirror 风格。 Classloader mirror 可用于获取类型和成员的表示。从类加载器镜像中，可以获得更专用的invoker mirror（最常用的镜像），这些镜像实现反射调用，例如方法或构造函数调用和字段访问。

概要：

  • “Classloader”mirror。 这些镜像将名称转换为符号（通过 staticClass / staticModule / staticPackage方法）。
  • “Invoker”mirror。 这些镜像实现反射调用（通过方法MethodMirror.apply，FieldMirror.get等）。 这些 invoker mirror 是最常用的镜像类型。

运行时 Mirror

在运行时使用的 mirror 入口点是通过 ru.runtimeMirror(<classloader>)，其中 ru 是scala.reflect.runtime.universe。

scala.reflect.api.JavaMirrors#runtimeMirror 调用的结果是一个类加载器镜像，类型为scala.reflect.api.Mirrors#ReflectiveMirror，它可以按名称加载符号。

类加载器镜像可以创建调用者镜像（包括 scala.reflect.api.Mirrors#InstanceMirror，scala.reflect.api.Mirrors#MethodMirror，scala.reflect.api.Mirrors#FieldMirror，scala.reflect.api.Mirrors#ClassMirror 和 scala.reflect.api.Mirrors#ModuleMirror）。

这两种类型的镜像如何交互的例子可以在下面找到。

Mirror 的类型，用例和例子

`ReflectiveMirror 用于按名称加载符号，并作为调用者镜像的入口点。 入口点：val m = ru.runtimeMirror(<classloader>)。 例：

scala> val ru = scala.reflect.runtime.universe
ru: scala.reflect.api.JavaUniverse = ...

scala> val m = ru.runtimeMirror(getClass.getClassLoader)
m: scala.reflect.runtime.universe.Mirror = JavaMirror ...

InstanceMirror 用于为方法和字段以及内部类和内部对象（模块）创建调用者镜像。 入口点：val im = m.reflect(<value>)。例：

scala> class C { def x = 2 }
defined class C

scala> val im = m.reflect(new C)
im: scala.reflect.runtime.universe.InstanceMirror = instance mirror for C@3442299e

MethodMirror 用于调用实例方法（Scala只有实例方法 – 对象方法是对象实例的实例方法，可通过ModuleMirror.instance 获取）。入口点：val mm = im.reflectMethod(<method symbol>)。 例：

scala> val methodX = ru.typeOf[C].decl(ru.TermName("x")).asMethod
methodX: scala.reflect.runtime.universe.MethodSymbol = method x

scala> val mm = im.reflectMethod(methodX)
mm: scala.reflect.runtime.universe.MethodMirror = method mirror for C.x: scala.Int (bound to C@3442299e)

scala> mm()
res0: Any = 2

FieldMirror 用于获取/设置实例字段（如方法，Scala只有实例字段，参见上文）。 入口点：val fm = im.reflectField(<field or accessor symbol>)。 例：

scala> class C { val x = 2; var y = 3 }
defined class C

scala> val m = ru.runtimeMirror(getClass.getClassLoader)
m: scala.reflect.runtime.universe.Mirror = JavaMirror ...

scala> val im = m.reflect(new C)
im: scala.reflect.runtime.universe.InstanceMirror = instance mirror for C@5f0c8ac1

scala> val fieldX = ru.typeOf[C].decl(ru.TermName("x")).asTerm.accessed.asTerm
fieldX: scala.reflect.runtime.universe.TermSymbol = value x

scala> val fmX = im.reflectField(fieldX)
fmX: scala.reflect.runtime.universe.FieldMirror = field mirror for C.x (bound to C@5f0c8ac1)

scala> fmX.get
res0: Any = 2

scala> fmX.set(3)

scala> val fieldY = ru.typeOf[C].decl(ru.TermName("y")).asTerm.accessed.asTerm
fieldY: scala.reflect.runtime.universe.TermSymbol = variable y

scala> val fmY = im.reflectField(fieldY)
fmY: scala.reflect.runtime.universe.FieldMirror = field mirror for C.y (bound to C@5f0c8ac1)

scala> fmY.get
res1: Any = 3

scala> fmY.set(4)

scala> fmY.get
res2: Any = 4

ClassMirror 用于为构造函数创建调用者镜像。入口点：对于静态类 val cm1 = m.reflectClass(<class symbol>)，对于内部类 val mm2 = im.reflectClass(<class symbol>)。 例：

scala> case class C(x: Int)
defined class C

scala> val m = ru.runtimeMirror(getClass.getClassLoader)
m: scala.reflect.runtime.universe.Mirror = JavaMirror ...

scala> val classC = ru.typeOf[C].typeSymbol.asClass
classC: scala.reflect.runtime.universe.Symbol = class C

scala> val cm = m.reflectClass(classC)
cm: scala.reflect.runtime.universe.ClassMirror = class mirror for C (bound to null)

scala> val ctorC = ru.typeOf[C].decl(ru.termNames.CONSTRUCTOR).asMethod
ctorC: scala.reflect.runtime.universe.MethodSymbol = constructor C

scala> val ctorm = cm.reflectConstructor(ctorC)
ctorm: scala.reflect.runtime.universe.MethodMirror = constructor mirror for C.<init>(x: scala.Int): C (bound to null)

scala> ctorm(2)
res0: Any = C(2)

ModuleMirror 用于访问单例对象的实例。入口点：对于静态对象 val mm1 = m.reflectModule(<module symbol>)，对于内部对象 val mm2 = im.reflectModule(<module symbol>)。例：

scala> object C { def x = 2 }
defined module C

scala> val m = ru.runtimeMirror(getClass.getClassLoader)
m: scala.reflect.runtime.universe.Mirror = JavaMirror ...

scala> val objectC = ru.typeOf[C.type].termSymbol.asModule
objectC: scala.reflect.runtime.universe.ModuleSymbol = object C

scala> val mm = m.reflectModule(objectC)
mm: scala.reflect.runtime.universe.ModuleMirror = module mirror for C (bound to null)

scala> val obj = mm.instance
obj: Any = C$@1005ec04

编译时 Mirror

编译时镜像仅使用类加载器镜像来按名称加载符号。

类加载器镜像的入口点是通过 scala.reflect.macros.Context#mirror。使用类加载器镜像的典型方法包括scala.reflect.api.Mirror#staticClass，scala.reflect.api.Mirror#staticModule 和 scala.reflect.api.Mirror#staticPackage。例如：

import scala.reflect.macros.Context

case class Location(filename: String, line: Int, column: Int)

object Macros {
  def currentLocation: Location = macro impl

  def impl(c: Context): c.Expr[Location] = {
    import c.universe._
    val pos = c.macroApplication.pos
    val clsLocation = c.mirror.staticModule("Location") // get symbol of "Location" object
    c.Expr(Apply(Ident(clsLocation), List(Literal(Constant(pos.source.path)), Literal(Constant(pos.line)), Literal(Constant(pos.column)))))
  }
}

值得注意的是：有几种高级别的选择可以用来避免手动查找符号。例如，Of[Location.type].termSymbol（或 typeOf[Location].typeSymbol，如果我们需要一个 ClassSymbol），这是类型安全的，因为我们不必使用字符串来查找符号。

    原文作者：gcusky
    原文地址: https://segmentfault.com/a/1190000014772704
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞