Groovy元类与Java 8的互操作性

简介：

我正在开发一个名为的Java库，它还有一个Groovy扩展。在Java 8之前，您可以这样使用库：

// Syntax example with the Groovy extension
await().atMost(500, MILLISECONDS).until { asynch.getValue() == 2 }

ConditionFactory.metaClass.until { Closure closure ->
      delegate.until(new Callable<Boolean>() {
        Boolean call() {
          return closure.call();
        }
      });
    }

def originalMethod = ConditionFactory.metaClass.getMetaMethod("until", Runnable.class)
ConditionFactory.metaClass.until { Runnable runnable ->
  if (runnable instanceof Closure) {
    delegate.until(new Callable<Boolean>() {
      Boolean call() {
        return (runnable as Closure).call();
      }
    });
  } else {
    originalMethod.invoke(delegate, runnable)
  }
}

Groovy扩展使用Java API中定义的名为

ConditionFactory

的类。但是这个API没有定义一个接受Groovy闭包实例的until方法。因此，该方法添加了一个元类，如下所示：

// Syntax example with the Groovy extension
await().atMost(500, MILLISECONDS).until { asynch.getValue() == 2 }

ConditionFactory.metaClass.until { Closure closure ->
      delegate.until(new Callable<Boolean>() {
        Boolean call() {
          return closure.call();
        }
      });
    }

def originalMethod = ConditionFactory.metaClass.getMetaMethod("until", Runnable.class)
ConditionFactory.metaClass.until { Runnable runnable ->
  if (runnable instanceof Closure) {
    delegate.until(new Callable<Boolean>() {
      Boolean call() {
        return (runnable as Closure).call();
      }
    });
  } else {
    originalMethod.invoke(delegate, runnable)
  }
}

ConditionFactory.metaClass.until{Closure->
delegate.until（newcallable（））{
布尔调用（）{
返回closure.call（）；
}
});
}

正如您所看到的，它只是简单地委托给Java API中的

until

方法，该方法采用

Callable

的一个实例

问题：

---

JavaAPI还包含一个重载方法

until

，该方法将

Runnable

作为其参数。当Groovy扩展与Java 8一起使用时，将调用

Runnable

版本的

until

方法，而不是将

Closure

作为参数的

until

方法（使用

元类定义的方法）。元类似乎不再起作用了。为什么会这样？有解决办法吗？
事实上，我认为这与Java8没有任何关系（很抱歉造成混淆）。解决我问题的方法如下：

// Syntax example with the Groovy extension
await().atMost(500, MILLISECONDS).until { asynch.getValue() == 2 }

ConditionFactory.metaClass.until { Closure closure ->
      delegate.until(new Callable<Boolean>() {
        Boolean call() {
          return closure.call();
        }
      });
    }

def originalMethod = ConditionFactory.metaClass.getMetaMethod("until", Runnable.class)
ConditionFactory.metaClass.until { Runnable runnable ->
  if (runnable instanceof Closure) {
    delegate.until(new Callable<Boolean>() {
      Boolean call() {
        return (runnable as Closure).call();
      }
    });
  } else {
    originalMethod.invoke(delegate, runnable)
  }
}

def originalMethod=ConditionFactory.metaClass.getMetaMethod（“直到”，Runnable.class）
ConditionFactory.metaClass.until{Runnable Runnable->
if（可运行的闭包实例）{
delegate.until（newcallable（））{
布尔调用（）{
return（runnable as Closure）.call（）；
}
});
}否则{
调用（委托，可运行）
}
}
野生假设：
闭包
不是一个
@功能界面
？它的原型是什么？闭包不是一个功能接口，但现在我仔细看看，它确实实现了Runnable！我想这可能就是问题所在。