EXPERIMENTAL
Environment
反射环境根据反射工作是在运行时还是在编译时完成而有所不同。在运行时和编译时使用的环境之间的区别被封装在一个所谓的 宇宙（universe） 中。 反射环境的另一个重要方面是我们可以反射的访问一组实体。这组实体由所谓的 镜像（mirror） 决定。
例如，可通过运行时反射访问的实体由ClassloaderMirror提供。该镜像仅提供对由特定类加载器加载的实体（包，类型和成员）的访问。
镜像不仅可以确定反射访问的实体集。它们还提供对这些实体执行的反射操作。例如，在运行时反射中，可以使用调用者镜像（invoker mirror）来调用类的方法或构造函数。
Universes
宇宙有两种主要类型 - 由于同时具有运行时和编译时反射功能，一个人必须使用与即将完成的工作相对应的宇宙。二者之一：
scala.reflect.runtime.universe用于 运行时反射，或者scala.reflect.macros.Universe用于 编译时反射。
一个宇宙提供了反射中使用的所有主要概念的接口，例如类型（Types），树（Trees）和注解（Annotations）。
Mirrors
反射提供的所有信息都可以通过镜像访问。根据要获得的信息类型或要采取的反射动作，必须使用不同类型的镜像。类加载器镜像可用于获取类型和成员的表示。 从类加载器镜像中，可以获得更专门的调用者镜像（最常用的镜像），这些镜像实现了反射调用，例如方法或构造函数调用以及字段访问。
总结：
-
“类加载器” 镜像。这些镜像将名称转换为符号 (通过方法
staticClass/staticModule/staticPackage)。 -
“调用者” 镜像。这些镜像实现反射调用（通过方法
MethodMirror.apply，FieldMirror.get，等等。）。这些”调用者”镜像是最常用的镜像类型。
Runtime Mirrors
在运行时使用的镜像的入口点是通过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）。
下面提供了这两种类型的反射镜像如何相互作用的示例。
Types of Mirrors, Their Use Cases & Examples
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
Compile-Time Mirrors
编译时镜像仅使用类加载器镜像来按名称加载符号。
类加载器镜像的入口点通过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)))))
}
}
注意：有几种高级替代方法，可以避免必须手动查找符号。例如，typeOf[Location.type].termSymbol（如果需要ClassSymbol，则为typeOf[Location].typeSymbol），因为我们不必使用字符串来查找符号，所以它们是类型安全的。