在Java中包装Selenium wait.until函数，函数作为参数

我对Java相当陌生，有一个问题： 是否有任何干净的方法将下面的代码包装到一个函数中，从而将箭头指向的任何表达式作为参数

Foo A, B;
...

try {
    wait.until(new Function<WebDriver, Boolean>() {
        public Boolean apply(WebDriver driver) {
            return A.equals(B); // <=================== some expression 
        }
}
catch (Exception ex) {
  return false;
}
return true;

---

要做到这一点，您需要一个接口或一个抽象类。在这种情况下，两个接口中的一个是更好的选择

如果一个类实现了一个接口，那么它必须具有接口中列出的函数。因此，当您接受函数中的接口时，您知道该对象列出了该函数，并且可以调用它

您将这样定义一个接口：

public interface Test {
    public boolean passedTest();
}

然后，您将定义实现测试的类：

public EqualsTest implements Test {
    private Foo A, B;
    public EqualsTest(Foo A, Foo B){
        this.A = A;
        this.B = B;
    }
    @Overrides
    public boolean passedTest(){
        return A.equals(B);
    }
} 

然后，您的函数将如下所示：

public waitUntil(Test test){
    try{
        wait.until(new Function<WebDriver, Boolean>() {
            public Boolean apply(WebDriver driver) {
                return test.passedTest()
            }
        }
    } catch( Exception ex){
        return false;
    }
    return true;
}

---

如果不使用Java8，则需要使用如下所示的回调接口，然后调用传入匿名调用的泛型方法，该匿名调用实现该接口并在调用方法体中提供验证逻辑。也看看这个答案

---

是的，有点。如果您仅限于Java 7或以下版本，它就不会那么干净，但是您可以使用抽象工厂方法将逻辑提取到它自己的类中，我已经为Selenium做过多次类似的事情：

public abstract class FunctionFactory<T> {

    public abstract boolean execute(T t1, T t2);

    public static final FunctionFactory<T> WAIT_UNTIL_EQUALS = new FunctionFactory<T>() {

        @Override
        public boolean execute(T t1, T t2) {

            try {
                wait.until(new Function<WebDriver, Boolean>() {
                    public Boolean apply(WebDriver driver) {
                        return t1.equals(t2);
                    }
                }
            } catch (Exception ex) {
                return false;
            }
            return true;
        }

    }
}

那么你可以这样称呼它：

waitUntil(WAIT_UNTIL_EQUALS, t1, t2);

public boolean waitUntil(FunctionFactory factory, t1, t2) {
    return factory.execute(t1, t2);
}

waitUntil(WAIT_UNTIL_EQUALS, t1, t2);