Groovy中利用闭包优雅合并相似轮询方法

def someCondition = false

def method1() {
    while(!someCondition) {
        def connectionStatus = getConnectionStatus() // return 200, 404, etc.
        if (connectionStatus == 200) {
            someCondition = true
        } else {
            println "repeat until connection is 200"
            sleep 15
        }
    }
}

def method2(){
    while(!someCondition) {
        def result = getResult() // A, B, C, etc. 
        if (result in ["A", "B", "C"]) {
            someCondition = true
        } else {
            println "waiting until result is either A, B, or C"
            sleep 15
            result = getResult() // call again to check if result changed
        }
    }
}

/**
 * 等待直到指定条件满足。
 * @param sleep 每次重试之间的等待时间（毫秒）。
 * @param maxRetries 最大重试次数。
 * @param test 一个闭包，执行条件检查并返回布尔值。
 */
def waitUntil(int sleep = 1, int maxRetries = 10, Closure<Boolean> test) {
    int retries = 0
    while (retries++ < maxRetries && !test()) {
        println "Failed at attempt $retries/$maxRetries, sleeping for $sleep ms before retrying"
        Thread.sleep(sleep)
    }
    // 可以在此处添加逻辑来判断是否成功，例如返回一个布尔值
    // return test() // 返回最终条件是否满足
}

// 假设 getConnectionStatus() 和 getResult() 是已定义的方法

// 对应 method1 的场景
waitUntil {
    getConnectionStatus() == 200
}

// 对应 method2 的场景
waitUntil {
    getResult() in ["A", "B", "C"]
}

// 等待时间更长（100毫秒）
waitUntil(100) {
    getResult() in ["A", "B", "C"]
}

// 等待时间更长（100毫秒），且只重试5次
waitUntil(100, 5) {
    getResult() in ["A", "B", "C"]
}

/**
 * 等待直到指定条件满足，支持传递期望值到闭包。
 * @param expectedResult 期望的结果值，可以是一个列表、单个值或其他任何闭包所需的参数。
 * @param sleep 每次重试之间的等待时间（毫秒）。
 * @param maxRetries 最大重试次数。
 * @param test 一个闭包，执行条件检查并返回布尔值。它接受 expectedResult 作为参数。
 */
def waitUntil(Object expectedResult, int sleep = 1, int maxRetries = 10, Closure<Boolean> test) {
    int retries = 0
    while (retries++ < maxRetries && !test(expectedResult)) { // 将 expectedResult 传递给闭包
        println "Failed at attempt $retries/$maxRetries, sleeping for $sleep ms before retrying"
        Thread.sleep(sleep)
    }
    // return test(expectedResult) // 返回最终条件是否满足
}

// 期望结果列表只创建一次
waitUntil(["A", "B", "C"]) { expected -> // 闭包现在接受一个参数
    getResult() in expected // 使用传入的 expected 参数
}

// 也可以传递单个值
waitUntil(200) { expectedStatus ->
    getConnectionStatus() == expectedStatus
}