主页 / coding / 问题 / 78833225
Accepted
david.perez
Asked: 2024-08-05 15:24:00 +0800 CST

如何在Scala 3中通过反射获取案例类字段的值

  • 772

我正在迁移曾经使用 Scala 2 反射的代码。

我正在尝试使用scala-reflection库。

我需要获取案例类中给定名称的字段的值。

例子：

$ scala-cli -j system -S 3.4.2 --dep co.blocke::scala-reflection:2.0.8
scala> import co.blocke.scala_reflection.RType

scala> case class A(a: Int, b: String)
// defined case class A

scala> import co.blocke.scala_reflection.rtypes.ScalaClassRType

scala> val t = RType.of[A].asInstanceOf[ScalaClassRType[A]]
val t: co.blocke.scala_reflection.rtypes.ScalaClassRType[A] = ScalaClassRType(rs$line$2$A,rs$line$2$.A,List(),List(),List(),List(ScalaFieldInfo(0,a,IntRType(),Map(),None,None,false), ScalaFieldInfo(1,b,StringRType(),Map(),None,None,false)),Map(),List(java.lang.Object, scala.Product, java.io.Serializable),false,false,true,false,Map(),List(),List(),false)

scala> t.fields.find(_.name == "a")
val res2: Option[co.blocke.scala_reflection.rtypes.FieldInfo] = Some(ScalaFieldInfo(0,a,IntRType(),Map(),None,None,false))

scala> val c = A(3,"hola")
val c: A = A(3,hola)

在这个例子中，如何a通过实例反射来获取字段的值c。

如果更容易的话，我可以考虑使用其他库，如izumi-reflect。

scala

1 个回答

  1. Best Answer

    假设您想要通过将事物一个接一个地放入 JDBC 中来序列化它们：

    trait SerializationTarget
object SerializationTarget {
  val example: SerializationTarget = new SerializationTarget {}
}

    这是一个存根，我将使用它来传递它以调用某些 API。

    trait SerializeForJDBC[A] {

  def serialize(value: A, target: SerializationTarget): Unit
}

    这将是获取值A并以某种方式将其所有数据放入的类型类SerializationTarget- 不管它看起来像什么。

    我们将从一些（存根）实例开始，展示如何处理原语：

    object SerializeForJDBC {

  given SerializeForJDBC[Int] with
    def serialize(value: Int, target: SerializationTarget): Unit = ()
  given SerializeForJDBC[Double] with
    def serialize(value: Double, target: SerializationTarget): Unit = ()
  given SerializeForJDBC[String] with
    def serialize(value: String, target: SerializationTarget): Unit = ()
}

extension [A](value: A)
  final def serializeForJDBC(target: SerializationTarget)(using
      SerializeForJDBC[A]
  ): Unit =
    summon[SerializeForJDBC[A]].serialize(value, target)

    现在，当我们打电话时

    10.serializeForJDBC(SerializationTarget.example)
20.0.serializeForJDBC(SerializationTarget.example)
"test".serializeForJDBC(SerializationTarget.example)

    代码会选择正确given并使用它，基本上就像一个策略模式，但是该策略是基于类型的DI。

    最后，我们将使用Mirrors 为每个 生成这样的策略case class：

    object SerializeForJDBC {
  // other givens ...

  import scala.compiletime.*
  import scala.deriving.*

  inline given derived[A <: Product](using
      p: Mirror.ProductOf[A]
  ): SerializeForJDBC[A] = {
    new SerializeForJDBC[A] {
      // - p.MirroredElemTypes is a path-dependent type, which is a tuple
      //   containing types for the fields of a case class in order in which
      //   they were defined
      // - Tuple.Map turns it into (SerializeForJDBC[Field1], SerializeForJDBC[Field2], ...)
      // - summonAll takes the type of a tuple and returns a tuple of givens
      // - that's why we had to define givens before and put them into scope
      //   e.g. by putting them into the companion object of a type class
      private val instances =
        summonAll[Tuple.Map[p.MirroredElemTypes, SerializeForJDBC]].toList
          .asInstanceOf[List[SerializeForJDBC[Any]]]

      def serialize(value: A, target: SerializationTarget): Unit =
        // the easiest way of passing values into mirrors is to cast everything
        // as Any and TypeClass[Any] and make sure that indices are correct
        // e.g. using .zip
        value.productIterator.zip(instances).foreach { case (field, instance) =>
          instance.asInstanceOf[SerializeForJDBC[Any]].serialize(field, target)
        }
    }
  }
}

    最后我们可以调用它：

    case class Example(a: Int, b: Double, c: String)

Example(1, 2.0, "3").serializeForJDBC(SerializationTarget.example)

    每次需要时，它都会创建一个新的实例SerializeForJDBC[Example]。这应该不是什么大问题，但如果我们想缓存实例，我们可以使用derives关键字（因为我们将基于镜像的方法定义为derived）：

    case class Example(a: Int, b: Double, c: String) derives SerializeForJDBC

Example(1, 2.0, "3").serializeForJDBC(SerializationTarget.example)

    在实际代码中，您必须用SerializationTarget与 JDBC 交互的任何方式进行替换，替换原始的主体given，并调整如何将每个字段的实例组合成一个整体的实例case class。

    内置镜像的替代方案是 Magnolia 库 - 由于它是基于宏的，因此它能够提供比缺失隐式/给定更好的错误消息。如果想要在 Scala 2 和 Scala 3 之间实现交叉编译解决方案，它也是一个不错的选择。

    • 2

相关问题