Groovy： 让 Java 程序告别繁文缛节

关键词：JVM、脚本语言、Gradle、DSL、Jenkins、动态语言、Spock、构建工具

一、前言：Java 程序员的“啰嗦病”

如果你写 Java 多年，你可能对这些场景再熟悉不过：

List<String> list = new ArrayList<>();
for (String s : list) {
    System.out.println(s);
}

或者每次定义一个 Bean，都得写 getter/setter、toString、equals/hashCode... 那种"强类型 + 冗长 + 模板化"的痛感，几乎是老 Java 程序员的共同记忆。

Groovy 就是在这种背景下诞生的 —— 它保留了 Java 的生态与严谨，又引入了脚本语言的轻快与灵活。

一句话总结：

Groovy = Java 的语法糖 + Python 的灵活性 + Ruby 的优雅。

二、Groovy 是什么？

Groovy 是一门基于 JVM 的动态语言，它可以：

• 像脚本语言一样直接运行（无需编译）
• 像 Java 一样被编译成字节码运行在 JVM 上
• 无缝调用 Java 类库
• 在 Gradle、Jenkins、Grails 等生态中广泛使用

官方定义很直接：

“Groovy is a powerful, optionally typed and dynamic language, with static-typing and static compilation capabilities.”

换句话说：

• 它支持动态类型，也能加上 @CompileStatic 变成静态类型；
• 它既能写脚本，也能构建大型应用。

三、语法入门：Java 程序员的 5 分钟迁移指南

下面是几个常见语法对比，帮你在 5 分钟内“秒懂” Groovy。

✅ 1. 变量声明与输出

Java

String name = "Walter";
System.out.println("Hello, " + name);

Groovy

def name = "Walter"
println "Hello, ${name}"

👉 省掉类型声明、分号、System.out，还多了字符串插值。

✅ 2. 集合与闭包（Closure）

Java

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squared = numbers.stream()
    .filter(n -> n % 2 == 0)
    .map(n -> n * n)
    .collect(Collectors.toList());

Groovy

def numbers = [1, 2, 3, 4, 5]
def squared = numbers.findAll { it % 2 == 0 }
                     .collect { it * it }
println squared  // [4, 16]

👉 闭包（Closure） { it -> ... } 是 Groovy 的灵魂。 it 是隐含参数，可省略使代码更简洁。

✅ 3. Map 与 Range

def person = [name: "Alice", age: 30]
println "${person.name} is ${person.age} years old."

def range = 1..5
println range.collect { it * 2 }  // [2, 4, 6, 8, 10]

👉 Groovy 的 Map 和 Range 都是语言内建结构，不用导包。

✅ 4. 类与方法

class Person {
    String name
    int age

    def greet() {
        println "Hi, I'm $name, and I'm $age years old."
    }
}

def p = new Person(name: "Bob", age: 42)
p.greet()

👉 不用显式 getter/setter，Groovy 自动生成。 构造器支持“命名参数”语法，直接按字段名传参。

✅ 5. 动态调用

Groovy 可以在运行时动态增加方法、属性，非常灵活：

class DynamicDemo {}
def d = new DynamicDemo()
d.metaClass.sayHello = { println "Hello from meta!" }
d.sayHello()

👉 这是 Java 做不到的动态特性。

四、Groovy 的实战舞台

Groovy 虽然不像 Kotlin 那样“官方宠儿”， 但在几个领域里，它是事实标准语言：

示例：Gradle 构建脚本（Groovy DSL）

build.gradle：

plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.apache.commons:commons-lang3:3.14.0'
}

task greet {
    doLast {
        println "Hello from Groovy-powered Gradle!"
    }
}

运行：

gradle greet

输出：

Hello from Groovy-powered Gradle!

👉 这段脚本本质上就是 Groovy 代码，Gradle 只是调用了 Groovy 解释器执行它。

五、如何运行 Groovy

Groovy 支持脚本、交互、编译三种方式运行：

1️⃣ 直接运行脚本

groovy hello.groovy

2️⃣ 交互式 REPL

groovysh

3️⃣ 编译成字节码

groovyc MyClass.groovy
groovy MyClass

4️⃣ 脚本模式（Unix）

#!/usr/bin/env groovy
println "Hello Groovy!"

加执行权限后可直接运行。

六、Groovy 的优缺点

七、Groovy 的应用与发展

📊 应用现状：低调但不可或缺

虽然 Groovy 不像 Kotlin 那样受到官方的力推，但它在多个关键领域占据了不可替代的位置：

1. 构建工具领域：Gradle 的核心

Gradle 作为 Android 官方构建工具和许多大型项目的首选，其 DSL 就是基于 Groovy。尽管 Gradle 现在也支持 Kotlin DSL，但 Groovy DSL 仍然是主流，因为它：

• 更简洁直观（特别是在配置依赖时）
• 社区资源更丰富
• 学习曲线更平缓

许多企业级项目（如 Spring Framework、Hibernate）都使用 Groovy DSL 编写构建脚本。

2. 持续集成：Jenkins Pipeline

Jenkins 的声明式 Pipeline 和脚本式 Pipeline 都使用 Groovy：

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }
        stage('Test') {
            steps {
                sh 'mvn test'
            }
        }
    }
}

这种应用让 Groovy 成为 DevOps 工程师必须掌握的语言之一。

3. 测试框架：Spock

Spock 框架使用 Groovy 的特性，让测试代码更加优雅：

def "should add two numbers"() {
    given:
    def calculator = new Calculator()

    when:
    def result = calculator.add(2, 3)

    then:
    result == 5
}

相比 JUnit，Spock 的 BDD 风格更接近自然语言，可读性更强。

4. Web 开发：Grails 框架

Grails 是一个全栈 Web 框架，基于 Groovy 构建。它提供了类似 Rails 的约定优于配置（Convention over Configuration）理念，让 Web 开发更加高效。虽然近年来 Grails 社区活跃度有所下降，但它仍然是一个成熟的企业级 Web 开发框架。

5. 数据科学与脚本工具

Groovy 在数据处理、文件操作、API 调用等脚本场景中表现出色：

def json = new JsonSlurper().parseText(new URL('https://api.example.com/data').text)
json.items.each { item ->
    println "${item.name}: ${item.value}"
}

发展趋势：稳中求进

当前状态

• 成熟稳定：Groovy 3.x 系列持续更新，与最新 Java 版本保持同步
• 生态丰富：虽然新项目增长放缓，但现有生态依然活跃
• 企业采用：在金融、电信、制造等行业的中大型项目中广泛使用

未来方向

1. 性能优化
2. 通过 @CompileStatic 注解实现静态编译，性能接近 Java

3. 支持 GraalVM 原生镜像编译，提升启动速度

4. 与现代 Java 特性的融合

5. 支持 Java 17+ 的新特性（如 sealed classes、records）

6. 与 Project Loom（虚拟线程）的集成

7. DSL 领域的深耕

8. 继续在 Gradle、Jenkins 等工具中发挥作用

9. 探索新的 DSL 应用场景（如配置管理、规则引擎）

10. 与 Kotlin 的差异化定位

11. Kotlin：更现代、类型安全、移动端优先
12. Groovy：更灵活、脚本友好、DSL 专长

💡 适用场景建议

适合使用 Groovy 的场景：

✅ 编写构建脚本（Gradle）
✅ 编写 CI/CD 流水线（Jenkins）
✅ 编写测试用例（Spock）
✅ 快速原型开发
✅ 数据处理脚本
✅ 内部工具开发

不太适合的场景：

❌ 大型企业级应用的核心业务逻辑（建议用 Java/Kotlin）
❌ 需要极致性能的实时系统
❌ 移动端开发（Groovy 无法直接用于 Android/iOS）

八、总结：让 JVM 重获乐趣

Groovy 不是为了取代 Java，也不是要与 Kotlin 竞争。 它的使命，是让 JVM 世界重新变得有趣，让脚本编写变得优雅。

当你想写点小脚本时；
当你在 Jenkins 写流水线时；
当你在 Gradle 配置构建时；
当你厌倦 Java 的样板代码时；
Groovy 可能就是那个让你"重新喜欢写代码"的语言。

在 Kotlin 大行其道的今天，Groovy 依然在构建工具、CI/CD、测试框架等领域占据重要地位。它证明了：一门语言的价值不在于是否"热门"，而在于是否"有用"。

一句话总结：

Groovy 让 Java 世界有了脚本的灵魂， 而不失类型系统的理性。 在 DSL 和脚本领域，它依然是最优雅的选择之一。