如何在使用Scala运行时反射创建对象时降低内存垃圾占用？

针对你用Scala反射创建带默认值case class实例的性能和内存问题，我整理了几个更有效的优化方向，先帮你分析下现有方案的核心问题，再给出具体实现：

先分析现有方案的瓶颈 #

你提到方案二性能提升不明显，核心问题其实不在对象创建本身——你已经在伴生对象里复用了唯一实例，真正的开销来自每次调用时重复执行的反射查找操作：比如每次都要找伴生对象、查找default方法符号、生成方法镜像，这些反射操作的耗时远大于获取对象引用的开销。而你之前尝试的缓存只存了实例，并没有缓存这些反射元数据，所以优化效果甚微。

优化方案一：缓存反射元数据（最易实现的运行时优化） #

把反射查找的结果（比如方法镜像、方法句柄）缓存起来，只在第一次调用时做反射操作，后续直接复用缓存的元数据执行调用。这样能彻底消除重复反射的开销：

import java.util.concurrent.ConcurrentHashMap
import scala.reflect.ClassTag
import scala.reflect.runtime.{currentMirror => cm}
import scala.reflect.runtime.universe._

object ReflectDefaultCache {
  // 缓存：case class的Type -> 获取默认实例的函数
  private val defaultGetterCache = new ConcurrentHashMap[Type, () => Any]()

  def getDefault[A](implicit ct: ClassTag[A]): A = {
    val clazzSymbol = cm.classSymbol(ct.runtimeClass)
    val caseClassType = clazzSymbol.toType

    // 第一次调用时完成反射查找，后续直接用缓存的函数
    defaultGetterCache.computeIfAbsent(caseClassType, _ => {
      val companionModule = clazzSymbol.companion.asModule
      val companionInstance = cm.reflectModule(companionModule).instance
      val companionMirror = cm.reflect(companionInstance)
      
      // 找到伴生对象里的default方法
      val defaultMethod = companionMirror.symbol.typeSignature
        .members
        .find(m => m.isMethod && m.name.toString == "default")
        .get
        .asMethod
      
      val methodMirror = companionMirror.reflectMethod(defaultMethod)
      // 返回直接调用方法的函数
      () => methodMirror.apply()
    })().asInstanceOf[A]
  }
}

使用时直接调用ReflectDefaultCache.getDefault[XYZ]，第一次调用会做反射查找，之后所有调用都是直接复用缓存的方法镜像，性能会有显著提升。

优化方案二：用编译时宏替代运行时反射（最优性能方案） #

如果你的场景允许使用编译期宏，可以完全消除运行时反射的开销——宏会在编译阶段直接生成调用伴生对象default方法的代码，和你直接写XYZ.default的性能完全一致：

import scala.language.experimental.macros
import scala.reflect.macros.blackbox

object DefaultInstanceMacro {
  def getDefault[A]: A = macro getDefaultImpl[A]

  def getDefaultImpl[A: c.WeakTypeTag](c: blackbox.Context): c.Tree = {
    import c.universe._
    val caseClassType = weakTypeTag[A].tpe
    val companionSymbol = caseClassType.typeSymbol.companion

    // 编译期检查伴生对象是否有default方法
    val defaultMethod = companionSymbol.typeSignature.member(TermName("default"))
    if (defaultMethod.isEmpty) {
      c.abort(c.enclosingPosition, s"Case class ${caseClassType}的伴生对象没有定义default方法")
    } else {
      // 直接生成调用伴生对象default方法的代码
      q"$companionSymbol.default"
    }
  }
}

使用时直接写val xyz = DefaultInstanceMacro.getDefault[XYZ]，编译后这段代码会被替换成XYZ.default，完全没有运行时反射的开销，内存占用也最小。

优化方案三：用Java MethodHandle替代Scala反射（折中性能方案） #

如果你不能用宏，又觉得Scala反射性能不够，可以试试Java的MethodHandle——它的调用开销比Scala反射低很多，同样配合缓存使用：

import java.lang.invoke.MethodHandles
import java.util.concurrent.ConcurrentHashMap
import scala.reflect.ClassTag

object MethodHandleDefault {
  private val handleCache = new ConcurrentHashMap[Class[_], MethodHandles.MethodHandle]()

  def getDefault[A](implicit ct: ClassTag[A]): A = {
    val caseClass = ct.runtimeClass
    val handle = handleCache.computeIfAbsent(caseClass, cls => {
      // 找到伴生对象的类
      val companionClazz = Class.forName(s"${cls.getName}$$")
      val lookup = MethodHandles.lookup()
      // 获取default方法的MethodHandle
      val defaultMethod = companionClazz.getDeclaredMethod("default")
      lookup.unreflect(defaultMethod)
    })
    // 调用方法获取实例
    handle.invoke().asInstanceOf[A]
  }
}

总结 #

1. 若能使用编译期宏，这是最优解，性能和直接调用一致，无反射开销；
2. 必须用运行时反射的话，优先缓存反射元数据（方法镜像/MethodHandle），而不是只缓存实例；
3. 你的方案二性能差的核心原因是重复执行反射查找，缓存元数据后能大幅降低这部分开销。

内容的提问来源于stack exchange，提问作者Shivam