利用Groovy动态脚本解析多格式支付结果，应对复杂业务变化

最近在项目中用 Groovy 对业务能力进行了扩展，效果出乎意料地好，于是想分享一些实战经验。

项目背景是一个支付场景，需要接入多家运营商的支付能力。每家运营商在支付后都会回调返回结果，但麻烦的是，它们的报文格式各不相同。

最初的解决方案很直接：为每家运营商写一套对应的解析规则。但这并没有看上去那么轻松，很快我们就遇到了新的问题：

• 运营商的支付结果报文格式可能会变化。
• 未来还可能接入新的运营商。

这意味着，一旦运营商调整报文，我们的解析规则就得跟着改；每接入一家新运营商，就得新增一套适配代码。项目是用 Java 开发的，每次修改都意味着要走一遍改代码、测试、发布、回归的繁琐流程，效率极低。

当然，办法总比困难多。除了上面这种“硬编码”的笨办法，我们评估了两种更灵活的方案：

1. 规则引擎，例如开源的 Drools、Easy Rules 等。
2. 动态脚本，比如 Groovy。

规则引擎本就是为处理业务复杂性和多变性而生，但我们的系统业务流程本身并不算复杂。引入一个完整的规则引擎框架，显得有些“杀鸡用牛刀”，反而会增加系统复杂度和维护成本，因此这个方案被 Pass 掉了。

最终，我们选用了 Groovy 动态脚本 的方案。如果你也是第一次听说 Groovy，别担心，它其实并不神秘。

什么是 Groovy？

Groovy 是一种基于 Java 平台的动态编程语言。它结合了静态类型语言和动态类型语言的特性，是一种面向对象的脚本语言，设计目标是提供更简洁、更具表达力的语法，以及更易于使用的 API。

你只需要记住两个核心点：

• 动态脚本语言：允许在运行时动态添加、修改和删除类与方法。
• 与 Java 高度兼容：其语法与 Java 非常相似，甚至更简洁。

它的原理并不复杂：JVM 的类加载器会动态地将 Groovy 代码编译成 Java 字节码（Class 文件），然后生成对象在 JVM 上执行。这有点像 Nginx + Lua 的组合（静态编译语言+动态脚本语言），通过“动静结合”来实现需要灵活变动的业务规则。

对于需要在 Java 体系中实现动态逻辑的场景，Groovy 是一个非常顺滑的选择。

Groovy 的适用场景

营销活动

营销场景可以说是 Groovy 的“主战场”。千人千面、优惠券组合、积分兑换规则……运营策略几乎天天在变。如果每次调整策略都要发版，根本跟不上节奏。利用 Groovy 脚本，可以将这些频繁变化的营销规则抽象出来，实现快速配置和动态生效，高效响应产品和运营的需求。

风控规则

风控领域也极其适合采用 Groovy。在与黑产对抗的过程中，策略人员每天都会产生新的拦截规则。如果每次都要等待发版才能上线，很多紧急漏洞或正在发生的“薅羊毛”攻击就无法及时止损。
通过 Groovy 脚本引擎，可以将拦截规则写成脚本，实现快速部署和热更新，大大提升风险应对的时效性。

快速入门

只需三步，就能在 Java 项目中集成 Groovy 的动态能力。

1、引入依赖
在 Maven 项目的 pom.xml 中添加：

<dependency>
    <groupId>org.codehaus.groovy</groupId>
    <artifactId>groovy-all</artifactId>
    <version>3.0.17</version>
    <type>pom</type>
</dependency>

2、编写 Groovy 脚本
新建一个 Hello.groovy 文件，声明一个简单的方法：

class Hello {
    String say(String name) {
        return name + " World!"
    }
}

3、在 Java 中加载并调用
使用 GroovyClassLoader 加载脚本文件，生成实例并通过反射调用方法：

public class QuickStart {
    public static void main(String[] args) throws Exception {
        // 文件路径
        String filePath = "src/main/java/com/zhang/awesome/groovy/Hello.groovy";
        File groovyFile = new File(filePath);
        GroovyClassLoader groovyClassLoader = new GroovyClassLoader();
        // 加载class
        Class groovyClass = groovyClassLoader.parseClass(groovyFile);
        // 生成实例
        GroovyObject groovyObject = (GroovyObject) groovyClass.newInstance();
        // 反射调用say方法
        Object result = groovyObject.invokeMethod("say", "Hello");
        System.out.println("return: " + result.toString()); // 输出：return: Hello World!
    }
}

是不是非常简单？Groovy 语法基本与 Java 兼容，学习和使用成本很低。

进阶指南

Groovy 的三种使用方式

在 Java 中调用 Groovy，主要有三种途径：GroovyShell、ScriptEngineManager 和 GroovyClassLoader。

1、GroovyShell
适合执行简单的脚本片段或表达式。

public static void main(String[] args) {
    final String script = "Runtime.getRuntime().availableProcessors()";
    Binding intBinding = new Binding();
    GroovyShell shell = new GroovyShell(intBinding);
    final Object eval = shell.evaluate(script);
    System.out.println(eval); // 输出CPU核心数
}

2、ScriptEngineManager
这是 JSR-223 规范的标准 API，支持多种脚本引擎，通用性更强。

public static void main(String[] args) throws ScriptException, NoSuchMethodException {
    ScriptEngineManager factory = new ScriptEngineManager();
    // 每次生成一个engine实例
    ScriptEngine engine = factory.getEngineByName("groovy");
    Bindings binding = engine.createBindings();
    // 入参
    binding.put("date", new Date());
    // 如果script文本来自文件,请首先获取文件内容
    engine.eval("def getTime(){return date.getTime();}", binding);
    engine.eval("def sayHello(name,age){return 'Hello,I am ' + name + ',age' + age;}");
    // 反射到方法
    Long time = (Long) ((Invocable) engine).invokeFunction("getTime", null);
    System.out.println(time);
    String message = (String) ((Invocable) engine).invokeFunction("sayHello", "zhangsan", 12);
    System.out.println(message);
}

3、GroovyClassLoader
这是最常用、最灵活的方式，支持从字符串、文件或URL加载完整的 Groovy 类。

public static void groovyClassLoader() throws InstantiationException, IllegalAccessException {
    GroovyClassLoader groovyClassLoader = new GroovyClassLoader();
    // 可以是纯Java代码字符串
    String helloScript = "package com.vivo.groovy.util" +
            "class Hello {" +
            "String say(String name) {" +
            "System.out.println(\"hello, \" + name)" +
            " return name;" +
    "}" +
            "}";
    Class helloClass = groovyClassLoader.parseClass(helloScript);
    GroovyObject object = (GroovyObject) helloClass.newInstance();
    // 控制台输出"hello, vivo"
    Object ret = object.invokeMethod("say", "vivo");
    // 打印vivo
    System.out.println(ret.toString());
}

GroovyShell 和 ScriptEngineManager 的底层其实也调用了 GroovyClassLoader，并且可能存在一些性能开销。因此，在大多数需要加载完整类定义的场景下，更推荐直接使用 GroovyClassLoader。

最佳实践

将 Groovy 的动态脚本能力整合到生产项目中，需要一些设计上的考量，主要围绕以下两点：

1. 脚本加载与更新机制
如何让脚本变更后实时生效？这是实现“动态”的关键。
GroovyClassLoader 支持从字符串、文件或 URL 加载。实现热更新的方式有很多：可以将脚本内容存放在配置中心（如 Apollo、Nacos）或数据库中，通过监听配置变更或接口调用来触发重新加载。在我们的项目中，就采用了数据库存储的方式，每次执行时都从数据库读取最新的脚本内容。

2. 合理的规则设计
我们不应该把所有的业务逻辑都塞进脚本，而应该抽象出最易变、最小粒度的规则放到脚本中。系统架构上需要做好静态框架与动态脚本的分离。

举个例子，在营销场景中，根据用户属性（年龄、等级）决定抽奖次数。我们可以在 Java 侧定义一个稳定的接口：

public interface IRewardRule {
    Integer getRewardCount(User user);
}

而具体的规则逻辑，则放在 Groovy 脚本 RewardRule.groovy 中实现：

class RewardRule implements IRewardRule {
    @Override
    Integer getRewardCount(User user) {
        if (user.getAge() <= 10) {
            return 5
        }else if (user.getAge() <= 20 && user.getAge() > 10) {
            return 3
        }else {
            return 1
        }
    }
}

业务调用时，用 GroovyClassLoader 加载脚本并转换为接口实例调用：

GroovyClassLoader classLoader = new GroovyClassLoader();
Class<?> groovyClazz = classLoader.parseClass(script);
Object instance = groovyClazz.newInstance();
classLoader.clearCache();
IRewardRule rewardRule = clazz.cast(instance);
Integer count = rewardRule.getRewardCount(user);

这种方式清晰地将稳定的契约（接口）与易变的实现（脚本）分离开，是系统设计中应对变化的一种有效模式。完整的 Demo 可以参考这个仓库：https://github.com/Zhang-BigSmart/awesome-groovy

避坑指南：内存泄露问题

这是一个至关重要的性能陷阱。GroovyClassLoader 每次调用 parseClass 方法，都会编译脚本并创建一个新的 Class 对象。即使脚本内容完全相同，由于生成的类名包含时间戳和哈希值（如 script1234567890.groovy），也会被当作全新的类进行加载。

这些类信息存储在 JVM 的 Metaspace 区域。如果业务逻辑高频执行且未加缓存，就会不断创建新类，导致 Metaspace 内存溢出（OOM）。此外，GroovyClassLoader 内部有 classCache 和 sourceCache 会缓存类信息，可能阻止 Class 被垃圾回收。

解决方案是应用层缓存：我们可以计算脚本内容的 MD5 值作为缓存键，避免相同脚本被重复编译加载。同时，在初始化缓存对象时加上同步锁，避免并发问题。

private final static Map<String, Object> SCRIPT_CACHE = new ConcurrentHashMap<>();

public synchronized <T> T initialize(String cacheKey, String script, Class<T> clazz) {
    if (SCRIPT_CACHE.containsKey(cacheKey)) {
        return clazz.cast(SCRIPT_CACHE.get(cacheKey));
    }
    GroovyClassLoader classLoader = new GroovyClassLoader();
    try {
        Class<?> groovyClazz = classLoader.parseClass(script);
        if (clazz != null) {
            Object instance = groovyClazz.newInstance();
            // 清除GroovyClassLoader的缓存
            classLoader.clearCache();
            // 存入应用缓存
            SCRIPT_CACHE.put(cacheKey, instance);
            return clazz.cast(instance);
        }
    } catch (Exception e) {
        log.error("initialize exception", e);
    }
    return null;
}

小结

对于 Java 开发者而言，Groovy 是一门极易上手的语言。它提供的动态加载能力，非常契合业务规则多变、需求迭代快速的场景，能显著提升开发效率、加快需求响应速度，并在一定程度上增强系统的稳定性。

如果你的项目中也遇到了需要频繁调整业务规则或逻辑的挑战，不妨考虑一下 Groovy 这个轻量而强大的工具。更多技术实践和深度讨论，欢迎访问云栈社区进行交流。

参考

• https://blog.itpub.net/69912579/viewspace-2784869/
• https://juejin.cn/post/6844903682639659015?utm_source=gold_browser_extension