Клас справи на карті в Скалі

Чи є хороший спосіб перетворити Scala case class екземпляр , наприклад

case class MyClass(param1: String, param2: String)
val x = MyClass("hello", "world")

в якесь відображення, напр

getCCParams(x) returns "param1" -> "hello", "param2" -> "world"

Що працює для будь-якого класу кейсів, а не тільки заздалегідь визначених. Я виявив, що ви можете витягти назву класу справи, написавши метод, який опитує базовий клас Product, наприклад

def getCCName(caseobj: Product) = caseobj.productPrefix 
getCCName(x) returns "MyClass"

Тож я шукаю подібне рішення, але для полів класу case. Я вважаю, що рішення, можливо, має використовувати відображення Java, але я не хочу писати щось, що може зламатися в майбутньому випуску Scala, якщо основна реалізація класів кейсів зміниться.

В даний час я працюю на сервері Scala та визначаю протокол та всі його повідомлення та винятки, використовуючи класи case, оскільки вони є такою красивою, стислою конструкцією для цього. Але тоді мені потрібно перевести їх на карту Java, щоб переслати рівень обміну повідомленнями для використання будь-якою реалізацією клієнта. Моя поточна реалізація просто визначає переклад для кожного класу випадку окремо, але було б непогано знайти узагальнене рішення.

Це має спрацювати:

def getCCParams(cc: AnyRef) =
  cc.getClass.getDeclaredFields.foldLeft(Map.empty[String, Any]) { (a, f) =>
    f.setAccessible(true)
    a + (f.getName -> f.get(cc))
  }

Оскільки класи case розширюють Product, можна просто .productIteratorотримати значення полів:

def getCCParams(cc: Product) = cc.getClass.getDeclaredFields.map( _.getName ) // all field names
                .zip( cc.productIterator.to ).toMap // zipped with all values

Або як варіант:

def getCCParams(cc: Product) = {          
      val values = cc.productIterator
      cc.getClass.getDeclaredFields.map( _.getName -> values.next ).toMap
}

Однією з переваг Продукту є те, що Вам не потрібно телефонувати setAccessible в поле, щоб прочитати його значення. Іншим є те, що productIterator не використовує відображення.

Зверніть увагу, що цей приклад працює з простими класами регістрів, які не розширюють інші класи і не оголошують поля поза конструктором.

Починаючи Scala 2.13,case class es (як реалізації Product) забезпечуються productElementNames методом який повертає ітератор над іменами їхніх полів.

Заархівуючи імена полів зі значеннями полів, отриманими за допомогою productIterator, ми можемо загалом отримати пов'язане Map:

// case class MyClass(param1: String, param2: String)
// val x = MyClass("hello", "world")
(x.productElementNames zip x.productIterator).toMap
// Map[String,Any] = Map("param1" -> "hello", "param2" -> "world")

Якщо хтось шукає рекурсивну версію, ось модифікація рішення @ Andrejs:

def getCCParams(cc: Product): Map[String, Any] = {
  val values = cc.productIterator
  cc.getClass.getDeclaredFields.map {
    _.getName -> (values.next() match {
      case p: Product if p.productArity > 0 => getCCParams(p)
      case x => x
    })
  }.toMap
}

Він також розширює вкладені класи справ у карти на будь-якому рівні вкладеності.

Ось простий варіант, якщо ви не дбаєте про те, щоб зробити його загальною функцією:

case class Person(name:String, age:Int)

def personToMap(person: Person): Map[String, Any] = {
  val fieldNames = person.getClass.getDeclaredFields.map(_.getName)
  val vals = Person.unapply(person).get.productIterator.toSeq
  fieldNames.zip(vals).toMap
}

scala> println(personToMap(Person("Tom", 50)))
res02: scala.collection.immutable.Map[String,Any] = Map(name -> Tom, age -> 50)

Рішення з ProductCompletionпакета перекладача:

import tools.nsc.interpreter.ProductCompletion

def getCCParams(cc: Product) = {
  val pc = new ProductCompletion(cc)
  pc.caseNames.zip(pc.caseFields).toMap
}

Ви можете використовувати безформний.

Дозволяє

case class X(a: Boolean, b: String,c:Int)
case class Y(a: String, b: String)

Визначте представлення LabelledGeneric

import shapeless._
import shapeless.ops.product._
import shapeless.syntax.std.product._
object X {
  implicit val lgenX = LabelledGeneric[X]
}
object Y {
  implicit val lgenY = LabelledGeneric[Y]
}

Визначте два класи класів для надання методів toMap

object ToMapImplicits {

  implicit class ToMapOps[A <: Product](val a: A)
    extends AnyVal {
    def mkMapAny(implicit toMap: ToMap.Aux[A, Symbol, Any]): Map[String, Any] =
      a.toMap[Symbol, Any]
        .map { case (k: Symbol, v) => k.name -> v }
  }

  implicit class ToMapOps2[A <: Product](val a: A)
    extends AnyVal {
    def mkMapString(implicit toMap: ToMap.Aux[A, Symbol, Any]): Map[String, String] =
      a.toMap[Symbol, Any]
        .map { case (k: Symbol, v) => k.name -> v.toString }
  }
}

Тоді ви можете використовувати його таким чином.

object Run  extends App {
  import ToMapImplicits._
  val x: X = X(true, "bike",26)
  val y: Y = Y("first", "second")
  val anyMapX: Map[String, Any] = x.mkMapAny
  val anyMapY: Map[String, Any] = y.mkMapAny
  println("anyMapX = " + anyMapX)
  println("anyMapY = " + anyMapY)

  val stringMapX: Map[String, String] = x.mkMapString
  val stringMapY: Map[String, String] = y.mkMapString
  println("anyMapX = " + anyMapX)
  println("anyMapY = " + anyMapY)
}

який друкує

anyMapX = Карта (c -> 26, b -> велосипед, a -> true)

anyMapY = Карта (b -> друга, a -> перша)

stringMapX = Карта (c -> 26, b -> велосипед, a -> true)

stringMapY = Карта (b -> друга, a -> перша)

Для вкладених класів регістрів (таким чином вкладених карт) перевірте іншу відповідь

Якщо ви випадково використовуєте Json4s, ви можете зробити наступне:

import org.json4s.{Extraction, _}

case class MyClass(param1: String, param2: String)
val x = MyClass("hello", "world")

Extraction.decompose(x)(DefaultFormats).values.asInstanceOf[Map[String,String]]

Я не знаю про приємне ... але це, здається, працює, принаймні для цього дуже базового прикладу. Ймовірно, для цього потрібно трохи попрацювати, але цього може бути достатньо для початку? В основному він відфільтровує всі "відомі" методи з класу case (або будь-якого іншого класу: /)

object CaseMappingTest {
  case class MyCase(a: String, b: Int)

  def caseClassToMap(obj: AnyRef) = {
    val c = obj.getClass
    val predefined = List("$tag", "productArity", "productPrefix", "hashCode",
                          "toString")
    val casemethods = c.getMethods.toList.filter{
      n =>
        (n.getParameterTypes.size == 0) &&
        (n.getDeclaringClass == c) &&
        (! predefined.exists(_ == n.getName))

    }
    val values = casemethods.map(_.invoke(obj, null))
    casemethods.map(_.getName).zip(values).foldLeft(Map[String, Any]())(_+_)
  }

  def main(args: Array[String]) {
    println(caseClassToMap(MyCase("foo", 1)))
    // prints: Map(a -> foo, b -> 1)
  }
}

commons.mapper.Mappers.Mappers.beanToMap(caseClassBean)

Подробиці: https://github.com/hank-whu/common4s

З використанням відображення Java, але без зміни рівня доступу. Перетворює Product та клас регістрів у Map[String, String]:

def productToMap[T <: Product](obj: T, prefix: String): Map[String, String] = {
  val clazz = obj.getClass
  val fields = clazz.getDeclaredFields.map(_.getName).toSet
  val methods = clazz.getDeclaredMethods.filter(method => fields.contains(method.getName))
  methods.foldLeft(Map[String, String]()) { case (acc, method) =>
    val value = method.invoke(obj).toString
    val key = if (prefix.isEmpty) method.getName else s"${prefix}_${method.getName}"
    acc + (key -> value)
  }
}