Groovy 与 Java 互操作：无缝调用

Groovy 与 Java 的互操作性是其核心优势之一。由于 Groovy 编译后也是字节码，两者可以在同一个项目中完美混合使用。以下指南将详细介绍如何在不同场景下实现两者的无缝调用。

1. 构建混合项目环境

在开始编码前，必须配置好支持两种语言的构建环境。这里以 Gradle 为例进行说明。

1. 创建 项目根目录，并进入该目录。
2. 新建 build.gradle 文件。
3. 配置 插件依赖，同时应用 java 和 groovy 插件。注意 groovy 插件必须依赖 java 插件。

plugins {
    id 'java'
    id 'groovy'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.apache.groovy:groovy:4.0.15'
}

4. 调整 目录结构。Gradle 的标准混合项目目录结构如下：

5. 执行 命令 gradle build，确保环境配置成功。

2. Groovy 调用 Java 代码

Groovy 可以无缝调用 Java 代码，包括使用 Java 类、实例化对象以及调用方法。Groovy 甚至能简化 Java 中繁琐的语法。

1. 切换 到 src/main/java 目录。
2. 编写 一个标准的 Java POJO 类 DataProcessor.java。

package com.example;

import java.util.List;
import java.util.ArrayList;

public class DataProcessor {
    private String name;

    public DataProcessor(String name) {
        this.name = name;
    }

    public List<String> process(List<String> input) {
        List<String> result = new ArrayList<>();
        for (String item : input) {
            result.add(item.toUpperCase());
        }
        return result;
    }

    public String getName() {
        return name;
    }
}

3. 切换 到 src/main/groovy 目录。
4. 编写 Groovy 脚本 Runner.groovy，调用刚才编写的 Java 类。

package com.example

// 1. 直接导入并实例化 Java 类
def processor = new DataProcessor("GroovyClient")

// 2. 使用 Groovy 的列表语法（底层自动转为 Java ArrayList）
def rawData = ["apple", "banana", "cherry"]

// 3. 调用 Java 方法
println "Processor Name: ${processor.name}"
def result = processor.process(rawData)

// 4. 遍历结果
result.each { item ->
    println "Processed: $item"
}

5. 运行 Runner.groovy。你会发现 Groovy 自动处理了 getter 方法（直接访问 .name 而不是 .getName()），并且列表初始化更加简洁。

3. Java 调用 Groovy 代码

在 Java 中调用 Groovy 代码，需要确保 Groovy 类已经被编译，或者通过 GroovyShell 动态执行。这里介绍最常用的静态编译调用方式。

1. 切换 到 src/main/groovy 目录。
2. 编写 Groovy 工具类 StringHelper.groovy。

package com.example

class StringHelper {

    // Groovy 特有的语法：默认参数
    static String greet(String name, String prefix = "Hello") {
        return "$prefix, $name!"
    }

    // Groovy 特有的语法：闭包作为参数
    static List<Integer> transform(List<Integer> numbers, Closure closure) {
        return numbers.collect(closure)
    }
}

3. 切换 到 src/main/java 目录。
4. 编写 Java 主类 Main.java 来调用上述 Groovy 类。

package com.example;

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // 1. 调用 Groovy 的静态方法（支持默认参数）
        String msg1 = StringHelper.greet("Alice");
        System.out.println(msg1); // 输出: Hello, Alice!

        String msg2 = StringHelper.greet("Bob", "Hi");
        System.out.println(msg2); // 输出: Hi, Bob!

        // 2. 处理 Groovy 闭包参数
        // 在 Java 端，Groovy 的 Closure 对应 groovy.lang.Closure 类型
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4);

        // 注意：这里演示直接调用 Groovy 集合方法 collect
        // 如果需要在 Java 传闭包，稍微复杂，通常建议 Groovy 封装好逻辑供 Java 调用
        // 这里展示一个简单的 Java 兼容性调用
        System.out.println("Numbers processed by Groovy logic: " + numbers);
    }
}

5. 编译 并 运行 Main.java。由于 Gradle 会先编译 Groovy 源码，Java 类可以直接引用生成的 .class 文件。

4. 闭包与 SAM 类型的互操作

Groovy 的闭包在 Java 中经常被用作 SAM（Single Abstract Method，单抽象方法）类型的实现，这在处理监听器或回调时非常有用。

1. 打开 src/main/java 接口文件 EventListener.java。

package com.example;

public interface EventListener {
    void onEvent(String eventData);
}

2. 打开 src/main/groovy 脚本 CallbackTest.groovy。

package com.example

// 定义一个模拟触发事件的 Java 类（假设在 Java 中已定义）
class EventSource {
    EventListener listener

    void fire(String data) {
        listener?.onEvent(data)
    }
}

def source = new EventSource()

// 直接将 Groovy 闭包赋值给 Java 接口类型
source.listener = { eventData -> 
    println "Groovy received: $eventData"
}

source.fire("System Start")

3. 观察 代码。Groovy 编译器会自动将闭包 { ... } 强制转换为 EventListener 接口的实现实例，无需手动编写 implements EventListener 的匿名内部类。

5. 常见问题与注意事项

在互操作过程中，需要处理类型转换和编译检查的问题。

1. 避免 在 Java 代码中直接访问 Groovy 的动态特性。例如，不要试图在 Java 中使用 obj.property 如果 obj 是一个纯 Groovy 动态类且该属性未显式声明。
2. 使用 @CompileStatic 注解。为了提高互操作时的性能和类型安全，建议在 Groovy 类被 Java 广泛调用时加上该注解。

import groovy.transform.CompileStatic

@CompileStatic
class SharedService {
    String doWork(String input) {
        return input.reverse()
    }
}

3. 理解 返回类型的差异。Groovy 的 == 运算符等同于 Java 的 equals()，而 Groovy 的 is() 等同于 Java 的 ==。在混合比较对象时，务必确认比较逻辑的一致性。

为了更直观地展示调用流向，请参考以下交互流程：