0

我想构建一个 Scala DSL 以将现有的 Java POJO 结构转换为等效于 Map 的结构。

然而，传入的对象结构很可能包含大量空引用，这将导致输出映射中没有值。

在这种情况下，性能非常重要，因此我需要避免反射和抛出/捕获 NPE。

我已经考虑过这个不符合我要求的主题。

我认为答案可能在于使用宏来生成一些特殊类型，但我没有使用 scala 宏的经验。

更正式地说：

项目提供的 POJO 类：（会有 50 个 POJO 嵌套，所以我想要一个不需要为每个类手动编写和维护类或特征的解决方案）

  case class Level1(
    @BeanProperty var a: String,
    @BeanProperty var b: Int)

  case class Level2(
    @BeanProperty var p: Level1,
    @BeanProperty var b: Int)

预期行为：

  println(convert(null)) // == Map()
  println(convert(Level2(null, 3))) // == Map("l2.b" -> 3)
  println(convert(Level2(Level1("a", 2), 3))) // == Map(l2.p.a -> a, l2.p.b -> 2, l2.b -> 3)

正确的实现，但我想要一个更简单的 DSL 来编写映射

  implicit def toOptionBuilder[T](f: => T) = new {
    def ? : Option[T] = Option(f)
  }

 def convert(l2: Level2): Map[String, _] = l2? match {
    case None => Map()
    case Some(o2) => convert(o2.p, "l2.p.") + ("l2.b" -> o2.b)
  }

  def convert(l1: Level1, prefix: String = ""): Map[String, _] = l1? match {
    case None => Map()
    case Some(o1) => Map(
      prefix + "a" -> o1.a,
      prefix + "b" -> o1.b)
  }

这是我想用 DSL 编写的方式：

 def convertDsl(l2:Level2)={
      Map(
          "l2.b" -> l2?.b,
          "l2.p.a" -> l2?.l1?.a,
          "l2.p.b" -> l2?.l1?.b
          )
    }

请注意，我可以使用“？”指定该属性是可选的。我想要的是使用宏静态生成方法 l2.?l1 或 l2?.l1 返回 Option[Level1] （因此在我的 DSL 中正确完成了类型检查）。

4

1 回答 1

0

我无法将其精确到您在上面给出的语法，但一般来说，这样的事情可能会起作用：

sealed trait FieldSpec

sealed trait ValueFieldSpec[+T] extends FieldSpec
{
  def value: Option[T]
}

case class IntFieldSpec(value: Option[Int]) extends ValueFieldSpec[Int]
case class StringFieldSpec(value: Option[String]) extends ValueFieldSpec[String]

case class Level1FieldSpec(input: Option[Level1]) extends FieldSpec
{
  def a: ValueFieldSpec[_] = StringFieldSpec(input.map(_.a))
  def b: ValueFieldSpec[_] = IntFieldSpec(input.map(_.b))
}

case class Level2FieldSpec(input: Option[Level2]) extends FieldSpec
{
  def b: ValueFieldSpec[_] = IntFieldSpec(input.map(_.b))
  def l1 = Level1FieldSpec(input.map(_.p))
}

case class SpecArrowAssoc(str: String)
{
  def ->(value: ValueFieldSpec[_]) = (str, value)
}

implicit def str2SpecArrowAssoc(str: String) = SpecArrowAssoc(str)

implicit def Level2ToFieldSpec(input: Option[Level2]) = Level2FieldSpec(input)

def map(fields: (String, ValueFieldSpec[_])*): Map[String, _] =
  Map[String, Any]((for {
    field <- fields
    value <- field._2.value
  } yield (field._1, value)):_*)

def convertDsl(implicit l2: Level2): Map[String, _] =
{
  map(
    "l2.b" -> l2.?.b,
    "l2.p.a" -> l2.?.l1.a,
    "l2.p.b" -> l2.?.l1.b
  )
}

然后我们得到：

scala> val myL2 = Level2(Level1("a", 2), 3)
myL2: Level2 = Level2(Level1(a,2),3)

scala> convertDsl(myL2)
res0: scala.collection.immutable.Map[String,Any] = Map(l2.b -> 3, l2.p.a -> a, l2.p.b -> 2)

请注意，DSL 使用 '.?' 而不仅仅是“？” 作为我可以看到 Scala 在分号推断和后缀运算符方面遇到的唯一方法（例如，参见 @0__ 对scala 语法糖问题的回答）。

此外，您可以提供的字符串是任意的（不对其进行检查或解析），并且这种简单的“FieldSpec”层次结构将假定您的所有 POJO 使用“a”表示字符串字段，使用“b”表示 Int 字段等。

通过一些时间和精力，我相信这可以得到改进。

于 2013-07-10T15:14:20.003 回答