前言回顾

在上篇文章中，我们深入了解了Groovy语言的基础知识和核心特性，探讨了它与Java的深度关系，以及其在动态配置管理和业务规则引擎方面的强大便利性。我们看到了Groovy为Java开发者带来的巨大价值：

简洁的语法：大幅减少样板代码，提升开发效率
动态特性：支持运行时修改和扩展，增强系统灵活性
无缝集成：与现有Java项目完美融合，降低迁移成本
强大的表达能力：特别适合构建DSL和配置系统

这些特性使得Groovy成为构建动态代码执行引擎的理想选择，特别是在大模型AI应用蓬勃发展的今天，它为FunctionCall和**工具调用（MCP）**等场景提供了完美的解决方案。

现在，让我们基于这些理论基础，动手实现一个功能完整、安全可靠的Java执行Groovy脚本万能工具类。

四、编写Java执行Groovy脚本的万能工具类

4.1 添加依赖

首先，在项目中添加Groovy依赖：

<!-- Maven -->
<dependency>
    <groupId>org.apache.groovy</groupId>
    <artifactId>groovy</artifactId>
    <version>4.0.15</version>
</dependency>
<dependency>
    <groupId>org.apache.groovy</groupId>
    <artifactId>groovy-jsr223</artifactId>
    <version>4.0.15</version>
</dependency>

// Gradle
implementation 'org.apache.groovy:groovy:4.0.15'
implementation 'org.apache.groovy:groovy-jsr223:4.0.15'

4.2 基础工具类框架

package com.d4w.common.util;

import org.apache.commons.lang3.StringUtils;

import javax.script.*;
import java.util.HashMap;
import java.util.Map;

/**
 * Groovy脚本运行工具类
 * 提供Java环境下执行Groovy脚本的便捷方法
 * 特别适用于大模型FunctionCall和工具调用（MCP）场景
 * 
 * @author xierui
 */
public class GroovyUtils {
    
    private static ScriptEngine engine = null;
    
    static {
        initializeGroovyEngine();
    }
    
    /**
     * 初始化Groovy脚本引擎
     */
    private static void initializeGroovyEngine() {
        ScriptEngineManager manager = new ScriptEngineManager();
        engine = manager.getEngineByName("groovy");
        
        if (engine == null) {
            throw new RuntimeException("Groovy脚本引擎初始化失败，请检查groovy-jsr223依赖");
        }
    }
    
    /**
     * 执行Groovy表达式的核心方法
     * 适用于大模型返回的工具调用场景，可直接执行字符串表达式并传入参数
     * 
     * @param expression Groovy表达式
     * @param params     参数Map
     * @return 执行结果
     */
    public static Object eval(String expression, Map<String, Object> params) {
        if (StringUtils.isBlank(expression)) {
            throw new RuntimeException("Groovy表达式不能为空");
        }
        
        try {
            Bindings bindings = new SimpleBindings();
            if (params != null) {
                bindings.putAll(params);
            }
            return engine.eval(expression, bindings);
        } catch (ScriptException e) {
            throw new RuntimeException(
                String.format("Groovy表达式执行失败，表达式：%s", expression), e);
        }
    }
    
    /**
     * 无参数执行表达式的简化方法
     * 
     * @param expression Groovy表达式
     * @return 执行结果
     */
    public static Object eval(String expression) {
        return eval(expression, new HashMap<>());
    }
}

五、在大模型工具调用场景中的应用

5.1 为什么Groovy特别适合大模型工具调用

随着ChatGPT、Claude等大语言模型的兴起，FunctionCall（函数调用）和MCP（Model Context Protocol）等工具调用机制变得越来越重要。Groovy脚本在这个场景中展现出了独特的优势：

动态执行能力：大模型返回的是字符串类型的工具名称和参数，Groovy可以直接将这些字符串转换为可执行的代码
语法简洁：相比Java，Groovy的语法更接近自然语言，便于大模型理解和生成
类型灵活：支持动态类型，能够处理大模型返回的各种数据类型
Java生态兼容：可以直接调用Java的所有类库和API

5.2 典型应用场景

// 场景1：大模型返回数学计算指令
String aiResponse = "a + b * 2";
Map<String, Object> params = Map.of("a", 10, "b", 5);
Object result = GroovyUtils.eval(aiResponse, params);
// 结果：20

// 场景2：大模型返回条件判断逻辑
String conditionExpression = "age >= 18 && score > 60";
Map<String, Object> userParams = Map.of("age", 20, "score", 85);
Object isValid = GroovyUtils.eval(conditionExpression, userParams);
// 结果：true

// 场景3：大模型返回字符串处理指令
String stringOperation = "name.toUpperCase() + '_' + id";
Map<String, Object> data = Map.of("name", "张三", "id", "001");
Object formatted = GroovyUtils.eval(stringOperation, data);
// 结果：张三_001

// 场景4：大模型返回复杂业务逻辑
String businessRule = \"\"\"
    if (amount > 1000) {
        return amount * 0.9  // 9折优惠
    } else if (amount > 500) {
        return amount * 0.95 // 95折优惠
    } else {
        return amount        // 无优惠
    }
\"\"\";
Map<String, Object> orderParams = Map.of("amount", 800);
Object finalPrice = GroovyUtils.eval(businessRule, orderParams);
// 结果：760.0

5.3 与大模型工具调用的完美结合

在实际的大模型应用中，这种组合能够实现：

零配置工具注册：无需预先定义工具函数，大模型可以直接生成执行逻辑
动态业务规则：业务规则可以由大模型根据上下文动态生成
灵活的数据处理：支持各种数据转换和计算操作
安全可控：运行在JVM沙箱中，相比直接执行系统命令更加安全

这种设计理念使得我们的工具类不仅仅是一个脚本执行器，更是连接人工智能和传统软件系统的重要桥梁。

六、高级特性

6.1 缓存机制

/**
 * 添加表达式缓存以提升性能
 */
private static final Map<String, CompiledScript> SCRIPT_CACHE = 
    new ConcurrentHashMap<>();

public static Object evalWithCache(String expression, Map<String, Object> params) {
    CompiledScript compiledScript = SCRIPT_CACHE.computeIfAbsent(expression, expr -> {
        try {
            if (engine instanceof Compilable) {
                return ((Compilable) engine).compile(expr);
            }
            return null;
        } catch (ScriptException e) {
            throw new RuntimeException("脚本编译失败: " + expr, e);
        }
    });
    
    if (compiledScript != null) {
        try {
            Bindings bindings = new SimpleBindings();
            if (params != null) {
                bindings.putAll(params);
            }
            return compiledScript.eval(bindings);
        } catch (ScriptException e) {
            throw new RuntimeException("脚本执行失败: " + expression, e);
        }
    } else {
        return eval(expression, params);
    }
}

6.2 安全性控制

/**
 * 安全的脚本执行器
 */
public static Object evalSafely(String expression, Map<String, Object> params, 
                               long timeoutMillis) {
    // 检查危险操作
    if (containsDangerousOperations(expression)) {
        throw new SecurityException("表达式包含危险操作: " + expression);
    }
    
    // 限制执行时间
    Future<Object> future = Executors.newSingleThreadExecutor().submit(() -> {
        return eval(expression, params);
    });
    
    try {
        return future.get(timeoutMillis, TimeUnit.MILLISECONDS);
    } catch (TimeoutException e) {
        future.cancel(true);
        throw new RuntimeException("脚本执行超时: " + expression);
    } catch (Exception e) {
        throw new RuntimeException("脚本执行失败: " + expression, e);
    }
}

private static boolean containsDangerousOperations(String expression) {
    String[] dangerousKeywords = {
        "System.exit", "Runtime.getRuntime", "ProcessBuilder",
        "File", "FileWriter", "FileReader", "Class.forName"
    };
    
    for (String keyword : dangerousKeywords) {
        if (expression.contains(keyword)) {
            return true;
        }
    }
    return false;
}

6.3 调试和日志

/**
 * 带调试信息的执行方法
 */
public static Object evalWithDebug(String expression, Map<String, Object> params) {
    long startTime = System.currentTimeMillis();
    
    try {
        System.out.println("开始执行表达式: " + expression);
        System.out.println("参数: " + params);
        
        Object result = eval(expression, params);
        
        long endTime = System.currentTimeMillis();
        System.out.println("执行成功，耗时: " + (endTime - startTime) + "ms");
        System.out.println("结果: " + result);
        
        return result;
    } catch (Exception e) {
        long endTime = System.currentTimeMillis();
        System.err.println("执行失败，耗时: " + (endTime - startTime) + "ms");
        System.err.println("错误: " + e.getMessage());
        throw e;
    }
}

七、最佳实践和注意事项

7.1 性能优化建议

使用脚本缓存：对于重复执行的表达式，使用编译缓存
避免复杂表达式：将复杂逻辑拆分为多个简单表达式
合理使用类型转换：明确指定期望的返回类型

7.2 安全注意事项

输入验证：对表达式内容进行安全检查
权限控制：限制可访问的类和方法
超时控制：设置合理的执行超时时间

7.3 错误处理建议

/**
 * 健壮的错误处理示例
 */
public static class SafeGroovyExecutor {
    
    public static Result<Object> executeSafely(String expression, 
                                              Map<String, Object> params) {
        try {
            // 参数验证
            if (StringUtils.isBlank(expression)) {
                return Result.error("表达式不能为空");
            }
            
            // 执行表达式
            Object result = GroovyUtils.evalWithCache(expression, params);
            return Result.success(result);
            
        } catch (SecurityException e) {
            return Result.error("安全检查失败: " + e.getMessage());
        } catch (RuntimeException e) {
            return Result.error("执行失败: " + e.getMessage());
        } catch (Exception e) {
            return Result.error("未知错误: " + e.getMessage());
        }
    }
    
    public static class Result<T> {
        private final boolean success;
        private final T data;
        private final String error;
        
        private Result(boolean success, T data, String error) {
            this.success = success;
            this.data = data;
            this.error = error;
        }
        
        public static <T> Result<T> success(T data) {
            return new Result<>(true, data, null);
        }
        
        public static <T> Result<T> error(String error) {
            return new Result<>(false, null, error);
        }
        
        // getter方法...
        public boolean isSuccess() { return success; }
        public T getData() { return data; }
        public String getError() { return error; }
    }
}

八、系列总结与展望

至此，我们的《Java执行Groovy脚本万能工具类详解》系列文章就圆满结束了。让我们回顾一下整个系列的核心内容：

系列回顾

上篇我们从理论基础出发，深入探讨了：

Groovy语言的核心特性和技术架构
Groovy与Java的深度集成关系
在动态配置管理和业务规则引擎方面的优势

下篇我们从实践出发，完整构建了：

功能强大的Java执行Groovy脚本工具类
针对大模型工具调用场景的优化设计
缓存、安全性、调试等高级特性
完善的最佳实践指南

工具类核心特点

通过两篇文章的详细介绍，我们最终构建了一个具有以下特点的万能工具类：

易用性：提供了多种便利方法，适合不同场景使用
安全性：包含安全检查和超时控制机制
性能：支持脚本缓存，提升重复执行的性能
健壮性：完善的错误处理和类型转换机制
可扩展性：支持预定义方法，可根据业务需要扩展

应用场景总结

这个工具类特别适用于以下场景：

大模型FunctionCall：动态执行AI返回的工具调用指令
业务规则引擎：灵活配置和修改业务逻辑
表达式计算器：复杂数学和逻辑表达式计算
数据处理管道：灵活的数据过滤、转换和聚合
配置化开发：减少硬编码，提升系统灵活性
插件系统：支持动态加载和执行用户脚本

AI时代的价值

特别值得强调的是，在当前AI技术飞速发展的时代，这个工具类为大模型与传统软件系统的集成提供了一个优雅的解决方案。它让我们能够：

将大模型的智能决策能力与Java生态的丰富资源完美结合
实现真正的"智能化配置"和"AI驱动的业务逻辑"
为未来的AI原生应用开发奠定坚实基础

实践建议

在实际使用中，请务必：

安全第一：在生产环境中严格控制脚本来源和内容
性能优化：合理使用缓存机制，避免重复编译
错误处理：建立完善的异常处理和日志记录机制
持续改进：根据实际业务需求不断完善和扩展工具类

结语

强大的工具需要谨慎使用。希望这个工具类能够帮助您在Java开发中获得更好的动态性和灵活性，同时在AI时代的技术浪潮中保持竞争优势。

愿您的代码更加简洁，系统更加智能，开发更加高效！

大模型FunctionCall的利器：Java执行Groovy脚本万能工具类详解（下篇）

评论区

需要帮助？