本教程探讨了如何在groovy中优雅地合并具有相似结构但条件判断不同的方法，以减少代码重复并提高可维护性。通过引入闭包（closure）作为参数，我们可以将变化的条件逻辑抽象出来，实现一个高度可配置的通用方法，从而避免为每个细微差异创建独立的方法，并进一步优化性能，减少不必要的对象创建。
1. 问题背景：相似方法的代码重复
在软件开发中，我们经常会遇到这样的场景：多个方法执行着几乎相同的逻辑流程，但它们内部的关键判断条件却有所不同。例如，以下两个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()
}
}
}这两个方法都包含一个while循环，用于重复检查某个条件，并在条件不满足时暂停一段时间。它们的核心差异在于if语句中的具体判断逻辑。这种模式会导致大量的代码重复，降低了代码的可读性和维护性。
2. 解决方案：利用闭包抽象条件逻辑
Groovy的闭包（Closure）特性为解决这类问题提供了优雅的方案。我们可以创建一个通用的等待方法，并将变化的条件判断逻辑封装在一个闭包中，作为参数传递给该通用方法。
2.1 基础实现：传入一个返回布尔值的闭包
首先，我们定义一个waitUntil方法，它接受一个返回布尔值的闭包作为参数。这个闭包将负责执行实际的条件检查。
/** * 持续等待直到某个条件满足。 * * @param sleep 每次重试之间的睡眠时间（毫秒），默认为1毫秒。 * @param maxRetries 最大重试次数，默认为10次。 * @param test 一个闭包，执行条件检查并返回true表示成功，false表示失败。 */ def waitUntil(int sleep = 1, int maxRetries = 10, Closuretest) { int retries = 0 while (retries++ < maxRetries && !test()) { // 每次循环执行闭包进行条件判断 println "第 ${retries}/${maxRetries} 次尝试失败，休眠 ${sleep} 毫秒后重试。" Thread.sleep(sleep) } if (retries > maxRetries) { println "达到最大重试次数，条件未满足。" } else { println "条件已满足，总共尝试了 ${retries} 次。" } }
现在，我们可以使用这个waitUntil方法来替代之前的method1和method2：
// 模拟获取连接状态的方法
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
}通过这种方式，我们成功地将两个相似的方法合并成了一个通用方法，并通过闭包参数灵活地定义了不同的等待条件。
2.2 性能优化：避免闭包内重复创建对象
在上述实现中，如果闭包内部需要引用一些常量集合或复杂对象（例如 ["A", "B", "C"]），并且这个闭包会被频繁调用，那么每次调用时都可能重新创建这些对象。对于长时间运行或高速循环的任务，这可能导致不必要的垃圾回收开销。
为了解决这个问题，我们可以将这些常量或共享数据作为参数传递给waitUntil方法，然后由waitUntil方法再将其传递给闭包。
/** * 持续等待直到某个条件满足，并支持传递预期结果。 * * @param expectedResult 预期结果或条件所需的其他数据。 * @param sleep 每次重试之间的睡眠时间（毫秒），默认为1毫秒。 * @param maxRetries 最大重试次数，默认为10次。 * @param test 一个闭包，接受 expectedResult 作为参数，执行条件检查并返回true表示成功，false表示失败。 */ def waitUntil(Object expectedResult, int sleep = 1, int maxRetries = 10, Closuretest) { int retries = 0 while (retries++ < maxRetries && !test(expectedResult)) { // 将 expectedResult 传递给闭包 println "第 ${retries}/${maxRetries} 次尝试失败，休眠 ${sleep} 毫秒后重试。" Thread.sleep(sleep) } if (retries > maxRetries) { println "达到最大重试次数，条件未满足。" } else { println "条件已满足，总共尝试了 ${retries} 次。" } }
现在，在使用时，我们将 ["A", "B", "C"] 这个列表作为 expectedResult 参数传递给 waitUntil，然后在闭包中通过 it（Groovy闭包的隐式参数）来引用它：
// 模拟获取结果的方法
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
}通过这种优化，我们确保了像 ["A", "B", "C"] 这样的对象只在外部创建一次，而不是在每次闭包调用时都重新创建，从而减少了潜在的垃圾回收压力，尤其适用于性能敏感的场景。
3. 注意事项与最佳实践
- 闭包的简洁性： 尽量保持闭包内部逻辑的简洁和单一职责，只包含条件判断相关的代码。
- 错误处理： 如果闭包内部的条件检查可能抛出异常（例如网络请求失败），应在闭包内部进行适当的异常捕获和处理，以避免中断整个等待循环。
- 参数命名： 为sleep和maxRetries等参数选择清晰的名称，提高代码可读性。
- 默认值： 为常用参数设置合理的默认值，使得方法调用更加简洁。
- 日志输出： 在等待方法中加入适当的日志输出（如重试次数、睡眠时间），有助于调试和监控。
- 线程安全： 如果条件判断涉及共享状态，需要考虑线程安全问题。
4. 总结
通过在Groovy中利用闭包作为一等公民的特性，我们可以将重复的等待逻辑与变化的条件判断解耦，从而实现高度可重用和可配置的代码。这种模式不仅减少了代码重复，提高了代码的可维护性，而且通过参数化传递共享数据，还能进一步优化性能，避免不必要的对象创建。掌握这种技巧，将有助于编写更简洁、更健壮的Groovy代码。
