Início / coding / Perguntas / 78833225
Accepted
david.perez
Asked: 2024-08-05 15:24:00 +0800 CST

Como obter o valor de um campo de uma classe de caso por reflexão no Scala 3

  • 772

Estou migrando o código que costumava usar a reflexão Scala 2.

Estou tentando usar a biblioteca de reflexão scala .

Preciso obter o valor de um campo de um determinado nome de uma classe de caso.

Exemplo:

$ 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)

Neste exemplo, como posso obter o valor de field apor reflexão em instance c.

Se for mais fácil, eu poderia considerar usar outras bibliotecas como izumi-reflect .

scala

1 respostas

  1. Best Answer

    Supondo que você queira serializar as coisas colocando-as no JDBC, um campo após o outro:

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

    este é um esboço que usarei como algo que você distribuirá para chamar alguma API.

    trait SerializeForJDBC[A] {

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

    Esta será a classe de tipo que pegaria o valor Ae de alguma forma colocaria todos os seus dados SerializationTarget- como quer que seja.

    Começaremos com algumas instâncias (stub) mostrando como os primitivos podem ser tratados:

    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)

    Agora, quando ligaríamos

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

    o código escolheria o certo givene o usaria, basicamente como um padrão de estratégia, mas a estratégia é editada com base em um tipo.

    Finalmente, usaríamos Mirrors para gerar tal estratégia para cada 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)
        }
    }
  }
}

    Finalmente, podemos chamá-lo de:

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

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

    Isso criaria uma nova instância SerializeForJDBC[Example]sempre que necessário. Não deve ser um grande problema, mas se quisermos armazenar a instância em cache, podemos usar a derivespalavra-chave (já que definimos o método baseado em espelho como derived):

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

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

    Em seu código real, você teria que substituir SerializationTargeta forma como interage com o JDBC, substituir os corpos dos primitivos givene ajustar como você combinaria as instâncias de cada campo em uma instância de um whole case class.

    Uma alternativa aos Mirrors integrados é a biblioteca Magnolia - por ser baseada em macro, é capaz de fornecer mensagens de erro um pouco melhores do que implícitos/dados ausentes. Também é uma boa escolha se quisermos ter uma solução compilada cruzada entre Scala 2 e Scala 3.

    • 2

relate perguntas