Scala微基准测试工具的测试自注册（反射/静态）实现求助

我来帮你搞定Scala里微基准测试工具的注册问题，结合Scala的语言特性，给你两种落地可行的方案，还会解决你可能遇到的坑：

一、静态注册方案（Scala风格的“静态初始化”） #

Java里的静态初始化块，在Scala里对应的是单例object的构造代码——因为Scala的object是懒加载的单例，当它第一次被访问时会执行初始化逻辑。我们可以利用这个特性做静态注册：

1. 定义核心接口与注册中心 #

首先定义基准测试的通用接口，再写一个全局的测试注册中心：

// 基准测试的通用特质
trait BenchmarkTest {
  def name: String // 测试名称
  def run(): Unit  // 测试逻辑
}

// 测试注册中心：单例object，负责存储和管理所有测试
object TestRegistry {
  private val registeredTests = collection.mutable.ListBuffer[BenchmarkTest]()

  // 注册测试的方法
  def register(test: BenchmarkTest): Unit = {
    registeredTests += test
    println(s"Registered benchmark: ${test.name}")
  }

  // 获取所有已注册的测试
  def getAllTests: Seq[BenchmarkTest] = registeredTests.toSeq
}

2. 编写测试类并自动注册 #

每个测试类实现BenchmarkTest特质，然后在单例object的初始化代码里调用注册方法——Scala会在object第一次被加载时自动执行这段代码：

// 示例：字符串拼接性能测试
object StringConcatenationTest extends BenchmarkTest {
  override def name: String = "字符串拼接性能测试"

  override def run(): Unit = {
    var result = ""
    for (i <- 1 to 10000) {
      result += i.toString
    }
    println(s"测试完成，结果长度：${result.length}")
  }

  // 自动注册：object初始化时执行
  TestRegistry.register(this)
}

3. 测试运行器的实现 #

这里要注意一个坑：Scala的object是懒加载的，如果测试类没有被显式引用，JVM不会加载它，注册逻辑也就不会触发。解决办法是在运行器里显式导入所有测试类，或者通过构建工具帮我们触发加载：

object TestRunner extends App {
  // 显式导入测试类，触发它们的初始化与注册
  import com.yourpackage.benchmarks._

  val tests = TestRegistry.getAllTests
  println(s"\n找到${tests.size}个基准测试：")
  
  tests.foreach { test =>
    println(s"\n开始运行：${test.name}")
    val startTime = System.nanoTime()
    test.run()
    val durationMs = (System.nanoTime() - startTime) / 1e6
    println(s"${test.name}完成，耗时：${durationMs.round} ms")
  }
}

如果不想手动导入测试类，可以在sbt里配置自动传递测试类的全类名给运行器：

// build.sbt中添加配置
val benchmarkPackage = "com.yourpackage.benchmarks"

Compile / run := {
  // 收集指定包下的所有类
  val benchmarkClasses = (Compile / discoveredClasses).value
    .filter(_.getName.startsWith(benchmarkPackage))
    .map(_.getName)
    .mkString(" ")
  
  // 把类名作为参数传给TestRunner
  (Compile / run).evaluated(Seq(benchmarkClasses))
}

然后修改TestRunner，通过参数加载类：

object TestRunner extends App {
  // 加载传入的类名，触发初始化与注册
  args.flatMap(_.split(" ")).foreach(Class.forName(_))

  // 后续运行逻辑不变...
}

二、反射扫描方案 #

如果想完全自动发现测试类，不需要手动注册或导入，可以用Scala的反射API扫描指定包下的所有测试类：

1. 依赖准备 #

首先需要在build.sbt中添加Scala反射库的依赖：

libraryDependencies += "org.scala-lang" % "scala-reflect" % scalaVersion.value

2. 反射扫描的运行器实现 #

import scala.reflect.runtime.universe._
import scala.reflect.runtime.{currentMirror => cm}

object ReflectiveTestRunner extends App {
  // 要扫描的目标包名
  val targetPackage = "com.yourpackage.benchmarks"

  // 获取包对应的符号
  val packageSymbol = cm.staticPackage(targetPackage)
  // 过滤出包下的所有类/单例object
  val classSymbols = packageSymbol.info.decls
    .filter(_.isClass)
    .map(_.asClass)

  // 筛选出实现了BenchmarkTest的类，并实例化
  val benchmarkTests = classSymbols.flatMap { cls =>
    // 判断类是否实现了BenchmarkTest特质
    if (cls.selfType <:< typeOf[BenchmarkTest]) {
      try {
        if (cls.isModuleClass) {
          // 如果是单例object，获取其实例
          val module = cm.reflectModule(cls.asModule)
          Some(module.instance.asInstanceOf[BenchmarkTest])
        } else {
          // 如果是普通类，调用无参构造实例化
          val classMirror = cm.reflectClass(cls)
          val constructor = cls.primaryConstructor.asMethod
          val instance = classMirror.reflectConstructor(constructor)()
          Some(instance.asInstanceOf[BenchmarkTest])
        }
      } catch {
        case e: Exception =>
          println(s"实例化${cls.fullName}失败：${e.getMessage}")
          None
      }
    } else {
      None
    }
  }.toSeq

  // 运行测试（逻辑和之前的TestRunner一致）
  println(s"\n通过反射找到${benchmarkTests.size}个基准测试：")
  benchmarkTests.foreach { test =>
    println(s"\n开始运行：${test.name}")
    val startTime = System.nanoTime()
    test.run()
    val durationMs = (System.nanoTime() - startTime) / 1e6
    println(s"${test.name}完成，耗时：${durationMs.round} ms")
  }
}

3. 进阶：用注解标记测试类 #

如果不想通过特质来筛选测试，可以自定义一个注解，扫描带有注解的类：

// 自定义基准测试注解
import scala.annotation.StaticAnnotation
class Benchmark extends StaticAnnotation

然后给测试类添加注解：

@Benchmark
object StringConcatenationTest extends BenchmarkTest {
  // 测试逻辑...
}

修改反射扫描的判断条件：

// 替换之前的if判断，检查类是否带有@Benchmark注解
if (cls.annotations.exists(_.tree.tpe =:= typeOf[Benchmark])) {
  // 实例化逻辑...
}

两种方案的优缺点对比 #

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