Groovy教程：利用闭包优化并合并相似方法

def someCondition = false

def method1() {
    while(!someCondition) {
        def connectionStatus = getConnectionStatus() // 返回 200, 404 等
        if (connectionStatus == 200) {
            someCondition = true
        } else {
            println "等待连接状态为200"
            sleep 15
        }
    }
}

def method2(){
    while(!someCondition) {
        def result = getResult() // 返回 A, B, C 等
        if (result in ["A", "B", "C"]) {
            someCondition = true
        } else {
            println "等待结果为 A, B 或 C"
            sleep 15
            // 再次调用以检查结果是否改变
            result = getResult() 
        }
    }
}

/**
 * 持续等待直到某个条件满足。
 *
 * @param sleep 每次重试之间的睡眠时间（毫秒），默认为1毫秒。
 * @param maxRetries 最大重试次数，默认为10次。
 * @param test 一个闭包，执行条件检查并返回true表示成功，false表示失败。
 */
def waitUntil(int sleep = 1, int maxRetries = 10, Closure<Boolean> test) {
    int retries = 0
    while (retries++ < maxRetries && !test()) { // 每次循环执行闭包进行条件判断
        println "第 ${retries}/${maxRetries} 次尝试失败，休眠 ${sleep} 毫秒后重试。"
        Thread.sleep(sleep)
    }
    if (retries > maxRetries) {
        println "达到最大重试次数，条件未满足。"
    } else {
        println "条件已满足，总共尝试了 ${retries} 次。"
    }
}

// 模拟获取连接状态的方法
def getConnectionStatus() {
    // 实际应用中会调用外部服务
    def statuses = [404, 500, 200]
    return statuses[new Random().nextInt(statuses.size())] // 随机返回状态码
}

// 模拟获取结果的方法
def getResult() {
    // 实际应用中会调用外部服务
    def results = ["X", "Y", "A", "B"]
    return results[new Random().nextInt(results.size())] // 随机返回结果
}

// 使用示例1：等待连接状态为200
println "--- 正在等待连接状态为200 ---"
waitUntil(100, 5) { // 每次休眠100毫秒，最多重试5次
    def status = getConnectionStatus()
    println "当前连接状态: $status"
    status == 200
}

// 使用示例2：等待结果为 "A", "B", 或 "C"
println "\n--- 正在等待结果为 A, B 或 C ---"
waitUntil(50, 8) { // 每次休眠50毫秒，最多重试8次
    def res = getResult()
    println "当前结果: $res"
    res in ["A", "B", "C"]
}

// 也可以使用默认参数
println "\n--- 使用默认参数等待 ---"
waitUntil {
    // 假设这里是另一个简单的条件
    new Random().nextInt(10) > 7
}

/**
 * 持续等待直到某个条件满足，并支持传递预期结果。
 *
 * @param expectedResult 预期结果或条件所需的其他数据。
 * @param sleep 每次重试之间的睡眠时间（毫秒），默认为1毫秒。
 * @param maxRetries 最大重试次数，默认为10次。
 * @param test 一个闭包，接受 expectedResult 作为参数，执行条件检查并返回true表示成功，false表示失败。
 */
def waitUntil(Object expectedResult, int sleep = 1, int maxRetries = 10, Closure<Boolean> test) {
    int retries = 0
    while (retries++ < maxRetries && !test(expectedResult)) { // 将 expectedResult 传递给闭包
        println "第 ${retries}/${maxRetries} 次尝试失败，休眠 ${sleep} 毫秒后重试。"
        Thread.sleep(sleep)
    }
    if (retries > maxRetries) {
        println "达到最大重试次数，条件未满足。"
    } else {
        println "条件已满足，总共尝试了 ${retries} 次。"
    }
}

// 模拟获取结果的方法
def getResult() {
    def results = ["X", "Y", "A", "B"]
    return results[new Random().nextInt(results.size())]
}

// 使用优化后的方法：等待结果为 "A", "B", 或 "C"
println "\n--- 使用优化方法等待结果为 A, B 或 C ---"
def allowedResults = ["A", "B", "C"] // 列表只创建一次
waitUntil(allowedResults, 50, 8) { it -> // 闭包接收 expectedResult 作为参数
    def res = getResult()
    println "当前结果: $res"
    res in it // 使用传入的列表进行判断
}

// 另一个例子：等待一个数字大于某个阈值
println "\n--- 使用优化方法等待数字大于阈值 ---"
def threshold = 50 // 阈值只创建一次
waitUntil(threshold, 20, 10) { it ->
    def num = new Random().nextInt(100)
    println "当前数字: $num, 阈值: $it"
    num > it
}