业务复杂多变？Groovy魔法让你轻松应对

前言

最近，小年在项目中使用 Groovy 对业务能力进行了一些扩展，感觉比较有意思，而且效果也不错，所以来分享一下使用经验。

先来简单概述一下小年的项目需求背景：有一个支付业务场景需要接入多个运营商的支付能力，每个运营商在支付后都会返回支付结果，但是每个运营商的支付结果报文格式各不相同。

要实现起来并不难，只需要针对每个运营商的报文格式制定不同的解析规则，当然问题并没有这么 easy

运营商的支付结果报文格式可能会变化
后面可能还需要接入新的运营商

也就是说，如果运营商改了报文格式，我们的解析规则需要不断调整，并且有新增的运营商，还需要新增适配的解析规则。

项目使用的是 Java 语言开发，如果每次调整解析规则，意味着需要修改代码，测试，发布，回归等一系列繁琐的步骤。

当然，办法总比困难多🤔

除了上面最直接的笨方法，还有两种可行方案：

1、规则引擎，比如开源 Drools、Easy Rules 等

2、动态脚本，比如 Groovy

规则引擎本身的目的就是为了解决业务的复杂性和多变性，但是小年的系统业务流程本身并不复杂，引入规则引擎就有点过于重，反而增加了系统复杂度，所以这个方案就被 Pass 掉了。

最终选用的是 Groovy 动态脚本的方案。可能有的同学第一次听说 Groovy ，包括小年自己也是。

什么是 Groovy？

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

这里我们只需要记住两个重点：

动态脚本语言，它允许在运行时动态添加、修改和删除类和方法；
与 Java 兼容，语法甚至更加简单；

原理并不复杂，JVM 类加载器动态将 Groovy 代码编译成 Java Class，然后生成 Java 对象在 JVM 上执行。

其实这跟 Nginx + Lua 的组合很相似（静态编译语言 + 动态脚本语言），一套动静组合实现一些需要灵活变动的需求或者规则。

适用场景

营销活动

营销活动这类的场景，可以说是最适合不过。营销活动的套路相信大家也都深有体会，千人千面、大数据杀熟这些套路。

运营同学需要经常性地调整营销策略和规则，不同的场景需要配置不同的规则，所以这时可以利用 Groovy 脚本来快速动态调整规则，快速高效的满足运营产品的需求。

风控规则

风控领域的规则引擎极其适合采用 Groovy 这一技术实现。在对抗黑产的过程中，策略制定人员每天都会产生新的拦截规则。如果每次都要发版，一些被发现的紧急问题或者被薅羊毛的漏洞没办法紧急修复。

因此，通过利用 Groovy 脚本引擎的动态解析执行功能，我们可以将拦截规则抽象成规则脚本，实现快速部署，从而显著提升工作效率。这种方法使得策略人员能够迅速响应风险事件，灵活调整规则，确保对黑产的打击始终保持高效和及时。

快速入门

1、引入依赖

xml 复制代码

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

2、新建一个 Hello.groovy 文件，声明一个 say() 方法

groovy 复制代码

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

3、在 Java 类中用 GroovyClassLoader 加载 Hello.groovy 文件生成 Class ，然后生成实例，最后通过反射调用方法即可。

java 复制代码

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());
    }
}

是不是非常简单？只需要简单的3个步骤，就可以实现Groovy动态脚本能力，并且 Groovy 语法基本与 Java 是兼容的，所以写起来也是很方便。

进阶指南

Groovy 的使用方式

在 Java 中使用 Groovy 有三种方式：

GroovyShell
ScriptEngineManager
GroovyClassLoader

1、GroovyShell

java 复制代码

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);
}

2、ScriptEngineManager

java 复制代码

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

java 复制代码

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());
}

Groovy 官方提供 **GroovyClassLoader **类，支持从文件、URL或字符串中加载解析 Groovy Class，实例化对象，反射调用指定方法。GroovyShell、ScriptEngineManager 底层核心也是调用了 GroovyClassLoader ，并且还会存在性能问题。所以一般场景来说还是比较推荐使用 GroovyClassLoader

最佳实践

当然，使用 Groovy 的动态脚本能力并不难，但如果要真正运用整合到项目中，是需要一定的设计模式和方法技巧，小年总结一下主要有这么两点

1. 脚本加载的方式

脚本变更后，如何实时生效？

既然是动态，我们最希望的当然是：调整和修改脚本的代码后，能够实时生效。也就是说应用能够感知脚本的变更，并且能重新Reload。

GroovyClassLoader 支持字符串、文件、URL的方式加载脚本。实现的方式很多，比如可以字符串的话，可以放在配置中心、数据库；文件的话可以放在资源服务器中再通过接口或者配置触发reload等。小年在项目中的使用方式是通过数据库的形式，把脚本代码都放在一个表的字段里，每次都从数据库中读取最新。

2. 规则设计

我们需要尽可能把最频繁变动的部分抽取到脚本中，而并不是把所有代码都丢到脚本来实现。简单来说就是要抽象出最小细粒度的动态规则，这部分才是脚本里面的内容。

举个例子，比如说在营销场景下，针对不同用户的属性（年龄、等级）可以获得不同的抽奖次数，我们在项目中定义一个接口：IRewardRule

java 复制代码

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

而获取用户抽奖次数的规则逻辑则是放在 Groovy 脚本中实现 RewardRule.groovy

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 生成对应的类，调用 getRewardCount 方法

java 复制代码

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

具体的Demo可以参考：github.com/Zhang-BigSm...

踩坑指南

内存泄露

GroovyClassLoader 类加载器每次调用 parseClass 方法执行 Groovy 脚本，都会重新编译脚本，调用类加载器进行类加载。我们知道类对象信息是放在 JVM 的 Metaspace 区域中，重复不断地执行 Groovy 脚本意味着会创建大量的类，容易导致 Metaspace 内存溢出，造成内存泄露。

简单了解一下 Groovy 脚本的加载流程， GroovyClassLoader 执行核心方法 parseClass 方法：

java 复制代码

public Class parseClass(String text) throws CompilationFailedException {
    return parseClass(text, "script" + System.currentTimeMillis() +
            Math.abs(text.hashCode()) + ".groovy");
}

public Class parseClass(GroovyCodeSource codeSource, boolean shouldCacheSource) throws CompilationFailedException {
    synchronized (sourceCache) {
        Class answer = sourceCache.get(codeSource.getName());
        if (answer != null) return answer;
        answer = doParseClass(codeSource);
        if (shouldCacheSource) sourceCache.put(codeSource.getName(), answer);
        return answer;
    }
}

可以看到每次调用 parseClass 方法，都会生成一个 Class 对象，而对象名是 script + System.currentTimeMillis()+Math.abs(text.hashCode() 组成，也就是说，即使是相同内容的脚本，都会被认为是新的代码，进行新的编译和加载。而你的业务逻辑不断重复执行就会一直生成新的类，最终导致 Metaspace 溢出。

而且 GroovyClassLoader 还会缓存类的信息，像上面的 sourceCache.put(codeSource.getName(), answer) 之外，还有 classCache 也会缓存类的对象，所以导致 Class 对象不可被回收

java 复制代码

protected void setClassCacheEntry(Class cls) {
    synchronized (classCache) {
        classCache.put(cls.getName(), cls);
    }
}

要解决这个性能问题，我们通常是对加载后的 Groovy 脚本进行缓存，避免重复编译加载，可以通过计算脚本的MD5值来生成键值对进行缓存。

通过应用层自己维护一个cache，从而解决 Metaspace 内存溢出的问题。当然，这里还有一个小细节点，在初始化的时候加上同步锁，可以避免并发的问题。

java 复制代码

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 动态加载的能力，非常适用于业务变化多而快的需求，提高开发效率，更快相应需求的变化，提供系统稳定性。

如果你正好也碰到一些需要频繁变动规则的需求，不妨可以考虑一下 Groovy。