scala - 如何存储对 Scala 中一组静态 Java 方法的引用？

Question

在 Eclipse 数据绑定(bind)的上下文中，有相当多的 Java 类充当 IObservable 的工厂。对象。例如，有 BeanObservables , PojoObservables , EMFObservables等等，他们都实现了一组类似的方法

  public static IObservableValue observeValue(Object target, String property)

现在，如果我们在 Scala 世界中，每个工厂都可能是一个实现共同特征的单例对象，例如 IObservableFactory ，例如，我可以将它们作为隐式值传递给使用它们创建数据绑定(bind)的方法。

但由于它们是在 Java 中定义的，看来我无能为力。我不会写

val pojoObservableFact = PojoObservables

因为PojoObservables不被识别为一个值。

有什么方法可以让编译器“实例化”一个与 PojoObservables 相对应的单例吗？ Scala 中的类？或者有什么解决方法吗？我知道我可以自己编写单例并转发所有方法调用，但这听起来有点乏味。

---

编辑

为了更清楚地说明:这就是我想要做的:定义一个使用传递的工厂创建可观察值的方法。

def createObservable(fact: ObservableFactory, target: AnyRef, property: String) =
  fact.observeValue(target, property)

但我不知道如何定义 ObservableFactory或者如何实际通过 PojoObservables ，一个仅具有静态方法的 Java 类，对此 createObservable方法。

Answer 1

如果没有其他人提出可行的答案，我认为基于方法签名编写代码生成器不会那么困难。

val a = classOf[String].getMethods.map(_.toString).filter(s =>
  s.contains("public") && s.contains("static")
)

例如，

将提取所有方法签名(在本例中为String)作为字符串。然后

val b = a.map(_.split(" ").reverse.take(2).reverse)

将仅获取函数签名，并将返回类型拆分在前面。现在

val c = b.map(_(1).dropWhile(_ != '(').drop(1).takeWhile(_ != ')').split(","))
val d = b.map(_(1).takeWhile(_ != '('))

将分别获取参数签名和函数名称。然后我们需要转换原始类型，这非常简单，因为我们只需将第一个字母大写(除了 void ，它变成单位):

def jprim2scala(s: String) = {
  val prim = List("boolean","byte","short","char","int","long","float","double")
  def arrayconvert(s: String): String = {
    if (s.endsWith("[]")) "Array["+arrayconvert(s.substring(0,s.length-2))+"]"
    else if (s=="void") "Unit"
    else if (prim contains s) {
      s.substring(0,1).toUpperCase + s.substring(1)
    }
    else s
  }
  arrayconvert(s)
}

def e = (b,c).zipped.map((bi,ci) => (jprim2scala(bi(0)), ci.map(jprim2scala)))

最后你可以把它们重新组合起来:

val f = (d,e).zipped.map((name,ei) => {
  val (ret,args) = ei
  val lastname = name.split('.').last
  "def "+lastname+"(" +
  (for ((a,i) <- args.zipWithIndex) yield ("a"+i+": "+a)).mkString(", ") +
  "): "+ret+" = "+name+"("+(0 until args.length).map("a"+_).mkString(",")+")"
})

现在您拥有了一堆 Scala 代码，您可以将它们(手动)放入适当的单例中。

object Stringleton {
  // The contents of this is cut-and-paste f.map("  "+_).foreach(println)
  def valueOf(a0: java.lang.Object): java.lang.String = java.lang.String.valueOf(a0)
  def valueOf(a0: Array[Char]): java.lang.String = java.lang.String.valueOf(a0)
  def valueOf(a0: Array[Char], a1: Int, a2: Int): java.lang.String = java.lang.String.valueOf(a0,a1,a2)
  def valueOf(a0: Boolean): java.lang.String = java.lang.String.valueOf(a0)
  def valueOf(a0: Char): java.lang.String = java.lang.String.valueOf(a0)
  def valueOf(a0: Int): java.lang.String = java.lang.String.valueOf(a0)
  def valueOf(a0: Long): java.lang.String = java.lang.String.valueOf(a0)
  def valueOf(a0: Float): java.lang.String = java.lang.String.valueOf(a0)
  def valueOf(a0: Double): java.lang.String = java.lang.String.valueOf(a0)
  def copyValueOf(a0: Array[Char], a1: Int, a2: Int): java.lang.String = java.lang.String.copyValueOf(a0,a1,a2)
  def copyValueOf(a0: Array[Char]): java.lang.String = java.lang.String.copyValueOf(a0)
  def format(a0: java.lang.String, a1: Array[java.lang.Object]): java.lang.String = java.lang.String.format(a0,a1)
  def format(a0: java.util.Locale, a1: java.lang.String, a2: Array[java.lang.Object]): java.lang.String = java.lang.String.format(a0,a1,a2)
}

(顺便说一句，Varargs 在这里不起作用 - 如果它们存在，您需要修复它们。您可以通过从方法本身返回到 .isVarArgs 方法来完成此操作(不是它的字符串表示形式)并将最后一个 Array[X] 转换为 X*，然后将其调用为 ai: _*。)

这种方法的好处是，如果有通用方法，您甚至不需要使用结构类型来将它们拉出来——您可以定义您自己的特征，让您的包装方法继承它! (如果您特别雄心勃勃，您可以硬塞几乎但不完全一致的方法来真正符合，例如所有方法都具有相同的方法名称。)