从字符串构造简单的Scala case类，严格避免样板代码。

Question

从字符串构造简单的Scala case类，严格避免样板代码。

29

我希望为简单的Scala case类从字符串（例如csv行）中初始化提供简洁的代码：

case class Person(name: String, age: Double)
case class Book(title: String, author: String, year: Int)
case class Country(name: String, population: Int, area: Double)

val amy = Creator.create[Person]("Amy,54.2")
val fred = Creator.create[Person]("Fred,23")
val hamlet = Creator.create[Book]("Hamlet,Shakespeare,1600")
val finland = Creator.create[Country]("Finland,4500000,338424")

有哪个最简单的Creator对象可以做到这一点呢？从看到一个好的解决方案中我将学到很多Scala。

(请注意，伴生对象Person、Book和Country不应该被强制存在。那样就是样板代码！)

- Perfect Tiling

2个回答

2

object Creator {
  def create[T: ClassTag](params: String): T = {
    val ctor = implicitly[ClassTag[T]].runtimeClass.getConstructors.head
    val types = ctor.getParameterTypes

    val paramsArray = params.split(",").map(_.trim)

    val paramsWithTypes = paramsArray zip types

    val parameters = paramsWithTypes.map {
      case (param, clas) =>
        clas.getName match {
          case "int" => param.toInt.asInstanceOf[Object] // needed only for AnyVal types
          case "double" => param.toDouble.asInstanceOf[Object] // needed only for AnyVal types
          case _ =>
            val paramConstructor = clas.getConstructor(param.getClass)
            paramConstructor.newInstance(param).asInstanceOf[Object]
        }

    }

    val r = ctor.newInstance(parameters: _*)
    r.asInstanceOf[T]
  }
}

- Maxim

1

我真的很喜欢这个简单易用，没有包依赖的特点。当然，由于反射机制，它会比较慢 --- 但是对于当前的目的，我并不在意这一点。（我假设基于shapeless的答案可以在编译时完成魔法，而无需使用反射...？！） - Perfect Tiling

3

这种方法的主要问题在于它很脆弱，一旦出现问题，就会在运行时崩溃——在大多数情况下，性能代价不太可能显著。而且，在 Shapeless 解决方案中没有运行时反射（虽然它确实使用了反射——请参见我在这里的回答进行讨论）。 - Travis Brown

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Travis Brown · Accepted Answer

我将提供一个解决方案，考虑到类型安全的合理限制（无运行时异常，无运行时反射等），使用Shapeless进行通用推导，这是尽可能简单的方案：

import scala.util.Try
import shapeless._

trait Creator[A] { def apply(s: String): Option[A] }

object Creator {
  def create[A](s: String)(implicit c: Creator[A]): Option[A] = c(s)

  def instance[A](parse: String => Option[A]): Creator[A] = new Creator[A] {
    def apply(s: String): Option[A] = parse(s)
  }

  implicit val stringCreate: Creator[String] = instance(Some(_))
  implicit val intCreate: Creator[Int] = instance(s => Try(s.toInt).toOption)
  implicit val doubleCreate: Creator[Double] =
    instance(s => Try(s.toDouble).toOption)

  implicit val hnilCreator: Creator[HNil] =
    instance(s => if (s.isEmpty) Some(HNil) else None)

  private[this] val NextCell = "^([^,]+)(?:,(.+))?$".r

  implicit def hconsCreate[H: Creator, T <: HList: Creator]: Creator[H :: T] =
    instance {
      case NextCell(cell, rest) => for {
        h <- create[H](cell)
        t <- create[T](Option(rest).getOrElse(""))
      } yield h :: t
      case _ => None
    }

  implicit def caseClassCreate[C, R <: HList](implicit
    gen: Generic.Aux[C, R],
    rc: Creator[R]
  ): Creator[C] = instance(s => rc(s).map(gen.from))
}

这个工作完全按照规定的方式进行（请注意，值被包装在 Option 中表示解析操作可能会失败）：

scala> case class Person(name: String, age: Double)
defined class Person

scala> case class Book(title: String, author: String, year: Int)
defined class Book

scala> case class Country(name: String, population: Int, area: Double)
defined class Country

scala> val amy = Creator.create[Person]("Amy,54.2")
amy: Option[Person] = Some(Person(Amy,54.2))

scala> val fred = Creator.create[Person]("Fred,23")
fred: Option[Person] = Some(Person(Fred,23.0))

scala> val hamlet = Creator.create[Book]("Hamlet,Shakespeare,1600")
hamlet: Option[Book] = Some(Book(Hamlet,Shakespeare,1600))

scala> val finland = Creator.create[Country]("Finland,4500000,338424")
finland: Option[Country] = Some(Country(Finland,4500000,338424.0))

Creator是一个类型类，提供了我们可以将字符串解析为给定类型的证明。我们必须为基本类型（如String、Int等）提供显式实例，但是我们可以使用Shapeless为case类派生通用实例（假设我们有所有成员类型的Creator实例）。