此文档页面特定于 Scala 2 中提供的功能，这些功能已在 Scala 3 中删除或被替代功能所取代。除非另有说明，此页面中的所有代码示例均假定你使用的是 Scala 2。
实验性
环境
反射环境根据反射任务是在运行时还是在编译时执行而有所不同。在运行时或编译时使用的环境之间的区别封装在一个所谓的宇宙中。反射环境的另一个重要方面是我们具有反射访问权限的实体集。这组实体由所谓的镜像决定。
例如，可以通过运行时反射访问的实体由 ClassloaderMirror 提供。此镜像仅提供对由特定类加载器加载的实体（包、类型和成员）的访问。
镜像不仅决定了可以通过反射访问的实体集。它们还提供对这些实体执行的反射操作。例如，在运行时反射中，调用程序镜像可用于调用类的某个方法或构造函数。
宇宙
有两种主要类型的宇宙——由于同时存在运行时和编译时反射功能，因此必须使用与手头任务相对应的宇宙。要么
scala.reflect.runtime.universe用于运行时反射，或者scala.reflect.macros.Universe用于编译时反射。
宇宙提供了一个界面，用于反射中使用所有主要概念，例如 Types、Trees 和 Annotations。
镜像
反射提供的所有信息都可以通过镜像访问。根据要获取的信息类型或要执行的反射操作，必须使用不同类型的镜像。类加载器镜像可用于获取类型和成员的表示形式。从类加载器镜像中，可以获取更专门的调用方镜像（最常用的镜像），它实现反射调用，例如方法或构造函数调用以及字段访问。
摘要
-
“类加载器”镜像。这些镜像将名称转换为符号（通过方法
staticClass/staticModule/staticPackage）。 -
“调用方”镜像。这些镜像实现反射调用（通过方法
MethodMirror.apply、FieldMirror.get等）。这些“调用方”镜像是最常用的镜像类型。
运行时镜像
在运行时使用的镜像的入口点是通过 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）。
下面提供了有关这两种类型的镜像如何交互的示例。
镜像类型、它们的用例和示例
一个 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
编译时镜像
编译时镜像仅使用类加载器镜像按名称加载符号。
通过 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（或 typeOf[Location].typeSymbol 如果我们需要一个 ClassSymbol），由于我们不必使用字符串查找符号，因此它们是类型安全的。