利用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 一个返回布尔值的闭包，当条件满足时返回 true。
 */
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)
    }
    // 可选：如果需要知道是否成功，可以返回 test() 的最终结果
    // return test()
}

// 假设 getResult() 方法存在
def getResult() {
    // 模拟异步操作，可能返回不同的值
    def values = ["X", "Y", "A", "B", "Z"]
    values[new Random().nextInt(values.size())]
}

// 替换 method2 的逻辑
println "Waiting for result A, B, or C..."
waitUntil {
    getResult() in ["A", "B", "C"]
}
println "Condition met or max retries reached."

// 替换 method1 的逻辑，假设 getConnectionStatus() 方法存在
def getConnectionStatus() {
    // 模拟网络请求
    def statuses = [404, 500, 200, 403]
    statuses[new Random().nextInt(statuses.size())]
}

println "Waiting for connection status 200 with longer sleep..."
waitUntil(100) { // 每次重试休眠100毫秒
    getConnectionStatus() == 200
}
println "Condition met or max retries reached."

println "Waiting with custom sleep and retries..."
waitUntil(200, 5) { // 每次休眠200毫秒，最多重试5次
    // 某个耗时操作或外部条件
    new Random().nextBoolean() // 模拟随机成功
}
println "Condition met or max retries reached."

/**
 * 持续等待直到某个条件满足，并支持传入额外参数到闭包。
 *
 * @param closureArgs 传递给闭包的额外参数。
 * @param sleep 每次重试之间的休眠时间（毫秒）。
 * @param maxRetries 最大重试次数。
 * @param test 一个返回布尔值的闭包，当条件满足时返回 true。
 */
def waitUntil(Object closureArgs, int sleep = 1, int maxRetries = 10, Closure<Boolean> test) {
    int retries = 0
    while (retries++ < maxRetries && !test(closureArgs)) { // 将 closureArgs 传递给闭包
        println "Failed at attempt $retries/$maxRetries, sleeping for $sleep ms before retrying"
        Thread.sleep(sleep)
    }
}

// 替换 method2 的优化版本
println "Waiting for result A, B, or C (optimized)..."
def expectedResults = ["A", "B", "C"] // 列表只创建一次
waitUntil(expectedResults) { it -> // 闭包接收一个参数 'it'，即 expectedResults
    getResult() in it
}
println "Condition met or max retries reached."